python中的常用模块
1 collections 模块：
1 namedtuple 生成可以使用名字来访问元素内容的tuple
2 deque 双端队列，可以快速的从另外一侧追加和推出对象
3 Counter 计数器 主要用来技术
4 OrderedDict 有序字典
5 defaultdict 带有默认值的字典
from collections import namedtuple,deque,OrderedDict,defaultdict,Counter
# #obj=namedtuple(name,list) list列表中的参数需要和调用该方法的参数位置和数量对等
# point=namedtuple('point',['x','y'])
# p=point(1,2)
# print(p.x)
# print(p.y)
# print(p)
#花色和数字
# card=namedtuple('card',['suits','number'])
# c1=card('红桃',2)
# print(c1)
# print(c1.suits)
# print(c1.number)
#deque 使用list存储数据的时，按索引访问元素很快，
# 但是插入和删除元素就很慢了，因为list是线性存储，
# 数据量大的时候，插入和删除效率就很低
#deque 是为了高效实现插入和删除操作的双向列表，适合与队列和栈
# import queue
# q=queue.Queue()
# q.put(5)
# q.put(6)
# q.put(7)
#
# #qsize 查看队列中的长度是多少
# print(q.qsize())
# print(q.get())
# print(q.get())
# print(q.get())
# # 若队列中已经被取空 则回被阻塞
# print(q.get()) #阻塞
#deque 双端队列 可以从两端存或则取
# q=deque([1,2])
# q.append('a') #从后边放数据 [1,2,a]
# q.appendleft('b') #左边放数据 [b,1,2,a]
# print(q.pop()) #从右边删 a
# q.popleft() # 从左边删 b
#OrderedDict
# d=dict([('a',1),('b',2),('c',3)])
# print(d) #dict的key是无序的
# od=OrderedDict([('a',1),('b',2),('c',3)]) #orderedDict 中的key是有序的
# print(od)
# print(od['a'])
# for i in od:
# print(i)
#defaultdict
values=[11,22,33,44,66,77,88]
my_dict=defaultdict(list) #参数内必须是可调用的数据类型 可传入 list set等
my_dict01=defaultdict(lambda :5)
for value in values:
if value>66:
my_dict['k1'].append(value)
else:
my_dict['k2'].append(value)
print(my_dict,my_dict01)
2 time模块：
python中的内置时间模块
import time
#sleep time()
# time.sleep(0.1)
# #时间戳 ------float 给计算机看的
# print(time.time()) #时间戳 从1970.1.1 00：00 开始按秒计算的偏移量，
#
#
# #时间字符串 格式化时间 给人看的
#
# print(time.strftime("%Y-%m-%d %X")) #x代表本地时间
# print(time.strftime("%Y-%m/%d %H:%M:%S"))
# print(time.strftime("%m/%d %H:%M:%S"))
# print(time.strftime("%H:%M:%S"))
# print(time.strftime("%H:%M"))
#
#
# #结构化时间-----元组 计算用的
# struct_time=time.localtime()
# print(struct_time)
# print(struct_time.tm_year)
#时间戳和结构化时间转换 字符串时间和时间戳之间不能直接转换
# t=time.time()
# print(time.localtime())# 获取本地结构化年时间
# print(time.localtime(t))#将获取的时间戳转换成结构化时间
# print(time.gmtime())# 格林威治时间
# print(time.mktime(time.localtime()))#将本地结构换时间转换成时间戳
#结构化时间和字符传时间转换 字符串时间和时间戳之间不能直接转换
#字符串时间转结构化时间
# print(time.strptime('2019-12-14','%Y-%m-%d'))
# #结构化时间转字符串时间
# print(time.strftime('%m/%d/%Y %H:%M:%S',time.localtime(1600000000)))
# asctime(结构化时间) 如果不传入参数 直接返回当前时间的格式化串
# ctime（时间戳） 如果不传参数，直接返回当前时间的格式化串
print(time.asctime(time.localtime()))
print(time.ctime())
3 random模块：
python中的随机数模块
import random #随机小数 random返回一个大于0且小于1之间的小数 uniform大于n小于m的小数 # print(random.random()) # print(random.uniform(1,4)) # # # #随机整数 randint(1,5)大于等于1且小于等于5之间的整数 # print(random.randint(1,5)) # print(random.randrange(1,10,2))#返回等于1且小于10之间的奇数，2等于是步长 # # # #随机选择一个返回 # print(random.choice([1,'23',[4,5]])) # #随机选择多个返回 返回的个数为函数的第二个参数 # print(random.sample([1,'23',[4,5]],2)) #打乱列表顺序 # item=[1,2,5,7,9] # random.shuffle(item) # print(item)
4 os模块：
python内置模块，用来和操作系统交互
import os
# #getcwd 返回当前工作目录 即当前python脚本工作的目录路径
# print(os.getcwd())
#chdir 切换目录 和shell中的cd类似
# os.chdir(r'C:\Users\Administrator\PycharmProjects')
# print(os.getcwd())
#返回当前目录(.)
# print(os.curdir)
#获取当前目录的父目录字符串名(..)
# print(os.pardir)
#也可以使用chdir 相当于cd .. 返回父目录
# os.chdir('..')
# print(os.getcwd())
#创建 makedirs 生成多层递归目录 即dirname1是dirname2的父目录
# os.makedirs('dirname1/dirname2')
#删除 removedirs 若目录为空 则删除 并递归到上一级目录 如若也为空 则删除 以此类推
# os.removedirs('dirname1')
# 创建 mkdir 生成单级目录 mkdir dirname
# os.mkdir('dirname3')
# 删除 rmdir 删除单级空目录 若目录不为空则无法删除 报错 rmdir dirname
# os.rmdir('dirname3')
# #列出指定目录下的所有文件和子目录，包括隐藏文件，并且以列表的形式打印出来
# print(os.listdir(r'C:\Users\Administrator\PycharmProjects\day'))
#
# #删除一个文件 remove
# os.remove('dirname3\方法')
#重命名一个文件/目录 该当前目录下的文件或则子目录
# os.rename('oldname','newname')
#获取文件/目录信息
# print(os.getcwd())
# print(os.stat('day19d.py'))
'''
stat 结构:
st_mode: inode 保护模式
st_ino: inode 节点号。
st_dev: inode 驻留的设备。
st_nlink: inode 的链接数。
st_uid: 所有者的用户ID。
st_gid: 所有者的组ID。
st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。
st_atime: 上次访问的时间。
st_mtime: 最后一次修改的时间。
st_ctime: 由操作系统报告的"ctime"。在某些系统上（如Unix）是最新的元数据更改的时间，在其它系统上（如Windows）是创建时间（详细信息参见平台的文档）。
'''
#获取当前操作系统的目录分隔符 Win \ linux / python代码跨平台用的
# print(os.sep)
#
# #获取输出当前平台使用的行终止符 Win下位'\t\n' linux下为‘\n’
# print(123)
# print(os.linesep)
# print(456)
# #输出用于分割文件路径字符串 win---> ; linux--->:
# print(os.pathsep)
#
# #输出字符串只是当前使用平台 win--->'nt'; linux----->'posix'
# print(os.name)
#运行shell命令 直接显示 linux 是对应shell命令 win是对应dos命令
#system 和 popen区别 前者没有返回值 而后者有
# # print(os.system('dir'))
# ret=os.popen('dir').read()
# print(ret)
#
# #获取环境变量
# print(os.environ)
#os.path
#返回path规范化的绝对路径
# print(os.path.abspath(os.getcwd()))
# #将path分割成目录和文件名元组返回
# print(os.path.split(os.getcwd()))
#
# #返回path的目录,其实就是os.path.split(path)的第一个元素
# print(os.path.dirname(os.getcwd()))
#
# #返回path最后的文件名，如果path以/或\结尾，那么就会返回空值
# #其实就是os.path.split(path)中的第二个值
# print(os.path.basename(os.getcwd()))
#
# #判断路径是否存在 如果path存在则返回True 否则False
# print(os.path.exists(os.getcwd()))
#如果path是绝对路径 返回True
# print(os.path.isabs(os.getcwd()))
#
# #如果path是一个存在的文件，返回True 否则False
# print(os.path.isfile(r'C:/Users/Administrator/PycharmProjects/day/day19/day19d.py'))
#
# #如果path是一个存在的目录 则返回True 否则False
# print(os.path.isdir('C:/Users/Administrator/PycharmProjects/day/day19'))
#
# #将多个路径组合返回 第一个绝对路径之前的参数将被忽略
# print(os.path.join('C:/Users/','Administrator/PycharmProjects/','day'))
#返回path所指向的文件或目录的最后访问时间 返回时间戳
# print(os.path.getatime(os.getcwd()))
# #返回path所指向的文件或目录的最后修改时间 返回时间戳
# print(os.path.getmtime(os.getcwd()))
#
# #返回path的大小 文件夹最大4096
# print(os.path.getsize(os.getcwd()))
5 sys模块：
和python解释器交互的一个接口
#命令行参数list 第一个元素是程序本身路径 执行一个脚本需要先传一些参数
# 1 需要在终端 运行文件时 把参数传入 格式 python 文件名 参数1 参数2
# 2 传入的参数1 参数2需要在文件中已经做了判断 才能用
# 验证权限使用 在命令行执行文件需要权限
ret01=sys.argv
print(ret01)
name=ret01[1]
pwd=ret01[2]
if name=='alex' and pwd=='yuan':
print('login pass')
else:
print('login faile')
sys.exit()
print('可以使用')
#返回操作系统平台名称
# print(sys.platform)
# #退出程序exit(n) 正常退出时exit(0) 错误退出sys.exit(1)
# #整个程序退出 等于退出python解释器，如果exit（1） 则为错误退出发送给系统处理
#
# #获取python的解释器版本
# print(sys.version)
#
#
# #搜索模块的搜索路径 初始化时使用python
# # 顺序 本身所处的目录找----->到上一级搜-------->python解释器中搜索
# print(sys.path)
6 序列化模块：
python 中有三种序列化模块
1 json
通用的序列化格式 只有很少的一部分数据类型通过json转化成字符串
2 pickle
所有的python中的数据类型都可以转化成字符串形式，pickle序列化的内容只有python能理解
且反序列化依赖python代码
3 shelve
操作简单，生成序列化句柄，使用句柄直接操作，非常方便
json：
import json
#可序列化数据类型 数字 字符串 列表 字典 元组（先转成列表在序列化）
#json dumps序列化方法 loads反序列化方法 在内存中直接更改
#数据结构中用单引号，序列化后回转成双引号，
# 因为json是个单引号的数据类型，json_str='{"k1":"v1"}'需要将数据类型中的单引号转化才能做区分
# dict_json={'k1':'v1'}
# dict_str=json.dumps(dict_json)
# print(type(dict_str),dict_str)
# dic_d=json.loads(dict_str)
# print(type(dic_d),dic_d)
#dump load 操作文件 dump先序列化字符串 在写到文件中 load先读出来在反序列化
# dict_json01={'k2':'v2'}
# f=open('fff','w',encoding='utf8')
# json.dump(dict_json01,f)
# f1=open('fff','r',encoding='utf8')
# ret=json.load(f1)
# f1.close()
# print(type(ret),ret)
#dump指定参数ensure_aciis=False 可以写中文 否则直接写成bytes类型 但是不影响读取
# dict_json02={'k2':'v2','k3':'大中国'}
# f=open('fff','w',encoding='utf8')
# json.dump(dict_json02,f,ensure_ascii=False)
# f.close()
# 如果插入的时候将多个数据类型放在一行 则回报错
# 解决思路
# 1 将数据用dumps一个一个的字符串后边+/n就做到了换行 然后在写入文件
# 2 然后在用for循环在一行一行的读出来，然后去空格 在load出来
# 3 这样就避开了dump和load
# f1=open('fff','r',encoding='utf8')
# ret=json.load(f1)
# f1.close()
# print(type(ret),ret)
2 pickle
# 方法 dumps dump（序列化，存） loads（反序列化，读） load
#pickle不仅可以序列化字典，列表，可以把python中的任意的数据类型序列化
import pickle
#
# dict_pickle={'k1':'v1','k2':'v2','k3':'v3'}
# str_dictp=pickle.dumps(dict_pickle)
# print(str_dictp) #返回的是二进制 所以和json中的dump不同之处就在于返回值类型不同
#
# dict_pickle01=pickle.loads(str_dictp)
# print(dict_pickle01) #字典
#
# import time
# struct_time=time.localtime(20000000000)
# print(struct_time)
# f=open('pickle_file','wb')
# pickle.dump(struct_time,f)
# f.close()
#
# f1=open('pickle_file','rb')
# struct_time2=pickle.load(f1)
# print(struct_time2.tm_year)
3 shelve 只提供一个open方法，用key来访问，类似字典。此模块有限制，不支持多个应用同一时间往同一个DB(实际上就是shelve文件)进行写操作。
'''
shelve 只提供一个open（）方法，用key来访问，类似字典
此模块有限制，不支持多个应用同一时间往同一个DB(实际上就是shelve文件)进行写操作。
如果应用如果值进行读操作，可以让shelve通过只读方式打开DB
即使是以读的形式打开，也可以直接可以修改 flag=‘r’执行只读 --->f=shelve.open(filename,flag='r')
由于shelve在默认情况下是不会记录 待持久化对象的任何修改的，
所以我们在shelve.open()时候需要修改默认参数，否则对象的修改不会保存
'''
import shelve
#存数据
# f1=shelve.open('shelve_file')
# #直接对文件句柄操作，就可以存入
# f1['key']={'int':10,'float':45.21,'str':'yuan'}
# print(dict(f1))
# f1.close()
#
#
# #读取数 取出数据的时候也只需要直接用key获取即可，但是如果key不存在则会报错
# f2=shelve.open('shelve_file')
# ret=f2['key']
# f2.close()
# print(ret)
#即使是以读的形式打开，也可以直接可以修改 flag=‘r’执行只读 --->f=shelve.open(filename,flag='r')
# f=shelve.open('shelve_file01',flag='r')
# f['key']=10
# exising=f['key']
# print(exising)
# f['key']=50
# f.close()
#
# f1=shelve.open('shelve_file01',flag='r')
# existing01=f1['key']
# print(existing01)
# f1.close()
# 由于shelve在默认情况下是不会记录
# 待持久化对象的任何修改的，
# 所以我们在shelve.open()
# 时候需要修改默认参数，否则对象的修改不会保存 writeback=True
# f1=shelve.open('shelve_file03')
# f1['k1']={'value':123,'new_value':'one'}
# print(f1['k1'])
# f1['k1']['new_value']='first'
# print(f1['k1'])
# f1.close()
#shelve.open(filename,writeback=True )
# f2=shelve.open('shelev_file04',writeback=True)
# f2['k1']={'value':123,'new_value':'one'}
# print(f2['k1'])
# f2['k1']['new_value']='first'
# print(f2['k1'])
# f2.close()
7 re模块：
'''
模块
re模块
正则表达式------字符串匹配
正则表达式本身也和python没有什么关系 就是匹配字符串内容的一种规则
官方定义
正则表达式是对字符串操作的一种逻辑公式，
就是用事先定义好的一些特定字符，及这些特定字符的组合
，组成一个 ‘规则字符串’，这个‘规则字符串’用来表达对字符串一种过滤逻辑
正则字符组 [字符组]
在同一个位置可能出现的各种字符组成了一个字符组，
在正则表达式中用[]表示
字符分为很多累，比如数字，字母，标点等等
元字符：
1 . 匹配除换行符以外的任意字符
2 \w 匹配字母或数字或下划线
3 \s 匹配任意的空白符
4 \d 匹配数字
5 \n 匹配一个换行符
6 \t 匹配一个制表符tab
7 \b 匹配一个单词的结尾
8 ^ 匹配一个字符串的开始
9 $ 匹配一个字符串的结束
10 \W 匹配非字母或数字或下划线
11 \D 匹配非数字
12 \S 匹配非空白符
13 a|b 或 a或则b
14 () 匹配括号内的表达式，也表示一个组
15 [..] 匹配字符组中的字符
16[^..] 匹配除字符组中字符的所有字符
量词 用来约束元字符
1 * 重复0次或更多次
2 + 重复一次或更多次
3 ？ 重复0次或一次
4{n} 重复n次
5{n，} 重复n次或更多次
6{n,m} 重复n到m次
()分组与 或 | 组合使用的时候要注意将长的放在前边
可以将多个元字符放入一组
后边在加量词可以约束组内的所有字节
贪婪匹配和费贪婪匹配
1 贪婪匹配：在满足匹配时，匹配尽可能长的字符串，默认情况下采用贪婪
2 非贪婪：在满足匹配时，匹配尽可能少的字符串
几个常用的非贪婪匹配Pattern
*? 重复任意次，但尽可能少重复
+? 重复1次或更多次，但尽可能少重复
?? 重复0次或1次，但尽可能少重复
{n,m}? 重复n到m次，但尽可能少重复
{n,}? 重复n次以上，但尽可能少重复
'''
import re
# findall 返回所有满足匹配条件的结果 放在列表里
# ret01=re.findall('[a-z]+','eva egon yuan')
# ret01a=re.findall('a','eva egon yuan')
# print(ret01,ret01a)
# # search
# # 从前往后走，找到一个就返回，返回的变量需要调用group才能拿到结果
# # 如果没有找到，那么就返回None 调用group回报错
# ret02=re.search('a','eva egon yuan').group()
# print(ret02)
# # match
# # 必须从头开始匹配，如果正则规则从头开始可以匹配上，就返回一个变量
# # 匹配的内容需要用group才能显示
# #如果没有匹配上，就返回None 调用group回报错
# ret03=re.match('ev','eva egon yuan').group()
# print(ret03)
# #split分割
# #先按照a分割得到bcd，再按照b分割得到cd
# ret04=re.split('[ab]','abcd')
# print(ret04)
#
# #sub
# #将数字替换成H 参数2 代表替换了几次
# ret05=re.sub('\d','H','eva3egon4yuan5',2)
# print(ret05)
#
# #subn
# #将数字替换成H，返回元组，返回内容是（替换的结果，替换了几次）
# ret06=re.subn('\d','H','eva3egon4yuan5')
# print(ret06)
# #
# #compile 将正则表达式编译成一个正则表达式对象
# 应用场景 正则较长 且经常使用
# obj=re.compile('\d{3}')
# ret07=obj.search('abc123ccc')
# print(ret07.group())
# ret071=obj.search('abc456cccsadf1')
# print(ret071.group())
#finditer
#finditer 返回一个存放匹配结果的迭代器
#
# ret08=re.finditer('\d','dsf1dsf1e41gb1')
# print(ret08) #迭代器内存地址
# # # # print(next(ret08).group()) #取第一个值
# # # # print(next(ret08).group()) #取第二个值
# # print([i.group() for i in ret08])#列表推倒式
#
# for i in ret08:
# print(i.group())
# 控制分组 可根据group的参数取回下标对应分组的值 下边例子就有2个分组
# import re
# ret=re.search('[1-9](?P<id>\d{14})(\d{2}[0-9x])?$','412702199002027515')
# print(ret.group())
# print(ret.group('id'))
# print(ret.group(1))
# print(ret.group(2))
#分组优先 findall的优先级查询
# ret09=re.findall('www.(baidu|jd).com','www.baidu.com')
# print(ret09)# 只返回['baidu'] 因为findall会优先把匹配结果 组内里的内容优先返回
# # 取消分组优先 在分组内 起始位置加入？ 取消分组优先
# ret09a=re.findall('www.(?:baidu|jd).com','www.baidu.com')
# print(ret09a)
#
#
# #分组优先 split的优先级查询
# ret10=re.split("\d+","eva3egon4yuan")
# print(ret10) #结果 ： ['eva', 'egon', 'yuan']
#
#
# #如果在正则上加上分组 会保留正则匹配的结果
# ret11=re.split("(\d+)","eva3egon4yuan")
# print(ret11) #结果 ： ['eva', '3', 'egon', '4', 'yuan']
#在匹配部分加上（）之后所切出的结果是不同的，
#没有（）的没有保留所匹配的项，但是有（）的却能够保留了匹配的项，
#这个在某些需要保留匹配部分的使用过程是非常重要的。
#引用分组 前后需要一样
# ret12=re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>helloword</h1>")#(?P=tag_name) 意思是引用前边分组名字且内容一致
# ret12a=re.search("<(?P<tag_name>\w+)>\w+</\1>","<h1>helloword</h1>")# </\1> 中的\1意思是引用第一组的内容，且前后内容一致
# print(ret12.group())
# print(ret12a.group(1))
# print(ret12.group('tag_name'))
ret13=re.findall(r"\d+\d.\d+|(\d+)","1-2*(60+(-40.35/5))-(-4*3)")
print(ret13)
ret13.remove('')
print(ret13)
