模块二

一.colleciton模块

在内置数据类型（dic,list,set,tuple）的基础上，collections模块还提供了几个额外的数据类型:Counter，deque,defaultdict,namedtuple和OrderedDict等

1.namedtuple:生成可以使用名字来访问元素内容的tuple

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

3.Counter:计数器,主要用来计数

4.OrderedDict:有序字典

5.defaultdict:带有默认值的字典

namedtuple

我们知道tuple可以表示不变集合，例如：一个点的二维坐标可以表示成：

from collections import namedtuple
Point = namedtuple('Point',['x','y'])
p = Point(1,2)
print(p.x)
print(p.y)

类似的，如果要用坐标和半径表示一个圆，也可以用namedtuple定义：

#namedtuple('名称',[属性list]):
Circle = nametuple('Circle',['x','y','r'])

deque

使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储。插入删除效率很低。

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

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

#deque(['y','a','b','c','x'])

deque除了实现list的append()和pop()外,还支持appendleft()和popleft(),这样就可以非常高效地往头部添加或删除元素。

OrderedDict

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

如果要保持Key的顺序,可以用OrderedDict:

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

OrderedDict的Key会按照插入的顺序排列，不是Key本身排序

defaultdict

之前做过的一道题：

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

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

from collections import deafultdict
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)
    else:
        my_dict['k2'].append(value)

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

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

print(dd['key2'])
#'N/A'  #key2不存在，返回默认值

Counter(******)

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

c = Counter('abcdeabcdabcaba')
print(c)
#输出：Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})

二.time，datetime模块

三种表现形式：

　　1.时间戳

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

　　3.结构化时间

time.sleep

time.sleep(secs)
#推迟几秒

time.time()

time.time()  #获取当前时间戳

time.strftime()

import time
time.strftime("%Y-%m-%d %X")
time.strftime("%Y-%m-%d %H:%M:%S")
#两者结果一样的 获取当前的年月日时间

time.localtime()（时间戳）

获取结构化时间

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

几种格式之间的转换图：

time.mktime（结构化时间）

结构化时间---》时间戳

import time
time_tuple = time.localtime(15000000000)
time.mktime(time_tuple)
#1500000000.0

datetime

import datetime
datetime.date.today()   #年月日
datetime.datetime.today()   #年月日 时分秒

三.random

random.random 与 random.uniform()  随机小数

>>> random.random()      # 大于0且小于1之间的小数
0.7664338663654585
>>> random.uniform(1,3) #大于1小于3的小数
1.6270147180533838

random.randint()与random.randrange()随机整数

 random.randint(1,5)  # 大于等于1且小于等于5之间的整数
 random.randrange(1,10,2) # 大于等于1且小于10之间的奇数

random.choice()与random.sample随机返回值

#随机选择一个返回
 random.choice([1,'23',[4,5]])  # #1或者23或者[4,5]
#随机选择多个返回，返回的个数为函数的第二个参数
 random.sample([1,'23',[4,5]],2) # #列表元素任意2个组合
[[4, 5], '23']

random.shuffle()打乱列表顺序

item=[1,3,5,7,9]
random.shuffle(item) # 打乱次序
print(item) 
#[5, 1, 3, 7, 9]

四.os模块

os模块是跟操作系统打交道的模块

#ATM+购物车的例子 settings配置里面
import os
BASE_PATH = os.path.dirname(__file__)  #获取当前文件的根目录
DB_PATH = os.path.join(BASE_PATH，‘db’) #拼接路径

lst = os.listdir(DB_PATH)  #获取当前文件夹下的文件名，返回给列表

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.path.append()

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

sys.platform 和 sys.version

import sys
print(sys.platform)
#win32
print(sys.version)
#3.6.4 (v3.6.4:d48eceb, Dec 19 2017, 06:54:40) [MSC v.1900 64 bit (AMD64)]

sys.argv

import sys
print(sys.argv)
#['E:/demo/test.py']   
#第一个元素是程序本身路径

六.序列化模块

什么是序列化

　　序列：字符串

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

序列化的目的：

　　1.以某种存储形式使自定义对象持久化

　　2.将对象从一个地方传递到另一个地方

　　3.使程序更具维护性

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

dump load

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

pickle

dump  load 与dumps  loads

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

import pickle
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = pickle.dumps(dic)
print(str_dic)  #一串二进制内容

dic2 = pickle.loads(str_dic)
print(dic2)    #字典

import time
struct_time  = time.localtime(1000000000)
print(struct_time)
f = open('pickle_file','wb')
pickle.dump(struct_time,f)
f.close()

f = open('pickle_file','rb')
struct_time2 = pickle.load(f)
print(struct_time2.tm_year)

json模块

　　所有的语言都支持jason格式

　　支持的数据类型很少，  字符串 ，列表 ，字典 ，整形， 元组， 布尔值

pickle模块

　　只支持python

　　python所有的数据类型都支持

他们俩的方法里都有dumps loads 和 dump load

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

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

七.subprocess模块

sub:子     process:进程

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