常用模块

常用模块

'''

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

1、namedtuple：具名元组，具有名字的元组，生成可以使用名字来访问元素内容的tuple

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

3、Counter：计数器，主要用来计数

4、OrderedDict：有序字典

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

'''

#namedtuple

想表示坐标点x为1，y为2的坐标

from collections import namedtuple
#point = namedtuple('坐标',['x','y','z'])  #第二个参数既可以传可迭代对象，也可以传字符串
point = namedtuple('坐标','x y z')  #字符串必须要空格隔开，不空格就是一个
p = point(1,2)  #注意元素的个数必须跟namedtuple第二个参数里面的值数量一致
print(p)
print(p.x)
print(p.y)
card = namedtuple('扑克牌'，'color number')
A = card('♠','A')
print(A)
print(A.color)
print(A.number)

　　

用具名元组来记录一个城市的信息

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

　　

 

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

　　

deque 双端队列

两端都能进值，两端都能取值

特殊点：双端队列可以根据索引在任意位置插值

队列不应该支持任意位置插值，只能在首尾插值(不能插队)

四种方法：append(尾部追加)，appendleft，pop（末尾取值）,popleft

from collections import deque
q = deque(['a','b','c'])
q.append(1)
q.appendleft(2)
print(q.pop())  #1
print(q.popleft)  #2
​
q.insert(1,'hahaha')  #往中间插入值
print(q.pop())
print(q.popleft())
print(q.popleft())
​

　　

OrderedDict 有序字典

from collections import OrderedDict
order_d = OrderedDict([('a',1),('b',2),('c',3)])
order_d1 = OrderedDict()
order_d1['x'] = 1
order_d1['y'] = 2
order_d1['z'] = 3
print(order_d1)
for i in order_d1:
    print(i)
#print(order_d1)

　　

defaultdict默认值字典

有如下值集合[11,22,33,44,55,66,77,88,99...]，将所有大于66的值保存至字典的第一个key中，将小于66的值保存至第二个key的值中。

即：{'k1':大于66，'k2':小于66}

#原生代码
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]
#默认值字典表达式
form collections import defaultdict
values = [11,22,33,44,55,66,77,88,99,90]
my_dict = defaultdict(list)  #后续该字典中新建的key对应的value，值默认就是列表
for value in values:
    if value > 66:
        my_dict['k1'].append(value)
    else:
        my_dict['k2'].append(value)

　　

 

Counter

#例：统计s = 'abcdeabcdabcaba'这个字符串每一个字符，在当前字符串出现的次数
from collections import Counter
s = 'abcdeabcdabcaba'
res = Counter(s)
print(res)

　　

时间模块

time时间的表达形式有三种：

1、时间戳

2、格式化时间（主要是用来展示给人看的）

3、结构化时间

#时间戳
import time
​
print(time.time())    #时间戳
​
​
#格式化时间
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
%y    两位数的年份表示(00-99)
​
%Y    四位数的年份表示(000-9999)
​
%m    月份（01-12）
​
%d    月内中的一天（0-31）
​
%H    24小时制小时数（0-23）
​
%I    24小时制小时数（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    当前时区的名称
​
%%    %本身

 

时间戳、结构化时间、格式化时间之间的互相转换

结构化时间
​
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.strptime('%Y-%m',time.localtime()),%Y-%m))

 

 

time.sleep() #让程序睡多久

 

#date time
​
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())   #weekday是0-6表示星期，0表示星期一，得到的结果是3，就是星期四
​
print(res.isoweekday())    #1-7表示的是星期，1是星期一，7是星期日

 

 

时间之间的运算

#timedelta
​
'''日期对象 = 日期对象 +/- timedelta对象
​
timedelta对象 = 日期对象 +/- 日期对象'''
​
current_time = datetime.date.today()
​
timetel_t = datetime.timedelta(days=7)   #day=7就是7天的意思
​
#print(current_time+timetel_t)   #结果是当前日期加7天
res1 = current_time+timetel_t   #日期对象
print(current_time - timetel_t)
print(res1-current_time)

　　

小练习：计算今天距离今年过生日还有多少天

birth = datetime.data(2019,12,21)
current_time = datetime.date.today()
print(birth-current_time)  #156 days, 0:00:00

 

UTC时间

dt_today = datetime.datetime.today()
​
dt_now = datetime.datetime.now()
​
dt_utnow = datetime.datetime.utcnow()   #和北京时间相差8个小时   
​
print(dt_utcnow.dt mow,dt_today)
​

　　

​

random模块：随机模块

import random
​
print(random.randint(1,6))    #随机取一个提供的整数范围内的数字，包含首尾
​
​
​
print(random.random())    #随机取0-1之间的小数
​
​
​
print(random.choice([1,2,3]))     #摇号,随机从列表中取一个值
​
​
​
res = [1,2,3,4,5,6]
​
random.shuffle(res)     #洗牌，打乱一个有序的顺序
​
print(res)   

　　

例：生成5位数的随机验证码，大写字母、小写字母、数字

chr

random.choice

封装成一个函数，用户想生成几位就生成几位

def get_code(n):
    cofe = ''
    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模块：跟操作系统打交道的模块

常见的

import os
BASE_DIR = os.path.dirname(__file__)
MOVIE_DIR = os.path.join(BASE_DIR,'老师们的作品')
movie_list = os.listdir(MOVIE_DIR)
#listdir会将当前文件夹里面，所有的文件展示出来
while True:
    for i,j in enumerate(movie_list,1):
        print(i,j)
    choice = input('你先看谁的？').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 = ps.path.join(MOVIE_DIR,target_file)
            with open(target_path,'r',encoding='utf-8') as f:
                print(f.read())
 #os模块主要用在路径上                
os.mkdir('电影每日精选')   #自动创建文件夹
​
print(os.path.exists('文件夹路径'))    #判断文件是否存在
​
print(os.path.isfile('文件夹路径'))    #这个只能判断文件，不能判断文件夹
​
这三个是配合起来使用的，先判断这个文件夹在不在，如果不在，创建一个
​
os.makedirs('dirname1/dirname2')    #可生成多层递归目录
​
os.removedirs('dirname1')    #若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，以此类推
​
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.getwd()   #获取当前工作目录，即当前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最后的文件名，如何以/或\结尾，那么就会返回空值，即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模块：跟python解释器打交道的模块

​
import sys
​
sys.path.append()     #将某个路径添加到系统的环境变量中
​
print(sys.platform)    #当前的系统
​
print(sys.version)      #python解释器版本
​
​
​
print(sys.argv)    #返回的是当前文件夹的名字，sys.argv可以接收在终端敲了这个文件之后，后面跟的参数，会一次性把参数拿到，命令行启动文件，可以做身份验证
​

　　

​

序列化模块

序列：字符串

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

1、写入文件的数据必须是字符串

2、基于网络传输的数据必须是二进制

str.encode()才能变成二进制，统一转成字符串，才能转成二进制

因为只有转成了字符串，才能够做一个数据的存储（传输）

 

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

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

json模块

1、能够将数据类型转换成字符串存起来，基于网络传输

2、所有的语言都支持json格式（相当于中间人）

缺点：支持的数据类型很少

支持：（字符串、列表、字典、整型、元组（转成列表来存的）、布尔值，这几个是可以序列化的

 

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

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

d = {"name":"jason"}
print(d)
res = json.dumps(d)   #json格式的字符串，必须是双引号，它内部对应的是:'{"name":"jason"}',外层是单引号，内层是双引号
print(res,type(res))
res1 = json.loads(res)   #loads一下又从字符串变成字典
print(res1,type(res1))

　　

dump：传文件

load：传文件

d = {"name":"jason"}
#写入文件
with open('userinfo','w',encoding='utf-8') as f:
    json.dump(d,f)   #先转字符串并自动写入文件
    json.dump(d,f)
    
#取出来
with open('userinfo','r',encoding='utf-8') as f:
    res1 = json.load(f)   #不能够多次反序列化
    res2 = json.load(f)
    print(res1,type(res1))
    print(res2,type(res2))

　　

    
    
​

ensure_ascii=False 不要转码

 

pickle模块

缺点：只支持python语言

优点：python所有的数据类型都支持

用pickle操作文件的时候，文件的打开模式必须是b模式

import pickle
​
d = {'name','jason'}
​
print(pickle.dumps(d))    #将对象直接转成二进制
​
res1 = pickle.loads(res)
​
print(res1.type(res1))

　　

 

subprocess（子进程）

sub:子

process:进程

1、用户通过网络连接上了你的这台电脑

2、用户输入相应的命令，基于网络发送给了你这台电脑上摸个程序

3、获取用户命令，里面subprocess执行该用户命令

4、将执行结果再基于网络发送给用户

这样就实现用户远程操作你这台电脑的操作

while True:
    cmd = input('cmd>>>:').strip()
    import subprocess
​
    obj = subprocess.Popen('tasklist',shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
​
    #print(obj)
​
    print('正确命令返回的结果stdout',obj.stdout.read().decode('gbk'))
​
    print('错误命令返回的提示信息stderr',obj.stderr.read().decode('gbk'))
​

　　

​