3. Die Grundlagen von Python
3.1. Skript [bases_01]: Grundlegende Operationen
Das Skript [bases_01] stellt die ersten Merkmale von Python vor.
# ----------------------------------
def affiche(chaine):
# gibt eine Zeichenkette aus
print("chaine=%s" % chaine)
# ----------------------------------
def affiche_type(variable):
# zeigt den Variablentyp an
print("type[%s]=%s" % (variable, type(variable)))
# ----------------------------------
def f1(param):
# addiert 10 zu „param“
return param + 10
# ----------------------------------
def f2():
# gibt ein Tupel mit 3 Werten zurück
return "un", 0, 100
# -------------------------------- Hauptprogramm ------------------------------------
# Dies ist ein Kommentar
# Variable wird verwendet, ohne deklariert worden zu sein
nom = "dupont"
# eine Bildschirmausgabe
print("nom=%s" % nom)
# eine Liste mit Elementen unterschiedlichen Typs
liste = ["un", "deux", 3, 4]
# die Anzahl ihrer Elemente
n = len(liste)
# eine Schleife
for i in range(n):
print("liste[%d]=%s" % (i, liste[i]))
# Initialisierung von 2 Variablen mit einem Tupel
(chaine1, chaine2) = ("chaine1", "chaine2")
# Verkettung der beiden Zeichenfolgen
chaine3 = chaine1 + chaine2
# Anzeige des Ergebnisses
print("[%s,%s,%s]" % (chaine1, chaine2, chaine3))
# Verwendung einer Funktion
affiche(chaine1)
# Der Typ einer Variablen kann bekannt sein
affiche_type(n)
affiche_type(chaine1)
affiche_type(liste)
# Der Typ einer Variablen kann sich während der Ausführung ändern
n = "a changé"
affiche_type(n)
# Eine Funktion kann ein Ergebnis zurückgeben
res1 = f1(4)
print("res1=%s" % res1)
# Eine Funktion kann eine Liste von Werten zurückgeben
(res1, res2, res3) = f2()
print("(res1,res2,res3)=[%s,%s,%s]" % (res1, res2, res3))
# Man hätte diese Werte in einer Variablen speichern können
liste = f2()
for i in range(len(liste)):
print("liste[%s]=%s" % (i, liste[i]))
# Tests
for i in range(len(liste)):
# zeigt nur die Zeichenfolgen an
if type(liste[i]) == "str":
print("liste[%s]=%s" % (i, liste[i]))
# weitere Tests
for i in range(len(liste)):
# zeigt nur ganze Zahlen >10 an
if type(liste[i]) == "int" and liste[i] > 10:
print("liste[%s]=%s" % (i, liste[i]))
# eine while-Schleife
liste = (8, 5, 0, -2, 3, 4)
i = 0
somme = 0
while i < len(liste) and liste[i] > 0:
print("liste[%s]=%s" % (i, liste[i]))
somme += liste[i] # Summe = Summe + Liste[i]
i += 1 # i = i + 1
print("somme=%s" % somme)
# Programmende
Kommentare
- Zeile 2: Das Schlüsselwort „def“ definiert eine Funktion;
- Zeile 2: Die Funktion erhält den Parameter [chaine]. Der Typ des Parameters wird nicht angegeben. Python verwendet ausschließlich die Wertübergabe. Diese unterscheidet sich je nach Datentyp:
- Bei einem einfachen Typ (Zahl, Boolescher Wert…) ist dieser Wert der vom Datenelement gekapselte Wert (4, True…);
- bei einem komplexen Typ (Liste, Klasse …) ist dieser Wert die Adresse des Datentyps;
- Zeilen 3–4: Der Inhalt der Funktion. Er ist um ein Tabulatorzeichen nach rechts eingerückt. Diese Einrückung in Verbindung mit dem Zeichen : der Anweisung def definiert den Inhalt der Funktion. Dies gilt für alle Anweisungen mit Inhalt: if, else, while, for, try, except;
- Zeile 4: Die hier verwendete Syntax lautet [print('text1%F1text2%F2…' % data1, data2)]:
- Die [%Fi] (hier %s) sind Anzeigeformate:
- %s (string): für eine Zeichenkette;
- %d (decimal): für vorzeichenbehaftete dezimale Ganzzahlen;
- %f (float): Dezimalformat für reelle Zahlen;
- %e (exponentiell): Exponentialformat für eine reelle Zahl;
- …
- [data1, data2…] sind die Ausdrücke, deren Wert angezeigt werden soll:
- [data1] wird im Format F1 angezeigt;
- [data2] wird im Format F2 angezeigt;
- …
- Zeile 10: Python verwaltet den Typ der Variablen intern. Den Typ einer Variablen kann man mit der Funktion type(variable) ermitteln, die eine Variable vom Typ „type“ zurückgibt. Der Ausdruck „%s“ % (type(variable)) ist eine Zeichenkette, die den Typ der Variablen darstellt;
- Zeile 25: Das Hauptprogramm. Dieses folgt üblicherweise (aber nicht zwangsläufig) auf die Definition aller Funktionen des Skripts. Sein Inhalt ist nicht eingerückt;
- Zeile 28: In Python werden Variablen nicht deklariert. Python unterscheidet zwischen Groß- und Kleinschreibung. Die Variable Nom unterscheidet sich von der Variable nom. Eine Zeichenkette kann in Anführungszeichen „“ oder Apostrophe ' gesetzt werden. Man kann also 'dupont' oder „dupont“ schreiben;
- Zeile 34: Es gibt einen Unterschied zwischen einem Tupel (1,2,3) (beachten Sie die runden Klammern) und einer Liste [1,2,3] (beachten Sie die eckigen Klammern). Das Tupel ist unveränderlich, während die Liste veränderbar ist. In beiden Fällen wird das Element Nr. i als [i] bezeichnet;
- Zeile 40: range(n) ist das Tupel (0,1,2,…,n-1);
- Zeile 41: Das Format %d wird für vorzeichenbehaftete Ganzzahlen verwendet;
- Zeile 74: len(var) ist die Anzahl der Elemente der Sammlung var (Tupel, Liste, Wörterbuch …);
- Zeile 84: Die Struktur [for in …] ermöglicht die Iteration über eine iterierbare Struktur. Listen und Tupel sind iterierbare Elemente;
- Zeile 86: Die weiteren booleschen Operatoren sind or und not;
- Zeile 93: Berechnet die Summe der Zahlen > 0 in der Liste;
Die Ausgabe lautet wie folgt:
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_01.py
nom=dupont
liste[0]=un
liste[1]=deux
liste[2]=3
liste[3]=4
[chaine1,chaine2,chaine1chaine2]
chaine=chaine1
type[4]=<class 'int'>
type[chaine1]=<class 'str'>
type[['un', 'deux', 3, 4]]=<class 'list'>
type[a changé]=<class 'str'>
res1=14
(res1,res2,res3)=[un,0,100]
liste[0]=un
liste[1]=0
liste[2]=100
liste[0]=8
liste[1]=5
somme=13
Process finished with exit code 0
3.2. Skript [bases_02]: Formatierungszeichenfolgen
Python 3 hat eine neue Art der Formatierung von Zeichenketten eingeführt:
# Formatierungszeichenfolgen
# Die Formate entsprechen denen der Programmiersprache C
# Ganzzahl
int1 = 10
print(f"[int1={int1}]")
print(f"[int1={int1:4d}]")
print(f"[int1={int1:04d}]")
# Float
float1=8.2
print(f"[float1={float1}]")
print(f"[float1={float1:8.2f}]")
print(f"[float1={float1:.3e}]")
# Zeichenkette
str1="abcd"
print(f"[str1={str1}]")
print(f"[str1={str1:8s}]")
str2="jean de florette"
print(f"[{str2:20.10s}]")
# Formatierte Zeichenfolgen können Variablen zugewiesen werden
str3=f"[{str2:20.10s}]"
print(str3)
Die Syntax der formatierten Zeichenkette lautet wie folgt:
wobei:
- [expri]: ein Ausdruck;
- [formati]: das Format des Ausdrucks [expri]. Diese Formate entsprechen denen der Programmiersprache C:
- %d: für Ganzzahlen;
- %f: Dezimalschreibweise für reelle Zahlen;
- %e: Exponentialdarstellung für reelle Zahlen;
- %s: für Zeichenketten. Dieses Format wird verwendet, wenn für [expri] kein Format angegeben ist;
- %nd, %nf, %ns: Gibt „[expri]“ auf n Zeichen aus: Die Zeichenfolge wird entweder abgeschnitten oder mit Leerzeichen aufgefüllt;
- Zeile 7: [04d], 4-stellige Ganzzahl, links mit Nullen aufgefüllt;
- Zeile 11: [8.2f], Dezimalzahl mit 8 Zeichen, davon 2 nach dem Komma;
- Zeile 12: [.3e], eine reelle Zahl in Exponentialform mit 3 Dezimalstellen für die Mantisse;
- Zeile 18: [20.10s], die ersten 10 Zeichen einer Zeichenkette, aufgefüllt mit Leerzeichen auf 20 Zeichen;
Die Ergebnisse der Ausführung lauten wie folgt:
3.3. Skript [bases_03]: Typumwandlungen
Hier befassen wir uns mit Typumwandlungen bei Daten vom Typ str (Zeichenkette), int (Ganzzahl), float (Gleitkommazahl) und bool (Boolescher Wert).
# Typumwandlungen
# int --> str, float, bool
x = 4
print(x, type(x))
x = str(4)
print(x, type(x))
x = float(4)
print(x, type(x))
x = bool(4)
print(x, type(x))
# bool --> int, float, str
x = True
print(x, type(x))
x = int(True)
print(x, type(x))
x = float(True)
print(x, type(x))
x = str(True)
print(x, type(x))
# str --> int, float, bool
x = "4"
print(x, type(x))
x = int("4")
print(x, type(x))
x = float("4")
print(x, type(x))
x = bool("4")
print(x, type(x))
# float → str, int, bool
x = 4.32
print(x, type(x))
x = str(4.32)
print(x, type(x))
x = int(4.32)
print(x, type(x))
x = bool(4.32)
print(x, type(x))
# Fehlerbehandlung bei Typumwandlungen
try:
x = int("abc")
print(x, type(x))
except ValueError as erreur:
print(erreur)
# Verschiedene Fälle
x = bool("abc")
print(x, type(x))
x = bool("")
print(x, type(x))
x = bool(0)
print(x, type(x))
x = None
print(x, type(x))
x = bool(None)
print(x, type(x))
x = bool(0.0)
print(x, type(x))
# Alle Daten sind Klasseninstanzen und verfügen daher über Methoden
# Zeichenkette
str1 = "abc"
print(str1.capitalize())
# Ganzzahl
int1 = 4
print(int1.bit_length())
# Boolescher Wert
bool1=True
print(bool1.conjugate())
# Reelle Zahl
float1=8.2
print (float1.is_integer())
Es sind zahlreiche Typumwandlungen möglich. Einige können fehlschlagen, wie beispielsweise in den Zeilen 46–47, wo versucht wird, die Zeichenkette „abc“ in eine Ganzzahl umzuwandeln. Der Fehler wurde mit einer Struktur try / except behandelt. Eine allgemeine Form dieser Struktur
sieht wie folgt aus:
try:
actions
except Exception as ex:
actions
finally:
actions
Wenn eine der Aktionen im try-Block eine Ausnahme auslöst (einen Fehler meldet), erfolgt eine sofortige Verzweigung zur except-Klausel. Wenn die Aktionen im **try-Block keine Ausnahme auslösen, wird die except-Klausel ignoriert. Die Attribute Exception und ex der Anweisung except sind optional. Wenn sie vorhanden sind, gibt Exception den Typ der von der Anweisung except abgefangenen Ausnahme an, und ex enthält die aufgetretene Ausnahme. Es können mehrere Anweisungen vom Typ except vorhanden sein, wenn verschiedene Ausnahmetypen im selben try behandelt werden sollen.
Die Anweisung finally ist optional. Ist sie vorhanden, werden die Aktionen der Anweisung finally immer ausgeführt, unabhängig davon, ob eine Ausnahme aufgetreten ist oder nicht.
Wir werden später noch einmal auf die Ausnahmen zurückkommen.
Die Zeilen 49–61 zeigen verschiedene Versuche, Daten vom Typ str, int, float und NoneType in einen booleschen Wert umzuwandeln. Dies ist immer möglich. Es gelten folgende Regeln:
- bool(int i) ist gleich False, wenn i gleich 0 ist, und True in allen anderen Fällen;
- bool(float f) ist gleich False, wenn f gleich 0,0 ist, und True in allen anderen Fällen;
- bool(str „chaine“) ergibt False, wenn „chaine“ 0 Zeichen enthält, und True in allen anderen Fällen;
- bool(None) ergibt False. None ist ein Sonderwert, der bedeutet, dass die Variable existiert, aber keinen Wert hat.
Die Bildschirmausgaben lauten wie folgt:
Es ist zu beachten, dass alle Daten Objekte sind, d. h. Instanzen einer Klasse. Das bedeutet, dass sie Methoden haben können. Dies zeigen die Zeilen 63–75 des Codes. Wir wollen hier nicht erklären, was die verwendeten Methoden bewirken, sondern lediglich aufzeigen, dass sie existieren.
3.4. Skript [bases_04]: Geltungsbereich der Variablen
Das Skript [bases_04] zeigt, dass Python keinen Begriff der blockweiten Variablen kennt:
# Gültigkeitsbereich der Variablen
i = 4
if True:
i += 1
j = 7
print(f"i={i}, j={j}")
Ergebnisse
Kommentare
Die Ergebnisse zeigen zwei Dinge:
- Zeile 4: Die Variable [i] aus dem Block [if] ist identisch mit der in Zeile 2 verwendeten Variablen i;
- Zeile 6: Die Variable [j] ist diejenige, die im Block [if] initialisiert wurde;
In manchen Programmiersprachen, in denen Variablen deklariert werden, ist eine in einem Block definierte Variable (wie in den Zeilen 3–5) außerhalb dieses Blocks nicht bekannt. In Python gibt es so etwas nicht.
3.5. Skript [bases_05]: Listen – 1
Das Skript [bases_05] lautet wie folgt:
# eindimensionale Listen
# Initialisierung
list1 = [0, 1, 2, 3, 4, 5]
# Durchlauf – 1
print(f"list1 a {len(list1)} éléments")
for i in range(len(list1)):
print(f"list1[{i}]={list1[i]}")
list1[1] = 10
# Durchlauf – 2
print(f"list1 a {len(list1)} éléments")
for element in list1:
print(element)
# Hinzufügen von zwei Elementen
list1[len(list1):] = [10, 11]
# Mit dem Format %s wird die Liste in einer Zeile angezeigt
print("%s" % list1)
# Entfernen der letzten beiden Elemente
list1[len(list1) - 2:] = []
# Das Standardformat ermöglicht die Anzeige der Liste in einer Zeile
print(f"{list1}")
# Hinzufügen einer Liste am Anfang der Liste
list1[:0] = [-10, -11, -12]
print(f"{list1}")
# Einfügen von zwei Elementen in die Mitte der Liste
list1[3:3] = [100, 101]
print(f"{list1}")
# Löschen von zwei Elementen in der Mitte der Liste
list1[3:4] = []
print(f"{list1}")
Anmerkungen:
- Die Notation „array[i:j]“ bezeichnet die Elemente i bis j-1 des Arrays;
- die Notation [i:] bezeichnet die Elemente i und folgende des Arrays;
- Die Notation „[:i]“ bezeichnet die Elemente 0 bis i-1 des Arrays;
- Zeile 19: print (%s) % (list1) gibt die Zeichenkette „[ list1[0], list1[2]…, list1[n-1]]“ aus;
- Zeile 24: Die Schreibweise print ('f{list1}') bewirkt dasselbe;
Ergebnisse
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_05.py
list1 a 6 éléments
list1[0]=0
list1[1]=1
list1[2]=2
list1[3]=3
list1[4]=4
list1[5]=5
list1 a 6 éléments
0
10
2
3
4
5
[0, 10, 2, 3, 4, 5, 10, 11]
[0, 10, 2, 3, 4, 5]
[-10, -11, -12, 0, 10, 2, 3, 4, 5]
[-10, -11, -12, 100, 101, 0, 10, 2, 3, 4, 5]
[-10, -11, -12, 101, 0, 10, 2, 3, 4, 5]
Process finished with exit code 0
3.6. Skript [bases_06]: Listen – 2
Der vorstehende Code lässt sich anders schreiben (bases_06), indem bestimmte Methoden der Listen verwendet werden:
# eindimensionale Listen
# Initialisierung
list1 = [0, 1, 2, 3, 4, 5]
# Durchlauf – 1
print(f"list1 a {len(list1)} éléments")
for i in range(len(list1)):
print(f"list1[{i}]={list1[i]}")
# Änderung eines Elements
list1[1] = 10
# Durchlauf – 2
print(f"list1 a {len(list1)} éléments")
for element in list1:
print(element)
# Hinzufügen von zwei Elementen
list1.extend([10, 11])
print(f"{list1}")
# Löschen der letzten beiden Elemente
del list1[len(list1) - 2:]
print(f"{list1}")
# Hinzufügen eines Tupels am Anfang der Liste
for i in (-12, -11, -10):
list1.insert(0, i)
print(f"{list1}")
# Einfügen in die Mitte der Liste
for i in (101, 100):
list1.insert(3, i)
print(f"{list1}")
# Löschen in der Mitte der Liste
del list1[3:4]
print(f"{list1}")
Die Ergebnisse sind dieselben wie bei der vorherigen Version.
3.7. Skript [bases_07]: Das Wörterbuch
Das Skript [bases_07] zeigt, wie man ein Wörterbuch, das manchmal auch als assoziatives Array bezeichnet wird, definiert und nutzt.
# Eine Funktion, die prüft, ob der Schlüssel „mari“ im Wörterbuch „conjoints“ vorhanden ist
def existe(conjoints, mari):
if mari in conjoints:
print(f"La clé [{mari}] existe associée à la valeur [{conjoints[mari]}]")
else:
print(f"La clé [{mari}] n'existe pas")
# ----------------------------- Hauptprogramm
# ein Wörterbuch
conjoints = {"Pierre": "Gisèle", "Paul": "Virginie", "Jacques": "Lucette", "Jean": ""}
# Durchlauf – 1
print(f"Nombre d'éléments du dictionnaire : {len(conjoints)}")
for (clé, valeur) in conjoints.items():
print(f"conjoints[{clé}]={valeur}")
# Liste der Schlüssel des Wörterbuchs
print("liste des clés-------------")
clés = conjoints.keys()
print(f"{clés}")
# Liste der Werte des Wörterbuchs
print("liste des valeurs------------")
valeurs = conjoints.values()
print(f"{valeurs}")
# Suche nach einem Schlüssel
existe(conjoints, "Jacques")
existe(conjoints, "Lucette")
existe(conjoints, "Jean")
# Löschen eines Schlüssel-Wert-Paares
del (conjoints["Jean"])
print(f"Nombre d'éléments du dictionnaire : {len(conjoints)}")
print(f"{conjoints}")
# Schlüssel und Werte eines Wörterbuchs sind keine Listen
print(f"type des clés : {type(clés)}")
print(f"type des valeurs : {type(valeurs)}")
# Sie können in Listen umgewandelt werden
lclés = list(clés)
print(f"clés : {type(lclés)}, {lclés}")
lvaleurs = list(valeurs)
print(f"valeurs : {type(lvaleurs)}, {lvaleurs}")
Hinweise:
- Zeile 11: die feste Definition eines Wörterbuchs;
- Zeile 15: conjoints.items() macht die Liste der (Schlüssel, Wert)-Paare des Wörterbuchs zu einer Vereinigung;
- Zeile 20: conjoints.keys() gibt die Schlüssel des assoziativen Arrays zurück;
- Zeile 25: conjoints.values() gibt die Werte des Wörterbuchs „conjoints“ zurück;
- Zeile 3: „mari“ in „conjoints“ gibt True zurück, wenn der Schlüssel mari im Wörterbuch conjoints vorhanden ist, andernfalls False;
- Zeile 36: Ein Wörterbuch kann in einer einzigen Zeile angezeigt werden.
Ergebnisse
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_07.py
Nombre d'éléments du dictionnaire : 4
conjoints[Pierre]=Gisèle
conjoints[Paul]=Virginie
conjoints[Jacques]=Lucette
conjoints[Jean]=
liste des clés-------------
dict_keys(['Pierre', 'Paul', 'Jacques', 'Jean'])
liste des valeurs------------
dict_values(['Gisèle', 'Virginie', 'Lucette', ''])
La clé [Jacques] existe associée à la valeur [Lucette]
La clé [Lucette] n'existe pas
La clé [Jean] existe associée à la valeur []
Nombre d'éléments du dictionnaire : 3
{'Pierre': 'Gisèle', 'Paul': 'Virginie', 'Jacques': 'Lucette'}
type des clés : <class 'dict_keys'>
type des valeurs : <class 'dict_values'>
clés : <class 'list'>, ['Pierre', 'Paul', 'Jacques']
valeurs : <class 'list'>, ['Gisèle', 'Virginie', 'Lucette']
Process finished with exit code 0
Anmerkungen:
- In den Zeilen 16–17 der Ergebnisse ist zu beachten, dass die Schlüssel und Werte eines Dictionaries keine Liste bilden, sondern einen Typ „dict_keys“;
- Zeilen 18–19: Durch eine einfache Typänderung lassen sie sich in den Typ „[list]“ umwandeln;
3.8. Skript „[bases_08]“: Tupel
Das Tupel weist Ähnlichkeiten mit der Liste auf, ist jedoch nicht veränderbar:
# Tupel
# Initialisierung
tuple1 = (0, 1, 2, 3, 4, 5)
# Durchlauf – 1
print(f"tuple1 a {len(tuple1)} elements")
for i in range(len(tuple1)):
print(f"tuple1[{i}]={tuple1[i]}")
# Durchlauf – 2
print(f"tuple1 a {len(tuple1)} elements")
for element in tuple1:
print(element)
# Ein Tupel kann in einer Zeile angezeigt werden
print(f"tuple1={tuple1}")
# Ein Tupel kann nicht geändert werden
tuple1[0] = 10
Ergebnisse
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_08.py
tuple1 a 6 elements
tuple1[0]=0
tuple1[1]=1
tuple1[2]=2
tuple1[3]=3
tuple1[4]=4
tuple1[5]=5
tuple1 a 6 elements
0
1
2
3
4
5
tuple1=(0, 1, 2, 3, 4, 5)
Traceback (most recent call last):
File "C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_08.py", line 19, in <module>
tuple1[0] = 10
TypeError: 'tuple' object does not support item assignment
Process finished with exit code 1
Anmerkungen:
- Zeilen 17–20 der Ergebnisse: zeigen, dass ein Tupel nicht geändert werden kann.
3.9. Skript [bases_09]: Mehrdimensionale Listen und Wörterbücher
Das Skript [bases_09] zeigt, wie man eine mehrdimensionale Liste oder ein mehrdimensionales Wörterbuch definiert und nutzt:
# mehrdimensionale Listen
# Initialisierung
multi = [[0, 1, 2], [10, 11, 12, 13], [20, 21, 22, 23, 24]]
# Durchlauf
for i1 in range(len(multi)):
for i2 in range(len(multi[i1])):
print(f"multi[{i1}][{i2}]={multi[i1][i2]}")
# Anzeige in einer Zeile
print(f"multi={multi}")
# mehrdimensionale Wörterbücher
# Initialisierung
multi = {"zéro": [0, 1], "un": [10, 11, 12, 13], "deux": [20, 21, 22, 23, 24]}
# Durchlauf
for (clé, valeur) in multi.items():
for i2 in range(len(valeur)):
print(f"multi[{clé}][{i2}]={multi[clé][i2]}")
# Einzeilige Anzeige
print(f"multi={multi}")
Kommentare
- Zeile 7: multi[i1] ist eine Liste;
- Zeile 18: „Wert“ ist eine Liste;
Ergebnisse
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_09.py
multi[0][0]=0
multi[0][1]=1
multi[0][2]=2
multi[1][0]=10
multi[1][1]=11
multi[1][2]=12
multi[1][3]=13
multi[2][0]=20
multi[2][1]=21
multi[2][2]=22
multi[2][3]=23
multi[2][4]=24
multi=[[0, 1, 2], [10, 11, 12, 13], [20, 21, 22, 23, 24]]
multi[zéro][0]=0
multi[zéro][1]=1
multi[un][0]=10
multi[un][1]=11
multi[un][2]=12
multi[un][3]=13
multi[deux][0]=20
multi[deux][1]=21
multi[deux][2]=22
multi[deux][3]=23
multi[deux][4]=24
multi={'zéro': [0, 1], 'un': [10, 11, 12, 13], 'deux': [20, 21, 22, 23, 24]}
Process finished with exit code 0
3.10. Skript [bases_10]: Verknüpfungen zwischen Zeichenfolgen und Listen
Das Skript [bases_10] zeigt, wie man die Elemente einer Zeichenkette, die durch ein einheitliches Trennzeichen getrennt sind, in eine Liste überführt.
# Zeichenkette in Liste
chaine = '1:2:3:4'
liste = chaine.split(':')
print(type(liste))
# Listenanzeige
print(f"liste a {len(liste)} éléments")
print(f"liste={liste}")
# Liste in Zeichenkette
chaine2 = ":".join(liste)
print(f"chaine2={chaine2}")
# ein leeres Feld hinzufügen
chaine += ":"
print(f"chaine={chaine}")
liste = chaine.split(":")
# Listenanzeige
print(f"liste a {len(liste)} éléments")
print(f"liste={liste}")
# Fügen wir erneut ein leeres Feld hinzu
chaine += ":"
print(f"chaine={chaine}")
liste = chaine.split(":")
# Liste anzeigen
print(f"liste a {len(liste)} éléments")
print(f"liste={liste}")
Hinweise:
- Zeile 3: Die Methode chaine.split(Trennzeichen) zerlegt die Zeichenkette chaine in durch séparateur getrennte Elemente und gibt diese als Liste zurück. Somit hat der Ausdruck '1:2:3:4'.split(":") den Wert der Liste ('1','2','3','4');
- Zeile 11: 'Trennzeichen'.join(Liste) ergibt die Zeichenkette 'Liste[0]+Trennzeichen+Liste[1]+Trennzeichen+…'.
Ergebnisse
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_10.py
<class 'list'>
liste a 4 éléments
liste=['1', '2', '3', '4']
chaine2=1:2:3:4
chaine=1:2:3:4:
liste a 5 éléments
liste=['1', '2', '3', '4', '']
chaine=1:2:3:4::
liste a 6 éléments
liste=['1', '2', '3', '4', '', '']
Process finished with exit code 0
3.11. Skript [bases_11]: Reguläre Ausdrücke
Das Skript [bases_11] zeigt, wie reguläre Ausdrücke verwendet werden:
# Import des Moduls für reguläre Ausdrücke
import re
# --------------------------------------------------------------------------
def compare(modèle, chaine):
# vergleicht die Zeichenfolge [chaîne] mit dem Muster [modèle]
# Ergebnisse anzeigen
print(f"\nRésultats({chaine},{modèle})")
match = re.match(modèle, chaine)
if match:
print(match.groups())
else:
print(f"La chaîne [{chaine}] ne correspond pas au modèle [{modèle}]")
# Reguläre Ausdrücke in Python
# die verschiedenen Felder einer Zeichenkette abrufen
# Das Muster: eine Ziffernfolge, die von beliebigen Zeichen umgeben ist
# Es soll nur die Ziffernfolge extrahiert werden
modèle = r"^.*?(\d+).*?$"
# Die Zeichenkette wird mit dem Muster abgeglichen
compare(modèle, "xyz1234abcd")
compare(modèle, "12 34")
compare(modèle, "abcd")
# Das Muster: eine Ziffernfolge, die von beliebigen Zeichen umgeben ist
# Man möchte die Ziffernfolge sowie die vorangehenden und nachfolgenden Felder
modèle = r"^(.*?)(\d+)(.*?)$"
# Die Zeichenfolge wird mit dem Muster abgeglichen
compare(modèle, "xyz1234abcd")
compare(modèle, "12 34")
compare(modèle, "abcd")
# das Muster – ein Datum im Format TT/MM/JJ
modèle = r"^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$"
compare(modèle, "10/05/97")
compare(modèle, " 04/04/01 ")
compare(modèle, "5/1/01")
# das Muster – eine Dezimalzahl
modèle = r"^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$"
compare(modèle, "187.8")
compare(modèle, "-0.6")
compare(modèle, "4")
compare(modèle, ".6")
compare(modèle, "4.")
compare(modèle, " + 4")
# Ende
Hinweise:
- Beachten Sie das in Zeile 2 importierte Modul [re]. Es enthält die Funktionen zur Verwaltung regulärer Ausdrücke;
- Zeile 10: Der Vergleich einer Zeichenkette mit einem regulären Ausdruck (Muster) liefert den Booleschen Wert True, wenn die Zeichenkette dem Muster entspricht, andernfalls False;
- Zeile 12: match.groups() ist ein Tupel, dessen Elemente die Teile der Zeichenkette sind, die den in Klammern gesetzten Elementen des regulären Ausdrucks entsprechen. Im Muster:
- ^.*?(\d+).*?, ist match.groups() ein Tupel mit einem Element, da nur eine Klammer vorhanden ist;
- ^(.*?)(\d+)(.*?)$, match.groups() ist ein Tupel mit drei Elementen, da drei Klammern vorhanden sind;
- Zeile 21: Ein literaler regulärer Ausdruck wird als r"xxx" notiert. Es ist das Symbol r, das die Zeichenkette zu einem regulären Ausdruck macht;
Mit regulären Ausdrücken können wir das Format einer Zeichenkette prüfen. So lässt sich beispielsweise überprüfen, ob eine Zeichenkette, die ein Datum darstellt, das Format tt/mm/jj hat. Dazu verwenden wir ein Muster und vergleichen die Zeichenkette mit diesem Muster. In diesem Beispiel müssen t, m und j also Ziffern sein. Das Muster für ein gültiges Datumsformat lautet dann „\d\d/\d\d/\d\d“, wobei das Symbol \d eine Ziffer bezeichnet. In einem Muster können folgende Symbole verwendet werden:
Zeichen | Beschreibung |
\ | Markiert das folgende Zeichen als Sonderzeichen oder Literal. Beispielsweise entspricht „n“ dem Zeichen „n“, während „\n“ einem Zeilenumbruch entspricht. Die Zeichenfolge „\\“ entspricht „\“, während „\(" dem Zeichen „(“ entspricht. |
^ | Entspricht dem Anfang der Zeichenkette. |
$ | Entspricht dem Ende der Zeichenkette. |
* | Entspricht dem vorhergehenden Zeichen, nullmal oder mehrmals. So entspricht „zo*“ sowohl „z“ als auch „zoo“. |
+ | Entspricht dem vorhergehenden Zeichen, einmal oder mehrmals. So entspricht „zo+“ beispielsweise „zoo“, aber nicht „z“. |
? | Entspricht dem vorhergehenden Zeichen, null- oder einmal. Zum Beispiel entspricht „a?ve?“ dem Zeichen „ve“ in „lever“. |
. | Entspricht einem beliebigen einzelnen Zeichen, mit Ausnahme des Zeilenumbruchzeichens. |
(Vorlage) | Sucht nach „modèle“ und speichert die Übereinstimmung. Die entsprechende Teilzeichenfolge kann aus der Sammlung „match.groups()“ extrahiert werden. Um Übereinstimmungen mit Zeichen in Klammern ( ) zu finden, verwenden Sie „\(" oder „\)“. |
x|y | Entspricht entweder x oder y. Beispielsweise entspricht „z|foot“ entweder „z“ oder „foot“. „(z|f)oo“ entspricht entweder „zoo“ oder „foo“. |
{n} | n ist eine nicht-negative ganze Zahl. Entspricht genau n-mal dem Zeichen. Beispielsweise entspricht „o{2}“ nicht dem „o“ in „Bob“, sondern den ersten beiden „o“ in „fooooot“. |
{n,} | n ist eine nicht-negative ganze Zahl. Entspricht mindestens n-mal dem Zeichen. Beispielsweise entspricht „o{2,}“ nicht dem „o“ in „Bob“, sondern allen „o“ in „fooooot“. „o{1,}“ entspricht „o+“ und „o{0,}“ entspricht „o*“. |
{n,m} | m und n sind nicht-negative ganze Zahlen. Entspricht mindestens n und höchstens m Mal dem Zeichen. Beispielsweise entspricht „o{1,3}“ den ersten drei „o“ in „foooooot“ und „o{0,1}“ entspricht „o?“. |
[xyz] | Zeichensatz. Entspricht einem der angegebenen Zeichen. Beispielsweise entspricht „[abc]“ dem Zeichen „a“ in „plat“. |
[^xyz] | Negativer Zeichensatz. Entspricht jedem nicht angegebenen Zeichen. Beispielsweise entspricht „[^abc]“ dem Zeichen „p“ in „plat“. |
[a-z] | Zeichenbereich. Entspricht jedem Zeichen in der angegebenen Zeichenfolge. Beispielsweise entspricht „[a-z]“ jedem Kleinbuchstaben zwischen „a“ und „z“. |
[^m-z] | Negativer Zeichenbereich. Entspricht jedem Zeichen, das nicht in der angegebenen Zeichenfolge enthalten ist. Beispielsweise entspricht „[^m-z]“ jedem Zeichen, das nicht zwischen „m“ und „z“ liegt. |
\b | Entspricht einer Wortgrenze, d. h. der Position zwischen einem Wort und einem Leerzeichen. Beispielsweise entspricht „er\b“ dem Wortteil „er“ in „lever“, nicht jedoch dem Wortteil „er“ in „verbe“. |
\B | Entspricht einer Grenze, die kein Wort darstellt. „en*t\B“ entspricht „ent“ in „bien entendu“. |
\d | Entspricht einem Zeichen, das eine Ziffer darstellt. Entspricht [0-9]. |
\D | Entspricht einem Zeichen, das keine Ziffer darstellt. Entspricht [^0-9]. |
\f | Entspricht einem Seitenumbruchzeichen. |
\n | Entspricht einem Zeilenumbruchzeichen. |
\r | Entspricht einem Wagenrücklaufzeichen. |
\s | Entspricht allen Leerzeichen, einschließlich Leerzeichen, Tabulatoren, Seitenumbrüchen usw. Entspricht „[ \f\n\r\t\v]“. |
\S | Entspricht jedem Nicht-Leerzeichen. Entspricht „[^ \f\n\r\t\v]“. |
\t | Entspricht einem Tabulatorzeichen. |
\v | Entspricht einem vertikalen Tabulatorzeichen. |
\w | Entspricht jedem Zeichen, das ein Wort darstellt und einen Unterstrich enthält. Entspricht „[A-Za-z0-9_]“. |
\W | Entspricht jedem Zeichen, das kein Wort darstellt. Entspricht „[^A-Za-z0-9_]“. |
\num | Entspricht num, wobei num eine positive ganze Zahl ist. Bezieht sich auf gespeicherte Zuordnungen. Beispielsweise entspricht „(.)\1“ zwei aufeinanderfolgenden identischen Zeichen. |
\n | Entspricht n, wobei n ein oktaler Escape-Wert ist. Oktale Escape-Werte müssen aus 1, 2 oder 3 Ziffern bestehen. Beispielsweise entsprechen sowohl „\11“ als auch „\011“ einem Tabulatorzeichen. „\0011“ entspricht „\001“ & „1“. Oktale Escape-Werte dürfen den Wert 256 nicht überschreiten. Sollte dies der Fall sein, werden nur die ersten beiden Ziffern im Ausdruck berücksichtigt. Ermöglicht die Verwendung der Codes ASCII in regulären Ausdrücken. |
\xn | Entspricht n, wobei n ein hexadezimaler Escape-Wert ist. Hexadezimale Escape-Werte müssen zwingend aus zwei Ziffern bestehen. Beispielsweise entspricht „\x41“ dem Zeichen „A“. „\x041“ entspricht „\x04“ und „1“. Ermöglicht die Verwendung der Codes ASCII in regulären Ausdrücken. |
Ein Element in einer Vorlage kann ein- oder mehrmals vorkommen. Betrachten wir einige Beispiele rund um das Symbol \d, das für eine Ziffer steht:
Vorlage | Bedeutung |
\d | eine Ziffer |
\d? | 0 oder 1 Ziffer |
\d* | 0 oder mehr Ziffern |
\d+ | 1 oder mehr Ziffern |
\d{2} | 2 Ziffern |
\d{3,} | mindestens 3 Ziffern |
\d{5,7} | zwischen 5 und 7 Ziffern |
Stellen wir uns nun das Modell vor, mit dem das erwartete Format einer Zeichenkette beschrieben werden kann:
gesuchte Zeichenfolge | Modell |
ein Datum im Format TT/MM/JJ | \d{2}/\d{2}/\d{2} |
eine Uhrzeit im Format hh:mm:ss | \d{2}:\d{2}:\d{2} |
eine vorzeichenlose Ganzzahl | \d+ |
eine möglicherweise leere Folge von Leerzeichen | \s* |
eine vorzeichenlose Ganzzahl, der Leerzeichen vorangestellt oder nachgestellt sein können | \s*\d+\s* |
eine ganze Zahl, die vorzeichenbehaftet sein kann und der Leerzeichen vorangestellt oder nachgestellt sein können | \s*[+|-]?\s*\d+\s* |
eine vorzeichenlose reelle Zahl, der Leerzeichen vorangestellt oder nachgestellt sein können | \s*\d+(.\d*)?\s* |
eine reelle Zahl, die vorzeichenbehaftet sein kann und vor oder nach der Leerzeichen stehen können | \s*[+-]?\s*\d+(.\d*)?\s* |
eine Zeichenfolge, die das Wort „juste“ enthält | \bjuste\b |
Man kann angeben, an welcher Stelle in der Zeichenfolge nach dem Muster gesucht werden soll:
Muster | Bedeutung |
^Muster | Das Muster steht am Anfang der Zeichenfolge |
Muster$ | Das Muster beendet die Zeichenfolge |
^Muster$ | Das Muster beginnt und beendet die Zeichenfolge |
Muster | Das Muster wird überall in der Zeichenfolge gesucht, beginnend am Anfang der Zeichenfolge. |
gesuchte Zeichenfolge | Muster |
Eine Zeichenfolge, die mit einem Ausrufezeichen endet | !$ |
eine Zeichenfolge, die mit einem Punkt endet | \.$ |
eine Zeichenkette, die mit der Sequenz // beginnt | ^// |
eine Zeichenfolge, die nur aus einem Wort besteht, dem gegebenenfalls Leerzeichen vorangestellt oder nachgestellt sind | ^\s*\w+\s*$ |
eine Zeichenfolge, die aus zwei Wörtern besteht, denen gegebenenfalls Leerzeichen vorangehen oder folgen | ^\s*\w+\s*\w+\s*$ |
eine Zeichenfolge, die das Wort „secret“ enthält | \bsecret\b |
Die Teilmengen eines Musters können „extrahiert“ werden. So lässt sich nicht nur überprüfen, ob eine Zeichenfolge einem bestimmten Muster entspricht, sondern es können auch die Elemente aus dieser Zeichenfolge extrahiert werden, die den in Klammern gesetzten Teilmengen des Musters entsprechen. Wenn man also eine Zeichenkette analysiert, die ein Datum im Format TT/MM/JJ enthält, und zusätzlich die Elemente TT, MM und JJ dieses Datums extrahieren möchte, verwendet man das Muster (\d\d)/(\d\d)/(\d\d).
Ergebnisse des Skripts
C:\Data\st-2020\dev\python\cours-2020\python3-flask-2020\venv\Scripts\python.exe C:/Data/st-2020/dev/python/cours-2020/python3-flask-2020/bases/bases_11.py
Résultats(xyz1234abcd,^.*?(\d+).*?$)
('1234',)
Résultats(12 34,^.*?(\d+).*?$)
('12',)
Résultats(abcd,^.*?(\d+).*?$)
La chaîne [abcd] ne correspond pas au modèle [^.*?(\d+).*?$]
Résultats(xyz1234abcd,^(.*?)(\d+)(.*?)$)
('xyz', '1234', 'abcd')
Résultats(12 34,^(.*?)(\d+)(.*?)$)
('', '12', ' 34')
Résultats(abcd,^(.*?)(\d+)(.*?)$)
La chaîne [abcd] ne correspond pas au modèle [^(.*?)(\d+)(.*?)$]
Résultats(10/05/97,^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$)
('10', '05', '97')
Résultats( 04/04/01 ,^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$)
('04', '04', '01')
Résultats(5/1/01,^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$)
La chaîne [5/1/01] ne correspond pas au modèle [^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$]
Résultats(187.8,^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '187.8')
Résultats(-0.6,^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('-', '0.6')
Résultats(4,^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '4')
Résultats(.6,^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '.6')
Résultats(4.,^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '4.')
Résultats( + 4,^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('+', '4')
Process finished with exit code 0