====== 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 [[nsi:langages:python:sequences|le chapitre sur les séquences]] suivi du [[nsi:langages:python:sequences_avance|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)
==== 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)
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 [[nsi:langages:c:start|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 -- [[http://pythontutor.com/visualize.html#code=def%20f%28x%29%3A%0A%20%20%20%20x%20%3D%20x%20%2B%203%0A%0Ay%20%3D%2012%0Af%28y%29%0Aprint%28y%29%20%23%20affiche%2012%20ou%2015%20%3F&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false|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 -- [[http://pythontutor.com/visualize.html#code=def%20f%28x%29%3A%0A%20%20%20%20x%5B0%5D%20%3D%2019%0A%0Ay%20%3D%20%5B10,%2052,%2027,%2048%5D%0Af%28y%29%0Aprint%28y%5B0%5D%29%20%23%20affiche%2010%20ou%2019%20%3F&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false|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.
{{page>nsi:langages:python:tableaux#Tableau en compréhension&nofooter&noheader}}