好多模块

collections模块、时间模块、random模块、os模块、sys模块、序列化模块、subprocess模块

一、collections模块

在内置数据类型（dict、list、set、tuple）的基础上，collections模块还提供了几个额外的数据类型：Counter、deque、defaultdict、namedtuple和OrderedDict等。

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

from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])  # 第一个是类名，第二个是类的各个字段的名字。后者可以是由数个字符串组成的可迭代对象，或者是由空格分隔开的字段名组成的字符串。
括号里还可以写成('Point','x y')

p = Point(1, 2)  # 1对应x ，2对应y
p.x  # 1
p.y  # 2

# namedtuple('名称', [属性list])

2.deque: deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈

from collections import deque

q = deque(['a', 'b', 'c'])
q.append('x')  # 从后面添加一个x
q.appendleft('y')  # 从左边添加一个y
print(q)  # deque(['y', 'a', 'b', 'c', 'x'])

 补充：

import queue
            q = queue.Queue()  # 队列
            q.put(1)  # 存值
            q.get()  # 取值
            q.get()  # 没有值得情况下程序会在原地等待 直到队列中给get方法返回一个值 才会继续往下执行

deque除了实现list的 append() 和 pop() 外，还支持 appendleft() 和 popleft()，这样就可以非常高效地往头部添加或删除元素。

3.defaultdict: 带有默认值的字典

from collections import defaultdict

my_dict = defaultdict(list)  # 后续该字典中新建的key对应的value默认就是列表
print(my_dict['aaa'])  # []  使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict
values = [11, 22, 33,44,55,66,77,88,99,90]
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)  整型

my_dict2 = defaultdict(bool)  布尔值

my_dict3 = defaultdict(tuple)  元组

4.OrderedDict: 有序字典

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

如果要保持Key的顺序，可以用OrderedDict：

normal_d = dict([('a',1),('b',2),('c',3)])  # 用普通形式定义的字典
print(normal_d)  # {'a': 1, 'b': 2, 'c': 3}  # 无序的，在这里看不出来，在cmd终端可以看出

#############################
from collections import OrderedDict

d = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
print(d)  # OrderedDict([('a', 1), ('b', 2), ('c', 3)])
# OrderedDict的Key会按照插入的顺序排列，不是Key本身排序
# 取key的时候也是按照插入key的顺序返出

5.Counter: 计数器，主要用来计数（出现的次数）

它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。

from collections import Counter

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

 

二、时间模块（time和datetime）

time模块主要的调用方式：

在Python中，通常有这三种方式来表示时间：时间戳、元组(struct_time)、格式化的时间字符串：

1.时间戳  >>>>>>>>  time.time()  # 1563449577.9410462   表示的是从1970年1月1日00:00:00开始按秒计算的偏移量

2.时间元祖  >>>>>>>>>>  time.localtime()  # 返回的是元组形式    time.struct_time(tm_year=2019, tm_mon=7, tm_mday=18, tm_hour=19, tm_min=31, tm_sec=53, tm_wday=3, tm_yday=199, tm_isdst=0)

3.格式化时间  >>>>>>>>>  time.strftime('%Y-%m-%d %H:%M:%S')  # 2019-07-18 19:35:24

　　　　　　　　　　　　 time.strftime(('%Y-%m-%d %X'))  # 2019-07-18 19:35:24

　　　　　　　　　　　　  %X等价于%H:%M:%S

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

注：三种时间格式除了时间戳与格式化时间不能直接互换外，其他都可以互换。

互换例子：https://www.cnblogs.com/Dominic-Ji/articles/11109067.html#_label15

datetime模块主要的调用方式：

1.今日日期  >>>>>>>  datetime.date.today()  # 2019-07-18

2.今日日期 >>>>>>>> datetime.datetime.today()  # 2019-07-18 19:45:54.369845

# 无论是年月日，还是年月日时分秒对象都可以调用以下方法获取针对性的数据
# 以datetime对象举例
import datetime

now_time = datetime.datetime.today()
print(now_time.year)  # 获取年份2019
print(now_time.month)  # 获取月份7
print(now_time.day)  # 获取日18
print(now_time.weekday())  # 获取星期(weekday星期是0-6) 0表示周3
print(now_time.isoweekday())  # 获取星期(weekday星期是1-7) 1表示周4

 3.时间运算  >>>>>>>>  timedelta对象   可以对时间进行运算操作

import datetime

current_time = datetime.date.today()  # 日期对象
timetel_t = datetime.timedelta(days=7)  # timedelta对象
res1 = current_time+timetel_t  # 日期对象

print(current_time - timetel_t)  # 2019-07-11
print(res1-current_time)  # 7 days, 0:00:00

总结：日期对象与timedelta之间的关系

　　　　日期对象 = 日期对象 +/- timedelta对象
　　　　timedelta对象 = 日期对象 +/- 日期对象

import datetime

# UTC时间
dt_today = datetime.datetime.today()
dt_now = datetime.datetime.now()
dt_utcnow = datetime.datetime.utcnow()
print(dt_utcnow)  # 2019-07-18 12:00:30.405495
print(dt_now)  # 2019-07-18 20:00:30.405495
print(dt_today)  # 2019-07-18 20:00:30.405496

# 可以看出来now和utcnow之间的不一样，now代表北京东八区时间，utcnow代表伦敦时间

三、random模块

主要运用方法：

1.随机小数  >>>>  random.random()  # 大于0且小于1之间的小数

2.随机整数  >>>> random.randint(1,5)  # 大于等于1且小于等于5之间的整数

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

3.随机选择一个返回  >>>>  random.choice([元素1，元素2，元素3])

4.打乱列表顺序  >>>>  random.shuffle(列表)

# 生成随机验证码

"""
大写字母 小写字母 数字  任意组合
封装成一个函数,用户想生成几位就生成几位
"""
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)  # 每次生成4个随机数字字母组合

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

主要运用方法：

1.os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错

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

3.os.remove()  删除一个文件

4.os.rename("oldname","newname")  重命名文件/目录

5.os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径

6.os.path.exists(path)  如果path存在，返回True；如果path不存在，返回False

7.os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False

8.os.path.getsize(path) 返回path的大小

五、sys模块：是与python解释器交互的一个窗口

主要运用方式：

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

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

3.sys.version        获取Python解释程序的版本信息

4.sys.argv　　　  命令行启动文件 可以做身份的验证。如：

if len(sys.argv) <= 1:
    print('请输入用户名和密码')
else:
    username = sys.argv[1]
    password = sys.argv[2]
    if username == 'jason' and password == '123':
        print('欢迎使用')
        # 当前这个py文件逻辑代码
    else:
        print('用户不存在 无法执行当前文件')

六、序列化模块

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

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

ps：写入文件的数据必须是字符串，基于网络传输的数据必须是二进制

包括两种：json模块和pickle模块

区别：

    json模块(******)
        所有的语言都支持json格式
        支持的数据类型很少  字符串 列表 字典 整型 元组(转成列表)  布尔值

    pickle模块(****)
        只支持python
        python所有的数据类型都支持

 

 

json模块：

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

import json

d = {"name":"jason"}
print(d)  # {'name': 'jason'}
res = json.dumps(d)  # 序列化
print(res,type(res))  # {"name": "jason"} <class 'str'>  json转换完的字符串类型的字典中的字符串是由""表示的
res1 = json.loads(res)  # 反序列化  用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
print(res1,type(res1))  # {'name': 'jason'} <class 'dict'>

dump: 序列化，存

load: 反序列化，读

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

在使用反序列化的时候，不支持操作多次，所以可以采取写入时候每次写入都换行，然后逐行反序列化。如：

import json

d = {"name":"jason"}

with open('userinfo','w',encoding='utf-8') as f:
    json_str = json.dumps(d)
    json_str1 = json.dumps(d)
    f.write('%s
'%json_str)
    f.write('%s
'%json_str1)

############
{"name": "jason"}
{"name": "jason"}
############

with open('userinfo','r',encoding='utf-8') as f:
    for line in f:
        res = json.loads(line)
        print(res,type(res)) 

# {'name': 'jason'} <class 'dict'>
{'name': 'jason'} <class 'dict'>

ensure_ascii关键字参数：

import json

d1 = {'name':'朱志坚'}
print(json.dumps(d1))  # {"name": "u6731u5fd7u575a"} 

print(json.dumps(d1,ensure_ascii=False))  # {"name": "朱志坚"}

pickle模块：pickle模块提供了四个功能：dumps、dump(序列化，存）、loads（反序列化，读）、load  （不仅可以序列化字典，列表...可以把python中任意的数据类型序列化）

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模块：

"""
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'))