常用模块（一）

一、模块

什么是模块？模块是别人写好的功能放在一个文件里面，分为三种模块：

1.内置模块：安装python解释器的时候一起装上的

2.第三方模块、扩展模块：需要自己安装

3.自定义模块：你写的py文件

二、序列化模块

序列：列表，元组，字符串，bytes

什么叫序列化：把一个数据类型转换成字符串、bytes类型的过程就是序列化

为什么要把一个数据类型序列化？

{'name':'路飞', 'sex':'male'}

当你需要把一个数据类型储存在文件中

当你需要把也给数据类型通过网络传输的时候及不安全的

1.json模块

import json
stu = {'name':'路飞', 'gender':'male'}
ret = json.dumps(stu)  # 序列化过程
print(stu, type(stu))
print(ret, type(ret))

# d = json.loads(ret)    # 反序列化的过程
# print('d-->',d,type(d))

# lst = [1,2,3,4,'aaa','bbb']
# ret = json.dumps(lst)  # 序列化的过程
# print(lst,type(lst))
# print(ret,type(ret))
#
# d = json.loads(ret)    # 反序列化的过程
# print('d-->',d,type(d))

json的优点：

　　所有的语言都通用

缺点：

　　只支持非常少的数据类型

　　　　在网络操作中，以及多语言环境中，要传递字典、数字、字符串、列表等简单的数据类型的时候使用。

　　对数据类型的约束很苛刻：

　　　　字典的key必须是字符串

　　　　只支持：数字，字符串，列表，字典

　　　　且所有的字符串都必须是用“”表示

    dumps(dic/list)   dic/list --> str  序列化方法
    loads(str)        str --> dic/list  反序列化方法
    dump(dic/lst,f)   dic/list --> 文件 序列化方法
    load(f)           文件 --> dic/list 反序列化方法 多次dump进入文件中的数据load会报错
    参数：ensure_ascii=False 希望序列化的中文能以中文的形式被现实并且写到文件中

　（1）方法dump load这两个方法，是完全和文件打交道。

# dic = {'name':'路飞','sex':'male'}
# with open('json_file','w',encoding='utf-8') as f:
#     json.dump(dic,f,ensure_ascii=False)

# with open('json_file','r',encoding='utf-8') as f:
#     dic = json.load(f)
# print(dic,dic['name'])

　（2）能不能多次向同一个文件中dump？可以，但是不能多次load

# dic = {'name':'路飞','sex':'male'}
# with open('json_file','w',encoding='utf-8') as f:
#     json.dump(dic,f,ensure_ascii=False)
#     json.dump(dic,f,ensure_ascii=False)
#     json.dump(dic,f,ensure_ascii=False)
#     json.dump(dic,f,ensure_ascii=False)
#     json.dump(dic,f,ensure_ascii=False)

# with open('json_file','r',encoding='utf-8') as f:
#     dic = json.load(f)

　（3）有需求要向文件中写入多个字典

# def my_dumps(dic):
#     with open('json_file', 'a', encoding='utf-8') as f:
#         dic_str = json.dumps(dic)
#         f.write(dic_str + '
')
# dic1 = {'name':'路飞','sex':'male'}
# dic2 = {'name':'索隆','sex':'male'}
# dic3 = {'name':'山治','sex':'male'}
# my_dumps(dic1)
# my_dumps(dic2)
# my_dumps(dic3)
#
# with open('json_file','r',encoding='utf-8') as f:
#     for line in f:
#         dic = json.loads(line.strip())
#         print(dic['name'])

　（4）json格式化

# import json
# data = {'username':['李华','二愣子'],'sex':'male','age':16}
# json_dic2 = json.dumps(data,sort_keys=True,indent=4,separators=(',',':'),ensure_ascii=False)
# print(json_dic2)

　　

2.pickle

import pickle
# class Course():
#     def __init__(self,name,price):
#         self.name = name
#         self.price = price

# python = Course('python',29800)
# linux = Course('linux',25800)
# mysql = Course('mysql',18000)
# ret = pickle.dumps(python)
# print(ret)

# p = pickle.loads(ret)
# print(p.name,p.price)

# with open('pickle_file','wb') as f:
#     pickle.dump(python,f)

# with open('pickle_file','rb') as f:
#     course = pickle.load(f)
# print(course.name)

　　

pickle的dump，load 操作文件必须以+b模式打开。

在load的时候，如果这个要被load的内容所在的类不在内存中，会报错。

pickle支持多次dump和多次load（需要异常处理）

pickle的多次dump

# def my_dump(course):
#     with open('pickle','ab') as f:
#         pickle.dump(course,f)
# my_dump(python)
# my_dump(linux)
# my_dump(mysql)

# with open('pickle','rb') as f:
#     while True:
#         try:
#             content = pickle.load(f)
#             print(content.name)
#         except EOFError:
#             break

　　

三、time模块

时间模块

# 三种格式
    # 时间戳时间（机器） 浮点数 秒为单位  1536023551.0450916
        # 1970-1-1  0：0：0 伦敦时间开始计时
        # 1970-1-1 8：0：0 北京时间
    # 结构化时间（转换） 元组
    # 格式化时间 （人） str数据类型的　　

时间转换关系

print(time.time())  # 1536023699.1837125
print(time.strftime('%H:%M:%S'))  # 09:14:11
print(time.strftime('%Y-%m-%d'))  # 2018-09-04
print(time.strftime('%y-%m-%d'))  # 18-09-04
print(time.strftime('%c'))  # Tue Sep  4 09:30:50 2018
print(time.strftime('%Y-%m-%d %H:%M:%S'))  # 2018-09-04 09:17:30
print(time.localtime())
struct_time = time.localtime()
print(struct_time.tm_mday)
print(struct_time.tm_sec)

str_time = '2018-8-8'
struct_time = time.strptime(str_time,'%Y-%m-%d')
print(struct_time)
time_stamp = time.mktime(struct_time)
print(time_stamp)

timestamp = 2000000000
struct_time = time.localtime(timestamp)
print(struct_time)
strtime = time.strftime('%Y-%m-%d', struct_time)
print(strtime)

　　

import time
def get_timestamp():
    fmt_time = time.strftime('%Y-%m-1')
    struct = time.strptime(fmt_time, '%Y-%m-%d')
    res = time.mktime(struct)
    return res
ret = get_timestamp()
print(ret)

四、random模块

随机数模块

# 随机小数
print(random.random())  # (0,1)
print(random.uniform(2,3))  # (n,m)

# 随机整数
print(random.randint(1,2))  #[1,2]
print(random.randrange(1,2))  # [1,2)
print(random.randrange(1,100,2))  # 1-100奇数

# 从一个列表中随机抽取 ****
lst = [1, 2, 3, 4, 5, ('a', 'b'), 'cc', 'd']
ret = random.choice(lst)
print(ret)
ret = random.choice(range(100))
print(ret)

ret = random.sample(lst, 2)  # 抽2个值
print(ret)

# 乱序***
lst = [1, 2, 3, 4, 5, ('a', 'b'), 'cc', 'd']
random.shuffle(lst)  # 原列表操作
print(lst)

　　

# 请你生成一个6位的验证码（数字和字母）chr 65-90 A-Z; 97-122 a-z
def get_code(n=6, alph_flag = True):
    code = ''
    for i in range(n):
        c = str(random.randint(0,9))
        if alph_flag:
            alpha_upper = chr(random.randint(65,90))
            alpha_lower = chr(random.randint(97,122))
            c = random.choice([c, alpha_upper, alpha_lower])
        code += c
    return code
ret = get_code()
print(ret)

五、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       返回操作系统平台名称

print(__file__)   返回当前文件的绝对路径

　　

七、collsections模块

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

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

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

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

4.OrderedDict: 有序字典

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

内置的数据类型
    int float complex
    str list tuple
    dict set
基础数据类型
    int float complex
    str list tuple
    dict

collections模块
    根据基础数据类型又做了一些扩展
    有序字典    py3.6之后自动有序
    Counter  计数器
    默认字典
    可命名元组
    双端队列

　　

1.Ordereddict有序字典

from collections import OrderedDict
dd = OrderedDict([('a',1),('k1','v1')])
print(dd)
for k in dd:
    print(k,dd[k])
dd['k2'] = 'v2'
print(dd)

　　

2.Counter计数器

Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。计数值可以是任意的Interger（包括0和负数）。Counter类和其他语言的bags或multisets很相似。

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

　

3.defaultdict默认字典

from collections import defaultdict
d = defaultdict(list)
print(d['a'])
d['b'].append(123)
print(d)
d = {}
# func = lambda :'default'
d = defaultdict(lambda :'aaa')
print(d['kkk'])  # aaa
d['k'] = 'vvvvv'
print(d)

　　

有如下值集合 [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)
    else:
        my_dict['k2'].append(value)

defaultdict字典解决方法

　　

4.namedtuple可命名元组

# 结构化时间
# from collections import namedtuple
# birth = namedtuple('Struct_time',['year','month','day'])
# b1 = birth(2018,9,5)
# print(type(b1))
# print(b1.year)
# print(b1.month)
# print(b1.day)
# print(b1)
# 可命名元组非常类似一个只有属性没有方法的类
# ['year','month','day']是对象属性名
# Struct_time是类 的名字
# 这个类最大的特点就是一旦实例化 不能修改属性的值
# 可以通过.name直接调用

5.deque双端队列

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

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

# list的缺点
# 双端队列可以弥补
# 队列
# from collections import deque
# dq = deque()
# dq.append(1)
# dq.append(2) # 右边添加
# dq.appendleft(3) # 左边添加
# print(dq)
# print(dq.pop())  # 取值
# print(dq.popleft())

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