Table des matières
p-uplets et tableaux
- Le type associé au p-uplet en Python est
tuple
On peut parler de doublet pour 2-uplet, triplet pour 3-uplet, quadruplet pour 4-uplet…
Remarquez que l'on peut parler de p-uplet en général, sans forcément parler du type tuple de Python. Par exemple, si dans une base de données un individu a un nom, un prénom, un age, une adresse… Ces données forment un p-uplet.
- Le type associé au tableau en Python est
list
En informatique, une liste et un tableau ne sont pas exactement la même chose. Le type list de Python est plutôt un tableau mais un tableau très souple qui permet de faire ce que font les listes… La confusion n'est pas trop gênante pour l'instant. La distinction entre tableau et liste sera reprise en Terminale.
p-uplets et tableaux se manipulent de façon semblable. Les détails sont donnés dans le chapitre sur les séquences suivi du chapitre sur les méthodes plus avancées.
Cas des p-uplets
Les p-uplets sont signalés par des ( ) mais aussi ,
>>> t = (19, 5, 8, 3, 2, 4)
Mais on peut alléger en ôtant les parenthèses, les virgules suffisent :
>>> t = 19, 5, 8, 3, 2, 4
Le type en Python est tuple.
>>> type(t) <class 'tuple'>
Cas particulier d'un tuple à 1 élément
C'est rare, mais il peut arriver que l'on ait besoin d'un tuple ne contenant qu'un élément. Mais s'il n'y a qu'un élément, plus besoin de , et les ( ) servent à beaucoup d'autres choses…
Par exemple si je veux créer un tuple ne contenant que 4 :
>>> t = 4 # Python comprend que t est un entier >>> t = (4) # même chose >>> t = 4, # l'ajout de la virgule permet à Python de comprendre.
Donnée immuable
Un p-uplet est immuable : une fois créé, on ne peut pas le modifier.
Les tableaux sont semblables aux p-uplets mais sont mutable. Le fait de pouvoir modifier le contenu d'un tableau crée quelques difficultés. De plus, il est parfois utile d'avoir la garantie qu'une donnée ne pourra être modifiée.
Le code suivant, dans lequel on essaie de modifier le contenu d'un p-uplet, déclenche une erreur.
>>> t = 4, 5, 6 >>> t[0] = 17 TypeError: 'tuple' object does not support item assignment
Cas d'utilisation
Je donne ci-dessous quelques cas d'utilisation
Affectation multiple
Au lieu de
x = 3 y = 5 z = 8
On peut écrire
x, y, z = 3, 5, 8
Fonction à sorties multiples
Une fonction qui doit renvoyer deux quantités. Par exemple la somme et le produit de x et y.
def somme_produit(x,y):
return x + y, x * y
# utilisation
s, p = somme_produit(4,5)
print(s) # affiche 9
print(p) # affiche 20
Remarquez que dans l'exemple en ligne 5, somme_produit(4,5) renvoie le tuple 9, 20 et on a ainsi l'affectation s, p = 9, 20 qui est équivalent à s = 9 ; p = 20.
Intervertir des variables
a et b sont deux variables contenant des données éventuellement différentes et on souhaiterait intervertir les contenus de a et b. En général, on a besoin d'une 3e variable temporaire. Vous pouvez comparer cela au cas de deux bouteilles dont on souhaite intervertir le contenu. Il faut une 3e bouteille.
temp = a # copie le contenu de a dans la variable temporaire a = b # efface a pour copier le contenu de b b = c # utilise la copie car a a perdu son contenu d'origine
Un tuple permet de faire cela de façon plus rapide et plus lisible :
b, a = a, b
À droite de =, on crée un tuple contenant une copie de a et de b. Puis on utilise cette copie pour la distribuer sur b et a.
Cas des tableaux
Les tableaux sont signalés par des [ ]
>>> t = [19, 5, 8, 3, 2, 4] >>> type(t) <class 'list'>
La différence essentielle par rapport au p-uplet est que l'on peut changer le contenu d'un tableau. Comme les tableaux Python sont dynamiques, on peut même modifier leur taille.
Cela vaut la peine d'être signalé car ce n'est pas le cas dans beaucoup de langages. En C par exemple, on doit préciser la taille d'un tableau à sa création et on ne pourra pas la changer plus tard. Cette souplesse de Python se paie en termes de performances : modifier la taille du tableau peut occasionner des réorganisation des données en mémoire ce qui fait perdre du temps. De façon générale, Python n'est pas un langage performant en termes de vitesse.
Modification du contenu d'un tableau
Contentons nous ici des deux choses les plus utiles.
Modifier le contenu d'une case
>>> t = [19, 5, 8, 3, 2, 4] >>> t[3] 8 >>> t[3] = 15 # modification de la valeur >>> t[3] 15
Ajouter un élément
On utilise la commande append – ajouter.
>>> t = [] # tableau vide >>> len(t) 0 >>> t.append(17) # ajout de 17 au bout du tableau >>> len(t) 1 >>> t[0] 17 >>> t [17] >>> t.append(45) # ajout de 45 au bout du tableau >>> len(t) 2 >>> t[1] 45 >>> t [17, 45]
Remarquez la notation particulière : t.append(valeur). Cela signifie que Python, en même temps qu'il définit ce qu'est une variable de type list, définit un ensemble de méthodes qui peuvent leur être appliquées, comme la fonction append. Dans cette idée, la méthode append appartient au type list. On pourrait écrire list.append(t, valeur), mais on préfère la notation t.append(valeur).
mutable est dangereux
Le p-uplet est non mutable, le tableau est mutable. On penser que le tableau a quelque chose en plus et se demander à quoi bon le p-uplet. Dans cette section, j'essaie de vous donner une idée de l'intérêt qu'il peut y avoir dans une donnée non mutable ou des dangers d'une donnée mutable.
Voici le cas d'un entier – voir sur python tutor
def f(x):
x = x + 3
y = 12
f(y)
print(y) # affiche 12 ou 15 ?
Et voici le cas d'un tableau – voir sur python tutor.
def f(x):
x[0] = 19
y = [10, 52, 27, 48]
f(y)
print(y[0]) # affiche 10 ou 19 ?
Ce comportement est source de nombreuses erreurs et de dysfonctionnement difficiles à interpréter. Il faut donc faire attention.
Tableaux en compréhension
Un peu plus avancé mais bel et bien au programme ! Vous pouvez laisser cela en première lecture et y revenir plus tard.
Il existe une façon élégante de fabriquer un tableau.
Exemple : Écrire le programme donnant les 100 premiers carrés :
$$1^2,\,2^2,\,3^2,\,\cdots\,=\, 1,\, 4,\, 9,\, \cdots$$
Solutions :
- On peut créer le tableau à la main :
[1,4,9,...]mais c'est long et peu satisfaisant… - On peut créer un tableau en ajoutant les éléments au fur et à mesure, le tableau fonctionnant comme un accumulateur :
t = [] for i in range(101): t.append(i**2) - On crée le tableau en compréhension, ce qui fait la même chose mais de façon plus compacte :
t = [i**2 for i in range(101)]
Vous pouvez remarquer que ces deux options contiennent les mêmes ingrédients, mais dans le second cas, la déclaration de la boucle
forest dans la déclaration du tableau. Cela ressemble à la notation mathématique : en mathématique, si on parle de l'ensemble des carrés des entiers naturels de 0 à 100, on écrira $\left\lbrace n^2, n \in [[0 ; 100]]\right\rbrace$.