Les tuples

Il existe en python un format de données particulier, que l'on ne retrouve pas obligatoirement dans d'autres langages : les tuples ou p-uplets.

Ce sont des groupes de données ordonnées comme les listes. La principale différence est que les tuples ne peuvent pas être modifiés.

Création et accès aux valeurs :

Un tuple se crée avec des parenthèses :

In [1]:
mon_tuple = (1, 'a')
In [2]:
type(mon_tuple)
Out[2]:
tuple

On peut aussi ne pas utiliser les parenthèses :

In [3]:
autre_tuple = 2.8 , 'e'
In [4]:
type(autre_tuple)
Out[4]:
tuple

Comme pour les listes, on accède aux valeurs en précisant leur indice :

In [5]:
mon_tuple[0]
Out[5]:
1

On peut facilement parcourir les valeurs :

In [6]:
for valeur in mon_tuple :
    print(valeur)

1
a

Par contre on ne peut pas les modifier :

In [7]:
mon_tuple[0] = 5

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-7-097b6a0f166c> in <module>
----> 1 mon_tuple[0] = 5

TypeError: 'tuple' object does not support item assignment

Utilisation :

Les utilisations sont nombreuses. Retenons quelques exemples :

  • Repérer des coordonnées dans un dictionnaire :

Morpion

In [10]:
morpion = {(1,1): 'O', (1,2): 'X', (1,3) : '_',
          (2,1) : 'X', (2,2) : 'O', (2,3) : 'O',
          (3,1) : 'X', (3,2) : 'X', (3,3) : 'O',}
morpion[2,1]
Out[10]:
'X'
  • Echanger des valeurs facilement :
In [12]:
a = 'a'
b = 'b'
a,b = b,a
print('a =',a)
print('b =',b)

a = b
b = a
  • Renvoyer deux résultats dans une fonction :
In [15]:
def solution(ligne1, ligne2) :
    """
    résout un système de deux inconnues à deux solutions
    ligne1 et ligne2 sont des listes donnant les coefficients du système. Pour aX + bY =c, on donne [a,b,c]
    Renvoie un tuple avec les deux solutions
    
    Bien que pratiques, ces formules seront vues en post-bac...
    """
    a,b,c = ligne1[0], ligne1[1], ligne1[2]
    d,e,f = ligne2[0], ligne2[1], ligne2[2]
    
    det = a*e - d * b
    if det == 0 :
        return "Cas particuliers (aucune ou une infinité de solution)"
    
    inverse = [e/det, -b/det, -d/det, a/det]
    
    x = inverse[0] * c + inverse[1] * f
    y = inverse[2] * c + inverse[3] * f
    
    return x , y

Testons cette fonction pour le système dont les solutions sont $(x,y) = (4,2)$:

$$\left\{ \begin{array}{ll} 2x+3y = 14 \\ -x + 7y = 10 \end{array} \right. $$
In [16]:
solution([2,3,14],[-1,7,10])
Out[16]:
(4.0, 2.0)