一些常用模块

常用模块

今天学习了一些常用的模块：collection模块、time与datetime模块、os模块、sys模块、random模块、序列化模块（json、pickle）以及subprocess模块。

collection模块

namedtuple具名元组

from collections import namedtuple
point = namedtuple('坐标',['x','y','z'])  # 第二个参数既可以传可迭代对象
point = namedtuple('坐标','x y z')  # 也可以传字符串 但是字符串之间以空格隔开
p = point(1,2,5)  # 注意元素的个数必须跟namedtuple第二个参数里面的值数量一致
print(p)
print(p.x)
print(p.y)
print(p.z)

deque

# 队列:现进先出(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双端队列     pop、popleft、append、appendleft
from collections import deque
q = deque(['a','b','c'])
q.append(1)
q.appendleft(2)
print(q.pop())
print(q.popleft())
# 队列不应该支持任意位置插值、只能在首尾插值(不能插队)
# 特殊点:双端队列可以根据索引在任意位置插值
q.insert(0,'哈哈哈')

OrderedDict

使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序，如果要保持Key的顺序，可以用OrderedDict：

normal_d = dict([('a',1),('b',2),('c',3)])
print(normal_d)
from collections import OrderedDict
order_d = OrderedDict([('a',1),('b',2),('c',3)])
print(order_d)

defaultdict默认值字典

#使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict：
my_dict1 = defaultdict(list)  #  后续该字典中新建的key对应的value默认就是列表
print(my_dict1['yyy'])
print(my_dict1)  # defaultdict(<class 'list'>, {'yyy': []})

my_dict1 = defaultdict(int)
print(my_dict1['xxx'])

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

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

Counter统计

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

time与datetime模块

在Python中，通常有这三种方式来表示时间：时间戳、元组(struct_time)、格式化的时间字符串：

(1)时间戳(timestamp) ：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。

(2)格式化的时间字符串(Format String)： ‘1999-12-06’

(3)结构化时间(struct_time) ：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等）

​ .time() 时间戳

​ .localtime('时间戳') 时间戳转结构化时间

​ .mktime(’结构化时间‘) 结构化时间转时间戳

​ .strftime(’格式‘，结构化时间) 结构化时间转格式化时间

​ .strptime('格式化时间字符串', '格式') 格式化时间转结构化时间

格式化时间：

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

结构化时间：是一个元组

索引（Index）	属性（Attribute）	值（Values）
0	tm_year（年）	比如2011
1	tm_mon（月）	1 - 12
2	tm_mday（日）	1 - 31
3	tm_hour（时）	0 - 23
4	tm_min（分）	0 - 59
5	tm_sec（秒）	0 - 60
6	tm_wday（weekday）	0 - 6（0表示周一）
7	tm_yday（一年中的第几天）	1 - 366
8	tm_isdst（是否是夏令时）	默认为0

#导入时间模块
>>>import time

#时间戳
>>>time.time()
1500875844.800804

#时间字符串
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 13:54:37'
>>>time.strftime("%Y-%m-%d %H-%M-%S")
'2017-07-24 13-55-04'

(******)
#日期对象 = 日期对象 +/- 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)

dt_now = datetime.datetime.now()
dt_utcnow = datetime.datetime.utcnow()
print(dt_utcnow)
print(dt_now)
#UTC时间，与英国伦敦当地时间一致

random模块(随机模块)

import random
print(random.randint(1,6))  # 随机取一个你提供的整数范围内的数字  包含首尾
print(random.random())  # 随机取0-1之间小数
print(random.choice([1,2,3,4,5,6]))  # 摇号 随机从列表中取一个元素

res = [1,2,3,4,5,6]
random.shuffle(res)  # 打乱顺序
print(res)

# 生成随机验证码
import random
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(5)
print(res)
#思路是将需要生成几位验证码的位数当做参数传进去，然后生成随机的大写字母、小写字母以及数字，然后每次从上面三个中随机选择一个

os模块

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

#找到当前文件所属的文件夹：os.path.dirname(__file__)
BASE_DIR = os.path.dirname(__file__)
print(BASE_DIR) #结果：/Users/mac/Desktop/

#组合路径： os.path.join(BASE_DIR,'movie')
MOVIE_DIR = os.path.join(BASE_DIR,'movie')
print(MOVIE_DIR) #结果： /Users/mac/Desktop/movie  


os.path.exists(path)  #如果path存在，返回True；如果path不存在，返回False
os.listdir('dirname')    #列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  #删除一个文件os.rename("oldname","newname")  #重命名文件/目录
os.mkdir('dirname')    #生成单级目录；相当于shell中mkdir dirname
os.rmdir(r'/Users/mac/Desktop/movie')  # 只能删空文件夹
os.path.getsize(r'/Users/mac/Desktop/movie.txt'))  # 获取文件字节大小

sys模块

# 将某个路径添加到系统的环境变量中
#将文件当成项目启动文件的时候，需要把项目所在路径添加进sys.path，python的环境变量中。
sys.path.append()  
print(sys.version)  # python解释器的版本
print(sys.platform) #系统平台

#重点：sys.argv
'''
    当执行python3  xxx.py文件的时候，使用sys.argv,能获取到命令行输入的参数
    例1：
        python3 test.py
        print(sys.argv)  #结果：['test.py', 'test']
    例2：
        python3 test.py username password
        print(sys.argv)  #结果：['test.py', 'test', 'username', 'password']
'''

序列化模块（json、pickle）

什么叫序列化——将原本的字典、列表等内容转换成一个字符串的过程就叫做序列化。序列化指的就是把其他数据类型转化为字符串的过程。

Python中的反序列化是什么意思？反序列化操作，将str字符串转换成python中的数据结构

写入文件时的数据必须是字符串，但是我们要将一个字典类型的数据写入文件的时候，就会报错：TypeError: write() argument must be str, not dict。这个时候，就需要用到序列化操作，将字典类型的对象序列化为一个字符串、然后写入文件中。

字符串 ——> 反序列化（loads） ——> 数据结构 ——> 序列化(dumps) ——> 字符串

json

所有的语言都支持json格式,支持的数据类型很少 字符串 列表 字典 整型 元组(转成列表) 布尔值

Json模块提供了四个功能：dumps、dump、loads、load

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

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

import json
#dumps  # loads
d = {'name':'jason'}
print(d,type(d))  # {'name': 'jason'} <class 'dict'>
res = json.dumps(d)
print(res,type(res))  # {"name": "jason"} <class 'str'> 序列化，将字典类型转成了json格式
res1 = json.loads(res)
print(res1,type(res1))  # {'name': 'jason'} <class 'dict'>反序列化，将json格式转回了字典类型

#dump #load
with open('userinfo','w',encoding='utf-8') as f:
    json.dump(d,f)  # 接收一个文件句柄作为对像，直接将字典序列化为一个json格式字符串写入文件句柄中。
with open('userinfo','r',encoding='utf-8') as f:
    res = json.load(f)  # 接收一个文件句柄对象，直接将文件中的json格式的字符串反序列化为一个字典对象返回。
    print(res,type(res))

pickle模块

用于Python程序之间的序列化。

picker和json两个模块的不同：

• json，用于字符串 和 python数据类型间进行转换
• pickle，用于python特有的类型 和 python的数据类型间进行转换。
• pickle可以对Python的对象进行序列化，而json模块就不行，支持的数据类型很少 字符串 列表 字典 整型 元组(转成列表) 布尔值。
• pickle对Python所有的数据类型都支持。
• 方法都是dumps/dump, loads/load
• 用pickle操作文件的时候 文件的打开模式必须是b模式

import pickle
# dumps #loads
d = {'name':'jason'}
res = pickle.dumps(d)  # 将对象直接转成二进制
print(pickle.dumps(d))  #结果：b'x80x03}qx00Xx04x00x00x00nameqx01Xx05x00x00x00jasonqx02s.'

res1 = pickle.loads(res)
print(res1,type(res1))  #结果：{'name': 'jason'} <class 'dict'>


#dump #load
"""
用pickle操作文件的时候 文件的打开模式必须是b模式
"""
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:进程
"""
"""
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'))