Persistance de données sur le Raspberry Pi

Name: Python et Raspberry Pi Apprenez à développer sur votre nano-ordinateur (3e édition)
Rating: 4.5 (2 reviews)

Introduction

Durant le développement d’applications, la persistance des données est une problématique récurrente.

Dans ce domaine, Python propose un très large choix de modules pour répondre à de nombreuses situations : base de données SQL, fichier plat, JSON, sérialisation et désérialisation.

Sérialisation et désérialisation avec les modules pickle et shelve

Le principe de sérialisation/désérialisation repose sur la transformation d’une variable en une série d’octets. Cette série est ensuite transmise à travers le réseau, puis réassembler à la réception. La sérialisation n’est pas le seul moyen disponible, d’autres solutions existent, par exemple le gel de l’état d’un programme sur disque afin de reprendre cet état plus tard. La plupart des langages de programmation se doivent de proposer un jeu de fonctions concernant la sérialisation de données. Bien évidemment, Python n’échappe pas à cette règle. La bibliothèque standard propose deux modules : pickle et shelve. Avec le premier, le développeur est responsable de la manière dont les données sont sérialisées. Tandis que le second offre une indexation des données sérialisées sous la forme d’un dictionnaire.

Sérialiser des données avec pickle est possible directement depuis le REPL :

>>> import pickle  
>>> chaine = 'Hello world!' 
>>> serial = pickle.dumps(chaine) 
>>> print(serial) 
b'\x80\x03X\x0c\x00\x00\x00Hello world!q\x00.' 
>>> deserial = pickle.loads(serial) 
>>> print(deserial) 
Hello world !

Les structures de données les plus courantes sont aussi sérialisables :

>>> serial = pickle.dumps(dict(one='Hello', two='World')) 
>>> print(serial) 
b'\x80\x03}q\x00(X\x03\x00\x00\x00twoq\x01X\x05\x00\x00\x00Worldq\ 
x02X\x03\x00\x00\x00oneq\x03X\x05\x00\x00\x00Helloq\x04u.' 
>>> type(serial) 
<class 'bytes'> 
>>> deserial...

Traiter des fichiers CSV avec le module csv

CSV est un format de données très populaire utilisé essentiellement pour stocker des données texte dans des fichiers plats. Cet acronyme (Comma Separated Value) décrit à lui seul ce qu’un fichier CSV contient : des champs de données séparés par des virgules. En réalité, le choix du caractère de séparation peut être arbitraire et différent d’une virgule. Pour des raisons historiques, la virgule est le plus souvent choisie. En Python, la manipulation d’un fichier CSV est possible par le biais du module du même nom, le module csv disponible dans la bibliothèque standard.

1. Création et lecture d’un fichier CSV

La création peut se faire soit de manière traditionnelle, c’est-à-dire à la main avec un éditeur de texte, soit en Python par le biais du module. Deux interfaces d’entrée/sortie sont exposées, respectivement csv.reader et csv.writer. Pour l’écriture, il faudra utiliser la fonction csv.writer initialisant une interface d’écriture dans un fichier CSV. Elle accepte en paramètre un fichier préalablement ouvert et retourne l’interface permettant de sérialiser des données dans le fichier en question. Depuis cette interface, la fonction writerow() sérialise une liste ou un tuple passé en paramètre. Dans cet exemple, des données sont générées via la fonction generer_donnees() qui retourne un tuple à deux dimensions. Cette structure est ensuite parcourue pour être sérialisée dans le fichier bdd/fichier.csv (Chapitre_8/csv_1.py) :

1 #!/usr/bin/env...

Manipuler des données XML avec le module xml.etree.ElementTree

Voici un format très populaire sur Internet pour l’échange de données et qu’on ne présente plus, il s’agit du format XML, acronyme signifiant eXtensible Markup Language et défini dans la RFC 4825. XML est un format s’inspirant fortement du langage HTML et principalement destiné à structurer du contenu plutôt qu’à mettre en forme celui-ci, au contraire du langage HTML. Python embarque un module pour manipuler des données XML et connu sous le nom de xml. La particularité de ce module est d’exposer non pas une bibliothèque mais plusieurs :

xml.dom, bibliothèque s’inspirant du framework DOM (Document Object Model) ;
xml.parsers contenant un énième parseur Expat ;
xml.sax, une autre bibliothèque pour lire des données XML ;
enfin, xml.etree, la bibliothèque XML ElementTree.

Ce chapitre se concentre sur la dernière bibliothèque de cette énumération, à savoir ElementTree.

1. Créer et sérialiser un fichier XML

La bibliothèque ElementTree expose plusieurs classes et méthodes pour créer un fichier XML. Généralement, la création d’un fichier XML passe par la mise en forme des données dans une chaîne de caractères. Cette chaîne est ensuite convertie en objet XML pour être traitée par la bibliothèque et enfin sérialisée dans un fichier. Voici un exemple (Chapitre_8/xml_1.py) :

1 #!/usr/bin/env python3 
2 from xml.etree import ElementTree 
3 
4 
5 def main(): 
6     fichier = "bdd/commandes.xml" 
7     print(f"Génération de '{fichier}' ...") 
8     xml = ElementTree.XML(""" 
9 <body> 
10     <commandes> 
11         <commande code="HP03" quantite="2"> 
12             Imprimante HP 
13         </commande> 
14         <commande code="RP04" quantite="4"> 
15             Raspberry Pi 1 version B+ ...

Travailler avec le format d’échange de données JSON via le module json

Issu du monde de la programmation web, le format d’échange de données JSON (JavaScript Object Annotation) s’est rapidement fait connaître au fil du temps. Lentement mais sûrement, ce format de données est devenu la référence incontournable pour transporter tout type de données. Ce format d’échange de données est quasiment devenu un standard pour le développement d’API ou bien pour le stockage de données dans les bases de données orientées document, comme MongoDB ou CouchDB.

Travailler avec le format de données JSON en Python est assez simple. Les fonctions de sérialisation et de désérialisation sont accessibles à partir d’un module de la bibliothèque standard : le module json.

Commençons par une tâche simple, en l’occurrence sérialiser une structure de données Python en JSON (Chapitre_8/json_1.py) :

1 #!/usr/bin/env python3 
2 import json 
3 
4 
5 def main(): 
6     donnees = { 
7         "Renault": { 
8             "Clio": { 
9                 "annee": 1999, 
10        ...

Gestion d’une base de données SQL légère avec le module sqlite3

SQL (Structured Query Language) est un outil incontournable pour la gestion de données, notamment grâce aux très populaires bases de données MySQL et PostgreSQL issues du monde libre ainsi qu’aux solutions de gestion de bases de données proposées par Oracle. De nombreux projets ont vu le jour, comme SQLite, notamment destinés à des environnements embarqués et restreints en ressource. Le principe de SQLite est simple : proposer une base de données SQL légère représentée sous la forme d’un fichier plat.

SQLite couvre les quatre opérations de base, plus communément appelées CRUD :

Créer (Create)
Récupérer (Retrieve)
Mettre à jour (Update)
Supprimer (Delete)

Le code servant d’exemple et d’explication pour ce chapitre ne couvre pas seulement le module sqlite3 mais aussi cmd, utilisé ici afin de rendre l’application interactive et facile à utiliser.

Présentation rapide du module cmd : ce module fait partie de la bibliothèque standard de Python et tire profit d’un autre module pour offrir une gestion avancée de l’historique et de l’autocomplétion de commandes, le module readline. Bien que peu connu, ce module est incontournable lorsqu’il s’agit de développer rapidement des applications en console. L’exemple qui suit explique en détail le développement d’une application avec cmd.

Comme toutes les applications présentées dans ce livre jusqu’à présent, celle-ci commence avec l’import classique des modules et la déclaration d’une classe dans laquelle la logique du programme sera compactée (Chapitre_8/pisqlite.py) :

1 #!/usr/bin/env python3 
2 import sqlite3 
3 import cmd 
4 
5 
6 class PiSQLite(cmd.Cmd):

Afin que les fonctionnalités offertes par le module cmd puissent fonctionner, la classe du programme en question se doit d’hériter de la classe cmd.Cmd. Le principe est de surcharger par la suite les éléments nécessaires au développement de l’application. Cela commence par le constructeur de la classe :...

Conclusion

Ce chapitre décrit les techniques les plus courantes pour stocker des données en Python. Le lecteur est ainsi rapidement productif pour écrire lui-même sa propre application en utilisant une base de données avec SQLite, ou un fichier plat, ou enfin un format d’échange de données comme JSON.