python3--模块和包,软件开发规范
模块搜索路径
python解释器在启动时会自动加载一些模块，可以使用sys.modules查看
在第一次导入某个模块时(比如my_module),会检查该模块是否已经被加载到内存中(执行文件的名称空间对应的内存)，如果有则直接引用，如果没有，解释器则会查找同名的内建模块，如果还没有找到就从sys.path给出的目录列表中依次寻找my_module.py文件
总结模块的查找顺序:内存中已经加载的模块-->内置模块-->sys.path路径中包含的模块
需要特别注意的是:我们自定义的模块名不应该与系统内置模块重名。
在初始化就，python程序可以修改sys.path路径放到前面的优先于标准库被加载
import sys
sys.path.append(路径) # 往sys.path里面添加路径
编译python文件
为了提高加载模块的速度，强调强调强调：提高的是加载速度而绝非运行速度。python解释器会在__pycache__目录中下缓存每个模块编译后的版本，格式为：module.version.pyc。通常会包含python的版本号。例如，在CPython3.3版本下，my_module.py模块会被缓存成__pycache__/my_module.cpython-33.pyc。这种命名规范保证了编译后的结果多版本共存。
Python检查源文件的修改时间与编译的版本进行对比，如果过期就需要重新编译。这是完全自动的过程。并且编译的模块是平台独立的，所以相同的库可以在不同的架构的系统之间共享，即pyc使一种跨平台的字节码，类似于JAVA火.NET,是由python虚拟机来执行的，但是pyc的内容跟python的版本相关，不同的版本编译后的pyc文件不同，2.5编译的pyc文件不能到3.5上执行，并且pyc文件是可以反编译的，因而它的出现仅仅是用来提升模块的加载速度的。
python解释器在以下两种情况下不检测缓存
1 如果是在命令行中被直接导入模块，则按照这种方式，每次导入都会重新编译，并且不会存储编译后的结果（python3.3以前的版本应该是这样）
python -m my_module.py
2 如果源文件不存在，那么缓存的结果也不会被使用，如果想在没有源文件的情况下来使用编译后的结果，则编译后的结果必须在源目录下
提示：
1.模块名区分大小写，foo.py与FOO.py代表的是两个模块
2.你可以使用-O或者-OO转换python命令来减少编译模块的大小
-O转换会帮你去掉assert语句
-OO转换会帮你去掉assert语句和__doc__文档字符串
由于一些程序可能依赖于assert语句或文档字符串，你应该在在确认需要的情况下使用这些选项。
3.在速度上从.pyc文件中读指令来执行不会比从.py文件中读指令执行更快，只有在模块被加载时，.pyc文件才是更快的
4.只有使用import语句是才将文件自动编译为.pyc文件，在命令行或标准输入中指定运行脚本则不会生成这类文件，因而我们可以使用compieall模块为一个目录中的所有模块创建.pyc文件
把模块当做脚本执行
我们可以通过模块的全局变量__name__来查看模块名
当做脚本运行:
__name__ 等于'__main__'
当做模块导入:
__name__ 等于模块名
如果一个py文件被导入了，他就是一个模块
如果这个py文件被直接执行，这个被直接执行的文件就是一个脚本
作用：用来控制.py文件在不同的应用场景下执行不同的逻辑
def fib(n):
a, b = 0, 1
while b < n:
print(b, end=',')
a, b = b, a + b
if __name__ == '__main__':
print(__name__)
num = input('num :')
fib(int(num))执行结果
__main__
num :10
1,1,2,3,5,8,
文件被直接执行，那么它就是脚本(__name__ == '__main__')
创建一个test.py文件，导入之前py文件
import lianxi
lianxi.fib(10)
执行结果
1,1,2,3,5,8,__name__ == lianxi
文件被导入执行，那么它就是模块(__name__ == lianxi(文件名))
结论：
当一个模块被当做脚本执行的时候，__name__是一个字符串数据类型的'__main__'
当一个模块被当做模块导入的时候，__name__是一个字符串数据类型模块名
if __name__ == '__main__':
控制了:
只要当前这个文件直接被执行 就会执行if条件语句内的代码
否则 就不会执行if条件语句内的代码
补充:dir()函数
内建函数dir是用来查找模块中定义的名字，返回一个有序字符串列表
import my_module
dir(my_module)
如果没有参数,dir()列举出当前定义的名字
dir()不会列举出内建函数或者变量的名字，它们都被定义到了标准模块builtin中，可以列举出它们，
import builtins
dir(builtins)
包
包是一种通过使用'模块名'来组织python模块名称空间的方式
１. 无论是import形式还是from...import形式，凡是在导入语句中（而不是在使用时）遇到带点的，都要第一时间提高警觉：这是关于包才有的导入语法
2. 包是目录级的（文件夹级），文件夹是用来组成py文件（包的本质就是一个包含__init__.py文件的目录）
3. import导入文件时，产生名称空间中的名字来源于文件，import 包，产生的名称空间的名字同样来源于文件，即包下的__init__.py，导入包本质就是在导入该文件
强调：
1. 在python3中，即使包下没有__init__.py文件，import 包仍然不会报错，而在python2中，包下一定要有该文件，否则import 包报错
2. 创建包的目的不是为了运行，而是被导入使用，记住，包只是模块的一种形式而已，包即模块
包A和包B下有同名模块也不会冲突，如A.a与B.a来自俩个命名空间
创建目录结构
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)执行结果
对应文件内容如下
#文件内容
#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)注意事项
1.关于包相关的导入语句也分为import和from ... import ...两种，但是无论哪种，无论在什么位置，在导入时都必须遵循一个原则：凡是在导入时带点的，点的左边都必须是一个包，否则非法。可以带有一连串的点，如item.subitem.subsubitem,但都必须遵循这个原则。
2.对于导入后，在使用时就没有这种限制了，点的左边可以是包,模块，函数，类(它们都可以用点的方式调用自己的属性)。
3.对比import item 和from item import name的应用场景：
如果我们想直接使用name那必须使用后者
import
我们在于包glance(上面代码创建的文件)同级别的文件中测试
创建一个new.py与glance包同级,内容如下
import glance.db.models # 导入glance包(目录)下面的db(目录)包中的register_models(文件)模块
glance.db.models.register_models('mysql') # 使用的时候也需要以 包.包.模块的方式
import glance.db.models as m # 也可以使用别名的方式
m.register_models('mongdb')执行结果
from models.py: mysql
from models.py: mongdb
from...import...
需要注意的是from后import导入的模块，必须是明确的一个不能带点，否则会有语法错误，如from a import b.c是错误语法
我们在与包glance(代码创建的文件)同级别的文件中测试
创建一个new1.py与glance包同级 内容如下
from glance.db import models # 从包glance中的包db中,导入models模块
models.register_models('mysql')
from glance.db import models as m # 使用别名
m.register_models('mysql')
from glance.db.models import register_models # 从包glance中的包db中的models模块中,导入register_models函数
register_models('mongdb')
from glance.db.models import register_models as r # 使用别名
r('mongdb')执行结果
from models.py: mysql
from models.py: mysql
from models.py: mongdb
from models.py: mongdb
__init__.py文件
不管是哪种方式，只要是第一次导入包或者是包的任何其他部分，都会依次执行包下的__init__.py文件(我们可以在每个包的文件内都打印一行内容来验证一下)，这个文件可以为空，但是也可以存放一些初始化包的代码
在glance包里面的__init__.py文件中写入
print('执行了glance下的__init__.py文件')
在api包里面的__init__.py文件中写入
print('执行了api下的__init__.py文件')
在cmd包里面的__init__.py文件中写入
print('执行了cmd下的__init__.py文件')
创建一个new3.py文件与glance包同级，内容如下
import glance.api.versions
glance.api.versions.create_resource('py3.5')
import glance.api.versions as v
v.create_resource('py3.5')
from glance.cmd import manage
manage.main()
from glance.cmd import manage as m
m.main()执行结果
执行了glance下的__init__.py文件
执行了api下的__init__.py文件
from version.py: py3.5
from version.py: py3.5
执行了cmd下的__init__.py文件
from manage.py
from manage.py
可以看到__init__.py里面的内容都被执行了
from glance.api import *
从一个模块内导入所有*，此处我们研究从一个包导入所有*。
此处是想从包api中导入所有，实际上该语句只会导入包api下__init__.py文件中定义的名字，我们可以在这个文件中定义__all___:
在glance同级文件中执行from glance.api import *就导入__all__中的内容（versions仍然不能导入)，写在__all__列表中的名字才能被导入，而versions并不在里面
#在__init__.py中定义
x=10
def func():
print('from api.__init.py')
__all__=['x','func','policy']示例:
更改api下__init__.py文件，内容如下
__all__ = ['policy','versions']
更改cmd下__init__.py文件，内容如下
__all__ = ['manage']
在glance同级下创建new4.py文件，内容如下
from glance.api import *
policy.get()执行结果
执行了glance下的__init__.py文件
from policy.py
绝对导入和相对导入
我们的最顶级包glance是写给别人用的，然后在glance包内部也会有彼此之间互相导入的需求，这时候就有绝对导入和相对导入两种方式：
绝对导入：以glance作为起始
相对导入：用.或者..的方式最为起始（只能在一个包中使用，不能用于不同目录内）
例如：我们在glance/api/version.py中想要导入glance/cmd/manage.py
两种方式，用其中一种都行
#绝对导入
from glance.cmd import manage
manage.main()
#相对导入
from ..cmd import manage
manage.main()
测试结果，在glance同级的目录创建一个new4.py测试，内容如下
from glance.api import versions
versions.create_resource('py3.5')执行结果
from manage.py
from version.py: py3.5
特别需要注意的是：可以用import导入内置或者第三方模块（已经在sys.path中），但是要绝对避免使用import来导入自定义包的子模块(没有在sys.path中)，应该使用from... import ...的绝对或者相对导入,且包的相对导入只能用from的形式
比如想在glance/api/versions.py中导入glance/api/policy.py,在同一个目录下，有人这么导入，如下
更改glance/api/versions.py中的代码
import policy
def create_resource(conf):
print('from version.py: ',conf)
policy.get()执行结果
from policy.py
单独运行version.py是一点问题没有的，运行version.py的路径搜索就是从当前路径开始的，于是在导入policy时能在当前目录下找到。
但是在glance包同一级别下有一个new5.py文件中导入version.py,如下
from glance.api import versions执行结果
分析:
此时我们导入versions在versions.py中执行
import policy需要找从sys.path也就是从当前目录找policy.py,这必然是找不到的
绝对路径导入方式
所有的导入都写在对应的目录下的__init__.py中
glance/
├── __init__.py from glance import api
from glance import cmd
from glance import db
├── api
│ ├── __init__.py from glance.api import policy
from glance.api import versions
│ ├── policy.py
│ └── versions.py
├── cmd
│ ├── __init__.py from glance.cmd import manage
│ └── manage.py
└── db
├── __init__.py from glance.db import models
└── models.py
在glance目录同级下创建new6.py,内容如下
from glance.db import models
from glance.cmd import manage
from glance.api import policy
from glance.api import versions
if __name__ == '__main__':
models.register_models('test')
manage.main()
policy.get()
versions.create_resource('py3.6')执行结果
from models.py: test
from manage.py
from policy.py
from version.py: py3.6
相对路径导入方式
所有的导入都写在对应的目录下的__init__.py中，在manage.py中导入from ..api import policy
glance/
├── __init__.py from . import api #.表示当前目录
from . import cmd
from . import db
├── api
│ ├── __init__.py from . import policy
from . import versions
│ ├── policy.py
│ └── versions.py
├── cmd
│ ├── __init__.py from . import manage
│ └── manage.py from ..api import policy
#..表示上一级目录，想再manage中使用policy中的方法就需要回到上一级glance目录往下找api包，从api导入policy
└── db
├── __init__.py from . import models
└── models.py
单独导入包
单独导入包名称时不会导入包中包含的所有子模块，如
#在与glance同级的test.py中
import glance
glance.cmd.manage.main()
'''
执行结果：
AttributeError: module 'glance' has no attribute 'cmd'解决方法,在对应的__init__.py中写入
#glance/__init__.py
from . import cmd
#glance/cmd/__init__.py
from . import manage
执行
import glance
glance.cmd.manage.main()
结果为:from manage.py
import glance之后直接调用模块中的方法
glance/
├── __init__.py from .api import *
from .cmd import *
from .db import *
├── api
│ ├── __init__.py __all__ = ['policy','versions']
│ ├── policy.py
│ └── versions.py
├── cmd __all__ = ['manage']
│ ├── __init__.py
│ └── manage.py
└── db __all__ = ['models']
├── __init__.py
└── models.py
import glance
policy.get()
软件开发规范:目录结构如下
根据下图，创建对应的目录和文件
#==================>bin目录:存放执行脚本
# start.py
import os
import sys
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)
from core import core
from conf import my_log_settings
if __name__ == '__main__':
my_log_settings.load_my_logging_cfg()
core.run()
#==================>conf目录:存放配置文件
# config.ini
[DEFAULT]
user_timeout = 1000
[tom]
password = tom123
money = 10000000
[sam]
password = sam123
money=10000000000
[jack]
password = jack123
money=10
#settings.py
import os
config_path=r'%s\%s' %(os.path.dirname(os.path.abspath(__file__)),'config.ini')
user_timeout=10
user_db_path=r'%s\%s' %(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),\
'db')
#my_log_settings.py
import os
import logging.config
# 定义三种日志输出格式 开始
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
'[%(levelname)s][%(message)s]' #其中name为getlogger指定的名字
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'
# 定义日志输出格式 结束
logfile_dir = r'%s\log' %os.path.dirname(os.path.dirname(os.path.abspath(__file__))) # log文件的目录
logfile_name = 'all2.log' # log文件名
# 如果不存在定义的日志目录就创建一个
if not os.path.isdir(logfile_dir):
os.mkdir(logfile_dir)
# log文件的全路径
logfile_path = os.path.join(logfile_dir, logfile_name)
# log配置字典
LOGGING_DIC = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'standard': {
'format': standard_format
},
'simple': {
'format': simple_format
},
},
'filters': {},
'handlers': {
#打印到终端的日志
'console': {
'level': 'DEBUG',
'class': 'logging.StreamHandler', # 打印到屏幕
'formatter': 'simple'
},
#打印到文件的日志,收集info及以上的日志
'default': {
'level': 'DEBUG',
'class': 'logging.handlers.RotatingFileHandler', # 保存到文件
'formatter': 'standard',
'filename': logfile_path, # 日志文件
'maxBytes': 1024*1024*5, # 日志大小 5M
'backupCount': 5,
'encoding': 'utf-8', # 日志文件的编码，再也不用担心中文log乱码了
},
},
'loggers': {
#logging.getLogger(__name__)拿到的logger配置
'': {
'handlers': ['default', 'console'], # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
'level': 'DEBUG',
'propagate': True, # 向上（更高level的logger）传递
},
},
}
def load_my_logging_cfg():
logging.config.dictConfig(LOGGING_DIC) # 导入上面定义的logging配置
logger = logging.getLogger(__name__) # 生成一个log实例
logger.info('It works!') # 记录该文件的运行状态
if __name__ == '__main__':
load_my_logging_cfg()
#==================>core目录:存放核心逻辑
import logging
import time
from conf import settings
from lib import read_ini
config=read_ini.read(settings.config_path)
logger=logging.getLogger(__name__)
current_user={'user':None,'login_time':None,'timeout':int(settings.user_timeout)}
def auth(func):
def wrapper(*args,**kwargs):
if current_user['user']:
interval=time.time()-current_user['login_time']
if interval < current_user['timeout']:
return func(*args,**kwargs)
name = input('name>>: ')
password = input('password>>: ')
if config.has_section(name):
if password == config.get(name,'password'):
logger.info('登录成功')
current_user['user']=name
current_user['login_time']=time.time()
return func(*args,**kwargs)
else:
logger.error('用户名不存在')
return wrapper
@auth
def buy():
print('buy...')
@auth
def run():
print('''
购物
查看余额
转账
''')
while True:
choice = input('>>: ').strip()
if not choice:continue
if choice == '1':
buy()
if __name__ == '__main__':
run()
#=============>db目录：存放数据库文件
# 运行会自动生成
#=============>lib目录：存放自定义的模块和包
#read_ini.py
import configparser
def read(config_file):
config=configparser.ConfigParser()
config.read(config_file)
return config
#=============>log目录：存放日志
# all2.log
[2018-04-28 20:39:07,414][MainThread:11516][task_id:conf.my_log_settings][my_log_settings.py:73]
[INFO][It works!]
[2018-04-28 20:39:34,463][MainThread:11516][task_id:core.core][core.py:22][INFO][登录成功]
[2018-04-28 20:42:40,254][MainThread:3264][task_id:conf.my_log_settings][my_log_settings.py:73]
[INFO][It works!]
[2018-04-28 20:42:56,700][MainThread:940][task_id:conf.my_log_settings][my_log_settings.py:73]
[INFO][It works!]
[2018-04-28 20:43:36,007][MainThread:13384][task_id:conf.my_log_settings][my_log_settings.py:73]
[INFO][It works!]
[2018-04-28 20:43:42,734][MainThread:13384][task_id:core.core][core.py:27][ERROR][用户名不存在]免责声明：
① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。
② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341
