Didacticiel sur la persistance des données

Python
Dans ce didacticiel, nous explorerons divers modules Python intégrés et tiers pour stocker et
récupérer des données vers / depuis divers formats tels que des fichiers texte, CSV, JSON et
XML, ainsi que des bases de données relationnelles et non relationnelles. Ce didacticiel présente
également la base de données ZODB, qui est une API de persistance pour les objets Python. Le
format Microsoft Excel est un format de fichier de données très populaire. Ici, nous allons
apprendre à gérer le fichier .xlsx via Python.
Ce didacticiel s'adresse à tous les programmeurs de logiciels qui s'intéressent vivement à
l'apprentissage de la persistance des données en ce qui concerne Python.
Si vous êtes novice en Python, il est suggéré de parcourir les tutoriels liés à Python avant de
poursuivre celui-ci.

Persistance des données Python -

Introduction
Présentation de Python - Persistance des
données
Au cours de l'utilisation de toute application logicielle, l'utilisateur fournit certaines données à
traiter. Les données peuvent être saisies à l'aide d'un périphérique d'entrée standard (clavier) ou
d'autres périphériques tels qu'un fichier disque, un scanner, une caméra, un câble réseau, une
connexion WiFi, etc.
Les données ainsi reçues sont stockées dans la mémoire principale de l'ordinateur (RAM) sous la
forme de diverses structures de données telles que des variables et des objets jusqu'à ce que
l'application soit en cours d'exécution. Ensuite, le contenu de la mémoire de la RAM est effacé.
Cependant, le plus souvent, il est souhaité que les valeurs des variables et / ou des objets soient
stockées de telle manière qu'elles puissent être récupérées chaque fois que nécessaire, au lieu
de saisir à nouveau les mêmes données.
Le mot «persistance» signifie «la continuation d'un effet après que sa cause a été supprimée».
Le terme persistance des données signifie qu'il continue d'exister même après la fin de
l'application. Ainsi, les données stockées dans un support de stockage non volatile tel qu'un
fichier disque est un stockage de données persistant.
Dans ce didacticiel, nous explorerons divers modules Python intégrés et tiers pour stocker et
récupérer des données vers / depuis divers formats tels que des fichiers texte, CSV, JSON et
XML, ainsi que des bases de données relationnelles et non relationnelles.
En utilisant l'objet File intégré à Python, il est possible d'écrire des données de chaîne dans un
fichier disque et de les lire. La bibliothèque standard de Python fournit des modules pour stocker
et récupérer des données sérialisées dans diverses structures de données telles que JSON et
XML.
DB-API de Python fournit un moyen standard d'interagir avec les bases de données
relationnelles. D'autres packages Python tiers présentent des fonctionnalités d'interfaçage avec
des bases de données NOSQL telles que MongoDB et Cassandra.
Ce didacticiel présente également la base de données ZODB qui est une API de persistance
pour les objets Python. Le format Microsoft Excel est un format de fichier de données très
populaire. Dans ce didacticiel, nous allons apprendre à gérer le fichier .xlsx via Python.

Persistance des données Python - API de

fichier
Python utilise des input() et print()fonctions pour effectuer des opérations d'entrée / sortie
standard. La fonction input () lit les octets d'un périphérique de flux d'entrée standard, c'est-à-dire
le clavier.
le print()d'autre part, envoie les données vers le périphérique de flux de sortie standard, c'est-à-
dire le moniteur d'affichage. Le programme Python interagit avec ces périphériques IO via des
objets de flux standardstdin et stdout défini dans le module sys.
le input()function est en fait un wrapper autour de la méthode readline () de l'objet [Link].
Toutes les frappes du flux d'entrée sont reçues jusqu'à ce que la touche «Entrée» soit enfoncée.

>>> import sys

>>> x=[Link]()
Welcome to TutorialsPoint
>>> x
'Welcome to TutorialsPoint\n'

Notez que, readline()fonction laisse un caractère '\ n' à la fin. Il existe également une méthode
read () qui lit les données du flux d'entrée standard jusqu'à ce qu'elles soient terminées
parCtrl+D personnage.

>>> x=[Link]()
Hello
Welcome to TutorialsPoint
>>> x
'Hello\nWelcome to TutorialsPoint\n'

De même, print() est une fonction pratique émulant la méthode write () de l'objet stdout.

>>> x='Welcome to TutorialsPoint\n'

>>> [Link](x)
Welcome to TutorialsPoint
26

Tout comme les objets de flux prédéfinis stdin et stdout, un programme Python peut lire et
envoyer des données à un fichier disque ou à une socket réseau. Ce sont aussi des flux. Tout
objet qui a la méthode read () est un flux d'entrée. Tout objet qui a la méthode write () est un flux
de sortie. La communication avec le flux est établie en obtenant une référence à l'objet de flux
avec la fonction open () intégrée.
fonction open ()
Cette fonction intégrée utilise les arguments suivants -

f=open(name, mode, buffering)

Le paramètre name est le nom du fichier disque ou une chaîne d'octets, le mode est une chaîne
facultative à un caractère pour spécifier le type d'opération à effectuer (lecture, écriture, ajout,
etc.) et le paramètre de mise en mémoire tampon est soit 0, 1 ou -1 indiquant la mise en mémoire
tampon est désactivée, activée ou par défaut du système.
Le mode d'ouverture de fichier est énuméré selon le tableau ci-dessous. Le mode par défaut est
«r»

Sr. Non Paramètres et description

1 R
Ouvrir pour lecture (par défaut)

2 W
Ouvrir pour l'écriture, tronquer d'abord le fichier

3 X
Créez un nouveau fichier et ouvrez-le pour l'écriture

4 A
Ouvert à l'écriture, en ajoutant à la fin du fichier s'il existe

5 B
Mode binaire

6 T
Mode texte (par défaut)

sept +
Ouvrez un fichier disque pour la mise à jour (lecture et écriture)

Afin d'enregistrer des données dans un fichier, il doit être ouvert en mode «w».

f=open('[Link]','w')

Cet objet fichier agit comme un flux de sortie et a accès à la méthode write (). La méthode write ()
envoie une chaîne à cet objet et est stockée dans le fichier sous-jacent.
string="Hello TutorialsPoint\n"
[Link](string)

Il est important de fermer le flux pour s'assurer que toutes les données restantes dans la
mémoire tampon y sont complètement transférées.

[Link]()

Essayez d'ouvrir '[Link]' en utilisant n'importe quel éditeur de test (tel que le bloc-notes) pour
confirmer la création réussie du fichier.
Pour lire le contenu de «[Link]» par programme, il doit être ouvert en mode «r».

f=open('[Link]','r')

Cet objet se comporte comme un flux d'entrée. Python peut récupérer les données du flux en
utilisantread() méthode.

string=[Link]()
print (string)

Le contenu du fichier est affiché sur la console Python. L'objet File prend également en
chargereadline() méthode qui est capable de lire la chaîne jusqu'à ce qu'elle rencontre le
caractère EOF.
Cependant, si le même fichier est ouvert en mode «w» pour y stocker du texte supplémentaire,
les contenus antérieurs sont effacés. Chaque fois qu'un fichier est ouvert avec l'autorisation
d'écriture, il est traité comme s'il s'agissait d'un nouveau fichier. Pour ajouter des données à un
fichier existant, utilisez «a» pour le mode d'ajout.

f=open('[Link]','a')
[Link]('Python Tutorials\n')

Le fichier maintenant, a une chaîne plus ancienne et nouvellement ajoutée. L'objet fichier prend
également en chargewritelines() pour écrire chaque chaîne d'un objet de liste dans le fichier.

f=open('[Link]','a')
lines=['Java Tutorials\n', 'DBMS tutorials\n', 'Mobile development
tutorials\n']
[Link](lines)
[Link]()

Exemple
le readlines()La méthode renvoie une liste de chaînes, chacune représentant une ligne du
fichier. Il est également possible de lire le fichier ligne par ligne jusqu'à la fin du fichier.

f=open('[Link]','r')
while True:
line=[Link]()
if line=='' : break
print (line, end='')
[Link]()

Production
Hello TutorialsPoint
Python Tutorials
Java Tutorials
DBMS tutorials
Mobile development tutorials

Mode binaire
Par défaut, les opérations de lecture / écriture sur un objet fichier sont effectuées sur des
données de chaîne de texte. Si nous voulons gérer des fichiers de différents autres types tels
que les médias (mp3), les exécutables (exe), les images (jpg) etc., nous devons ajouter le préfixe
«b» au mode lecture / écriture.
L'instruction suivante convertira une chaîne en octets et l'écrira dans un fichier.

f=open('[Link]', 'wb')
data=b"Hello World"
[Link](data)
[Link]()

La conversion d'une chaîne de texte en octets est également possible à l'aide de la fonction
encode ().

data="Hello World".encode('utf-8')

Nous devons utiliser ‘rb’mode pour lire le fichier binaire. La valeur renvoyée de la méthode read
() est d'abord décodée avant l'impression.

f=open('[Link]', 'rb')
data=[Link]()
print ([Link](encoding='utf-8'))

Afin d'écrire des données entières dans un fichier binaire, l'objet entier doit être converti en octets
par to_bytes() méthode.
n=25
n.to_bytes(8,'big')
f=open('[Link]', 'wb')
data=n.to_bytes(8,'big')
[Link](data)

Pour relire un fichier binaire, convertissez la sortie de la fonction read () en entier par la fonction
from_bytes ().

f=open('[Link]', 'rb')
data=[Link]()
n=int.from_bytes(data, 'big')
print (n)

Pour les données en virgule flottante, nous devons utiliser struct module de la bibliothèque
standard de Python.

import struct
x=23.50
data=[Link]('f',x)
f=open('[Link]', 'wb')
[Link](data)

Décompression de la chaîne de la fonction read (), pour récupérer les données flottantes du
fichier binaire.

f=open('[Link]', 'rb')
data=[Link]()
x=[Link]('f', data)
print (x)

Lecture / écriture simultanée

Lorsqu'un fichier est ouvert pour l'écriture (avec 'w' ou 'a'), il n'est pas possible d'en lire et vice
versa. Cela génère une erreur UnSupportedOperation. Nous devons fermer le fichier avant
d'effectuer une autre opération.
Afin d'effectuer les deux opérations simultanément, nous devons ajouter le caractère «+» dans le
paramètre mode. Par conséquent, le mode 'w +' ou 'r +' permet d'utiliser les méthodes write ()
ainsi que read () sans fermer un fichier. L'objet File prend également en charge la fonction seek ()
pour rembobiner le flux à n'importe quelle position d'octet souhaitée.

f=open('[Link]','w+')
[Link]('Hello world')
[Link](0,0)
data=[Link]()
print (data)
[Link]()

Le tableau suivant résume toutes les méthodes disponibles pour un fichier comme un objet.

Sr. Non Méthode et description

1 close()
Ferme le fichier. Un fichier fermé ne peut plus être lu ou écrit.

2 flush()
Videz le tampon interne.

3 fileno()
Renvoie le descripteur de fichier entier.

4 next()
Renvoie la ligne suivante du fichier chaque fois qu'il est appelé. Utilisez l'itérateur next () dans P

5 read([size])
Lit au maximum les octets de taille du fichier (moins si la lecture atteint EOF avant d'obtenir des

6 readline([size])
Lit une ligne entière du fichier. Un caractère de fin de ligne est conservé dans la chaîne.

sept readlines([sizehint])
Lit jusqu'à EOF en utilisant readline () et retourne une liste contenant les lignes.

8 seek(offset[, whence])
Définit la position actuelle du fichier. 0-début 1-courant 2-fin.

9 seek(offset[, whence])
Définit la position actuelle du fichier. 0-début 1-courant 2-fin.

dix tell()
 Renvoie la position actuelle du fichier

11 truncate([size])
Tronque la taille du fichier.

12 write(str)
Écrit une chaîne dans le fichier. Il n'y a pas de valeur de retour.

Gestion des fichiers avec le module os

En plus de l'objet File renvoyé par open()fonction, les opérations d'E / S sur les fichiers peuvent
également être effectuées à l'aide de la bibliothèque intégrée de Python a un module os qui
fournit des fonctions utiles dépendant du système d'exploitation. Ces fonctions effectuent des
opérations de lecture / écriture de bas niveau sur le fichier.
le open()La fonction du module os est similaire à l'open () intégré. Cependant, il ne renvoie pas
un objet fichier mais un descripteur de fichier, un entier unique correspondant au fichier ouvert.
Les valeurs 0, 1 et 2 du descripteur de fichier représentent les flux stdin, stdout et stderr. Les
autres fichiers recevront un descripteur de fichier incrémentiel à partir de 2.
Comme dans le cas de open() fonction intégrée, [Link]()La fonction doit également spécifier le
mode d'accès aux fichiers. Le tableau suivant répertorie les différents modes définis dans le
module os.

N ° Sr. Module OS et description

1 os.O_RDONLY
Ouvert en lecture uniquement

2 os.O_WRONLY
Ouvert à l'écriture uniquement

3 os.O_RDWR
Ouvert à la lecture et à l'écriture

4 os.O_NONBLOCK
Ne bloquez pas à l'ouverture

5 os.O_APPEND
Ajouter à chaque écriture

6 os.O_CREAT
 Créer un fichier s'il n'existe pas

sept os.O_TRUNC
Tronquer la taille à 0

8 os.O_EXCL
Erreur si la création et le fichier existent

Pour ouvrir un nouveau fichier pour y écrire des données, spécifiez O_WRONLY aussi bien
que O_CREATmodes en insérant l'opérateur pipe (|). La fonction [Link] () renvoie un
descripteur de fichier.

f=[Link]("[Link]", os.O_WRONLY|os.O_CREAT)

Notez que les données sont écrites sur le fichier disque sous la forme d'une chaîne d'octets. Par
conséquent, une chaîne normale est convertie en chaîne d'octets en utilisant la fonction encode
() comme précédemment.

data="Hello World".encode('utf-8')

La fonction write () du module os accepte cette chaîne d'octets et ce descripteur de fichier.

[Link](f,data)

N'oubliez pas de fermer le fichier en utilisant la fonction close ().

[Link](f)

Pour lire le contenu d'un fichier à l'aide de la fonction [Link] (), utilisez les instructions suivantes:

f=[Link]("[Link]", os.O_RDONLY)
data=[Link](f,20)
print ([Link]('utf-8'))

Notez que la fonction [Link] () a besoin d'un descripteur de fichier et du nombre d'octets à lire
(longueur de la chaîne d'octets).
Si vous souhaitez ouvrir un fichier pour des opérations de lecture / écriture simultanées, utilisez le
mode O_RDWR. Le tableau suivant montre les fonctions importantes liées à l'opération de fichier
dans le module os.

Sr. Fonctions et description

Non

1 [Link](fd)
Fermez le descripteur de fichier.
 2 [Link](file, flags[, mode])
Ouvrez le fichier et définissez différents drapeaux selon les drapeaux et éventuellement son mode

3 [Link](fd, n)
Lit au plus n octets à partir du descripteur de fichier fd. Renvoie une chaîne contenant les octets lus
a été atteinte, une chaîne vide est renvoyée.

4 [Link](fd, str)
Ecrivez la chaîne str dans le descripteur de fichier fd. Renvoie le nombre d'octets réellement écrits.

Persistance des données Python -

Sérialisation d'objets
L'objet fichier intégré de Python retourné par la fonction open () intégrée de Python présente un
inconvénient important. Lorsqu'elle est ouverte avec le mode 'w', la méthode write () n'accepte
que l'objet string.
Cela signifie que si vous avez des données représentées sous une forme non-chaîne, l'objet de
classes intégrées (nombres, dictionnaire, listes ou tuples) ou d'autres classes définies par
l'utilisateur, il ne peut pas être écrit directement dans un fichier. Avant d'écrire, vous devez le
convertir dans sa représentation sous forme de chaîne.

numbers=[10,20,30,40]
file=open('[Link]','w')
[Link](str(numbers))
[Link]()

Pour un fichier binaire, argument à write()La méthode doit être un objet octet. Par exemple, la
liste d'entiers est convertie en octets parbytearray() fonction puis écrit dans le fichier.

numbers=[10,20,30,40]
data=bytearray(numbers)
[Link](data)
[Link]()

Pour lire les données du fichier dans le type de données respectif, une conversion inverse doit
être effectuée.

file=open('[Link]','rb')
data=[Link]()
print (list(data))

Ce type de conversion manuelle, d'un objet au format chaîne ou octet (et vice versa) est très
fastidieux et fastidieux. Il est possible de stocker l'état d'un objet Python sous forme de flux
d'octets directement dans un fichier ou de flux mémoire et de le récupérer dans son état d'origine.
Ce processus est appelé sérialisation et désérialisation.
La bibliothèque intégrée de Python contient divers modules pour le processus de sérialisation et
de désérialisation.

N ° Sr. Nom et description

1 pickle
Bibliothèque de sérialisation spécifique à Python

2 marshal
Bibliothèque utilisée en interne pour la sérialisation

3 shelve
Persistance des objets pythoniques

4 dbm
bibliothèque offrant une interface avec la base de données Unix

5 csv
bibliothèque pour le stockage et la récupération des données Python au format CSV

6 json
Bibliothèque pour la sérialisation au format JSON universel

Persistance des données Python - Module

Pickle
La terminologie de Python pour la sérialisation et la désérialisation est respectivement le pickling
et le unpickling. Le module pickle de la bibliothèque Python utilise un format de données très
spécifique à Python. Par conséquent, les applications non Python peuvent ne pas être en mesure
de désérialiser correctement les données décapées. Il est également conseillé de ne pas décoller
les données d'une source non authentifiée.
Les données sérialisées (picklées) peuvent être stockées dans une chaîne d'octets ou un fichier
binaire. Ce module définitdumps() et loads()fonctions pour sélectionner et décoller les données
à l'aide d'une chaîne d'octets. Pour les processus basés sur des fichiers, le module
adump() et load() fonction.
Les protocoles pickle de Python sont les conventions utilisées dans la construction et la
déconstruction d'objets Python vers / à partir de données binaires. Actuellement, le module pickle
définit 5 protocoles différents comme indiqué ci-dessous -

N ° Sr. Noms et description

 1 Protocol version 0
Protocole original «lisible par l'homme» rétrocompatible avec les versions antérieures.

2 Protocol version 1
Ancien format binaire également compatible avec les versions antérieures de Python.

3 Protocol version 2
Introduit dans Python 2.3 fournit un décapage efficace des classes de nouveau style.

4 Protocol version 3
Ajouté dans Python 3.0. recommandé lorsque la compatibilité avec d'autres versions de Python 3

5 Protocol version 4
a été ajouté dans Python 3.4. Il ajoute la prise en charge des très gros objets

Exemple
Le module pickle se compose de la fonction dumps () qui renvoie une représentation sous forme
de chaîne de données picklées.

from pickle import dump

dct={"name":"Ravi", "age":23, "Gender":"M","marks":75}
dctstring=dumps(dct)
print (dctstring)

Production
b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x04\x00\x00\x00Raviq\x02X\x03\
x00\x00\x00ageq\x03K\x17X\x06\x00\x00\x00Genderq\x04X\x01\x00\x00\x00Mq\
x05X\x05\x00\x00\x00marksq\x06KKu.

Exemple
Utilisez la fonction charges () pour décocher la chaîne et obtenir l'objet dictionnaire d'origine.

from pickle import load

dct=loads(dctstring)
print (dct)
Production
{'name': 'Ravi', 'age': 23, 'Gender': 'M', 'marks': 75}

Les objets décapés peuvent également être stockés de manière persistante dans un fichier
disque, en utilisant la fonction dump () et récupérés en utilisant la fonction load ().

import pickle
f=open("[Link]","wb")
dct={"name":"Ravi", "age":23, "Gender":"M","marks":75}
[Link](dct,f)
[Link]()

#to read
import pickle
f=open("[Link]","rb")
d=[Link](f)
print (d)
[Link]()

Le module pickle fournit également une API orientée objet pour un mécanisme de sérialisation
sous la forme de Pickler et Unpickler Des classes.
Comme mentionné ci-dessus, tout comme les objets intégrés dans Python, les objets des classes
définies par l'utilisateur peuvent également être sérialisés de manière persistante dans un fichier
disque. Dans le programme suivant, nous définissons une classe User avec le nom et le numéro
de mobile comme attributs d'instance. En plus du constructeur __init __ (), la classe remplace la
méthode __str __ () qui renvoie une représentation sous forme de chaîne de son objet.

class User:
def __init__(self,name, mob):
[Link]=name
[Link]=mob
def __str__(self):
return ('Name: {} mobile: {} '. format([Link], [Link]))

Pour décaper l'objet de la classe ci-dessus dans un fichier, nous utilisons la classe pickler et sa
méthode dump ().

from pickle import Pickler

user1=User('Rajani', 'raj@[Link]', '1234567890')
file=open('userdata','wb')
Pickler(file).dump(user1)
Pickler(file).dump(user2)
[Link]()

Inversement, la classe Unpickler a la méthode load () pour récupérer l'objet sérialisé comme suit
-

from pickle import Unpickler

file=open('usersdata','rb')
user1=Unpickler(file).load()
print (user1)

Persistance des données Python - Module

Marshal
Les fonctionnalités de sérialisation d'objets du module marshal dans la bibliothèque standard de
Python sont similaires au module pickle. Cependant, ce module n'est pas utilisé pour les données
à usage général. D'autre part, il est utilisé par Python lui-même pour la sérialisation d'objets
internes de Python afin de prendre en charge les opérations de lecture / écriture sur les versions
compilées des modules Python (fichiers .pyc).
Le format de données utilisé par le module marshal n'est pas compatible entre les versions de
Python. Par conséquent, un script Python compilé (fichier .pyc) d'une version ne s'exécutera
probablement pas sur une autre.
Tout comme le module pickle, le module marshal a également défini les fonctions load () et dump
() pour lire et écrire des objets rassemblés depuis / vers un fichier.

déverser()
Cette fonction écrit une représentation octet de l'objet Python pris en charge dans un fichier. Le
fichier lui-même est un fichier binaire avec autorisation d'écriture

charge()
Cette fonction lit les données d'octets d'un fichier binaire et les convertit en objet Python.
L'exemple suivant montre l'utilisation des fonctions dump () et load () pour gérer les objets code
de Python, qui sont utilisés pour stocker des modules Python précompilés.
Le code utilise des compile() pour créer un objet de code à partir d'une chaîne source qui
incorpore des instructions Python.

compile(source, file, mode)

Le paramètre de fichier doit être le fichier à partir duquel le code a été lu. S'il n'a pas été lu à
partir d'un fichier, passez une chaîne arbitraire.
Le paramètre mode est 'exec' si la source contient une séquence d'instructions, 'eval' s'il y a une
seule expression ou 'single' s'il contient une seule instruction interactive.
L'objet de code de compilation est ensuite stocké dans un fichier .pyc à l'aide de la fonction dump
().
import marshal
script = """
a=10
b=20
print ('addition=',a+b)
"""
code = compile(script, "script", "exec")
f=open("[Link]","wb")
[Link](code, f)
[Link]()

Pour désérialiser, l'objet du fichier .pyc utilise la fonction load (). Puisqu'il retourne un objet code,
il peut être exécuté en utilisant exec (), une autre fonction intégrée.

import marshal
f=open("[Link]","rb")
data=[Link](f)
exec (data)

Persistance des données Python - Module

Shelve
Le module shelve de la bibliothèque standard de Python fournit un mécanisme de persistance
d'objet simple mais efficace. L'objet d'étagère défini dans ce module est un objet de type
dictionnaire qui est stocké de manière persistante dans un fichier disque. Cela crée un fichier
similaire à la base de données dbm sur les systèmes UNIX.
Le dictionnaire d'étagère a certaines restrictions. Seul le type de données chaîne peut être utilisé
comme clé dans cet objet dictionnaire spécial, tandis que tout objet Python sélectionnable peut
être utilisé comme valeur.
Le module shelve définit trois classes comme suit -

Sr. Module Shelve et description

Non

1 Shelf
Il s'agit de la classe de base pour les implémentations de plateau. Il est initialisé avec un objet de ty

2 BsdDbShelf
Ceci est une sous-classe de la classe Shelf. L'objet dict passé à son constructeur doit prendre en ch
previous (), last () et set_location ().
 3 DbfilenameShelf
C'est aussi une sous-classe de Shelf mais accepte un nom de fichier comme paramètre pour son co
dict.

La fonction open () définie dans le module shelve qui renvoie un DbfilenameShelf objet.

open(filename, flag='c', protocol=None, writeback=False)

Le paramètre de nom de fichier est affecté à la base de données créée. La valeur par défaut du
paramètre d'indicateur est «c» pour l'accès en lecture / écriture. Les autres indicateurs sont 'w'
(écriture seule) 'r' (lecture seule) et 'n' (nouveau avec lecture / écriture).
La sérialisation elle-même est régie par le protocole pickle, la valeur par défaut est aucune. Le
dernier paramètre d'écriture différée par défaut est false. S'il est défini sur true, les entrées
accessibles sont mises en cache. Chaque accès appelle les opérations sync () et close (), le
processus peut donc être lent.
Le code suivant crée une base de données et y stocke les entrées de dictionnaire.

import shelve
s=[Link]("test")
s['name']="Ajay"
s['age']=23
s['marks']=75
[Link]()

Cela créera le fichier [Link] dans le répertoire actuel et stockera les données clé-valeur sous
forme hachée. L'objet Shelf dispose des méthodes suivantes:

N ° Sr. Méthodes et description

1 close()
synchroniser et fermer l'objet dict persistant.

2 sync()
Réécrivez toutes les entrées du cache si l'étagère a été ouverte avec l'écriture différée définie sur

3 get()
renvoie la valeur associée à la clé

4 items()
liste de tuples - chaque tuple est une paire clé / valeur

5 keys()
 liste des clés d'étagère

6 pop()
supprime la clé spécifiée et renvoie la valeur correspondante.

sept update()
Mettre à jour l'étagère à partir d'un autre dict / itérable

8 values()
liste des valeurs de conservation

Pour accéder à la valeur d'une clé particulière dans l'étagère -

s=[Link]('test')
print (s['age']) #this will print 23
s['age']=25
print ([Link]('age')) #this will print 25
[Link]('marks') #this will remove corresponding k-v pair

Comme dans un objet dictionnaire intégré, les méthodes items (), keys () et values () renvoient
des objets view.

print (list([Link]()))
[('name', 'Ajay'), ('age', 25), ('marks', 75)]

print (list([Link]()))
['name', 'age', 'marks']

print (list([Link]()))
['Ajay', 25, 75]

Pour fusionner des éléments d'un autre dictionnaire avec une étagère, utilisez la méthode update
().

d={'salary':10000, 'designation':'manager'}
[Link](d)
print (list([Link]()))

[('name', 'Ajay'), ('age', 25), ('salary', 10000), ('designation',

'manager')]
Persistance des données Python - paquet
dbm
Le package dbm présente un dictionnaire comme les bases de données de style DBM
d'interface. DBM stands for DataBase Manager. Ceci est utilisé par le système d'exploitation
UNIX (et similaire à UNIX). La bibliothèque dbbm est un moteur de base de données simple écrit
par Ken Thompson. Ces bases de données utilisent des objets chaîne codés en binaire comme
clé, ainsi que comme valeur.
La base de données stocke les données à l'aide d'une seule clé (une clé primaire) dans des
compartiments de taille fixe et utilise des techniques de hachage pour permettre une
récupération rapide des données par clé.
Le paquet dbm contient les modules suivants -
 [Link] module est une interface vers la version de la bibliothèque DBM implémentée
par le projet GNU.
 [Link] module fournit une interface à l'implémentation UNIX nbdm.
 [Link] utilisé comme option de secours dans le cas où d'autres implémentations
de dbm ne sont pas trouvées. Cela ne nécessite aucune dépendance externe mais est
plus lent que d'autres.

>>> [Link]('[Link]')
'[Link]'
>>> import dbm
>>> db=[Link]('[Link]','n')
>>> db['name']=Raj Deshmane'
>>> db['address']='Kirtinagar Pune'
>>> db['PIN']='431101'
>>> [Link]()

La fonction open () permet le mode ces drapeaux -

N ° Sr. Valeur et signification

1 'r'
Ouvrir la base de données existante pour lecture uniquement (par défaut)

2 'w'
Ouvrez la base de données existante pour la lecture et l'écriture

3 'c'
Ouvrez la base de données pour la lecture et l'écriture, en la créant si elle n'existe pas

4 'n'
 Créez toujours une nouvelle base de données vide, ouverte à la lecture et à l'écriture

L'objet dbm est un objet de type dictionnaire, tout comme un objet d'étagère. Par conséquent,
toutes les opérations de dictionnaire peuvent être effectuées. L'objet dbm peut invoquer les
méthodes get (), pop (), append () et update (). Le code suivant ouvre «[Link]» avec
l'indicateur «r» et itère sur la collection de paires clé-valeur.

>>> db=[Link]('[Link]','r')
>>> for k,v in [Link]():
print (k,v)
b'name' : b'Raj Deshmane'
b'address' : b'Kirtinagar Pune'
b'PIN' : b'431101'

Persistance des données Python - Module

CSV
CSV stands for comma separated values. Ce format de fichier est un format de données
couramment utilisé lors de l'exportation / importation de données vers / depuis des feuilles de
calcul et des tables de données dans des bases de données. Le module csv a été incorporé
dans la bibliothèque standard de Python suite à PEP 305. Il présente des classes et des
méthodes pour effectuer des opérations de lecture / écriture sur un fichier CSV conformément
aux recommandations de PEP 305.
CSV est un format de données d'exportation préféré par le logiciel de feuille de calcul Excel de
Microsoft. Cependant, le module csv peut également gérer les données représentées par
d'autres dialectes.
L'interface API CSV comprend les classes d'écrivain et de lecteur suivantes:

écrivain()
Cette fonction du module csv renvoie un objet écrivain qui convertit les données en une chaîne
délimitée et les stocke dans un objet fichier. La fonction a besoin d'un objet fichier avec
autorisation d'écriture comme paramètre. Chaque ligne écrite dans le fichier émet un caractère
de nouvelle ligne. Pour éviter tout espace supplémentaire entre les lignes, le paramètre de
nouvelle ligne est défini sur «».
La classe écrivain a les méthodes suivantes -

écrivainow ()
Cette méthode écrit les éléments dans un itérable (liste, tuple ou chaîne), en les séparant par
une virgule.
écrivain ()
Cette méthode prend une liste d'itérables, comme paramètre et écrit chaque élément sous la
forme d'une ligne d'éléments séparés par des virgules dans le fichier.
Example
L'exemple suivant montre l'utilisation de la fonction writer (). Tout d'abord, un fichier est ouvert en
mode «w». Ce fichier est utilisé pour obtenir un objet écrivain. Chaque tuple de la liste des tuples
est ensuite écrit dans le fichier à l'aide de la méthode writerow ().

import csv
persons=[('Lata',22,45),('Anil',21,56),('John',20,60)]
csvfile=open('[Link]','w', newline='')
obj=[Link](csvfile)
for person in persons:
[Link](person)
[Link]()

Output
Cela créera le fichier «[Link]» dans le répertoire courant. Il affichera les données suivantes.

Lata,22,45
Anil,21,56
John,20,60

Au lieu d'itérer sur la liste pour écrire chaque ligne individuellement, nous pouvons utiliser la
méthode writerows ().

csvfile=open('[Link]','w', newline='')
persons=[('Lata',22,45),('Anil',21,56),('John',20,60)]
obj=[Link](csvfile)
[Link](persons)
[Link]()

lecteur()
Cette fonction renvoie un objet lecteur qui renvoie un itérateur de lignes dans le csv file. En
utilisant la boucle for régulière, toutes les lignes du fichier sont affichées dans l'exemple suivant -

Exemple
csvfile=open('[Link]','r', newline='')
obj=[Link](csvfile)
 for row in obj:
print (row)

Production
['Lata', '22', '45']
['Anil', '21', '56']
['John', '20', '60']

L'objet lecteur est un itérateur. Par conséquent, il prend en charge la fonction next () qui peut
également être utilisée pour afficher toutes les lignes du fichier csv au lieu d'unfor loop.

csvfile=open('[Link]','r', newline='')
obj=[Link](csvfile)
while True:
try:
row=next(obj)
print (row)
except StopIteration:
break

Comme mentionné précédemment, le module csv utilise Excel comme dialecte par défaut. Le
module csv définit également une classe de dialectes. Dialect est un ensemble de normes
utilisées pour implémenter le protocole CSV. La liste des dialectes disponibles peut être obtenue
par la fonction list_dialects ().

>>> csv.list_dialects()
['excel', 'excel-tab', 'unix']

En plus des itérables, le module csv peut exporter un objet dictionnaire vers un fichier CSV et le
lire pour remplir l'objet dictionnaire Python. A cet effet, ce module définit les classes suivantes -

DictWriter ()
Cette fonction renvoie un objet DictWriter. Il est similaire à l'objet écrivain, mais les lignes sont
mappées à l'objet dictionnaire. La fonction a besoin d'un objet fichier avec autorisation d'écriture
et d'une liste de clés utilisées dans le dictionnaire comme paramètre fieldnames. Ceci est utilisé
pour écrire la première ligne du fichier comme en-tête.

en-tête d'écriture ()
Cette méthode écrit la liste des clés dans le dictionnaire sous la forme d'une ligne séparée par
des virgules en tant que première ligne du fichier.
Dans l'exemple suivant, une liste d'éléments de dictionnaire est définie. Chaque élément de la
liste est un dictionnaire. En utilisant la méthode writrows (), ils sont écrits dans un fichier séparés
par des virgules.

persons=[
{'name':'Lata', 'age':22, 'marks':45},
{'name':'Anil', 'age':21, 'marks':56},
{'name':'John', 'age':20, 'marks':60}
]
csvfile=open('[Link]','w', newline='')
fields=list(persons[0].keys())
obj=[Link](csvfile, fieldnames=fields)
[Link]()
[Link](persons)
[Link]()

Le fichier [Link] affiche le contenu suivant -

name,age,marks
Lata,22,45
Anil,21,56
John,20,60

DictReader ()
Cette fonction renvoie un objet DictReader à partir du fichier CSV sous-jacent. Comme, dans le
cas d'un objet lecteur, celui-ci est également un itérateur, en utilisant quel contenu du fichier est
récupéré.

csvfile=open('[Link]','r', newline='')
obj=[Link](csvfile)

La classe fournit l'attribut fieldnames, renvoyant les clés de dictionnaire utilisées comme en-tête
du fichier.

print ([Link])
['name', 'age', 'marks']

Utilisez une boucle sur l'objet DictReader pour récupérer des objets de dictionnaire individuels.

for row in obj:

print (row)

Cela entraîne la sortie suivante -

OrderedDict([('name', 'Lata'), ('age', '22'), ('marks', '45')])
OrderedDict([('name', 'Anil'), ('age', '21'), ('marks', '56')])
OrderedDict([('name', 'John'), ('age', '20'), ('marks', '60')])

Pour convertir l'objet OrderedDict en dictionnaire normal, nous devons d'abord importer
OrderedDict à partir du module de collections.

from collections import OrderedDict

r=OrderedDict([('name', 'Lata'), ('age', '22'), ('marks', '45')])
dict(r)
{'name': 'Lata', 'age': '22', 'marks': '45'}

Persistance des données Python - Module

JSON
JSON signifie JavaScript Object Notation. C'est un format d'échange de données léger. Il s'agit
d'un format texte indépendant du langage et multiplateforme, pris en charge par de nombreux
langages de programmation. Ce format est utilisé pour l'échange de données entre le serveur
Web et les clients.
Le format JSON est similaire à pickle. Cependant, la sérialisation pickle est spécifique à Python
alors que le format JSON est implémenté par de nombreux langages et est donc devenu un
standard universel. La fonctionnalité et l'interface du module json dans la bibliothèque standard
de Python sont similaires aux modules pickle et marshal.
Tout comme dans le module pickle, le module json fournit également dumps() et loads() fonction
pour la sérialisation de l'objet Python en chaîne codée JSON, et dump() et load() Les fonctions
écrivent et lisent des objets Python sérialisés vers / depuis un fichier.
 dumps() - Cette fonction convertit l'objet au format JSON.
 loads() - Cette fonction convertit une chaîne JSON en objet Python.
L'exemple suivant montre l'utilisation de base de ces fonctions -

import json
data=['Rakesh',{'marks':(50,60,70)}]
s=[Link](data)
[Link](s)

La fonction dumps () peut prendre l'argument sort_keys facultatif. Par défaut, il est faux. Si la
valeur est True, les clés du dictionnaire apparaissent dans l'ordre trié dans la chaîne JSON.
La fonction dumps () a un autre paramètre facultatif appelé indent qui prend un nombre comme
valeur. Il décide de la longueur de chaque segment de la représentation formatée de la chaîne
json, similaire à la sortie d'impression.
Le module json a également une API orientée objet correspondant aux fonctions ci-dessus. Il
existe deux classes définies dans le module - JSONEncoder et JSONDecoder.
Classe JSONEncoder
L'objet de cette classe est l'encodeur pour les structures de données Python. Chaque type de
données Python est converti en type JSON correspondant, comme indiqué dans le tableau
suivant -

Python

Dict

liste, tuple

Str

Enums dérivés int, float, int et float

Vrai

Faux

Aucun

La classe JSONEncoder est instanciée par le constructeur JSONEncoder (). Les méthodes
importantes suivantes sont définies dans la classe d'encodeur -

N ° Sr. Méthodes et description

1 encode()
sérialise l'objet Python au format JSON

2 iterencode()
Encode l'objet et renvoie un itérateur donnant la forme codée de chaque élément de l'objet.

3 indent
Détermine le niveau de retrait de la chaîne codée

4 sort_keys
 est soit vrai soit faux pour que les clés apparaissent dans un ordre trié ou non.

5 Check_circular
si True, vérifiez la référence circulaire dans l'objet de type conteneur

L'exemple suivant encode l'objet de liste Python.

e=[Link]()
[Link](data)

Classe JSONDecoder
L'objet de cette classe aide à être décodé en chaîne json dans la structure de données Python.
La méthode principale de cette classe est decode (). L'exemple de code suivant récupère l'objet
de liste Python à partir de la chaîne codée à l'étape précédente.

d=[Link]()
[Link](s)

Le module json définit load() et dump() fonctions pour écrire des données JSON dans un fichier
comme un objet - qui peut être un fichier disque ou un flux d'octets et en lire les données.

déverser()
Cette fonction écrit les données d'objet JSONed Python dans un fichier. Le fichier doit être ouvert
en mode «w».

import json
data=['Rakesh', {'marks': (50, 60, 70)}]
fp=open('[Link]','w')
[Link](data,fp)
[Link]()

Ce code créera '[Link]' dans le répertoire courant. Il montre le contenu comme suit -

["Rakesh", {"marks": [50, 60, 70]}]

charge()
Cette fonction charge les données JSON à partir du fichier et renvoie un objet Python à partir de
celui-ci. Le fichier doit être ouvert avec l'autorisation de lecture (doit avoir le mode «r»).
Example

fp=open('[Link]','r')
 ret=[Link](fp)
print (ret)
[Link]()

Output

['Rakesh', {'marks': [50, 60, 70]}]

le [Link] module dispose également d'une interface de ligne de commande qui valide les
données dans le fichier et imprime l'objet JSON d'une manière assez formatée.

C:\python37>python -m [Link] [Link]

[
"Rakesh",
{
"marks": [
50,
60,
70
]
}
]

Persistance des données Python -

Analyseurs XML
XML est l'acronyme de eXtensible Markup Language. C'est un langage portable, open source
et multiplateforme très semblable au HTML ou au SGML et recommandé par le World Wide Web
Consortium.
Il s'agit d'un format d'échange de données bien connu, utilisé par un grand nombre d'applications
telles que les services Web, les outils bureautiques et Service Oriented Architectures(SOA). Le
format XML est à la fois lisible par machine et lisible par l'homme.
Le package xml de la bibliothèque Python standard se compose des modules suivants pour le
traitement XML -

N ° Sr. Modules et description

1 [Link]
l'API ElementTree, un processeur XML simple et léger

2 [Link]
 la définition de l'API DOM

3 [Link]
une implémentation DOM minimale

4 [Link]
Implémentation de l'interface SAX2

5 [Link]
la liaison de l'analyseur Expat

Les données du document XML sont organisées dans un format hiérarchique arborescent, en
commençant par la racine et les éléments. Chaque élément est un nœud unique dans
l'arborescence et possède un attribut entre les balises <> et </>. Un ou plusieurs sous-éléments
peuvent être affectés à chaque élément.
Voici un exemple typique de document XML -

<?xml version = "1.0" encoding = "iso-8859-1"?>

<studentlist>
<student>
<name>Ratna</name>
<subject>Physics</subject>
<marks>85</marks>
</student>
<student>
<name>Kiran</name>
<subject>Maths</subject>
<marks>100</marks>
</student>
<student>
<name>Mohit</name>
<subject>Biology</subject>
<marks>92</marks>
</student>
</studentlist>

Tout en utilisant ElementTreemodule, la première étape consiste à configurer l'élément racine de

l'arbre. Chaque élément a une balise et un attrib qui est un objet dict. Pour l'élément racine, un
attrib est un dictionnaire vide.
import [Link] as xmlobj
root=[Link]('studentList')

Maintenant, nous pouvons ajouter un ou plusieurs éléments sous l'élément racine. Chaque objet
élément peut avoirSubElements. Chaque sous-élément a un attribut et une propriété de texte.

student=[Link]('student')
nm=[Link](student, 'name')
[Link]='name'
subject=[Link](student, 'subject')
[Link]='Ratna'
[Link]='Physics'
marks=[Link](student, 'marks')
[Link]='85'

Ce nouvel élément est ajouté à la racine en utilisant la méthode append ().

[Link](student)

Ajoutez autant d'éléments que vous le souhaitez en utilisant la méthode ci-dessus. Enfin, l'objet
élément racine est écrit dans un fichier.

tree = [Link](root)
file = open('[Link]','wb')
[Link](file)
[Link]()

Maintenant, nous voyons comment analyser le fichier XML. Pour cela, construisez une
arborescence de documents en donnant son nom comme paramètre de fichier dans le
constructeur ElementTree.

tree = [Link](file='[Link]')

L'objet arbre a getroot() méthode pour obtenir l'élément racine et getchildren () retourne une liste
d'éléments en dessous.

root = [Link]()
children = [Link]()

Un objet dictionnaire correspondant à chaque sous-élément est construit en itérant sur la

collection de sous-éléments de chaque nœud enfant.

for child in children:

student={}
pairs = [Link]()
 for pair in pairs:
product[[Link]]=[Link]

Chaque dictionnaire est ensuite ajouté à une liste renvoyant la liste d'origine des objets du
dictionnaire.
SAXest une interface standard pour l'analyse XML basée sur les événements. L'analyse XML
avec SAX nécessite ContentHandler en sous-classant [Link]. Vous enregistrez
des rappels pour les événements intéressants, puis laissez l'analyseur parcourir le document.
SAX est utile lorsque vos documents sont volumineux ou que vous avez des limitations de
mémoire car il analyse le fichier pendant qu'il le lit à partir du disque. Par conséquent, le fichier
entier n'est jamais stocké dans la mémoire.

Modèle d'objet de document

(DOM) API est une recommandation du World Wide Web Consortium. Dans ce cas, le fichier
entier est lu dans la mémoire et stocké sous une forme hiérarchique (arborescente) pour
représenter toutes les fonctionnalités d'un document XML.
SAX, pas aussi rapide que DOM, avec des fichiers volumineux. D'un autre côté, DOM peut tuer
des ressources s'il est utilisé sur de nombreux petits fichiers. SAX est en lecture seule, tandis
que DOM autorise les modifications du fichier XML.

Persistance des données Python - Module

Plistlib
Le format plist est principalement utilisé par MAC OS X. Ces fichiers sont essentiellement des
documents XML. Ils stockent et récupèrent les propriétés d'un objet. La bibliothèque Python
contient le module plist, qui est utilisé pour lire et écrire des fichiers 'liste de propriétés' (ils ont
généralement l'extension .plist ').
le plistlib module est plus ou moins similaire aux autres bibliothèques de sérialisation dans le
sens, il fournit également des fonctions dumps () et charges () pour la représentation sous forme
de chaîne d'objets Python et des fonctions load () et dump () pour le fonctionnement du disque.
L'objet dictionnaire suivant conserve la propriété (clé) et la valeur correspondante -

proplist = {
"name" : "Ganesh",
"designation":"manager",
"dept":"accts",
"salary" : {"basic":12000, "da":4000, "hra":800}
}

Afin d'écrire ces propriétés dans un fichier disque, nous appelons la fonction dump () dans le
module plist.

import plistlib
fileName=open('[Link]','wb')
[Link](proplist, fileName)
[Link]()

Inversement, pour relire les valeurs de propriété, utilisez la fonction load () comme suit -

fp= open('[Link]', 'rb')

pl = [Link](fp)
print(pl)

Persistance des données Python - Module

Sqlite3
Un inconvénient majeur des fichiers CSV, JSON, XML, etc. est qu'ils ne sont pas très utiles pour
l'accès aléatoire et le traitement des transactions car ils sont en grande partie non structurés. Par
conséquent, il devient très difficile de modifier le contenu.
Ces fichiers plats ne conviennent pas à l'environnement client-serveur car ils ne disposent pas de
capacité de traitement asynchrone. L'utilisation de fichiers de données non structurés entraîne
une redondance et une incohérence des données.
Ces problèmes peuvent être surmontés en utilisant une base de données relationnelle. Une base
de données est une collection organisée de données pour éliminer la redondance et les
incohérences et maintenir l'intégrité des données. Le modèle de base de données relationnelle
est très populaire.
Son concept de base est d'organiser les données dans une table d'entité (appelée relation). La
structure de la table d'entités fournit un attribut dont la valeur est unique pour chaque ligne. Un tel
attribut est appelé'primary key'.
Lorsque la clé primaire d'une table apparaît dans la structure d'autres tables, elle est
appelée 'Foreign key'et cela forme la base de la relation entre les deux. Sur la base de ce
modèle, de nombreux produits SGBDR populaires sont actuellement disponibles -
 GadFly
 mSQL
 MySQL
 PostgreSQL
 Microsoft SQL Server 2000
 Informix
 Interbase
 Oracle
 Sybase
 SQLite
SQLite est une base de données relationnelle légère utilisée dans une grande variété
d'applications. Il s'agit d'un moteur de base de données SQL transactionnel autonome, sans
serveur et sans configuration. La base de données entière est un fichier unique, qui peut être
placé n'importe où dans le système de fichiers. C'est un logiciel open source, avec un très faible
encombrement et une configuration nulle. Il est couramment utilisé dans les appareils intégrés,
l'IOT et les applications mobiles.
Toutes les bases de données relationnelles utilisent SQL pour gérer les données dans les tables.
Cependant, auparavant, chacune de ces bases de données était connectée à l'application
Python à l'aide du module Python spécifique au type de base de données.
Par conséquent, il y avait un manque de compatibilité entre eux. Si un utilisateur voulait changer
de produit de base de données, cela s'avérerait difficile. Ce problème d'incompatibilité a été
résolu en lançant «Python Enhancement Proposition (PEP 248)» pour recommander une
interface cohérente avec les bases de données relationnelles connues sous le nom de DB-API.
Les dernières recommandations sont appeléesDB-APIVersion 2.0. (PEP 249)
La bibliothèque standard de Python se compose du module sqlite3 qui est un module compatible
DB-API pour gérer la base de données SQLite via le programme Python. Ce chapitre explique la
connectivité de Python avec la base de données SQLite.
Comme mentionné précédemment, Python a un support intégré pour la base de données SQLite
sous la forme d'un module sqlite3. Pour les autres bases de données, le module Python
compatible DB-API respectif devra être installé à l'aide de l'utilitaire pip. Par exemple, pour utiliser
la base de données MySQL, nous devons installer le module PyMySQL.

pip install pymysql

Les étapes suivantes sont recommandées dans DB-API -

 Établissez la connexion avec la base de données en utilisant connect() fonction et
obtenir l'objet de connexion.
 Appel cursor() méthode d'objet de connexion pour obtenir un objet curseur.
 Formez une chaîne de requête composée d'une instruction SQL à exécuter.
 Exécutez la requête souhaitée en appelant execute() méthode.
 Fermez la connexion.

import sqlite3
db=[Link]('[Link]')

Ici, db est l'objet de connexion représentant [Link]. Notez que cette base de données sera créée
si elle n'existe pas déjà. L'objet de connexion db a les méthodes suivantes -

N ° Sr. Méthodes et description

1 cursor():
Renvoie un objet Cursor qui utilise cette connexion.

2 commit():
Valide explicitement toutes les transactions en attente dans la base de données.

3 rollback():
Cette méthode facultative entraîne la restauration d'une transaction au point de départ.

4 close():
Ferme définitivement la connexion à la base de données.

Un curseur agit comme un handle pour une requête SQL donnée permettant la récupération
d'une ou plusieurs lignes du résultat. L'objet curseur est obtenu à partir de la connexion pour
exécuter des requêtes SQL à l'aide de l'instruction suivante -
cur=[Link]()

L'objet curseur a les méthodes suivantes définies -

Sr. Non Méthodes et description

1 execute()
Exécute la requête SQL dans un paramètre de chaîne.

2 executemany()
Exécute la requête SQL à l'aide d'un ensemble de paramètres dans la liste des tuples.

3 fetchone()
Récupère la ligne suivante du jeu de résultats de la requête.

4 fetchall()
Récupère toutes les lignes restantes de l'ensemble de résultats de la requête.

5 callproc()
Appelle une procédure stockée.

6 close()
Ferme l'objet curseur.

Le code suivant crée une table dans [Link]: -

import sqlite3
db=[Link]('[Link]')
cur =[Link]()
[Link]('''CREATE TABLE student (
StudentID INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT (20) NOT NULL,
age INTEGER,
marks REAL);''')
print ('table created successfully')
[Link]()

L'intégrité des données souhaitée dans une base de données est obtenue
par commit() et rollback()méthodes de l'objet de connexion. La chaîne de requête SQL peut
avoir une requête SQL incorrecte qui peut déclencher une exception, qui doit être correctement
gérée. Pour cela, l'instruction execute () est placée dans le bloc try. Si elle réussit, le résultat est
sauvegardé en permanence à l'aide de la méthode commit (). Si la requête échoue, la transaction
est annulée à l'aide de la méthode rollback ().
Le code suivant exécute la requête INSERT sur la table student dans [Link].

import sqlite3
db=[Link]('[Link]')
qry="insert into student (name, age, marks) values('Abbas', 20, 80);"
try:
cur=[Link]()
[Link](qry)
[Link]()
print ("record added successfully")
except:
print ("error in query")
[Link]()
[Link]()

Si vous souhaitez que les données de la clause values de la requête INSERT soient fournies
dynamiquement par l'entrée utilisateur, utilisez la substitution de paramètres comme
recommandé dans Python DB-API. Le ? character est utilisé comme espace réservé dans la
chaîne de requête et fournit les valeurs sous la forme d'un tuple dans la méthode execute ().
L'exemple suivant insère un enregistrement à l'aide de la méthode de substitution de paramètre.
Le nom, l'âge et les notes sont pris en compte.

import sqlite3
db=[Link]('[Link]')
nm=input('enter name')
a=int(input('enter age'))
m=int(input('enter marks'))
qry="insert into student (name, age, marks) values(?,?,?);"
try:
cur=[Link]()
[Link](qry, (nm,a,m))
[Link]()
print ("one record added successfully")
except:
print("error in operation")
[Link]()
[Link]()
Le module sqlite3 définit le executemany()méthode qui est capable d'ajouter plusieurs
enregistrements à la fois. Les données à ajouter doivent être données dans une liste de tuples,
chaque tuple contenant un enregistrement. L'objet list est le paramètre de la méthode
executemany (), avec la chaîne de requête. Cependant, la méthode executemany () n'est pas
prise en charge par certains des autres modules.
le UPDATELa requête contient généralement une expression logique spécifiée par la clause
WHERE. La chaîne de requête de la méthode execute () doit contenir une syntaxe de requête
UPDATE. Pour mettre à jour la valeur de 'age' à 23 pour name = 'Anil', définissez la chaîne
comme ci-dessous:

qry="update student set age=23 where name='Anil';"

Pour rendre le processus de mise à jour plus dynamique, nous utilisons la méthode de
substitution de paramètres décrite ci-dessus.

import sqlite3
db=[Link]('[Link]')
nm=input(‘enter name’)
a=int(input(‘enter age’))
qry="update student set age=? where name=?;"
try:
cur=[Link]()
[Link](qry, (a, nm))
[Link]()
print("record updated successfully")
except:
print("error in query")
[Link]()
[Link]()

De même, l'opération DELETE est effectuée en appelant la méthode execute () avec une chaîne
ayant la syntaxe de requête DELETE de SQL. Incidemment,DELETE La requête contient
également généralement un WHERE clause.

import sqlite3
db=[Link]('[Link]')
nm=input(‘enter name’)
qry="DELETE from student where name=?;"
try:
cur=[Link]()
[Link](qry, (nm,))
[Link]()
print("record deleted successfully")
except:
print("error in operation")
[Link]()
[Link]()

L'une des opérations importantes sur une table de base de données est la récupération des
enregistrements à partir de celle-ci. SQL fournitSELECTrequête pour le but. Lorsqu'une chaîne
contenant la syntaxe de requête SELECT est donnée à la méthode execute (), un objet
d'ensemble de résultats est renvoyé. Il existe deux méthodes importantes avec un objet curseur
à l'aide desquelles un ou plusieurs enregistrements du jeu de résultats peuvent être récupérés.

fetchone ()
Récupère le prochain enregistrement disponible de l'ensemble de résultats. Il s'agit d'un tuple
composé des valeurs de chaque colonne de l'enregistrement extrait.

fetchall ()
Récupère tous les enregistrements restants sous la forme d'une liste de tuples. Chaque tuple
correspond à un enregistrement et contient les valeurs de chaque colonne de la table.
L'exemple suivant répertorie tous les enregistrements de la table Student

import sqlite3
db=[Link]('[Link]')
37
sql="SELECT * from student;"
cur=[Link]()
[Link](sql)
while True:
record=[Link]()
if record==None:
break
print (record)
[Link]()

Si vous prévoyez d'utiliser une base de données MySQL au lieu d'une base de données SQLite,
vous devez installer PyMySQLmodule comme décrit ci-dessus. Toutes les étapes du processus
de connectivité de la base de données étant identiques, puisque la base de données MySQL est
installée sur un serveur, la fonction connect () a besoin de l'URL et des informations de
connexion.

import pymysql
con=[Link]('localhost', 'root', '***')
La seule chose qui peut différer avec SQLite est les types de données spécifiques à MySQL. De
même, toute base de données compatible ODBC peut être utilisée avec Python en installant le
module pyodbc.

Persistance des données Python -

SQLAlchemy
Toute base de données relationnelle contient des données dans des tables. La structure de la
table définit le type de données des attributs qui sont essentiellement des types de données
primaires uniquement qui sont mappés aux types de données intégrés correspondants de
Python. Cependant, les objets définis par l'utilisateur de Python ne peuvent pas être stockés et
récupérés de manière permanente vers / depuis des tables SQL.
Il s'agit d'une disparité entre les types SQL et les langages de programmation orientés objet tels
que Python. SQL n'a pas de type de données équivalent pour d'autres tels que dict, tuple, liste ou
toute classe définie par l'utilisateur.
Si vous devez stocker un objet dans une base de données relationnelle, ses attributs d'instance
doivent d'abord être déconstruits en types de données SQL, avant d'exécuter la requête INSERT.
D'autre part, les données récupérées à partir d'une table SQL sont de types primaires. Un objet
Python du type souhaité devra être construit en utilisant pour une utilisation dans un script
Python. C'est là que les mappeurs relationnels d'objets sont utiles.

Mappeur de relation d'objets (ORM)

Un Object Relation Mapper(ORM) est une interface entre une classe et une table SQL. Une
classe Python est mappée à une certaine table dans la base de données, de sorte que la
conversion entre les types objet et SQL est effectuée automatiquement.
La classe Students écrite en code Python est mappée à la table Students dans la base de
données. Par conséquent, toutes les opérations CRUD sont effectuées en appelant les méthodes
respectives de la classe. Cela élimine le besoin d'exécuter des requêtes SQL codées en dur
dans un script Python.
La bibliothèque ORM agit ainsi comme une couche d'abstraction sur les requêtes SQL brutes et
peut être utile dans le développement rapide d'applications. SQLAlchemyest un mappeur
relationnel d'objet populaire pour Python. Toute manipulation d'état de l'objet modèle est
synchronisée avec sa ligne associée dans la table de base de données.
La bibliothèque SQLALchemy comprend ORM API et langage d'expression SQL (SQLAlchemy
Core). Le langage d'expression exécute directement les constructions primitives de la base de
données relationnelle.
ORM est un modèle d'utilisation abstrait et de haut niveau construit au-dessus du langage
d'expression SQL. On peut dire que ORM est une utilisation appliquée du langage d'expression.
Nous discuterons de l'API SQLAlchemy ORM et utiliserons la base de données SQLite dans
cette rubrique.
SQLAlchemy communique avec différents types de bases de données via leurs implémentations
DBAPI respectives en utilisant un système de dialectes. Tous les dialectes nécessitent
l'installation d'un pilote DBAPI approprié. Les dialectes pour les types de bases de données
suivants sont inclus -
 Firebird
 Microsoft SQL Server
 MySQL
 Oracle
 PostgreSQL
  SQLite
 Sybase

L'installation de SQLAlchemy est simple et directe, à l'aide de l'utilitaire pip.

pip install sqlalchemy

Pour vérifier si SQLalchemy est correctement installé et sa version, entrez la suite à l'invite
Python -

>>> import sqlalchemy

>>>sqlalchemy.__version__
'1.3.11'

Les interactions avec la base de données sont effectuées via l'objet Engine obtenu en tant que
valeur de retour de create_engine() fonction.

engine =create_engine('sqlite:///[Link]')

SQLite permet la création d'une base de données en mémoire. Le moteur SQLAlchemy pour la
base de données en mémoire est créé comme suit -

from sqlalchemy import create_engine

engine=create_engine('sqlite:///:memory:')

Si vous avez l'intention d'utiliser la base de données MySQL à la place, utilisez son module DB-
API - pymysql et le pilote de dialecte correspondant.
engine = create_engine('mysql+pymydsql://root@localhost/mydb')

Le create_engine a un argument d'écho facultatif. S'il est défini sur true, les requêtes SQL
générées par le moteur seront répercutées sur le terminal.
SQLAlchemy contient declarative baseclasse. Il agit comme un catalogue de classes de
modèles et de tables mappées.

from [Link] import declarative_base

base=declarative_base()

L'étape suivante consiste à définir une classe de modèle. Il doit être dérivé de base - object de la
classe declarative_base comme ci - dessus.
Ensemble __tablename__ propriété au nom de la table que vous souhaitez créer dans la base
de données. D'autres attributs correspondent aux champs. Chacun est un objet Column dans
SQLAlchemy et son type de données provient de l'une des listes ci-dessous -
 BigInteger
 Boolean
 Date
 DateTime
 Float
 Integer
 Numeric
 SmallInteger
 String
 Text
 Time
Le code suivant est la classe de modèle nommée Student qui est mappée à la table Students.

#[Link]
from [Link] import declarative_base
from sqlalchemy import Column, Integer, String, Numeric
base=declarative_base()
class Student(base):
__tablename__='Students'
StudentID=Column(Integer, primary_key=True)
name=Column(String)
age=Column(Integer)
marks=Column(Numeric)

Pour créer une table Elèves ayant une structure correspondante, exécutez la méthode create_all
() définie pour la classe de base.

[Link].create_all(engine)

Nous devons maintenant déclarer un objet de notre classe Student. Toutes les transactions de
base de données telles que l'ajout, la suppression ou la récupération de données de la base de
données, etc., sont gérées par un objet Session.
from [Link] import sessionmaker
Session = sessionmaker(bind=engine)
sessionobj = Session()

Les données stockées dans l'objet Student sont physiquement ajoutées dans la table sous-
jacente par la méthode add () de la session.

s1 = Student(name='Juhi', age=25, marks=200)

[Link](s1)
[Link]()

Voici le code complet pour ajouter un enregistrement dans la table des étudiants. Lors de son
exécution, le journal des instructions SQL correspondant s'affiche sur la console.

from sqlalchemy import Column, Integer, String

from sqlalchemy import create_engine
from myclasses import Student, base
engine = create_engine('sqlite:///[Link]', echo=True)
[Link].create_all(engine)

from [Link] import sessionmaker

Session = sessionmaker(bind=engine)
sessionobj = Session()
s1 = Student(name='Juhi', age=25, marks=200)
[Link](s1)
[Link]()

Sortie de la console
CREATE TABLE "Students" (
"StudentID" INTEGER NOT NULL,
name VARCHAR,
age INTEGER,
marks NUMERIC,
PRIMARY KEY ("StudentID")
)
INFO [Link] ()
INFO [Link] COMMIT
INFO [Link] BEGIN (implicit)
INFO [Link] INSERT INTO "Students" (name, age,
marks) VALUES (?, ?, ?)
INFO [Link] ('Juhi', 25, 200.0)
INFO [Link] COMMIT

le session object fournit également la méthode add_all () pour insérer plus d'un objet dans une
seule transaction.

sessionobj.add_all([s2,s3,s4,s5])
[Link]()

Maintenant que les enregistrements sont ajoutés dans la table, nous aimerions en extraire
comme le fait la requête SELECT. L'objet session a la méthode query () pour effectuer la tâche.
L'objet de requête est retourné par la méthode query () sur notre modèle Student.

qry=[Link](Student)

Utilisez la méthode get () de cet objet Query récupère l'objet correspondant à la clé primaire
donnée.

S1=[Link](1)

Pendant que cette instruction est exécutée, son instruction SQL correspondante renvoyée sur la
console sera la suivante -

BEGIN (implicit)
SELECT "Students"."StudentID" AS "Students_StudentID", "Students".name AS
"Students_name", "Students".age AS "Students_age",
"Students".marks AS "Students_marks"
FROM "Students"
WHERE "Products"."Students" = ?
[Link] (1,)

La méthode [Link] () renvoie une liste de tous les objets qui peuvent être parcourus à l'aide
d'une boucle.

from sqlalchemy import Column, Integer, String, Numeric

from sqlalchemy import create_engine
from myclasses import Student,base
engine = create_engine('sqlite:///[Link]', echo=True)
[Link].create_all(engine)
from [Link] import sessionmaker
Session = sessionmaker(bind=engine)
sessionobj = Session()
qry=[Link](Students)
rows=[Link]()
for row in rows:
print (row)

La mise à jour d'un enregistrement dans la table mappée est très simple. Tout ce que vous avez
à faire est de récupérer un enregistrement à l'aide de la méthode get (), d'attribuer une nouvelle
valeur à l'attribut souhaité, puis de valider les modifications à l'aide de l'objet session. Ci-
dessous, nous changeons les notes de l'étudiant Juhi à 100.

S1=[Link](1)
[Link]=100
[Link]()

La suppression d'un enregistrement est tout aussi simple, en supprimant l'objet souhaité de la
session.

S1=[Link](1)
[Link](S1)
[Link]()

Persistance des données Python - module

PyMongo
MongoDB est un document orienté NoSQLbase de données. Il s'agit d'une base de données
multiplateforme distribuée sous licence publique côté serveur. Il utilise des documents de type
JSON comme schéma.
Afin de fournir la capacité de stocker d'énormes données, plusieurs serveurs physiques (appelés
fragments) sont interconnectés, de sorte qu'une évolutivité horizontale est obtenue. La base de
données MongoDB est constituée de documents.
Un document est analogue à une ligne dans une table de base de données relationnelle.
Cependant, il n'a pas de schéma particulier. Le document est une collection de paires clé-valeur -
similaire au dictionnaire. Cependant, le nombre de paires kv dans chaque document peut varier.
Tout comme une table dans une base de données relationnelle a une clé primaire, le document
de la base de données MongoDB a une clé spéciale appelée"_id".
Avant de voir comment la base de données MongoDB est utilisée avec Python, comprenons
brièvement comment installer et démarrer MongoDB. La version communautaire et commerciale
de MongoDB est disponible. La version communautaire peut être téléchargée
sur [Link]/download-center/community .
En supposant que MongoDB est installé dans c: \ mongodb, le serveur peut être appelé à l'aide
de la commande suivante.

c:\mongodb\bin>mongod

Le serveur MongoDB est actif au numéro de port 22017 par défaut. Les bases de données sont
stockées dans le dossier data / bin par défaut, bien que l'emplacement puisse être modifié par
l'option –dbpath.
MongoDB a son propre ensemble de commandes à utiliser dans un shell MongoDB. Pour
appeler le shell, utilisezMongo commander.

x:\mongodb\bin>mongo

Une invite de shell similaire à l'invite de shell MySQL ou SQLite apparaît devant laquelle les
commandes NoSQL natives peuvent être exécutées. Cependant, nous sommes intéressés par la
connexion de la base de données MongoDB à Python.
PyMongoLe module a été développé par MongoDB Inc lui-même pour fournir une interface de
programmation Python. Utilisez l'utilitaire pip bien connu pour installer PyMongo.

pip3 install pymongo

En supposant que le serveur MongoDB est opérationnel (avec mongod commande) et écoute
sur le port 22017, nous devons d'abord déclarer un MongoClientobjet. Il contrôle toutes les
transactions entre la session Python et la base de données.

from pymongo import MongoClient

client=MongoClient()

Utilisez cet objet client pour établir la connexion avec le serveur MongoDB.

client = MongoClient('localhost', 27017)

Une nouvelle base de données est créée avec la commande suivante.

db=[Link]

La base de données MongoDB peut avoir de nombreuses collections, similaires aux tables d'une
base de données relationnelle. Un objet Collection est créé parCreate_collection() fonction.

db.create_collection('students')

Maintenant, nous pouvons ajouter un ou plusieurs documents dans la collection comme suit -
from pymongo import MongoClient
client=MongoClient()
db=[Link]
db.create_collection("students")
student=db['students']
studentlist=[{'studentID':1,'Name':'Juhi','age':20, 'marks'=100},
{'studentID':2,'Name':'dilip','age':20, 'marks'=110},
{'studentID':3,'Name':'jeevan','age':24, 'marks'=145}]
student.insert_many(studentlist)
[Link]()

Pour récupérer les documents (similaire à la requête SELECT), nous devons

utiliser find()méthode. Il renvoie un curseur à l'aide duquel tous les documents peuvent être
obtenus.

students=db['students']
docs=[Link]()
for doc in docs:
print (doc['Name'], doc['age'], doc['marks'] )

Pour trouver un document particulier au lieu de tous dans une collection, nous devons appliquer
un filtre à la méthode find (). Le filtre utilise des opérateurs logiques. MongoDB a son propre
ensemble d'opérateurs logiques comme ci-dessous -

Sr. Non Opérateur MongoDB et opérateur logique traditionnel

1 $eq
égal à (==)

2 $gt
supérieur à (>)

3 $gte
supérieur ou égal à (> =)

4 $in
si égal à n'importe quelle valeur du tableau

5 $lt
 moins de (<)

6 $lte
inférieur ou égal à (<=)

sept $ne
différent de (! =)

8 $nin
si ce n'est égal à aucune valeur du tableau

Par exemple, nous souhaitons obtenir la liste des étudiants de plus de 21 ans. Utilisation de
l'opérateur $ gt dans le filtre pourfind() méthode comme suit -

students=db['students']
docs=[Link]({'age':{'$gt':21}})
for doc in docs:
print ([Link]('Name'), [Link]('age'), [Link]('marks'))

Le module PyMongo fournit update_one() et update_many() méthodes pour modifier un ou

plusieurs documents satisfaisant à une expression de filtre spécifique.
Mettons à jour l'attribut des marques d'un document dont le nom est Juhi.

from pymongo import MongoClient

client=MongoClient()
db=[Link]
doc=[Link].find_one({'Name': 'Juhi'})
db['students'].update_one({'Name': 'Juhi'},{"$set":{'marks':150}})
[Link]()

Persistance des données Python - Pilote

Cassandra
Cassandra est une autre base de données NoSQL populaire. Évolutivité, cohérence et tolérance
aux pannes élevées - ce sont quelques-unes des caractéristiques importantes de Cassandra.
C'estColumn storebase de données. Les données sont stockées sur de nombreux serveurs de
base. En conséquence, les données sont hautement disponibles.
Cassandra est un produit de la fondation Apache Software. Les données sont stockées de
manière distribuée sur plusieurs nœuds. Chaque nœud est un serveur unique composé
d'espaces de clés. La pierre angulaire de la base de données Cassandra estkeyspace qui peut
être considéré comme analogue à une base de données.
Les données dans un nœud de Cassandra sont répliquées dans d'autres nœuds sur un réseau
de nœuds peer-to-peer. Cela fait de Cassandra une base de données infaillible. Le réseau
s'appelle un centre de données. Plusieurs centres de données peuvent être interconnectés pour
former un cluster. La nature de la réplication est configurée en définissant la stratégie de
réplication et le facteur de réplication au moment de la création d'un espace de clés.
Un espace de clés peut avoir plusieurs familles de colonnes - tout comme une base de données
peut contenir plusieurs tables. L'espace de clés de Cassandra n'a pas de schéma prédéfini. Il est
possible que chaque ligne d'une table Cassandra ait des colonnes avec des noms différents et
des nombres variables.

Le logiciel Cassandra est également disponible en deux versions: communauté et entreprise. La

dernière version entreprise de Cassandra est disponible en téléchargement
sur[Link] L'édition communautaire se trouve
sur[Link]
Cassandra a son propre langage de requête appelé Cassandra Query Language (CQL). Les
requêtes CQL peuvent être exécutées à partir d'un shell CQLASH - similaire au shell MySQL ou
SQLite. La syntaxe CQL ressemble à celle du SQL standard.
L'édition communautaire Datastax est également livrée avec un IDE Develcenter illustré dans la
figure suivante -
Le module Python pour travailler avec la base de données Cassandra est appelé Cassandra
Driver. Il est également développé par la fondation Apache. Ce module contient une API ORM,
ainsi qu'une API principale de même nature que DB-API pour les bases de données
relationnelles.
L'installation du pilote Cassandra se fait facilement en utilisant pip utility.

pip3 install cassandra-driver

L'interaction avec la base de données Cassandra se fait via l'objet Cluster. Le module
[Link] définit la classe de cluster. Nous devons d'abord déclarer l'objet Cluster.

from [Link] import Cluster

clstr=Cluster()

Toutes les transactions telles que l'insertion / la mise à jour, etc., sont effectuées en démarrant
une session avec un espace de clés.

session=[Link]()

Pour créer un nouvel espace de clés, utilisez execute()méthode de l'objet de session. La

méthode execute () prend un argument de chaîne qui doit être une chaîne de requête. Le CQL a
l'instruction CREATE KEYSPACE comme suit. Le code complet est comme ci-dessous -

from [Link] import Cluster

clstr=Cluster()
session=[Link]()
[Link](“create keyspace mykeyspace with replication={
'class': 'SimpleStrategy', 'replication_factor' : 3
};”

Ici, SimpleStrategy est une valeur pour replication strategy et replication factorest défini sur
3. Comme mentionné précédemment, un espace de clés contient une ou plusieurs tables.
Chaque table est caractérisée par son type de données. Les types de données Python sont
automatiquement analysés avec les types de données CQL correspondants conformément au
tableau suivant -

Type de Python Type CQL

Aucun NUL

Booléen Booléen

Flotte flotteur, double

int, long int, bigint, varint, smallint, tinyint, compteur

décimal.Décimal Décimal

str, Unicode ascii, varchar, texte

tampon, bytearray Goutte

Date Date

Datetime Horodatage

Temps Temps

liste, tuple, générateur liste

ensemble, frozenset Ensemble

dict, OrderedDict Carte

[Link] timeuuid, uuid

Pour créer une table, utilisez l'objet session pour exécuter une requête CQL pour créer une table.
from [Link] import Cluster
clstr=Cluster()
session=[Link]('mykeyspace')
qry= '''
create table students (
studentID int,
name text,
age int,
marks int,
primary key(studentID)
);'''
[Link](qry)

L'espace de clés ainsi créé peut être utilisé pour insérer des lignes. La version CQL de la requête
INSERT est similaire à l'instruction SQL Insert. Le code suivant insère une ligne dans la table des
étudiants.

from [Link] import Cluster

clstr=Cluster()
session=[Link]('mykeyspace')
[Link]("insert into students (studentID, name, age, marks) values
(1, 'Juhi',20, 200);"

Comme vous vous en doutez, l'instruction SELECT est également utilisée avec Cassandra. Dans
le cas de la méthode execute () contenant la chaîne de requête SELECT, elle retourne un objet
de jeu de résultats qui peut être parcouru à l'aide d'une boucle.

from [Link] import Cluster

clstr=Cluster()
session=[Link]('mykeyspace')
rows=[Link]("select * from students;")
for row in rows:
print (StudentID: {} Name:{} Age:{} price:{} Marks:{}'
.format(row[0],row[1], row[2], row[3]))

La requête SELECT de Cassandra prend en charge l'utilisation de la clause WHERE pour

appliquer un filtre sur l'ensemble de résultats à extraire. Les opérateurs logiques traditionnels tels
que <,> == etc. sont reconnus. Pour récupérer, uniquement les lignes de la table des étudiants
pour les noms d'âge> 20 ans, la chaîne de requête de la méthode execute () doit être la suivante
-
rows=[Link]("select * from students WHERE age>20 allow
filtering;")

Notez que l'utilisation de ALLOW FILTERING. La partie ALLOW FILTERING de cette instruction
permet d'autoriser explicitement (certaines) requêtes qui nécessitent un filtrage.
L'API du pilote Cassandra définit les classes suivantes de type Statement dans son module
[Link].

SimpleStatement
Une requête CQL simple et non préparée contenue dans une chaîne de requête. Tous les
exemples ci-dessus sont des exemples de SimpleStatement.

BatchStatement
Plusieurs requêtes (telles que INSERT, UPDATE et DELETE) sont placées dans un lot et
exécutées en même temps. Chaque ligne est d'abord convertie en SimpleStatement, puis
ajoutée dans un lot.
Mettons les lignes à ajouter dans la table Students sous la forme d'une liste de tuples comme suit
-

studentlist=[(1,'Juhi',20,100), ('2,'dilip',20, 110),(3,'jeevan',24,145)]

Pour ajouter les lignes ci-dessus à l'aide de BathStatement, exécutez le script suivant -

from [Link] import SimpleStatement, BatchStatement

batch=BatchStatement()
for student in studentlist:
[Link](SimpleStatement("INSERT INTO students
(studentID, name, age, marks) VALUES
(%s, %s, %s %s)"), (student[0], student[1],student[2], student[3]))
[Link](batch)

Affirmation préparée
L'instruction préparée est comme une requête paramétrée dans DB-API. Sa chaîne de requête
est enregistrée par Cassandra pour une utilisation ultérieure. La méthode [Link] ()
retourne une instance PreparedStatement.
Pour notre table des étudiants, une requête PreparedStatement for INSERT est la suivante -

stmt=[Link]("INSERT INTO students (studentID, name, age, marks)

VALUES (?,?,?)")

Par la suite, il suffit d'envoyer les valeurs des paramètres à lier. Par exemple -

qry=[Link]([1,'Ram', 23,175])
Enfin, exécutez l'instruction liée ci-dessus.

[Link](qry)

Cela réduit le trafic réseau et l'utilisation du processeur car Cassandra n'a pas à réanalyser la
requête à chaque fois.

Persistance des données - ZODB

ZODB (Zope object Database) est une base de données pour stocker des objets Python. Il est
compatible ACID - fonctionnalité introuvable dans les bases de données NOSQL. Le ZODB est
également open source, évolutif horizontalement et sans schéma, comme de nombreuses bases
de données NoSQL. Cependant, il n'est pas distribué et n'offre pas une réplication facile. Il fournit
un mécanisme de persistance pour les objets Python. Il fait partie du serveur d'applications Zope,
mais peut également être utilisé indépendamment.
ZODB a été créé par Jim Fulton de Zope Corporation. Il a commencé comme un simple système
d'objets persistants. Sa version actuelle est la 5.5.0 et est entièrement écrite en Python. en
utilisant une version étendue de la persistance d'objet intégrée de Python (pickle).
Certaines des principales fonctionnalités de ZODB sont:
 transactions
 history/undo
 stockage enfichable de manière transparente
 mise en cache intégrée
 contrôle de concurrence multiversion (MVCC)
 évolutivité sur un réseau
Le ZODB est un hierarchicalbase de données. Il existe un objet racine, initialisé lors de la
création d'une base de données. L'objet racine est utilisé comme un dictionnaire Python et il peut
contenir d'autres objets (qui peuvent eux-mêmes ressembler à un dictionnaire). Pour stocker un
objet dans la base de données, il suffit de l'attribuer à une nouvelle clé à l'intérieur de son
conteneur.
ZODB est utile pour les applications où les données sont hiérarchiques et où il y aura
probablement plus de lectures que d'écritures. ZODB est une extension de l'objet pickle. C'est
pourquoi il ne peut être traité que via un script Python.
Pour installer la dernière version de ZODB, utilisez l'utilitaire pip -

pip install zodb

Les dépendances suivantes sont également installées -

 BTrees==4.6.1
 cffi==1.13.2
 persistent==4.5.1
 pycparser==2.19
 six==1.13.0
 transaction==2.4.0
ZODB fournit les options de stockage suivantes -

FileStorage
C'est la valeur par défaut. Tout est stocké dans un seul fichier Big [Link], qui est
essentiellement un journal de transactions.
RépertoireStorage
Cela stocke un fichier par révision d'objet. Dans ce cas, il ne nécessite pas la reconstruction de
[Link] lors d'un arrêt impur.

RelStorage
Cela stocke les cornichons dans une base de données relationnelle. PostgreSQL, MySQL et
Oracle sont pris en charge.
Pour créer une base de données ZODB, nous avons besoin d'un stockage, d'une base de
données et enfin d'une connexion.
La première étape consiste à avoir un objet de stockage.

import ZODB, [Link]

storage = [Link]('[Link]')

La classe DB utilise cet objet de stockage pour obtenir un objet de base de données.

db = [Link](storage)

Passez None au constructeur DB pour créer une base de données en mémoire.

Db=[Link](None)

Enfin, nous établissons la connexion avec la base de données.

conn=[Link]()

L'objet de connexion vous donne alors accès à la 'racine' de la base de données avec la
méthode 'root ()'. L'objet «racine» est le dictionnaire qui contient tous vos objets persistants.

root = [Link]()

Par exemple, nous ajoutons une liste d'étudiants à l'objet racine comme suit -

root['students'] = ['Mary', 'Maya', 'Meet']

Cette modification n'est pas enregistrée de manière permanente dans la base de données tant
que nous ne validons pas la transaction.

import transaction
[Link]()

Pour stocker l'objet d'une classe définie par l'utilisateur, la classe doit être héritée de la classe
parente [Link].

Avantages du sous-classement
Sous-classer la classe persistante a ses avantages comme suit -
  La base de données suivra automatiquement les modifications apportées aux objets en
définissant des attributs.
 Les données seront enregistrées dans son propre enregistrement de base de données.
 Vous pouvez enregistrer des données qui ne sont pas sous-classe Persistent, mais elles
seront stockées dans l'enregistrement de base de données de tout objet persistant qui y
fait référence. Les objets non persistants appartiennent à leur objet persistant et si
plusieurs objets persistants font référence au même sous-objet non persistant, ils
obtiendront leurs propres copies.
Laissez utiliser définir une classe d'étudiant sous-classant la classe persistante comme sous -

import persistent
class student([Link]):
def __init__(self, name):
[Link] = name
def __repr__(self):
return str([Link])

Pour ajouter un objet de cette classe, commençons par configurer la connexion comme décrit ci-
dessus.

import ZODB, [Link]

storage = [Link]('[Link]')
db = [Link](storage)
conn=[Link]()
root = [Link]()

Déclarez un objet un ajout à la racine, puis validez la transaction

s1=student("Akash")
root['s1']=s1
import transaction
[Link]()
[Link]()

La liste de tous les objets ajoutés à la racine peut être récupérée en tant qu'objet de vue à l'aide
de la méthode items () car l'objet racine est similaire au dictionnaire intégré.

print ([Link]())
ItemsView({'s1': Akash})

Pour récupérer l'attribut d'un objet spécifique à partir de la racine,

print (root['s1'].name)
Akash
L'objet peut être facilement mis à jour. Étant donné que l'API ZODB est un package Python pur,
elle ne nécessite aucun langage de type SQL externe pour être utilisé.

root['s1'].name='Abhishek'
import transaction
[Link]()

La base de données sera mise à jour instantanément. Notez que la classe de transaction définit
également la fonction abort () qui est similaire au contrôle de transaction rollback () dans SQL.

Persistance des données - Module

Openpyxl
Microsoft Excel est l'application de feuille de calcul la plus populaire. Il est utilisé depuis plus de
25 ans. Les versions ultérieures d'Excel utilisentOffice Open XML (OOXML) format de fichier.
Par conséquent, il a été possible d'accéder aux fichiers de feuilles de calcul via d'autres
environnements de programmation.
OOXMLest un format de fichier standard ECMA. Pythonopenpyxl package fournit des
fonctionnalités pour lire / écrire des fichiers Excel avec l'extension .xlsx.
Le package openpyxl utilise une nomenclature de classe similaire à la terminologie Microsoft
Excel. Un document Excel est appelé comme classeur et est enregistré avec l'extension .xlsx
dans le système de fichiers. Un classeur peut avoir plusieurs feuilles de calcul. Une feuille de
calcul présente une grande grille de cellules, chacune d'elles pouvant stocker une valeur ou une
formule. Les lignes et les colonnes qui forment la grille sont numérotées. Les colonnes sont
identifiées par des alphabets, A, B, C,…., Z, AA, AB, etc. Les lignes sont numérotées à partir de
1.
Une feuille de calcul Excel typique apparaît comme suit -

L'utilitaire pip est assez bon pour installer le package openpyxl.

pip install openpyxl

La classe Workbook représente un classeur vide avec une feuille de calcul vierge. Nous devons
l'activer pour que certaines données puissent être ajoutées à la feuille de calcul.

from openpyxl import Workbook

wb=Workbook()
sheet1=[Link]
[Link]='StudentList'

Comme nous le savons, une cellule dans la feuille de calcul est nommée au format
ColumnNameRownumber. En conséquence, la cellule supérieure gauche est A1. Nous
attribuons une chaîne à cette cellule comme -

sheet1['A1']= 'Student List'

Sinon, utilisez la feuille de calcul cell()méthode qui utilise le numéro de ligne et de colonne pour
identifier une cellule. Appelez la propriété value à l'objet cellule pour attribuer une valeur.

cell1=[Link](row=1, column=1)
[Link]='Student List'

Après avoir rempli la feuille de calcul avec des données, le classeur est enregistré en appelant la
méthode save () de l'objet classeur.

[Link]('[Link]')

Ce fichier de classeur est créé dans le répertoire de travail actuel.

Le script Python suivant écrit une liste de tuples dans un document de classeur. Chaque tuple
stocke le numéro de rouleau, l'âge et les notes de l'élève.

from openpyxl import Workbook

wb = Workbook()
sheet1 = [Link]
[Link]='Student List'
[Link](column=1, row=1).value='Student List'
studentlist=[('RollNo','Name', 'age', 'marks'),(1,'Juhi',20,100),
(2,'dilip',20, 110) , (3,'jeevan',24,145)]
for col in range(1,5):
for row in range(1,5):
[Link](column=col, row=1+row).value=studentlist[row-1][col-1]
[Link]('[Link]')

Le classeur [Link] est enregistré dans le répertoire de travail actuel. S'il est ouvert à l'aide
de l'application Excel, il apparaît comme ci-dessous -
Le module openpyxl propose load_workbook() fonction qui aide à lire les données dans le
document de classeur.

from openpyxl import load_workbook

wb=load_workbook('[Link]')

Vous pouvez désormais accéder à la valeur de n'importe quelle cellule spécifiée par le numéro
de ligne et de colonne.

cell1=[Link](row=1, column=1)
print ([Link])
Student List

Exemple
Le code suivant remplit une liste avec des données de feuille de travail.

from openpyxl import load_workbook

wb=load_workbook('[Link]')
sheet1 = wb['Student List']
studentlist=[]
for row in range(1,5):
stud=[]
for col in range(1,5):
val=[Link](column=col, row=1+row).value
[Link](val)
[Link](tuple(stud))
print (studentlist)

Production
[('RollNo', 'Name', 'age', 'marks'), (1, 'Juhi', 20, 100), (2, 'dilip', 20,
110), (3, 'jeevan', 24, 145)]

Une caractéristique très importante de l'application Excel est la formule. Pour attribuer une
formule à une cellule, affectez-la à une chaîne contenant la syntaxe de formule d'Excel. Attribuez
la fonction MOYENNE à la cellule c6 ayant l'âge.

sheet1['C6']= 'AVERAGE(C3:C5)'

Le module Openpyxl a Translate_formula()pour copier la formule sur une plage. Le programme

suivant définit la fonction MOYENNE dans C6 et la copie dans C7 qui calcule la moyenne des
notes.

from openpyxl import load_workbook

wb=load_workbook('[Link]')

sheet1 = wb['Student List']

from [Link] import Translator#copy formula
sheet1['B6']='Average'
sheet1['C6']='=AVERAGE(C3:C5)'
sheet1['D6'] = Translator('=AVERAGE(C3:C5)',
origin="C6").translate_formula("D6")
[Link]('[Link]')

La feuille de calcul modifiée apparaît maintenant comme suit -