Skip to content

3. Nozioni di base

  

3.1. Un esempio di programma Python

Di seguito è riportato un programma che illustra le funzionalità di base di Python.

Il programma (bases_01)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#    -*- 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

Nota:

  • riga 1: un commento speciale utilizzato per dichiarare il tipo di codifica dello script, in questo caso UTF-8. Questo dipende dall'editor di testo utilizzato. Qui con Notepad++:
 
  • riga 4: la parola chiave def definisce una funzione;
  • righe 5-6: il corpo della funzione. È indentato di un tabulatore a destra. Questa indentazione, combinata con i due punti (:) nell'istruzione def, definisce il corpo della funzione. Questo vale per tutte le istruzioni con un corpo: if, else, while, for, try, except;
  • riga 12: Python gestisce i tipi di variabili internamente. È possibile determinare il tipo di una variabile utilizzando la funzione type(variable)*, che restituisce una variabile di tipo 'type'. L'espressione '%s' % (type(variable))* è una stringa che rappresenta il tipo della variabile;
  • riga 25: il programma principale. Questo viene dopo la definizione di tutte le funzioni dello script. Il suo contenuto non è indentato;
  • Riga 28: In Python non si dichiarano le variabili. Python distingue tra maiuscole e minuscole. La variabile Nom è diversa dalla variabile nom*. Una stringa può essere racchiusa tra virgolette doppie " o virgolette singole '. Quindi è possibile scrivere 'dupont' o "dupont*";
  • riga 31: l'espressione "xxxx%syyyy%szzzz" % (100, 200) è la stringa "xxxx100yyy200szzzz" dove ogni %s è stato sostituito da un elemento della tupla. %s è il specificatore di formattazione della stringa. Esistono altri formati;
  • riga 34: c'è una differenza tra una tupla (1,2,3) (notare le parentesi) e una lista [1,2,3] (notare le parentesi quadre). La tupla è immutabile, mentre la lista è mutabile. In entrambi i casi, l'elemento numero i è indicato da [i];
  • riga 40: range(n) è la tupla (0,1,2,...,n-1);
  • riga 74: len(var) è il numero di elementi nella collezione var (tupla, lista, dizionario, ...);
  • riga 86: gli altri operatori booleani sono or e not.

L'output sullo schermo è il seguente:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
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. Conversioni di tipo

Qui ci concentriamo sulle conversioni di tipo che coinvolgono dati di tipo str (stringa), int (intero), float (virgola mobile) e bool (booleano).

Il programma (bases_01b)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
#   -*- 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)

Sono possibili molte conversioni di tipo. Alcune potrebbero fallire, come quelle nelle righe 45–49, che tentano di convertire la stringa 'abc' in un numero intero. Abbiamo gestito l'errore utilizzando un blocco try/except. Una forma generale di questo blocco è la seguente:


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

Se una qualsiasi delle azioni all'interno del blocco try genera un'eccezione (segnala un errore), il controllo passa immediatamente alla clausola **except. Se le azioni all'interno del blocco try non generano un'eccezione, la clausola except viene ignorata. Gli attributi Exception e Message dell'istruzione except sono facoltativi. Quando presenti, Exception specifica il tipo di eccezione intercettata dall'istruzione except, mentre Message contiene il messaggio di errore associato all'eccezione. È possibile avere più istruzioni except se si desidera gestire diversi tipi di eccezioni all'interno dello stesso blocco try.

L'istruzione finally è facoltativa. Se presente, le azioni nel blocco finally vengono sempre eseguite, indipendentemente dal fatto che si sia verificata o meno un'eccezione.

Torneremo sulle eccezioni più avanti.

Le righe 52–61 mostrano vari tentativi di convertire dati di tipo str, int, float e NoneType in booleani. Ciò è sempre possibile. Le regole sono le seguenti:

  • bool(int i) è False se i è 0, True in tutti gli altri casi;
  • bool(float f) è False se f è 0.0, True in tutti gli altri casi;
  • bool(str string) è False se string ha 0 caratteri, True in tutti gli altri casi;
  • bool(None) è False. None è un valore speciale che indica che la variabile esiste ma non ha alcun valore.

L'output sullo schermo è il seguente:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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. L'ambito delle variabili

Programma (bases_02)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#    -*- 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)

Risultati

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

Note:

  • Lo script illustra l'uso della variabile i, dichiarata come globale nelle funzioni f1 e f2. In questo caso, il programma principale e le funzioni f1 e f2 condividono la stessa variabile i.

3.4. Liste, tuple e dizionari

3.4.1. Liste unidimensionali

Programma (bases_03)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#   -*- 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)

Note:

  • la notazione array[i:j] si riferisce agli elementi da i a j-1 dell'array;
  • la notazione [i:] si riferisce all'elemento i e agli elementi successivi dell'array;
  • la notazione [:i] si riferisce agli elementi da 0 a i-1 della lista;
  • La riga 20: print (%s) % (list1) visualizza la stringa: "[ list1[0], list1[2], ..., list1[n-1]]".

Risultati

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
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]

Il codice precedente può essere scritto in modo diverso (bases_03b) utilizzando alcuni metodi di lista:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#   -*- 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)

I risultati sono gli stessi della versione precedente.

3.4.2. Il dizionario

Il programma (bases_04)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#    -*- 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)

Note:

  • riga 17: couples.items() restituisce l'elenco delle coppie (chiave, valore) nel dizionario couples;
  • riga 22: conjoints.keys() restituisce le chiavi del dizionario conjoints;
  • riga 27: conjoints.values() restituisce i valori del dizionario conjoints;
  • riga 7: spouses.has_key(husband) restituisce True se la chiave husband esiste nel dizionario spouses, False in caso contrario;
  • riga 38: un dizionario può essere visualizzato su una singola riga.
Risultati
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
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. Tuple

Programma (bases_05)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
#   -*- 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

I risultati
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
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

Note:

  • Le righe 15-18 dei risultati: mostrano che una tupla non può essere modificata.

3.4.4. Elenchi multidimensionali

Programma (bases_06)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
#   -*- 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])
Risultati
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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. Collegamenti tra stringhe e liste

Programma (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)

Note:

  • riga 5: il metodo string.split(separator) divide la stringa string in elementi separati da separator e li restituisce come una lista. Pertanto, l'espressione '1:2:3:4'.split(":") restituisce la lista ('1','2','3','4');
  • riga 13: 'separator'.join(list) restituisce la stringa 'list[0]+separator+list[1]+separator+...'.
Risultati
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
<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. Espressioni regolari

Programma (bases_09)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#    -*- 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

Note:

  • Si noti il modulo importato alla riga 3. Contiene le funzioni per la gestione delle espressioni regolari;
  • riga 10: il confronto di una stringa con un'espressione regolare (pattern) restituisce True se la stringa corrisponde al pattern, False in caso contrario;
  • riga 12: match.groups() è una tupla i cui elementi sono le parti della stringa che corrispondono agli elementi dell'espressione regolare racchiusi tra parentesi. Nel pattern:
  • ^.*?(\d+).*?, match.groups() sarà una tupla a un elemento;
  • ^(.*?)(\d+)(.*?)$, match.groups() sarà una tupla a 3 elementi.
Risultati
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
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. Modalità di passaggio dei parametri di funzione

Programma (bases_10)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
#    -*- 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)
Risultati
1
2
x=1
x=2, y=3

Note:

  • In Python tutto è un oggetto. Alcuni oggetti sono detti "immutabili": non possono essere modificati. È il caso dei numeri, delle stringhe e delle tuple. Quando gli oggetti Python vengono passati come argomenti alle funzioni, sono i loro riferimenti ad essere passati, a meno che questi oggetti non siano "immutabili", nel qual caso è il valore dell'oggetto ad essere passato;
  • Le funzioni f1 (riga 3) e f2 (riga 6) hanno lo scopo di illustrare il passaggio di un parametro di output. Vogliamo che il parametro effettivo di una funzione venga modificato dalla funzione;
  • Righe 3–4: La funzione f1 modifica il suo parametro formale a. Vogliamo sapere se anche il parametro effettivo verrà modificato.
  • righe 12–13: il parametro effettivo è x = 1. Il risultato della riga 1 mostra che il parametro effettivo non viene modificato. Pertanto, il parametro effettivo x e il parametro formale a sono due oggetti diversi;
  • righe 6–9: la funzione f2 modifica i suoi parametri formali a e b e li restituisce come risultati;
  • righe 15–16: i parametri effettivi (x, y) vengono passati a f2 e il risultato di f2 viene assegnato a (x, y). La riga 2 dei risultati mostra che i parametri effettivi (x, y) sono stati modificati.

Concludiamo che quando gli oggetti "immutabili" sono parametri di output, devono far parte dei risultati restituiti dalla funzione.

3.7. File di testo

Programma (bases_11)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#    -*- 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")

Note:

  • Riga 37: per terminare lo script a metà del codice.
Risultati

Il file 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

Output dello schermo:

1
2
[login10,uid10:gid10:infos10:dir10:shell10]
la cle [X] n'existe pas
https://stahe.github.io
Questo tutorial scritto da Serge Tahé è reso disponibile al pubblico secondo i termini della Creative Commons Attribuzione – Non commerciale – ShareAlike 3.0 Unported.