python3--模块和包,软件开发规范

发布时间：2018-04-28 20:55:11编辑：Run阅读（3857）

模块搜索路径

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][用户名不存在]

关键字：