collections,time,random,os,sys,序列化模块(json和pickle)应用

一、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(__file__)    查看当前文件的目录(文件夹)

　　和 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和pickle总结:

json序列化（json.dumps）：把其他类型的数据（包括字符串）转成json格式的字符串

json反序列化（json.loads）:把json格式的字符串转化成其他格式数据类型

pickle序列化之后是一个二进制数据格式（bytes类型），所以它的读写模式必须是b模式

　　写入的文件数据必须是字符串，基于网络传输的数据也必须是二进制数据，所以我们要把其他类型的数据都转换成字符串类型才好存储，更好的跨平台使用，所以要用到json模块。

　　json模块

　　　　所有的语言都支持json格式

　　　　但是支持的python数据类型很少：字符串 、列表 、字典、整型、元组（转成列表）、布尔值

　　pickle模块

　　　　只支持python

　　　　python所有的数据类型都支持

注意（重点！！！！！！）

dumps:序列化：将其他数据类型转成json格式的字符串

loads:反序列化：将json格式的字符串转换成其他数据类型

dump:文件的序列化,两个参数:第一个是写入的数据，第二个是接收一个文件对象  f

load:文件的反序列化，接收一个文件对象 f

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序列化之后的数据全部都是json格式字符串

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()   参数先写入数据，再是文件对象 f

json.load()   参数只要文件对象 f 就可以

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": "u6731u5fd7u575a"}

#如果转换的数据里面有中文，需要加ensure_ascii=False，不然就会是二进制字符
d1 = {'name':'朱志坚'}
print(json.dumps(d1,ensure_ascii=False))

pickle模块   也有dumps/loads/dump/load,用法和json模块也是一样的

但是pickle.dumps返回的是一个二进制数据（bytes类型）

import pickle
d = {'name':'jason'}
res = pickle.dumps(d)  # 将对象直接转成二进制
print(pickle.dumps(d))   #b'x80x03}qx00Xx04x00x00x00nameqx01Xx05x00x00x00jasonqx02s.'
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.将执行结果再基于网络发送给用户
这样就实现  用户远程操作你这台电脑的操作