Módulo común (II)

Una serialización

1. ¿Qué es la serialización y de-serialización

Se refiere a una secuencia de convertir el contenido en la memoria de un tipo específico de formato de datos

------- memoria de tipo de datos "secuencia de --------" formato específico (formato de estibado JSO o formatos)

formato específico (JSON formato o formato de salmuera) -------- "deserialización --------" tipo de datos en la memoria

2. ¿Por qué utilizar la serialización

Los resultados obtenidos serialización === "contenido de un formato particular para dos propósitos

1, puede ser utilizado para almacenar == "para archivar

2, se transfirió a otras plataformas == "intercambio de datos de plataforma cruzada

Hizo hincapié en:

El uso de un formato específico para:

Puede ser un formato propietario == "pepinillo sólo puede identificarse pitón

2 para su uso en un formato específico:

En caso de ser un formato común === ser capaz de identificar todos los idiomas "JSON

3, la forma de serializar y deserializar

dos JSON

JSON tipo de cadena obtenida por el formato de serialización es JSON

1 serialización

Serialización: Pitón Tipo de datos --- "--- JSON serializado" --- cadena "JSON archivo

import json
json.dumps(True)
print(res,type(res)) #true, <class 'str'>

json.dumps([1, 'aaa', True, False])
print(res, type(res)) #[1, "aaa", True, False] <class 'str'>

Las operaciones de archivo:

import json
json.dumps：res= json.dumps('aaa'), f = open() --> f.write(res)
with open('a.txt', 'wt', encoding='utf-8')as f:
		json.dump('haha', f) #内部实现 f.write()
    
# 序列化的结果写入文件的复杂方法
json_res=json.dumps([1,'aaa',True, False])
# print(json_res,type(json_res)) # "[1, "aaa", true, false]"
with open('test.json',mode='wt',encoding='utf-8') as f:
    f.write(json_res)

# 将序列化的结果写入文件的简单方法
with open('test.json',mode='wt',encoding='utf-8') as f:
    json.dump([1,'aaa',True,False],f)

2 deserialización

Deserialize: archivo JSON - "Cadena" --- --- JSON deserialización "tipos de datos de Python u otro idioma

import json

json.loads:f = open(), str = f.read(), json.loads(str)

Caso II:

import json

#序列化
with open(r'a.json', 'wt', encoding='utf-8')as f:
    json.dump('haha', f)
    
#反序列化
with open(r'a.json', 'rt', encoding='utf-8')as f:
    res = json.load(f)
    print(res,type(res)) #haha <class 'str'>

Operaciones con archivos

# 从文件读取json格式的字符串进行反序列化操作的复杂方法
with open('test.json',mode='rt',encoding='utf-8') as f:
    json_res=f.read()
    l=json.loads(json_res)
    print(l,type(l))

# 从文件读取json格式的字符串进行反序列化操作的简单方法
with open('test.json',mode='rt',encoding='utf-8') as f:
    l=json.load(f)
    print(l,type(l))

j formato compatible hijo es el idioma común para todos los tipos de datos, pero no establece el tipo de datos pitón deserializado

json.dumps({1,2,3,4,5}) #报错

JSON enfatizó: comillas dobles cadena de datos interna JSON, no hay comillas simples.

Asegúrese de averiguar formato JSON, que no debe confundirse con el pitón

l=json.loads('[1, "aaa", true, false]')
print(l) #[1, 'aaa', True, False]

l=json.loads("[1,1.3,true,'aaa', true, false]")
print(l) #报错， json格式数据内部的字符串是双引号

tuplas pitón, si se convierten en datos JSON, tuplas interna ---> Lista

tuple1 = ('1',2,3, 'aa')
res =json.dumps(tuple1)
print(res,type(res)) #["1", 2, 3, "aa"] <class 'str'>

aprender:

Tipo intérprete de bytes en pitón python3.5 pueden deserializado en datos de formato, pero no admite antes python3.5

l = json.loads(b'[1, "aaa", true, false]') #b'json格式数据'
print(l, type(l)) #[1, 'aaa', True, False] <class 'list'>

with open('test.json',mode='rb') as f:
    l=json.load(f)
    
#注：在 python3.5 之上的解释器 bytes 类型可以反序列化成 python格式数据，但是 python3.5 之前不支持

res=json.dumps({'name':'哈哈哈'}, ensure_ascii=False) #ensure_ascii 默认为 True，此时中文字符序列化的得到 "\u54c8\u54c8\u54c8"
print(res,type(res)) #{"name": "哈哈哈"} <class 'str'>

res=json.loads('{"name": "\u54c8\u54c8\u54c8"}')
print(res,type(res)) #{'name': '哈哈哈'} <class 'dict'>

Mono Patch: pensamiento Un programa de parcheo

Jugar parche mono en la entrada

import json
import ujson

def monkey_patch_json():
  	json.__name__ = 'ujson'
    json.dumps = ujson.dumps
    json.loads = ujson.loads
    
monekey_patch_json() #在入口文件处运行



# 后续代码中的应用
# json.dumps()
# json.dumps()
# json.dumps()

tres salmuera

módulo de Python pickle es proporcionar un módulo de serialización, un resultado de la secuencia de tipo de datos bytes

Pros: que puede soportar todos los tipos de datos en Python

Se puede almacenar directamente tipo de datos 'bytes', salmuera acceso más rápido

desventajas:

Sólo apoyar el uso de Python, no puede ser multiplataforma

Serialización y de-serialización

Pitón de la salmuera serializará Tipo de todos los bytes de datos

import pickle
res=pickle.dumps({1,2,3,4,5})
print(res, type(res)) #b'\x80\x03cbuiltins\nset\nq\x00]q\x01(K\x01K\x02K\x03K\x04K\x05e\x85q\x02Rq\x03.' <class 'bytes'>

s=pickle.loads(res)# 后续代码中的应用
print(s,type(s)) #{1, 2, 3, 4, 5} <class 'set'>

pepinillo y python3 de problemas de compatibilidad python2

# coding:utf-8
import pickle

with open('a.pkl',mode='wb') as f:
    # 一：在python3中执行的序列化操作如何兼容python2
    # python2不支持protocol>2，默认python3中protocol=4
    # 所以在python3中dump操作应该指定protocol=2
    pickle.dump('你好啊',f,protocol=2)

with open('a.pkl', mode='rb') as f:
    # 二：python2中反序列化才能正常使用
    res=pickle.load(f)
    print(res)

ickle cuestiones y problemas específicos para serializar todos los otros lenguajes de programación, Python es que sólo se puede utilizar, y pueden ser diferentes versiones de Python no son compatibles entre sí los datos sin importancia, por lo tanto, sólo puede ser salvado de la salmuera.

cuatro ConfigParser

ConfigParser: módulo de configuración

'''aa.ini'''

# 注释1
; 注释2

[section1]
k1 = v1
k2:v2
user=egon
age=18
is_admin=true
salary=31

[section2]
k1 = v1

# coding:utf-8
'''配置文件'''
import configparser

#初始化，并读取配置文件
config=configparser.ConfigParser()
res = config.read('aa.ini') #  'aa.ini':文件路径
print(res,type(res)) #['aa.ini'] <class 'list'>

#查看所有的标题 sections
res=config.sections()
print(res) #['section1', 'section2']

#查看标题section1下所有key=value的key
options=config.options('section1')
print(options) #['k1', 'k2', 'user', 'age', 'is_admin', 'salary']

#查看标题section1下所有key=value的(key,value)格式
item_list=config.items('section1') #返回值是列表套元组形式
print(item_list) #[('k1', 'v1'), ('k2', 'v2'), ('user', 'egon'), ('age', '18'), ('is_admin', 'true'), ('salary', '31')]

# #查看标题section1下user的值=>字符串格式
val=config.get('section1', 'user')
print(val) #egon

#查看标题section1下age的值=>整数格式
val1 = config.getint('section1','age')
print(val1, type(val1)) #18 <class 'int'>

#查看标题section1下is_admin的值=>布尔值格式
val2=config.getboolean('section1','is_admin')
print(val2) #True

#查看标题section1下salary的值=>浮点型格式
val3=config.getfloat('section1','salary')
print(val3) #31.0

reescribir

import configparser

config=configparser.ConfigParser()
config.read('a.cfg',encoding='utf-8')


#删除整个标题section2
config.remove_section('section2')

#删除标题section1下的某个k1和k2
config.remove_option('section1','k1')
config.remove_option('section1','k2')

#判断是否存在某个标题
print(config.has_section('section1'))

#判断标题section1下是否有user
print(config.has_option('section1',''))


#添加一个标题
config.add_section('egon')

#在标题egon下添加name=egon,age=18的配置
config.set('egon','name','egon')
config.set('egon','age',18) #报错,必须是字符串


#最后将修改的内容写入文件,完成最终的修改
config.write(open('a.cfg','w'))

cinco hashlib

1. ¿Qué es el hash de hash

un algoritmo basado en hash que recibe el contenido entrante, después de calcular la cadena de valor hash para dar

características valor hash:

1, siempre y cuando los valores de entrada, el valor hash resultante como inevitable

2, no puede ser devuelta por el valor hash del contenido en una solución de

3, sólo tiene que utilizar el mismo algoritmo de control, independientemente de cómo el contenido entrante, que se obtiene el valor hash es una longitud fija

2. uso

Uso 1: 1 Características: el texto cifrado para la verificación de la contraseña y la transmisión

Utilice 2: 1 y características Característica 3: comprobación de la integridad del archivo

3, ¿Cómo

hashlib es un módulo criptográfico, construyó una gran cantidad de algoritmos

1 uso hashlib

#传入的值必须为 bytes类型

import hashlib
m = hashlib.md5()
m.update('hello'.encode('utf-8')) #传入数据必须为 bytes 类型，所以需要将字符串 encode 成 bytes 类型
res = m.hexdigest()
print(res) #5d41402abc4b2a76b9719d911017c592

Los datos a ser cifrados por separado múltiples pasajes y cifrado a tiempo completo a los objetos de entrada, el resultado final de la encriptación es el mismo. Mientras el hash para verificar las características de 1: simplemente pasar el mismo valor, valor hash obtiene como inevitable

import hashlib
m = hashlib.md5('hello'.encode('utf-8'))
m.update('world'.encode('utf-8'))
res =m.hexdigest() #'helloworld'
print(res)

import hashlib
m = hashlib.md5()
m.update('hello'.encode('utf-8'))
m.update('world'.encode('utf-8'))
res =m.hexdigest()#'helloworld'
print(res)

#结果展示
'''
fc5e038d38a57032085441e7fe7010b0
fc5e038d38a57032085441e7fe7010b0
'''

2 analógica golpeó biblioteca

import hashlib
user_pwd = 'beffc46e29d93a4b0ad3765c242d6fc8'
# 模拟撞库
# 制作密码字典
password = [
    'h123an',
    '123han',
    'ha123n',
    '12han3',
    'han123',
    'ha12n3',
]

dic = {}
for str_num in password:
    m = hashlib.md5(str_num.encode('utf-8'))
    dic[str_num] = m.hexdigest() #n拿到密码字典

#模拟撞库得到密码
for k, v in dic.items():
    if v == user_pwd:
        print('撞库成功， 明文密码为%s'%k)#撞库成功， 明文密码为han123
        break

3 sal

Aumento de los costos golpean la biblioteca, puede mejorar la seguridad de "sal datos cifrados ==

#提升撞库成本====》加盐
import hashlib

m = hashlib.md5()
m.update('han123'.encode('utf-8'))
#加盐
str1 = '天王盖地虎'
m.update(str1.encode('utf-8'))
res = m.hexdigest() #'天王盖地虎han123'
print(res) #5c62dc89fd9440ab7a2b3ecee7e904ad

Los casos específicos:

def pwd_md5(pwd):
    global res
    md5_obj = hashlib.md5()
    str1 = pwd
    md5_obj.update(str1.encode('utf-8'))  # update 中一定要传入bytes类型数据
    # 创造盐
    sa1 = '哈哈'
    # 加盐
    md5_obj.update(sa1.encode('utf-8'))  # update 中一定要传入bytes类型数据
    # 得到一个加密后的字符串
    res1 = md5_obj.hexdigest()

    print(res1)
    return res1

pwd = input('请输入用户密码').strip()
user_str2 = f'tank:{pwd_md5(pwd)}'
# def register(*regs, **kwregs):
#     # # user_str1 = f'tank:1234'
with open('user.txt', 'w', encoding='utf-8')as f:
        f.write(user_str2)

Mejorar el nivel de operación de cifrado

Puede interceptar la posición determinada de empalme de cifrado de datos (por ejemplo: 1/4, 2/4, 3/4, 4/4 datos de longitud tales como la posición), para mejorar los datos de comprobación de integridad es consistente, y se puede utilizar para el vídeo, el texto y si el software de la aplicación completa no ha sido manipulado.

4 módulo hmac (entender)

módulo de Python proporciona hmac dentro de ella para que creemos clave y el contenido para su posterior procesamiento y luego vueltos a cifrar:

#要想保证hmac最终结果一致，必须保证：
#1:hmac.new括号内指定的初始key一样
#2:无论update多少次，校验的内容累加到一起是一样的内容

# 操作一
import hmac
h1=hmac.new('hello'.encode('utf-8'),digestmod='md5')
h1.update('world'.encode('utf-8'))

print(h1.hexdigest()) # 0e2564b7e100f034341ea477c23f283b

# 操作二
import hmac
h2=hmac.new('hello'.encode('utf-8'),digestmod='md5')
h2.update('w'.encode('utf-8'))
h2.update('orld'.encode('utf-8'))

print(h1.hexdigest()) # 0e2564b7e100f034341ea477c23f283b

六 subproceso

módulo de subproceso: ejecutar comandos del sistema

#执行系统命令
obj = subprocess.Popen('echo 123 ; ls / ; ls /root', shell=True,
                       stdout=subprocess.PIPE, #正确的内容被放入该管道
                       stderr=subprocess.PIPE, #错误的内容被放入该管道
                       )

# print(obj) #<subprocess.Popen object at 0x10f7fad68>

#查看正确管道内的内容
str_true = obj.stdout.read() #读出的是 bytes类型
print(str_true.decode('utf-8'))
# 结果展示
'''
123
Applications
Library
Network
System
Users
Volumes
bin
cores
dev
etc
home
installer.failurerequests
net
private
sbin
tmp
usr
var
'''

#查看错误管道内的内容
str_error = obj.stderr.read()
res = str_error.decode('utf-8')
print(res) #ls: /root: No such file or directory

Entrada Muestra comando en el terminal:

aprender:

# coding:utf-8
import subprocess

'''
sh-3.2# ls /Users/egon/Desktop |grep txt$
mysql.txt
tt.txt
事物.txt
'''

res1=subprocess.Popen('ls /Users/jieli/Desktop',shell=True,stdout=subprocess.PIPE)
res=subprocess.Popen('grep txt$',shell=True,stdin=res1.stdout,
                 stdout=subprocess.PIPE)

print(res.stdout.read().decode('utf-8'))


#等同于上面,但是上面的优势在于,一个数据流可以和另外一个数据流交互,可以通过爬虫得到结果然后交给grep
res1=subprocess.Popen('ls /Users/jieli/Desktop |grep txt$',shell=True,stdout=subprocess.PIPE)
print(res1.stdout.read().decode('utf-8'))


#windows下:
# dir | findstr 'test*'
# dir | findstr 'txt$'
import subprocess
res1=subprocess.Popen(r'dir C:\Users\Administrator\PycharmProjects\test\函数备课',shell=True,stdout=subprocess.PIPE)
res=subprocess.Popen('findstr test*',shell=True,stdin=res1.stdout,
                 stdout=subprocess.PIPE)

print(res.stdout.read().decode('gbk')) #subprocess使用当前系统默认编码，得到结果为bytes类型，在windows下需要用gbk解码

módulo de siete XML (entender)

XML es un protocolo para el intercambio de datos entre diferentes idiomas o implementar programas, con casi JSON, JSON, pero más fácil de usar, sin embargo, en la antigüedad, no nació en la Edad Media JSON, XML sólo podemos optar por usarlo, ya que muchos muchas empresas tradicionales como la interfaz del sistema industria financiera también principalmente XML.

xml formato es el siguiente, que es distinguir entre estructuras de datos por <> nodo:

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

xml数据

xml acuerdo en todos los idiomas están soportados en Python pueden utilizar los siguientes módulos que operan xml:

# print(root.iter('year')) #全文搜索
# print(root.find('country')) #在root的子节点找，只找一个
# print(root.findall('country')) #在root的子节点找，找所有

import xml.etree.ElementTree as ET
 
tree = ET.parse("xmltest.xml")
root = tree.getroot()
print(root.tag)
 
#遍历xml文档
for child in root:
    print('========>',child.tag,child.attrib,child.attrib['name'])
    for i in child:
        print(i.tag,i.attrib,i.text)
 
#只遍历year 节点
for node in root.iter('year'):
    print(node.tag,node.text)
#---------------------------------------

import xml.etree.ElementTree as ET
 
tree = ET.parse("xmltest.xml")
root = tree.getroot()
 
#修改
for node in root.iter('year'):
    new_year=int(node.text)+1
    node.text=str(new_year)
    node.set('updated','yes')
    node.set('version','1.0')
tree.write('test.xml')
 
 
#删除node
for country in root.findall('country'):
   rank = int(country.find('rank').text)
   if rank > 50:
     root.remove(country)
 
tree.write('output.xml')

#在country内添加（append）节点year2
import xml.etree.ElementTree as ET
tree = ET.parse("a.xml")
root=tree.getroot()
for country in root.findall('country'):
    for year in country.findall('year'):
        if int(year.text) > 2000:
            year2=ET.Element('year2')
            year2.text='新年'
            year2.attrib={'update':'yes'}
            country.append(year2) #往country节点下添加子节点

tree.write('a.xml.swap')

Crear su propio documento XML

import xml.etree.ElementTree as ET
 
 
new_xml = ET.Element("namelist")
name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
age = ET.SubElement(name,"age",attrib={"checked":"no"})
sex = ET.SubElement(name,"sex")
sex.text = '33'
name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
age = ET.SubElement(name2,"age")
age.text = '19'
 
et = ET.ElementTree(new_xml) #生成文档对象
et.write("test.xml", encoding="utf-8",xml_declaration=True)
 
ET.dump(new_xml) #打印生成的格式

Ocho módulo de estantería

módulo de estantería es más simple que el módulo salmuera, abierto sólo una función que devuelve el diccionario-como objeto, puede leer y escribir; clave debe ser una cadena, y el valor puede ser apoyado tipos de datos pitón

import shelve

f=shelve.open(r'sheve.txt')
# f['stu1_info']={'name':'egon','age':18,'hobby':['piao','smoking','drinking']}
# f['stu2_info']={'name':'gangdan','age':53}
# f['school_info']={'website':'http://www.pypy.org','city':'beijing'}

print(f['stu1_info']['hobby'])
f.close()