常用模块

collections:

在内置数据类型（int，float，str，dict，list，tuple，set，bool）的基础上，collections模块还提供了几个数据类型:Counter、deque、defaultdict、namedtuple和OrderedDic等

1.namedtuple:生成可以使用名字来访问元素内容的tuple

2.deque：双端队列，可以快速的从另外一侧追加和推出对象

3:.Counter:计数器，主要用来计数

4.OrderedDict：有序字典

5.defaultdict：带有默认值的字典

namedtuple(具名元祖）：

这个就是可以让你的元祖带有名字。

因为一个元祖(1,2)可以用来表示坐标，但如果没有标识谁知道呢。这个时候namedtuple就派上了用场。

from clooections import namedtuple


point = namedtuple('point',['x','y'])或namedtuple('point','x y')
可以为字符串但必须要空格隔开。
p = point(1,2)
print(p)  # point(x=1,y=2)

还可以用具名元祖来记录一个城市的信息

 from collections import namedtuple
City = namedtuple('City', 'name country population coordinates')  # 第一个是类名，第二个是类的各个字段的名字。后者可以是由数个字符串组成的可迭代对象，或者是由空格分隔开的字段名组成的字符串
tokyo = City('Tokyo', 'JP', 36.933, (35.689722, 139.691667)) 
print（tokyo）
City(name='Tokyo', country='JP', population=36.933, coordinates=(35.689722, 139.691667))

 from collections import namedtuple
City = namedtuple('City', 'name country population coordinates')  # 第一个是类名，第二个是类的各个字段的名字。后者可以是由数个字符串组成的可迭代对象，或者是由空格分隔开的字段名组成的字符串
tokyo = City('Tokyo', 'JP', 36.933, (35.689722, 139.691667)) 
print（tokyo）
City(name='Tokyo', country='JP', population=36.933, coordinates=(35.689722, 139.691667))

类似的，如果要坐标和半径表示一个圆，也可以用namedtuple定义

Circle = namedtuple('Circle', ['x', 'y', 'r'])

deque:(双端队列)

队列：先进先出

import queue

q = queue.Queue()

q.put('first')  往队列中添加值

q.get() 往队列中要值

如果队列中的值取完，还get去取，那么程序会在原地等待，直到取到了值才会停止。

deque双端队列

里面有五个用法

append：加在最末尾

appendleft：加在最左边

pop：取末尾的

popleft：取最左边的

insert 插值：插到指定索引，但这样是不符合的队列的规则的。队列不应该支持插队。

OrderedDict有序字典：

使用dict时，key是无序的，在对dict做迭代时，我们无法确定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']

defaultdict有默认值字典：

使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict：

from collections import defaultdict
dd = defaultdict(lambda: 'N/A')
dd['key1'] = 'abc'
dd['key1'] # key1存在
'abc'
dd['key2'] # key2不存在，返回默认值
'N/A'

Counter计数器：

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

c = Counter('abcdeabcdabcaba')

print c  Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})

时间模块time：

time模块的三种表现形式：

1.时间戳(timestamp)：通常来说时间戳表示从1970年1月1日0时0点0分0秒开始按秒计算偏移量。

运行time.time()返回的是一个float类型

2.格式化时间(format string)：运行time.strtime('%Y-%m-%d  %X)输出就是现在的年月日，时分秒

%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.结构化时间

time.localtime()

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

time.localtime()

time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24

tm_hour=13, tm_mn=59, tm_sec=37, 

tm_wday=0, tm_yday=205, tm_isdst=0)

反结构化:mlctime

小结：时间戳是计算机能够识别的时间，格式化时间是让人能够看懂的时间，结构化时间是操作时间的。

几种格式之间的转换

datetime模块：

这个也是用来操作时间的

import datetime

# 自定义日期
res = datetime.date(2019, 7, 15)
print(res)  # 2019-07-15

# 获取本地时间
# 年月日
now_date = datetime.date.today()
print(now_date)  # 2019-07-01
# 年月日时分秒
now_time = datetime.datetime.today()
print(now_time)  # 2019-07-01 17:46:08.214170

# 无论是年月日，还是年月日时分秒对象都可以调用以下方法获取针对性的数据
# 以datetime对象举例
print(now_time.year)  # 获取年份2019
print(now_time.month)  # 获取月份7
print(now_time.day)  # 获取日1
print(now_time.weekday())  # 获取星期(weekday星期是0-6) 0表示周一
print(now_time.isoweekday())  # 获取星期(weekday星期是1-7) 1表示周一

# timedelta对象
# 可以对时间进行运算操作
import datetime

# 获得本地日期 年月日
tday = datetime.date.today()
# 定义操作时间 day=7 也就是可以对另一个时间对象加7天或者减少7点
tdelta = datetime.timedelta(days=7)

# 打印今天的日期
print('今天的日期:{}'.format(tday))  # 2019-07-01
# 打印七天后的日期
print('从今天向后推7天:{}'.format(tday + tdelta))  # 2019-07-08
# 总结:日期对象与timedelta之间的关系
"""
日期对象 = 日期对象 +/- timedelta对象
timedelta对象 = 日期对象 +/- 日期对象

验证:

"""
# 定义日期对象
now_date1 = datetime.date.today()
# 定义timedelta对象
lta = datetime.timedelta(days=6)
now_date2 = now_date1 + lta  # 日期对象 = 日期对象 +/- timedelta对象
print(type(now_date2))  # <class 'datetime.date'>
lta2 = now_date1 - now_date2  # timedelta对象 = 日期对象 +/- 日期对象
print(type(lta2))  # <class 'datetime.timedelta'>


# 小练习 计算举例今年过生日还有多少天
birthday = datetime.date(2019, 12, 21)
now_date = datetime.date.today()
days = birthday - now_date
print('生日：{}'.format(birthday))
print('今天的日期：{}'.format(tday))
print('距离生日还有{}天'.format(days))


# 总结年月日时分秒及时区问题
import datetime

dt_today = datetime.datetime.today()
dt_now = datetime.datetime.now()
dt_utcnow = datetime.datetime.utcnow()  # UTC时间与我们的北京时间cha ju

print(dt_today)
print(dt_now)
print(dt_utcnow)

random随机数模块：

是一个用来获取随机数的模块

random.random()随机一个大于且小于的小数

random.uniform(1,3)随机一个大于1小于3的小数

random.randint(1,9)用来随机一个大于等于1小于等于9的整数

random.randrange(1,10,2)大于等于1且小于10之间的奇数

random.choice([1,2])随机返回的1或2

random.samole([1,2,3,4,2],2)列表中任意2个组合

random.shuffle()打乱次序

随机生成验证码

import random

def get_code(num):
        res = ""
        for i in range(num):
                d1 = chr(random.randint(65,90)
                d2 = chr(random.randint(97,122)
                d3 = str(random.randint(0,9)
                res+=random.choice([d1,d2,d3])
        return res

os模块：

是用来与操作系统打交道的

os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息

os.system("bash command")  运行shell命令，直接显示
os.popen("bash command).read()  运行shell命令，获取执行结果
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd

os.path
os.path.abspath(path) 返回path规范化的绝对路径
os.path.split(path) 将path分割成目录和文件名二元组返回 
os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素 
os.path.basename(path) 返回path最后的文件名。如何path以／或结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)  如果path是绝对路径，返回True
os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小

sys模块：

是与pythos解释器（应用程序）打交道的模块

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

sys.argv命令行参数list，第一个元素是程序本身路径

sys.exit（n）退出程序，正常退出时exit(0),错误退出sys.exit(1)

sys.version 获取python解释器程序的版本信息

sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

sys.platform  返回操作系统平台名称

序列化模块:

序列：字符串

序列化：将数据类型转化为字符串形式

json模块：

json是一种跨语言的序列化，并且传输速度快。但只能用于传输小数据

四个方法：

dump:是将数据类型转为json格式的字符串并存到文件中

dumps：将数据类型转为json格式的字符串

loads：将json格式的字符串转成对应的数据类型

load：将json格式的字符串从文件中读出转成对应的数据类型

如果想把序列化的中文按中文存进去，要把ensure_ascii设置为False

pickle模块：

能够传输大数据，并且支持python中所有的类型，缺点：只能在python中使用

方法和上面一样，但要注意pickle序列化到文件时，文件打开的模式必须是b模式。

subprocess模块：

子进程模块，用于操作shell命令的

import subprocess
order = subprocess.Popen('终端命令', shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
suc_res = order.stdout.read().decode('系统默认编码')
err_res = order.stderr.read().decode('系统默认编码')

order = subprocess.run('终端命令', shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
suc_res = order.stdout.decode('系统默认编码')
err_res = order.stderr.decode('系统默认编码')

里面的stdout是表示输出管道

stdin表示输入管道

stderr表示错误信息。