模块

   今日类容

1.collection模块

2.时间模块

3.random模块

4.os模块

5.sys模块

6.序列化模块

7.subprocess模块

一  collection

0.普通的队列，先进先出

queue

队列:现进先出(FIFO first in first out)
import queue
q = queue.Queue()  # 生成队列对象
q.put('first')  # 往队列中添加值
q.put('second')
q.put('third')

print(q.get())  # 朝队列要值
print(q.get())
print(q.get())
print(q.get())  # 如果队列中的值取完了 程序会在原地等待 直到从队列中拿到值才停止

1.namedtuple：具名元组

　　可以很方便的定义一种数据类型，他具备tuple的不可变性，也可以根据属性来引用，非常方便。

from collections import  namedtuple
point = namedtuple('p',['x','y'])
p = point(1,2)
print(p.x) #1
print(p.y) #2

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

　　可以高效的实现插入和删除的双向列表，适用于队列和栈。

有四个方法：

　　添加：append末尾添加，appendleft左边添加

　　insert：可以往中间放 ，这是他不合理的地方

　　取出：pop 右边取    ， popleft左边取

from collections import deque
q= deque(['a','b','c'])
q.append('x')
q.appendleft('y')
print(q)
 
#deque(['y', 'a', 'b', 'c', 'x'])

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

　　是一个简单的计数器，目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储。其中元素为key，个数为value. 计数值可以是任意的interger(含0和负数)

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

4.OrdereDict: 有序字典　

　　使用dict时，key是无序的，如果要保证key的顺序，可以用OrderedDict。OrderedDict的key是按照插入的顺序排列，不是key本身排序。　

from collections import OrderedDict
dic = dict([('a',1),('b',2),('c',3)])
dic1 = OrderedDict([('a',1),('b',2),('c',3)])
print(dic.keys()) #dict_keys(['a', 'b', 'c'])
print(dic1.keys()) #odict_keys(['a', 'b', 'c'])

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

　　使用dict时，如果key不存在，则抛出KeyError，如果希望key不存在时，返回一个默认值，可以用defaultdict。

from collections import defaultdict
dic = defaultdict(lambda :'N/A')
dic['k1'] = 'abc'
print(dic['k1']) #‘abc’
print(dic['k2']) #N/A

二 时间模块

1.时间模块

时间模块分为三种表现形式：
　　1.时间戳

　　2.格式化时间（用来展示给人看的）

　　3.结构化时间

1.显示时间戳，时间戳就是从1970，1，1

time.time

import time 

print（time.time()）

2.格式化时间，可以显示时间给人看的

指定打印时间句式'%Y-%m-%d %H:%M:%S'

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

strftime

print(time.strftime('%Y-%m-%d'))
print(time.strftime('%Y-%m-%d %H:%M:%S'))
print(time.strftime('%Y-%m-%d %X'))  # %X等价于%H:%M:%S
print(time.strftime('%H:%M'))
print(time.strftime('%Y/%m'))

格式化时间补充：

%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.结构化时间，就是打印出来什么是什么的结果

print(time.localtime())

print(time.localtime(time.time()))
res = time.localtime(time.time())
print(time.time())
print(time.mktime(res))
print(time.strftime('%Y-%m',time.localtime()))
print(time.strptime(time.strftime('%Y-%m',time.localtime()),'%Y-%m'))

4.datetime

 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就是周日

5.时间的计算

日期对象 = 日期对象 +/- 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时间，跟当前时区相差8小时

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
有一些常用的语句：

1.随机取一个你提供的整数范围内的数字  包含首尾
random.randint

print (random.randint(1,6))

2.随机取0-1之间小数

random.random

print(random.random())

3.摇号 随机从列表中取一个元素

random.choice

print(random.choice([1,2,3,4,5,6]))

4.可以把一个列表里的顺序打乱：也可以称之为洗牌

random.shuffle

res = [1,2,3,4,5,6]
random.shuffle(res) 
print(res)

random可以随机生成数字或字母组合的验证码
一般用于生成验证码，线上赌场发牌等等

那么这里我们写了一个生成随机验证码的例子
规则：
　　大小写字母，小写字母，数字
　　5位数的随机码验证，然几位后封装成一个函数，
　　用户想生成几位就生成

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模块：跟操作系统打交道的模块
sys模块：跟python解释器打交道的模块（或者说应用程序）

os模块常用方法：
os.path.exists  判断文件是否存在
os.path.isfile  只能判断文件，不能判断文件夹
os.rmdir  只能删除空文件夹
os.chdir   切换当前所在的目录

os模块方法补充

os.getcwd():　　获取当前工作目录，（即当前Python脚本工作的目录路径）

　　os.chdir('dirname'):　　改变当前脚本的工作目录，相当于shell下的cd

　　os.system('bash command'):　　运行shell命令，直接显示（相当于启动一个全新的shell，然后去执行那条命令，命令执行完成过后，shell直接退出）

　　os.curdir:　　返回当前目录字符串名

　　os.pardir:　　返回当前目录的父目录的字符串名

　　os.makedirs('dirname1/dirname2'):　　可生成一个多层递归目录

　　os.removedirs('dirname1'):　　若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依次类推

　　os.mkdir('dirname'):　　创建一个目录

　　os.rmdir('dirname'):　　删除一个目录，若目录不为空则无法删除，报错

　　os.listdir('dirname'):　　显示指定目录下，所有的文件和子目录，包括隐藏文件

　　os.remove():　　删除文件

　　os.rename('oldname','newname'):　　重命名文件/目录，如果新的文件名/目录名已经存在，则会报错

　　os.stat(' path/filename'):　　获取文件/目录信息,并可以获取到文件的大小

　　os.sep:　　输出操作系统特定的路径分隔符 ，如：win 为‘\’,Linux为‘/’

　　os.liesep:　　输出当前平台使用的行终止符，如 win为 ‘	
’,Linux为‘
’

　　os.pathsep:　　输出用于分割文件路径的字符串

　　os.name:　　输出字符串指示当前使用平台，如 win ->'nt' ; Linux ->'posix'

　　os.environ:　　获取操作系统的环境变量

　　os.path.abspath(path):　　返回path规范化的绝对路径

　　os.path.split(path):　　　将path分割成目录和文件名二元组返回

　　os.path.dirname(path):　　返回path的目录

　　os.path.basename(path):　　返回path最后的文件名（一个绝对路径只返回最后的文件名）

　　os.path.exists(path):　　判断路径是否存在，如果path存在，返回True；如果不存在，返回Flase

　　os.path.isabs(path):　　判断是否是绝对路径，如果是，则返回True

　　os.path.isfile(path):　　判断是否是一个文件

　　os.path.isdir(path):　　判断是否是一个存在的目录

　　os.path.join(path1[,path2[,.......]])：　　将路径和文件名分为一个列表中的两个元素，将它们拼起来

　　os.path.getatime(path)：　　返回path所指向的文件或者目录的最后存取时间

　　os.path.getmtime(path):　　返回path所指向的文件或者目录的最后修改时间

　　os.popen('dir'):　　相当于打开了一个临时的文件存储打开的目录（可以赋给变量，字符串的形式) 

案例：

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



os.mkdir('tank老师精选')  # 自动创建文件夹
print(os.path.exists(r'D:Python项目day16
ion老师精选'))  # 判断文件是否存在
print(os.path.exists(r'D:Python项目day16老师们的作品	ank老师.txt'))  # 判断文件是否存在
print(os.path.isfile(r'D:Python项目day16	ank老师精选'))  # 只能判断文件 不能判断文件夹
print(os.path.isfile(r'D:Python项目day16老师们的作品	ank老师.txt'))  # 只能判断文件 不能判断文件夹

os.rmdir(r'D:Python项目day16老师们的作品')  # 只能删空文件夹

print(os.getcwd())
print(os.chdir(r'D:Python项目day16老师们的作品'))  # 切换当前所在的目录
print(os.getcwd())

# 获取文件大小
print(os.path.getsize(r'D:Python项目day16老师们的作品	ank老师.txt'))  # 字节大小
with open(r'D:Python项目day16老师们的作品	ank老师.txt',encoding='utf-8') as f:
    print(len(f.read()))

五 sys模块
sys模块包括了一组非常实用的服务，内含很多函数方法和变量，用来处理Python运
行时配置以及资源，从而可以与前当程序之外的系统环境交互，如：Python解释器。

sys模块的常用方法
import sys
sys.path.append()   将=某个路径添加到系统的环境变量中
print（sys.platfrom）  获取当前系统平台。
print(sys.version)  python解释器的版本
print(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('用户不存在 无法执行当前文件')

六 json模块  pickle模块

　　JSON（Java Script Object Notation）：一种轻量级数据交互格式，相对于XML而言更简单，也易于阅读和编写，机器也方便解析和生成，Json是JavaScript中的一个子集。python的json模块序列化与反序列化的过程分别是encoding和decoding。

• encoding：把一个python对象编码转换成Json字符串。
• decoding：把json格式字符串编码转换成python对象。

json模块分为：序列化 和 反序列化

序列化：
　　序列：字符串
　　序列化：其他数据类型转换成字符串的过程
注意：1.写入文件的数据必须是字符串
　　　2.基于网络传输的数据必须是二进制　

反序列化：字符串转为其他数据类型，
　　

json 模块：
　　所有的语言都支持json格式
　　但是支持的数据类型很少，只有 字符串，列表，字典，整型，元组（转成列表），布尔值

json一共就四个方法：

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

dumps：序列化  把其他数据类型转换为json格式的字符串

往文件里写用下面的

load：反序列化  将文件的内容转换成为json数据

dump：序列化  把json数据写入到文件中

案例：dunps loads

import json
d = {"name":"jason"}
print(d)
res = json.dumps(d)  # json格式的字符串 必须是双引号 >>>: '{"name": "jason"}'
print(res,type(res))
res1 = json.loads(res)
print(res1,type(res1))

案例：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
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)


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

案例：在dumps的时候中文要指定编码，不然是二进制

d1 = {'name':'朱志坚'}
print(json.dumps(d1,ensure_ascii=False))默认是True，改为False就可以了

pickle模块

它只支持python，Python所有的数据类型都支持，
他有很大的弊端，就是不能跟其他平台交互，称之为孤儿，
在用pickle操作文件的时候，文件的打开模式必须是b模式
因为他会直接将对象转为二进制

案例：

d = {'name':'jason'}
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模块

sub ：子
process：进程

模块详细解释：

args： 要执行的shell命令，默认应该是一个字符串序列，如['df', '-Th']或('df', '-Th')，也可以是一个字符串，如'df -Th'，但是此时需要把shell参数的值置为True。
shell： 如果shell为True，那么指定的命令将通过shell执行。如果我们需要访问某些shell的特性，如管道、文件名通配符、环境变量扩展功能，这将是非常有用的。当然，python本身也提供了许多类似shell的特性的实现，如glob、fnmatch、os.walk()、os.path.expandvars()、os.expanduser()和shutil等。
check： 如果check参数的值是True，且执行命令的进程以非0状态码退出，则会抛出一个CalledProcessError的异常，且该异常对象会包含 参数、退出状态码、以及stdout和stderr(如果它们有被捕获的话)。
stdout, stderr：input： 该参数是传递给Popen.communicate()，通常该参数的值必须是一个字节序列，如果universal_newlines=True，则其值应该是一个字符串。
run()函数默认不会捕获命令执行结果的正常输出和错误输出，如果我们向获取这些内容需要传递subprocess.PIPE，然后可以通过返回的CompletedProcess类实例的stdout和stderr属性或捕获相应的内容；
call()和check_call()函数返回的是命令执行的状态码，而不是CompletedProcess类实例，所以对于它们而言，stdout和stderr不适合赋值为subprocess.PIPE；
check_output()函数默认就会返回命令执行结果，所以不用设置stdout的值，如果我们希望在结果中捕获错误信息，可以执行stderr=subprocess.STDOUT。
universal_newlines： 该参数影响的是输入与输出的数据格式，比如它的值默认为False，此时stdout和stderr的输出是字节序列；当该参数的值设置为True时，stdout和stderr的输出是字符串。
3. subprocess.CompletedProcess类介绍
需要说明的是，subprocess.run()函数是Python3.5中新增的一个高级函数，其返回值是一个subprocess.CompletedPorcess类的实例，因此，subprocess.completedPorcess类也是Python 3.5中才存在的。它表示的是一个已结束进程的状态信息，它所包含的属性如下：

args： 用于加载该进程的参数，这可能是一个列表或一个字符串
returncode： 子进程的退出状态码。通常情况下，退出状态码为0则表示进程成功运行了；一个负值-N表示这个子进程被信号N终止了
stdout： 从子进程捕获的stdout。这通常是一个字节序列，如果run()函数被调用时指定universal_newlines=True，则该属性值是一个字符串。如果run()函数被调用时指定stderr=subprocess.STDOUT，那么stdout和stderr将会被整合到这一个属性中，且stderr将会为None
stderr： 从子进程捕获的stderr。它的值与stdout一样，是一个字节序列或一个字符串。如果stderr灭有被捕获的话，它的值就为None
check_returncode()： 如果returncode是一个非0值，则该方法会抛出一个CalledProcessError异常

案列：

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