Chapitre 1: p–uplets

Nous verrons dans cette partie trois exemples de types construits:

• les p-uplets tuple et listes list: des collections d'éléments ordonnés dans lesquels les valeurs sont accédées via un index de position.
• les p-uplet nommés namedtuple et les dictionnaires dict: ensemble d'éléments dans lesquels les valeurs sont accédées via une clef.

Nous commencons dans ce premier chapitre par les tuples, très utilisés notamment lorsque l'on souhaite travailler avec plusieurs variables simultanément.

Syntaxe

Les tuples sont des valeurs séparées par des virgules , entourées de parenthèses (..., ..., ...)` qui peuvent parfois être ommises.

(1, 2, 3)

(1, 2, 3)

# sans parenthèses
1, 2, 3

(1, 2, 3)

type((1, 2, 3))

tuple

Accés aux valeurs par index

On peut stocker plusieurs valeurs de types différents dans une variable de type tuple.

t = (1, 2.0, "trois")
t

(1, 2.0, 'trois')

type(t)

tuple

L'accés se fait par un index entier de position qui commence à 0. On place l'index entre des crochets.

t[0]

1

t[1]

2.0

t[2]

'trois'

ATTENTION: Dans les types construits, il faut bien distinguer l'index et la valeur stockée à cet index.

Méthodes des tuples

Les tuples présentent de nombreuses méthodes qui sont décrites dans la documentation ou grâce à l'appel help(tuple)

• La fonction len: nombre d'éléments stockés.
• La méthode index: index de l'élément cherché donné en argument.
• La méthode count: nombre d'éléments de valeur donnée en argument.

# appel d'une fonction
fonction(arguments)
# appel d'une méthode d'objet
objet.méthode(arguments)

print(t)

(1, 2.0, 'trois')

len(t)

3

t.index(-3)

-------------------------------------------------------------------------

ValueError                              Traceback (most recent call last)

<ipython-input-11-1ab9b8c50e8f> in <module>
----> 1 t.index(-3)


ValueError: tuple.index(x): x not in tuple

t.count(10)

Utilisations courantes

Déstructuration

Il peut être pratique de récupérer les valeurs stockées dans le tuple dans des variables de type simple: on parle de déstructuration.

a, b, c = t
print("t=", t)
print("a=", a)
print("b=", b)
print("c=", c)

Permuter des variables

Habituellement, lorsque l'on souhaite pemuter deux variables, il est nécessaire de passer par une troisième variable auxiliaire. Grâce aux tuples, la permutation peut se faire en une instruction.

a = 3
b = 2
print("a=",a, "b=", b)
print("Permutation")
a, b = b, a
print("a=",a, "b=", b)

a= 3 b= 2
Permutation
a= 2 b= 3

Renvoyer plusieurs valeurs dans une fonction

Il s'agit d'une application courante des tuples. prenons l'exemple d'une fonction qui renvoie les deux racines du trinome.

def racines_du_trinome(a,b,c):
    delta = b**2-4*a*c
    if delta > 0:
        return -b-delta**0.5/(2*a), -b+delta**0.5/(2*a)
racines_du_trinome(1,0,-1)

(-1.0, 1.0)

Ici on récupère les racines par déstructuration.

x1, x2 = racines_du_trinome(1,0,-2)
print("racine 1:", x1)
print("racine 2:", x2)

racine 1: -1.4142135623730951
racine 2: 1.4142135623730951

Particularités des tuples

Les tuples peuvent stocker n'importe quel type de valeurs.

(False, "un", 2.0, 3)

(False, 'un', 2.0, 3)

Les tuples sont immutables, c'est à dire qu'on ne peut les modifier une fois qu'ils ont été créés.

t[0] = 6

-------------------------------------------------------------------------

TypeError                               Traceback (most recent call last)

<ipython-input-17-28b8e5df48e8> in <module>
----> 1 t[0] = 6


TypeError: 'tuple' object does not support item assignment

p-uplets nommés

Il est possible de créer des p-uplets nommés afin de pouvoir accéder aux éléments de la collection par clé.

Ce type nécessite d'être importé par le module collections avant d'être utilisé.

from collections import namedtuple

Eleve = namedtuple('Eleve', 'nom, age, classe, spécialité')
e = Eleve("John", 17, "1g", "nsi" )
e

Eleve(nom='John', age=17, classe='1g', spécialité='nsi')

L'avantage de l'accés par clef est qu'il apporte plus d'expressivité au code.

L'accés peut se faire en ajoutant un point et le nom de la clé. Il s'agit encore d'une notation pointée comme dans le cas d'appel de méthodes, cependant il n'y a pas de parenthèses car il s'agit de valeurs et non de fonctions(On parle d'attributs de l'objet).

e.age

17

e.spécialité

'nsi'

Usage

L'usage des p-uplet qu'ils soient nommés ou pas reste peu répandu au profit des tableaux list et dictionnaires dict respectivement, qui au contraire des n-uplets sont mutables.

On pourra ainsi y ajouter des éléments, en retirer...