Sérialisation et désérialisation d'objets Python : partie 2

Ceci est la deuxième partie d'un tutoriel sur la sérialisation et la désérialisation des objets Python. Dans la première partie, vous avez appris les bases, puis vous avez approfondi les détails de Pickle et JSON.

Dans cette partie, vous explorerez YAML (assurez-vous d'avoir l'exemple d'exécution de la première partie), discuterez des considérations en matière de performances et de sécurité, découvrirez d'autres formats de sérialisation et enfin apprendrez à choisir le bon. p>

YAML

YAML est mon format préféré. Il s'agit d'un format de sérialisation de données convivial. Contrairement à Pickle et JSON, il ne fait pas partie de la bibliothèque standard Python, vous devez donc l'installer :

pip 安装 yaml

Le module

yaml n'a que load()和dump()函数。默认情况下，它们使用像 loads() 和 dumps() de telles chaînes, mais peut prendre un deuxième argument, qui est un flux ouvert qui peut ensuite être vidé/chargé vers/depuis un fichier.

import yaml



print yaml.dump(simple)



boolean: true

int_list: [1, 2, 3]

none: null

number: 3.44

text: string

Veuillez noter à quel point YAML est lisible par rapport à Pickle ou même à JSON. Vient maintenant la partie intéressante de YAML : il comprend les objets Python ! Pas besoin d'encodeurs et de décodeurs personnalisés. Voici une sérialisation/désérialisation complexe à l'aide de YAML :

> serialized = yaml.dump(complex)

> print serialized



a: !!python/object:__main__.A

  simple:

    boolean: true

    int_list: [1, 2, 3]

    none: null

    number: 3.44

    text: string

when: 2016-03-07 00:00:00



> deserialized = yaml.load(serialized)

> deserialized == complex

True

Comme vous pouvez le voir, YAML a sa propre notation pour étiqueter les objets Python. Le résultat est toujours très facile à lire. Les objets Datetime ne nécessitent aucun balisage spécial car YAML prend intrinsèquement en charge les objets datetime.

Performances

Avant de commencer à réfléchir à la performance, vous devez vous demander si la performance est un problème. Si vous sérialisez/désérialisez de petites quantités de données relativement rarement (par exemple en lisant un fichier de configuration au début de votre programme), les performances ne sont pas vraiment un problème et vous pouvez passer à autre chose.

Cependant, en supposant que vous profilez votre système et que vous constatez que la sérialisation et/ou la désérialisation entraîne des problèmes de performances, les problèmes suivants doivent être résolus.

Les performances ont deux aspects : quelle est la vitesse de sérialisation/désérialisation et quelle est la taille de la représentation sérialisée ?

Pour tester les performances de différents formats de sérialisation, je vais créer une structure de données plus grande et la sérialiser/désérialiser à l'aide de Pickle, YAML et JSON. big_data La liste contient 5 000 objets complexes.

big_data = [dict(a=simple, when=datetime.now().replace(microsecond=0)) for i in range(5000)]

Kimchi

J'utiliserai IPython ici car il possède des fonctions magiques %timeit pratiques pour mesurer le temps d'exécution.

import cPickle as pickle



In [190]: %timeit serialized = pickle.dumps(big_data)

10 loops, best of 3: 51 ms per loop



In [191]: %timeit deserialized = pickle.loads(serialized)

10 loops, best of 3: 24.2 ms per loop



In [192]: deserialized == big_data

Out[192]: True



In [193]: len(serialized)

Out[193]: 747328

Le pickle par défaut prend 83,1 millisecondes pour être sérialisé et 29,2 millisecondes pour être désérialisé, avec une taille sérialisée de 747 328 octets.

Essayons d’utiliser le protocole le plus élevé.

In [195]: %timeit serialized = pickle.dumps(big_data, protocol=pickle.HIGHEST_PROTOCOL)

10 loops, best of 3: 21.2 ms per loop



In [196]: %timeit deserialized = pickle.loads(serialized)

10 loops, best of 3: 25.2 ms per loop



In [197]: len(serialized)

Out[197]: 394350

Résultats intéressants. Le temps de sérialisation est tombé à seulement 21,2 ms, mais le temps de désérialisation a légèrement augmenté pour atteindre 25,2 ms. La taille sérialisée est considérablement réduite à 394 350 octets (52 %).

JSON

In [253] %timeit serialized = json.dumps(big_data, cls=CustomEncoder)

10 loops, best of 3: 34.7 ms per loop



In [253] %timeit deserialized = json.loads(serialized, object_hook=decode_object)

10 loops, best of 3: 148 ms per loop



In [255]: len(serialized)

Out[255]: 730000

D'accord. Les performances d'encodage semblent un peu moins bonnes que Pickle, mais les performances de décodage sont bien pires : 6 fois plus lentes. Que se passe-t-il? Il s'agit d'un artefact de la fonction object_hook qui doit être exécuté pour chaque dictionnaire afin de vérifier s'il doit être converti en objet. Il fonctionne beaucoup plus rapidement sans utiliser de hooks d'objet.

%timeit deserialized = json.loads(serialized)

10 loops, best of 3: 36.2 ms per loop

La leçon ici est d'examiner attentivement tout encodage personnalisé lors de la sérialisation et de la désérialisation en JSON, car ils peuvent avoir un impact significatif sur les performances globales.

YAML

In [293]: %timeit serialized = yaml.dump(big_data)

1 loops, best of 3: 1.22 s per loop



In[294]: %timeit deserialized = yaml.load(serialized)

1 loops, best of 3: 2.03 s per loop



In [295]: len(serialized)

Out[295]: 200091

D'accord. YAML est vraiment très lent. Notez cependant quelque chose d’intéressant : la taille sérialisée n’est que de 200 091 octets. Bien mieux que Pickle et JSON. Jetons un coup d'oeil rapide à l'intérieur :

In [300]: print serialized[:211]

- a: &id001

    boolean: true

    int_list: [1, 2, 3]

    none: null

    number: 3.44

    text: string

  when: 2016-03-13 00:11:44

- a: *id001

  when: 2016-03-13 00:11:44

- a: *id001

  when: 2016-03-13 00:11:44

YAML est très intelligent ici. Il détermine que les 5 000 dictionnaires partagent la même valeur de clé « a », il ne la stocke donc qu'une seule fois et la référence en utilisant *id001 pour tous les objets.

Sécurité

La sécurité est souvent un problème critique. Pickle et YAML sont vulnérables aux attaques d'exécution de code en raison de leur construction d'objets Python. Les fichiers intelligemment formatés peuvent contenir du code arbitraire qui sera exécuté par Pickle ou YAML. Pas de panique. Ceci est intentionnel et documenté dans la documentation de Pickle :

Avertissement : le module pickle n'est pas conçu pour protéger contre les données incorrectes ou construites de manière malveillante. N’annulez jamais les données reçues de sources non fiables ou non authentifiées.

Et qu'y a-t-il dans le document YAML :

AVERTISSEMENT : il est dangereux d'appeler yaml.load avec des données reçues de sources non fiables ! yaml.load est aussi puissant que pickle.load, il peut donc appeler n'importe quelle fonction Python.

Sachez simplement que vous ne devez pas utiliser Pickle ou YAML pour charger des données sérialisées reçues de sources non fiables. JSON convient, mais si vous disposez d'un encodeur/décodeur personnalisé, vous pourriez également être exposé.

Le module

yaml fournit la fonction yaml.safe_load() qui charge simplement des objets simples, mais vous perdez alors une grande partie des fonctionnalités de YAML et pouvez choisir d'utiliser simplement JSON.

Autres formats

Il existe de nombreux autres formats de sérialisation disponibles. En voici quelques-uns.

Tampon de protocole

Protobuf (c'est-à-dire Protocol Buffer) est le format d'échange de données de Google. Il est implémenté en C++ mais possède des liaisons Python. Il possède une architecture sophistiquée et regroupe efficacement les données. Très puissant, mais pas très simple à utiliser.

Pack de messages

MessagePack est un autre format de sérialisation populaire. Il est également binaire et efficace, mais contrairement à Protobuf il ne nécessite pas de schéma. Il possède un système de types similaire à JSON, mais plus riche. Les clés peuvent être de n'importe quel type, pas seulement les chaînes, et les chaînes non UTF8 sont prises en charge.

CBOR

CBOR signifie Concise Binary Object Representation. De même, il prend en charge le modèle de données JSON. CBOR n'est pas aussi connu que Protobuf ou MessagePack, mais il est intéressant pour deux raisons :

1. Il s'agit d'une norme Internet officielle : RFC 7049.
2. Il est conçu pour l'Internet des objets (IoT).

Comment choisir ?

C'est une grande question. Tant de choix, comment choisir ? Considérons les différents facteurs à prendre en compte :

1. Le format de sérialisation doit-il être lisible et/ou modifiable par l'homme ?
2. Recevrez-vous du contenu sérialisé provenant de sources non fiables ?
3. La sérialisation/désérialisation est-elle un goulot d'étranglement en termes de performances ?
4. Les données sérialisées doivent-elles être échangées avec des environnements non Python ?

Je vais vous faciliter la tâche et vous présenter quelques scénarios courants ainsi que le format que je recommande pour chacun :

Enregistrer automatiquement l'état local des programmes Python

Utilisez cornichon (cPickle) et HIGHEST_PROTOCOL ici. Il est rapide, efficace et peut stocker et charger la plupart des objets Python sans aucun code spécial. Il peut également être utilisé comme cache persistant local.

Profil

Certainement YAML. Rien ne vaut sa simplicité pour tout ce que les humains ont besoin de lire ou de modifier. Il a été utilisé avec succès par Ansible et de nombreux autres projets. Dans certains cas, vous préférerez peut-être utiliser des modules Python directs comme fichiers de configuration. C'est peut-être le bon choix, mais ce n'est pas une sérialisation, cela fait en fait partie du programme, pas un fichier de configuration séparé.

APIWeb

JSON est clairement le gagnant ici. Aujourd'hui, les API Web sont le plus souvent utilisées par les applications Web JavaScript qui utilisent JSON de manière native. Certaines API Web peuvent renvoyer d'autres formats (par exemple csv pour des ensembles de résultats tabulaires denses), mais je pense que vous pouvez regrouper les données csv dans JSON avec une surcharge minimale (pas besoin de répéter chaque ligne en tant qu'objet avec tous les noms de colonnes).

Communication à grande échelle haute capacité/faible latence

Utilisez l'un des protocoles binaires : Protobuf (si une architecture est requise), MessagePack ou CBOR. Exécutez vos propres tests pour vérifier les performances et les capacités de représentation de chaque option.

Conclusion

La sérialisation et la désérialisation des objets Python sont un aspect important des systèmes distribués. Vous ne pouvez pas envoyer d'objets Python directement sur le réseau. Vous avez souvent besoin d'interagir avec d'autres systèmes implémentés dans d'autres langages, et parfois vous souhaitez simplement stocker l'état de votre programme dans un stockage persistant.

Python est livré avec plusieurs schémas de sérialisation dans sa bibliothèque standard, et bien d'autres sont disponibles sous forme de modules tiers. Comprendre toutes les options ainsi que les avantages et les inconvénients de chacune vous permettra de choisir la méthode la mieux adaptée à votre situation.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!