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