模块

colectiong模块

在python内置的数据类型(dict list set tuple)的基础上,collections模块还提供了几个额外的数据类型
Counter deque defaultdict namedtuple OrderedDict
Counter     　　　　计数器   　用来计数的
deque     　　　　  双端队列     不过这个两头都能进能出
defaultdict　　    带有默认值的字典
namedtuple   　　  具名元组      直接生成可以使用名字来访问元素内筒的tuple
OrderedDict       有序的字典

namedtuple

# namedtuple(名字,其中的数据参数)     扑克牌    坐标     一个城市的信息
from collections import namedtuple
# 坐标
point = namedtuple('坐标是',['x','y','z'])
point_num = point(2,3,3)
print(point_num)  # 坐标是(x=2, y=3, z=3)
print(point_num.x)  # 2
print(point_num.y)  # 3
print(point_num.z)  # 3

# 扑克
Poker = namedtuple('poker','flower num')
Poker_type = Poker('♠','A')
print(Poker_type)  # poker(flower='♠', num='A')
print(Poker_type.flower)  # ♠
print(Poker_type.num)  # A

城市
City = namedtuple('USA','name hobby')
City_n = City('Koby','basketball')
print(City_n)  # USA(name='洛杉矶', hobby='Koby basetball')
print(City_n.name)  # Koby
print(City_n.hobby)  # basketball

队列

# 队列   先进先出(FIFO    frist in frist out)   不能插队
import queue
q = queue.Queue()    # 生成队列对象
q.put('frist')   # 向队列中添加值
q.put('second')
q.put('third')

print(q.get())  # frist 向队列要值
print(q.get())  # second
print(q.get())  # third
print(q.get())  # 如果队列中的值取完了    程序不会报错  而是在哪里跌倒就在那里歇会  直到从队列中拿到值

deque

# deque 双端队列       append    appendeleft      pop     popleft
# from collections import deque   #####自行解注释
q = deque(['a','b','c'])
q.append('哈哈')  # 追加   直接加在源列表最后
q.appendleft('你猜我在那里')  # 在原列表的最开始添加元素
print(q)  # deque(['你猜我在那里', 'a', 'b', 'c', '哈哈'])
#
p = deque([1,2,3])
print(p.pop())  # 按照索引弹出最后一个元素
print(p.popleft())  # 弹出第一个索引对应的值
#
p = deque([1,2,3])
p.insert(2,'你把我插队在哪里')  # 特殊     双端队列可以在根据索引在任意位置插值
print(p)  # deque([1, 2, '你把我插队在哪里', 3])
p.insert(4,'你把我插在哪里')
print(p)  # deque([1, 2, '你把我插队在哪里', 3, '你把我插在哪里'])
#
dic = dict([('name','james'),('age',20)])  # 创建字典的方式  一般不用
print(dic)  # {'name': 'james', 'age': 20}

OrderedDict

OrderedDict    有序字典   python中的字典是无序的    但是用了这个  是按照你书写的顺序了
from collections import OrderedDict
dic = OrderedDict([('name','james'),('age','20')])
print(dic)  # OrderedDict([('name', 'james'), ('age', '20')])
dic1 = OrderedDict()
dic1['x'] = 1
dic1['y'] = 2
dic1['z'] = 3
print(dic1)  # OrderedDict([('x', 1), ('y', 2), ('z', 3)])

defaultdict

num = [1,2,3,4,5,6,7,8,9]
dic = defaultdict(list)
for i in num:
    if i < 6:
        dic['k1'].append(i)
    else:
        dic['k2'].append(i)
print(dic)  # defaultdict(<class 'list'>, {'k1': [1, 2, 3, 4, 5], 'k2': [6, 7, 8, 9]})


my_dict1 = defaultdict(str)
print(my_dict1['xxx'])  # 返回空

my_dict2 = defaultdict(bool)
print(my_dict2['kkk'])  # False

my_dict3 = defaultdict(tuple)
print(my_dict3['mmm'])  # ()

my_dict4 = defaultdict(int)
print(my_dict4['yyy'])  # 0
print(my_dict4['xxx'])  # 0

Counter

   先将字符串内容循环取值  加入字典的key     再计算次数  当作字典的value存入字典
from collections import Counter
s = 'asdasdasdasdasd'
res = Counter(s)
print(res)  # Counter({'a': 5, 's': 5, 'd': 5})   一次尽量两步

time模块

时间的三种表现形式

　　1  时间戳    time.time   当前时间距离1970-01-01  00:00:00  过去的秒数

import time
print(time.time())  # 1563447416.9686005

　　2  格式化时间  time.strftime    按照一定的格式输出需要的时间     2019-07-18  18:46:46    例如这样子的

　　　　

print(time.strftime('%Y-%m-%d'))  # 2019-07-18
print(time.strftime('%Y-%m-%d %H:%M:%S'))  # 2019-07-18 18:56:15
print(time.strftime('%Y-%m-%d %X'))  # 2019-07-18 18:56:15   %X等价于%H:%M:%S

　　3  结构化时间   time.localtion      当前的是按照一定的结构        time.struct_time(tm_year=2019, tm_mon=7, tm_mday=18, tm_hour=18, tm_min=47, tm_sec=55, tm_wday=3, tm_yday=199, tm_isdst=0)

格式化时间的字符串

%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 当前时区的名称
%% %号本身

python中时间日期格式化符号：

datetime模块

import datetime
print(datetime.date.today())  # 2019-07-18   今天的日期     年月日的形式输出
print(datetime.datetime.today())  # 2019-07-18 18:54:18.496601    也是今天是日期  年月日时分秒

res = datetime.date.today()
print(res.year)  # 2019
print(res.month)  # 7
print(res.day)  # 18 
print(res.weekday())  # 3   0-6表示星期  0表示周一
print(res.isoweekday())  # 1-7表示星期 7就是周日

时间的运算

# 天数     timedalta
local_time = datetime.date.today()  # 2019-07-18          # 日期对象
num_time = datetime.timedelta(days=10)      # 10天     运算天数
res = local_time+num_time  # 今天过后10天
res1 = local_time-num_time  #  今天之前10天 
print(res)  # 2019-07-28
print(res1)  # 2019-07-08

UTC时间    根据格林威治的时间

dt_today = datetime.datetime.today()
dt_now = datetime.datetime.now()
dt_utcnow = datetime.datetime.utcnow()
print(dt_utcnow)  # 2019-07-18 11:09:33.884600
print(dt_now)  # 2019-07-18 19:09:33.884600
print(dt_today)  # 2019-07-18 19:09:33.884601

random模块(随机数)

import random

print(random.randint(0,9))  # 随机一个范围内的整数
print(random.random())  # 小数点后面17位      随机一个0-1之间的小数
print(random.choice([1,2,3,4,5,6,7,8,9]))  # 随机选取一个列表内的数    适用于摇号

# shuffle  #   洗牌   数据随机打乱
num = [1,2,3,4,5,6,7,8,9]
random.shuffle(num)
print(num)

随机验证码联系

import random
verification_num = input('输入验证码位数:')
verification_num = int(verification_num)

def verification(verification_num):
    verification_code = ''
    for num in range(verification_num):
       upper_str = chr(random.randint(65,90))
       lower_str = chr(random.randint(97,122))
       random_int = str(random.randint(0,9))
       verification_code += random.choice([upper_str,lower_str,random_int])
    print(verification_code)
    return verification_code
verification(verification_num)

os模块

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

import os
# os 使用方法
os.remove()     删除一个文件
os.rename('原名字','修改后名字')    修改文件名字
os.mkdir('文件名')   生成一个单级的空目录
os.rmdir('文件名')  删除一个单级的空目录   目录不为空 无法删除  会报错
os.listdit('文件名')    列出指定文件下所有的文件和子目录  包括隐藏文件





os.makedirs('文件1/文件2/文件3')    生成一个多层的目录
os.
removedirs('文件名')      目录为空的  就删除   并返回上一级目录  还空   就继续删  以此类推
os.stat('path/filename')  获取文件/目录信息
os.system("bash command")  运行shell命令，直接显示
os.popen("bash command).read()  运行shell命令，获取执行结果
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd

# os.path  使用方法

os.path.exists(path)    检查文件路径是否存在,存在返回Ture   不存在返回False
os.path.ahspath(path)  返回规范的绝对路径
os.path.isabs(path)   判断路径是不是绝对路径      是  返回  Ture
os.path.isfile(path)   判断是不是一个存在的文件   是 返回Ture
 否则返回None
os.path.isdir(path)  判断是否是存在的目录   存在返回Ture   否则返回None
os.path.dirname(path)   返回路径文件的目录 
os.path.split(path)  路径切分成目录和文件名



os.path.basename(path) 返回path最后的文件名。如何path以／或结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小

sys模块

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

import sys

sys.path.append()    将某个路径添加在环境变量中


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

序列化模块

序列化

　　序列  字符串

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

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

json

dumps和loads

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'}]

dunp和load

d = {"name":"zhang",'age':23}
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))  # {'name': 'zhang', 'age': 23} <class 'dict'>

ps:若在序列化的信息中含有中文字符,不想由任何我改变的转化,可以用ensure_ascii命令

pickle

dumps和loads

import pickle
d = {"name":"zhang",'age':23}
res = pickle.dumps(d)  # 将对象直接转成二进制
print(pickle.dumps(d))

#b'x80x03}qx00(Xx04x00x00x00nameqx01Xx05x00x00x00zhangqx02Xx03x00x00x00ageqx03Kx17u.'

res1 = pickle.loads(res)
print(res1,type(res1))  # {'name': 'zhang', 'age': 23} <class 'dict'>

dump和load

import pickle
d = {"name":"zhang",'age':23}  
with open('userinfo_1','wb') as f:  # 用pickle操作文件时打开文件模式必须为b模式
    pickle.dump(d,f)

with open('userinfo_1','rb') as f:
    res = pickle.load(f)
    print(res,type(res))  # {'name': 'zhang', 'age': 23} <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'))