Python第十五课(模块2)

Python第十五课(模块2)    >>>转到思维导图>>>转到中二青年

collections模块

collections模块在内置的数据类型，比如：int、str、list、dict等基础之上额外提供了几种数据类型。
1.namedtuple(): 生成可以使用名字来访问元素内容的tuple子类
2.deque: 双端队列，可以快速的从另外一侧追加和推出对象
3.Counter: 计数器，主要用来计数
4.OrderedDict: 有序字典
5.defaultdict: 带有默认值的字典

具名元组(namedtuple)

tuple是一个不可变的集合，namedtuple是一个函数，她用来构建一个自定义的tuple对象，并且规定了tuple元素的个数，可通过属性而不是索引来引用tuple的某个元素。我们可以通过namedtuple很方便的自定义一个数据类型，它具有tuple 的不变属性又可以根据属性来引用。

想表示空间坐标点x为1， y为2，z为5的坐标

from collections import namedtuple
point = namedtuple('坐标',['x','y','z'])  # 第二个参数既可以传可迭代对象
point1 = namedtuple('坐标','x y z')  # 也可以传字符串 但是字符串之间以空格隔开
p = point(1,2,5)
p1 = point1(2,3,6)
print(p,p.x,p.y,p.z)  # 坐标(x=1, y=2, z=5) 1 2 5
print(p1,p1.x,p1.y,p1.z)  # 坐标(x=2, y=3, z=6) 2 3 6

想表示一张黑桃A的扑克牌

card = namedtuple('扑克牌','color number')
card1 = namedtuple('扑克牌',['color','number'])
A = card('♠','A')
B = card1('♠','A')
print(A.color,A.number,A)  # ♠ A 扑克牌(color='♠', number='A')
print(B.color,B.number,B)  # ♠ A 扑克牌(color='♠', number='A')

想表示一个城市

city = namedtuple('日本','name person size')
c = city('东京','R老师','L')
print(c,c.​name,c.person,c.size)  # 日本(name='东京', person='R老师', size='L') 东京 R老师 L

队列(queue)

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())  # 如果队列中的值取完了 程序会在原地等待 直到从队列中拿到值才停止

先进先出(FIFO first in first out)

put()向队列添加值
get()向队列要值  # 值不够 程序会在原地等待 直到队列中给get方法返回一个值 才会继续往下执行
队列不应该支持任意位置插值，只能在首尾插值(不能插队)

双端队列(deque)

append()在末尾添加元素
appendleft()在开头添加元素
pop()弹出末尾的元素
popleft()弹出开头的元素
insert(index,obj)双端队列可以根据索引在任意位置插值

from collections import deque
q = deque(['a','b','c'])
q.append(1)  # 在末尾添加值
q.appendleft(2)  # 在开头添加值
"""
队列不应该支持任意位置插值
只能在首尾插值(不能插队)
"""
q.insert(0,'哈哈哈')  # 特殊点:双端队列可以根据索引在任意位置插值
print(q)  # deque(['哈哈哈', 2, 'a', 'b', 'c', 1])
print(q.pop())  # 1
print(q.popleft())  # 哈哈哈
print(q.popleft())  # 2
print(q)  # deque(['a', 'b', 'c'])

有序字典(OrderedDict)

normal_d = dict([('a',1),('b',2),('c',3)])
print(normal_d)  # {'a': 1, 'b': 2, 'c': 3}
from collections import OrderedDict
order_d = OrderedDict([('a',1),('b',2),('c',3)])  # // 有序字典顺序是插入进去的顺序排列的
print(order_d)  # OrderedDict([('a', 1), ('b', 2), ('c', 3)])
order_d1 = OrderedDict()
order_d1['z'] = 1
order_d1['y'] = 2
order_d1['x'] = 3
print(order_d1)
for i in order_d1:
    print(i)  # z y x
print(order_d1)  # OrderedDict([('z', 1), ('y', 2), ('x', 3)])

dict中key是无序的，在做迭代时，无法确认key的顺序
orderdDict是对字典类型的补充，他记住了字典元素添加的顺序

默认字典(defaultdict)

from collections import defaultdict
values = [11, 22, 33,44,55,66,77,88,99,90]
my_dict = defaultdict(list)  # 后续该字典中新建的key对应的value默认就是列表
print(my_dict['aaa'])  # []
for value in  values:
    if value>66:
        my_dict['k1'].append(value)
    else:
        my_dict['k2'].append(value)
print(my_dict)
# defaultdict(<class 'list'>, {'aaa': [], 'k2': [11, 22, 33, 44, 55, 66], 'k1': [77, 88, 99, 90]})
my_dict1 = defaultdict(int)
print(my_dict1['xxx'])  # 0
print(my_dict1['yyy'])  # 0
my_dict2 = defaultdict(bool)
print(my_dict2['kkk'])  # False
my_dict3 = defaultdict(tuple)
print(my_dict3['mmm'])  # ()

defaultdict(list)字典内所有新增的键对应的值都是一个空列表 并且不是共用一个
在使用 d[key] 取值的时候， 如果指定的key不存在，就会抛出KeyError异常
使用defaultdict，只要传入一个函数，那么请求一个不存在的key时， 便会调用这个函数使用其结果来作为这个key的默认值

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

计数器(Counter)

c = Counter('abcdeabcdabcaba')
print c
输出：Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})

Counter是对字典类型的补充，用于追踪值的出现次数
它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value
计数值可以是任意的Interger（包括0和负数）

time时间模块

三种表现形式

# ​导入时间模块
>>>import time
# ​时间戳
>>>time.time()
1500875844.800804
# 时间字符串
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 13:54:37'
>>>time.strftime("%Y-%m-%d %H-%M-%S")
'2017-07-24 13-55-04'
# 时间元组:localtime将一个时间戳转换为当前时区的struct_time
time.localtime()
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24,
　　　　　　　　　　tm_hour=13, tm_min=59, tm_sec=37,
                 tm_wday=0, tm_yday=205, tm_isdst=0)

1.时间戳
时间戳(timestamp) ：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。
2.格式化时间

python中时间日期的格式化符号
%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个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等）​

time.localtime()​
​#​time.struct_time(tm_year=2019, tm_mon=7, tm_mday=19, tm_hour=16, tm_min=27, tm_sec=29, tm_wday=4, tm_yday=200, tm_isdst=0)

几种格式之间的转换

datetime时间模块

打印时间

import datetime
print(datetime.date​.today())  # date>>>:年月日
print(datetime.datetime​.today())  # datetime>>>:年月日 时分秒
res = datetime.date.​today()
res1 = datetime.datetime​.today()
print(res.year)
print(res.month)
print(res.day)
print(res.weekday())  # 0-6表示星期  0表示周一
print(res.isoweekday())  # 1-7表示星期 7就是周日

日期+/-

import datetime
"""​
日期对象 = 日期对象 +/- 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)
# 小练习 计算今天距离今年过生日还有多少天
birth = datetime.datetime(2019,12,21,8,8,8)
current_time = datetime.datetime​.today()
print(birth-current_time)

UTC时间

# UTC时间
dt_today = datetime.datetime.​today()
dt_now = datetime.datetime.now()
dt_utcnow = datetime.datetime.utcnow()
print(dt_utcnow,dt_now,dt_today)

random随机模块

取随机数

>>> import random
#​随机小数
>>> random.random()      # 大于0且小于1之间的小数
0.7664338663654585
>>> random.uniform(1,3) #​大于1小于3的小数
1.6270147180533838
#​恒富：发红包
#​随机整数
>>> random.randint(1,5)  # 大于等于1且小于等于5之间的整数
>>> random.randrange(1,10,2) # 大于等于1且小于10之间的奇数
#​随机选择一个返回
>>> random.choice([1,'23',[4,5]])  # #​1或者23或者[4,5]
#​随机选择多个返回，返回的个数为函数的第二个参数
>>> random.sample([1,'23',[4,5]],2) # #​列表元素任意2个组合
[[4, 5], '23']

打乱列表顺序

>>> item=[1,3,5,7,9]
>>> random.shuffle(item) # 打乱次序
>>> item
[5, 1, 3, 7, 9]
>>> random.shuffle(item)
>>> item
[5, 9, 7, 1, 3]

生成验证码

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)

OS模块

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.pathos.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的大小

stat结构

st_mode: inode 保护模式
st_ino: inode 节点号。
st_dev: inode 驻留的设备。
st_nlink: inode 的链接数。
st_uid: 所有者的用户ID。
st_gid: 所有者的组ID。
st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。
st_atime: 上次访问的时间。
st_mtime: 最后一次修改的时间。
st_ctime: 由操作系统报告的"ctime"。在某些系统上（如Unix）是最新的元数据更改的时间，在其它系统上（如Windows）是创建时间（详细信息参见平台的文档）。

os模块属性

os.sep    输出操作系统特定的路径分隔符，win下为"\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符，win下为"
",Linux下为"
"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'

sys模块

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

sys.argv           命令行参数List，第一个元素是程序本身路径
sys.exit(n)        退出程序，正常退出时exit(0),错误退出sys.exit(1)
sys.version        获取Python解释程序的版本信息
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称

异常处理与status

import sys
try:
    sys.exit(1)
except SystemExit as e:
    print(e)

序列化模块

序列:字符串
序列化:其他数据类型转换成字符串的过程
反序列化:字符串转成其他数据类型
json模块

json，用于字符串 和 python数据类型间进行转换
优点：所有的语言都支持json格式

缺点：支持的数据类型很少(字符串,列表,字典,整型,元组(转成列表) ,布尔值)
loads和dumps

import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic)  #​序列化：将一个字典转换成一个字符串
print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
#​注意，json转换完的字符串类型的字典中的字符串是由""表示的
dic2 = json.loads(str_dic)  #​反序列化：将一个字符串格式的字典转换成一个字典
#​注意，要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
print(type(dic2),dic2)  #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
str_dic = json.dumps(list_dic) #​也可以处理嵌套的数据类型
print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
list_dic2 = json.loads(str_dic)
print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]

load和dump

import json
f = open('json_file','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)  #​dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件
f.close()
f = open('json_file')
dic2 = json.load(f)  #​load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回
f.close()
print(type(dic2),dic2)

pickle模块

pickle，用于python特有的类型 和 python的数据类型间进行转换
缺点：只支持python

优点：​python所有的数据类型都支持
pickle模块提供了四个功能：dumps(序列化)、loads(反序列化)、dump(存)、load(读)

pickle
import pickle
d = {'name':'jason'}
res = pickle.dumps(d)  # 将对象直接转成二进制
print(pickle.dumps(d))
res1 = pickle.loads(res)
print(res1,type(res1))
"""
用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))

subprocess模块

# subprocess
"""
sub :子
process:进程
"""
"""
1.用户通过网络连接上了你的这台电脑
2.用户输入相应的命令 基于网络发送给了你这台电脑上某个程序
3.获取用户命令 里面subprocess执行该用户命令
4.将执行结果再基于网络发送给用户
这样就实现  用户远程操作你这台电脑的操作
"""
while True:
    cmd = input('cmd>>>:').strip()
    import subprocess
    obj = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
    print(obj)
    print('正确命令返回的结果stdout',obj.stdout.read().decode('gbk'))
    print('错误命令返回的提示信息stderr',obj.stderr.read().decode('gbk'))