3. Die Grundlagen von Python

3.1. Skript [bases_01]: Grundlegende Operationen

Das Skript [bases_01] stellt die grundlegenden Funktionen von Python vor.

# ----------------------------------
def affiche(chaine):
    #  chain poster
    print("chaine=%s" % chaine)


# ----------------------------------
def affiche_type(variable):
    #  displays variable type
    print("type[%s]=%s" % (variable, type(variable)))


# ----------------------------------
def f1(param):
    #  adds 10 to param
    return param + 10


# ----------------------------------
def f2():
    #  returns a tuple of 3 values
    return "un", 0, 100


#  -------------------------------- main program ------------------------------------
#  this is a comment
#  variable used without being declared
nom = "dupont"

#  a screen display
print("nom=%s" % nom)

#  a list with elements of different types
liste = ["un", "deux", 3, 4]

#  its number of elements
n = len(liste)

#  a loop
for i in range(n):
    print("liste[%d]=%s" % (i, liste[i]))

#  initialize 2 variables with a tuple
(chaine1, chaine2) = ("chaine1", "chaine2")

#  concatenation of the 2 strings
chaine3 = chaine1 + chaine2

#  result display
print("[%s,%s,%s]" % (chaine1, chaine2, chaine3))

#  use function
affiche(chaine1)

#  the type of a variable can be known
affiche_type(n)
affiche_type(chaine1)
affiche_type(liste)

#  the type of a variable can change at runtime
n = "a changé"
affiche_type(n)

#  a function can return a result
res1 = f1(4)
print("res1=%s" % res1)

#  a function can return a list of values
(res1, res2, res3) = f2()
print("(res1,res2,res3)=[%s,%s,%s]" % (res1, res2, res3))

#  we could have retrieved these values in a
liste = f2()
for i in range(len(liste)):
    print("liste[%s]=%s" % (i, liste[i]))

#  testing
for i in range(len(liste)):
    #  displays only channels
    if type(liste[i]) == "str":
        print("liste[%s]=%s" % (i, liste[i]))

#  other tests
for i in range(len(liste)):
    #  displays only integers >10
    if type(liste[i]) == "int" and liste[i] > 10:
        print("liste[%s]=%s" % (i, liste[i]))

#  a while loop
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]  #  sum=sum+list[i]
    i += 1  #  i=i+1
print("somme=%s" % somme)
#  end of program

Kommentare

Zeile 2: Das Schlüsselwort def definiert eine Funktion;
Zeile 2: Die Funktion erhält den Parameter [string]. Der Parametertyp ist nicht angegeben. Python verwendet ausschließlich die Wertübergabe. Dies hängt von den Daten ab:
- Bei einem einfachen Typ (Zahl, Boolescher Wert usw.) ist dieser Wert der von den Daten gekapselte Wert (4, True usw.);
- bei einem komplexen Typ (Liste, Klasse usw.) ist dieser Wert die Adresse der Daten;
Zeilen 3–4: Der Funktionskörper. Er ist um eine Tabulatortaste nach rechts eingerückt. Diese Einrückung definiert in Kombination mit dem Zeichen : der def-Anweisung den Funktionskörper. Dies gilt für alle Anweisungen mit einem Körper: 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 (Zeichenkette): für eine Zeichenkette;
- %d (decimal): für vorzeichenbehaftete Dezimalzahlen;
- %f (float): Dezimalformat für reelle Zahlen;
- %e (exponential): Exponentialformat für eine reelle Zahl;
- …
[data1, data2…] sind die Ausdrücke, deren Werte Sie anzeigen möchten:
- [data1] wird im F1-Format angezeigt;
- [data2] wird im F2-Format angezeigt;
- …
Zeile 10: Python verwaltet Variablentypen intern. Du kannst den Typ einer Variablen 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 normalerweise (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. Bei Python wird zwischen Groß- und Kleinschreibung unterschieden. Die Variable `Nom` unterscheidet sich von der Variable `nom`. Eine Zeichenkette kann in doppelte Anführungszeichen " oder einfache Anführungszeichen ' gesetzt werden. Man kann also `'dupont'` oder `"dupont"` schreiben;
Zeile 34: Es gibt einen Unterschied zwischen einem Tupel (1,2,3) (beachte die Klammern) und einer Liste [1,2,3] (beachte die eckigen Klammern). Ein Tupel ist unveränderlich, während eine Liste veränderlich ist. In beiden Fällen wird das Element Nummer 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 in der Sammlung var (Tupel, Liste, Wörterbuch usw.);
Zeile 84: Die Struktur [for in …] ermöglicht es Ihnen, eine iterierbare Struktur zu durchlaufen. Listen und Tupel sind iterierbare Elemente;
Zeile 86: Die anderen booleschen Operatoren sind or und not;
Zeile 93: summiert die Zahlen größer als 0 in der Liste;

Die Bildschirmausgabe 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]: Formatierte Zeichenfolgen

Python 3 führte eine neue Methode zur Formatierung von Zeichenfolgen ein:

#  formatting strings
#  formats are those of the C language
#  integer
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}]")
#  string
str1="abcd"
print(f"[str1={str1}]")
print(f"[str1={str1:8s}]")
str2="jean de florette"
print(f"[{str2:20.10s}]")
#  formatted strings can be assigned to variables
str3=f"[{str2:20.10s}]"
print(str3)

Die Syntax für die formatierte Zeichenfolge lautet wie folgt:

1	`f'…{expr1:format1} …. {expr2:format2} ….'`

wobei:

[expr]: 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 Zeichenfolgen. Dies ist das Format, das verwendet wird, wenn für [expr] kein Format angegeben ist;
- %nd, %nf, %ns: zeigt [expri] über n Zeichen an: Die Zeichenkette wird entweder abgeschnitten oder mit Leerzeichen aufgefüllt;
Zeile 7: [04d], 4-stellige Ganzzahl, links mit Nullen aufgefüllt;
Zeile 11: [8.2f], 8-stellige dezimale Gleitkommazahl mit 2 Stellen nach dem Komma;
Zeile 12: [.3e], eine Gleitkommazahl 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:

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_02.py
[int1=10]
[int1=  10]
[int1=0010]
[float1=8.2]
[float1=    8.20]
[float1=8.200e+00]
[str1=abcd]
[str1=abcd    ]
[jean de fl          ]
[jean de fl          ]

Process finished with exit code 0

3.3. Skript [bases_03]: Typkonvertierungen

Hier konzentrieren wir uns auf Typkonvertierungen mit Daten vom Typ str (Zeichenkette), int (Ganzzahl), float (Gleitkomma) und bool (Boolescher Wert).

#  type changes
#  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))

#  type change error handling
try:
    x = int("abc")
    print(x, type(x))
except ValueError as erreur:
    print(erreur)

#  various cases
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))

#  all data are class instances and as such have their own methods
#  character string
str1 = "abc"
print(str1.capitalize())
#  whole number
int1 = 4
print(int1.bit_length())
#  boolean
bool1=True
print(bool1.conjugate())
#  real number
float1=8.2
print (float1.is_integer())

Viele Typkonvertierungen sind möglich. Einige können fehlschlagen, wie beispielsweise die in den Zeilen 46–47, die versuchen, die Zeichenkette 'abc' in eine Ganzzahl zu konvertieren. Wir haben den Fehler mithilfe eines try/except-Blocks behandelt. Eine allgemeine Form dieses Blocks

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 signalisiert), springt die Steuerung sofort zur except-Klausel. Wenn die Aktionen im try-Block keine Ausnahme auslösen, wird die except-Klausel ignoriert. Die Attribute Exception und ex der except-Anweisung sind optional. Wenn vorhanden, gibt Exception den Typ der von der except-Anweisung abgefangenen Ausnahme an, und ex enthält die aufgetretene Ausnahme. Es können mehrere except-Anweisungen vorhanden sein, wenn Sie verschiedene Ausnahmetypen innerhalb desselben try-Blocks behandeln möchten.

Die finally-Anweisung ist optional. Ist sie vorhanden, werden die Aktionen im finally-Block immer ausgeführt, unabhängig davon, ob eine Ausnahme aufgetreten ist oder nicht.

Wir werden etwas später noch einmal auf Ausnahmen zurückkommen.

Die Zeilen 49–61 zeigen verschiedene Versuche, Daten vom Typ str, int, float und NoneType in boolean zu konvertieren. Dies ist immer möglich. Die Regeln lauten wie folgt:

bool(int i) ist False, wenn i 0 ist, und True in allen anderen Fällen;
bool(float f) ist False, wenn f 0,0 ist, und True in allen anderen Fällen;
bool(str string) ist False, wenn string 0 Zeichen hat, True in allen anderen Fällen;
bool(None) ist False. None ist ein Sonderwert, der bedeutet, dass die Variable existiert, aber keinen Wert hat.

Die Bildschirmausgabe 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_03.py
4 <class 'int'>
4 <class 'str'>
4.0 <class 'float'>
True <class 'bool'>
True <class 'bool'>
1 <class 'int'>
1.0 <class 'float'>
True <class 'str'>
4 <class 'str'>
4 <class 'int'>
4.0 <class 'float'>
True <class 'bool'>
4.32 <class 'float'>
4.32 <class 'str'>
4 <class 'int'>
True <class 'bool'>
invalid literal for int() with base 10: 'abc'
True <class 'bool'>
False <class 'bool'>
False <class 'bool'>
None <class 'NoneType'>
False <class 'bool'>
False <class 'bool'>
Abc
3
1
False

Process finished with exit code 0

Beachten Sie, dass alle Daten Objekte sind, d. h. Klasseninstanzen. Das bedeutet, dass sie Methoden haben können. Dies wird in den Zeilen 63–75 des Codes gezeigt. Wir versuchen hier nicht zu erklären, was die Methoden bewirken, sondern lediglich zu zeigen, dass sie existieren.

3.4. Skript [bases_04]: Variablengültigkeitsbereich

Das Skript [bases_04] zeigt, dass Python kein Konzept für Variablen mit Block-Gültigkeitsbereich kennt:

#  variable scope
i = 4
if True:
    i += 1
    j = 7
print(f"i={i}, j={j}")

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_04.py
i=5, j=7

Process finished with exit code 0

Kommentare

Die Ergebnisse zeigen zwei Dinge:

Zeile 4: Die Variable [i] im [if]-Block ist dieselbe wie die in Zeile 2 verwendete Variable i;
Zeile 6: Die Variable [j] ist diejenige, die im [if]-Block initialisiert wurde;

In einigen Sprachen, in denen Variablen deklariert werden, ist eine innerhalb eines Blocks definierte Variable (wie die in den Zeilen 3–5) außerhalb dieses Blocks nicht bekannt. In Python ist dies nicht der Fall.

3.5. Skript [bases_05]: Listen – 1

Das Skript [bases_05] lautet wie folgt:

#  1-dimensional lists
#  initialization
list1 = [0, 1, 2, 3, 4, 5]

#  routes - 1
print(f"list1 a {len(list1)} éléments")
for i in range(len(list1)):
    print(f"list1[{i}]={list1[i]}")

list1[1] = 10
#  routes - 2
print(f"list1 a {len(list1)} éléments")
for element in list1:
    print(element)

#  addition of two elements
list1[len(list1):] = [10, 11]
#  the %s format displays the list on one line
print("%s" % list1)

#  deletion of last two items
list1[len(list1) - 2:] = []
#  the default format displays the list on one line
print(f"{list1}")

#  add to the beginning of a list
list1[:0] = [-10, -11, -12]
print(f"{list1}")

#  mid-list insertion of two elements
list1[3:3] = [100, 101]
print(f"{list1}")

#  deletion of two items in the middle of a list
list1[3:4] = []
print(f"{list1}")

Anmerkungen:

Die Notation array[i:j] bezieht sich auf die Elemente i bis j-1 des Arrays;
Die Notation [i:] bezieht sich auf das Element i und die nachfolgenden Elemente des Arrays;
Die Notation [:i] bezieht sich auf 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 Notation 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 vorherige Code kann unter Verwendung bestimmter Listenmethoden anders geschrieben werden (bases_06):

#  1-dimensional lists

#  initialization
list1 = [0, 1, 2, 3, 4, 5]

#  routes - 1
print(f"list1 a {len(list1)} éléments")
for i in range(len(list1)):
    print(f"list1[{i}]={list1[i]}")

#  element modification
list1[1] = 10

#  routes - 2
print(f"list1 a {len(list1)} éléments")
for element in list1:
    print(element)

#  addition of two elements
list1.extend([10, 11])
print(f"{list1}")

#  deletion of last two items
del list1[len(list1) - 2:]
print(f"{list1}")

#  add a tuple at the beginning of the list
for i in (-12, -11, -10):
    list1.insert(0, i)
print(f"{list1}")

#  mid-list insertion
for i in (101, 100):
    list1.insert(3, i)
print(f"{list1}")

#  mid-list deletion
del list1[3:4]
print(f"{list1}")

Die Ergebnisse sind dieselben wie in der vorherigen Version.

3.7. Skript [bases_07]: das Wörterbuch

Das Skript [bases_07] zeigt, wie man ein Wörterbuch definiert und verwendet, das manchmal auch als assoziatives Array bezeichnet wird.

#  a function that checks whether the husband key exists in the joint dictionary
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")


#  ----------------------------- Main
#  a dictionary
conjoints = {"Pierre": "Gisèle", "Paul": "Virginie", "Jacques": "Lucette", "Jean": ""}

#  routes - 1
print(f"Nombre d'éléments du dictionnaire : {len(conjoints)}")
for (clé, valeur) in conjoints.items():
    print(f"conjoints[{clé}]={valeur}")

#  list of dictionary keys
print("liste des clés-------------")
clés = conjoints.keys()
print(f"{clés}")

#  list of dictionary values
print("liste des valeurs------------")
valeurs = conjoints.values()
print(f"{valeurs}")

#  key search
existe(conjoints, "Jacques")
existe(conjoints, "Lucette")
existe(conjoints, "Jean")

#  deleting a key-value
del (conjoints["Jean"])
print(f"Nombre d'éléments du dictionnaire : {len(conjoints)}")
print(f"{conjoints}")

#  dictionary keys and values are not lists
print(f"type des clés : {type(clés)}")
print(f"type des valeurs : {type(valeurs)}")

#  we can transform them into lists
lclés = list(clés)
print(f"clés : {type(lclés)}, {lclés}")
lvaleurs = list(valeurs)
print(f"valeurs : {type(lvaleurs)}, {lvaleurs}")

Anmerkungen:

Zeile 11: die fest codierte Definition eines Wörterbuchs;
Zeile 15: conjoints.items() gibt die Liste der (Schlüssel, Wert)-Paare aus dem conjoints-Wörterbuch zurück;
Zeile 20: conjoints.keys() gibt die Schlüssel des conjoints-Wörterbuchs zurück;
Zeile 25: conjoints.values() gibt die Werte des conjoints-Wörterbuchs zurück;
Zeile 3: husband in spouses gibt True zurück, wenn der Schlüssel husband im Wörterbuch spouses 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:

Beachten Sie, dass in den Zeilen 16–17 der Ergebnisse die Schlüssel und Werte eines Wörterbuchs keine Liste bilden, sondern einen Typ „dict_keys“;
Zeilen 18–19: Ein einfacher Typumwandlung konvertiert sie in einen [list]-Typ;

3.8. Skript [bases_08]: Tupel

Ein Tupel ähnelt einer Liste, ist jedoch unveränderlich:

#  tuples
#  initialization
tuple1 = (0, 1, 2, 3, 4, 5)

#  routes - 1
print(f"tuple1 a {len(tuple1)} elements")
for i in range(len(tuple1)):
    print(f"tuple1[{i}]={tuple1[i]}")

#  routes - 2
print(f"tuple1 a {len(tuple1)} elements")
for element in tuple1:
    print(element)

#  a tuble can be displayed in one line
print(f"tuple1={tuple1}")

#  a tuple cannot be modified
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:

Die Zeilen 17–20 der Ausgabe zeigen, dass ein Tupel nicht geändert werden kann.

3.9. Skript [bases_09]: Mehrdimensionale Listen und Wörterbücher

Das Skript [bases_09] veranschaulicht, wie man eine mehrdimensionale Liste oder ein mehrdimensionales Wörterbuch definiert und verwendet:

#  multidimensional lists
#  initialization
multi = [[0, 1, 2], [10, 11, 12, 13], [20, 21, 22, 23, 24]]

#  route
for i1 in range(len(multi)):
    for i2 in range(len(multi[i1])):
        print(f"multi[{i1}][{i2}]={multi[i1][i2]}")

#  one-line display
print(f"multi={multi}")

#  multidimensional dictionaries
#  initialization
multi = {"zéro": [0, 1], "un": [10, 11, 12, 13], "deux": [20, 21, 22, 23, 24]}

#  route
for (clé, valeur) in multi.items():
    for i2 in range(len(valeur)):
        print(f"multi[{clé}][{i2}]={multi[clé][i2]}")

#  one-line display
print(f"multi={multi}")

Kommentare

Zeile 7: multi[i1] ist eine Liste;
Zeile 18: value 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 Zeichenketten und Listen

Das Skript [bases_10] zeigt, wie Elemente aus einer durch ein gemeinsames Trennzeichen getrennten Zeichenkette in eine Liste extrahiert werden können.

#  string to list
chaine = '1:2:3:4'
liste = chaine.split(':')
print(type(liste))

#  list display
print(f"liste a {len(liste)} éléments")
print(f"liste={liste}")

#  list to string
chaine2 = ":".join(liste)
print(f"chaine2={chaine2}")

#  add an empty field
chaine += ":"
print(f"chaine={chaine}")
liste = chaine.split(":")

#  list display
print(f"liste a {len(liste)} éléments")
print(f"liste={liste}")

#  let's add another empty field
chaine += ":"
print(f"chaine={chaine}")
liste = chaine.split(":")

#  list display
print(f"liste a {len(liste)} éléments")
print(f"liste={liste}")

Anmerkungen:

Zeile 3: Die Methode `string.split(separator)` teilt die Zeichenkette `string` in durch `separator` getrennte Elemente auf und gibt diese als Liste zurück. So liefert der Ausdruck `'1:2:3:4'.split(":")` die Liste `('1','2','3','4')` zurück;
Zeile 11: 'separator'.join(list) gibt die Zeichenkette 'list[0]+separator+list[1]+separator+…' zurück.

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] veranschaulicht die Verwendung regulärer Ausdrücke:

#  import the regular expressions module
import re


# --------------------------------------------------------------------------
def compare(modèle, chaine):
    #  compares the string [string] with the model [model]
    #  displaying results
    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}]")


#  regular expressions in python
#  retrieve the various fields of a string
#  the model: a sequence of numbers surrounded by any characters
#  you only want to retrieve the sequence of digits
modèle = r"^.*?(\d+).*?$"

#  the chain is compared with the
compare(modèle, "xyz1234abcd")
compare(modèle, "12 34")
compare(modèle, "abcd")

#  the model: a sequence of numbers surrounded by any characters
#  we want the sequence of numbers and the fields that follow and precede them
modèle = r"^(.*?)(\d+)(.*?)$"

#  the chain is compared with the
compare(modèle, "xyz1234abcd")
compare(modèle, "12 34")
compare(modèle, "abcd")

#  the template - a date in dd/mm/yy format
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")

#  the model - a decimal number
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")
#  end

Anmerkungen:

Beachten Sie das in Zeile 2 importierte Modul [re]. Es enthält die Funktionen zur Verarbeitung regulärer Ausdrücke;
Zeile 10: Der Vergleich einer Zeichenkette mit einem regulären Ausdruck (Muster) gibt „True“ zurück, wenn die Zeichenkette mit dem Muster übereinstimmt, andernfalls „False“;
Zeile 12: match.groups() ist ein Tupel, dessen Elemente die Teile der Zeichenkette sind, die mit den in Klammern eingeschlossenen Elementen des regulären Ausdrucks übereinstimmen. Im Muster:
- ^.*?(\d+).*? ist match.groups() ein Tupel mit einem Element, da es einen Satz Klammern gibt;
- ^(.*?)(\d+)(.*?)$, ist match.groups() ein Tupel mit drei Elementen, da es drei Klammern gibt;
Zeile 21: Ein literaler regulärer Ausdruck wird als r"xxx" geschrieben. Es ist das Symbol r, das die Zeichenkette in einen regulären Ausdruck umwandelt;

Mit regulären Ausdrücken können wir das Format einer Zeichenkette überprüfen. Beispielsweise können wir sicherstellen, dass eine Zeichenkette, die ein Datum darstellt, im Format tt/mm/jj vorliegt. Dazu verwenden wir ein Muster und vergleichen die Zeichenkette mit diesem Muster. In diesem Beispiel müssen d, m und y Ziffern sein. Das Muster für ein gültiges Datumsformat lautet daher „\d\d/\d\d/\d\d“, wobei das Symbol \d für eine Ziffer steht. Die folgenden Symbole können in einem Muster verwendet werden:

Zeichen	Beschreibung
\	Bezeichnet das folgende Zeichen als Sonderzeichen oder Literal. Beispielsweise entspricht „n“ dem Zeichen „n“, während „\n“ einem Zeilenumbruchzeichen entspricht. Die Zeichenfolge „\\“ entspricht „\“, während „\(" dem Zeichen „(“ entspricht.
^	Stimmt mit dem Anfang der Zeichenfolge überein.
$	Stimmt mit dem Ende der Zeichenkette überein.
*	Stimmt nullmal oder mehrmals mit dem vorangehenden Zeichen überein. Somit passt „zo*“ zu „z“ oder „zoo“.
+	Stimmt mit dem vorangehenden Zeichen ein- oder mehrmals überein. So passt „zo+“ zu „zoo“, aber nicht zu „z“.
?	Passt null- oder einmal auf das vorangehende Zeichen. Zum Beispiel passt „a?ve?“ auf „ve“ in „lever“.
.	Stimmt mit einem beliebigen einzelnen Zeichen überein, mit Ausnahme des Zeilenumbruchzeichens.
(Muster)	Sucht nach dem Muster und speichert die Übereinstimmung. Die übereinstimmende Teilzeichenfolge kann aus der Sammlung match.groups() abgerufen werden. Um Übereinstimmungen mit Zeichen innerhalb von Klammern ( ) zu finden, verwende „$" oder „$“.
x\|y	Passt entweder auf x oder y. Zum Beispiel passt „z\|foot“ auf „z“ oder „foot“. „(z\|f)oo“ passt auf „zoo“ oder „foo“.
{n}	n ist eine nicht-negative ganze Zahl. Passt genau auf n Vorkommen des Zeichens. Beispielsweise passt „o{2}“ nicht auf „o“ in „Bob“, sondern auf die ersten beiden „o“s in „fooooot“.
{n,}	n ist eine nicht-negative ganze Zahl. Passt auf mindestens n Vorkommen des Zeichens. Beispielsweise passt „o{2,}“ nicht auf „o“ in „Bob“, sondern auf alle „o“s in „fooooot“. „o{1,}“ entspricht „o+“ und „o{0,}“ entspricht „o*“.
{n,m}	m und n sind nicht-negative ganze Zahlen. Findet mindestens n und höchstens m Vorkommen des Zeichens. Beispielsweise passt „o{1,3}“ auf die ersten drei „o“s in „foooooot“ und „o{0,1}“ entspricht „o?“.
[xyz]	Zeichensatz. Findet eines der angegebenen Zeichen. Beispielsweise findet „[abc]“ das „a“ in „plat“.
[^xyz]	Negativer Zeichensatz. Findet jedes Zeichen, das nicht aufgeführt ist. Beispielsweise findet „[^abc]“ das „p“ in „plat“.
[a-z]	Zeichenbereich. Entspricht jedem Zeichen im angegebenen Bereich. Beispielsweise entspricht „[a-z]“ jedem Kleinbuchstaben zwischen „a“ und „z“.
[^m-z]	Negativer Zeichenbereich. Entspricht jedem Zeichen, das nicht im angegebenen Bereich liegt. Beispielsweise entspricht „[^m-z]“ jedem Zeichen, das nicht zwischen „m“ und „z“ liegt.
\b	Passt auf eine Wortgrenze, d. h. die Position zwischen einem Wort und einem Leerzeichen. Beispielsweise passt „er\b“ auf „er“ in „lever“, aber nicht auf „er“ in „verb“.
\B	Passt auf eine Grenze, die kein Wort darstellt. „en*t\B“ passt auf „ent“ in „bien entendu“.
\d	Passt auf ein Zeichen, das eine Ziffer darstellt. Entspricht [0-9].
\D	Passt auf ein Zeichen, das keine Ziffer ist. Entspricht [^0-9].
\f	Entspricht einem Zeilenumbruchzeichen.
\n	Entspricht einem Zeilenumbruchzeichen.
\r	Entspricht einem Wagenrücklaufzeichen.
\s	Entspricht einem beliebigen Leerzeichen, einschließlich Leerzeichen, Tabulator, Seitenumbruch usw. Entspricht „[ \f\n\r\t\v]“.
\S	Entspricht jedem Zeichen, das kein Leerzeichen ist. Entspricht "[^ \f\n\r\t\v]".
\t	Entspricht einem Tabulatorzeichen.
\v	Entspricht einem vertikalen Tabulatorzeichen.
\w	Entspricht jedem Zeichen, das ein Wort darstellt, einschließlich Unterstrich. Entspricht „[A-Za-z0-9_]“.
\W	Entspricht jedem Zeichen, das kein Wort darstellt. Entspricht „[^A-Za-z0-9_]“.
\num	Passt auf num, wobei num eine positive ganze Zahl ist. Bezieht sich auf gespeicherte Übereinstimmungen. Beispielsweise passt „(.)\1“ auf zwei aufeinanderfolgende identische 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 256 nicht überschreiten. Ist dies der Fall, werden im Ausdruck nur die ersten beiden Ziffern berücksichtigt. Ermöglicht die Verwendung von ASCII-Codes in regulären Ausdrücken.
\xn	Entspricht n, wobei n ein hexadezimaler Escape-Wert ist. Hexadezimale Escape-Werte müssen aus genau zwei Ziffern bestehen. Beispielsweise entspricht „\x41“ dem Zeichen „A“. „\x041“ entspricht „\x04“ und „1“. Ermöglicht die Verwendung von ASCII-Codes in regulären Ausdrücken.

Ein Element in einem Muster kann einmal oder mehrmals vorkommen. Sehen wir uns einige Beispiele mit dem Symbol \d an, das eine einzelne Ziffer darstellt:

Muster	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 ein Modell vor, das das erwartete Format einer Zeichenkette beschreiben kann:

Zielzeichenfolge	Muster
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 Folge von Leerzeichen, die leer sein kann	\s*
eine vorzeichenlose Ganzzahl, der Leerzeichen vorangehen oder folgen können	\s\d+\s
eine ganze Zahl, die vorzeichenbehaftet sein kann und der Leerzeichen vorangehen oder folgen können	\s*[+\|-]?\s\d+\s
eine vorzeichenlose reelle Zahl, der Leerräume vorangestellt oder nachgestellt sein können	\s\d+(.\d)?\s*
eine reelle Zahl, die vorzeichenbehaftet sein kann und der Leerzeichen vorangehen oder nachfolgen können	\s*[+-]?\s\d+(.\d)?\s*
eine Zeichenkette, die das Wort „just“ enthält	\bjuste\b

Sie können angeben, wo in der Zeichenfolge nach dem Muster gesucht werden soll:

Muster	Bedeutung
^Muster	Das Muster steht am Anfang der Zeichenfolge
Muster$	Das Muster beendet die Zeichenkette
^Muster$	Das Muster beginnt und endet die Zeichenfolge
Muster	Das Muster wird ab dem Anfang an einer beliebigen Stelle in der Zeichenfolge gesucht.

Gesuchtes Muster	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 aus einem einzelnen Wort besteht, dem wahlweise Leerzeichen vorangestellt oder nachgestellt sind	^\s\w+\s$
eine Zeichenfolge, die aus zwei Wörtern besteht, optional mit Leerzeichen davor oder danach	^\s\w+\s\w+\s*$
eine Zeichenfolge, die das Wort „secret“ enthält	\bsecret\b

Teilmuster eines Musters können „extrahiert“ werden. So können wir nicht nur überprüfen, ob eine Zeichenfolge einem bestimmten Muster entspricht, sondern auch die Elemente aus dieser Zeichenfolge extrahieren, die den in Klammern eingeschlossenen Teilmustern des Musters entsprechen. Wenn wir beispielsweise eine Zeichenfolge analysieren, die ein Datum im Format dd/mm/yy enthält, und die Komponenten dd, mm und yy dieses Datums extrahieren möchten, würden wir das Muster (\d\d)/(\d\d)/(\d\d) verwenden.

Skriptergebnisse


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