摘要:导入模块、导入包、编程规范
以My_module为例,My_module的代码如下:
__all__ = ['name','read']
print('in mymodule')
name = '帅锅'
def read():
print('in read',name)
def read2():
print('in read2',name)
if __name__ == '__main__':
print('in mymodule')
print('__name__ : ',__name__)
一、导入模块
1、import 模块名
1-1、在import的过程中发生了哪些事情:
import一个模块相当于先执行了一次这个被导入模块,然后在本命名空间建立一个与被导入模块命名空间的联系,
相当于在本命名空间新建了一个变量,这个变量名称是被导入模块的名称,指向被导入模块的命名空间。
1-2、一个模块不会被重复导入,也就是说,import了一次这个模块,然后再import一次,也只是执行了第一次的imoptr
import My_module # 执行了
import My_module # 不会执行
1-3、如何去使用被导入模块中的名字
import My_module
print(My_module.name) # 打印出My_module中的name
My_module.My_module_fun() # 执行了My_module中的函数
1-4、小结导入模块的过程
导入模块的时候:
1.寻找模块
2.如果找到了,就开辟一块空间,执行这个模块
3.把这个模块中用到的名字都收录到新开辟的空间中
4.创建一个变量来引用这个模块的空间(变量名与这个模块名一致)
*1.模块不会被重复导入
*2.模块和文件之间的内存空间始终是隔离的
*3.模块的名字必须是符合变量命名规范的
1-5、本文件中存在与导入模块相同的变量
# My_module中的内容:
name = '帅锅'
def read():
print('in read',name)
# 执行文件的内容:
import My_module
My_module.read() # in read 帅锅
name = 'SB'
My_module.read() # in read 帅锅
My_module.name = 'SB'
My_module.read() # in read SB
总结:
在本文件中定义了一个与导入模块相同的变量,
并不会影响导入模块中的变量,因为这两个变量是存在不同的命名空间中的,互不影响。
1-6、本文件中存在一个变量,这个变量名是导入的模块名
这个时候就相当于把指向导入模块的指针断开了,再指向新的值
My_module = 1
print(My_module) # 1
My_module.read() #报错
1-7、一次导入多个模块的方式
import os,time,My_module
但是一般不建议这么使用,因为根据pep8规范(python编写规范):
我们导入模块的顺序应该是:内置模块,第三方模块,自定义模块
import os # 内置
import time # 内置
import django # 第三方
import my_module # 自定义
1-8、给模块起别名,一旦给模块起了别名,那么原名就不能使用了
import My_module as m
print(m.name) # 帅锅
print(My_module.name) # 报错
1-9、如何判断模块能否被导入
sys.path是一个存放了所有模块路径的列表,
一个模块是否能被导入,就看这个模块所在的目录在不在sys.path中,
如果这个模块的路径不在sys.path中,那么就不可被导入,
不过可以自己手动添加:sys.path.append(“自定义的模块路径”)
1-10、循环引用模块(看图)
1-11、运行一个py文件的两种方式方式
1,直接运行它 :
在cmd终端运行: python xx.py 或者在pycharm中直接运行
当用这种方式运行这个py文件,那么这个py文件就称为:脚本
这个时候py文件中的:__name__ == '__main__'
2,导入它 :
导入一个模块,也会运行一次这个py文件
当用这种方式运行py文件,这个py文件就称为:模块
这个时候py文件中的:__name__ == '模块名'
import My_module
__name__ = 'my_module '
例如:
在My_module中有这样的代码:
print('in mymodule')
print('__name__ : ',__name__)
那么直接在My_module中运行结果为:in mymodule __name__ : __main__
在导入My_module的文件中执行导入模块(会默认执行一次My_module)
import My_module
然后执行,结果为:in mymodule __name__ : My_module
2、from xx import xx
2-1在from import的过程中发生了哪些事情
from My_module import name
from My_module import read
1,要找到My_module
2,开空间,执行my_module
3,所有的My_module中的名字都存储在My_module所属的空间中
4,本文件空间中建立对应的变量名(name,read),分别取引用My_module空间中对应的名字
from My_module import name
from My_module import read
print(name) # 帅锅
read() # in read 帅锅
2-2、引用模块的变量后,进行修改(看图)
from My_module import name
from My_module import read
print(name) # 帅锅
name = 'aaa'
read() # in read 帅锅
print(name) # aaa
2-3、from import 多个内容
from My_module import name,read,read2
2-4、给导入的内容起别名
from My_module import name as n,read as r,read2 as r2
2-5、from import *和 __all__关系
1,只有from import * 没有__all__的时候,My_module的所有变量都可以在本文件中使用
from My_module import *
print(name) # 帅锅
read() # in read 帅锅
read2() # in read2 帅锅
2,即有from import * 也有__all__的时候,只有被__all__声明的变量才能在本文件中使用
My_module中:__all__ = ['name','read']
本文件中执行:
from My_module import *
print(name) # 帅锅
read() # in read 帅锅
read2() # 报错:name 'read2' is not defined
但是如果直接导入还是可以用的:from My_module import read2 # 可以使用read2,即使__all__没有定义
因此 __all__ 只与 import * 强关联
2-6、模块的导入和修改
模块在导入后,在程序运行期间,你再去修改导入的模块,导入的内容依旧是不变的。
如果硬是要在程序运行期间修改模块的内容,并让修改的内容生效,那么可以使用reload.
from importlib import reload # python2中的reload是内置函数,python3中reload函数放到了importlib中
'''
在这期间修改模块的内容
'''
# 重新reload,修改的内容就生效了
reload(My_module)
3、补充的内容
1.pyc文件、pyi文件 *
pyc文件是导入包的时候自动产生的字节码文件,只能提高程序的启动效率并不能提高程序的执行效率
2.模块的导入和修改 *
3.模块的循环引用 **** 不能循环
4.dir(模块名) ***
可以获取这个模块中的所有名字
二、导入包
1、
1.无论是import形式还是from...import形式,凡是在导入语句中遇到带点的都是关于包的导入语法。
2. 包是目录级的(文件夹级),文件夹是用来组成py文件(包的本质就是一个包含__init__.py文件的目录)
3. import导入文件时,产生名称空间中的名字来源于文件,import 包,产生的名称空间的名字同样来源于文件,即包下的__init__.py,导入包本质就是在导入该文件
4.导入包就相当于执行力这个包下的__init__.py文件,在__init__下导入了什么模块,你就等于导入了什么模块
强调:
1. 在python3中,即使包下没有__init__.py文件,import 包仍然不会报错,而在python2中,包下一定要有该文件,否则import 包会报错
2. 创建包的目的不是为了运行,而是被导入使用,记住,包只是模块的一种形式而已,包即模块
2、目录结构创建
创建代码目录:
import os
os.makedirs('glance/api')
os.makedirs('glance/cmd')
os.makedirs('glance/db')
l = []
l.append(open('glance/__init__.py','w'))
l.append(open('glance/api/__init__.py','w'))
l.append(open('glance/api/policy.py','w'))
l.append(open('glance/api/versions.py','w'))
l.append(open('glance/cmd/__init__.py','w'))
l.append(open('glance/cmd/manage.py','w'))
l.append(open('glance/db/models.py','w'))
map(lambda f:f.close() ,l)
目录结构:
glance/ #Top-level package
├── __init__.py #Initialize the glance package
├── api #Subpackage for api
│ ├── __init__.py
│ ├── policy.py
│ └── versions.py
├── cmd #Subpackage for cmd
│ ├── __init__.py
│ └── manage.py
└── db #Subpackage for db
├── __init__.py
└── models.py
文件内容
#policy.py
def get():
print('from policy.py')
#versions.py
def create_resource(conf):
print('from version.py: ',conf)
#manage.py
def main():
print('from manage.py')
#models.py
def register_models(engine):
print('from models.py: ',engine)
3、注意事项
1.关于包相关的导入语句也分为import和from ... import ...两种,但是无论哪种,无论在什么位置,在导入时都必须遵循一个原则:
凡是在导入时带点的,点的左边都必须是一个包,右边可以是包也可以是文件,否则非法。可以带有一连串的点,如glance.db.models,但都必须遵循这个原则。
2.对于导入后,在使用时就没有这种限制了,点的左边可以是包,模块,函数,类(它们都可以用点的方式调用自己的属性)。
4、import:import什么,调用的时候就要写全
import glance.db.models
glance.db.models.register_models('hello') # from models.py: hello
5、from...import
需要注意的是from后import导入的模块,必须是明确的一个不能带点,否则会有语法错误,如:from a import b.c是错误语法
from glance.db import models
models.register_models('hello')
from glance.db.models import register_models
register_models('hello')
6、__init__.py文件
不管是哪种方式,只要是第一次导入包或者是包的任何其他部分,都会依次执行包下的__init__.py文件,
也就是说每次导入一个包都会先执行包下的__init__.py文件。
在包api下的__init__.py文件写入这样的代码:
print('__init__')
__all__ = ['policy']
然后在主程序执行:
from glance.api import *
policy.get() # __init__ # from policy.py
versions.create_resource('aa') # 报错:name 'versions' is not defined
7、绝对导入和相对导入
我们的最顶级包glance是写给别人用的,然后在glance包内部也会有彼此之间互相导入的需求,这时候就有绝对导入和相对导入两种方式:
绝对导入:以glance作为起始
相对导入:用.或者..的方式最为起始(只能在一个包中使用,不能用于不同目录内)
一旦使用了相对导入,那么这个文件只能作为模块使用,不用直接执行了。
8、单独导入包
直接单独导入包,比如import glance,是不会导入包中的模块的,
直接导入包名称的时候,只会去执行包中的__init__文件,所以单独导入包名称的时候,需要
去包下的__init__文件中导入相应的模块。
例如:在与glance同级的test.py文件下运行代码:
import glance
glance.api.policy.get() # 报错:module 'glance' has no attribute 'api'
导入包就等于导入包下__init__的内容,而此时在glance的__init__内没有导入相应的内容,所以会报错
在glance包下的__init__写入:
from glance.api import policy
再次执行
import glance
glance.api.policy.get()
结果:from policy.py
三、开发规范(插图)