3. De basis

3.1. Een voorbeeld van een Python-programma

Hieronder staat een programma dat de eerste kenmerken van Python laat zien.

Het programma (bases_01)


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

# ----------------------------------
def affiche(chaine):
    # geeft een tekenreeks weer
    print "chaine=%s" % (chaine)


# ----------------------------------
def afficheType(variable):
    # geeft het type van de variabele weer
    print "type[%s]=%s" % (variable,type(variable))

# ----------------------------------
def f1(param):
    # voegt 10 toe aan parameter
    return param+10

# ----------------------------------
def f2():
    # geeft 3 waarden weer
    return ("un",0,100);


# -------------------------------- hoofdprogramma ------------------------------------
# dit is een opmerking
# variabele gebruikt zonder te zijn gedeclareerd
nom="dupont"

# een schermweergave
print "nom=%s" % (nom)

# een lijst met elementen van verschillende typen
liste=["un","deux",3,4]

# het aantal elementen
n=len(liste)

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

# initialisatie van 2 variabelen met een tuple
(chaine1,chaine2)=("chaine1","chaine2")

# samenvoeging van de 2 strings
chaine3=chaine1+chaine2

# weergave van het resultaat
print "[%s,%s,%s]" % (chaine1,chaine2,chaine3)

# gebruik van een functie
affiche(chaine1)

# het type van een variabele kan bekend zijn
afficheType(n)
afficheType(chaine1)
afficheType(liste)

# het type van een variabele kan tijdens de uitvoering veranderen
n="a change"
afficheType(n)

# een functie kan een resultaat retourneren
res1=f1(4)
print "res1=%s" % (res1)

# een functie kan een lijst met waarden retourneren
(res1,res2,res3)=f2()
print "(res1,res2,res3)=[%s,%s,%s]" % (res1,res2,res3)

# deze waarden hadden in een variabele kunnen worden opgeslagen
liste=f2()
for i in range(len(liste)):
    print "liste[%s]=%s" % (i, liste[i])

# tests
for i in range(len(liste)):
    # geeft alleen de tekenreeksen weer
    if (type(liste[i])=="str"):
        print "liste[%s]=%s" % (i,liste[i])

# nog meer tests
for i in range(len(liste)):
    # geeft alleen gehele getallen >10 weer
    if (type(liste[i])=="int" and liste[i]>10):
        print "liste[%s]=%s" % (i,liste[i])

# een while-lus
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] #som=som+t[i]
    i+=1 #i = i + 1
print "somme=%s" % (somme)
# einde programma

Let op:

regel 1: een speciale opmerking die dient om het coderingstype van het script aan te geven, in dit geval UTF-8. Dit is afhankelijk van de gebruikte teksteditor. Hier met Notepad++:

regel 4: het sleutelwoord def definieert een functie;
regels 5-6: de inhoud van de functie. Deze is één tab naar rechts ingesprongen. Het is deze inspringing in combinatie met het teken : van de instructie def die de inhoud van de functie definieert. Dit geldt voor alle instructies met inhoud: if, else, while, for, try, except;
regel 12: Python beheert het type van variabelen intern. Je kunt het type van een variabele achterhalen met de functie type(variable), die een variabele van het type 'type' retourneert. De uitdrukking '%s' % (type(variabele)) is een tekenreeks die het type van de variabele weergeeft;
regel 25: het hoofdprogramma. Dit volgt na de definitie van alle functies in het script. De inhoud ervan is niet ingesprongen;
regel 28: in Python hoef je variabelen niet te declareren. Python is hoofdlettergevoelig. De variabele Nom is anders dan de variabele nom. Een tekenreeks kan worden omsloten door aanhalingstekens " of apostrofs '. Je kunt dus 'dupont' of "dupont" schrijven;
regel 31: de uitdrukking "xxxx%syyyy%szzzz" % (100, 200) is de tekenreeks "xxxx100yyy200szzzz", waarbij elke %s is vervangen door een element van het tupel. %s is het weergaveformaat voor tekenreeksen. Er bestaan nog andere formaten;
regel 34: er is een verschil tussen een tuple (1,2,3) (let op de ronde haakjes) en een lijst [1,2,3] (let op de vierkante haakjes). Het tuple is niet-wijzigbaar, terwijl de lijst dat wel is. In beide gevallen wordt element nr. i aangeduid als [i];
regel 40: range(n) is het tupel (0,1,2,...,n-1);
regel 74: len(var) is het aantal elementen van de verzameling var (tuple, lijst, woordenboek, ...);
regel 86: de andere booleaanse operatoren zijn or en not.

De schermresultaten zijn als volgt:

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. Typeveranderingen

We richten ons hier op typewijzigingen met gegevens van het type str (tekenreeks), int (geheel getal), float (reëel getal) en bool (booleaanse waarde).

Het programma (bases_01b)


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

# typeomzettingen
# 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)

# afhandeling van fouten bij typeconversie
try:
    x=int("abc")
    print x, type(x)
except ValueError, erreur:
    print erreur

# diverse gevallen van booleaanse waarden
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)

Er zijn talrijke typeconversies mogelijk. Sommige kunnen mislukken, zoals die in de regels 45-49, waarin wordt geprobeerd de tekenreeks 'abc' om te zetten in een geheel getal. De fout is afgehandeld met een structuur try / except. Een algemene vorm van deze structuur is als volgt:


try:
    actions
except Exception, Message:
    actions
finally:
    actions

Als een van de acties in de try-blok een uitzondering genereert (een fout signaleert), wordt onmiddellijk overgeschakeld naar de except-clausule. Als de acties in de try-blok geen uitzondering genereren, wordt de except-clausule genegeerd. De attributen Exception en Message van de instructie except zijn optioneel. Wanneer ze aanwezig zijn, specificeert Exception het type uitzondering dat door de instructie except wordt opgevangen en bevat Message de foutmelding die bij de uitzondering hoort. Er kunnen meerdere except-instructies zijn, als men verschillende soorten uitzonderingen in dezelfde try wil afhandelen.

De instructie finally is optioneel. Als deze aanwezig is, worden de acties van de finally altijd uitgevoerd, ongeacht of er een uitzondering is opgetreden of niet.

We komen later nog terug op de uitzonderingen.

De regels 52-61 tonen verschillende pogingen om gegevens van het type str, int, float en NoneType om te zetten in een booleaanse waarde. Dit is altijd mogelijk. De regels zijn als volgt:

bool(int i) is gelijk aan False als i gelijk is aan 0, en aan True in alle andere gevallen;
bool(float f) is gelijk aan False als f gelijk is aan 0,0, en aan True in alle andere gevallen;
bool(str string) is gelijk aan False als string 0 tekens bevat, en aan True in alle andere gevallen;
bool(None) is False. None is een speciale waarde die aangeeft dat de variabele bestaat maar geen waarde heeft.

De uitvoer op het scherm is als volgt:

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. Het bereik van variabelen

Programma (bases_02)


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

# bereik van variabelen
def f1():
    # we gebruiken de globale variabele i
    global i
    i+=1
    j=10
    print "f1[i,j]=[%s,%s]" % (i,j)

def f2():
    # we gebruiken de globale variabele i
    global i
    i+=1
    j=20
    print "f2[i,j]=[%s,%s]" % (i,j)

def f3():
    # er wordt een lokale variabele i gebruikt
    i=1
    j=30
    print "f3[i,j]=[%s,%s]" % (i,j)
  
# tests
i=0
j=0 # deze twee variabelen zijn alleen bekend in een functie f
    # dan alleen als deze expliciet wordt gedeclareerd met de instructie global
    # dat ze deze wil gebruiken
f1()
f2()
f3()
print "test[i,j]=[%s,%s]" % (i,j)

Resultaten

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

Opmerkingen:

het script toont het gebruik van de variabele i, die in de functies f1 en f2 als globale variabele is gedeclareerd. In dit geval delen het hoofdprogramma en de functies f1 en f2 dezelfde variabele i.

3.4. Lijsten, tuples en woordenboeken

3.4.1. Eéndimensionale lijsten

Programma (bases_03)


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

# eendimensionale lijsten
# initialisatie
list1=[0,1,2,3,4,5]

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

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

# twee elementen toevoegen
list1[len(list1):]=[10,11]
print ("%s") % (list1)

# verwijdering van de laatste twee elementen
list1[len(list1)-2:]=[]
print ("%s") % (list1)

# een tuple toevoegen aan het begin van de lijst
list1[:0]=[-10, -11, -12]
print ("%s") % (list1)

# twee elementen in het midden van de lijst invoegen
list1[3:3]=[100,101]
print ("%s") % (list1)

# verwijdering van twee elementen in het midden van de lijst
list1[3:4]=[]
print ("%s") % (list1)

Opmerkingen:

de notatie array[i:j] verwijst naar de elementen i tot en met j-1 van de array;
de notatie [i:] verwijst naar de elementen vanaf i van de matrix;
de notatie [:i] verwijst naar de elementen 0 tot en met i-1 van de array;
regel 20: print (%s) % (list1) geeft de tekenreeks weer: "[ list1[0], list1[2], ..., list1[n-1]]".

Resultaten

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]

De bovenstaande code kan anders worden geschreven (bases_03b) door gebruik te maken van bepaalde methoden van de lijsten:


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

# eendimensionale lijsten

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

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

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

# twee elementen toevoegen
list1.extend([10,11])
print ("%s") % (list1)

# verwijdering van de laatste twee elementen
del list1[len(list1)-2:]
print ("%s") % (list1)

# een tuple toevoegen aan het begin van de lijst
for i in (-12, -11, -10):
    list1.insert(0,i)
print ("%s") % (list1)

# invoegen in het midden van de lijst
for i in (101,100):
    list1.insert(3,i)
print ("%s") % (list1)

# verwijdering in het midden van de lijst
del list1[3:4]
print ("%s") % (list1)

De verkregen resultaten zijn dezelfde als bij de vorige versie.

3.4.2. Het woordenboek

Het programma (bases_04)


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

def existe(conjoints,mari):
    # controleert of de sleutel 'mari' voorkomt in het woordenboek 'conjoints'
    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
# woordenboeken
conjoints={"Pierre":"Gisele", "Paul":"Virginie", "Jacques":"Lucette","Jean":""}

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

# lijst met sleutels uit het woordenboek
print "liste des cles-------------"
cles=conjoints.keys()
print ("%s") % (cles)

# lijst met woordenboekwaarden
print "liste des valeurs------------"
valeurs=conjoints.values()
print ("%s") % (valeurs)

# zoeken naar een sleutel
existe(conjoints,"Jacques")
existe(conjoints,"Lucette")
existe(conjoints,"Jean")

# een sleutel-waarde verwijderen
del (conjoints["Jean"])
print "Nombre d'elements du dictionnaire : %s " % (len(conjoints))
print ("%s") % (conjoints)

Opmerkingen:

regel 17: conjoints.items() geeft de lijst met (sleutel, waarde)-paren van het woordenboek als samenvoegingen weer;
regel 22: conjoints.keys() geeft de sleutels van het woordenboek conjoints weer;
regel 27: conjoints.values() geeft de waarden van het woordenboek ‘conjoints’ weer;
regel 7: conjoints.has_key(mari) retourneert True als de sleutel mari voorkomt in het woordenboek conjoints, False anders;
regel 38: een woordenboek kan in één regel worden weergegeven.

De resultaten

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. De tuples

Programma (bases_05)


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

# tuples
# initialisatie
tab1=(0,1,2,3,4,5)

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

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

# wijziging van een element
tab1[0]=-1

De resultaten

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

Opmerkingen:

regels 15-18 van de resultaten: laten zien dat een tuple niet kan worden gewijzigd.

3.4.4. Meerdimensionale lijsten

Programma (bases_06)


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

# meerdimensionale lijsten

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

# doorloop
for i1 in range(len(multi)):
    for i2 in range(len(multi[i1])):
        print "multi[%s][%s]=%s" % (i1,i2,multi[i1][i2])

# multidimensionale woordenboeken
# initialisatie
multi={"zero":[0,1], "un":[10,11,12,13], "deux":[20,21,22,23,24]}

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

Resultaten

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. Koppelingen tussen reeksen en lijsten

Programma (bases_07)


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

# reeks naar lijst
chaine='1:2:3:4'
tab=chaine.split(':')
print type(tab)

# lijst weergeven
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

# van lijst naar tekenreeks
chaine2=":".join(tab)
print "chaine2=%s" % (chaine2)

# een leeg veld toevoegen
chaine+=":"
print "chaine=%s" % (chaine)
tab=chaine.split(":")

# lijst weergeven
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

# laten we opnieuw een leeg veld toevoegen
chaine+=":"
print "chaine=%s" % (chaine)
tab=chaine.split(":")

# lijst weergeven
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

Opmerkingen:

regel 5: de methode chaine.split(scheidingsteken) splitst de tekenreeks chaine op in elementen die worden gescheiden door séparateur en geeft deze weer in de vorm van een lijst. De uitdrukking '1:2:3:4'.split(":") heeft dus als waarde de lijst ('1','2','3','4');
regel 13: 'separateur'.join(liste) heeft als waarde de tekenreeks 'lijst[0]+scheidingsteken+lijst[1]+scheidingsteken+...'.

Resultaten

<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. Reguliere expressies

Programma (bases_09)


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

import re

# --------------------------------------------------------------------------
def compare(modele,chaine):
    # vergelijkt de tekenreeks 'chaîne' met het patroon 'modele'
    # resultaten weergeven
    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)


# reguliere expressies in Python
# de verschillende velden van een tekenreeks ophalen
# het patroon: een reeks cijfers omgeven door willekeurige tekens
# we willen alleen de reeks cijfers ophalen
modele=r"^.*?(\d+).*?$"

# we vergelijken de tekenreeks met het patroon
compare(modele,"xyz1234abcd")
compare(modele,"12 34")
compare(modele,"abcd")

# het patroon: een reeks cijfers omgeven door willekeurige tekens
# we willen de reeks cijfers en de velden ervoor en erna
modele=r"^(.*?)(\d+)(.*?)$"

# we vergelijken de tekenreeks met het patroon
compare(modele,"xyz1234abcd")
compare(modele,"12 34")
compare(modele,"abcd")

# het patroon: een datum in de notatie dd/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")

# het patroon – een decimaal getal
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")
# einde

Opmerkingen:

let op de geïmporteerde module in regel 3. Deze bevat de functies voor het beheer van reguliere expressies;
regel 10: de vergelijking van een tekenreeks met een reguliere uitdrukking (patroon) levert de booleaanse waarde True op als de tekenreeks overeenkomt met het patroon, en False anders;
regel 12: match.groups() is een tuple waarvan de elementen de delen van de tekenreeks zijn die overeenkomen met de elementen van de reguliere expressie die tussen haakjes staan. In het patroon:
^.*?(\d+).*?, is match.groups() een tuple met één element;
^(.*?)(\d+)(.*?)$, match.groups() is een tuple met 3 elementen.

Resultaten

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. Wijze van doorgeven van functieparameters

Programma (bases_10)


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

def f1(a):
    a=2

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

Resultaten

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

Opmerkingen:

in Python is alles een object. Sommige objecten worden „onveranderlijk“ genoemd: ze kunnen niet worden gewijzigd. Dit geldt voor getallen, tekenreeksen en tuples. Wanneer Python-objecten als parameters aan functies worden doorgegeven, worden hun verwijzingen doorgegeven, tenzij deze objecten „onveranderlijk“ zijn; in dat geval wordt de waarde van het object doorgegeven;
de functies f1 (regel 3) en f2 (regel 6) zijn bedoeld om het doorgeven van een uitvoerparameter te illustreren. We willen dat de daadwerkelijke parameter van een functie door de functie wordt gewijzigd;
regels 3-4: de functie f1 wijzigt haar formele parameter a. We willen weten of de werkelijke parameter ook zal worden gewijzigd.
regels 12-13: de werkelijke parameter is x=1. Het resultaat van regel 1 laat zien dat de werkelijke parameter niet wordt gewijzigd. De werkelijke parameter x en de formele parameter a zijn dus twee verschillende objecten;
regels 6-9: de functie f2 wijzigt haar formele parameters a en b en geeft deze als resultaten terug;
regels 15-16: de effectieve parameters (x,y) worden doorgegeven aan f2 en het resultaat van f2 wordt teruggeplaatst in (x,y). Regel 2 van de resultaten laat zien dat de effectieve parameters (x,y) zijn gewijzigd.

Hieruit volgt dat wanneer „onveranderlijke” objecten als uitgangsparameters fungeren, deze deel moeten uitmaken van de door de functie geretourneerde resultaten.

3.7. De tekstbestanden

Programma (bases_11)


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

import sys

# sequentiële verwerking van een tekstbestand
# dit is een verzameling regels in de vorm login:pwd:uid:gid:infos:dir:shell
# elke regel wordt in een woordenboek opgeslagen in de vorm login => [uid,gid,infos,dir,shell]

# --------------------------------------------------------------------------
def afficheInfos(dico,cle):
    # geeft de waarde weer die aan de sleutel in het woordenboek ‘dico’ is gekoppeld, indien deze bestaat
    valeur=None
    if dico.has_key(cle):
        valeur=dico[cle]
    if 'list' in str(type(valeur)):
        print "[{0},{1}]".format(cle,":".join(valeur))
    else:
        # de sleutel komt niet voor in het woordenboek 'dico'
        print "la cle [{0}] n'existe pas".format(cle)           


def cutNewLineChar(ligne):
    # de regeleinde-markering wordt verwijderd, indien deze aanwezig is
    l=len(ligne);
    while(ligne[l-1]=="\n" or ligne[l-1]=="\r"):
        l-=1
    return(ligne[0:l]);
    
# de bestandsnaam wordt vastgelegd
INFOS="infos.txt"

# het bestand wordt geopend in de modus ‘aanmaken’
try:
    fic=open(INFOS,"w")
except:
    print "Erreur d'ouverture du fichier INFOS en écriture\n"
    sys.exit()

# er wordt willekeurige inhoud gegenereerd
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")

# het bestand wordt gesloten
fic.close()

# het bestand wordt geopend in de leesmodus
try:
    fic=open(INFOS,"r")
except:
    print "Erreur d'ouverture du fichier INFOS en écriture\n"
    sys.exit()

# het woordenboek is aanvankelijk leeg
dico={}

# een regel lezen  
ligne=fic.readline()  
while(ligne!=''):
    # het einde-van-regel-teken wordt verwijderd
    ligne=cutNewLineChar(ligne)
  
    # de regel wordt in een array geplaatst
    infos=ligne.split(":")
  
    # de login wordt opgehaald
    login=infos[0]
  
    # de eerste twee elementen verwijderen [login,pwd]
    infos[0:2]=[]
  
    # er wordt een vermelding in het woordenboek aangemaakt
    dico[login]=infos
  
    # een regel lezen  
    ligne=fic.readline()  

# het bestand wordt gesloten
fic.close()

# het woordenboek verwerken
afficheInfos(dico,"login10")
afficheInfos(dico,"X")

Opmerkingen:

regel 37: om het script halverwege de code te beëindigen.

Resultaten

Het bestand 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

De schermresultaten:

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