常用模块

collection模块:

```python
    在字典,列表,元组,集合的基础上,还提供了具名元组,双端队列,计数器,有序字典,默认字典等
1.namedtuple:具名元组,具有名字的元组
    from collections import namedtuple
    eg1:
    point = namedtuple(‘坐标‘,[‘x‘,‘y‘]) #可以传可迭代对象   也可穿字符串  串间空格隔开
    p = point(1,2)  #元素个数与 namedtuple的第二个参数中的个数一一对应
    print(p.x)
    print(p.y)
    eg2:
    b = namedtuple(‘扑克‘,‘color 大小‘)
    a = b(‘♠‘,‘K‘)
    print(a)
2.depue:双端队列  可以高效的实现添加,删除,插入;适用于队列与栈
       特点:可以根据索引在任意位置插值,正常队列不能插值
    from collections import deque
    q = deque([‘a‘,‘b‘,‘c‘])
    q.append(‘d‘)
    q.appendleft(‘lii‘)
    b=q.popleft()
    print(b)
    deque除了实现list的append()和pop()外，还支持appendleft()和popleft()
3.OrdereDict:有序字典,平常字典的key是无序的,要让他有序就用有序字典
    无序字典:key无序,无法确定key的顺序
    >>> from collections import OrderedDict
    >>> d = dict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)])
    >>> d # dict的Key是无序的
    {‘a‘: 1, ‘c‘: 3, ‘b‘: 2}
    有序字典:key会根据插入顺序排
    >>> od = OrderedDict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)])
    >>> od # OrderedDict的Key是有序的
    OrderedDict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)])
4.defaultdict:默认字典
    有集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中;
    老方法:
        values = [11, 22, 33,44,55,66,77,88,99,90]
        my_dict = {}
        for value in  values:
        if value>66:
            if my_dict.has_key(‘k1‘):
                my_dict[‘k1‘].append(value)
            else:
                    my_dict[‘k1‘] = [value]
        else:
            if my_dict.has_key(‘k2‘):
                my_dict[‘k2‘].append(value)
            else:
                my_dict[‘k2‘] = [value]
     新方法:
         from collections import defaultdict
        values = [11, 22, 33,44,55,66,77,88,99,90]
        my_dict = defaultdict(list)
        for value in  values:
            if value>66:
                my_dict[‘k1‘].append(value)
            else:
                my_dict[‘k2‘].append(value)
5.Counter:计数器,计算个数
       老方法:
         d = {}
        b=[]
        c = ‘sdskhgusdfsdfs‘
        for i in c:
           b.append(i)
        b.count(i)
        d[i]=b.count(i)
        print(d)
    新方法:
        from collections import Counter
        res = ‘sdskhgusdfsdfs‘
        print(Counter(res)
```

time模块:

```
表示时间的三张形式:时间戳,格式化时间(用来展示给人看的),时间结构化
import time
1.time.time()        #1500875844.800804
2.time.strftime(‘%Y-%m-%d %H:%M:%S‘)         # %X  等价于%H:%M:%S‘    2019-07-18 20:04:35
3.time.localtime()    #(tm_year=2019, tm_mon=7, tm_mday=18, tm_hour=20, tm_min=3, tm_sec=0)    
三者间的转化:



```

date time模块

```
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
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表示周一
# 获得本地日期 年月日
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
```

random模块

```
随机小数:random.random(0,1)           (0,1)
随机整数:random.randint(0,9)          [0,9]
洗牌:    random.shuffle([1,3,5])       [1,5,3],打乱次序
摇号:    random.choice([1,3,5])      随机选择一个返回
应用场景:生成随机验证码
    def my(a):
         h =‘‘
         for i in range(a):
             f =chr(random.randint(97,122))
             A =chr(random.randint(65,99))
             c = str(random.randint(0,9))
             h+=random.choice([f,A,c])
         return h
     print(my(5))
```

o s 模块:与操作系统大交到

```python
常用的
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.path.exists(path)  如果path存在，返回True；如果path不存在，返回False
os.path.getsize(path) 返回path的大小
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回
os.path.dirname(path) 返回path的目录
os.path.isabs(path)  如果path是绝对路径，返回True

融汇贯通:
import os
BASE_DIR = os.path.dirname(__file__)
MOVIE_DIR = os.path.join(BASE_DIR,‘老师们的作品‘)
movie_list = os.listdir(MOVIE_DIR)
while True:
    for i,j in enumerate(movie_list,1):
        print(i,j)
    choice = input(‘你想看谁的啊(今日热搜:tank老师)>>>:‘).strip()
    if choice.isdigit():  # 判断用户输入的是否是纯数字
        choice = int(choice)  # 传成int类型
        if choice in range(1,len(movie_list)+1):  # 判断是否在列表元素个数范围内
            # 获取用户想要看的文件名
            target_file = movie_list[choice-1]
            # 拼接文件绝对路径
            target_path = os.path.join(MOVIE_DIR,target_file)
            with open(target_path,‘r‘,encoding=‘utf-8‘) as f:
                print(f.read())

```

sys模块:与python解释器打交到

```python
sys.path.append()  将某个路径添加到系统的环境变量中
sys.argv   命令行参数List，第一个元素是程序本身路径
eg:
    if len(sys.argv) <= 1:
            print(‘请输入用户名和密码‘)
    else:
            username = sys.argv[1]
         password = sys.argv[2]
         if username == ‘jason‘ and password == ‘123‘:
             print(‘欢迎使用‘) 
         else:
             print(‘用户不存在 无法执行当前文件‘)
```

序列化与反序列化

```
序列化:就是把其他类型的数据转化为字符串的过程
反序列化:是把字符串转化成其他的数据类型
序列化的目的:让程序便于维护,让对象持久化,以便于传递到其他地方
dump:序列化到文件中               load:从文件中反序列化出来      存
dumps:序列化                     loads:反序列化                 取
json模块
        所有的语言都支持json格式,都认识它
        但其本身支持的数据类型很少  字符串 列表 字典 整型 元组(转成列表)  布尔值
           json 格式的字符串必须是双引号的
           
pickle模块
        只支持python的(自己与自己玩)
        python所有的数据类型都支持
        用pickle操作文件的时候 文件的打开模式必须是b模式
注:写入文件的数据必须是字符串,基于网络传输的数据必须是二进制
--------------------------------------------------------------------------------
import json
dic = {"name": "王彦飞", "age": "18"}
obj = json.dumps(dic,ensure_ascii=False)
print(obj)
user = json.loads(obj)
print(user)
with open(‘name‘,‘w‘,encoding=‘utf-8‘)as f:
    data =json.dump(dic,f)
    print(data)

f = open(‘name‘,‘r‘,encoding=‘utf-8‘)
d = json.load(f)
print(d)
f.close()

f = open(‘bb‘,‘w‘,encoding=‘utf-8‘)
data = json.dumps(‘hello‘)
re = json.dumps(‘what is your name‘)
f.write(‘%s\n‘%data)
f.write(‘%s\n‘% re)
print(data)
print(re)
f.close()

with open(‘bb‘,‘r‘,encoding=‘utf-8‘)as f:
    for line in f:
        res = json.loads(line)
        print(line)
--------------------------------------------------------------------------------
import pickle
dic = {‘name‘:‘王彦飞‘,‘age‘:‘18‘}
b = pickle.dumps(dic)
print(b)
c = pickle.loads(b)
print(c)
with open(‘bb‘,‘wb‘) as f:
    data = pickle.dump(dic,f)
with open(‘bb‘,‘rb‘,) as f:
   b= pickle.load(f)
   print(b)
```

subprocess模块:子进程

```python
进程:指的是一个正在运行中的程序
子进程:指的是由另个一进程开启的进程  a在运行过程中 开启了b   b就是a的子进程
为什么要开启子进程
    当一个程序在运行过程中有一个任务,自己做不了或是不想做 就可以开启另一个进程来帮助其完成任务
    例如 qq中收到一个链接 点击链接 就开启了; 浏览器  浏览器就是qq的子进程
-----------------------------------------------------------------------------------------------------eg:
import subprocess
obj =subprocess.Popen(‘dir‘,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
print(obj.stdout.read().decode(‘gbk‘))

obj = subprocess.Popen(‘help‘,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE) print(obj.stdout.read().decode(‘gbk‘))

p1 = subprocess.Popen("tasklist",shell=True,stdout=subprocess.PIPE)
p2=subprocess.Popen("findstrQQ",shell=True,stdin=p1.stdout,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
print(p2.stdout.read())
print(p2.stderr.read())
-----------------------------------------------------------------------------------------------------
subprocess.Poen(参数1:指令,参数2:是否是一个指令,3 错误输出管道,4 输入管道,5 输出管道)
取出管道中的数据
p.stderr.read()
p.stdout.read()
将输入写入管道 交给对方进程
p.stdin.write(p.stdout.read())
```