python中from module import * 的一個陷阱

from module import *把module中的成員所有導到了當前的global namespace，訪問起來就比較方便了。固然，python style通常不建議這麼作，由於可能引發name conflict。

但還有另一個問題 - 你覺得你修改了某個變量，其實，被from module import *後的那個並無被更新，很是危險，由於程序有可能還能夠正常運行， 只不過結果錯了，到了production才被發現就比較慘了。

舉個例子：

你定義了一些變量在base模塊中：

# reference data type
class Demo:
        def __init__(self, name):
                self.name = name
demo = Demo('Demo')

# primitive type
foo = 1

 

而後在一個模塊中用from  module import 的方式讀它：

from base import *
def read():
        print 'reference data id: ' + str(id(demo))
        print 'reference data value : ' + demo.name

        print 'primitive data id: ' + str(id(foo))
        print 'primitive data value: ' + str(foo)

在另一個模塊中寫它：

import base

def write():
        print "\nOriginal:"
        print "Original reference data id: " + str(id(base.demo))
        base.demo.name = "Updated Demo" # this will reflect that change
        #base.demo = base.Demo("Updated Demo") # this won't relfect the change
        print "Original data id: " + str(id(base.foo))
        base.foo = 1000
        print "Original data id after assignment: " + str(id(base.foo))

 

而後先寫，後讀，看寫的內容是否有效：

import read
import write

print "before write"
read.read()

write.write()

print "\nafter write"
read.read()

 

結論是沒有，緣由是：

• 當你用from module import時，實際上是copy了一份reference或者pointer，指向一分內存，var和module.var都指向同一分內存
• 當你修改module.var時，其實你是讓它指向了另一分內存，此時var和module.var指向的是不一樣的內存
• 因此，雖然module.var的值變了，var仍是指向原來那分內存，原來的值

這個對於object，比較容易理解，你能夠直接修改object裏的值，這個是有效的，可是當你指向另一個object時就無效了。 對於primitive類型來說，其實也是一個道理，由於每次賦值，都是讓其指向一個不一樣的內存地址，而不是inplace修改已有的那分內存 -  這個很容易驗證：

In [1]: a = 10

In [2]: id(a)
Out[2]: 20429204

In [3]: a = 100

In [4]: id(a)
Out[4]: 20430108

 

因此，建議是除非是一個quick and dirty的腳本，不然不要使用from module import *！

 

例子：https://github.com/baiyanhuang/blog/tree/master/arena/python/from_module_import