一、collections模块
1.具名元组：namedtuple(生成可以使用名字来访问元素的tuple)
表示坐标点x为1 y为2的坐标
注意：第二个参数可以传可迭代对象，也可以传字符串，但是字符串要隔开
from collections import namedtuple point1 = namedtuple('坐标',['x','y','z']) # 第二个参数既可以传可迭代对象 point = namedtuple('坐标','x y z') # 也可以传字符串 但是字符串之间以空格隔开 p = point(1,2,5) # 注意元素的个数必须跟namedtuple第二个参数里面的值数量一致 print(p) #坐标(x=1, y=2, z=5) print(p.x) #1 print(p.y) #2 print(p.z) #5
2.双端队列:deque(可以快速的从另外一侧追加和推出对象)
队列不应该支持任意位置插值，只能在首尾插值（不能插队）
from collections import deque q = deque(['a','b','c']) #生成一个列表的双端队列 q.append(1) #在列表末端插入数字1 q.appendleft(2) #在列表左端插入数字2 print(q.pop()) #删掉列表末尾的元素，返回数字1 print(q.popleft())#删掉列表左端的元素，返回数字2 #结果 1 2
虽然说不能插队，但是双端队列有个特殊点：insert可以根据索引在任意位置插值。
q.insert(0,'哈哈哈') # 特殊点:双端队列可以根据索引在任意位置插值 #在索引位置为0的地方插入字符串 ‘哈哈哈’
3.Counter:计数器，主要用来计数
Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式储存，其中元素作为key，其计数作为value.
from collections import Counter s = 'abcdeabcdabcaba' res = Counter(s) print(res) #Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})
4.OrderedDict:有序字典
使用dict时，key是无序的。在对dict做迭代时，我们无法确定key的顺序。如果要保持key的顺序，可以用OrderedDict
>>> from collections import OrderedDict >>> d = dict([('a', 1), ('b', 2), ('c', 3)]) >>> d # dict的Key是无序的 {'a': 1, 'c': 3, 'b': 2} >>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)]) >>> od # OrderedDict的Key是有序的 OrderedDict([('a', 1), ('b', 2), ('c', 3)])
注意：OrderedDict的key会按照插入的顺序排列，不是key本身排序
>>> od = OrderedDict() >>> od['z'] = 1 >>> od['y'] = 2 >>> od['x'] = 3 >>> od.keys() # 按照插入的Key的顺序返回 ['z', 'y', 'x']
5.defaultdict:带有默认值的字典
from collections import defaultdict values = [11, 22, 33,44,55,66,77,88,99,90] my_dict = defaultdict(list) # 后续该字典中新建的key对应的value默认就是列表 for value in values: if value>66: my_dict['k1'].append(value) else: my_dict['k2'].append(value) print(my_dict) #defaultdict(<class 'list'>, {'k2': [11, 22, 33, 44, 55, 66], 'k1': [77, 88, 99, 90]})
二、时间模块 time/datatime
time
三种表现形式：
1.时间戳
2.格式化时间（用来展示给人看的）
3.结构化时间
import time #时间戳 print(time.time()) #1563440824.5854228 #格式化时间（这个用的更多） print(time.strftime('%Y-%m-%d')) #2019-07-18 print(time.strftime('%Y-%m-%d %H:%M:%S')) #2019-07-18 17:07:04 月份和日期是用小写，其他都是大写 print(time.strftime('%Y-%m-%d %X')) # %X等价于%H:%M:%S print(time.strftime('%H:%M')) print(time.strftime('%Y/%m')) #结构化时间 print(time.localtime()) #time.struct_time(tm_year=2019, tm_mon=7, tm_mday=18, tm_hour=17, tm_min=7, tm_sec=4, tm_wday=3, tm_yday=199, tm_isdst=0)
三种格式之间的转换：
1.时间戳>>>结构化时间：
time.localtime(time.time()) #返回的是当地时间的结构化时间
time.gmtime(time.time()) #返回的是UTC时间，与英国伦敦当地时间一致
2.结构化时间>>>时间戳
time.mktime(time.localtime())
>>>time_tuple = time.localtime(1500000000) >>>time.mktime(time_tuple) 1500000000.0
3.结构化时间>>>格式化时间
#time.strftime("格式定义","结构化时间") 结构化时间参数若不传，则显示当前时间 >>>time.strftime("%Y-%m-%d %X") '2017-07-24 14:55:36' >>>time.strftime("%Y-%m-%d",time.localtime(1500000000)) '2017-07-14'
4.结构化时间>>>格式化时间:
#time.strptime(时间字符串,字符串对应格式) >>>time.strptime("2017-03-16","%Y-%m-%d") time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1) >>>time.strptime("07/24/2017","%m/%d/%Y") time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1)
datatime
import datetime print(datetime.date.today()) # date>>>:年月日 #2019-07-18 print(datetime.datetime.today()) # datetime>>>:年月日 时分秒 #2019-07-18 17:26:54.507152 res = datetime.date.today() res1 = datetime.datetime.today() print(res.year) #显示年份 2019 print(res.month) #显示月份 7 print(res.day) #显示日期 18 print(res.weekday()) # 0-6表示星期 0表示周一 #3 print(res.isoweekday()) # 1-7表示星期 7就是周日 #4
timedelta对象
""" (******) 日期对象 = 日期对象 +/- timedelta对象 timedelta对象 = 日期对象 +/- 日期对象 """ current_time = datetime.date.today() # 日期对象 timetel_t = datetime.timedelta(days=7) # timedelta对象 res1 = current_time+timetel_t # 日期对象 print(current_time - timetel_t) print(res1-current_time)
三、random模块 随机选择
randint/random/choice
print(random.randint(1,6)) # 随机取一个你提供的整数范围内的数字 包含首尾 print(random.random()) # 随机取0-1之间小数 print(random.choice([1,2,3,4,5,6])) # 摇号 随机从列表中取一个元素 里面可以是元组也可以是列表
res = [1,2,3,4,5,6]
random.shuffle(res) # 洗牌
print(res)
生成一个五位随机数的验证码
#生成一个五位数的验证码，每个数字可以是数字、大写字母(65,90)、小写字母(97,122) def get_num(n): code = '' for i in range(n): #生成大写字母 upper_str = chr(random.randint(65,90)) #生成小写字母 lower_str = chr(random.randint(97,122)) #生成数字 num = str(random.randint(0,9)) #随机从这三个中抽取一个 code += random.choice([upper_str,lower_str,num]) return code print(get_num(5))
四、os模块 跟操作系统打交道的模块
os.path.dirname(__filr__) 查看当前文件的目录(文件夹)
和 os.getcwd一样
import os BASE_DIR = os.path.dirname(__file__) #返回当前文件的目录(文件夹) now_file = os.getcwd() #返回当前文件的目录(文件夹) print(now_file) print(BASE_DIR)
os.listdir('dirname') 查看指定目录(文件夹)下的所有文件和子目录，包括隐藏文件,结果返回的是一个列表
MOVIE_DIR = os.path.join(BASE_DIR,'老师们的作品') movie_list = os.listdir(MOVIE_DIR) print(movie_list)
os.path.join(path1,path2) 路径的拼接
MOVIE_DIR = os.path.join(BASE_DIR,'老师们的作品')
os.mkdir('dirname') 自动创建文件夹
os.path.exists('dirname') 判断文件是否存在（包括文件和文件夹）
os.path.isfile('dirname') 判断文件是否存在（只能判断文件）
os.rmdir('dirname') 删除文件夹（但是只能删除空文件夹）
os.chdir('dirname') 切换当前所在的目录
os.path.getsize('dirname') 获取文件大小（字节大小）
五、sys模块 跟python解释器打交道的模块
sys.path 返回的是一个列表：包括当前文件的文件夹和根目录还有一些其他python解释器的路径
sys.path.append('dirname') 将某个路径添加到系统的环境变量
sys.version python解释器的版本
sys.platform 返回操作系统的名称
六、序列化模块（json模块） 将原本的字典、列表等内容转换成一个字符串的过程就叫做序列化
写入的文件数据必须是字符串，基于网络传输的数据也必须是二进制数据，所以我们要把其他类型的数据都转换成字符串类型才好存储，更好的跨平台使用，所以要用到json模块。
包括序列化和反序列化：
序列化是：把其他类型的数据转换成字符串的过程
反序列化是：把字符串转化成其他数据类型
json模块
所有的语言都支持json格式
但是支持的数据类型很少：字符串 、列表 、字典、整型、元组（转成列表）、布尔值
pickle模块
只支持python
python所有的数据类型都支持
（重点！！！！！！）
dumps:序列化：将其他数据类型转成json格式的字符串
loads:反序列化：将json格式的字符串转换成其他数据类型
dump:文件的序列化
load:文件的反序列化
json格式的字符串 必须是双引号
d = {'name':'jason'}
res = json.dumps(d) # json格式的字符串 必须是双引号 >>>: '{"name": "jason"}'
print(res,type(res)) #{"name": "jason"} <class 'str'>
res1 = json.loads(res)
print(res1,type(res1))
#{'name': 'jason'} <class 'dict'>
json.dumps之后的数据全部都是字符串类型
import json res = json.dumps((1,2,3)) res1 = json.dumps([1,2,3]) res2 = json.dumps(True) print(res,type(res)) #[1, 2, 3] <class 'str'> print(res1,type(res1)) #[1, 2, 3] <class 'str'> print(res2,type(res2)) #true <class 'str'>
json.dump/json.load 在文件中操作
json.dump() 参数先写入数据，再是文件
json.load() 参数只要写文件就可以
d = {"name":"jason"}
with open('userinfo','w',encoding='utf-8') as f:
json.dump(d,f) # 装字符串并自动写入文件
with open('userinfo','r',encoding='utf-8') as f:
res = json.load(f)
print(res,type(res)) #{'name': 'jason'} <class 'dict'>
ensure_ascii关键字参数
d1 = {'name':'朱志坚'}
print(json.dumps(d1)) #{"name": "\u6731\u5fd7\u575a"}
#如果转换的数据里面有中文，需要加ensure_ascii=False，不然就会是二进制字符
d1 = {'name':'朱志坚'}
print(json.dumps(d1,ensure_ascii=False))
pickle模块 也有dumps/loads/dump/load,用法和json模块也是一样的
但是pickle.dumps返回的是一个二进制
import pickle d = {'name':'jason'} res = pickle.dumps(d) # 将对象直接转成二进制 print(pickle.dumps(d)) #b'\x80\x03}q\x00X\x04\x00\x00\x00nameq\x01X\x05\x00\x00\x00jasonq\x02s.' res1 = pickle.loads(res) print(res1,type(res1)) #{'name': 'jason'} <class 'dict'>
用pickle操作文件的时候 文件的打开模式必须是b模式
with open('userinfo_1','wb') as f: pickle.dump(d,f) with open('userinfo_1','rb') as f: res = pickle.load(f) print(res,type(res)) #{'name': 'jason'} <class 'dict'>
七、subprocess模块
sub:子
process:进程
1.用户通过网络连接上了你的这台电脑
2.用户输入相应的命令 基于网络发送给了你这台电脑上某个程序
3.获取用户命令 里面subprocess执行该用户命令
4.将执行结果再基于网络发送给用户
这样就实现 用户远程操作你这台电脑的操作