在内置数据类型（dict、list、set、tuple）的基础上，collections模块还提供了几个额外的数据类型：Counter、deque、defaultdict、namedtuple和OrderedDict等。
1：namedtuple：生成可以使用名字来访问元素内容的tuple。
2：deque：双端队列，可以快速的从另外一侧追加和退出对象。
3：Counter：计数器，主要用来计数。
4：OrderedDict：有序字典
5：defaultdict：带有默认值的字典
例：表示坐标点的x和y
from collections import namedtuple
point = namedtuple('坐标',['x','y'])
point1 = namedtuple('坐标','x y')
p = point(9,9)
p1 = point1(9,9)
print(p)# 坐标(x=9, y=9)
# 坐标(x=9, y=9)用具名元组来记录一个城市的信息
from collections import namedtuple
Country = namedtuple('中国','name city')
c = Country('广西','桂林')
print(c)# 中国(name='广西', person='桂林')from collections import deque
q = deque(['a','b','c'])
q.append(1) #
q.appendleft(3)
print(q)
q.insert(2,'插队') # 可以通过 insert 进行索引插入元素
print(q)# deque([3, 'a', 'b', 'c', 1])
# deque([3, 'a', '插队', 'b', 'c', 1])from collections import Counter
s = Counter('aaasdsdsddddddsad')
print(s)# Counter({'d': 9, 'a': 4, 's': 4})from collections import OrderedDict
d = dict([('a',1),('b',2),('c',3)])
print(d) # dict 的 key 是无序的
od = OrderedDict([('b',2),('c',3),('a',1)])
print(od) # OrderedDict 的 key 是有序的# {'a': 1, 'b': 2, 'c': 3}
# OrderedDict([('b', 2), ('c', 3), ('a', 1)])注意：OrderedDict 的 key 会按照插入的顺序排序，不是 key 本身的排序
有如下值集合 [11,22,33,44,55,66,77,88,,99,90..]，将所有大于 66的值保存至字典的第一个key中，将小于 66的值保存至第二个key的值中。
即： {‘k1‘: 大于66, ‘k2‘: 小于66}
values = [11,22,33,44,55,66,77,88,99,90]
dic = {}
for i in values:
if i > 66:
if 'k1' not in dic:
dic['k1'] = []
dic['k1'].append(i)
else:
if 'k2' not in dic:
dic['k2'] = []
dic['k2'].append(i)
print(dic)# {'k2': [11, 22, 33, 44, 55, 66], 'k1': [77, 88, 99, 90]}from collections import defaultdict
values = [11,22,33,44,55,66,77,88,99,90]
dic = defaultdict(list)
for i in values:
if i > 66:
dic['k1'].append(i)
else:
dic['k2'].append(i)
print(dic)# defaultdict(<class 'list'>, {'k2': [11, 22, 33, 44, 55, 66], 'k1': [77, 88, 99, 90]})在Python中，通常有这三种方式来表示时间：时间戳、元组(struct_time)、格式化的时间字符串：
(1)时间戳(timestamp) ：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。
(2)格式化的时间字符串(Format String)： ‘1999-12-06’
%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)元组(struct_time) ：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等）
import time
print(time.time()) # 时间戳
# 1563442062.862509
print(time.strftime('%Y-%m-%d %X')) # 格式化时间
# 2019-07-18 17:29:46
print(time.strftime('%Y-%m-%d %H-%M-%S'))
# 2019-07-18 17-29-46
print(time.localtime()) # 结构化时间
# time.struct_time(tm_year=2019, tm_mon=7, tm_mday=18, tm_hour=17, tm_min=30, tm_sec=52, tm_wday=3, tm_yday=199, tm_isdst=0)
import time
# 时间戳转换结构化时间
res = time.time()
print(time.gmtime(res))
print(time.localtime(res))
# time.struct_time(tm_year=2019, tm_mon=7, tm_mday=18, tm_hour=18, tm_min=34, tm_sec=8, tm_wday=3, tm_yday=199, tm_isdst=0)
# time.struct_time(tm_year=2019, tm_mon=7, tm_mday=18, tm_hour=18, tm_min=34, tm_sec=8, tm_wday=3, tm_yday=199, tm_isdst=0)
# 结构化时间转换时间戳
res = time.localtime()
print(time.mktime(res))
# 1563446202.0import time
# 结构化时间转换格式化时间
res = time.localtime()
print(time.strftime('%Y-%m-%d',res))
# 2019-07-18
# 格式化时间转换结构化时间
res = time.strftime('%Y-%m-%d %X')
print(time.strptime(res,'%Y-%m-%d %X'))
# time.struct_time(tm_year=2019, tm_mon=7, tm_mday=18, tm_hour=18, tm_min=46, tm_sec=37, tm_wday=3, tm_yday=199, tm_isdst=-1)import datetime
# 自定义时间
res = datetime.date(2019,7,18)
print(res)
# 2019-07-18
# 获取本地时间
print(datetime.date.today)
res = datetime.datetime.today()
print(res)
# 2019-07-18
# 2019-07-18 18:52:39.687587
# 无论是年月日，还是年月日时分秒对象都可以调用以下方法获取针对性的数据
# 以上面的 res 举例
print(res.year) # 获取年份
print(res.month) # 获取月份
print(res.day) # 获取日
print(res.weekday()) # 获取星期 0表示周一
print(res.isoweekday()) # 获取星期 1表示周一
# 2019
# 7
# 18
# 3
# 4
# timedelta 对象
today = datetime.date.today()
tdelta = datetime.timedelta(days=3)
print(f'今天日期{today}')
print(f'从今天向后推3天:{today+tdelta}')
# 今天日期2019-07-18
# 从今天向后推3天:2019-07-21日期对象 = 日期对象 +/- timedelta
timedelta 对象 = 日期对象 +/- 日期对象
验证：
import datetime
now_date = datetime.date.today()
day = datetime.timedelta(days=7)
now_date1 = now_date+day # 日期对象 = 日期对象 +/- timedelta
print(type(now_date))
day1 = now_date1 - now_date # timedelta 对象 = 日期对象 +/- 日期对象
print(day1)# <class 'datetime.date'>
# 7 days, 0:00:00import random
# 随机小数
random.random() # 大于0且小于1之间的小数
# 0.6860937326862173
random.uniform(1,3) # 大于1小于3直接的小数
# 2.3627834021598133
# 随机整数
random.randint(1,5) # 大于等于1小于等于5之间的整数
# 1
random.randrange(1,10,2) # 大于等于1小于10之间的奇数
# 7
# 随机返回一个
random.choice([1,'23',[1,2,3]]) # 1或者23或者[1,2,3]
# 23
# 随机返回多个
random.sample([1,2,3,'23',[4,5,6]],3) # 列表中任意3个元素的组合
# [3, 1, [4, 5, 6]]
# 打乱列表顺序
l = [1,2,3,4,5]
random.shuffle(l) # 打乱次序
print(l)
# [4, 5, 3, 1, 2]随机生成验证码
def get_code(n):
code = ''
for i in range(n):
num = str(random.randint(0,9))
upper_letter = chr(random.randint(65,90))
lower_letter = chr(random.randint(97,122))
code += random.choice([num,upper_letter,lower_letter])
return code
res = get_code(6)
print(res)# okULb3os 模块是与操作系统交互的一个接口
import os
os.mkdir('文件夹名') # 自动创建文件夹
print(os.path.exists(r'文件路径')) # 判断文件是否存在
print(os.path.exists(r'文件夹路径')) # 判断文件夹是否存在
print(os.path.isfile(r'文件路径')) # 只能判断文件是否存在，不能判断文件夹
os.rmdir(r'文件夹路径') # 只删除空文件夹
print(os.getcwd()) # 获取当前文件所在的文件夹路径
print(os.chdir(r'另一个文件夹的路径')) # 切换当前所在的目录
print(os.getcwd())
print(os.path.getsize(r'文件夹或文件路径')) # 获取文件大小sys 模块是与 python 解释器交互的一个接口
import sys
sys.path.append('路径') # 将某个路径添加到系统的环境变量中
print(sys.platform) # 返回操作系统的名称
print(sys.version) # 获取 python 解释器的版本序列：字符串
序列化：将其它数据类型转换成字符串的过程。
反序列化：字符串转成其它数据类型。
序列化的目的
1：以某种存储形式使用自定义对象持久化。
2：将对象从一个地方传递到另一个地方。
3：是程序更具有维护性。
用于序列化的两个模块
json，用于字符串和 python 数据类型间进行转换。
pickle，用于 python 特有的数据类型和 python 的数据类型进行转换。
注意：pickle 仅用于 python
# dumps 和 loads
import json
dic = {'a':1,'b':2,'c':3}
res = json.dumps(dic) # 序列化：将一个字典转换成一个字符串
print(res,type(res))
# {"a": 1, "b": 2, "c": 3} <class 'str'>
res1 = json.loads(res) # 反序列化：将一个字符串格式的字典转换成一个字典
# 注意：要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示。
print(res1,type(res1))
# {'a': 1, 'b': 2, 'c': 3} <class 'dict'>
# 也可处理嵌套的数据类型
lis = [1,2,['a','b','c'],3,{'k1':'a','k2':'b','k3':'c'}]
res = json.dumps(lis)
print(res)
# [1, 2, ["a", "b", "c"], 3, {"k1": "a", "k2": "b", "k3": "c"}]
res1 = json.loads(res)
print(res1)
# [1, 2, ['a', 'b', 'c'], 3, {'k1': 'a', 'k2': 'b', 'k3': 'c'}]# dump 和 load
import json
dic = {'name':'zkim','age':18,'hobby':'running'}
with open('user_info','w',encoding='utf-8')as f:
json.dump(dic,f)
# dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件
with open('user_info','r',encoding='utf-8')as f:
res = json.load(f)
print(res)
# load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回import pickle
# dumps 和 loads
dic = {'name':'zkim','hobby':'running'}
str_dic = pickle.dumps(dic)
print(str_dic) # 一串二进制
str_dic1 = pickle.loads(str_dic)
print(str_dic1)
# {'name': 'zkim', 'hobby': 'running'}
# dump 和 load
with open('userinfo.txt','wb')as f:
pickle.dump(dic,f)
with open('userinfo.txt','rb')as f:
res = pickle.load(f)
print(res)
# {'name': 'zkim', 'hobby': 'running'}原文：https://www.cnblogs.com/jincoco/p/11210771.html