模块与包思维导图模板_ProcessOn思维导图、流程图

模块*****

定义：

别人写好的，具有相同类别的一组功能 具体样式可能是  文件夹/py文件/C语言编译好的一些编译文件

作用：

1.分类管理方法

2.节省内存

3.提供更多的功能

分类：

内置模块

跟着python解释器一起安装的那些方法

第三方模块/扩展模块

没在安装python解释器一起装上的那些功能

自定义模块

自己写的功能如果是个通用的功能，就可以当做一个模块

模块的导入：

import 文件名   #导入一个py文件的名字，但不加.py

import 一个模块，相当于执行了这个模块所在的py文件

一个模块不会被重复导入

所有的模块导入都应该尽量放在这个文件的开头

导入模块的过程发生了什么？

1.找到这个my_module模块

2.创建一个属于my_module的内存空间

3.从上到下执行my_module的代码

4.将这个模块所在的内存空间建立一个个my_module之间的引用关系

模块有自己的内存空间，与本文件（即自己写的代码，导入模块的文件）的内存空间是相互隔离的，只是可以通过模块名引用  ##

导入多个模块：

import os, my_module   （×）

import os import my_module    （√）

模块导入顺序

# 先导入内置模块 # 再导入第三方模块 # 最后导入自定义模块

使用方法：

模块名.方法名()   #my_module.login()

模块名相当于一个变量来使用，因此，模块的名字必须遵循变量的命名规则

一般模块名，都是小写字母开头

模块的重命名：

import my_module as m

并非是把模块的名字改了，只是把引用模块的变量名改了

导入模块的指定部分

语法：from  模块名  import  需要导入的变量/方法名

任然相当于执行了一遍整个py文件

from my_module import login的时候发生了什么？

1.找到这个my_module模块

2.创建一个属于my_module的内存空间

3.从上到下执行my_module的代码

4.知道了要imprt的是login这个方法，那么就在本文件中 创建一个变量login，指向模块命名空间中的login方法

注意：

# 导入了什么就能使用什么，没有导入的变量不能使用

# 没有导入不等于不存在，只是没有建立本文件到模块中其他名字的引用

# 当模块中导入的方法或变量与本文件中的重名时，那么这个名字只代表最后一次对他赋值的方法或者变量

# 被导入的模块不能反向引用本文件中的变量和方法

# 在文件中对全局变量的修改，完全不会影响对模块的引用 要对模块中的变量进行修改，只有带着模块名的限定时(my_module.name = 'Zoey')才能修改，不过都不会这么做的

在本文件中对name重新赋值，只会断开name到模块中的name = 'Alex' 的引用，并将本文件的name赋值为'太亮'，而模块中的name还是'alex'

重命名：

语法：from  模块名  import  需要导入的变量/方法名  as  新名字

导入多个变量/方法：

语法：from  模块名  import  变量名，方法名（每个用，隔开）

PEP8允许在一行导入多个变量

导入多个再重命名：

语法：from my_module import login as l,name as n

from 模块 import * ：

模块中的所有东西都可以引用了，在本文件中都有一个与模块中的东西相同的变量名来引用

模块中写__all__可以控制*导入的内容

__all__ = ['login','name']   #  只让*导入login和name，别的都导入不了 必须是列表，列表中的变量名、方法名也必须是字符串类型，不能直接写login、name这样

模块其他知识

1.把模块当成脚本运行

运行一个py文件的两种方式

①以模块的方式运行：import my_module

②以脚本的形式运行：即直接用 pycharm 运行或者用 cmd 运行

__name__内置变量

模块方式执行时__name__ = 'my_module'

直接运行时__name__ = '__main__'

模块代码中没有直接封装在函数或者类，不需要调用就能执行的代码都应该写在    if __name__ = 'main'：  这句话下面(快捷写法main写完按TAB键)。这样，模块在作为脚本运行时就会正常运行，而在以模块的形式导入其他文件中时，导入后就不会自动输出一些有的没的

2.模块搜索路径

模块的搜索路径指的就是在导入模块时需要检索的文件夹

导入模块时查找模块的顺序是： ①先从内存中已经导入的模块中寻找 ②内置的模块 ③环境变量sys.path中找

能否导入自定义模块，要看sys.path列表中是否有要调用的文件的绝对路径 可以用sys.path.append('文件路径')来添加 可以用del sys.path[-1]来删除新添加的路径

3.pyc编译文件

4.重新加载模块

模块只导入一次，不会重复导入 因此，模块导入之后，再修改模块，即使再重新导入也与我无关了

要想重新加载只有用importlib.reload(模块名)，就可以强制重新加载一遍模块 此方法就只是用来玩一下，不可以用在开发中！！！

5.模块的循环引入

在模块导入中，坚决不要发生循环导入问题 如果发生了循环导入，则会发现，明明写在模块的方法，却提示找不到 # 多个文件之间有导入关系，画个图看看导入关系是否成环

6.整一个base_path作为项目的基本路径，使导模块更方便

print(__file__)会输出执行此语句的文件所在的绝对路径

7.永远不要给一个文件起一个与所有已知模块相同的文件名，不然会影响模块导入使用的                 （注意有坑！！！）

包***

1.定义：

集合了一组py文件，提供了一组复杂功能的，有__init__的文件夹

2.作用：

提供的功能比较复杂，一个py文件写不下

3.包中都有什么：

至少拥有一个__init__.py

4.直接导入模块：

①import 包.包.模块  使用时：包.包.模块.变量

②from 包.包 import 模块（推荐使用） 使用时：模块.变量

从包中导入模块，要注意这个包所在的目录是否早sys.path中

5.导入包 （读框架源码的时候会用到）

导入包，相当于执行了这个包下面的__init__.py文件 如果希望导入包之后，模块能正常使用，需要自己去完成__inti__文件的开发 可以设计一下__init__.py来完成一些模块的导入：在init里面导入下一层包/模块

包中模块的绝对导入：

from glance import api from glance.api import policy 绝对导入时，当前执行文件与包的相对位置不能变

包中模块的相对导入：

from . import api from . import policy #  .表示当前目录位置(指正在编辑的__init__文件与需要导入的模块是否是在相同目录) #  使用了相对导入的模块，只能被当做模块执行，不能被当作脚本执行（即不能用pycharm直接run）

模块的总结

补充：项目开发规范

常用模块1 (方法模块)

1.re模块*****

正则表达式

概念：一种匹配字符串的规则

作用：可以定制一个规则，①来确认某一字符串是否符合规则；                                          ②从大段的字符串中找到符合规则的内容

在程序领域的应用：

①登录注册页的表单验证

②爬虫

③自动化开发：日志分析

正则表达式语法：

字符组：

[小-大]规定一个位置上能出现的内容（大和小是指ASCII码的值）               [1-9A-Zabc]  ==》匹配一个字符               [a-z][1-9][A-Z]  ==》匹配三个字符

元字符：

/d ==[0-9]  即/d也表示匹配数字   （digit）

/w == [0-9A-Za-z_]  即/w也表示匹配一个数字字母下划线   （word）

/s ==[/n /t]  即/s表示匹配所有的空白符，包括回车、空格、制表符tab   （space）            #  /n表示匹配回车            #  /t表示匹配制表符

/D 表示匹配非数字

/W 表示匹配非数字字母下划线

/S 表示匹配非空白符

^ 表示匹配字符串的开始 ****

$ 表示匹配字符串的结尾 ****

^hello$    ==》  只有一个hello可以匹配（多个hallo就无法匹配）

.   匹配除换行符以外的任意字符（如果.要作为字符本身来匹配的话，需要加转意符/.）     #在爬虫中用的多，在表单验证是很少用

a|b  表示匹配a或者b，任然是匹配一个字符

！！若两个字符有重叠部分的，要把长的放前面

（）分组

[...]  匹配字符组中的字符

[^…]  匹配字符组中的字符以外的

量词：

放在字符之后对字符进行约束，一个量词约束一个元字符或者一个字符组

? 重复零次或一次 + 重复至少一次   * 重复至少零次 {n} 重复n次 {n,} 重复至少n次 {n,m} 重复n到m次

量词匹配的一个原则：贪婪匹配  会给你匹配尽量多的次数 （贪婪匹配内部使用的是回溯算法）

特殊用法和现象：

1.？的用法：

①紧跟在字符后面：字符重复一次或零次

②跟在量词后面：取消贪婪匹配，进行惰性匹配，在能匹配上的情况下尽量少的重复量词所约束的字符 例如：李.{1,3}  ==>  李杰和李莲英；李.{1,3}和   ==> 李莲英和他的小弟 最常用： .*?x  ==>匹配任意字符，直到找到x  ==>  爬虫中很常见

2.字符组中一些特殊字符会现原形，不用转义

[ () +*/?$. ] 会现原形  而^以及所有带\的都不会，只表示其本身含义 [-]只有写在字符组首位的时候才表示普通负号，写在其他位置时都默认表示范围

3.要匹配正则表达式中的一些特殊字符本身，需要转义

在正则表达式中要匹配字符串/n ==> 正则表达式就应该写为//n ，在python代码中就直接两个都加r写成 r'/n'  ==>r'//n' 另外还如 /( 、//t、/^等等也是一样的

re模块： 操作字符串的模块

1）匹配的方法

findall *****

语法及参数：re.findall('正则表达式','需要操作的字符串')

返回值类型：列表

返回值个数：1

返回值内容：所有匹配上的项（没匹配上就是一个空列表）

Python中分组遇见findall：             分组优先显示！！有坑！！！ findall会优先显示正则表达式分组中的内容，要取消分组优先，需要在分组中最前面加上?: 例：ret = re.findall('www.(baidu|oldboy).com','www.oldboy.com')  --> ret = 'oldboy' ret = re.findall('www.(?:baidu|oldboy).com','www.oldboy.com')  --> ret = 'www.oldboy.com'

search *****

语法及参数：re.search('正则表达式','需要操作的字符串')

返回值类型：匹配上了 --> 正则匹配结果对象                     没匹配上 --> None

返回值个数：1

返回值内容：匹配上了 --> 对象                     没匹配上 --> None

返回的对象通过group来获取匹配到的第一个结果 ret = re.search('/d+','1416asdg2342sdf2').group()  ==> ret = 1416      #用findall能获取所有匹配结果，用search只能获取第一个

Python中分组遇见search： 当search正则表达式中有分组时，可以通过给group(n)传参，拿到正则表达式中第n个分组所对应的匹配的内容 不传n则默认是0，则拿到完整匹配结果

match **

与search语法、返回值都完全一样，不过match是从头匹配（即默认正则表达式最前面有一个^），因此匹配结果可能不同

对比：

ret = re.match('/d+','1416asdg2342sdf2').group() ==> ret = 1416

ret = re.match('/d+','sa1416asdg2342sdf2') ==> ret = None        (#没匹配上就没有 .group()方法。因此常用写法是if ret:print(ret.group())

2）替换的方法

sub ***

语法及参数：re.sub('正则表达式'，'替换成什么'，'需要操作的字符串'，替换的次数)         #如不指定替换的次数，默认全替换

返回值类型：字符串

返回值个数：1

返回值内容：替换后的字符串

subn ***

语法及参数：re.subn('正则表达式'，'替换成什么'，'需要操作的字符串')

返回值类型：元祖

返回值个数：1

返回值内容：（替换后的字符串，替换的次数）组成的元祖

3）切割的方法

split ***

语法及参数：re.split('正则表达式','需要操作的字符串') # 以所有满足正则表达式的项为'刀'来切割需要操作的字符串

返回值类型：列表

返回值个数：1

返回值内容：所有切割后的字符串组成的列表

Python中分组遇见split： split中将正则表达式用分组括号括起来，返回值将保留切割的'刀'。 如果正则表达式只有部分括起来了，那么就只将括起来的部分匹配的内容作为'刀'保留 ret = re.split('\d+','alex83egon20') -->ret = ['alex','egon',''] ret = re.split('(\d+)','alex83egon20taibai40')-->ret = ['alex','83','egon','20','']

4）进阶方法 （爬虫和自动化开发必备）

compile ***** (对复杂正则表达式预编译)

正则表达式在python中运行过程： \d*\s?adsf*.   --> 将正则表达式编译为python能理解的代码  -->  执行代码

语法及参数：re.compile('正则表达式').findall('需要操作的字符串') # 将增则表达式编译为代码储存起来，以便后面每次都可以直接用

用法：ret = re.compile('很长的正则表达式')           ret.findall('需要操作的字符串')           ret.search('需要操作的字符串')等等

作用：节省时间（时间效率） 只有多次使用同一个正则表达式的时候，才会提高代码效率

finditer ***** （对海量数据进行处理）

一个海量数据中，匹配正则表达式的字符串结果也是一个庞大的数据量，finditer就将这个庞大数据量的 匹配结果转化成为一个可迭代对象，就可以使用for循环来进行下一步处理了

用法：ret = re.finditer('正则表达式','需要操作的海量数据')           for r in ret:                print(r.group())

相关值的类型：ret  可迭代对象的内存地址                         r     正则匹配结果对象

作用：节省内存（空间效率）

分组命名

语法：(?P<name>正则表达式)  表示给分组起名字           (?P=name)    表示使用这个分组

通过索引使用分组

\1 表示使用第一组，匹配到的内容必须和第一组相同

2.random模块*****      （随机）

应用：抽奖、彩票、发红包、验证码

1）获取随机小数的方法

①random 获取0-1之间的随机小数

语法：random.random()

②uniform 获取n到m之间的随机小数

语法：random.uniform(n,m)

2）获取随机整数的方法         *****

①randint 获取[n,m]闭区间内的随机整数            可以取到m

语法：random.randint(n,m)           没有step，只有两个参数

②randrange 获取[n,m)左闭右开区间内的随机整数           顾头不顾尾~可以有步长 step= 2，就可以获取一定范围的奇数/偶数

语法：random.randrange(n,m,step)

3）随机抽取

①choice 随机抽取一个值 元祖/列表/字符串/range()

语法： a=['wahaha',12,(3,'wangzai')] random.choice(a)

②sample 随机抽取n个值 元祖/列表/字符串/range()

语法： a=['wahaha',12,(3,'wangzai')] random.sample(a,n)

4）打乱顺序 在原列表的基础上做乱序 只能操作列表，dict都不行

shuffle 语法： a=['wahaha',12,(3,'wangzai')] random.shuffle(a)

3.time模块**** (描述/获取时间)

1）三种时间的格式

①时间戳时间（格林威治时间/float数据类型时间）（是给机器用的） 语法：time.time() 获取的是伦敦时间1970年1月1日0:0:0（北京时间1970年1月1日8:0:0）起至当前所经历的秒数

②结构化时间：是一个时间对象，可以通过.属性名来获取对象的值，结构类似于一个元祖。（前两种格式的转换桥梁） 语法：time.localtime()     通过结构化时间，可以将时间戳时间转换为格式化时间

③格式化时间（字符串时间/str数据类型时间）（给人看的） 语法：time.strftime(%Y-%m-%d)     #2019-08-14           time.strftime(%H:%M:%S)      #21:33:50 可以根据你需要的格式来显示时间

%y 两位数的年份表示（00-99） %Y 四位数的年份表示（000-9999） %m 月份（01-12） %d 月内中的一天（0-31） %H 24小时制小时数（0-23） %I 12小时制小时数（01-12） %M 分钟数（00=59） %S 秒（00-59）

2）三种格式之间的转换

4.sys模块**** （与python解释器交互）

1）sys.path:当前python解释器寻找模块的路径

2）sys.modules：当前文件在内存中导入的所有路径

用的最多的地方：反射本模块的时候用，sys.modules[__name__]，其他时候几乎不会用到

3）sys.exit()：强制python解释器结束程序

基本不会用，都直接用内置函数exit()

4）sys.argv：

①返回值类型：列表（在执行python文件的时候,在python指令之后的所有内容,以空格隔开都会成为argv返回值列表的项）

②返回值解读：第一个元素是执行这个文件时，写在python命令后面的第一个值。 之后的元素，执行Python启动的时候，在python命令后面写其他内容，都会被添加到这个列表中

③应用：执行py文件的时候先做一个登录认证，认证成功才给你执行这个py文件，认证不成功就直接给退出 （可以不用再执行python文件之后再input认证）

这样做的优势：一是符合运维人员的工作习惯；二是可以避免input阻塞，顺畅系统调度，提高系统执行效率

代码： name = sys.argv[1] pwd = sys.argv[2] if name == 'alex' and pwd == 'alex3714':     print('执行以下代码') else:     exit()

5.os模块***** （与操作系统交互）

1）os.系列

(1)和工作目录相关的

①os.getcwd()：获取当前文件的工作路径（即在哪里执行的当前文件）

②os.chdir('新路径')：修改当前文件的工作路径（不管在哪执行，都把工作路径给强制改为新路径） 相当于shell下cd

(2)创建/删除文件、文件夹相关的****

①os.mkdir('dirname')：创建单级目录（这个文件夹与当前文件同级）

应用：网盘

②os.makedirs('dir1/dir2/dir3')：创建多级目录

还可以传第二个参数exist_ok = True,则如果创建的文件已经存在，也不会报错。该参数默认值为False。

③os.rmdir('dir1/dir2/dir3')：删除单级目录

#只能删除一级文件夹（即dir3）

#只能删除空文件夹，非空的删不了

④os.removedirs('dir1/dir2/dir3')：删除多级目录

#递归向上删除文件夹，直至遇到非空文件夹为止

#只能删除空文件夹，非空的删不了。如果dir1空，dir2非空，dir3空，运行结果就只是删dir3

⑤os.remove('aaa.py')：删除一个文件

⑥os.rename("oldname","newname")：重命名文件/目录

⑦os.listdir('路径')*****

列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表格式返回

(3)和操作系统差异相关的

①os.stat('path/filename')：获取文件/目录信息

②os.sep：查看当前所在的操作系统的目录分割符

Windows：\ Linux：/

③os.linesep：输出当前平台使用的行终止符

win："\r\n" Linux："\n"

要打印出确切的符号，应该写为：print([os.linesep])，不然只会看到一个空行

④os.pathsep：查看用于分割文件路径的字符串

win下为; Linux下为:

⑤os.name：查看字符串指示当前使用平台

win：'nt' Linux、Mac：'posix'

(4)使用python来和操作系统命令交互相关的

①os.system('命令')：运行shell命令

#直接按操作系统的编码方式显示，且不需要print

只执行，不返回结果，因此不能后续操作

②os.popen('命令')：运行shell命令

返回一个对象：ret = os.popen('dir')   ret是个对象，然后ret.read()就能读取到内存，就可以直接操作了，ret.read()类型是str

应用场景：查看当前路径、查看某些信息的时候

(5)查看环境变量

③os.environ：查看操作系统的环境变量

返回值类型：字典。环境变量:值

2）os.path.系列

①os.path.abspath('路径')：返回path规范化的绝对路径

如果给的是个相对路径，他会给你返回绝对路径

如果给的是一个不规范的路径(即左斜杠/)，他会给你转成一个规范化的路径(即右斜杠\)，并且这个\是已经转义好的\

②os.path.split('路径')：将路径分割成目录和文件名的二元元组返回

返回值类型：('目录路径'，'文件名')

print(os.path.split('D:/sylar/python_workspace/day25/5.os模块.py')) #（'D:/sylar/python_workspace/day25'，'5.os模块.py'）

③os.path.dirname('路径')：目录路径，就是split的第一个元素

应用：去拿项目的base_path，用__file__拿到当前目录之后，直接网上翻几层就得到了 os.path.dirname(os.path.dirname(__file__))

④os.path.basename('路径')：文件名，就是split的第二个元素

⑤os.path.exist('路径')：判断路径是否存在

返回值：True/False

⑥os.path.isabs('路径')：判断路径是否是绝对路径

返回值：True/False

⑥os.path.isfile('路径')：判断路径是否是一个存在的文件

返回值：True/False

⑥os.path.isdir('路径')：判断路径是否是一个存在的目录

返回值：True/False

⑦os.path.join(path1,path2, ...)：将多个路径用\连接后返回

#第一个绝对路径之前的参数将被忽略

⑧os.path.getatime('路径')：返回路径所指向的文件或者目录的最后访问时间

⑨os.path.getmtime('路径')：返回路径所指向的文件或者目录的最后修改时间

⑩os.path.getsize('路径')：返回路径指向的文件或者目录的大小*****

#文件的大小都能准确统计，但目录的大小统一都返回4096 单位：字节

面试题：统计一个文件夹中所有文件的总的大小

6.序列化模块*****

1）定义

序列化：将原本的字典、列表、数字、对象等内容转换成一个字符串的过程

反序列化：将字符串装换成原本的列表、对象等数据类型的过程

2）为什么要序列化？

①要把内容写入文件的时候就要序列化，因为写文件只能写字符串

②网络传输数据时就要序列化，因为网络通过高低电压传输10101二进制，二进制由于bytes最接近，而bytes与字符串最接近

3）方法

(1)json模块

方法：

①json.dumps()：序列化

返回值类型：字符串

#字符串是由“”括起来的

②json.loads()：反序列化

返回值类型：原数据类型

③json.dump('要写入的内容',f)：存。接收一个文件句柄，直接将内容写入文件中

# dic = {'aaa':'bbb','ccc':'ddd'} # with open('json_dump2','w') as f: # json.dump(dic,f)

④json.load(f)：读。直接将文件中的内容反序列化

# with open('json_dump2') as f: # print(json.load(f))

json的限制情况：

①json格式的限制1：json格式的key必须是字符串数据类型，如果是数字为key,那么dump之后会强行转成字符串数据类型

json格式的限制2：经过json序列化之后的数据，字符串都是用“”来的，经过反序列化会回到‘’。因此如果要对一个数据进行反序列化，那么所有字符串类型的数据都必须是“”括起来，否则会报错

③json是否支持元组,：对元组做value的字典会把元组强制转换成列表；对元组做key的字典会报错

④能否多次dump数据到一个文件里：可以多次dump，但没法load （写可以写，但读不了，只能一次读一个变量）

代码： # dic = {'abc':(1,2,3)} # lst = ['aaa',123,'bbb',12.456] # with open('json_demo','w') as f: # json.dump(lst,f) # json.dump(dic,f)

用dumps可以实现：

代码： # dic = {'abc':(1,2,3)} # lst = ['aaa',123,'bbb',12.456] # with open('json_demo','w') as f: # str_lst = json.dumps(lst) # str_dic = json.dumps(dic) # f.write(str_lst+'\n') # f.write(str_dic+'\n') # with open('json_demo') as f: # for line in f: # ret = json.loads(line) # print(ret)

⑤对中文格式的数据dump之后，会在文件里显示编码，需要将参数ensure_ascii = False

⑥set不能被dump/dumps

⑦json的其他参数：为了让程序员看得更方便，但写入文件的话，会占不必要的空间

2）pickle模块

pickle序列化之后的返回值是bytes数据类型

优缺点：

优点：可以处理任意数据类型，且可以将数据原封不动的反序列化而不作任何改变。

缺点：序列化之后无法直接看出原数据内容 （但实际无所谓，因为序列化的目的是把数据存入内存，之后要再拿出来的，如果只是储存来供人看得话，根本不要序列化）。

方法：

①pickle.dumps()

对象都可以序列化

②pickle.loads()

③pickle.dump()

注意，因为是bytes类型，open(........., mode = 'wb')

④pickle.load()

注意，因为是bytes类型，open(........., mode = 'rb')

能多次dump和load数据：

# with open('pickle_demo','wb') as f: # pickle.dump({'k1':'v1'}, f) # pickle.dump({'k11':'v1'}, f) # pickle.dump({'k11':'v1'}, f) # pickle.dump({'k12':[1,2,3]}, f) # pickle.dump(['k1','v1','l1'], f) # with open('pickle_demo','rb') as f: # while True: # try: # print(pickle.load(f)) # except EOFError: # break

3）shelve模块（削微模块^_^） （用的较少）

适用于：

如果写定了一个文件，且改动的比较少，读文件的操作比较多，并且你大部分的读取都需要基于某个key获得某个value，name就适合使用shelve

方法：

存值： # f = shelve.open('shelve_demo') # f['key'] = {'k1':(1,2,3),'k2':'v2'} # f.close()

取值： # f = shelve.open('shelve_demo') # content = f['key'] # f.close() # print(content)

7.collections模块*** （数据类型的扩展模块）

双端队列deque:

什么是队列？先进先出的一列数据

一端放，另一端取，且看不到队列里的值和顺序

适用于网上购票等排队的事项

什么是双端队列？

两端都可以放，两端都可以取，先放的在中间，后方的在两端，取得时候先取两端的，且能看到队列里的值和顺序

collection实际是个包，因此需要from collection import deque

①默认从右边操作

②可以按内容删除

③可以在指定位置插入内容

双端队列的操作效果和list差不多，区别在哪呢？

①列表是一个连续内存空间，如果使用remove/insert比较多的话，每一次所有元素都需要挪一遍位置，列表的效率很低

②双端队列的底层使用的是C语言的一个叫链表的数据类型，链表的内存空间不连续，是一个个独立有用地址相连系的内存空间

总结：

在insert/remove的时候，deque的平均效率要高于列表

列表根据索引查看某个值的效率要高于deque

append和pop对于列表的效率是没有影响

常用模块2 面向对象相关

1.hashlib模块***** (提供常用的摘要算法的模块)

能够把一个字符串数据类型的变量，转变成一个定长的、密文的字符串，且这个字符串的每一个字符都是一个16进制数。

1）摘要算法特点：

①只能将字符串转为密文，不能将密文再转回原字符串（转密不可逆）

②对于同一字符串（不管有多长），无论在任何环境下、多少次执行、在任何语言中，用相同的算法、相同的手段进行摘要，获得的值也总是相同的

③只要不是相同的字符串，得到的结果一定不同

2）常用的摘要算法：

(1)md5算法：

结果：32位的字符串，每个字符都是一个16进制数

应用：

①注册时用户名和密码的加密储存

代码： #s='alex3714' #md5_obj = hashlib.md5() #md5_obj.update(s.encoding('utf-8')) #res = md5_obj.hexdigist() #print(res)

注：可以对s进行分段update，最终结果不变

②文件的一致性校验

代码： # md5_obj = hashlib.md5() # with open('5.序列化模块_shelve.py','rb') as f: # md5_obj.update(f.read()) # ret1 = md5_obj.hexdigest() # md5_obj = hashlib.md5() # with open('5.序列化模块_shelve.py.bak','rb') as f: # md5_obj.update(f.read()) # ret2 = md5_obj.hexdigest() # print(ret1,ret2)

大文件的一致性校验：

md5不够安全：因为使用的人太多，存在撞库现象

怎样解决？

①加"盐" # md5_obj = hashlib.md5('任意的字符串作为盐'.encode('utf-8')) # md5_obj.update(s1.encode('utf-8')) # res = md5_obj.hexdigest()

②动态加盐 将username作为盐

(2)sha1算法：

结果：40位的字符串，每个字符都是一个16进制数

语法： #s='alex3714' #sha1_obj = hashlib.sha1() #sha1_obj.update(s.encoding('utf-8')) #res = sha1_obj.hexdigist() #print(res)

也适合动态加盐

sha算法后面的数字越大，算法越复杂，结果越长，计算 速度越慢，安全性更高（是因为用的人少所以更安全）

2.configparse模块* (处理配置文件的模块)

可以将按固定格式写的.ini配置文件直接解析，然后可以进行字符串的操作

.ini配置文件的格式：

[section1] 键1 = 值1 键2 = 值2 [section2] 键3 = 值3

3.logging模块*****

1）功能：

①日志格式的规范

②操作的简化

③日志的分级管理

2）使用

(1)普通配置型

简单的，可定制化差

(2)对象配置型

复杂的，可定制化强

3）认识日志的分级

①调试模式：logging.debug('debug message')

②基础信息模式：logging.info('info message')

③警告：logging.warning('warning message')

④错误：logging.error('error message')

⑤严重错误：logging.critical('critical message')

4）logging.basicConfig()函数可配置logging模块的参数

# import logging # logging.basicConfig(level=logging.DEBUG, # format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s', # datefmt='%a, %d %b %Y %H:%M:%S', # filename='test.log') 然后输出日志文件： # logging.debug('debug message') # logging.info('info message') # logging.warning('warning message') # logging.error('error message') # logging.critical('critical message')

basicConfig矛盾点：不能将一个log信息既输出到文件，又输出到屏幕

5）logger对象的形式来操作日志文件

语法： import logging # 创建一个logger对象 logger = logging.getLogger() # 创建一个文件管理操作符 fh = logging.FileHandler('logger.log',encoding='utf-8') # 创建一个屏幕管理操作符 sh = logging.StreamHandler() # 创建一个日志输出的格式 format1 = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') # 文件管理操作符绑定一个格式 fh.setFormatter(format1) # 屏幕管理操作符绑定一个格式 sh.setFormatter(format1) # 设置日志分级显示 logger.setLevel(logging.DEBUG) # logger对象绑定文件管理操作符 logger.addHandler(fh) # logger对象绑定屏幕管理操作符 logger.addHandler(sh) logger.debug('debug message') # 调试模式 logger.info('我的信息') # 基础信息 logger.warning('warning message') # 警告 logger.error('error message') # 错误 logger.critical('critical message')# 严重错误

异常处理

1.什么是一异常，以及异常与错误的区别：

Iteration：异常，是在代码执行过程中引发的

Error：语法错误，在编译代码阶段就检测出来，比较明显

2.异常发生时候的效果：

一旦在程序中发生异常，程序就不再执行了

3.如何看报错信息：

从下到上的看，往往最后一条就是错误的点

4.处理最简单的异常：

# lis = ['登录','注册','退出'] # for i in enumerate(lis,1): #     print(i[0],i[1]) # try: #     num = int(input('num :')) #     print(lis[num-1]) # except IndexError: #     print('请输入一个数字')

5.多分支异常处理：

# try: #     num = int(input('num :')) #     print(l[num-1]) # except ValueError: #     print('请输入一个数字') # except IndexError: #     print('您输入的数字无效')

第二种写法： # except (IndexError,NameError) as e: #     print(e)

6.万能异常：

Exception是所有异常类的父类，包含99.9%的异常；BaseException是Exception的父类，包含剩余的几个不继承Exception的异常。

#try: #    pass #except Exeption as 变量名: #    print(type(变量名),变量名,变量名.__traceback__.tb_lineno)

这里的变量名就是异常的那个实例化对象

7.万能异常与其他分支合作：

except会从上往下走，找一第一个符合的就执行，因此万能异常必须放在所有except的最后

# except NameError:pass # except IndexError:pass # except Exception:pass

8.异常处理的其他机制

finally的意义在于：程序的中断、函数的返回，均不影响finally的执行。即使有异常没有被处理到, 最后执行报错了，或者前面的代码里面有exit()，finally也依旧会执行。