模块

collections模块

namedtuple（具名元组）

#一个点的二维坐标
from collections import namedtuple
point = namedtuple('point',['x','y'])
p = point(1,2)
print(p.x)  #1
print(p.y)  #2

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

from collections import namedtuple
city = namedtuple('city',['name country population ') #第一个是类名，第二个是类的各个字段的名字。
tokyo = city('Tokyo','jp',36.333)
print(tokyo) #City(name='Tokyo', country='JP', population=36.933)

deque

　　deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈

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

OrderedDict

使用dict时，key是无序的。在对dict做迭代时，我们无法确定key的顺序。

如果要保持key的顺序，可以用OrderedDict

from collections import OrderedDict
d = dict([('a',1),('b',2),('c',3)])
print(d)  #{'a': 1, 'b': 2, 'c': 3} dict的key是无序的
od =OrderedDict([('a',1),('b',2),('c',3)])
print(od)   #OrderedDict([('a', 1), ('b', 2), ('c', 3)])
#OrderedDict的key是有序的

defaultdict

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

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

 

from collections import defaultdict
values = [11,22,33,44,55,66,77,88,99,90]
my_dict = defaultdict(list)
for value in values:
    if value < 66:
        my_dict['k1'].append(value)
    if value > 66:
        my_dict['k2'].append(value)
print(my_dict)
#  defaultdict(<class 'list'>, {'k1': [11, 22, 33, 44, 55], 'k2': [77, 88, 99, 90]})

使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict：

from collections import defaultdict
dd = defaultdict(lambda : 'N/A')
dd['key1'] = 'abc'
print(dd['key1'])  #abc
print(dd['key2'])  #N/A

counter

　　counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。

from collections import Counter
c = Counter('abdesbdajwbdaaa')
print(c)
#Counter({'a': 5, 'b': 3, 'd': 3, 'e': 1, 's': 1, 'j': 1, 'w': 1})

时间模块

常用方法

1.time.time()
获取当前时间戳
2time.sleep()
推迟指定的时间运行，单位为秒

表示时间的三种方式：

1.时间戳

time.time()
#1563438379.9929085

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

time.strftime('%Y-%m-%d %H:%M:%S')
#2019-07-18 16:27:55

3.结构化时间

time.localtime()

#time.struct_time(tm_year=2019, tm_mon=7, tm_mday=18, tm_hour=16, tm_min=31, tm_sec=9, tm_wday=3, tm_yday=199, tm_isdst=0)

时间戳-->结构化时间

time.localtime(1600000000)
#time.struct_time(tm_year=2020, tm_mon=9, tm_mday=13, tm_hour=20, tm_min=26, tm_sec=40, tm_wday=6, tm_yday=257, tm_isdst=0)

结构化-->时间戳

res = time.localtime(1600000000)
time.mktime(res)
#1600000000.0

结构化时间-->格式化时间

res = time.localtime()
print(time.strftime('%Y-%m-%d',res)
#2019-07-18

格式化时间-->结构化时间

time.strptime(时间字符串，字符串对应格式）
time.strptime('2019-11-11','%Y-%m-%d')

#time.struct_time(tm_year=2019, tm_mon=11, tm_mday=11, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=315, tm_isdst=-1)

datetime模块

import datetime
print(datetime.date.today())    #date :年月日
#2019-07-18

print(datetime.datetime.today())  #datetime:年月日  时分秒
#2019-07-18 16:50:06.550708

res = datetime.date.today()
print(res.weekday())   #0-6表示星期   0表示周一
print(res.isoweekday())   #1-7表示星期  7表示周日

（******）

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

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

current_time = datetime.date.today()   #日期对象
timetel_t = datetime.timedelta(day=7)  #timedelta对象
res1 = current_time + timetel_t  #日期对象
print（res1）#  2019-07-25
print(res1-current_time)   # 7 days, 0:00:00

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

birth = datetime.datetime(2020,1,5,0,0,)
current_time = datetime.datetime.today()
print(birth - current_time)
#170 days, 6:55:11.581293

UTC时间

dt_today = datetime.datetime.today()
dt_now = datetime.datetime.now()
dt_utnow = datetime.datetime.utcnow()    #UTC时间与北京时间的差距
print(dt_utnow,dt_now,dt_today)
#  2019-07-18 09:06:53.308526 2019-07-18 17:06:53.308526 2019-07-18 17:06:53.308526

random模块

import random
#随机小数
print(random.random())   #大于0且小于1之间的小数
0.25151601034070525


#随机整数
random.randint(1,5)   #大于等于1且小于等于5之间的整数

#随机选择一个返回
random.choice([1,2,'23',[23]])  #1或者2或者23或者[23]


#打乱列表顺序
a = [1,3,4,5,7,0]
random.shuffle(a)  #打乱次序
print（a）

练习：生成随机验证码

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.chioce([upper_str,lower_str,random_int])
    return code

os模块

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

os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
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.getcwd() 获取当前工作目录，即当前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最后的文件名。如何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模块

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

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

序列化模块

序列化

　　序列：字符串

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

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

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

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

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

json模块（******）

　　所有语言都支持json格式

　　支持的数据类型很少   （字符串，列表，字典，整型，元组[转成列表] 布尔值）

pickle模块 （****）

　　只支持python

　　python所有的数据类型都支持

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

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

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

import json
f = open('json_file','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)  #dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件
f.close()

f = open('json_file')
dic2 = json.load(f)  #load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回
f.close()
print(type(dic2),dic2)

import json
f = open('file','w')
json.dump({'国籍':'中国'},f)
ret = json.dumps({'国籍':'中国'})
f.write(ret+'
')
json.dump({'国籍':'美国'},f,ensure_ascii=False)
ret = json.dumps({'国籍':'美国'},ensure_ascii=False)
f.write(ret+'
')
f.close()

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