一、collections模块

1.namedtuple(具名元组)

具有名字的元组

例题1

表示坐标x为1，y为2，z为3的坐标

from collections import namedtuple
point = namedtuple('坐标',['x','y','z'])  # 第二个参数可以传可迭代对象
#point = namedtuple('坐标','x y z')  # 也可以传字符串 字符串之间用逗号隔开
p = point(1,2,3)  # 元素个数必须和namedtuple第二个参数里的数量一致
print(p)  # 坐标(x=1, y=2, z=3)
print(p.x)  # 1
print(p.y)  # 2
print(p.z)  # 3

例题2

用具有元组名来表示扑克牌的花色与大小
from collections import namedtuple
card = namedtuple('扑克牌','color number')
p = card('♠','A')
print(p)  # 扑克牌(color='♠', number='A')
print(p.color)  # ♠
print(p.number)  #A

2.deque(双端队列)

定义：可以快速的从另外一侧追加和推出对象

首先，之前了解过队列，队列就是先进先出(FIFO first in first out)

队列

import queue
q = queue.Queue()  # 生成队列对象
q.put('first')  # 往队列中添加值
q.put('second')
q.put('third')

print(q.get())  # first # 朝队列要值
print(q.get())  # second
print(q.get())  # third
print(q.get())  # 如果队列中的值取完了 程序会在原地等待 直到从队列中拿到值才停止

deque 双端队列

注意

1.队列不支持在任意位置插值，只能在首尾插值

2.双端队列可以利用insert根据索引在任意位置插值

from collections import deque
q = deque(['a','b','c'])  # 生成双端队列对象
q.append(1)  # 在尾部添加数字1
q.appendleft(2)  # 在左边添加数字2
print(q)  # 打印结果：deque([2, 'a', 'b', 'c', 1])

q.pop()  # 在添加之后的基础上取出尾部
q.popleft()  # 在添加之后的基础上取出头部
print(q)  # 打印结果：deque(['a', 'b', 'c'])



from collections import deque
q = deque(['a','b','c'])  # 生成双端队列对象
q.insert(1,2)  # insert可以根据索引在任意位置插值
print(q)  # 打印结果：deque(['a', 2, 'b', 'c'])

3.OrderedDict(有序字典)

使用dict时，key时无序的。在对dict做迭代时，我们无法确定key的顺序。

如果需要保持key的顺序，可以用OrderDict

首先定义一个字典：

建议在python2中实现，效果会更加明显

>>> d = dict([('a',1),('b',2),('c',3)])
>>> print(d)
{'a': 1, 'b': 2, 'c': 3}  # 字典无序
>>>
>>> from collections import OrderedDict
>>> od = OrderedDict([('a',1),('b',2),('c',3)])
>>> print(od)
OrderedDict([('a', 1), ('b', 2), ('c', 3)])  # 字典有序
>>>

定义一个空列表，效果会更加明显
>>> order_d1 = dict()
>>> order_d1['x'] = 1
>>> order_d1['y'] = 2
>>> order_d1['z'] = 3
>>> print(order_d1)
{'y': 2, 'x': 1, 'z': 3}
>>> for i in order_d1:
...     print(i)
...
y
x
z
>>>  #字典无序



>>> from collections import OrderedDict
>>> order_d1 = OrderedDict()
>>> order_d1['x'] = 1
>>> order_d1['y'] = 2
>>> order_d1['z'] = 3
>>> print(order_d1)
OrderedDict([('x', 1), ('y', 2), ('z', 3)])
>>> for i in order_d1:
...     print(i)
...
x
y
z
>>>  # 字典有序

4.defaultdict(带有默认值的字典)

有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。

即： {'k1': 大于66 , 'k2': 小于66}

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]})

5.Counter(计数器)

Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。计数值可以是任意的Interger（包括0和负数）。Counter类和其他语言的bags或multisets很相似。

s = 'abcdeabcdabcaba'
res = Counter(s)
print(res)  # Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})

二、时间模块

1.time

三种表现形式：

1.时间戳(timestamp)

2.格式化时间（Format String）

3.结构化时间(struct_time)

1.>时间戳

通常来说，时间戳表示的是从1970年1月1日00：00:00开始按秒计算的偏移量.

import time  
print(time.time())  # 1563447675.0913758  

 距离1970年1月1日00:00:00的时间（按秒计算）

2.>格式化时间

import time
print(time.strftime('%Y-%m-%d'))  # 2019-07-18
print(time.strftime('%Y-%m-%d %H-%M-%S'))  # 2019-07-18 19-10-04
print(time.strftime('%Y-%m-%d %X'))  # 2019-07-18 19:11:18

#print(time.strftime('%Y-%m-%d %H-%M-%S')) 等价于 print(time.strftime('%Y-%m-%d %X'))

格式化时间字符串（Format String）

%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）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身

格式化的时间字符串

3.结构化时间

localtime将一个时间戳转换为当前时区的struct_time

import time
print(time.localtime())
print(time.localtime(time.time()))
print(time.strftime('%Y-%m',time.localtime()))

小结：时间戳是计算机能够识别的时间；时间字符串是人能够看懂的时间；元组则是用来操作时间的

4.三种格式之间的转换

5.常用方法

1.time.sleep(secs)
(线程)推迟指定的时间运行。单位为秒。
2.time.time()
获取当前时间戳

2.datetime

import datetime

print(datetime.date.today())  # date:年月日

print(datetime.datetime.today())  # datetime:年月日 时分秒

本地日期


import datetime
res = datetime.date.today()
print(res.year)  # 2019年
print(res.month)  # 7月
print(res.day)  # 18日
print(res.weekday())  # 0-6表示星期  0表示周一
print(res.isoweekday())  # 1-7表示星期 7就是周日

时间的运算操作

current_time = datetime.date.today()  # 日期对象

timetel_t = datetime.timedelta(days=7)  # timedelta对象

res1 = current_time+timetel_t  # 日期对象


格式：
日期对象 = 日期对象 +/- timedelta对象
timedelta对象 = 日期对象 +/- 日期对象

UTC时间

import datetime
dt_today = datetime.datetime.today()  # 当前时间
dt_now = datetime.datetime.now()  # 当前时间
dt_utcnow = datetime.datetime.utcnow()  # UTC时间（相差8个小时）
print(dt_today)
print(dt_now)
print(dt_utcnow)

三、random模块

1.随机小数

import random

 print(random.random())  # 大于0且小于1之间的小数

 print(random.uniform(1,2))  # 大于1且小于2之间的小数

2.随机整数

import random

print(random.randint(1,5))  # 大于等于1且小于等于5之间的整数
print(random.randrange(1,10,2))  # 大于等于1且小于10之间的奇数

3.随机摇号

import random

 print(random.choice([1,'23',[4,5]]))   #1或者23或者[4,5]

4.练习：

生成随机验证码

import random
def get_code(n):
    code = ''
    for i in range(n):
        # 先生成随机的大写字母 小写字母 数字
        upper_str = chr(random.randint(65,90))
        lower_str = chr(random.randint(97,122))
        random_int = str(random.randint(0,9))
        # 从上面三个中随机选择一个作为随机验证码的某一位
        code += random.choice([upper_str,lower_str,random_int])
    return code
res = get_code(4)
print(res)

View Code

四、OS模块

os模块是与操作系统交互的一个接口

1.os.listdir

os.listdir('dirname') 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表的方式打印

2.os.mkdir('dirname')

os.mkdir('dirname') 自动创建文件夹

3.os.rmdir

os.rmdir('dirname') 只删除空文件夹，若不是空文件夹则无法删除，会报错

4.os.path

os.path.exists 判断文件是否存在

os.path.isfile 只能判断文件，不能判断文件夹th

os.path.getsize 获取文件大小

5.os.getcwd()

获取当前工作目录

6.os.chdir

os.chdir('dirname') 改变当前工作目录

五、sys模块

sys模块是与python解释器交互的一个接口

import sys

sys.path.append()  # 将某个路径添加到系统的环境变量中

print(sys.platfrom)  # 返回操作系统平台名称

print(sys.version)  # python解释器的版本

print(sys.argv)  # 命令行启动文件  （可以做身份验证）

六、序列化模块

1.序列化:

将其他数据类型转换成字符串的过程叫做序列化.

写入文件的数据必须是字符串

基于网络传输的数据必须是二进制

反序列化：字符串转换成其他数据类型

2.序列化的目的

1.>以某种存储形式使自定义对象持久化

2.>将对象从一个地方传递到另一个地方

3.>是程序更具维护性

3.json模块

所有语言都支持json格式

支持的数据类型很少：字符串，列表，字典，整型，元祖（转成列表）布尔值

dumps和loads

import json
d = {"name":"jason"}
res = json.dumps(d)  # json格式的字符串 必须是双引号'{"name": "jason"}'
print(res,type(res))  # {"name": "jason"} <class 'str'>
res1 = json.loads(res)  # 将json格式的字符串转换成原来的数据类型
print(res1,type(res1))  # {'name': 'jason'} <class 'dict'>

dump和losd

import json
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))  # 可以将字符串读取成原来的数据类型

可以将文件写入两次，但是不能够多次反序列化

4.pickle模块

只支持python

python所有的数据类型都支持