一、模块

模块：

一系列功能的集合体，在python中一个py文件就是一个模块，模块名就是py文件的文件名；

模块的好处：

1.减少重复的代码

2.拿来主义

定义模块：

就是创建一个py文件；

使用模块：

关键字：import

用法：import 模块名（不要加py后缀）

注意区分执行文件和模块文件，执行文件是你当前逻辑程序，模块文件是你用来调用功能的文件；

首次导入模块：

1.创建一个模块的名称空间

2.执行模块文件，将模块文件产生的名字存放于创建的模块名称空间

3.当执行文件中拿到一个模块名，该模块名指向模块名称空间中的模块名

强调：当第一次导入模块名，就会把模块内容导入到内存空间，在同一文件再次导用模块名时调用的就是第一次导入内存空间内的模块文件，不会从新导入模块文件；

调用模块内的功能：

用模块名.功能名()

注意：

模块中功能的执行始终以模块自己的名称空间为准；

也就是调用的模块功能用的都是该模块内的值，修改的也是该模块内的值，并不影响当前执行文件；

为模块起别名：

关键字as

定义：

import 模块名 as 想定义的模块名；

用处：

1.模块名太长，把模块名定义短一点，减少繁琐

2.比如有两个模块，两个模块有相同的功能名，但其中的功能效果不同，这时候就可以把两个模块名都改成相同的模块名，

用一个输入加判断，来确定你要导入的是哪个功能，你输入的是哪个模块名，就是哪个模块内功能的效果，模块名(修改过)和功能名未变，

，使用的是什么功能取决于你输入的模块名，其他的代码都无需改动，以后修改只需要，多添加一个判断模块名就可以了；

导入多个模块（不推荐）

import 模块名1，模块名2，模块名3

推荐还是多行导入

第二种导入方式：

关键字 from 

from 模块名 import 功能名1，功能名2，功能名3

首次导入：

1.创建一个模块的名称空间

2.执行模块文件，将模块文件产生的名字存放于创建的模块名称空间

3.在当前名称空间中可以直接拿到模块中的名字，可以直接使用，不用加任何前缀

注意：这种情况，因为没有模块名.功能名，如果在当前执行文件中有与模块名内功能相同的名字，就会执行当前文件内的功能名(变量名)，

所以要注意，不能取与模块功能相同的名称；

多个调用：

关键字：*

from 模块名 import *

*代替所有能调用的功能的名字；

注意：因为有些功能常用，有些功能不常用，模块的设计者，一般都会控制*所能调用的模块名；

关键字：__all__=[]

__all__=[功能名1，功能名2….]

限制以后，*所能调用的就只能是all以内的功能名；

测试模块功能：

关键字:__name__

__name__的值

1.在文件被直接执行的情况下等于__main__

2.在文件被导入的情况下等于模块名

也就是可以用__name__来判断，是否是直接执行测试功能，还是导入

if __name__ == '__main__':
　　#代码块
    print('再代码块中输入你所要测试的功能')

模块的搜索路径

sys.path:当前执行文件所在的文件夹；只看第一个路径；

可以用print(sys.path)在终端输出路径，第一个就是当前执行文件所在的文件夹

模块的查找顺序：

1.内存空间

2.内置空间

3.sys.path路径

sys.modules:当前内存中已经被导入的模块

print(sys.modules) ：在终端输出内存中所有被导入的模块

在sys.path中添加路径

sys.path.append(需要添加的路径)

比如你把模块文件放在了别的文件夹，sys.path只是当前文件夹，这时候用append把放模块的文件夹的路径加到sys.path中，

这样就能在sys.path找到模块所在的文件夹，就可以调用模块

软件开发目录规范

路径：用常量名，后面赋予路径

常量路径名=r’路径’

常用目录：(当前水平用这个目录足够了)

ATM:文件夹，所需要做的项目名，用于存放项目相关所有文件和文件夹

readme:文件，用于介绍程序功能

bin：文件夹，只放启动文件

start：文件，启动文件

conf：文件夹，用于存放配置文件

settings:文件名，配置文件

core：文件夹,存放核心逻辑

src：文件名，业务核心逻辑文件

db：文件夹，用于存放数据文件

db：文件名，用于存放数据

lib:文件夹，用于存放常用工具，也就是模块文件

common:文件名，常用功能文件，也就是常用模块文件

log:文件夹，用于存放文件日志

access.log:文件名，日志文件

应该把项目的根目录添加到环境变量中；

就比如上方的ATM项目：

根目录就是ATM目录，以后需要调用什么功能，在根目录下都可以查找到

取目录：

os.path.dirname(__file__) :取当前文件所在的目录

os.path.dirname(os.path.dirname(__file__) ) ：取当前所在在文件目录的上一级目录

以此类推，取第几层就写几段，后面有跟方便的方法，此方法仅供参考

然后把你需要的路径，赋值到一个常量当中，当以后有需要调用的时候，直接调用常量名

不必输入固定目录，以限制程序

比如，sys.path.append(os.path.dirname(__file__) )：直接加入当前路径

第二种方法：推荐

os.path.normpath(os.path.join(

　　　　 __file__,
 　　　　’..’,
　　　　 ‘..’
 　　　　))

logging模块

debug:代表调试信息，级别10

info:代表正常运行信息，级别20

warning:代表警告信息，级别30

errot:代表错误信息，级别40

critical:代表崩溃信息，级别50

设置成什么级别，打印什么级别信息

logging模块模板

"""
logging配置
"""

#定义日志文件路径
#把日志路径赋予一个变量
LOG_PATH=r'a3.log'

# 定义三种日志输出格式 开始
#把自己定义的个数赋予一个变量用于后面的调用
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'


# log配置字典
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    #多个日志格式，不可更改
    'formatters': {
        #日志格式名，可更改，这名字的意思是往终端打
        'standard': {
            #日志格式：上方定义的格式的变量名
            'format': standard_format
        },
        #这个名字的意思是往文件打
        'simple': {
            'format': simple_format
        },
    },
    #过滤，没什么用，可以无视
    'filters': {},
    #定义日志输出的格式：文件或终端，不可更改
    'handlers': {
        #打印到终端的日志名，可以更改
        'console': {
            #定义日志级别，不可更改：日志级别，可更改为DEBUG/INFO/WARNING/ERROT/CRITICAL
            'level': 'DEBUG',
            #定义日志输出格式，不可更改
            'class': 'logging.StreamHandler',  # 打印到屏幕
            #绑定格式，不可更改：具体格式根据上方定义的格式更改
            'formatter': 'simple'
        },
        #打印到文件的日志,收集info及以上的日志
        'default': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            'formatter': 'standard',
            #日志写到哪个文件：变量名，此变量我们在上面以赋予路径
            'filename': LOG_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': False,  # 向上（更高level的logger）传递
        },
    },
}

import logging
import logging.config

#加载上方定义的字典
def get_logger(name):
    #让logging模块从字典里加载配置
    logging.config.dictConfig(LOGGING_DIC)  # 导入上面定义的logging配置
    #拿到logging名，因为上面logging名为空，所以这里用__name__，如果上方定义了实名，就用上方定义的实名
    logger = logging.getLogger(name)  # 生成一个log实例
    return logger # 记录该文件的运行状态
#用来测试是否在当前文件执行
if __name__ == '__main__':
    get_logger()

什么是序列化：

我们把对象(变量)从内存中变成可储存或可传输的过程叫做序列化；

为什么要有序列化：

1.持久保存状态

2.跨平台数据交互

json模块

json只能处理字典，列表，字符串，数字，bool，空类型

json内都是双引号

序列化：内存中的数据结构——转成一种中间格式(字符串)——存储到文件中

关键字：json.dump()

用法：json.dump(需要序列化的值，打开文件的变量名)

反序列化：文件——读取中间格式（字符串）——转成内存中的数据结构

只用W写模式

关键字：json.load

用法：json.load(打开文件的变量名)

pickle模块

pickle可以转换所有的类型，但只能在python中使用

序列化：内存中的数据结构——转成一种中间格式(字符串)——存储到文件中

关键字：pickle.dump()

用法：pickle.dump(需要序列化的值，打开文件的变量名)

反序列化：文件——读取中间格式（字符串）——转成内存中的数据结构

只用W写模式

关键字：pickle.load

用法：pickle.load(打开文件的变量名)

os模块

os.path.abspath(path) 返回path规范化的绝对路径
os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False，不区分文件夹
os.path.isabs(path) 如果path是绝对路径，返回True
os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False

os.path.getsize(path)统计文件大小，单位为字节

os.path.join(‘a’,’b’,’c.txt’) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

不用写路径符

os.path.normpath(path) 规范化路径，把里面的斜杠同一，..（..返回上一层符号）执行等

用于取需要的绝对路径：