模块二

序列化

序列化的本质就是将一种数据结构（如字典、列表)等转换成一个特殊的序列（字符串或者bytes）的过程就叫做序列化。

json--推荐使用

json是各种语言通用的

两组四个方法 元组转成列表 集合不可用

1. dumps loads

   1. dumps---将对象序列化成字符串
   2. loads--将字符串转化成对象 ---反序列化

   import pickle
   dic = {"dsd":"Dsadf sa" }
   
   pickle.dump(dic,open("aa","wb"))
   print(pickle.load(open("aa","rb")))
   
   import json
   lst = [1,2,3,4,5,6]
   print(json.dumps(lst),type(json.dumps(lst)))序列化
   str_lst = json.dumps(lst)
   print(json.loads(str_lst),type(json.loads(str_lst)))反序列化
   
   dic = {'dsa':12,"dsad":"的萨芬"}
   print(json.dumps(dic),type(json.dumps(dic)))
   print(json.loads(json.dumps(dic)),type(json.loads(json.dumps(dic))))
   结果
   {"dsa": 12, "dsad": "\u7684\u8428\u82ac"} <class 'str'>
   {'dsa': 12, 'dsad': '的萨芬'} <class 'dict'>
   
   
   dic = {'dsa':12,"dsad":"的萨芬"}
   print(json.dumps(dic,ensure_ascii=False),type(json.dumps(dic,ensure_ascii=False))) #关闭ascii码
   print(json.loads(json.dumps(dic)),type(json.loads(json.dumps(dic))))
   结果
   {"dsa": 12, "dsad": "的萨芬"} <class 'str'>
   {'dsa': 12, 'dsad': '的萨芬'} <class 'dict'>
   
   

2. dunmp load

   1. dump--将对象序列化字符串写入文件
   2. load--将文件中字符串转化成反序列成对象

   import json
   lst = [1,2,3,4,56,5]
   with open("info","a",encoding="utf-8") as f:
       json.dump(lst,f)
   with open("info","r",encoding="utf-8") as f1:
       l = json.load(f1)
       print(l,type(l))
       
   
   lst = {"发":"F","fds":"123"}
   with open("info","a",encoding="utf-8") as f:
       json.dump(lst,f,ensure_ascii=False)
   with open("info","r",encoding="utf-8") as f1:
       l = json.load(f1)
       print(l,type(l))
   结果
   {'发': 'F', 'fds': '123'} <class 'dict'>
   

pickle 序列化-nb

python自带的(只有python自己可以使用)

分为两组四个方法

1. dumps loads

   1. dumps 转成类似于字节
   2. loads

   import pickle
   lst = [1,2,3,4,5,6,7]
   t_lst = pickle.dumps(lst)
   print(t_lst)
   print(pickle.loads(t_lst))
   
   dic = {11:1,2:"dsa",3:"Dsa",4:"21",5:"的撒"}
   t_dic = pickle.dumps(dic)
   print(t_dic)
   print(pickle.loads(t_dic))
   
   def func():
       print(111)
   fun = pickle.dumps(func)
   print(fun)
   print(pickle.loads(fun)())
   
   
   
   

2. dump load

   1. dump
   2. load

   import pickle
   dic = {"dsd":"Da" }
   with open("aa","ab") as f:
       f.write(pickle.dumps(dic)+"\n".encode("utf-8"))
   
   
   with open("aa","rb") as f1:
       for i in f1:
           print(pickle.loads(i))`
   

os模块

程序员通过python像操作系统发送指令(与操作系统交互的接口)

分为四大组:

1. 工作目录

   1. os.getcwd()--查看当前工作路径***
   2. os.chdir("F:\s24\day16")--切换工作路径**
   3. os.curdir返回当前目录: ('.')
   4. os.pardir 获取当前目录的父目录字符串名：('..')

2. 文件夹

   1. os.mkdir("ttt)#创建一个文件夹或多级文件夹***

   2. os.rmdir("ttt")#删除一个文件夹(多级删不了)***

   3. os.makedirs("tt/ss/dd")#递归创建文件夹***

   4. os.removedirs("tt/ss/dd")#递归删除文件夹,有文件就停止***

   5. os.listdir("路径")获取路径下的所有文件名(包括文件夹)***

3. 文件

   1. os.rename()修改名字***
   2. os.remove("文件名")#删除后找不回来***

4. 路径

   1. os.path.abspath("路径") 通过相对路径获取绝对路径***
   2. os.path.split(绝对路径)将路径切割以最后一个斜杠切(路径,文件名)**
   3. os.path.dirname(绝对路径) 得到路径***
   4. os.path.basename(绝对路径) 获取文件名***
   5. os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False ***
   6. os.path.isabs(path) 如果path是绝对路径，返回True **
   7. os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False ***
   8. os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False ***
   9. os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略 ***
   10. os.path.getatime(path) 返回path所指向的文件或者目录的最后访问时间 **
   11. os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间 **
   12. getctime() 获取文件的创建时间
   13. os.path.getsize(path) 返回path的大小 ***

5. 操作系统相关(了解)

   1. os.sep 输出操作系统特定的路径分隔符，win下为"\",Linux下为"/" *

   2. os.linesep 输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"

   3. os.pathsep 输出用于分割文件路径的字符串 win下为;,Linux下为: *

   4. os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix' *

      和执行系统命令相关

   5. os.system("bash command") 运行shell命令，直接显示 **

   6. os.popen("bash command).read() 运行shell命令，获取执行结果 **

   7. os.environ 获取系统环境变量 **

6. os.stat('path/filename') 获取文件/目录信息 的结构说明(了解)

   1. stat 结构:
   2. st_mode: inode 保护模式
   3. st_ino: inode 节点号。
   4. st_dev: inode 驻留的设备。
   5. st_nlink: inode 的链接数。
   6. st_uid: 所有者的用户ID。
   7. st_gid: 所有者的组ID。
   8. st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。
   9. st_atime: 上次访问的时间。
   10. st_mtime: 最后一次修改的时间。
   11. st_ctime: 由操作系统报告的"ctime"。在某些系统上（如Unix）是最新的元数据更改的时间在其它系统上（如Windows）是创建时间（详细信息参见平台的文档）。

   sys 与python解释器交互的接口

   1. sys.argv 当作脚本执行的时候能够携带参数 命令行参数List，第一个元素是程序本身路径***
   2. sys.exit(n) 退出程序，正常退出时exit(0),错误退出
   3. sys.exit(1)
   4. sys.version 获取Python解释程序的版本信息
   5. sys.path 返回模块的搜索路径，初始化时使用,添加自定义路径****
   6. PYTHONPATH环境变量的值 ***
   7. sys.platform 返回操作系统平台名称***

   hashlib--加密和校验

   MD5,sha1,sha256,sha512 最常用的是MD5,平时加密使用sha1加密

   1. 只要明文相同秘闻就相同
   2. 只要铭文不同密文就不相同
   3. 不能反逆(不能解密)--md5已经被中国人破解了

hashlib的特征以及使用要点：

1. bytes类型数据 ---> 通过hashlib算法 ---> 固定长度的字符串
2. 不同的bytes类型数据转化成的结果一定不同。
3. 相同的bytes类型数据转化成的结果一定相同。
4. 此转化过程不可逆。

加密:

1. 加密内容

2. 将加密的内容转成字节

   import hashlib
   md5 = hashlib.md5()#导入加密方式
   md5.update("alex123".encode("utf-8"))#放明文
   print(md5.hexdigest())#加密
   

加盐

什么叫加盐？加盐这个词儿来自于国外，外国人起名字我认为很随意，这个名字来源于烧烤，俗称BBQ。我们烧烤的时候，一般在快熟的时候，都会给肉串上面撒盐，增加味道，那么这个撒盐的工序，外国人认为比较复杂，所以就将比较复杂的加密方式称之为加盐。

其实代码非常简单：

ret = hashlib.md5('xx教育'.encode('utf-8'))  # xx教育就是固定的盐
ret.update('a'.encode('utf-8'))
print(ret.hexdigest())

​ 动态的盐

username = '宝元666'
ret = hashlib.md5(username[::2].encode('utf-8'))  # 针对于每个账户，每个账户的盐都不一样
ret.update('a'.encode('utf-8'))
print(ret.hexdigest())

校验 一致性

import hashlib
# 直接 update
md5obj = hashlib.md5()
md5obj.update('宝元 is a old driver'.encode('utf-8'))
print(md5obj.hexdigest())  # da525c66739e6baa8729332f8bae8e0f

# 分段update
md5obj = hashlib.md5()
md5obj.update('宝元 '.encode('utf-8'))
md5obj.update('is '.encode('utf-8'))
md5obj.update('a '.encode('utf-8'))
md5obj.update('old '.encode('utf-8'))
md5obj.update('driver'.encode('utf-8'))
print(md5obj.hexdigest())  # da525c66739e6baa8729332f8bae8e0f
# 结果相同

我们现在知道可以进行分段update后,我们就可以迭代的获取文件中的内容,现在来做一个高大上版文件校验

高大上版文件校验

校验Pyhton解释器的Md5值是否相同

import hashlib

def file_check(file_path):
    with open(file_path,mode='rb') as f1:
        sha256 = hashlib.md5()
        while 1:
            content = f1.read(1024)
            if content:
                sha256.update(content)
            else:
                return sha256.hexdigest()
print(file_check('python-3.6.6-amd64.exe'))

collections

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

from collections import namedtuple
aa= namedtuple("p",["a","b"])#第一个参数 是元组的名字,第二个参数是元组中元素的名字
p=aa(1,2)
print(p.a)

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

p = (1, 2)

但是，看到(1, 2)，很难看出这个tuple是用来表示一个坐标的。

这时，namedtuple就派上了用场：

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

结果：Point(x=1, y=2)

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

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

2.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()，这样就可以非常高效地往头部添加或删除元素。

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

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

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

4.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本身排序：

>>> od = OrderedDict()
>>> od['z'] = 1
>>> od['y'] = 2
>>> od['x'] = 3
>>> od.keys() # 按照插入的Key的顺序返回
['z', 'y', 'x']

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

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

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

li = [11,22,33,44,55,77,88,99,90]
result = {}
for row in li:
    if row > 66:
        if 'key1' not in result:
            result['key1'] = []
        result['key1'].append(row)
    else:
        if 'key2' not in result:
            result['key2'] = []
        result['key2'].append(row)
print(result)


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)

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

from collections import defaultdict
dd = defaultdict(lambda: 'N/A')
dd['key1'] = 'abc'
 # key1存在
print(dd['key1'])
dd['key2'] # key2不存在，返回默认值
print(dd['key2'])