3. Grundlagen

3.1. Ein Beispiel für ein Python-Programm

Im Folgenden finden Sie ein Programm, das die ersten Funktionen von Python veranschaulicht.

Das Programm (bases_01)


# -*- coding=utf-8 -*-

# ----------------------------------
def affiche(chaine):
    # zeigt eine Zeichenkette an
    print "chaine=%s" % (chaine)


# ----------------------------------
def afficheType(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 3 Werte 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
afficheType(n)
afficheType(chaine1)
afficheType(liste)

# Der Typ einer Variablen kann sich während der Ausführung ändern
n="a change"
afficheType(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 + t[i]
    i+=1 #i = i + 1
print "somme=%s" % (somme)
# Programmende

Hinweis:

Zeile 1: Ein spezieller Kommentar, der dazu dient, den Kodierungstyp des Skripts anzugeben, hier UTF-8. Dies hängt vom verwendeten Texteditor ab. Hier mit Notepad++:

Zeile 4: Das Schlüsselwort „def“ definiert eine Funktion;
Zeilen 5–6: 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 12: 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 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 31: Der Ausdruck „xxxx%syyyy%szzzz“ % (100, 200) ist die Zeichenkette "xxxx100yyy200szzzz", wobei jedes %s durch ein Element des Tupels ersetzt wurde. %s ist das Anzeigeformat für Zeichenketten. Es gibt weitere Formate;
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 74: len(var) ist die Anzahl der Elemente der Sammlung var (Tupel, Liste, Wörterbuch, ...);
Zeile 86: Die anderen booleschen Operatoren sind or und not.

Die Bildschirmausgabe lautet wie folgt:

nom=dupont
liste[0]=un
liste[1]=deux
liste[2]=3
liste[3]=4
[chaine1,chaine2,chaine1chaine2]
chaine=chaine1
type[4]=<type 'int'>
type[chaine1]=<type 'str'>
type[['un', 'deux', 3, 4]]=<type 'list'>
type[a change]=<type '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

3.2. Typumwandlungen

Hier geht es um Typumwandlungen mit Daten vom Typ str (Zeichenkette), int (Ganzzahl), float (Gleitkommazahl) und bool (Boolescher Wert).

Das Programm (bases_01b)


# -*- coding=utf-8 -*-

# 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, erreur:
    print erreur

# Verschiedene Fälle des Booleschen Werts
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)

Es sind zahlreiche Typumwandlungen möglich. Einige können fehlschlagen, wie beispielsweise in den Zeilen 45–49, in denen 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, Message:
    actions
finally:
    actions

Wenn eine der Aktionen im „try“-Block eine Ausnahme auslöst (einen Fehler meldet), wird sofort zur „except“-Klausel verzweigt. Wenn die Aktionen im „try“-Block keine Ausnahme auslösen, wird die „except“-Klausel ignoriert. Die Attribute Exception und Message der Anweisung except sind optional. Sind sie vorhanden, gibt Exception den Typ der von der Anweisung except abgefangenen Ausnahme an, und Message enthält die mit der Ausnahme verbundene Fehlermeldung. 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 Ausnahmen zurückkommen.

Die Zeilen 52–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) ergibt False, wenn i gleich 0 ist, und True in allen anderen Fällen;
bool(float f) ergibt 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 Ausgabe auf dem Bildschirm lautet wie folgt:

4 <type 'int'>
4 <type 'str'>
4.0 <type 'float'>
True <type 'bool'>
True <type 'bool'>
1 <type 'int'>
1.0 <type 'float'>
True <type 'str'>
4 <type 'str'>
4 <type 'int'>
4.0 <type 'float'>
True <type 'bool'>
4.32 <type 'float'>
4.32 <type 'str'>
4 <type 'int'>
True <type 'bool'>
invalid literal for int() with base 10: 'abc'
True <type 'bool'>
False <type 'bool'>
False <type 'bool'>
None <type 'NoneType'>
False <type 'bool'>
False <type 'bool'>

3.3. Der Geltungsbereich der Variablen

Programm (bases_02)


# -*- coding=utf-8 -*-

# Gültigkeitsbereich von Variablen
def f1():
    # Die globale Variable i wird verwendet
    global i
    i+=1
    j=10
    print "f1[i,j]=[%s,%s]" % (i,j)

def f2():
    # Verwendung der globalen Variablen i
    global i
    i+=1
    j=20
    print "f2[i,j]=[%s,%s]" % (i,j)

def f3():
    # Es wird eine lokale Variable „i“ verwendet
    i=1
    j=30
    print "f3[i,j]=[%s,%s]" % (i,j)
  
# Tests
i=0
j=0 # Diese beiden Variablen sind einer Funktion f
    # nur dann bekannt, wenn diese sie explizit mit der Anweisung „global“ deklariert
    # dass sie diese verwenden möchte
f1()
f2()
f3()
print "test[i,j]=[%s,%s]" % (i,j)

Ergebnisse

f1[i,j]=[1,10]
f2[i,j]=[2,20]
f3[i,j]=[1,30]
test[i,j]=[2,0]

Anmerkungen:

Das Skript veranschaulicht die Verwendung der Variablen i, die in den Funktionen f1 und f2 als globale Variable deklariert wurde. In diesem Fall nutzen das Hauptprogramm sowie die Funktionen f1 und f2 dieselbe Variable i.

3.4. Listen, Tupel und Wörterbücher

3.4.1. Eindimensionale Listen

Programm (bases_03)


# -*- coding=utf-8 -*-

# eindimensionale Listen
# Initialisierung
list1=[0,1,2,3,4,5]

# Durchlauf – 1
print "list1 a %s elements" % (len(list1))
for i in range(len(list1)):
    print "list1[%s]=%s" % (i, list1[i])

list1[1]=10;
# Durchlauf – 2
print "list1 a %s elements" % (len(list1))
for element in list1:
    print element

# Hinzufügen von zwei Elementen
list1[len(list1):]=[10,11]
print ("%s") % (list1)

# Löschen der letzten beiden Elemente
list1[len(list1)-2:]=[]
print ("%s") % (list1)

# Hinzufügen eines Tupels am Anfang der Liste
list1[:0]=[-10, -11, -12]
print ("%s") % (list1)

# Einfügen von zwei Elementen in die Mitte der Liste
list1[3:3]=[100,101]
print ("%s") % (list1)

# Entfernen von zwei Elementen in der Mitte der Liste
list1[3:4]=[]
print ("%s") % (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 20: print (%s) % (list1) gibt die Zeichenkette aus: „[ list1[0], list1[2], ..., list1[n-1]]“.

Ergebnisse

list1 a 6 elements
list1[0]=0
list1[1]=1
list1[2]=2
list1[3]=3
list1[4]=4
list1[5]=5
list1 a 6 elements
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]

Der obige Code kann mithilfe bestimmter Listenmethoden anders geschrieben werden (bases_03b):


# -*- coding=utf-8 -*-

# eindimensionale Listen

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

# Durchlauf – 1
print "list1 a %s elements" % (len(list1))
for i in range(len(list1)):
    print "list1[%s]=%s" % (i, list1[i])

list1[1]=10
# Durchlauf – 2
print "list1 a %s elements" % (len(list1))
for element in list1:
    print element

# Hinzufügen von zwei Elementen
list1.extend([10,11])
print ("%s") % (list1)

# Löschen der letzten beiden Elemente
del list1[len(list1)-2:]
print ("%s") % (list1)

# Hinzufügen eines Tupels am Anfang der Liste
for i in (-12, -11, -10):
    list1.insert(0,i)
print ("%s") % (list1)

# Einfügen in der Mitte der Liste
for i in (101,100):
    list1.insert(3,i)
print ("%s") % (list1)

# Löschen in der Mitte der Liste
del list1[3:4]
print ("%s") % (list1)

Die erhaltenen Ergebnisse sind dieselben wie bei der vorherigen Version.

3.4.2. Das Wörterbuch

Das Programm (bases_04)


# -*- coding=utf-8 -*-

def existe(conjoints,mari):
    # prüft, ob der Schlüssel „mari“ im Wörterbuch „conjoints“ vorhanden ist
    if(conjoints.has_key(mari)):
        print "La cle [%s] existe associee a la valeur [%s]" % (mari, conjoints[mari])
    else:
        print "La cle [%s] n'existe pas" % (mari)


# ----------------------------- Hauptprogramm
# Wörterbücher
conjoints={"Pierre":"Gisele", "Paul":"Virginie", "Jacques":"Lucette","Jean":""}

# Durchlauf – 1
print "Nombre d'elements du dictionnaire : %s " % (len(conjoints))
for (cle,valeur) in conjoints.items():
    print "conjoints[%s]=%s" % (cle,valeur)

# Liste der Schlüssel des Verzeichnisses
print "liste des cles-------------"
cles=conjoints.keys()
print ("%s") % (cles)

# Liste der Wörterbuchwerte
print "liste des valeurs------------"
valeurs=conjoints.values()
print ("%s") % (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 "Nombre d'elements du dictionnaire : %s " % (len(conjoints))
print ("%s") % (conjoints)

Anmerkungen:

Zeile 17: conjoints.items() gibt die Liste der (Schlüssel, Wert)-Paare des gemeinsamen Wörterbuchs zurück;
Zeile 22: conjoints.keys() gibt die Schlüssel des assoziativen Wörterbuchs zurück;
Zeile 27: conjoints.values() gibt die Werte des Dictionaries „conjoints“ zurück;
Zeile 7: conjoints.has_key(mari) gibt True zurück, wenn der Schlüssel mari im Wörterbuch conjoints vorhanden ist, ansonsten False;
Zeile 38: Ein Wörterbuch kann in einer einzigen Zeile angezeigt werden.

Die Ergebnisse

Nombre d'elements du dictionnaire : 4
conjoints[Paul]=Virginie
conjoints[Jean]=
conjoints[Pierre]=Gisele
conjoints[Jacques]=Lucette
liste des cles-------------
['Paul', 'Jean', 'Pierre', 'Jacques']
liste des valeurs------------
['Virginie', '', 'Gisele', 'Lucette']
La cle [Jacques] existe associee a la valeur [Lucette]
La cle [Lucette] n'existe pas
La cle [Jean] existe associee a la valeur []
Nombre d'elements du dictionnaire : 3
{'Paul': 'Virginie', 'Pierre': 'Gisele', 'Jacques': 'Lucette'}

3.4.3. Die Tupel

Programm (bases_05)


# -*- coding=utf-8 -*-

# Tupel
# Initialisierung
tab1=(0,1,2,3,4,5)

# Durchlauf – 1
print "tab1 a %s elements" % (len(tab1))
for i in range(len(tab1)):
    print "tab1[%s]=%s" % (i, tab1[i])

# Durchlauf – 2
print "tab1 a %s elements" % (len(tab1))
for element in tab1:
    print element

# Änderung eines Elements
tab1[0]=-1

Die Ergebnisse

tab1 a 6 elements
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1 a 6 elements
0
1
2
3
4
5
Traceback (most recent call last):
  File "exemple_05.py", line 18, in <module>
    tab1[0]=-1
TypeError: 'tuple' object does not support item assignment

Anmerkungen:

Zeilen 15–18 der Ergebnisse: zeigen, dass ein Tupel nicht geändert werden kann.

3.4.4. Mehrdimensionale Listen

Programm (bases_06)


# -*- coding=utf-8 -*-

# 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 "multi[%s][%s]=%s" % (i1,i2,multi[i1][i2])

# mehrdimensionale Wörterbücher
# Initialisierung
multi={"zero":[0,1], "un":[10,11,12,13], "deux":[20,21,22,23,24]}

# Durchlauf
for (cle,valeur) in multi.items():
    for i2 in range(len(multi[cle])):
        print "multi[%s][%s]=%s" % (cle,i2,multi[cle][i2])

Ergebnisse

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[zero][0]=0
multi[zero][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

3.4.5. Verknüpfungen zwischen Kanälen und Listen

Programm (bases_07)


# -*- coding=Utf-8 -*-

# Zeichenkette in Liste
chaine='1:2:3:4'
tab=chaine.split(':')
print type(tab)

# Liste anzeigen
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

# Liste in Zeichenkette
chaine2=":".join(tab)
print "chaine2=%s" % (chaine2)

# ein leeres Feld hinzufügen
chaine+=":"
print "chaine=%s" % (chaine)
tab=chaine.split(":")

# Liste anzeigen
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

# Fügen wir erneut ein leeres Feld hinzu
chaine+=":"
print "chaine=%s" % (chaine)
tab=chaine.split(":")

# Liste anzeigen
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

Anmerkungen:

Zeile 5: 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 13: 'separateur'.join(liste) hat den Wert der Zeichenkette 'Liste[0]+Trennzeichen+Liste[1]+Trennzeichen+...'.

Ergebnisse

<type 'list'>
tab a 4 elements
['1', '2', '3', '4']
chaine2=1:2:3:4
chaine=1:2:3:4:
tab a 5 elements
['1', '2', '3', '4', '']
chaine=1:2:3:4::
tab a 6 elements
['1', '2', '3', '4', '', '']

3.5. Reguläre Ausdrücke

Programm (bases_09)


# -*- coding=utf-8 -*-

import re

# --------------------------------------------------------------------------
def compare(modele,chaine):
    # vergleicht die Zeichenkette „zeichenkette“ mit der Vorlage „vorlage“
    # Ergebnisse anzeigen
    print "\nResultats(%s,%s)" % (chaine,modele)
    match=re.match(modele,chaine)
    if match:
        print match.groups()
    else:
        print "La chaine [%s] ne correspond pas au modele [%s]" % (chaine,modele)


# Reguläre Ausdrücke in Python
# die verschiedenen Felder einer Zeichenkette extrahieren
# Das Muster: eine Zahlenfolge, die von beliebigen Zeichen umgeben ist
# Es soll nur die Ziffernfolge extrahiert werden
modele=r"^.*?(\d+).*?$"

# Die Zeichenkette wird mit dem Muster abgeglichen
compare(modele,"xyz1234abcd")
compare(modele,"12 34")
compare(modele,"abcd")

# Das Muster: eine Ziffernfolge, die von beliebigen Zeichen umgeben ist
# Wir möchten die Ziffernfolge sowie die vorangehenden und nachfolgenden Felder
modele=r"^(.*?)(\d+)(.*?)$"

# Die Zeichenfolge wird mit dem Muster abgeglichen
compare(modele,"xyz1234abcd")
compare(modele,"12 34")
compare(modele,"abcd")

# das Muster – ein Datum im Format TT/MM/JJ
modele=r"^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$"
compare(modele,"10/05/97")
compare(modele," 04/04/01 ")
compare(modele,"5/1/01")

# das Muster – eine Dezimalzahl
modele=r"^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$"
compare(modele,"187.8")
compare(modele,"-0.6")
compare(modele,"4")
compare(modele,".6")
compare(modele,"4.")
compare(modele," + 4")
# Ende

Hinweise:

Beachten Sie das in Zeile 3 importierte Modul. 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;
^(.*?)(\d+)(.*?)$, match.groups() ist ein Tupel mit 3 Elementen.

Ergebnisse

Resultats(xyz1234abcd,^.*?(\d+).*?$)
('1234',)

Resultats(12 34,^.*?(\d+).*?$)
('12',)

Resultats(abcd,^.*?(\d+).*?$)
La chaine [abcd] ne correspond pas au modele [^.*?(\d+).*?$]

Resultats(xyz1234abcd,^(.*?)(\d+)(.*?)$)
('xyz', '1234', 'abcd')

Resultats(12 34,^(.*?)(\d+)(.*?)$)
('', '12', ' 34')

Resultats(abcd,^(.*?)(\d+)(.*?)$)
La chaine [abcd] ne correspond pas au modele [^(.*?)(\d+)(.*?)$]

Resultats(10/05/97,^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$)
('10', '05', '97')

Resultats( 04/04/01 ,^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$)
('04', '04', '01')

Resultats(5/1/01,^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$)
La chaine [5/1/01] ne correspond pas au modele [^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$]

Resultats(187.8,^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '187.8')

Resultats(-0.6,^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('-', '0.6')

Resultats(4,^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '4')

Resultats(.6,^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '.6')

Resultats(4.,^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '4.')

Resultats( + 4,^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('+', '4')

3.6. Art der Parameterübergabe bei Funktionen

Programm (bases_10)


# -*- coding=utf-8 -*-

def f1(a):
    a=2

def f2(a,b):
    a=2
    b=3
    return (a,b)
  
# ------------------------ Hauptprogramm
x=1
f1(x)
print "x=%s" % (x)
(x,y)=(-1,-1)
(x,y)=f2(x,y)
print "x=%s, y=%s" % (x,y)

Ergebnisse

1 2	`x=1 x=2, y=3`

Anmerkungen:

In Python ist alles ein Objekt. Bestimmte Objekte werden als „unveränderlich“ bezeichnet: Sie können nicht verändert werden. Dies gilt für Zahlen, Zeichenketten und Tupel. Wenn Python-Objekte als Parameter an Funktionen übergeben werden, werden deren Referenzen übergeben, es sei denn, diese Objekte sind „unveränderlich“; in diesem Fall wird der Wert des Objekts übergeben;
Die Funktionen f1 (Zeile 3) und f2 (Zeile 6) sollen die Übergabe eines Ausgabeparameters veranschaulichen. Es soll erreicht werden, dass der tatsächliche Parameter einer Funktion durch die Funktion verändert wird;
Zeilen 3–4: Die Funktion f1 ändert ihren formalen Parameter a. Wir wollen wissen, ob auch der effektive Parameter geändert wird.
Zeilen 12–13: Der tatsächliche Parameter ist x=1. Das Ergebnis aus Zeile 1 zeigt, dass der tatsächliche Parameter nicht verändert wird. Somit sind der tatsächliche Parameter x und der formale Parameter a zwei verschiedene Objekte;
Zeilen 6–9: Die Funktion f2 ändert ihre formalen Parameter a und b und gibt sie als Ergebnisse zurück;
Zeilen 15–16: Die effektiven Parameter (x, y) werden an f2 übergeben, und das Ergebnis von f2 wird in (x, y) zurückgespeichert. Zeile 2 der Ergebnisse zeigt, dass die effektiven Parameter (x, y) geändert wurden.

Daraus lässt sich schließen, dass „unveränderliche“ Objekte, die als Ausgabeparameter dienen, Teil der von der Funktion zurückgegebenen Ergebnisse sein müssen.

3.7. Textdateien

Programm (bases_11)


# -*- coding=utf-8 -*-

import sys

# sequenzielle Verarbeitung einer Textdatei
# Diese besteht aus einer Reihe von Zeilen der Form login:pwd:uid:gid:infos:dir:shell
# Jede Zeile wird in einem Wörterbuch in der Form „login =>“ gespeichert: [uid,gid,infos,dir,shell]

# --------------------------------------------------------------------------
def afficheInfos(dico,cle):
    # zeigt den Wert an, der dem Schlüssel im Wörterbuch „dico“ zugeordnet ist, sofern er existiert
    valeur=None
    if dico.has_key(cle):
        valeur=dico[cle]
    if 'list' in str(type(valeur)):
        print "[{0},{1}]".format(cle,":".join(valeur))
    else:
        # Der Schlüssel ist kein Schlüssel im Wörterbuch „dico“
        print "la cle [{0}] n'existe pas".format(cle)           


def cutNewLineChar(ligne):
    # Die Zeilenende-Markierung der Zeile wird entfernt, falls vorhanden
    l=len(ligne);
    while(ligne[l-1]=="\n" or ligne[l-1]=="\r"):
        l-=1
    return(ligne[0:l]);
    
# Der Dateiname wird festgelegt
INFOS="infos.txt"

# Die Datei wird zum Erstellen geöffnet
try:
    fic=open(INFOS,"w")
except:
    print "Erreur d'ouverture du fichier INFOS en écriture\n"
    sys.exit()

# Es wird ein beliebiger Inhalt generiert
for i in range(1,101):
    ligne="login%s:pwd%s:uid%s:gid%s:infos%s:dir%s:shell%s" % (i,i,i,i,i,i,i)
    fic.write(ligne+"\n")

# Die Datei wird geschlossen
fic.close()

# Die Datei wird zum Lesen geöffnet
try:
    fic=open(INFOS,"r")
except:
    print "Erreur d'ouverture du fichier INFOS en écriture\n"
    sys.exit()

# Wörterbuch ist anfangs leer
dico={}

# Zeile lesen  
ligne=fic.readline()  
while(ligne!=''):
    # Das Zeilenendezeichen wird entfernt
    ligne=cutNewLineChar(ligne)
  
    # Die Zeile wird in ein Array gespeichert
    infos=ligne.split(":")
  
    # Login wird abgerufen
    login=infos[0]
  
    # die ersten beiden Elemente werden entfernt [login,pwd]
    infos[0:2]=[]
  
    # Es wird ein Eintrag im Wörterbuch angelegt
    dico[login]=infos
  
    # Zeile lesen  
    ligne=fic.readline()  

# Die Datei wird geschlossen
fic.close()

# Auswertung des Wörterbuchs
afficheInfos(dico,"login10")
afficheInfos(dico,"X")

Anmerkungen:

Zeile 37: um das Skript in der Mitte des Codes zu beenden.

Ergebnisse

Die Datei infos.txt:

login0:pwd0:uid0:gid0:infos0:dir0:shell0
login1:pwd1:uid1:gid1:infos1:dir1:shell1
login2:pwd2:uid2:gid2:infos2:dir2:shell2
...
login98:pwd98:uid98:gid98:infos98:dir98:shell98
login99:pwd99:uid99:gid99:infos99:dir99:shell99

Die Bildschirmausgabe:

1 2	`[login10,uid10:gid10:infos10:dir10:shell10] la cle [X] n'existe pas`