Python-Datenpersistenz - Kurzanleitung

Übersicht über Python - Datenpersistenz

Während der Verwendung einer Softwareanwendung stellt der Benutzer einige Daten zur Verfügung, die verarbeitet werden sollen. Die Daten können mit einem Standardeingabegerät (Tastatur) oder anderen Geräten wie Festplattendatei, Scanner, Kamera, Netzwerkkabel, WiFi-Verbindung usw. eingegeben werden.

Die so empfangenen Daten werden im Hauptspeicher (RAM) des Computers in Form verschiedener Datenstrukturen wie Variablen und Objekte gespeichert, bis die Anwendung ausgeführt wird. Danach werden Speicherinhalte aus dem RAM gelöscht.

Meistens ist es jedoch erwünscht, dass die Werte von Variablen und / oder Objekten so gespeichert werden, dass sie bei Bedarf abgerufen werden können, anstatt dieselben Daten erneut einzugeben.

Das Wort "Persistenz" bedeutet "das Fortbestehen einer Wirkung, nachdem ihre Ursache beseitigt wurde". Der Begriff Datenpersistenz bedeutet, dass er auch nach Beendigung der Anwendung weiterhin besteht. Somit sind Daten, die auf einem nichtflüchtigen Speichermedium wie einer Festplattendatei gespeichert sind, ein persistenter Datenspeicher.

In diesem Lernprogramm werden verschiedene integrierte Python-Module und Python-Module von Drittanbietern zum Speichern und Abrufen von Daten in / aus verschiedenen Formaten wie Textdateien, CSV-, JSON- und XML-Dateien sowie relationalen und nicht relationalen Datenbanken untersucht.

Mit dem in Python integrierten Dateiobjekt ist es möglich, Zeichenfolgendaten in eine Festplattendatei zu schreiben und daraus zu lesen. Die Standardbibliothek von Python bietet Module zum Speichern und Abrufen serialisierter Daten in verschiedenen Datenstrukturen wie JSON und XML.

Die DB-API von Python bietet eine Standardmethode für die Interaktion mit relationalen Datenbanken. Andere Python-Pakete von Drittanbietern bieten Schnittstellenfunktionen mit NOSQL-Datenbanken wie MongoDB und Cassandra.

In diesem Lernprogramm wird auch die ZODB-Datenbank vorgestellt, eine Persistenz-API für Python-Objekte. Das Microsoft Excel-Format ist ein sehr beliebtes Datendateiformat. In diesem Tutorial erfahren Sie, wie Sie mit der XLSX-Datei über Python umgehen.

Python verwendet integrierte Funktionen input() und print()Funktionen zum Ausführen von Standardeingabe- / Ausgabeoperationen. Die Funktion input () liest Bytes von einem Standard-Eingabestream-Gerät, dh einer Tastatur.

Das print()Funktion hingegen sendet die Daten an das Standardausgabestream-Gerät, dh den Anzeigemonitor. Das Python-Programm interagiert mit diesen E / A-Geräten über Standard-Stream-Objektestdin und stdout im sys-Modul definiert.

Das input()Die Funktion ist eigentlich ein Wrapper um die readline () -Methode des sys.stdin-Objekts. Alle Tastenanschläge vom Eingabestream werden empfangen, bis die Eingabetaste gedrückt wird.

>>> import sys
>>> x=sys.stdin.readline()
Welcome to TutorialsPoint
>>> x
'Welcome to TutorialsPoint\n'

Beachten Sie, dass, readline()Funktion hinterlässt ein nachfolgendes '\ n' Zeichen. Es gibt auch eine read () -Methode, die Daten aus dem Standardeingabestream liest, bis sie von beendet werdenCtrl+D Charakter.

>>> x=sys.stdin.read()
Hello
Welcome to TutorialsPoint
>>> x
'Hello\nWelcome to TutorialsPoint\n'

Ähnlich, print() ist eine Convenience-Funktion, die die write () -Methode eines stdout-Objekts emuliert.

>>> x='Welcome to TutorialsPoint\n'
>>> sys.stdout.write(x)
Welcome to TutorialsPoint
26

Genau wie stdin und stdout vordefinierte Stream-Objekte kann ein Python-Programm Daten aus einer Festplattendatei oder einem Netzwerk-Socket lesen und an diese senden. Sie sind auch Streams. Jedes Objekt mit der Methode read () ist ein Eingabestream. Jedes Objekt mit der Methode write () ist ein Ausgabestream. Die Kommunikation mit dem Stream wird hergestellt, indem eine Referenz auf das Stream-Objekt mit der integrierten Funktion open () abgerufen wird.

open () Funktion

Diese integrierte Funktion verwendet die folgenden Argumente:

f=open(name, mode, buffering)

Der Parameter name ist der Name der Datenträgerdatei oder der Byte-Zeichenfolge, der Modus ist eine optionale Zeichenfolge mit einem Zeichen, um die Art der auszuführenden Operation anzugeben (Lesen, Schreiben, Anhängen usw.), und der Pufferparameter ist entweder 0, 1 oder -1 Die Pufferung ist deaktiviert, aktiviert oder das System ist standardmäßig aktiviert.

Der Dateiöffnungsmodus wird gemäß der folgenden Tabelle aufgelistet. Der Standardmodus ist 'r'

Sr.Nr.	Parameter & Beschreibung
1	R Zum Lesen öffnen (Standard)
2	W Zum Schreiben öffnen und zuerst die Datei abschneiden
3	X Erstellen Sie eine neue Datei und öffnen Sie sie zum Schreiben
4	A Zum Schreiben öffnen und an das Ende der Datei anhängen, falls vorhanden
5	B Binärmodus
6	T Textmodus (Standard)
7	+ Öffnen Sie eine Datenträgerdatei zum Aktualisieren (Lesen und Schreiben).

Um Daten in einer Datei zu speichern, müssen sie im Modus 'w' geöffnet werden.

f=open('test.txt','w')

Dieses Dateiobjekt fungiert als Ausgabestream und hat Zugriff auf die write () -Methode. Die write () -Methode sendet eine Zeichenfolge an dieses Objekt und wird in der zugrunde liegenden Datei gespeichert.

string="Hello TutorialsPoint\n"
f.write(string)

Es ist wichtig, den Stream zu schließen, um sicherzustellen, dass alle im Puffer verbleibenden Daten vollständig an ihn übertragen werden.

file.close()

Versuchen Sie, 'test.txt' mit einem beliebigen Testeditor (z. B. Notepad) zu öffnen, um die erfolgreiche Erstellung der Datei zu bestätigen.

Um den Inhalt von 'test.txt' programmgesteuert lesen zu können, muss er im 'r'-Modus geöffnet werden.

f=open('test.txt','r')

Dieses Objekt verhält sich wie ein Eingabestream. Python kann mithilfe von Daten aus dem Stream abrufenread() Methode.

string=f.read()
print (string)

Der Inhalt der Datei wird auf der Python-Konsole angezeigt. Das File-Objekt unterstützt ebenfallsreadline() Methode, die in der Lage ist, Zeichenfolgen zu lesen, bis sie auf EOF-Zeichen stoßen.

Wenn jedoch dieselbe Datei im 'w'-Modus geöffnet wird, um zusätzlichen Text darin zu speichern, werden frühere Inhalte gelöscht. Immer wenn eine Datei mit Schreibberechtigung geöffnet wird, wird sie so behandelt, als wäre sie eine neue Datei. Verwenden Sie zum Hinzufügen von Daten zu einer vorhandenen Datei 'a' für den Anhänge-Modus.

f=open('test.txt','a')
f.write('Python Tutorials\n')

Die Datei hat jetzt sowohl frühere als auch neu hinzugefügte Zeichenfolgen. Das Dateiobjekt unterstützt auchwritelines() Methode zum Schreiben jeder Zeichenfolge in einem Listenobjekt in die Datei.

f=open('test.txt','a')
lines=['Java Tutorials\n', 'DBMS tutorials\n', 'Mobile development tutorials\n']
f.writelines(lines)
f.close()

Beispiel

Das readlines()Die Methode gibt eine Liste von Zeichenfolgen zurück, die jeweils eine Zeile in der Datei darstellen. Es ist auch möglich, die Datei zeilenweise zu lesen, bis das Dateiende erreicht ist.

f=open('test.txt','r')
while True:
   line=f.readline()
   if line=='' : break
   print (line, end='')
f.close()

Ausgabe

Hello TutorialsPoint
Python Tutorials
Java Tutorials
DBMS tutorials
Mobile development tutorials

Binärmodus

Standardmäßig werden Lese- / Schreibvorgänge für ein Dateiobjekt für Textzeichenfolgendaten ausgeführt. Wenn wir Dateien verschiedener anderer Typen wie Medien (mp3), ausführbare Dateien (exe), Bilder (jpg) usw. verarbeiten möchten, müssen wir dem Lese- / Schreibmodus das Präfix 'b' hinzufügen.

Die folgende Anweisung konvertiert eine Zeichenfolge in Bytes und schreibt in eine Datei.

f=open('test.bin', 'wb')
data=b"Hello World"
f.write(data)
f.close()

Die Konvertierung von Textzeichenfolgen in Bytes ist auch mit der Funktion encode () möglich.

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

Wir müssen verwenden ‘rb’Modus zum Lesen von Binärdateien. Der zurückgegebene Wert der read () -Methode wird vor dem Drucken zuerst dekodiert.

f=open('test.bin', 'rb')
data=f.read()
print (data.decode(encoding='utf-8'))

Um ganzzahlige Daten in eine Binärdatei zu schreiben, sollte das ganzzahlige Objekt von in Bytes konvertiert werden to_bytes() Methode.

n=25
n.to_bytes(8,'big')
f=open('test.bin', 'wb')
data=n.to_bytes(8,'big')
f.write(data)

Um aus einer Binärdatei zurückzulesen, konvertieren Sie die Ausgabe der Funktion read () mit der Funktion from_bytes () in eine Ganzzahl.

f=open('test.bin', 'rb')
data=f.read()
n=int.from_bytes(data, 'big')
print (n)

Für Gleitkommadaten müssen wir verwenden struct Modul aus der Standardbibliothek von Python.

import struct
x=23.50
data=struct.pack('f',x)
f=open('test.bin', 'wb')
f.write(data)

Entpacken der Zeichenfolge aus der Funktion read (), um die Float-Daten aus der Binärdatei abzurufen.

f=open('test.bin', 'rb')
data=f.read()
x=struct.unpack('f', data)
print (x)

Gleichzeitiges Lesen / Schreiben

Wenn eine Datei zum Schreiben geöffnet wird (mit 'w' oder 'a'), ist es nicht möglich, daraus zu lesen und umgekehrt. Dies führt zu einem UnSupportedOperation-Fehler. Wir müssen die Datei schließen, bevor wir eine andere Operation ausführen können.

Um beide Operationen gleichzeitig auszuführen, müssen wir dem mode-Parameter das Zeichen '+' hinzufügen. Daher ermöglicht der Modus 'w +' oder 'r +' die Verwendung von write () - und read () -Methoden, ohne eine Datei zu schließen. Das File-Objekt unterstützt auch die Funktion seek (), um den Stream auf eine beliebige Byteposition zurückzuspulen.

f=open('test.txt','w+')
f.write('Hello world')
f.seek(0,0)
data=f.read()
print (data)
f.close()

Die folgende Tabelle fasst alle Methoden zusammen, die für ein dateiähnliches Objekt verfügbar sind.

Sr.Nr.	Methode & Beschreibung
1	close() Schließt die Datei. Eine geschlossene Datei kann nicht mehr gelesen oder geschrieben werden.
2	flush() Spülen Sie den internen Puffer.
3	fileno() Gibt den Integer-Dateideskriptor zurück.
4	next() Gibt bei jedem Aufruf die nächste Zeile aus der Datei zurück. Verwenden Sie den nächsten () Iterator in Python 3.
5	read([size]) Liest höchstens Größenbytes aus der Datei (weniger, wenn der Lesevorgang EOF erreicht, bevor Größenbytes abgerufen werden).
6	readline([size]) Liest eine ganze Zeile aus der Datei. Ein nachfolgendes Zeilenumbruchzeichen wird in der Zeichenfolge beibehalten.
7	readlines([sizehint]) Liest bis EOF mit readline () und gibt eine Liste mit den Zeilen zurück.
8	seek(offset[, whence]) Legt die aktuelle Position der Datei fest. 0-Anfang 1-Strom 2-Ende.
9	seek(offset[, whence]) Legt die aktuelle Position der Datei fest. 0-Anfang 1-Strom 2-Ende.
10	tell() Gibt die aktuelle Position der Datei zurück
11	truncate([size]) Schneidet die Dateigröße ab.
12	write(str) Schreibt eine Zeichenfolge in die Datei. Es gibt keinen Rückgabewert.

Zusätzlich zum Dateiobjekt, das von zurückgegeben wird open()Funktion, Datei-E / A-Operationen können auch mit der in Python integrierten OS-Modul-Bibliothek ausgeführt werden, die nützliche betriebssystemabhängige Funktionen bietet. Diese Funktionen führen Lese- / Schreibvorgänge auf niedriger Ebene für Dateien aus.

Das open()Die Funktion des OS-Moduls ähnelt der integrierten Funktion open (). Es wird jedoch kein Dateiobjekt zurückgegeben, sondern ein Dateideskriptor, eine eindeutige Ganzzahl, die der geöffneten Datei entspricht. Die Werte 0, 1 und 2 des Dateideskriptors stehen für stdin-, stdout- und stderr-Streams. Andere Dateien erhalten ab 2 einen inkrementellen Dateideskriptor.

Wie im Fall von open() eingebaute Funktion, os.open()Die Funktion muss auch den Dateizugriffsmodus angeben. In der folgenden Tabelle sind verschiedene Modi aufgeführt, die im OS-Modul definiert sind.

Sr.Nr.	Os Modul & Beschreibung
1	os.O_RDONLY Nur zum Lesen geöffnet
2	os.O_WRONLY Nur zum Schreiben geöffnet
3	os.O_RDWR Offen zum Lesen und Schreiben
4	os.O_NONBLOCK Beim Öffnen nicht blockieren
5	os.O_APPEND Bei jedem Schreibvorgang anhängen
6	os.O_CREAT Datei erstellen, falls nicht vorhanden
7	os.O_TRUNC Größe auf 0 kürzen
8	os.O_EXCL Fehler, wenn create and file vorhanden ist

Geben Sie an, um eine neue Datei zum Schreiben von Daten zu öffnen O_WRONLY ebenso gut wie O_CREATModi durch Einfügen des Pipe-Operators (|). Die Funktion os.open () gibt einen Dateideskriptor zurück.

f=os.open("test.dat", os.O_WRONLY|os.O_CREAT)

Beachten Sie, dass Daten in Form einer Byte-Zeichenfolge in die Datenträgerdatei geschrieben werden. Daher wird eine normale Zeichenfolge mithilfe der Funktion encode () wie zuvor in eine Bytezeichenfolge konvertiert.

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

Die Funktion write () im OS-Modul akzeptiert diese Byte-Zeichenfolge und den Dateideskriptor.

os.write(f,data)

Vergessen Sie nicht, die Datei mit der Funktion close () zu schließen.

os.close(f)

Verwenden Sie die folgenden Anweisungen, um den Inhalt einer Datei mit der Funktion os.read () zu lesen:

f=os.open("test.dat", os.O_RDONLY)
data=os.read(f,20)
print (data.decode('utf-8'))

Beachten Sie, dass die Funktion os.read () den Dateideskriptor und die Anzahl der zu lesenden Bytes (Länge der Bytezeichenfolge) benötigt.

Wenn Sie eine Datei für gleichzeitige Lese- / Schreibvorgänge öffnen möchten, verwenden Sie den O_RDWR-Modus. Die folgende Tabelle zeigt wichtige Funktionen für den Dateibetrieb im OS-Modul.

Sr.Nr.	Funktionen & Beschreibung
1	os.close(fd) Schließen Sie den Dateideskriptor.
2	os.open(file, flags[, mode]) Öffnen Sie die Datei und setzen Sie verschiedene Flags entsprechend den Flags und möglicherweise den Modus entsprechend dem Modus.
3	os.read(fd, n) Lesen Sie höchstens n Bytes aus dem Dateideskriptor fd. Gibt eine Zeichenfolge zurück, die die gelesenen Bytes enthält. Wenn das Ende der Datei erreicht ist, auf die fd verweist, wird eine leere Zeichenfolge zurückgegeben.
4	os.write(fd, str) Schreiben Sie die Zeichenfolge str in den Dateideskriptor fd. Gibt die Anzahl der tatsächlich geschriebenen Bytes zurück.

Das in Python integrierte Dateiobjekt, das von der in Python integrierten open () -Funktion zurückgegeben wird, weist ein wichtiges Manko auf. Beim Öffnen im Modus 'w' akzeptiert die Methode write () nur das Zeichenfolgenobjekt.

Das heißt, wenn Sie Daten in einer Form ohne Zeichenfolge darstellen lassen, die entweder in integrierten Klassen (Zahlen, Wörterbuch, Listen oder Tupel) oder in anderen benutzerdefinierten Klassen enthalten sind, können sie nicht direkt in eine Datei geschrieben werden. Vor dem Schreiben müssen Sie es in seine Zeichenfolgendarstellung konvertieren.

numbers=[10,20,30,40]
   file=open('numbers.txt','w')
   file.write(str(numbers))
   file.close()

Für eine Binärdatei Argument zu write()Methode muss ein Byte-Objekt sein. Beispielsweise wird die Liste der Ganzzahlen von in Bytes konvertiertbytearray() Funktion und dann in die Datei geschrieben.

numbers=[10,20,30,40]
   data=bytearray(numbers)
   file.write(data)
   file.close()

Um Daten aus der Datei im jeweiligen Datentyp zurückzulesen, muss eine umgekehrte Konvertierung durchgeführt werden.

file=open('numbers.txt','rb')
   data=file.read()
   print (list(data))

Diese Art der manuellen Konvertierung eines Objekts in ein Zeichenfolgen- oder Byteformat (und umgekehrt) ist sehr umständlich und langwierig. Es ist möglich, den Status eines Python-Objekts in Form eines Byte-Streams direkt in einer Datei oder einem Speicher-Stream zu speichern und in den ursprünglichen Status abzurufen. Dieser Vorgang wird als Serialisierung und De-Serialisierung bezeichnet.

Die in Python integrierte Bibliothek enthält verschiedene Module für den Serialisierungs- und Deserialisierungsprozess.

Sr.Nr.	Name & Beschreibung
1	pickle Python-spezifische Serialisierungsbibliothek
2	marshal Bibliothek, die intern für die Serialisierung verwendet wird
3	shelve Pythonische Objektpersistenz
4	dbm Bibliothek mit Schnittstelle zur Unix-Datenbank
5	csv Bibliothek zum Speichern und Abrufen von Python-Daten im CSV-Format
6	json Bibliothek zur Serialisierung in das universelle JSON-Format

Pythons Terminologie für Serialisierung und Deserialisierung lautet Beizen bzw. Entpicken. Das Pickle-Modul in der Python-Bibliothek verwendet ein sehr Python-spezifisches Datenformat. Daher können Nicht-Python-Anwendungen eingelegte Daten möglicherweise nicht ordnungsgemäß deserialisieren. Es wird außerdem empfohlen, Daten nicht von nicht authentifizierten Quellen zu entfernen.

Die serialisierten (eingelegten) Daten können in einer Byte-Zeichenfolge oder einer Binärdatei gespeichert werden. Dieses Modul definiertdumps() und loads()Funktionen zum Be- und Entpicken von Daten mithilfe einer Byte-Zeichenfolge. Für dateibasierte Prozesse hat das Moduldump() und load() Funktion.

Pythons Pickle-Protokolle sind die Konventionen, die beim Erstellen und Dekonstruieren von Python-Objekten zu / von Binärdaten verwendet werden. Derzeit definiert das Pickle-Modul 5 verschiedene Protokolle, wie unten aufgeführt -

Sr.Nr.	Namen & Beschreibung
1	Protocol version 0 Ursprüngliches "lesbares" Protokoll, das abwärtskompatibel mit früheren Versionen ist.
2	Protocol version 1 Altes Binärformat auch kompatibel mit früheren Versionen von Python.
3	Protocol version 2 Die in Python 2.3 eingeführte Methode bietet ein effizientes Beizen von Klassen neuen Stils.
4	Protocol version 3 In Python 3.0 hinzugefügt. Empfohlen, wenn Kompatibilität mit anderen Python 3-Versionen erforderlich ist.
5	Protocol version 4 wurde in Python 3.4 hinzugefügt. Es bietet Unterstützung für sehr große Objekte

Beispiel

Das Pickle-Modul besteht aus der Funktion dumps (), die eine Zeichenfolgendarstellung von eingelegten Daten zurückgibt.

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

Ausgabe

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.

Beispiel

Verwenden Sie die Funktion load (), um die Zeichenfolge zu entfernen und das ursprüngliche Wörterbuchobjekt abzurufen.

from pickle import load
dct=loads(dctstring)
print (dct)

Ausgabe

{'name': 'Ravi', 'age': 23, 'Gender': 'M', 'marks': 75}

Eingelegte Objekte können mit der Funktion dump () auch dauerhaft in einer Datenträgerdatei gespeichert und mit der Funktion load () abgerufen werden.

import pickle
f=open("data.txt","wb")
dct={"name":"Ravi", "age":23, "Gender":"M","marks":75}
pickle.dump(dct,f)
f.close()

#to read
import pickle
f=open("data.txt","rb")
d=pickle.load(f)
print (d)
f.close()

Das Pickle-Modul bietet auch eine objektorientierte API für den Serialisierungsmechanismus in Form von Pickler und Unpickler Klassen.

Wie oben erwähnt, können Objekte benutzerdefinierter Klassen ebenso wie in Python integrierte Objekte dauerhaft in der Festplattendatei serialisiert werden. Im folgenden Programm definieren wir eine Benutzerklasse mit Namen und Handynummer als Instanzattribute. Zusätzlich zum Konstruktor __init __ () überschreibt die Klasse die Methode __str __ (), die eine Zeichenfolgendarstellung ihres Objekts zurückgibt.

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

Um ein Objekt der obigen Klasse in eine Datei aufzunehmen, verwenden wir die pickler-Klasse und ihre dump () -Methode.

from pickle import Pickler
user1=User('Rajani', '[email protected]', '1234567890')
file=open('userdata','wb')
Pickler(file).dump(user1)
Pickler(file).dump(user2)
file.close()

Umgekehrt verfügt die Unpickler-Klasse über die load () -Methode, um serialisierte Objekte wie folgt abzurufen:

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

Die Objektserialisierungsfunktionen des Marschallmoduls in der Python-Standardbibliothek ähneln denen des Pickle-Moduls. Dieses Modul wird jedoch nicht für allgemeine Daten verwendet. Andererseits wird es von Python selbst für die interne Objektserialisierung von Python verwendet, um Lese- / Schreibvorgänge für kompilierte Versionen von Python-Modulen (.pyc-Dateien) zu unterstützen.

Das vom Marshall-Modul verwendete Datenformat ist nicht für alle Python-Versionen kompatibel. Daher wird ein kompiliertes Python-Skript (.pyc-Datei) einer Version höchstwahrscheinlich nicht auf einer anderen ausgeführt.

Genau wie das Pickle-Modul definierte das Marschall-Modul auch die Funktionen load () und dump () zum Lesen und Schreiben von Marshall-Objekten aus / in eine Datei.

dump ()

Diese Funktion schreibt eine Byte-Darstellung des unterstützten Python-Objekts in eine Datei. Die Datei selbst ist eine Binärdatei mit Schreibberechtigung

Belastung()

Diese Funktion liest die Byte-Daten aus einer Binärdatei und konvertiert sie in ein Python-Objekt.

Das folgende Beispiel zeigt die Verwendung der Funktionen dump () und load () zum Behandeln von Codeobjekten von Python, die zum Speichern vorkompilierter Python-Module verwendet werden.

Der Code verwendet eingebaute compile() Funktion zum Erstellen eines Codeobjekts aus einer Quellzeichenfolge, in die Python-Anweisungen eingebettet sind.

compile(source, file, mode)

Der Dateiparameter sollte die Datei sein, aus der der Code gelesen wurde. Wenn es nicht aus einer Datei gelesen wurde, übergeben Sie eine beliebige Zeichenfolge.

Der mode-Parameter lautet 'exec', wenn die Quelle eine Folge von Anweisungen enthält, 'eval', wenn ein einzelner Ausdruck vorhanden ist, oder 'single', wenn er eine einzelne interaktive Anweisung enthält.

Das Kompilierungscodeobjekt wird dann mit der Funktion dump () in einer .pyc-Datei gespeichert.

import marshal
script = """
a=10
b=20
print ('addition=',a+b)
"""
code = compile(script, "script", "exec")
f=open("a.pyc","wb")
marshal.dump(code, f)
f.close()

Zum Deserialisieren verwendet das Objekt aus der .pyc-Datei die Funktion load (). Da es ein Codeobjekt zurückgibt, kann es mit exec () ausgeführt werden, einer weiteren integrierten Funktion.

import marshal
f=open("a.pyc","rb")
data=marshal.load(f)
exec (data)

Das Shelve-Modul in Pythons Standardbibliothek bietet einen einfachen, aber effektiven Objektpersistenzmechanismus. Das in diesem Modul definierte Regalobjekt ist ein wörterbuchähnliches Objekt, das dauerhaft in einer Festplattendatei gespeichert wird. Dadurch wird eine Datei erstellt, die der DBM-Datenbank unter UNIX-ähnlichen Systemen ähnelt.

Das Regalwörterbuch unterliegt bestimmten Einschränkungen. In diesem speziellen Wörterbuchobjekt kann nur der Zeichenfolgendatentyp als Schlüssel verwendet werden, während jedes auswählbare Python-Objekt als Wert verwendet werden kann.

Das Regalmodul definiert drei Klassen wie folgt:

Sr.Nr.	Regalmodul & Beschreibung
1	Shelf Dies ist die Basisklasse für Regalimplementierungen. Es wird mit einem diktartigen Objekt initialisiert.
2	BsdDbShelf Dies ist eine Unterklasse der Shelf-Klasse. Das an seinen Konstruktor übergebene dict-Objekt muss die Methoden first (), next (), previous (), last () und set_location () unterstützen.
3	DbfilenameShelf Dies ist ebenfalls eine Unterklasse von Shelf, akzeptiert jedoch einen Dateinamen als Parameter für den Konstruktor und nicht für das Diktierobjekt.

Die im Shelve-Modul definierte open () -Funktion, die a zurückgibt DbfilenameShelf Objekt.

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

Der Dateinamenparameter wird der erstellten Datenbank zugewiesen. Der Standardwert für den Flag-Parameter ist 'c' für den Lese- / Schreibzugriff. Andere Flags sind 'w' (nur Schreiben) 'r' (schreibgeschützt) und 'n' (neu mit Lesen / Schreiben).

Die Serialisierung selbst unterliegt dem Pickle-Protokoll, der Standardwert ist none. Der letzte Parameter zum Zurückschreiben von Parametern ist standardmäßig false. Bei true werden die aufgerufenen Einträge zwischengespeichert. Jeder Zugriff ruft die Operationen sync () und close () auf, daher kann der Prozess langsam sein.

Der folgende Code erstellt eine Datenbank und speichert Wörterbucheinträge darin.

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

Dadurch wird die Datei test.dir im aktuellen Verzeichnis erstellt und die Schlüsselwertdaten in Hash-Form gespeichert. Für das Shelf-Objekt stehen folgende Methoden zur Verfügung:

Sr.Nr.	Methoden & Beschreibung
1	close() Dauerhaftes Diktierobjekt synchronisieren und schließen.
2	sync() Schreiben Sie alle Einträge im Cache zurück, wenn das Regal mit dem Rückschreibwert True geöffnet wurde.
3	get() Gibt den mit dem Schlüssel verknüpften Wert zurück
4	items() Liste der Tupel - Jedes Tupel ist ein Schlüsselwertpaar
5	keys() Liste der Regalschlüssel
6	pop() Entfernen Sie den angegebenen Schlüssel und geben Sie den entsprechenden Wert zurück.
7	update() Aktualisieren Sie das Regal von einem anderen Diktat / Iterable
8	values() Liste der Regalwerte

Zugriff auf den Wert eines bestimmten Schlüssels im Regal -

s=shelve.open('test')
print (s['age']) #this will print 23
   s['age']=25
print (s.get('age')) #this will print 25
s.pop('marks') #this will remove corresponding k-v pair

Wie in einem integrierten Wörterbuchobjekt geben die Methoden items (), keys () und values () Ansichtsobjekte zurück.

print (list(s.items()))
[('name', 'Ajay'), ('age', 25), ('marks', 75)]  

print (list(s.keys()))
['name', 'age', 'marks']

print (list(s.values()))
['Ajay', 25, 75]

Verwenden Sie die update () -Methode, um Elemente eines anderen Wörterbuchs mit dem Regal zusammenzuführen.

d={'salary':10000, 'designation':'manager'}
s.update(d)
print (list(s.items()))

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

Das DBM-Paket enthält ein Wörterbuch wie Datenbanken im DBM-Stil. DBM stands for DataBase Manager. Dies wird vom UNIX-Betriebssystem (und UNIX-ähnlichen Betriebssystem) verwendet. Die DBBM-Bibliothek ist eine einfache Datenbank-Engine, die von Ken Thompson geschrieben wurde. Diese Datenbanken verwenden binär codierte Zeichenfolgenobjekte als Schlüssel sowie als Wert.

Die Datenbank speichert Daten unter Verwendung eines einzelnen Schlüssels (eines Primärschlüssels) in Buckets fester Größe und verwendet Hashing-Techniken, um ein schnelles Abrufen der Daten nach Schlüssel zu ermöglichen.

Das DBM-Paket enthält folgende Module:

dbm.gnu Das Modul ist eine Schnittstelle zur DBM-Bibliotheksversion, wie sie vom GNU-Projekt implementiert wird.
dbm.ndbm Das Modul bietet eine Schnittstelle zur Implementierung von UNIX nbdm.
dbm.dumbwird als Fallback-Option verwendet, falls andere DBM-Implementierungen nicht gefunden werden. Dies erfordert keine externen Abhängigkeiten, ist jedoch langsamer als andere.

>>> dbm.whichdb('mydbm.db')
'dbm.dumb'
>>> import dbm
>>> db=dbm.open('mydbm.db','n')
>>> db['name']=Raj Deshmane'
>>> db['address']='Kirtinagar Pune'
>>> db['PIN']='431101'
>>> db.close()

Die open () Funktion ermöglicht den Modus dieser Flags -

Sr.Nr.	Wert & Bedeutung
1	'r' Vorhandene Datenbank nur zum Lesen öffnen (Standard)
2	'w' Öffnen Sie die vorhandene Datenbank zum Lesen und Schreiben
3	'c' Öffnen Sie die Datenbank zum Lesen und Schreiben und erstellen Sie sie, falls sie nicht vorhanden ist
4	'n' Erstellen Sie immer eine neue, leere Datenbank, die zum Lesen und Schreiben geöffnet ist

Das DBM-Objekt ist ein wörterbuchähnliches Objekt, genau wie das Regalobjekt. Daher können alle Wörterbuchoperationen ausgeführt werden. Das DBM-Objekt kann die Methoden get (), pop (), append () und update () aufrufen. Der folgende Code öffnet 'mydbm.db' mit dem Flag 'r' und iteriert über die Sammlung von Schlüssel-Wert-Paaren.

>>> db=dbm.open('mydbm.db','r')
>>> for k,v in db.items():
   print (k,v)
b'name' : b'Raj Deshmane'
b'address' : b'Kirtinagar Pune'
b'PIN' : b'431101'

CSV stands for comma separated values. Dieses Dateiformat ist ein häufig verwendetes Datenformat beim Exportieren / Importieren von Daten in / aus Tabellenkalkulationen und Datentabellen in Datenbanken. Das CSV-Modul wurde als Ergebnis von PEP 305 in die Standardbibliothek von Python aufgenommen. Es enthält Klassen und Methoden zum Ausführen von Lese- / Schreibvorgängen für CSV-Dateien gemäß den Empfehlungen von PEP 305.

CSV ist ein bevorzugtes Exportdatenformat für die Excel-Tabellenkalkulationssoftware von Microsoft. Das CSV-Modul kann jedoch auch Daten verarbeiten, die von anderen Dialekten dargestellt werden.

Die CSV-API-Schnittstelle besteht aus folgenden Writer- und Reader-Klassen:

Schriftsteller()

Diese Funktion im CSV-Modul gibt ein Writer-Objekt zurück, das Daten in eine begrenzte Zeichenfolge konvertiert und in einem Dateiobjekt speichert. Die Funktion benötigt ein Dateiobjekt mit Schreibberechtigung als Parameter. Jede in die Datei geschriebene Zeile gibt ein Zeilenumbruchzeichen aus. Um zusätzlichen Abstand zwischen den Zeilen zu vermeiden, wird der Parameter newline auf '' gesetzt.

Die Writer-Klasse verfügt über folgende Methoden:

writerow ()

Diese Methode schreibt Elemente in eine Iterable (Liste, Tupel oder Zeichenfolge) und trennt sie durch Komma.

Schriftsteller ()

Diese Methode verwendet eine Liste von Iterables als Parameter und schreibt jedes Element als durch Kommas getrennte Zeile von Elementen in die Datei.

Example

Das folgende Beispiel zeigt die Verwendung der Funktion writer (). Zuerst wird eine Datei im 'w'-Modus geöffnet. Diese Datei wird verwendet, um das Writer-Objekt abzurufen. Jedes Tupel in der Liste der Tupel wird dann mit der writerow () -Methode in eine Datei geschrieben.

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

Output

Dadurch wird die Datei 'personen.csv' im aktuellen Verzeichnis erstellt. Es werden folgende Daten angezeigt.

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

Anstatt die Liste zu durchlaufen, um jede Zeile einzeln zu schreiben, können wir die Methode writerows () verwenden.

csvfile=open('persons.csv','w', newline='')
persons=[('Lata',22,45),('Anil',21,56),('John',20,60)]
   obj=csv.writer(csvfile)
   obj.writerows(persons)
   obj.close()

Leser()

Diese Funktion gibt ein Reader-Objekt zurück, das einen Iterator von Zeilen in der zurückgibt csv file. Bei Verwendung der regulären for-Schleife werden alle Zeilen in der Datei im folgenden Beispiel angezeigt:

Beispiel

csvfile=open('persons.csv','r', newline='')
   obj=csv.reader(csvfile)
   for row in obj:
      print (row)

Ausgabe

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

Das Leserobjekt ist ein Iterator. Daher unterstützt es die Funktion next (), mit der auch alle Zeilen in der CSV-Datei anstelle von a angezeigt werden könnenfor loop.

csvfile=open('persons.csv','r', newline='')
   obj=csv.reader(csvfile)
   while True:
   try:
      row=next(obj)
      print (row)
   except StopIteration:
      break

Wie bereits erwähnt, verwendet das CSV-Modul Excel als Standarddialekt. Das CSV-Modul definiert auch eine Dialektklasse. Dialekt ist eine Reihe von Standards, die zur Implementierung des CSV-Protokolls verwendet werden. Die Liste der verfügbaren Dialekte kann mit der Funktion list_dialects () abgerufen werden.

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

Zusätzlich zu iterables kann das CSV-Modul ein Wörterbuchobjekt in eine CSV-Datei exportieren und lesen, um das Python-Wörterbuchobjekt zu füllen. Zu diesem Zweck definiert dieses Modul folgende Klassen:

DictWriter ()

Diese Funktion gibt ein DictWriter-Objekt zurück. Es ähnelt dem Writer-Objekt, die Zeilen werden jedoch dem Dictionary-Objekt zugeordnet. Die Funktion benötigt ein Dateiobjekt mit Schreibberechtigung und eine Liste der Schlüssel, die im Wörterbuch als Feldnamenparameter verwendet werden. Dies wird verwendet, um die erste Zeile in die Datei als Header zu schreiben.

writeheader ()

Diese Methode schreibt die Liste der Schlüssel im Wörterbuch als durch Kommas getrennte Zeile als erste Zeile in die Datei.

Im folgenden Beispiel wird eine Liste von Wörterbuchelementen definiert. Jedes Element in der Liste ist ein Wörterbuch. Mit der Methode writrows () werden sie durch Kommas getrennt in eine Datei geschrieben.

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

Die Person.csv-Datei zeigt folgenden Inhalt:

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

DictReader ()

Diese Funktion gibt ein DictReader-Objekt aus der zugrunde liegenden CSV-Datei zurück. Wie im Fall eines Reader-Objekts ist dieses auch ein Iterator, mit dem der Inhalt der Datei abgerufen wird.

csvfile=open('persons.csv','r', newline='')
obj=csv.DictReader(csvfile)

Die Klasse stellt das Attribut fieldnames bereit und gibt die Wörterbuchschlüssel zurück, die als Header der Datei verwendet werden.

print (obj.fieldnames)
['name', 'age', 'marks']

Verwenden Sie eine Schleife über dem DictReader-Objekt, um einzelne Wörterbuchobjekte abzurufen.

for row in obj:
   print (row)

Dies führt zu folgender Ausgabe -

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

Um das OrderedDict-Objekt in ein normales Wörterbuch zu konvertieren, müssen wir zuerst OrderedDict aus dem Sammlungsmodul importieren.

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

JSON steht für JavaScript Object Notation. Es ist ein leichtes Datenaustauschformat. Es ist ein sprachunabhängiges und plattformübergreifendes Textformat, das von vielen Programmiersprachen unterstützt wird. Dieses Format wird für den Datenaustausch zwischen dem Webserver und den Clients verwendet.

Das JSON-Format ähnelt dem von pickle. Die Pickle-Serialisierung ist jedoch Python-spezifisch, während das JSON-Format in vielen Sprachen implementiert ist und daher zum universellen Standard geworden ist. Die Funktionalität und Schnittstelle des JSON-Moduls in der Python-Standardbibliothek ähnelt den Pickle- und Marshall-Modulen.

Genau wie beim Pickle-Modul bietet auch das JSON-Modul dumps() und loads() Funktion zur Serialisierung des Python-Objekts in eine JSON-codierte Zeichenfolge und dump() und load() Funktionen schreiben und lesen serialisierte Python-Objekte in / aus der Datei.

dumps() - Diese Funktion konvertiert das Objekt in das JSON-Format.
loads() - Diese Funktion konvertiert eine JSON-Zeichenfolge zurück in ein Python-Objekt.

Das folgende Beispiel zeigt die grundlegende Verwendung dieser Funktionen -

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

Die Funktion dumps () kann das optionale Argument sort_keys verwenden. Standardmäßig ist es False. Bei der Einstellung True werden die Wörterbuchschlüssel in der JSON-Zeichenfolge in sortierter Reihenfolge angezeigt.

Die Funktion dumps () verfügt über einen weiteren optionalen Parameter namens indent, der eine Zahl als Wert annimmt. Es entscheidet über die Länge jedes Segments der formatierten Darstellung der JSON-Zeichenfolge, ähnlich wie bei der Druckausgabe.

Das json-Modul verfügt auch über eine objektorientierte API, die den obigen Funktionen entspricht. Im Modul sind zwei Klassen definiert - JSONEncoder und JSONDecoder.

JSONEncoder-Klasse

Objekt dieser Klasse ist der Encoder für Python-Datenstrukturen. Jeder Python-Datentyp wird in den entsprechenden JSON-Typ konvertiert, wie in der folgenden Tabelle gezeigt -

Python	JSON
Dikt	Objekt
Liste, Tupel	Array
Str	Zeichenfolge
int, float, int- & float-abgeleitete Enums	Nummer
Wahr	wahr
Falsch	falsch
Keiner	Null

Die JSONEncoder-Klasse wird vom JSONEncoder () -Konstruktor instanziiert. Folgende wichtige Methoden sind in der Encoderklasse definiert -

Sr.Nr.	Methoden & Beschreibung
1	encode() serialisiert das Python-Objekt in das JSON-Format
2	iterencode() Codiert das Objekt und gibt einen Iterator zurück, der die codierte Form jedes Elements im Objekt liefert.
3	indent Bestimmt die Einrückungsstufe der codierten Zeichenfolge
4	sort_keys ist entweder wahr oder falsch, damit die Schlüssel in sortierter Reihenfolge angezeigt werden oder nicht.
5	Check_circular Wenn True, überprüfen Sie das Objekt vom Containertyp auf Zirkelverweise

Das folgende Beispiel codiert das Python-Listenobjekt.

e=json.JSONEncoder()
e.encode(data)

JSONDecoder-Klasse

Das Objekt dieser Klasse hilft beim Dekodieren in einem JSON-String zurück in die Python-Datenstruktur. Die Hauptmethode in dieser Klasse ist decode (). Der folgende Beispielcode ruft das Python-Listenobjekt aus der codierten Zeichenfolge in einem früheren Schritt ab.

d=json.JSONDecoder()
d.decode(s)

Das JSON-Modul definiert load() und dump() Funktionen zum Schreiben von JSON-Daten in eine Datei wie ein Objekt - dies kann eine Festplattendatei oder ein Bytestream sein und Daten von diesen zurücklesen.

dump ()

Diese Funktion schreibt JSONed Python-Objektdaten in eine Datei. Die Datei muss im Modus 'w' geöffnet werden.

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

Dieser Code erstellt 'json.txt' im aktuellen Verzeichnis. Es zeigt den Inhalt wie folgt -

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

Belastung()

Diese Funktion lädt JSON-Daten aus der Datei und gibt das Python-Objekt daraus zurück. Die Datei muss mit Leseberechtigung geöffnet werden (sollte den 'r'-Modus haben).

Example

fp=open('json.txt','r')
   ret=json.load(fp)
   print (ret)
   fp.close()

Output

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

Das json.tool Das Modul verfügt außerdem über eine Befehlszeilenschnittstelle, die Daten in Dateien überprüft und JSON-Objekte auf ziemlich formatierte Weise druckt.

C:\python37>python -m json.tool json.txt
[
   "Rakesh",   
   {
      "marks": [
         50,
         60,
         70
      ]
   }
]

XML ist die Abkürzung für eXtensible Markup Language. Es ist eine tragbare Open Source- und plattformübergreifende Sprache, die HTML oder SGML sehr ähnlich ist und vom World Wide Web Consortium empfohlen wird.

Es ist ein bekanntes Datenaustauschformat, das von einer Vielzahl von Anwendungen wie Webdiensten, Office-Tools und verwendet wird Service Oriented Architectures(SOA). Das XML-Format ist sowohl maschinenlesbar als auch für Menschen lesbar.

Das XML-Paket der Standard-Python-Bibliothek besteht aus folgenden Modulen für die XML-Verarbeitung:

Sr.Nr.	Module & Beschreibung
1	xml.etree.ElementTree die ElementTree API, ein einfacher und leichter XML-Prozessor
2	xml.dom die DOM-API-Definition
3	xml.dom.minidom eine minimale DOM-Implementierung
4	xml.sax Implementierung der SAX2-Schnittstelle
5	xml.parsers.expat die Expat-Parser-Bindung

Die Daten im XML-Dokument sind in einem baumartigen hierarchischen Format angeordnet, beginnend mit root und Elementen. Jedes Element ist ein einzelner Knoten im Baum und verfügt über ein Attribut, das in den Tags <> und </> eingeschlossen ist. Jedem Element können ein oder mehrere Unterelemente zugewiesen werden.

Das Folgende ist ein typisches Beispiel für ein XML-Dokument:

<?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>

Während dem Benutzen ElementTreeModul besteht der erste Schritt darin, das Stammelement des Baums einzurichten. Jedes Element hat ein Tag und ein Attribut, das ein Diktierobjekt ist. Für das Stammelement ist ein Attribut ein leeres Wörterbuch.

import xml.etree.ElementTree as xmlobj
root=xmlobj.Element('studentList')

Jetzt können wir ein oder mehrere Elemente unter dem Stammelement hinzufügen. Jedes Elementobjekt kann habenSubElements. Jedes Unterelement verfügt über ein Attribut und eine Texteigenschaft.

student=xmlobj.Element('student')
   nm=xmlobj.SubElement(student, 'name')
   nm.text='name'
   subject=xmlobj.SubElement(student, 'subject')
   nm.text='Ratna'
   subject.text='Physics'
   marks=xmlobj.SubElement(student, 'marks')
   marks.text='85'

Dieses neue Element wird mit der Methode append () an das Stammverzeichnis angehängt.

root.append(student)

Fügen Sie mit der obigen Methode so viele Elemente wie gewünscht hinzu. Schließlich wird das Stammelementobjekt in eine Datei geschrieben.

tree = xmlobj.ElementTree(root)
   file = open('studentlist.xml','wb')
   tree.write(file)
   file.close()

Jetzt sehen wir, wie die XML-Datei analysiert wird. Erstellen Sie dazu einen Dokumentbaum, der seinen Namen als Dateiparameter im ElementTree-Konstruktor angibt.

tree = xmlobj.ElementTree(file='studentlist.xml')

Das Baumobjekt hat getroot() Die Methode zum Abrufen des Stammelements und von getchildren () gibt eine Liste der darunter liegenden Elemente zurück.

root = tree.getroot()
children = root.getchildren()

Ein Wörterbuchobjekt, das jedem Unterelement entspricht, wird durch Iterieren über die Unterelementsammlung jedes untergeordneten Knotens konstruiert.

for child in children:
   student={}
   pairs = child.getchildren()
   for pair in pairs:
      product[pair.tag]=pair.text

Jedes Wörterbuch wird dann an eine Liste angehängt, die die ursprüngliche Liste der Wörterbuchobjekte zurückgibt.

SAXist eine Standardschnittstelle für ereignisgesteuertes XML-Parsing. Das Parsen von XML mit SAX erfordert ContentHandler durch Unterklasse von xml.sax.ContentHandler. Sie registrieren Rückrufe für Ereignisse von Interesse und lassen den Parser das Dokument durchgehen.

SAX ist nützlich, wenn Ihre Dokumente groß sind oder wenn Sie Speicherbeschränkungen haben, da die Datei beim Lesen von der Festplatte analysiert wird, sodass die gesamte Datei niemals im Speicher gespeichert wird.

Dokumentobjektmodell

(DOM) API ist eine Empfehlung des World Wide Web Consortium. In diesem Fall wird die gesamte Datei in den Speicher eingelesen und in einer hierarchischen (baumbasierten) Form gespeichert, um alle Funktionen eines XML-Dokuments darzustellen.

SAX, nicht so schnell wie DOM, mit großen Dateien. Andererseits kann DOM Ressourcen töten, wenn es für viele kleine Dateien verwendet wird. SAX ist schreibgeschützt, während DOM Änderungen an der XML-Datei zulässt.

Das Plist-Format wird hauptsächlich von MAC OS X verwendet. Diese Dateien sind im Grunde XML-Dokumente. Sie speichern und rufen Eigenschaften eines Objekts ab. Die Python-Bibliothek enthält das plist-Modul, das zum Lesen und Schreiben von 'Eigenschaftslisten'-Dateien verwendet wird (normalerweise haben sie die Erweiterung .plist').

Das plistlib Das Modul ist anderen Serialisierungsbibliotheken in dem Sinne mehr oder weniger ähnlich. Es bietet außerdem Funktionen dumps () und load () für die Zeichenfolgendarstellung von Python-Objekten sowie Funktionen load () und dump () für den Festplattenbetrieb.

Das folgende Wörterbuchobjekt behält die Eigenschaft (den Schlüssel) und den entsprechenden Wert bei -

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

Um diese Eigenschaften in eine Datenträgerdatei zu schreiben, rufen wir die Funktion dump () im Modul plist auf.

import plistlib
fileName=open('salary.plist','wb')
plistlib.dump(proplist, fileName)
fileName.close()

Um die Eigenschaftswerte zurückzulesen, verwenden Sie die Funktion load () wie folgt:

fp= open('salary.plist', 'rb')
pl = plistlib.load(fp)
print(pl)

Ein Hauptnachteil von CSV-, JSON-, XML- usw. Dateien besteht darin, dass sie für den Direktzugriff und die Transaktionsverarbeitung nicht sehr nützlich sind, da sie weitgehend unstrukturiert sind. Daher wird es sehr schwierig, den Inhalt zu ändern.

Diese Flatfiles sind nicht für Client-Server-Umgebungen geeignet, da sie nicht asynchron verarbeitet werden können. Die Verwendung unstrukturierter Datendateien führt zu Datenredundanz und Inkonsistenz.

Diese Probleme können mithilfe einer relationalen Datenbank behoben werden. Eine Datenbank ist eine organisierte Sammlung von Daten, um Redundanz und Inkonsistenzen zu beseitigen und die Datenintegrität aufrechtzuerhalten. Das relationale Datenbankmodell ist sehr beliebt.

Das Grundkonzept besteht darin, Daten in einer Entitätstabelle anzuordnen (Relation genannt). Die Entitätstabellenstruktur stellt ein Attribut bereit, dessen Wert für jede Zeile eindeutig ist. Ein solches Attribut heißt'primary key'.

Wenn der Primärschlüssel einer Tabelle in der Struktur anderer Tabellen angezeigt wird, wird er aufgerufen 'Foreign key'und dies bildet die Grundlage für die Beziehung zwischen den beiden. Basierend auf diesem Modell sind derzeit viele beliebte RDBMS-Produkte erhältlich -

GadFly
mSQL
MySQL
PostgreSQL
Microsoft SQL Server 2000
Informix
Interbase
Oracle
Sybase
SQLite

SQLite ist eine einfache relationale Datenbank, die in einer Vielzahl von Anwendungen verwendet wird. Es ist ein in sich geschlossenes, serverloses, transaktionsfreies SQL-Datenbankmodul ohne Konfiguration. Die gesamte Datenbank ist eine einzelne Datei, die an einer beliebigen Stelle im Dateisystem abgelegt werden kann. Es ist eine Open-Source-Software mit sehr geringem Platzbedarf und ohne Konfiguration. Es wird häufig in eingebetteten Geräten, IOT und mobilen Apps verwendet.

Alle relationalen Datenbanken verwenden SQL für die Verarbeitung von Daten in Tabellen. Früher war jedoch jede dieser Datenbanken mit Hilfe des Python-Moduls, das für den Datenbanktyp spezifisch ist, mit der Python-Anwendung verbunden.

Daher bestand ein Mangel an Kompatibilität zwischen ihnen. Wenn ein Benutzer zu einem anderen Datenbankprodukt wechseln möchte, ist dies schwierig. Dieses Inkompatibilitätsproblem wurde behoben, indem "Python Enhancement Proposal (PEP 248)" ausgelöst wurde, um eine konsistente Schnittstelle zu relationalen Datenbanken zu empfehlen, die als DB-API bezeichnet werden. Neueste Empfehlungen werden aufgerufenDB-APIVersion 2.0. (PEP 249)

Die Standardbibliothek von Python besteht aus dem sqlite3-Modul, einem DB-API-kompatiblen Modul für die Verwaltung der SQLite-Datenbank über das Python-Programm. In diesem Kapitel wird die Konnektivität von Python mit der SQLite-Datenbank erläutert.

Wie bereits erwähnt, unterstützt Python die SQLite-Datenbank in Form eines sqlite3-Moduls. Für andere Datenbanken muss das entsprechende DB-API-kompatible Python-Modul mit Hilfe des Pip-Dienstprogramms installiert werden. Um beispielsweise die MySQL-Datenbank zu verwenden, müssen wir das PyMySQL-Modul installieren.

pip install pymysql

Die folgenden Schritte werden in der DB-API empfohlen:

Stellen Sie mithilfe von eine Verbindung zur Datenbank her connect() Funktion und Verbindungsobjekt erhalten.
Anruf cursor() Methode des Verbindungsobjekts, um das Cursorobjekt abzurufen.
Bilden Sie eine Abfragezeichenfolge, die aus einer auszuführenden SQL-Anweisung besteht.
Führen Sie die gewünschte Abfrage durch Aufrufen aus execute() Methode.
Schließen Sie die Verbindung.

import sqlite3
db=sqlite3.connect('test.db')

Hier ist db das Verbindungsobjekt, das test.db darstellt. Beachten Sie, dass diese Datenbank erstellt wird, wenn sie noch nicht vorhanden ist. Das Verbindungsobjekt db verfügt über folgende Methoden:

Sr.Nr.	Methoden & Beschreibung
1	cursor(): Gibt ein Cursor-Objekt zurück, das diese Verbindung verwendet.
2	commit(): Übernimmt alle ausstehenden Transaktionen explizit in die Datenbank.
3	rollback(): Diese optionale Methode bewirkt, dass eine Transaktion zum Startpunkt zurückgesetzt wird.
4	close(): Schließt die Verbindung zur Datenbank dauerhaft.

Ein Cursor fungiert als Handle für eine bestimmte SQL-Abfrage, mit der eine oder mehrere Zeilen des Ergebnisses abgerufen werden können. Das Cursorobjekt wird von der Verbindung abgerufen, um SQL-Abfragen mit der folgenden Anweisung auszuführen:

cur=db.cursor()

Für das Cursorobjekt sind folgende Methoden definiert:

Sr.Nr.	Methoden & Beschreibung
1	execute() Führt die SQL-Abfrage in einem Zeichenfolgenparameter aus.
2	executemany() Führt die SQL-Abfrage mithilfe einer Reihe von Parametern in der Liste der Tupel aus.
3	fetchone() Ruft die nächste Zeile aus der Abfrageergebnismenge ab.
4	fetchall() Ruft alle verbleibenden Zeilen aus der Abfrageergebnismenge ab.
5	callproc() Ruft eine gespeicherte Prozedur auf.
6	close() Schließt das Cursorobjekt.

Der folgende Code erstellt eine Tabelle in test.db: -

import sqlite3
db=sqlite3.connect('test.db')
cur =db.cursor()
cur.execute('''CREATE TABLE student (
StudentID INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT (20) NOT NULL,
age INTEGER,
marks REAL);''')
print ('table created successfully')
db.close()

Die in einer Datenbank gewünschte Datenintegrität wird erreicht durch commit() und rollback()Methoden des Verbindungsobjekts. Die SQL-Abfragezeichenfolge enthält möglicherweise eine falsche SQL-Abfrage, die eine Ausnahme auslösen kann, die ordnungsgemäß behandelt werden sollte. Zu diesem Zweck wird die Anweisung execute () in den try-Block eingefügt. Wenn dies erfolgreich ist, wird das Ergebnis mit der Methode commit () dauerhaft gespeichert. Wenn die Abfrage fehlschlägt, wird die Transaktion mit der rollback () -Methode rückgängig gemacht.

Der folgende Code führt die INSERT-Abfrage für die Schülertabelle in test.db aus.

import sqlite3
db=sqlite3.connect('test.db')
qry="insert into student (name, age, marks) values('Abbas', 20, 80);"
try:
   cur=db.cursor()
   cur.execute(qry)
   db.commit()
print ("record added successfully")
except:
   print ("error in query")
   db.rollback()
db.close()

Wenn Sie möchten, dass Daten in der Werteklausel der INSERT-Abfrage dynamisch durch Benutzereingaben bereitgestellt werden, verwenden Sie die in Python DB-API empfohlene Parametersubstitution. Das ? Das Zeichen wird als Platzhalter in der Abfragezeichenfolge verwendet und stellt die Werte in Form eines Tupels in der Methode execute () bereit. Im folgenden Beispiel wird ein Datensatz mithilfe der Parametersubstitutionsmethode eingefügt. Name, Alter und Noten werden als Eingabe verwendet.

import sqlite3
db=sqlite3.connect('test.db')
nm=input('enter name')
a=int(input('enter age'))
m=int(input('enter marks'))
qry="insert into student (name, age, marks) values(?,?,?);"
try:
   cur=db.cursor()
   cur.execute(qry, (nm,a,m))
   db.commit()
   print ("one record added successfully")
except:
   print("error in operation")
   db.rollback()
db.close()

Das sqlite3-Modul definiert The executemany()Methode, mit der mehrere Datensätze gleichzeitig hinzugefügt werden können. Die hinzuzufügenden Daten sollten in einer Liste von Tupeln angegeben werden, wobei jedes Tupel einen Datensatz enthält. Das Listenobjekt ist zusammen mit der Abfragezeichenfolge der Parameter der Methode executeemany (). Die Methode execememany () wird jedoch von einigen anderen Modulen nicht unterstützt.

Das UPDATEDie Abfrage enthält normalerweise einen logischen Ausdruck, der durch die WHERE-Klausel angegeben wird. Die Abfragezeichenfolge in der Methode execute () sollte eine UPDATE-Abfragesyntax enthalten. Um den Wert von 'age' für name = 'Anil' auf 23 zu aktualisieren, definieren Sie die Zeichenfolge wie folgt:

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

Um den Aktualisierungsprozess dynamischer zu gestalten, verwenden wir die oben beschriebene Parametersubstitutionsmethode.

import sqlite3
db=sqlite3.connect('test.db')
nm=input(‘enter name’)
a=int(input(‘enter age’))
qry="update student set age=? where name=?;"
try:
   cur=db.cursor()
   cur.execute(qry, (a, nm))
   db.commit()
   print("record updated successfully")
except:
   print("error in query")
   db.rollback()
db.close()

In ähnlicher Weise wird die DELETE-Operation ausgeführt, indem die Methode execute () mit einer Zeichenfolge mit der DELETE-Abfragesyntax von SQL aufgerufen wird. Übrigens,DELETE Abfrage enthält normalerweise auch eine WHERE Klausel.

import sqlite3
db=sqlite3.connect('test.db')
nm=input(‘enter name’)
qry="DELETE from student where name=?;"
try:
   cur=db.cursor()
   cur.execute(qry, (nm,))
   db.commit()
   print("record deleted successfully")
except:
   print("error in operation")
   db.rollback()
db.close()

Eine der wichtigen Operationen in einer Datenbanktabelle ist das Abrufen von Datensätzen daraus. SQL bietetSELECTAbfrage für den Zweck. Wenn für die Methode execute () eine Zeichenfolge mit der SELECT-Abfragesyntax angegeben wird, wird ein Ergebnismengenobjekt zurückgegeben. Es gibt zwei wichtige Methoden mit einem Cursorobjekt, mit denen ein oder mehrere Datensätze aus der Ergebnismenge abgerufen werden können.

fetchone ()

Ruft den nächsten verfügbaren Datensatz aus der Ergebnismenge ab. Es ist ein Tupel, das aus Werten jeder Spalte des abgerufenen Datensatzes besteht.

fetchall ()

Ruft alle verbleibenden Datensätze in Form einer Liste von Tupeln ab. Jedes Tupel entspricht einem Datensatz und enthält Werte für jede Spalte in der Tabelle.

Das folgende Beispiel listet alle Datensätze in der Schülertabelle auf

import sqlite3
db=sqlite3.connect('test.db')
37
sql="SELECT * from student;"
cur=db.cursor()
cur.execute(sql)
while True:
   record=cur.fetchone()
   if record==None:
      break
   print (record)
db.close()

Wenn Sie eine MySQL-Datenbank anstelle einer SQLite-Datenbank verwenden möchten, müssen Sie diese installieren PyMySQLModul wie oben beschrieben. Da alle Schritte im Datenbankkonnektivitätsprozess gleich sind, benötigt die Funktion connect () die URL und die Anmeldeinformationen, da die MySQL-Datenbank auf einem Server installiert ist.

import pymysql
con=pymysql.connect('localhost', 'root', '***')

Bei SQLite können sich nur MySQL-spezifische Datentypen unterscheiden. Ebenso kann jede ODBC-kompatible Datenbank mit Python verwendet werden, indem das pyodbc-Modul installiert wird.

Jede relationale Datenbank enthält Daten in Tabellen. Die Tabellenstruktur definiert den Datentyp von Attributen, bei denen es sich im Wesentlichen nur um primäre Datentypen handelt, die den entsprechenden integrierten Python-Datentypen zugeordnet sind. Die benutzerdefinierten Objekte von Python können jedoch nicht dauerhaft gespeichert und in / aus SQL-Tabellen abgerufen werden.

Dies ist eine Ungleichheit zwischen SQL-Typen und objektorientierten Programmiersprachen wie Python. SQL hat keinen äquivalenten Datentyp für andere wie Diktat, Tupel, Liste oder eine benutzerdefinierte Klasse.

Wenn Sie ein Objekt in einer relationalen Datenbank speichern müssen, sollten seine Instanzattribute zuerst in SQL-Datentypen dekonstruiert werden, bevor die INSERT-Abfrage ausgeführt wird. Auf der anderen Seite handelt es sich bei Daten, die aus einer SQL-Tabelle abgerufen werden, um Primärtypen. Ein Python-Objekt des gewünschten Typs muss mithilfe von Python erstellt werden. Hier sind Object Relational Mappers nützlich.

Object Relation Mapper (ORM)

Ein Object Relation Mapper(ORM) ist eine Schnittstelle zwischen einer Klasse und einer SQL-Tabelle. Eine Python-Klasse wird einer bestimmten Tabelle in der Datenbank zugeordnet, sodass die Konvertierung zwischen Objekt- und SQL-Typen automatisch durchgeführt wird.

Die in Python-Code geschriebene Students-Klasse wird der Students-Tabelle in der Datenbank zugeordnet. Infolgedessen werden alle CRUD-Operationen durch Aufrufen der jeweiligen Methoden der Klasse ausgeführt. Dadurch müssen keine fest codierten SQL-Abfragen im Python-Skript ausgeführt werden.

Die ORM-Bibliothek fungiert somit als Abstraktionsschicht über den unformatierten SQL-Abfragen und kann bei der schnellen Anwendungsentwicklung hilfreich sein. SQLAlchemyist ein beliebter objektrelationaler Mapper für Python. Jede Manipulation des Status des Modellobjekts wird mit der zugehörigen Zeile in der Datenbanktabelle synchronisiert.

SQLALchemy-Bibliothek enthält ORM API und SQL Expression Language (SQLAlchemy Core). Die Ausdruckssprache führt primitive Konstrukte der relationalen Datenbank direkt aus.

ORM ist ein übergeordnetes und abstrahiertes Verwendungsmuster, das auf der SQL Expression Language aufbaut. Es kann gesagt werden, dass ORM eine angewandte Verwendung der Ausdruckssprache ist. In diesem Thema werden wir die SQLAlchemy ORM-API diskutieren und die SQLite-Datenbank verwenden.

SQLAlchemy kommuniziert mit verschiedenen Arten von Datenbanken über ihre jeweiligen DBAPI-Implementierungen unter Verwendung eines Dialektsystems. Für alle Dialekte muss ein entsprechender DBAPI-Treiber installiert sein. Dialekte für folgende Arten von Datenbanken sind enthalten -

Firebird
Microsoft SQL Server
MySQL
Oracle
PostgreSQL
SQLite
Sybase

Die Installation von SQLAlchemy ist mithilfe des Pip-Dienstprogramms einfach und unkompliziert.

pip install sqlalchemy

Geben Sie an der Python-Eingabeaufforderung Folgendes ein, um zu überprüfen, ob SQLalchemy ordnungsgemäß installiert ist und welche Version es enthält:

>>> import sqlalchemy
>>>sqlalchemy.__version__
'1.3.11'

Interaktionen mit der Datenbank werden über das Engine-Objekt ausgeführt, das als Rückgabewert von erhalten wird create_engine() Funktion.

engine =create_engine('sqlite:///mydb.sqlite')

SQLite ermöglicht die Erstellung einer In-Memory-Datenbank. Die SQLAlchemy-Engine für die In-Memory-Datenbank wird wie folgt erstellt:

from sqlalchemy import create_engine
engine=create_engine('sqlite:///:memory:')

Wenn Sie stattdessen die MySQL-Datenbank verwenden möchten, verwenden Sie das DB-API-Modul - pymysql und den entsprechenden Dialekt-Treiber.

engine = create_engine('mysql+pymydsql://root@localhost/mydb')

Die create_engine verfügt über ein optionales Echo-Argument. Wenn true festgelegt ist, werden die von der Engine generierten SQL-Abfragen auf dem Terminal wiedergegeben.

SQLAlchemy enthält declarative baseKlasse. Es fungiert als Katalog von Modellklassen und zugeordneten Tabellen.

from sqlalchemy.ext.declarative import declarative_base
base=declarative_base()

Der nächste Schritt besteht darin, eine Modellklasse zu definieren. Es muss wie oben vom Basisobjekt der Klasse declative_base abgeleitet werden.

Einstellen __tablename__ Eigenschaft zum Namen der Tabelle, die in der Datenbank erstellt werden soll. Andere Attribute entsprechen den Feldern. Jedes ist ein Column-Objekt in SQLAlchemy und sein Datentyp stammt aus einer der folgenden Listen -

BigInteger
Boolean
Date
DateTime
Float
Integer
Numeric
SmallInteger
String
Text
Time

Der folgende Code ist die Modellklasse mit dem Namen Student, die der Studententabelle zugeordnet ist.

#myclasses.py
from sqlalchemy.ext.declarative 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)

Führen Sie die für die Basisklasse definierte Methode create_all () aus, um eine Schülertabelle mit einer entsprechenden Struktur zu erstellen.

base.metadata.create_all(engine)

Wir müssen jetzt ein Objekt unserer Schülerklasse deklarieren. Alle Datenbanktransaktionen wie das Hinzufügen, Löschen oder Abrufen von Daten aus der Datenbank usw. werden von einem Sitzungsobjekt verarbeitet.

from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)
sessionobj = Session()

Im Student-Objekt gespeicherte Daten werden mithilfe der add () -Methode der Sitzung physisch in die zugrunde liegende Tabelle eingefügt.

s1 = Student(name='Juhi', age=25, marks=200)
sessionobj.add(s1)
sessionobj.commit()

Hier ist der gesamte Code zum Hinzufügen eines Datensatzes zur Schülertabelle. Während der Ausführung wird das entsprechende SQL-Anweisungsprotokoll auf der Konsole angezeigt.

from sqlalchemy import Column, Integer, String
from sqlalchemy import create_engine
from myclasses import Student, base
engine = create_engine('sqlite:///college.db', echo=True)
base.metadata.create_all(engine)

from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)
sessionobj = Session()
s1 = Student(name='Juhi', age=25, marks=200)
sessionobj.add(s1)
sessionobj.commit()

Konsolenausgabe

CREATE TABLE "Students" (
   "StudentID" INTEGER NOT NULL,
   name VARCHAR,
   age INTEGER,
   marks NUMERIC,
   PRIMARY KEY ("StudentID")
)
INFO sqlalchemy.engine.base.Engine ()
INFO sqlalchemy.engine.base.Engine COMMIT
INFO sqlalchemy.engine.base.Engine BEGIN (implicit)
INFO sqlalchemy.engine.base.Engine INSERT INTO "Students" (name, age, marks) VALUES (?, ?, ?)
INFO sqlalchemy.engine.base.Engine ('Juhi', 25, 200.0)
INFO sqlalchemy.engine.base.Engine COMMIT

Das session object bietet auch die Methode add_all (), um mehr als ein Objekt in eine einzelne Transaktion einzufügen.

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

Nachdem nun Datensätze in die Tabelle aufgenommen wurden, möchten wir genau wie bei der SELECT-Abfrage daraus abrufen. Das Sitzungsobjekt verfügt über die query () -Methode, um die Aufgabe auszuführen. Das Abfrageobjekt wird von der query () -Methode in unserem Student-Modell zurückgegeben.

qry=seesionobj.query(Student)

Verwenden Sie die Methode get () dieses Abfrageobjekts, um ein Objekt abzurufen, das dem angegebenen Primärschlüssel entspricht.

S1=qry.get(1)

Während diese Anweisung ausgeführt wird, lautet die entsprechende SQL-Anweisung, die auf der Konsole wiedergegeben wird, wie folgt:

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" = ?
sqlalchemy.engine.base.Engine (1,)

Die query.all () -Methode gibt eine Liste aller Objekte zurück, die mit einer Schleife durchlaufen werden können.

from sqlalchemy import Column, Integer, String, Numeric
from sqlalchemy import create_engine
from myclasses import Student,base
engine = create_engine('sqlite:///college.db', echo=True)
base.metadata.create_all(engine)
from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)
sessionobj = Session()
qry=sessionobj.query(Students)
rows=qry.all()
for row in rows:
   print (row)

Das Aktualisieren eines Datensatzes in der zugeordneten Tabelle ist sehr einfach. Sie müssen lediglich einen Datensatz mit der Methode get () abrufen, dem gewünschten Attribut einen neuen Wert zuweisen und die Änderungen dann mit dem Sitzungsobjekt festschreiben. Unten ändern wir die Noten des Juhi-Schülers auf 100.

S1=qry.get(1)
S1.marks=100
sessionobj.commit()

Das Löschen eines Datensatzes ist ebenso einfach, indem das gewünschte Objekt aus der Sitzung gelöscht wird.

S1=qry.get(1)
Sessionobj.delete(S1)
sessionobj.commit()

MongoDB ist dokumentenorientiert NoSQLDatenbank. Es handelt sich um eine plattformübergreifende Datenbank, die unter einer serverseitigen öffentlichen Lizenz vertrieben wird. Es verwendet JSON-ähnliche Dokumente als Schema.

Um die Speicherung großer Datenmengen zu ermöglichen, sind mehrere physische Server (Shards genannt) miteinander verbunden, sodass eine horizontale Skalierbarkeit erreicht wird. Die MongoDB-Datenbank besteht aus Dokumenten.

Ein Dokument ist analog zu einer Zeile in einer Tabelle einer relationalen Datenbank. Es gibt jedoch kein bestimmtes Schema. Dokument ist eine Sammlung von Schlüssel-Wert-Paaren - ähnlich wie Wörterbuch. Die Anzahl der kv-Paare in jedem Dokument kann jedoch variieren. So wie eine Tabelle in der relationalen Datenbank einen Primärschlüssel hat, hat das Dokument in der MongoDB-Datenbank einen speziellen Schlüssel namens"_id".

Bevor wir sehen, wie die MongoDB-Datenbank mit Python verwendet wird, wollen wir kurz verstehen, wie MongoDB installiert und gestartet wird. Community- und kommerzielle Version von MongoDB ist verfügbar. Die Community-Version kann von www.mongodb.com/download-center/community heruntergeladen werden .

Angenommen, MongoDB ist in c: \ mongodb installiert, kann der Server mit dem folgenden Befehl aufgerufen werden.

c:\mongodb\bin>mongod

Der MongoDB-Server ist standardmäßig unter Portnummer 22017 aktiv. Datenbanken werden standardmäßig im Ordner data / bin gespeichert, obwohl der Speicherort mit der Option –dbpath geändert werden kann.

MongoDB verfügt über einen eigenen Befehlssatz, der in einer MongoDB-Shell verwendet werden kann. Verwenden Sie zum Aufrufen der ShellMongo Befehl.

x:\mongodb\bin>mongo

Es wird eine Shell-Eingabeaufforderung ähnlich der MySQL- oder SQLite-Shell-Eingabeaufforderung angezeigt, vor der native NoSQL-Befehle ausgeführt werden können. Wir sind jedoch daran interessiert, die MongoDB-Datenbank mit Python zu verbinden.

PyMongoDas Modul wurde von MongoDB Inc selbst entwickelt, um eine Python-Programmierschnittstelle bereitzustellen. Verwenden Sie das bekannte Pip-Dienstprogramm, um PyMongo zu installieren.

pip3 install pymongo

Angenommen, der MongoDB-Server ist betriebsbereit (mit mongod Befehl) und lauscht an Port 22017, müssen wir zuerst a deklarieren MongoClientObjekt. Es steuert alle Transaktionen zwischen der Python-Sitzung und der Datenbank.

from pymongo import MongoClient
client=MongoClient()

Verwenden Sie dieses Clientobjekt, um eine Verbindung mit dem MongoDB-Server herzustellen.

client = MongoClient('localhost', 27017)

Mit dem folgenden Befehl wird eine neue Datenbank erstellt.

db=client.newdb

Die MongoDB-Datenbank kann viele Sammlungen enthalten, ähnlich wie Tabellen in einer relationalen Datenbank. Ein Sammlungsobjekt wird erstellt vonCreate_collection() Funktion.

db.create_collection('students')

Jetzt können wir ein oder mehrere Dokumente wie folgt zur Sammlung hinzufügen:

from pymongo import MongoClient
client=MongoClient()
db=client.newdb
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)
client.close()

Um die Dokumente abzurufen (ähnlich wie bei der SELECT-Abfrage), sollten wir verwenden find()Methode. Es gibt einen Cursor zurück, mit dessen Hilfe alle Dokumente abgerufen werden können.

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

Um ein bestimmtes Dokument anstelle aller Dokumente in einer Sammlung zu finden, müssen Sie die Methode filter to find () anwenden. Der Filter verwendet logische Operatoren. MongoDB hat seine eigenen logischen Operatoren wie folgt:

Sr.Nr.	MongoDB-Operator & traditioneller logischer Operator
1	$eq gleich (==)
2	$gt größer als (>)
3	$gte größer oder gleich (> =)
4	$in wenn gleich einem Wert im Array
5	$lt weniger als (<)
6	$lte kleiner oder gleich (<=)
7	$ne ungleich (! =)
8	$nin wenn nicht gleich einem Wert im Array

Zum Beispiel sind wir daran interessiert, eine Liste von Studenten zu erhalten, die älter als 21 Jahre sind. Verwenden des Operators $ gt im Filter fürfind() Methode wie folgt -

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

PyMongo-Modul bietet update_one() und update_many() Methoden zum Ändern eines Dokuments oder mehrerer Dokumente, die einen bestimmten Filterausdruck erfüllen.

Aktualisieren wir das Markenattribut eines Dokuments, dessen Name Juhi ist.

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

Cassandra ist eine weitere beliebte NoSQL-Datenbank. Hohe Skalierbarkeit, Konsistenz und Fehlertoleranz - dies sind einige der wichtigen Merkmale von Cassandra. Das istColumn storeDatenbank. Die Daten werden auf vielen Commodity-Servern gespeichert. Infolgedessen sind Daten hoch verfügbar.

Cassandra ist ein Produkt der Apache Software Foundation. Daten werden auf mehrere Knoten verteilt gespeichert. Jeder Knoten ist ein einzelner Server, der aus Schlüsselbereichen besteht. Grundlegender Baustein der Cassandra-Datenbank istkeyspace Dies kann als analog zu einer Datenbank angesehen werden.

Daten in einem Knoten von Cassandra werden in anderen Knoten über ein Peer-to-Peer-Netzwerk von Knoten repliziert. Das macht Cassandra zu einer narrensicheren Datenbank. Das Netzwerk wird als Rechenzentrum bezeichnet. Es können mehrere Rechenzentren miteinander verbunden werden, um einen Cluster zu bilden. Die Art der Replikation wird konfiguriert, indem die Replikationsstrategie und der Replikationsfaktor zum Zeitpunkt der Erstellung eines Schlüsselbereichs festgelegt werden.

Ein Schlüsselbereich kann mehr als eine Spaltenfamilie haben - genau wie eine Datenbank mehrere Tabellen enthalten kann. Cassandras Schlüsselraum hat kein vordefiniertes Schema. Es ist möglich, dass jede Zeile in einer Cassandra-Tabelle Spalten mit unterschiedlichen Namen und variablen Nummern enthält.

Die Cassandra-Software ist auch in zwei Versionen erhältlich: Community und Enterprise. Die neueste Unternehmensversion von Cassandra steht unter zum Download zur Verfügunghttps://cassandra.apache.org/download/. Community Edition finden Sie unterhttps://academy.datastax.com/planet-cassandra/cassandra.

Cassandra hat eine eigene Abfragesprache namens Cassandra Query Language (CQL). CQL-Abfragen können innerhalb einer CQLASH-Shell ausgeführt werden - ähnlich wie bei MySQL oder SQLite. Die CQL-Syntax ähnelt Standard-SQL.

Die Datastax Community Edition enthält außerdem eine Develcenter-IDE (siehe folgende Abbildung):

Das Python-Modul für die Arbeit mit der Cassandra-Datenbank wird aufgerufen Cassandra Driver. Es wird auch von der Apache Foundation entwickelt. Dieses Modul enthält eine ORM-API sowie eine Kern-API, die der DB-API für relationale Datenbanken ähnelt.

Die Installation des Cassandra-Treibers ist einfach pip utility.

pip3 install cassandra-driver

Die Interaktion mit der Cassandra-Datenbank erfolgt über das Cluster-Objekt. Das Modul Cassandra.cluster definiert die Clusterklasse. Wir müssen zuerst das Cluster-Objekt deklarieren.

from cassandra.cluster import Cluster
clstr=Cluster()

Alle Transaktionen wie Einfügen / Aktualisieren usw. werden ausgeführt, indem eine Sitzung mit einem Schlüsselbereich gestartet wird.

session=clstr.connect()

Verwenden Sie zum Erstellen eines neuen Schlüsselbereichs execute()Methode des Sitzungsobjekts. Die Methode execute () verwendet ein Zeichenfolgenargument, das eine Abfragezeichenfolge sein muss. Das CQL hat die Anweisung CREATE KEYSPACE wie folgt. Der vollständige Code lautet wie folgt:

from cassandra.cluster import Cluster
clstr=Cluster()
session=clstr.connect()
session.execute(“create keyspace mykeyspace with replication={
   'class': 'SimpleStrategy', 'replication_factor' : 3
};”

Hier, SimpleStrategy ist ein Wert für replication strategy und replication factorwird auf 3 gesetzt. Wie bereits erwähnt, enthält ein Schlüsselbereich eine oder mehrere Tabellen. Jede Tabelle ist durch ihren Datentyp gekennzeichnet. Python-Datentypen werden gemäß der folgenden Tabelle automatisch mit den entsprechenden CQL-Datentypen analysiert:

Python-Typ	CQL-Typ
Keiner	NULL
Bool	Boolescher Wert
Schweben	schweben, doppelt
int, lang	int, bigint, varint, smallint, tinyint, counter
dezimal.Dezimal	Dezimal
str, Unicode	ASCII, VARARAR, Text
Puffer, Bytearray	Klecks
Datum	Datum
Terminzeit	Zeitstempel
Zeit	Zeit
Liste, Tupel, Generator	Liste
Set, Frozenset	einstellen
diktieren, OrderedDict	Karte
uuid.UUID	timeuuid, uuid

Verwenden Sie zum Erstellen einer Tabelle das Sitzungsobjekt, um die CQL-Abfrage zum Erstellen einer Tabelle auszuführen.

from cassandra.cluster import Cluster
clstr=Cluster()
session=clstr.connect('mykeyspace')
qry= '''
create table students (
   studentID int,
   name text,
   age int,
   marks int,
   primary key(studentID)
);'''
session.execute(qry)

Der so erstellte Schlüsselraum kann weiter zum Einfügen von Zeilen verwendet werden. Die CQL-Version der INSERT-Abfrage ähnelt der SQL Insert-Anweisung. Der folgende Code fügt eine Zeile in die Schülertabelle ein.

from cassandra.cluster import Cluster
clstr=Cluster()
session=clstr.connect('mykeyspace')
session.execute("insert into students (studentID, name, age, marks) values 
   (1, 'Juhi',20, 200);"

Wie zu erwarten, wird die SELECT-Anweisung auch bei Cassandra verwendet. Bei der Methode execute (), die eine SELECT-Abfragezeichenfolge enthält, wird ein Ergebnismengenobjekt zurückgegeben, das mithilfe einer Schleife durchlaufen werden kann.

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

Die SELECT-Abfrage von Cassandra unterstützt die Verwendung der WHERE-Klausel, um Filter auf die abzurufende Ergebnismenge anzuwenden. Herkömmliche logische Operatoren wie <,> == usw. werden erkannt. Um nur die Zeilen aus der Schülertabelle für Namen mit einem Alter> 20 abzurufen, sollte die Abfragezeichenfolge in der Methode execute () wie folgt lauten:

rows=session.execute("select * from students WHERE age>20 allow filtering;")

Beachten Sie die Verwendung von ALLOW FILTERING. Der Teil ALLOW FILTERING dieser Anweisung ermöglicht das explizite Zulassen von (einigen) Abfragen, die gefiltert werden müssen.

Die Cassandra-Treiber-API definiert die folgenden Klassen des Anweisungstyps in ihrem Modul cassendra.query.

SimpleStatement

Eine einfache, unvorbereitete CQL-Abfrage, die in einer Abfragezeichenfolge enthalten ist. Alle obigen Beispiele sind Beispiele für SimpleStatement.

BatchStatement

Mehrere Abfragen (wie INSERT, UPDATE und DELETE) werden in einem Stapel abgelegt und gleichzeitig ausgeführt. Jede Zeile wird zuerst als SimpleStatement konvertiert und dann in einem Stapel hinzugefügt.

Fügen wir Zeilen, die in die Schülertabelle eingefügt werden sollen, in Form einer Liste von Tupeln wie folgt ein:

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

Führen Sie das folgende Skript aus, um die obigen Zeilen mit BathStatement hinzuzufügen:

from cassandra.query import SimpleStatement, BatchStatement
batch=BatchStatement()
for student in studentlist:
   batch.add(SimpleStatement("INSERT INTO students 
      (studentID, name, age, marks) VALUES
      (%s, %s, %s %s)"), (student[0], student[1],student[2], student[3]))
session.execute(batch)

PreparedStatement

Die vorbereitete Anweisung ähnelt einer parametrisierten Abfrage in der DB-API. Die Abfragezeichenfolge wird von Cassandra zur späteren Verwendung gespeichert. Die Session.prepare () -Methode gibt eine PreparedStatement-Instanz zurück.

Für unsere Schülertabelle lautet eine PreparedStatement for INSERT-Abfrage wie folgt:

stmt=session.prepare("INSERT INTO students (studentID, name, age, marks) VALUES (?,?,?)")

Anschließend müssen nur noch die Werte der zu bindenden Parameter gesendet werden. Zum Beispiel -

qry=stmt.bind([1,'Ram', 23,175])

Führen Sie abschließend die obige gebundene Anweisung aus.

session.execute(qry)

Dies reduziert den Netzwerkverkehr und die CPU-Auslastung, da Cassandra die Abfrage nicht jedes Mal neu analysieren muss.

ZODB (Zope object Database) ist eine Datenbank zum Speichern von Python-Objekten. Es ist ACID-konform - eine Funktion, die in NOSQL-Datenbanken nicht enthalten ist. Der ZODB ist wie viele NoSQL-Datenbanken auch Open Source, horizontal skalierbar und schemafrei. Es ist jedoch nicht verteilt und bietet keine einfache Replikation. Es bietet einen Persistenzmechanismus für Python-Objekte. Es ist Teil des Zope Application Servers, kann aber auch unabhängig verwendet werden.

ZODB wurde von Jim Fulton von der Zope Corporation erstellt. Es begann als einfaches persistentes Objektsystem. Die aktuelle Version ist 5.5.0 und ist vollständig in Python geschrieben. Verwenden einer erweiterten Version der in Python integrierten Objektpersistenz (Pickle).

Einige der Hauptmerkmale von ZODB sind -

transactions
history/undo
transparent steckbarer Speicher
eingebautes Caching
Multiversion Concurrency Control (MVCC)
Skalierbarkeit über ein Netzwerk

Der ZODB ist ein hierarchicalDatenbank. Es gibt ein Stammobjekt, das beim Erstellen einer Datenbank initialisiert wird. Das Stammobjekt wird wie ein Python-Wörterbuch verwendet und kann andere Objekte enthalten (die selbst wie ein Wörterbuch sein können). Um ein Objekt in der Datenbank zu speichern, reicht es aus, es einem neuen Schlüssel in seinem Container zuzuweisen.

ZODB ist nützlich für Anwendungen, bei denen Daten hierarchisch sind und wahrscheinlich mehr Lese- als Schreibvorgänge ausgeführt werden. ZODB ist eine Erweiterung des Pickle-Objekts. Aus diesem Grund kann es nur über das Python-Skript verarbeitet werden.

Um die neueste Version von ZODB zu installieren, verwenden Sie das Dienstprogramm pip -

pip install zodb

Folgende Abhängigkeiten werden ebenfalls installiert -

BTrees==4.6.1
cffi==1.13.2
persistent==4.5.1
pycparser==2.19
six==1.13.0
transaction==2.4.0

ZODB bietet folgende Speicheroptionen:

Dateispeicher

Dies ist die Standardeinstellung. Alles in einer großen Data.fs-Datei gespeichert, die im Wesentlichen ein Transaktionsprotokoll ist.

DirectoryStorage

Dadurch wird eine Datei pro Objektrevision gespeichert. In diesem Fall muss der Data.fs.index bei einem unsauberen Herunterfahren nicht neu erstellt werden.

RelStorage

Dadurch werden Gurken in einer relationalen Datenbank gespeichert. PostgreSQL, MySQL und Oracle werden unterstützt.

Um eine ZODB-Datenbank zu erstellen, benötigen wir einen Speicher, eine Datenbank und schließlich eine Verbindung.

Der erste Schritt besteht darin, ein Speicherobjekt zu haben.

import ZODB, ZODB.FileStorage
storage = ZODB.FileStorage.FileStorage('mydata.fs')

Die DB-Klasse verwendet dieses Speicherobjekt, um ein Datenbankobjekt abzurufen.

db = ZODB.DB(storage)

Übergeben Sie None an den DB-Konstruktor, um eine speicherinterne Datenbank zu erstellen.

Db=ZODB.DB(None)

Schließlich stellen wir eine Verbindung mit der Datenbank her.

conn=db.open()

Das Verbindungsobjekt gibt Ihnen dann mit der Methode 'root ()' Zugriff auf das 'root' der Datenbank. Das 'root'-Objekt ist das Wörterbuch, das alle Ihre persistenten Objekte enthält.

root = conn.root()

Zum Beispiel fügen wir dem Stammobjekt eine Liste von Schülern hinzu:

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

Diese Änderung wird nicht dauerhaft in der Datenbank gespeichert, bis wir die Transaktion festschreiben.

import transaction
transaction.commit()

Um das Objekt einer benutzerdefinierten Klasse zu speichern, muss die Klasse von persistent.Persistent parent class geerbt werden.

Vorteile der Unterklasse

Die Unterklasse Persistente Klasse hat folgende Vorteile:

Die Datenbank verfolgt automatisch Objektänderungen, die durch Festlegen von Attributen vorgenommen wurden.
Die Daten werden in einem eigenen Datenbankeintrag gespeichert.
Sie können Daten speichern, die nicht der Unterklasse Persistent angehören, die jedoch im Datenbankdatensatz des persistenten Objekts gespeichert sind, auf das sie verweisen. Nicht persistente Objekte gehören ihrem persistenten Objekt. Wenn mehrere persistente Objekte auf dasselbe nicht persistente Unterobjekt verweisen, erhalten sie ihre eigenen Kopien.

Lassen Sie use eine Schülerklasse definieren, die die Unterklasse Persistent als unter -

import persistent
   class student(persistent.Persistent):
   def __init__(self, name):
      self.name = name
   def __repr__(self):
      return str(self.name)

Um ein Objekt dieser Klasse hinzuzufügen, richten wir zunächst die Verbindung wie oben beschrieben ein.

import ZODB, ZODB.FileStorage
storage = ZODB.FileStorage.FileStorage('studentdata.fs')
db = ZODB.DB(storage)
conn=db.open()
root = conn.root()

Deklarieren Sie das Objekt und fügen Sie es dem Stamm hinzu, und schreiben Sie die Transaktion fest

s1=student("Akash")
root['s1']=s1
import transaction
transaction.commit()
conn.close()

Die Liste aller Objekte, die dem Stamm hinzugefügt wurden, kann mithilfe der Methode items () als Ansichtsobjekt abgerufen werden, da das Stammobjekt dem integrierten Wörterbuch ähnelt.

print (root.items())
ItemsView({'s1': Akash})

Um das Attribut eines bestimmten Objekts von root abzurufen,

print (root['s1'].name)
Akash

Das Objekt kann einfach aktualisiert werden. Da die ZODB-API ein reines Python-Paket ist, muss keine externe SQL-Sprache verwendet werden.

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

Die Datenbank wird sofort aktualisiert. Beachten Sie, dass die Transaktionsklasse auch die Funktion abort () definiert, die der Transaktionssteuerung rollback () in SQL ähnelt.

Microsoft Excel ist die beliebteste Tabellenkalkulationsanwendung. Es ist seit mehr als 25 Jahren in Gebrauch. Spätere Versionen von Excel verwendenOffice Open XML (OOXML) Dateiformat. Daher war es möglich, über andere Programmierumgebungen auf Tabellenkalkulationsdateien zuzugreifen.

OOXMList ein ECMA-Standarddateiformat. Pythonsopenpyxl Das Paket bietet Funktionen zum Lesen / Schreiben von Excel-Dateien mit der Erweiterung .xlsx.

Das openpyxl-Paket verwendet eine Klassennomenklatur, die der Microsoft Excel-Terminologie ähnelt. Ein Excel-Dokument wird als Arbeitsmappe aufgerufen und mit der Erweiterung .xlsx im Dateisystem gespeichert. Eine Arbeitsmappe kann mehrere Arbeitsblätter enthalten. Ein Arbeitsblatt enthält ein großes Raster von Zellen, von denen jede entweder einen Wert oder eine Formel speichern kann. Zeilen und Spalten, die das Raster bilden, sind nummeriert. Spalten werden durch die Buchstaben A, B, C, ..., Z, AA, AB usw. gekennzeichnet. Die Zeilen sind ab 1 nummeriert.

Ein typisches Excel-Arbeitsblatt wird wie folgt angezeigt:

Das Pip-Dienstprogramm ist gut genug, um das openpyxl-Paket zu installieren.

pip install openpyxl

Die Arbeitsmappenklasse repräsentiert eine leere Arbeitsmappe mit einem leeren Arbeitsblatt. Wir müssen es aktivieren, damit einige Daten zum Arbeitsblatt hinzugefügt werden können.

from openpyxl import Workbook
wb=Workbook()
sheet1=wb.active
sheet1.title='StudentList'

Wie wir wissen, wird eine Zelle im Arbeitsblatt als ColumnNameRownumber-Format bezeichnet. Dementsprechend ist die obere linke Zelle A1. Wir weisen dieser Zelle eine Zeichenfolge zu als -

sheet1['A1']= 'Student List'

Verwenden Sie alternativ Arbeitsblätter cell()Methode, die Zeilen- und Spaltennummer verwendet, um eine Zelle zu identifizieren. Rufen Sie die Werteigenschaft für das Zellenobjekt auf, um einen Wert zuzuweisen.

cell1=sheet1.cell(row=1, column=1)
cell1.value='Student List'

Nach dem Auffüllen des Arbeitsblatts mit Daten wird die Arbeitsmappe durch Aufrufen der Methode save () des Arbeitsmappenobjekts gespeichert.

wb.save('Student.xlsx')

Diese Arbeitsmappendatei wird im aktuellen Arbeitsverzeichnis erstellt.

Das folgende Python-Skript schreibt eine Liste von Tupeln in ein Arbeitsmappendokument. Jedes Tupel speichert die Rollennummer, das Alter und die Noten des Schülers.

from openpyxl import Workbook
wb = Workbook()
sheet1 = wb.active
sheet1.title='Student List'
sheet1.cell(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):
      sheet1.cell(column=col, row=1+row).value=studentlist[row-1][col-1]
wb.save('students.xlsx')

Die Arbeitsmappe students.xlsx wird im aktuellen Arbeitsverzeichnis gespeichert. Wenn es mit einer Excel-Anwendung geöffnet wird, wird es wie folgt angezeigt:

Das openpyxl-Modul bietet load_workbook() Funktion, die beim Zurücklesen von Daten im Arbeitsmappendokument hilft.

from openpyxl import load_workbook
wb=load_workbook('students.xlsx')

Sie können jetzt auf den Wert jeder Zelle zugreifen, die durch die Zeilen- und Spaltennummer angegeben wird.

cell1=sheet1.cell(row=1, column=1)
print (cell1.value)
Student List

Beispiel

Der folgende Code füllt eine Liste mit Arbeitsblattdaten.

from openpyxl import load_workbook
wb=load_workbook('students.xlsx')
sheet1 = wb['Student List']
studentlist=[]
for row in range(1,5):
   stud=[]
for col in range(1,5):
   val=sheet1.cell(column=col, row=1+row).value
stud.append(val)
studentlist.append(tuple(stud))
print (studentlist)

Ausgabe

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

Ein sehr wichtiges Merkmal der Excel-Anwendung ist die Formel. Um einer Zelle eine Formel zuzuweisen, weisen Sie sie einer Zeichenfolge zu, die die Formelsyntax von Excel enthält. Weisen Sie der c6-Zelle mit Alter die Funktion DURCHSCHNITT zu.

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

Openpyxl-Modul hat Translate_formula()Funktion zum Kopieren der Formel über einen Bereich. Das folgende Programm definiert die AVERAGE-Funktion in C6 und kopiert sie nach C7, um den Durchschnitt der Noten zu berechnen.

from openpyxl import load_workbook
wb=load_workbook('students.xlsx')

sheet1 = wb['Student List']
from openpyxl.formula.translate import Translator#copy formula
sheet1['B6']='Average'
sheet1['C6']='=AVERAGE(C3:C5)'
sheet1['D6'] = Translator('=AVERAGE(C3:C5)', origin="C6").translate_formula("D6")
wb.save('students.xlsx')

Das geänderte Arbeitsblatt sieht nun wie folgt aus: