3. Die Grundlagen
3.1. Ein Beispiel für ein Python-Programm
Im Folgenden finden Sie ein Programm, das die grundlegenden Funktionen von Python veranschaulicht.
Das Programm (bases_01)
| # -*- coding=utf-8 -*-
# ----------------------------------
def affiche(chaine):
# chain poster
print "chaine=%s" % (chaine)
# ----------------------------------
def afficheType(variable):
# displays variable type
print "type[%s]=%s" % (variable,type(variable))
# ----------------------------------
def f1(param):
# add 10 to param
return param+10
# ----------------------------------
def f2():
# returns 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
afficheType(n)
afficheType(chaine1)
afficheType(liste)
# the type of a variable can change at runtime
n="a change"
afficheType(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+t[i]
i+=1 # i=i+1
print "somme=%s" % (somme)
# end of program
|
Hinweis:
- Zeile 1: Ein spezieller Kommentar, der den Zeichensatz des Skripts angibt, 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 Funktionskörper. Er ist um eine Tabulatortaste nach rechts eingerückt. Diese Einrückung definiert in Kombination mit dem Doppelpunkt (:) in der
def-Anweisung den Funktionskörper. Dies gilt für alle Anweisungen mit einem Körper: if, else, while, for, try, except;
- Zeile 12: 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. Es 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 doppelte Anführungszeichen " oder einfache Anführungszeichen ' gesetzt werden. Sie können also 'dupont' oder "dupont*" schreiben;
- Zeile 31: Der Ausdruck „xxxx%syyyy%szzzz“ % (100, 200) ergibt die Zeichenkette „xxxx100yyy200szzzz“, wobei jedes %s durch ein Element des Tupels ersetzt wurde. %s ist der Formatierungsbezeichner für Zeichenketten. Es gibt weitere Formate;
- 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). Das Tupel ist unveränderlich, während die Liste veränderbar ist. In beiden Fällen wird das Element Nummer i mit [i] bezeichnet;
- Zeile 40: range(n) ist das Tupel (0,1,2,...,n-1);
- Zeile 74: len(var) ist die Anzahl der Elemente in 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. Typkonvertierungen
Hier konzentrieren wir uns auf Typkonvertierungen mit Daten vom Typ str (Zeichenkette), int (Ganzzahl), float (Gleitkomma) und bool (Boolescher Wert).
Das Programm (bases_01b)
| # -*- coding=utf-8 -*-
# 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, erreur:
print erreur
# various Boolean 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)
|
Viele Typkonvertierungen sind möglich. Einige können fehlschlagen, wie beispielsweise die in den Zeilen 45–49, 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 lautet wie folgt:
try:
actions
except Exception, Message:
actions
finally:
actions
Wenn eine der Aktionen innerhalb des try-Blocks eine Ausnahme auslöst (einen Fehler signalisiert), springt die Steuerung sofort zur **except-Klausel. Wenn die Aktionen innerhalb des try-Blocks keine Ausnahme auslösen, wird die except-Klausel ignoriert. Die Attribute Exception und Message der except-Anweisung sind optional. Wenn vorhanden, gibt Exception den Typ der von der except-Anweisung abgefangenen Ausnahme an, und Message enthält die mit der Ausnahme verbundene Fehlermeldung. 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.
In den Zeilen 52–61 werden verschiedene Versuche gezeigt, Daten der Typen str, int, float und NoneType in boolean umzuwandeln. Dies ist immer möglich. Es gelten folgende Regeln:
- 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, 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:
| 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 von Variablen
Programm (bases_02)
| # -*- coding=utf-8 -*-
# variable scope
def f1():
# we use the global variable i
global i
i+=1
j=10
print "f1[i,j]=[%s,%s]" % (i,j)
def f2():
# we use the global variable i
global i
i+=1
j=20
print "f2[i,j]=[%s,%s]" % (i,j)
def f3():
# we use a local variable i
i=1
j=30
print "f3[i,j]=[%s,%s]" % (i,j)
# tests
i=0
j=0 # these two variables are known only to a function f
# only if it explicitly declares with the global instruction
# she wants to use them
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 global deklariert wurde. In diesem Fall teilen sich das Hauptprogramm und 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 -*-
# 1-dimensional lists
# initialization
list1=[0,1,2,3,4,5]
# routes - 1
print "list1 a %s elements" % (len(list1))
for i in range(len(list1)):
print "list1[%s]=%s" % (i, list1[i])
list1[1]=10;
# routes - 2
print "list1 a %s elements" % (len(list1))
for element in list1:
print element
# addition of two elements
list1[len(list1):]=[10,11]
print ("%s") % (list1)
# deletion of last two items
list1[len(list1)-2:]=[]
print ("%s") % (list1)
# addition at the beginning of a tuple list
list1[:0]=[-10, -11, -12]
print ("%s") % (list1)
# mid-list insertion of two elements
list1[3:3]=[100,101]
print ("%s") % (list1)
# deletion of two items in the middle of a list
list1[3:4]=[]
print ("%s") % (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 der Liste;
- Zeile 20: print (%s) % (list1) gibt die Zeichenfolge „[ list1[0], list1[2], ..., list1[n-1]]“ aus.
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 vorherige Code kann mithilfe bestimmter Listenmethoden anders geschrieben werden (bases_03b):
| # -*- coding=utf-8 -*-
# 1-dimensional lists
# initialization
list1=[0,1,2,3,4,5]
# routes - 1
print "list1 a %s elements" % (len(list1))
for i in range(len(list1)):
print "list1[%s]=%s" % (i, list1[i])
list1[1]=10
# routes - 2
print "list1 a %s elements" % (len(list1))
for element in list1:
print element
# addition of two elements
list1.extend([10,11])
print ("%s") % (list1)
# deletion of last two items
del list1[len(list1)-2:]
print ("%s") % (list1)
# addition at the beginning of a tuple list
for i in (-12, -11, -10):
list1.insert(0,i)
print ("%s") % (list1)
# mid-list insertion
for i in (101,100):
list1.insert(3,i)
print ("%s") % (list1)
# mid-list deletion
del list1[3:4]
print ("%s") % (list1)
|
Die 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):
# checks whether the husband key exists in the joint dictionary
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)
# ----------------------------- Main
# dictionaries
conjoints={"Pierre":"Gisele", "Paul":"Virginie", "Jacques":"Lucette","Jean":""}
# routes - 1
print "Nombre d'elements du dictionnaire : %s " % (len(conjoints))
for (cle,valeur) in conjoints.items():
print "conjoints[%s]=%s" % (cle,valeur)
# list of dictionary keys
print "liste des cles-------------"
cles=conjoints.keys()
print ("%s") % (cles)
# list of dictionary values
print "liste des valeurs------------"
valeurs=conjoints.values()
print ("%s") % (valeurs)
# key search
existe(conjoints,"Jacques")
existe(conjoints,"Lucette")
existe(conjoints,"Jean")
# deleting a key-value
del (conjoints["Jean"])
print "Nombre d'elements du dictionnaire : %s " % (len(conjoints))
print ("%s") % (conjoints)
|
Anmerkungen:
- Zeile 17: couples.items() gibt die Liste der (Schlüssel, Wert)-Paare im Wörterbuch couples zurück;
- Zeile 22: conjoints.keys() gibt die Schlüssel des conjoints-Wörterbuchs zurück;
- Zeile 27: conjoints.values() gibt die Werte des conjoints-Wörterbuchs zurück;
- Zeile 7: spouses.has_key(husband) gibt True zurück, wenn der Schlüssel husband im Wörterbuch spouses vorhanden ist, andernfalls False;
- Zeile 38: Ein Wörterbuch kann in einer einzigen Zeile angezeigt werden.
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. Tupel
Programm (bases_05)
| # -*- coding=utf-8 -*-
# tuples
# initialization
tab1=(0,1,2,3,4,5)
# routes - 1
print "tab1 a %s elements" % (len(tab1))
for i in range(len(tab1)):
print "tab1[%s]=%s" % (i, tab1[i])
# routes - 2
print "tab1 a %s elements" % (len(tab1))
for element in tab1:
print element
# element modification
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:
- Die 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 -*-
# 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 "multi[%s][%s]=%s" % (i1,i2,multi[i1][i2])
# multidimensional dictionaries
# initialization
multi={"zero":[0,1], "un":[10,11,12,13], "deux":[20,21,22,23,24]}
# route
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 Zeichenketten und Listen
Programm (bases_07)
# -*- coding=Utf-8 -*-
# chaîne vers liste
chaine='1:2:3:4'
tab=chaine.split(':')
print type(tab)
# affichage liste
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)
# liste vers chaîne
chaine2=":".join(tab)
print "chaine2=%s" % (chaine2)
# ajoutons un champ vide
chaine+=":"
print "chaine=%s" % (chaine)
tab=chaine.split(":")
# affichage liste
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)
# ajoutons de nouveau un champ vide
chaine+=":"
print "chaine=%s" % (chaine)
tab=chaine.split(":")
# affichage liste
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)
Anmerkungen:
- Zeile 5: Die Methode
string.split(separator) teilt die Zeichenkette string in durch *separator getrennte Elemente auf und gibt diese als Liste zurück. So gibt der Ausdruck '1:2:3:4'.split(":")* die Liste ('1','2','3','4') zurück;
- Zeile 13: 'separator'.join(list) gibt die Zeichenkette 'list[0]+separator+list[1]+separator+...' zurück.
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):
# compares chain chain with model chain
# displaying results
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)
# 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
modele=r"^.*?(\d+).*?$"
# the chain is compared with the
compare(modele,"xyz1234abcd")
compare(modele,"12 34")
compare(modele,"abcd")
# the model: a sequence of numbers surrounded by any characters
# we want the sequence of digits and the fields that follow and precede them
modele=r"^(.*?)(\d+)(.*?)$"
# the chain is compared with the
compare(modele,"xyz1234abcd")
compare(modele,"12 34")
compare(modele,"abcd")
# the template - a date in dd/mm/yy format
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")
# the model - a decimal number
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")
# end
|
Anmerkungen:
- Beachten Sie das in Zeile 3 importierte Modul. 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;
- ^(.*?)(\d+)(.*?)$, ist match.groups() ein Tupel mit drei 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. Modus der Funktionsparameterübergabe
Programm (bases_10)
| # -*- coding=utf-8 -*-
def f1(a):
a=2
def f2(a,b):
a=2
b=3
return (a,b)
# ------------------------ hand
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
Anmerkungen:
- In Python ist alles ein Objekt. Manche 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 Argumente an Funktionen übergeben werden, werden ihre 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. Wir möchten, dass der tatsächliche Parameter einer Funktion durch die Funktion verändert wird;
- Zeilen 3–4: Die Funktion f1 verändert ihren formalen Parameter a. Wir wollen wissen, ob auch der tatsächliche Parameter verä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 verändert ihre formalen Parameter a und b und gibt sie als Ergebnisse zurück;
- Zeilen 15–16: Die tatsächlichen Parameter (x, y) werden an f2 übergeben, und das Ergebnis von f2 wird (x, y) zugewiesen. Zeile 2 der Ergebnisse zeigt, dass die tatsächlichen Parameter (x, y) geändert wurden.
Wir schließen daraus, dass „unveränderliche“ Objekte, wenn sie Ausgabeparameter sind, Teil der von der Funktion zurückgegebenen Ergebnisse sein müssen.
3.7. Textdateien
Programm (bases_11)
| # -*- coding=utf-8 -*-
import sys
# sequential operation of a text file
# this is a set of lines of the form login:pwd:uid:gid:infos:dir:shell
# each line is put into a dictionary in the form login => [uid,gid,infos,dir,shell]
# --------------------------------------------------------------------------
def afficheInfos(dico,cle):
# displays the value associated with key in the dico dictionary if it exists
valeur=None
if dico.has_key(cle):
valeur=dico[cle]
if 'list' in str(type(valeur)):
print "[{0},{1}]".format(cle,":".join(valeur))
else:
# key is not a dictionary key dico
print "la cle [{0}] n'existe pas".format(cle)
def cutNewLineChar(ligne):
# delete the end-of-line mark if it exists
l=len(ligne);
while(ligne[l-1]=="\n" or ligne[l-1]=="\r"):
l-=1
return(ligne[0:l]);
# set the file name
INFOS="infos.txt"
# we open it in creation
try:
fic=open(INFOS,"w")
except:
print "Erreur d'ouverture du fichier INFOS en écriture\n"
sys.exit()
# generate arbitrary content
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")
# close the file
fic.close()
# open it for reading
try:
fic=open(INFOS,"r")
except:
print "Erreur d'ouverture du fichier INFOS en écriture\n"
sys.exit()
# empty dictionary at start
dico={}
# line reading
ligne=fic.readline()
while(ligne!=''):
# remove the end-of-line character
ligne=cutNewLineChar(ligne)
# put the line in a table
infos=ligne.split(":")
# retrieve login
login=infos[0]
# remove the first two elements [login,pwd]
infos[0:2]=[]
# create a dictionary entry
dico[login]=infos
# line reading
ligne=fic.readline()
# close the file
fic.close()
# using the dictionary
afficheInfos(dico,"login10")
afficheInfos(dico,"X")
|
Hinweise:
- Zeile 37: um das Skript mitten im Code 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
Bildschirmausgabe:
| [login10,uid10:gid10:infos10:dir10:shell10]
la cle [X] n'existe pas
|
