常用模块介绍

一collection模块

　　1.1namedtuple(具名元组)

　　具名元组:生成可以使用名字来访问元素内容的tuple

　　eg:

from collections import namedtuple
point = namedtuple('坐标点',['x','y','z'])  # 第一个参数是整个的名字typeame,第二个参数可以是可迭代对象也可以是字符串,但是字符串之间要用空格隔开
point1 = namedtuple('坐标点','x y z')
p = point(2,3,4)  # 输入的值的数目要和上面名字数量一致
p1 = point1(5,6,7)
print(p)  # 坐标点(x=2, y=3, z=4)
print(p.x)  # 按照名字输出 2
print(p.y)  # 3
print(p.z)  # 4
print(p1)  # 坐标点(x=5, y=6, z=7)
print(p1.x)  # 5  
print(p1.y)  # 6
print(p1.z)  # 7

card = namedtuple('扑克牌','color number')
card1 = namedtuple('扑克牌',['color','number'])
A = card('♠','A')
print(A)  # 扑克牌(color='♠', number='A')
print(A.color)  # ♠
print(A.number)  # A

　　1.2deque:双端队列

　　队列(FIFO):先进先出,类似于排队

import queue
q = queue.Queue()  # 生成队列对象
q.put(1)  # 往队列列中添加值
q.put(2)
q.put(3)
print(q.get())  # 从队列中取值先进先出 1
print(q.get())  # 2
print(q.get())  # 3
print(q.get())  # 当队列中没值可取时,会原地等待直至拿到值才停止

　　双端队列(deque)中常用的命令:

　　　　1.append,appendleft(尾部添加,首部添加)

　　　　2.pop,popleft(尾部弹出,首部弹出)

from collections import deque
list1 = deque(['a','b','c'])
list1.append(2)  
print(list1)  # deque(['a', 'b', 'c', 2])
list1.appendleft(1)
print(list1)  # deque([1, 'a', 'b', 'c', 2])
list1.pop()
print(list1)  # deque([1, 'a', 'b', 'c'])
list1.popleft()
print(list1)  # deque([1, 'a', 'b', 'c'])

ps:双端队列可以根据索引再任意位置插入数据

from collections import deque
list1 = deque(['a','b','c'])
list1.insert(1,'我就要插队')
print(list1)  # deque(['a', '我就要插队', 'b', 'c'])

　　1.3OrderedDict(有序字典)

　　使用字典时key是无序的.再对key做迭代的时候,是不能确定顺序的,这时候可以使用OrderedDict它可以使key保持顺序(会按照键插入的先后顺序)

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


>>> order_d1 = dict()
>>> order_d1['x'] = 1
>>> order_d1['y'] = 2
>>> order_d1['z'] = 3
>>> print(order_d1)
{'y': 2, 'x': 1, 'z': 3}
>>> for i in order_d1:
...     print(i)
...
y
x
z

　　1.4defaultdict(默认值字典)

from 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 % 2 == 1 :
        my_dict['k1'].append(value)
    else:
        my_dict['k2'].append(value)
print(my_dict)  
# defaultdict(<class 'list'>, {'k1': [11, 33, 55, 77, 99], 'k2': [22, 44, 66, 88, 90]})

ps:使用字典时当一个字典的key不存在的时候会报错,当不想报错时,可以返回一默认值这时候就可以使用defaultdict.

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

　　1.5Counter(计数)

　　Counter:其作用是统计一个容器类型中某个元素的数量,返回的是一个字典,字典的key是统计元素,value是数目.

from collections import Counter
s = 'fadfasdfasdfasfasdfafafa'
print(Counter(s))
#Counter({'f': 8, 'a': 8, 'd': 4, 's': 4})

二.时间模块(time/datetime)

　　2.1时间的三种表现形式

　　　　1.时间戳

　　　　2.格式化时间(用来展示给人看的)

　　　　3.结构化时间

　　2.2time模块

　　　　2.2.1时间戳

import time
print(time.time())  # 1563446302.2636714
# 该时间是距离1970/1/1 00:00:00的秒数

　　　　2.2.2格式化时间

import time
print(time.strftime('%Y-%m-%d %H:%M:%S'))  # 2019-07-18 18:42:41
print(time.strftime('%Y/%m/%d %X'))  # %X等价于%H:%M:%S,字符间的拼接可自己设置 2019/07/18 18:42:41

ps:补充关于其余符号的含义

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

　　　　2.2.3结构化时间

import time
print(time.localtime())
#time.struct_time(tm_year=2019, tm_mon=7, tm_mday=18, tm_hour=18, tm_min=50, tm_sec=32, tm_wday=3, tm_yday=199, tm_isdst=0)

ps补充:三种格式之间转化

import time
res = time.localtime(time.time())
print(time.mktime(res))
print(time.strftime('%Y-%m',time.localtime()))
print(time.strptime(time.strftime('%Y-%m',time.localtime()),'%Y-%m'))
#1563447700.0
#2019-07
#time.struct_time(tm_year=2019, tm_mon=7, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=182, tm_isdst=-1)

　　2.3datetime

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

ps:时间加减的两种不同方式

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

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

时间的加减

ps:utc时间

dt_today = datetime.datetime.today()  # 北京时间
dt_now = datetime.datetime.now()  # 伦敦时间
dt_utcnow = datetime.datetime.utcnow()  # 伦敦时间 和北京时间差8小时
print(dt_utcnow)  # 2019-07-18 11:19:40.922292
print(dt_now)  # 2019-07-18 19:19:40.922292
print(dt_today)  # 2019-07-18 19:19:40.922292

三.random(随机)模块

　　3.1随机取一个范围内的整数数字(包括首尾)

print(random.randint(1,6))  # 掷色子(返回的是整数)

　　3.2返回0-1之间的小数

print(random.random())  

　　3.3打乱顺序

a=[1,2,3,4,5,6,7,8,9,0]
random.shuffle(a)
print(a)  # [9, 6, 8, 2, 3, 7, 1, 0, 4, 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

四.os模块(和操作系统打交道的模块)

os.mkdir('dirname')    # 生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')    # 删除单级空目录，若目录不为空则无法删除，报错
os.listdir('dirname')   #  列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  # 删除一个文件
os.rename("oldname","newname")  # 重命名文件/目录
os.getcwd() # 获取当前工作路径
os.chdir("dirname")  # 切换当前所在目录至指定文件路径
os.path.exists(path)  # 判断文件是否存在如果path存在，返回True；如果path不存在，返回False
os.path.isfile(path)  # 判断文件夹是否存在如果path是一个存在的文件，返回True。否则返回False
os.path.join(path1,[path2[, ...]])  # 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getsize(path) # 返回path的大小(字节数)
os.path.dirname(__file__) # 返回上一级文件夹

五.sys模块(和应用程序打交道)

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

cmd窗口做登陆认证

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)

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

为什么要用序列化:因为写入文件的数据必须是字符串的形式,而基于网路传输的数据必须是二进制.

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

　　6.1json模块

　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命令

import json
dict1 = {'name':'张xx'}
print(json.dumps(dict1,ensure_ascii=False))  # {"name": "张xx"}

　　6.2pickle

dumps和loads

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

#b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x05\x00\x00\x00zhangq\x02X\x03\x00\x00\x00ageq\x03K\x17u.'

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

 

　　　

　

 

来源：https://www.cnblogs.com/z929chongzi/p/11209941.html