Comme les chaînes de caractères, parfois nous voulons une chaîne de int ou une chaîne d'autre chose. En Python ces « chaînes » sont des listes (de type list), une suite de valeurs quelconque.
Une liste est donc une structure de données qui contient une série de valeurs.
Les valeurs contenus ne sont pas forcément du même type.
Une liste est crée par une série de valeurs séparées par des virgules, et le tout encadré par des crochets:
liste2 a été réassignée mais pas liste1 alors que sa valeur a changée! Essayez le même exercice avec d'autre types, str par exemple.
Attention: certaines opérations renvoient des nouvelles listes alors que d'autre modifient la variable.
Type tuple
Un cousin des lists sont les tuples. La différence entre les deux est que les tuples ne sont pas mutable. Sinon leur fonctionnement est presque identique.
Un tuple est créé par des parenthèses au lieu de crochets.
>>> t = (1, 'a', 2)
>>> t
(1, 'a', 2)
>>> t[1]
'a'>>> t2 = (1,)
>>> t2
(1,)
Il faut au moins une virgule pour créer un tuple.
Unpacking
Pour des lists et surtout des tuples qui sont courts, on cherche souvent à stocker les entrées dans des variables séparées.
>>> animaux = ['girafe', 'hippopotame', 'singe']
>>> a = animaux[0]
>>> b = animaux[1]
>>> c = animaux[2]
Le même résultat peut être obtenu par un déballage (unpacking).
>>> animaux = ['girafe', 'hippopotame', 'singe']
>>> a, b, c = animaux
La syntaxe est donc
variable1, variable2, ... = la_liste
Opérations sur list et tuple (avancé)
D'autre opérations qui sont des mutations les lists: append, extend, insert, pop, remove, reverse et sort.
l =range(5)
l.append(10)
l2 = ('a', 1)
l.extend(l2)
l.remove(1)
element = l.pop()
premier_element = l.pop(0)
l.reverse()
l.sort()
Attention: Ces opérations évaluent à rien (None). Une erreur récurrente est d'appeler l2 = l.append(10). Cela met l2 à None. Et l'erreur inverse: l1 + l2 (érroné) au lieu de l1 = l1 + l2 (correcte).
D'autre opérations sur les lists et tuples: index et count.
Compréhension de liste (très? avancé)
Un motif récurrent d'initialisation d'une liste est sa création par une boucle.
carres = []
for i inrange(10):
carres.append(i*i)
Dans l'intérêt de la lisibilité du programme, une nouvelle syntaxe a été ajoutée.
carres = [i*i for i inrange(10)]
carres_impairs = [i*i for i inrange(10) if i%2==1]
La syntaxe est
[expression for variable in une_liste]
[expression for variable in une_liste if condition]
Cette écriture ressemble à la notation d'ensemble en mathématiques.
Les fonctions
Définition d’une fonction
Rappel: Nous avons déjà vu comment faire appel à des fonctions eixstantes.
Nous allons maintenant voir comment définir de nouvelles fonctions.
Les fonctions est un autre outil de contrôle du flux d'instructions. Ils permettent de décomposer les programmes en sous-programmes et de réutiliser des morceaux de programmes.
Exemple de définition d’une fonction
def compter_lettre(lettre, texte):
n=0for c in texte :
if c == lettre :
n +=1return"nombre d'occurences de la lettre %s : %s"\% (lettre, n)
print compter_lettre('e', 'je reviens')
Une instruction return valeur dans le bloc d’instructions définissant une fonction provoque la fin d’exécution de la fonction avec le retour de la valeur de l’expression qui suit.
Remarque(avancée): Une fois définie, une fonction peut être manipulée comme tout autre variable!
>>>print compter_lettre
<function compter_lettre at 0x7f485e9d45f0>>>>type(compter_lettre)
<type'function'>
Appel d’une fonction
Une fois qu’une fonction f a été définie, elle peut être utilisée dans une expression particulière qu’on nomme un appel de fonction et qui a la forme f(v1,v2,...,vn), où v1, v2, …, vn sont des expressions dont la valeur est transmise au paramètres.
Cela veut dire que d'abord parametre1 est assigné la valeur v1, parametre2 est assigné la valeur v2, et ainsi de suite. Ensuite le bloc d'instruction est exécuté ligne par ligne, jusqu'à la fin du bloc ou une instruction return.
Si la fin du bloc est atteint, la valeur None est retournée.
Paramètres par défaut
Python offre un mécanisme d’instanciation des paramètres par défaut. On peut écrire la liste des paramètres en entête d’une définition de fonction. Par exemple
>>>def pluriel(mot, famille ='standard'):
... if famille =='standard':
... return mot +'s'
... if famille =='s':
... return mot
... if famille =='oux':
... return mot +'x'
... if famille =='al':
... return mot[:-1] +'ux'>>>print pluriel('maison')
'maisons'>>>print pluriel('souris', 's')
'souris'>>>print pluriel('chou', 'oux')
'choux'>>>print pluriel('cheval', 'al')
'chevaux'
Les k premiers paramètres doivent obligatoirement être précisés à l’appel de fonction mais pas les n derniers. L’appel de fonction se fait donc avec k arguments au minimum et k+n arguments au maximum. Si un paramètre d_i n’est pas instancié explicitement, il prend la valeur par défaut de expr_i.
Il est possible d'instancier certain paramètre et pas d'autre. Par exemple, avec un appel pluriel(p_1, ..., p_k, d_4 = 10). d_4 prends la valeur 10 au lieu de expr_4.
Variables locales et variables globales
Les variables qui sont introduites dans la définition d’une fonction peuvent être utilisées dans la suite de la définition mais pas à l’extérieur de la fonction.
Ces variables sont dites locales par opposition aux variables globales qui sont introduites à l’extérieur de la définition d’une fonction et qui peuvent être utilisées à l’intérieur comme à l’extérieur de cette définition.
Lorsque le même nom est utilisé pour introduire une variable locale et une variable globale, Python distingue bien deux variables différentes mais à l’intérieur de la définition de la fonction, c’est à la variable locale auquel le nom réfère.
Variables locales et variables globales
>>>def f(x):
... y=2
... return x + y
>>>print f(3)
5>>>print y
Traceback (most recent call last):
File "<pyshell#5>", line 1, in<module>print y
NameError: name 'y'isnot defined
>>> u =7>>>def g(v):
... return u * v
>>>print g(2)
14>>>def h(u):
... return u
>>>print h(3)
3>>>print u
7>>>def k(w):
... u =5
... return w+u
>>>print k(3)
8>>>print u
7