GoupillWiki

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== 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...//

<WRAP tip>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.</WRAP>
  * Le type associé au tableau en Python est ''list''

<WRAP tip>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.</WRAP>

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 ''%%,%%''

<code python>
>>> t = (19, 5, 8, 3, 2, 4)
</code>

Mais on peut alléger en ôtant les parenthèses, les virgules suffisent :

<code python>
>>> t = 19, 5, 8, 3, 2, 4
</code>

Le type en Python est ''tuple''.

<code python>
>>> type(t)
<class 'tuple'>
</code>

==== 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'' :

<code python>
>>> 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.
</code>

==== Donnée immuable ====

Un p-uplet est **immuable** : une fois créé, on ne peut pas le modifier.

<WRAP info>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.</WRAP>

Le code suivant, dans lequel on essaie de modifier le contenu d'un p-uplet, déclenche une erreur.

<code python>
>>> t = 4, 5, 6
>>> t[0] = 17
TypeError: 'tuple' object does not support item assignment
</code>

==== Cas d'utilisation ====

Je donne ci-dessous quelques cas d'utilisation

=== Affectation multiple ===

Au lieu de

<code python>
x = 3
y = 5
z = 8
</code>

On peut écrire

<code python>
x, y, z = 3, 5, 8
</code>

=== Fonction à sorties multiples ===

Une fonction qui doit renvoyer deux quantités. Par exemple la somme et le produit de ''x'' et ''y''.

<code python linenums>
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
</code>

<WRAP tip>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%%''.</WRAP>

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

<code python>
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
</code>

Un tuple permet de faire cela de façon plus rapide et plus lisible :

<code python>
b, a = a, b
</code>

À 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 ''%%[ ]%%''

<code python>
>>> t = [19, 5, 8, 3, 2, 4]
>>> type(t)
<class 'list'>
</code>

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.

<WRAP tip>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.</WRAP>

==== Modification du contenu d'un tableau ====

Contentons nous ici des deux choses les plus utiles.

=== Modifier le contenu d'une case ===

<code python>
>>> t = [19, 5, 8, 3, 2, 4]
>>> t[3]
8
>>> t[3] = 15 # modification de la valeur
>>> t[3]
15
</code>

=== Ajouter un élément ===

On utilise la commande ''append'' -- //ajouter//.

<code python>
>>> 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]
</code>

<WRAP tip>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)''.</WRAP>

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

<WRAP group>
<WRAP half column>
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]]

<Code:python linenums:1>
def f(x):
    x = x + 3

y = 12
f(y)
print(y) # affiche 12 ou 15 ?
</Code>
</WRAP>

<WRAP half column>
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]].

<Code:python linenums:1>
def f(x):
    x[0] = 19

y = [10, 52, 27, 48]
f(y)
print(y[0]) # affiche 10 ou 19 ?
</Code>
</WRAP>
</WRAP>

Ce comportement est source de nombreuses erreurs et de dysfonctionnement difficiles à interpréter. Il faut donc faire attention.

==== Tableaux en compréhension ====

<wrap important>Un peu plus avancé mais bel et bien au programme ! Vous pouvez laisser cela en première lecture et y revenir plus tard.</wrap>

{{page>nsi:langages:python:tableaux#Tableau en compréhension&nofooter&noheader}}