Python的模块
Posted 毛新觉罗
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python的模块相关的知识，希望对你有一定的参考价值。
模块的基本知识点：
1、定义：一个.py文件就是一个模块
2、模块的种类：
（1）Python标准库（内置模块）
（2）第三方模块
（3）应用程序自定义模块
3、调用模块的关键字：
import : 1、执行调用的文件。 2、引用。
补充：
package（包）的基本知识点：
包的两种调用方式：
## 第一种调用方式 from package1.package2 import test ## 第二种调用方式 from package1.package2.test import function
（1）下面介绍第三方模块的调用方式：
1 ## file_模块.py 文件的内容： 2 3 def add(a,b): 4 return a+b 5 def sub(a,b): 6 return a*b 7 8 if __name__ == \'__main__\': ## 注意：这里只有在文件内才能运行 9 c = add(1,2) 10 print(c)
1 import file_模块 2 c = file_模块.add(2,3) 3 print(c)
运行结果： 5
（2）Python的内置模块有：
- time（时间）模块
- random（随机）模块
- json模块和pickle模块
- os模块（文件操作）
- re模块（正则表达式）（重点）
- sys模块
- xml模块
- configparser模块
- hashlib模块（加密）
- logging模块（日志）（重点）
下面逐一介绍各个模块的方法：
- 1. time模块
1 import time 2 3 # 时间戳： 4 print(time.time()) 5 6 # 结构化时间--当地时间 8 print(time.localtime(1585482263.9318557)) 9 # 运行结果：time.struct_time(tm_year=2020, tm_mon=3, tm_mday=29, tm_hour=19, tm_min=44, tm_sec=23, tm_wday=6, tm_yday=89, tm_isdst=0) 10 11 t = time.localtime() 12 print(t.tm_year) ## 打印出当地时间的年份 13 14 # 结构化时间 -- UTC 15 print(time.gmtime()) 16 # 运行结果：time.struct_time(tm_year=2020, tm_mon=3, tm_mday=29, tm_hour=11, tm_min=50, tm_sec=1, tm_wday=6, tm_yday=89, tm_isdst=0) 17 18 # 将结构化时间转化成时间戳 19 print(time.mktime(time.localtime())) 20 # 运行结果：1585482737.0 21 22 # 将结构化时间转化成字符串时间 23 print(time.strftime(\'%Y--%m--%d %X\',time.localtime())) 24 # 运行结果：2020--03--29 19:57:20 25 26 # 将字符串时间转化成结构化时间 27 print(time.strptime(\'2020--03--29 19:57:20\',\'%Y--%m--%d %X\')) 28 # 运行结果：time.struct_time(tm_year=2020, tm_mon=3, tm_mday=29, tm_hour=19, tm_min=57, tm_sec=20, tm_wday=6, tm_yday=89, tm_isdst=-1) 29 30 print(time.asctime()) 31 # 运行结果：Sun Mar 29 20:00:33 2020 32 print(time.ctime()) 33 34 import datetime 35 print(datetime.datetime.now()) 36 # 运行结果：2020-03-29 20:02:28.666899
- 2.random模块
1 import random 2 3 ## 从 0-1 随机选出一个小数 4 print(random.random()) 5 6 ## 从 a-b 随机选出一个整数 7 print(random.randint(1,5)) 8 9 ## 从 a-b 随机选出一个整数，不包括b 10 print(random.randrange(1,5)) 11 12 ## 从列表 [11,22,33,44,55] 随机选出一个元素 13 print(random.choice([11,22,33,44,55])) 14 15 ## 从列表 [11,22,33,44,55] 随机选出n个元素 16 print(random.sample([11,22,33,44,55],2)) 17 18 ## 从 a-b 随机选出一个小数 19 print(random.uniform(1,5)) 20 21 ## 重新排序 22 ret = [1,2,3,4,5] 23 random.shuffle(ret) 24 print(ret) 25 26 ## 随机验证码 28 def v_code(): 29 ret = \'\' 30 for i in range(4): 31 res = random.randint(1,9) 32 alf = chr(random.randint(65,122)) 33 s = str(random.choice([res,alf])) 34 ret += s 35 return ret 36 37 res = v_code() 38 print(res)
- 3. json 模块和 pickle 模块
JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式。JSON的数据格式其实就是python里面的字典格式，里面可以包含方括号括起来的数组，也就是python里面的列表。
在python中，有专门处理json格式的模块—— json 和 picle模块
Json 模块提供了四个方法： dumps、dump、loads、load
pickle 模块也提供了四个功能：dumps、dump、loads、load
下面依次介绍 json 模块和 pickle 模块：
（一） json模块
dumps 和 dump：
dumps 和 dump 序列化：
dumps 会将对象转化成一个带双引号的字符串
dump 必须传文件描述符，只能用在文件操作中
dumps例子：
1 import json 2 res = {\'name\':\'alex\',\'age\':17,\'agen\':\'man\'} 3 print(res) 4 print(json.dumps(res))
运行结果：
1 # {\'name\': \'alex\', \'age\': 17, \'agen\': \'man\'} 2 # {"name": "alex", "age": 17, "agen": "man"}
dump例子：
1 import json 2 3 f_write = open(\'json_test\',\'w\') 4 res = {\'name\':\'alex\',\'age\':17,\'agen\':\'man\'} 5 json.dump(res,f_write) ## 这里实际上做了两步操作：1、res_dumps = json.dumps(res) 2、f_write.write(res_dumps)
loads 和 load 反序列：
loads 只完成了反序列化，
load 只接收文件描述符，完成了读取文件和反序列化
loads例子：
1 import json 2 print(type(json.loads(\'123\'))) 3 print(type(json.loads(\'[12]\'))) 4 dic = {\'name\':\'alex\'} 5 dic_dumps = json.dumps(dic) 6 print(dic_dumps) 7 dic_loads = json.loads(dic_dumps) 8 print(type(dic_loads))
运行结果：
1 # <class \'int\'> 2 # <class \'list\'> 3 # {"name": "alex"} 4 # <class \'dict\'>
load例子：
1 import json 2 f = open(\'json_test\',\'r\') 3 r_read = json.load(f) ## 相当于： 1、r_read = f.read() 2、r_read = json.loads(r_read) 4 print(r_read,type(r_read))
运行结果：
1 # {\'name\': \'alex\', \'age\': 17, \'agen\': \'man\'} <class \'dict\'>
（二）pickle模块
dumps 和 dump：
dumps 和 dump 序列化：
dumps 会将对象转化成一个二进制
dump 必须传文件描述符，只能用在文件操作中
dumps例子：
1 import pickle 2 res = \'这是一个字符串\' 3 res = pickle.dumps(res) 4 print(res,\'\\n\',type(res))
运行结果：
1 # b\'\\x80\\x03X\\x15\\x00\\x00\\x00\\xe8\\xbf\\x99\\xe6\\x98\\xaf\\xe4\\xb8\\x80\\xe4\\xb8\\xaa\\xe5\\xad\\x97\\xe7\\xac\\xa6\\xe4\\xb8\\xb2q\\x00.\' 2 # <class \'bytes\'>
dump例子：
1 import pickle 2 f = open(\'pickle_test\',\'wb\') 3 res = \'这是pickle_test的内容\' 4 pickle.dump(res,f) ## 相当于：1、res = pickle.dumps(res) 2、f.write(res)
loads 和 load 反序列：
loads 只完成了反序列化，
load 只接收文件描述符，完成了读取文件和反序列化
loads例子：
1 import pickle 2 res = b\'\\x80\\x03X\\x15\\x00\\x00\\x00\\xe8\\xbf\\x99\\xe6\\x98\\xaf\\xe4\\xb8\\x80\\xe4\\xb8\\xaa\\xe5\\xad\\x97\\xe7\\xac\\xa6\\xe4\\xb8\\xb2q\\x00.\' 3 print(pickle.loads(res))
运行结果：
1 #这是一个字符串
load例子：
1 import pickle 2 f = open(\'pickle_test\',\'rb\') 3 res = pickle.load(f) 4 print(res)
运行结果：
1 #这是pickle_test的内容
（三）python对象（obj） 与json对象的对应关系
+-------------------+---------------+
| Python | JSON |
+===================+===============+
| dict | object |
+-------------------+---------------+
| list, tuple | array |
+-------------------+---------------+
| str | string |
+-------------------+---------------+
| int, float | number |
+-------------------+---------------+
| True | true |
+-------------------+---------------+
| False | false |
+-------------------+---------------+
| None | null |
+-------------------+---------------+
（四）总结
1. json序列化方法：
dumps：无文件操作 dump：序列化+写入文件
2. json反序列化方法：
loads：无文件操作 load： 读文件+反序列化
3. json模块序列化的数据 更通用
picle模块序列化的数据 仅python可用，但功能强大，可以序列号函数
4. json模块可以序列化和反序列化的 数据类型 见 python对象（obj） 与json对象的对应关系表
5. 格式化写入文件利用 indent = 4
- 4.os模块
os模块是与操作系统交互的一个接口
1 os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径 2 os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd 3 os.curdir 返回当前目录: (\'.\') 4 os.pardir 获取当前目录的父目录字符串名：(\'..\') 5 os.makedirs(\'dirname1/dirname2\') 可生成多层递归目录 6 os.removedirs(\'dirname1\') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推 7 os.mkdir(\'dirname\') 生成单级目录；相当于shell中mkdir dirname 8 os.rmdir(\'dirname\') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname 9 os.listdir(\'dirname\') 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印 10 os.remove() 删除一个文件 11 os.rename("oldname","newname") 重命名文件/目录 12 os.stat(\'path/filename\') 获取文件/目录信息 13 os.sep 输出操作系统特定的路径分隔符，win下为"\\\\",Linux下为"/" 14 os.linesep 输出当前平台使用的行终止符，win下为"\\t\\n",Linux下为"\\n" 15 os.pathsep 输出用于分割文件路径的字符串 win下为;,Linux下为: 16 os.name 输出字符串指示当前使用平台。win->\'nt\'; Linux->\'posix\' 17 os.system("bash command") 运行shell命令，直接显示 18 os.environ 获取系统环境变量 19 os.path.abspath(path) 返回path规范化的绝对路径 20 os.path.split(path) 将path分割成目录和文件名二元组返回 21 os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素 22 os.path.basename(path) 返回path最后的文件名。如何path以／或\\结尾，那么就会返回空值。即os.path.split(path)的第二个元素 23 os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False 24 os.path.isabs(path) 如果path是绝对路径，返回True 25 os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False 26 os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False 27 os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略 28 os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间 29 os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间 30 os.system和os.popen的区别： os.system返回是否运行成功，成功返回0，失败返回1 os.popen返回shell运行的结果
- 5.re模块（重点）
正则表达式本身是一种小型的、高度专业化的编程语言，而在python中，通过内嵌集成re模块，程序员们可以直接调用来实现正则匹配。正则表达式模式被编译成一系列的字节码，然后由用C编写的匹配引擎执行。
本小结需要掌握的知识点有：
一、元字符
二、正则表达式的函数
下面分别学习两大知识点：
一、元字符
元字符有 . ^ $ * + {} ? () [ ] | \\
下面依次进行学习：
（1）.
进行匹配时，一个.可以代替一个换行符以外的任意字符串，下面例子：
1 import re 2 res = \'jksdjaexxofjasklgoasdalexijgjasgiojwoijrwng\' 3 ret = re.findall(\'j..d\',res) ## 模糊匹配，这里(..)代替两个除了换行符以外的任意的字符串，假如条件一样，那么结果会出现多个 4 print(ret) 5 # 运行结果：[\'jksd\']
（2） ^
匹配对象开头部分，下面例子：
1 import re 2 res = \'jksdjaexxofjasklgoasdalexijgjasgiojwoijrwng\' 3 ret = re.findall(\'^j..d\',res) ## 模糊匹配，只能匹配对象开头的部分，若是开头匹配不了则传回一个空列表 4 print(ret) 5 # 运行结果：[\'jksd\']
（3）$
匹配对象末尾部分，下面例子：
1 import re 2 res = \'jksdjaexxofjasklgoasdalexijgjasgiojwoijrwng\' 3 ret = re.findall(\'rw.g$\',res) ## 模糊匹配，只能匹配对象末尾的部分，若是末尾匹配不了则传回一个空列表 4 print(ret) 5 # 运行结果：[\'rwng\']
（4）* （贪婪匹配）
匹配0次或者多次前面出现的正则表达式，下面例子：
1 import re 2 res = \'dddddddddddddddddddddddijodjsgjjjjjjjjjjjjjjjjjj\' 3 ret = re.findall(\'d*\',res) ## 模糊匹配，返回一个列表，匹配 0-无穷次 的重复内容 4 print(ret) 5 ## 运行结果：[\'ddddddddddddddddddddddd\', \'\', \'\', \'\', \'d\', \'\', \'\', \'\', \'\', \'\', \'\', \'\', \'\', \'\', \'\', \'\', \'\', \'\', \'\', \'\', \'\', \'\', \'\', \'\', \'\', \'\', \'\']
（5）+ （贪婪匹配）
匹配1次或者多次前面出现的正则表达式，下面例子：
1 import re 2 res = \'dddddddddddddddddddddddijodjsgjjjjjjjjjjjjjjjjjj\' 3 ret = re.findall(\'d+\',res) ## 模糊匹配，返回一个列表，匹配 1-无穷次 的重复内容 4 print(ret) 5 ## 运行结果： [\'ddddddddddddddddddddddd\', \'d\']
注意： * 和 + 都是匹配其前面的那一个字符的重复内容，下面例子：
1 res1 = re.findall(\'alex*\',\'hello alea alexxxxx123\') 2 res2 = re.findall(\'alex+\',\'hello alse aleads\') 3 print(res1,\'分割线--分割线\',res2) 4 ## 运行结果：[\'ale\', \'alexxxxx\'] 分割线--分割线 []
总结： * 和 + 都是贪婪匹配（尽可能匹配）
（6）{ }
格式：{ a,b } 精准匹配 a-b 次前面出现的正则表达式
1 import re 2 ret1 = re.findall(\'alex{6}\',\'alexxx\') ## 注意：{6} 表示前面的正则表达式必须要出现6次 3 ret2 = re.findall(\'alex{0,6}\',\'alejjjalexxjjj\') 4 print(ret1,\'\\n\',ret2)
运行结果：
1 # [] 2 # [\'ale\', \'alexx\']
（7） ? （惰性匹配）
匹配0次或者1次前面出现的正则表达式
* 和 + 后面加入 ？ 可以变成惰性匹配（最多只能匹配一次），下面例子：
1 import re 2 res = \'alexxxx alexx alexxxx alexxx\' 3 ret1 = re.findall(\'alex?\',res) 4 ret2 = re.findall(\'alex*?\',res) ## 将 * 变成惰性匹配 5 ret3 = re.findall(\'alex+?\',res) ## 将 + 变成惰性匹配 6 print(ret1,\'\\n\',ret2,\'\\n\',ret3)
1 # 运行结果： 2 # [\'alex\', \'alex\', \'alex\', \'alex\'] 3 # [\'ale\', \'ale\', \'ale\', \'ale\'] 4 # [\'alex\', \'alex\', \'alex\', \'alex\']
（8） ( ) （分组）
匹配封闭的正则表达式，然后另存为子组，下面例子：
1 import re 2 ret1 = re.findall(\'(abc)+\',\'abcabcabcabcaaabcabc\') 3 ret2 = re.findall(\'(?:abc)+\',\'abcabcabcabcaaabcabc\') ## 和上式的区别：显示重复（abc） 4 print(ret1,\'\\n\',ret2)
运行结果：
1 # 运行结果： 2 # [\'abc\', \'abc\'] 3 # [\'abcabcabcabc\', \'abcabc\']
注意：像"abcabc"这种连在一起的进行分组匹配时，只能匹配出一个[\'abc\']
分组权限比普通权限要高，加（？：）可以去权限
1 import re 2 ## 分组权限 3 res = re.findall(\'d(\\d)\',\'abcd123\') 4 print(res) ##`[\'1\'] 5 6 ## 去权限 7 res = re.findall(\'d(?:\\d)\',\'abcd123\') 8 print(res) ## [\'d1\']
（9） [ ]
1、形式：[..] 匹配来自字符集的任意单个字符
2、形式：[x-y] 匹配x~y范围中的任意单个字符
3、形式：[^x-y] 匹配x~y范围以外的任意单个字符
例子：
1 import re 2 ret1 = re.findall(\'a[bc]d\',\'abcdffabdfffacdffad\') 3 ret2 = re.findall(\'[a-z]\',\'abc123abc\') 4 ret3 = re.findall(\'[^a-z]\',\'abc123abc\') 5 print(ret1,\'\\n\',ret2,\'\\n\',ret3)
运行结果：
1 # [\'abd\', \'acd\'] 2 # [\'a\', \'b\', \'c\', \'a\', \'b\', \'c\'] 3 # [\'1\', \'2\', \'3\']
（10） | 管道符
格式： ab|c 匹配 ab 或者 c
例子：
1 import re 2 ret = re.findall(\'ab|c\',\'acabddbddcddab\') 3 print(ret)
运行结果：
#[\'c\', \'ab\', \'c\', \'ab\']
（11） \\ 转义字符
1、转移符可以让无意义的字母变成有意义的符号，也就是下面的特殊功能
下面是转义字符的用法：
2、转移符也可以让有意义的元字符变成无意义的字符串，如 "." 加上 "\\." 就可以让 "." 这个元字符变成一个普通的字符串
下面注意一个现象：
1 importPython练习册 第 0013 题： 用 Python 写一个爬图片的程序，爬 这个链接里的日本妹子图片 :-)，(http://tieba.baidu.com/p/2166231880)(代码片段