Notas de estudio de Python, registros especiales, compartir con ustedes, espero que sea de ayuda para todos.
Publicación por entregas
Durante la ejecución del programa, todas las variables están en la memoria. Por ejemplo, defina un dict:
d = dict(name='Bob', age=20, score=88)
Puede modificar la variable en cualquier momento, como cambiar el nombre a 'Bill', pero una vez que finaliza el programa, la memoria ocupada por la variable será recuperada por completo por el sistema operativo. Si el 'Billete' modificado no se almacena en el disco, la próxima vez que se ejecute el programa nuevamente, la variable se inicializará en 'Bob' nuevamente.
Al proceso de cambio de variables de memoria a almacenable o transferible lo llamamos serialización, que se llama decapado en Python, y serialización, clasificación, aplanamiento, etc. en otros lenguajes. Todos significan lo mismo.
Después de la serialización, el contenido serializado puede escribirse en un disco o transmitirse a otras máquinas a través de la red.
Por el contrario, volver a leer el contenido de la variable del objeto serializado en la memoria se denomina deserialización, es decir, deshacer.
Python proporciona un módulo pickle para lograr la serialización.
Primero, intentamos serializar un objeto y escribirlo en un archivo:
import pickle
d = dict(name='Bob', age=20, score=88)
pickle.dumps(d)
resultado de la operación:
b'\x80\x03}q\x00(X\x03\x00\x00\x00ageq\x01K\x14X\x05\x00\x00\x00scoreq\x02KXX\x04\x00\x00\x00nameq\x03X\x03\x00\x00\x00Bobq\x04u.'
Process finished with exit code 0
El método pickle.dumps () serializa cualquier objeto en un byte, y luego estos bytes se pueden escribir en un archivo. O use otro método pickle.dump () para serializar directamente el objeto y escribirlo en un objeto similar a un archivo:
f = open('dump.txt', 'wb')
pickle.dump(d, f)
f.close()
Mire el archivo dump.txt escrito, un montón de contenido desordenado, esta es la información interna del objeto guardado por Python.
Cuando queremos leer un objeto del disco a la memoria, primero podemos leer el contenido en un byte y luego usar el método pickle.loads () para deserializar el objeto, o usar directamente el método pickle.load () de un archivo -como Deserializar el objeto directamente en Object. Abrimos otra línea de comandos de Python para deserializar el objeto que acabamos de guardar:
f = open('dump.txt', 'rb')
d = pickle.load(f)
f.close()
print d
resultado de la operación:
{'age': 20, 'score': 88, 'name': 'Bob'}
Process finished with exit code 1
¡Vuelve el contenido de la variable!
Por supuesto, esta variable y la variable original son objetos completamente no relacionados, simplemente tienen el mismo contenido.
El problema con Pickle es el mismo que el problema de serialización específico de todos los demás lenguajes de programación. Solo se puede usar en Python, y es posible que diferentes versiones de Python no sean compatibles entre sí. Por lo tanto, Pickle solo se puede usar para guardar datos sin importancia , y no puede tener éxito. La deserialización está bien.
JSON
Si queremos transferir objetos entre diferentes lenguajes de programación, debemos serializar los objetos en un formato estándar, como XML, pero una mejor forma es serializar a JSON, porque JSON se representa como una cadena, que puede ser utilizada por todos los lenguajes. También puede almacenarse fácilmente en un disco o transmitirse a través de la red. JSON no solo es un formato estándar, sino también más rápido que XML, y se puede leer directamente en una página web, lo cual es muy conveniente.
Los objetos representados por JSON son los objetos del lenguaje JavaScript estándar. Los tipos de datos integrados de JSON y Python corresponden a lo siguiente:
| Tipo JSON | Tipo de Python |
|---|---|
| {} | dictar |
| [] | lista |
| "cuerda" | str |
| 1234.56 | int o flotar |
| verdadero Falso | Verdadero Falso |
| nulo | Ninguno |
El módulo json incorporado de Python proporciona una conversión muy completa de objetos de Python al formato JSON. Primero veamos cómo convertir un objeto Python en un JSON:
import json
d = dict(name='Bob', age=20, score=88)
print json.dumps(d)
resultado de la operación:
{"age": 20, "score": 88, "name": "Bob"}
Process finished with exit code 0
El método dumps () devuelve una cadena cuyo contenido es JSON estándar. De manera similar, el método dump () puede escribir JSON directamente en un objeto similar a un archivo.
Para deserializar JSON en un objeto Python, use load () o el método load () correspondiente. El primero deserializa la cadena JSON y el segundo lee la cadena del objeto similar a un archivo y la deserializa:
json_str = '{"age":20, "score":88, "name":"Bob"}'
print json.loads(json_str)
resultado de la operación:
{u'age': 20, u'score': 88, u'name': u'Bob'}
Process finished with exit code 0
Dado que el estándar JSON estipula que la codificación JSON es UTF-8, siempre podemos convertir correctamente entre cadenas Python y JSON.
JSON avanzado
El objeto dict de Python se puede serializar directamente en JSON {}, pero en muchos casos, preferimos usar la clase para representar objetos, como definir la clase Student y luego serializar:
import json
class Student(object):
def __init__(self, name, age, score):
self.name = name
self.age = age
self.score = score
s = Student('Bob', 20, 88)
print json.dumps(s)
Ejecute el código y obtenga un TypeError sin piedad:
TypeError: <__main__.Student object at 0x10603cc50> is not JSON serializable
Process finished with exit code 1
El motivo del error es que el objeto Student no es un objeto que se pueda serializar en JSON.
Si incluso el objeto de instancia de la clase no se puede serializar en JSON, ¡esto definitivamente no es razonable!
Estos parámetros opcionales nos permiten personalizar la serialización JSON. La razón por la que el código anterior no puede serializar la instancia de la clase Student en JSON es porque, de forma predeterminada, el método dumps () no sabe cómo convertir la instancia Student en un objeto JSON {}.
El parámetro opcional predeterminado es convertir cualquier objeto en un objeto que se pueda secuenciar a JSON. Solo necesitamos escribir una función de conversión para Student y luego pasar la función en:
def student2dict(std):
return {
'name': std.name,
'age': std.age,
'score': std.score
}
De esta manera, la instancia Student se convierte primero en un dict mediante la función student2dict () y luego se serializa en JSON sin problemas:
print json.dumps(s, default=student2dict)
resultado de la operación:
{"age": 20, "score": 88, "name": "Bob"}
Process finished with exit code 0
Sin embargo, si encuentra una instancia de la clase Teacher la próxima vez, aún no se puede serializar en JSON. Podemos ser perezosos y convertir una instancia de cualquier clase en un dict:
print json.dumps(s, default=lambda obj: obj.__dict__)
Debido a que generalmente las instancias de clase tienen un atributo __dict__, es un dictado que se usa para almacenar variables de instancia. Hay algunas excepciones, como la clase que define __slots__.
De la misma manera, si queremos deserializar JSON en una instancia de objeto Student, el método load () primero convierte un objeto dict, y luego la función object_hook que pasamos es responsable de convertir el dict en una instancia Student:
def dict2student(d):
return Student(d['name'], d['age'], d['score'])
Los resultados son los siguientes:
<__main__.Student object at 0x10cd3c190>
Process finished with exit code 1
Lo que se imprime es el objeto de instancia de Estudiante deserializado.