Python - Sérialisation

Bonjour à tous, futurs maîtres Python ! Aujourd'hui, nous plongeons dans le monde fascinant de la sérialisation. Ne vous inquiétez pas si ce mot vous paraît intimidant – à la fin de cette leçon, vous sérialiserez des données comme un professionnel ! Embarquons ensemble dans ce voyage passionnant.

Python - Serialization

Sérialisation en Python

Imaginez que vous préparez un voyage. Vous devez tout emballer dans une valise. C'est essentiellement ce que fait la sérialisation avec les données – elle les empaquette proprement pour qu'elles puissent être stockées ou envoyées ailleurs. En termes de Python, la sérialisation est le processus de conversion de structures de données complexes dans un format qui peut être facilement stocké ou transmis.

Pourquoi est-ce important, vous demandez-vous ? Eh bien, disons que vous avez créé un programme Python fantastique qui génère une liste de vos films préférés. Vous voulez sauvegarder cette liste pour l'utiliser plus tard ou l'envoyer à un ami. La sérialisation vous permet de le faire !

Bibliothèques de Sérialisation en Python

Python, en tant que langage généreux qu'il est, nous offre plusieurs bibliothèques pour la sérialisation. C'est comme avoir différents types de valises pour différents voyages. Examinons les plus courantes :

Bibliothèque	Description
Pickle	Module de sérialisation intégré à Python
JSON	JavaScript Object Notation, excellent pour les applications web
YAML	YAML Ain't Markup Language, format lisible par les humains

Nous explorerons chacune de ces bibliothèques en détail, mais commençons par la plus spécifique à Python : Pickle.

Sérialisation Utilisant le Module Pickle

Pickle est le module de prédilection de Python pour la sérialisation. C'est comme un couteau suisse – polyvalent et intégré directement dans Python. Voyons comment cela fonctionne :

import pickle

# Notre liste de films préférés
films_préférés = ['The Matrix', 'Star Wars', 'The Lord of the Rings']

# Sérialisation de la liste
with open('movies.pkl', 'wb') as file:
pickle.dump(films_préférés, file)

print("La liste de films a été sérialisée !")

Dans cet exemple, nous "mettons en conserve" notre liste de films préférés. La fonction dump() effectue le travail lourd ici, convertissant notre liste en un format binaire et la sauvegardant dans un fichier nommé 'movies.pkl'.

Maintenant, voyons comment nous pouvons récupérer notre liste :

# Désérialisation de la liste
with open('movies.pkl', 'rb') as file:
films_chargés = pickle.load(file)

print("Liste de films désérialisée :", films_chargés)

Voilà ! Nous avons réussi à déballer notre valise (ou dans ce cas, notre bocal de cornichons). La fonction load() lit le fichier binaire et le convertit à nouveau en un objet Python.

Protocoles Pickle

Pickle utilise quelque chose appelé "protocoles" pour déterminer comment sérialiser des objets. Pensez à ces derniers comme des différentes méthodes d'emballage pour votre valise. Python 3 prend en charge 5 protocoles (de 0 à 4), les numéros plus élevés étant plus efficaces mais potentiellement moins compatibles avec les anciennes versions de Python.

import pickle

donnees = {'nom': 'Alice', 'âge': 30}

# Utilisation du protocole 4 (le plus efficace en Python 3)
sérialisé = pickle.dumps(donnees, protocol=4)
print("Données sérialisées :", sérialisé)

# Désérialisation
désérialisé = pickle.loads(sérialisé)
print("Données désérialisées :", désérialisé)

Dans cet exemple, nous utilisons dumps() pour sérialiser en une chaîne de caractères au lieu d'un fichier, et spécifions le protocole 4 pour une efficacité maximale.

Classes Pickler et Unpickler

Pour un contrôle plus fin sur le processus de sérialisation, Python fournit les classes Pickler et Unpickler. Ce sont comme avoir vos propres assistants personnels pour l'emballage :

import pickle

class PickleHelper:
def __init__(self, filename):
self.filename = filename

def save_data(self, data):
with open(self.filename, 'wb') as file:
pickler = pickle.Pickler(file)
pickler.dump(data)

def load_data(self):
with open(self.filename, 'rb') as file:
unpickler = pickle.Unpickler(file)
return unpickler.load()

# Utilisation
helper = PickleHelper('data.pkl')
helper.save_data(['pomme', 'banane', 'cerise'])
donnees_chargées = helper.load_data()
print("Données chargées :", données_chargées)

Cette classe PickleHelper offre une approche plus orientée objet pour la sérialisation, ce qui peut être très utile dans de plus grands projets.

Sérialisation d'Objets de Classe Personnalisée

Maintenant, abordons quelque chose de plus avancé – la sérialisation d'objets de classe personnalisée. Imaginez-nous une classe Person :

import pickle

class Person:
def __init__(self, nom, âge):
self.nom = nom
self.âge = âge

def saluer(self):
return f"Bonjour, je m'appelle {self.nom} et j'ai {self.âge} ans."

# Création d'un objet Person
alice = Person("Alice", 30)

# Sérialisation de l'objet
with open('person.pkl', 'wb') as file:
pickle.dump(alice, file)

# Désérialisation de l'objet
with open('person.pkl', 'rb') as file:
alice_chargée = pickle.load(file)

print(alice_chargée.saluer())  # Sortie : Bonjour, je m'appelle Alice et j'ai 30 ans.

C'est pas cool ? Nous avons juste emballé une personne entière dans un fichier et la désérialisée à nouveau !

Utilisation de JSON pour la Sérialisation

Bien que Pickle soit excellent pour la sérialisation spécifique à Python, parfois nous devons interagir avec d'autres langages ou systèmes. C'est là que JSON entre en jeu. C'est comme une langue universelle pour les données :

import json

# Données à sérialiser
donnees = {
"nom": "Bob",
"âge": 35,
"ville": "New York",
"loisirs": ["lecture", "nage", "codage"]
}

# Sérialisation en JSON
json_string = json.dumps(donnees, indent=4)
print("Chaîne JSON :", json_string)

# Désérialisation à partir de JSON
donnees_analysées = json.loads(json_string)
print("Données analysées :", données_analysées)

JSON est particulièrement utile pour les applications web et les API, car il est largement supporté sur différentes plateformes.

Utilisation de YAML pour la Sérialisation

Enfin, examinons YAML. YAML est connu pour sa lisibilité par les humains, ce qui en fait un favori pour les fichiers de configuration :

import yaml

# Données à sérialiser
donnees = {
"nom": "Charlie",
"âge": 40,
"animaux": ["chien", "chat", "poisson"],
"adresse": {
"rue": "123 Main St",
"ville": "Anytown"
}
}

# Sérialisation en YAML
yaml_string = yaml.dump(donnees, default_flow_style=False)
print("Chaîne YAML :\n", yaml_string)

# Désérialisation à partir de YAML
donnees_analysées = yaml.safe_load(yaml_string)
print("Données analysées :", données_analysées)

Le format YAML est agréable à lire, ce qui le rend excellent pour les données que les humains doivent lire ou modifier fréquemment.

Et voilà, mes chers étudiants ! Nous avons dévoilé le concept de sérialisation en Python, des bases de Pickle à la polyvalence de JSON et à la lisibilité de YAML. Rappelez-vous, chaque méthode a ses points forts, donc choisissez celle qui convient le mieux à vos besoins.

À mesure que nous terminons cette leçon, je suis rappelé d'une citation du grand informaticien Alan Kay : "Les choses simples devraient être simples, les choses complexes devraient être possibles." La sérialisation en Python incarne ce principe magnifiquement, offrant des solutions simples pour les tâches quotidiennes tout en permettant la manipulation complexe des données lorsque cela est nécessaire.

Continuez à pratiquer, soyez curieux et bon codage !

Credits: Image by storyset

Tutoriel précédent:

Python - Références faibles

Tutoriel suivant:

Python - Modèles