python模块,reload所有模块以及坑

#tips: 当需要动态的import模块时, 即模块名是一个字符串变量时无法使用import ,这时可以使用exec(modname)或者

__import__(modname).

模块基础:

1.导入模块        (仅导入一次，生成模块对象)

    import 与 from 都是赋值语句 与 函数中的赋值一样 :

    import :把整个模块对象赋值给一个变量名 ;

                比如 import A : 一个文件名为A.py 的模块被导入,生成了一个模块对象, 被赋值为A

    from module import x,y : x,y 引用了模块中同名变量的对象 

                                           x, y 会在当前导入者的模块中创建变量同时引用module中的对象

                                           若模块没有被加载过, from 语句会将模块首先加载 ,再创建与模块中同名的变量名,进行引用

    from的坑在下面有叙述;

2.

模块会建立模块对象,同时会建立命名空间(独立的作用域), 这一点与类，函数都一样. 都会有自己的code block 即__code__对象,

可以同过__dict__ 来获取模块属性.

模块,类,函数都是对象,都有自己的命名空间 ==>即都有自己的__code__ , 这一点在python code对象已经说过

3.模块包,即指定导入模块的路径

   比如import dir1.dir2.mod , 对应的目录:  sys.path能搜索到的路径 / dir1 / dir2 / mod.py

   同时指定的目录dir1 , dir2 下必须有个__init__.py :

   __init__.py 的作用是把这个目录当成一个模块来使用 , 因为目录并不是实际的模块文件.同时为(目录)产生模块对象,

   即产生了命名空间 -> 产生__code__;

    __init__.py 可以随意写入任何python代码, 也可以是空的

当前工作路径(cwd) \
                    dir1 \
                         __init__.py
                         dir2 \
                             __init__.py
                             mod.py

4.每个模块都有一个__name__属性 ,可以在module.__dict__ (模块对象的词典命名空间)中找到.  

   如果模块被导入则是模块名, 如果作为执行文件则是__main__

获取当前执行文件的模块:

from imp import reload
selfModule = sys.modules['__main__'] #获取自身模块

reload模块:

当reload(X)时，只会重载X模块,X模块导入其他模块并不会重新导入,只会获取其他模块对象;

因此想要reload全部模块的话 ,需要使用到模块对象的__dict__ , type（） 函数:

import types
from imp import reload
import sys
def print_status(module):
    print('reloading ' + module.__name__)

def walk_module(module,map):
    if module not in map:
        map[module] = None
        reload(module)
        print_status(module)
        module_dict = module.__dict__                                       #获取模块词典
        for attr in module_dict:                                           #遍历模块词典
            if type(module_dict[attr]) == types.ModuleType:                #如果词典中有其他模块的话,递归处理s
                print('模块 attr:',attr,'value:',module_dict[attr])
                walk_module(module_dict[attr],map)

def reload_all(*modules):   #需要重载的模块
    visited_map = {}
    for module in modules:
        if type(module) == types.ModuleType:    #如果是一个模块对象的话
            walk_module(module,visited_map)


if __name__  == '__main__':
    import t1
    reload_all(t1)

接下来 , 坑:

记住一点,任何使用 from 导入的变量名 ,只是对原对象的引用 ,只是与其他模块内的名字一样而已!!

from module import X:

这个X 是当前模块的一个全局变量，名字与module中的X 一样,并且都引用了同一个对象.

module.X 修改了并不代表当前模块的X 修改了, 当前模块的X还是引用着旧的对象!!

而通过 import module ; 使用module.x 则实时保持最新的引用

#模块A.py
x = 100
def func():
    print('A.py func()')

#main.py
    #from的坑.
    # x是当前模块的一个全局变量,只是名字跟A.x 变量名相同
    # 当from A import x 后, x 引用了 A.x 的对象 ,因此别把当前模块的x 与 A 模块的x 混淆
    from A import x
    import A
    A.x = 0                         #这里修改值 , 注意x 并未改变 .  x是对A.x 对象的引用
    print('获取from 的X:', x)
    print('获取import A.x:',A.x)  #使用module. 点号运算符总是会通过模块来获取值

    再来个例子:

#main.py
    #再次声明 任何使用 from 导入的变量名 ,只是对原对象的引用 ,只是与其他模块内的名字一样而已
    def changed():
        print('changed')
    from A import x
    import A
    from A import func
    func()                      #A.py func()
    A.func = changed            # 修改了模块A内的func引用
    func()                      #A.py func() 并未修改 , 原因是func 本身还引用旧的对象
    from A import func         #ok , 重新使用from 来导入一次, 让当前模块的func = A.func
    func()                      #changed
    A.func()                    #ok , 通过模块.func() 将保持最新的修改