Chapitre 1: p–uplets

Dans la deuxième partie 2-Représentation des données: types et valeurs de base, nous avions vu certains types de variables simples:

• int: les entiers
• float: les rééls(nombres à virgule flottante)
• boolean: booléen (Vrai ou Faux)
• str: caractère simple(s'il y en a plusieurs, les chaînes de caractères forment alors un type construit de plusieurs caractères semblable aux listes)

Cependant, il existe de nombreux objets qui sont représentés par plusieurs valeurs, c'est le cas par exemple du texte, des images et des sons...

Dans ce cas les enregistrements collectent des valeurs de types différents dans des champs.

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 stocker plusieurs variables d'un coup.

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

Assignations de variables

On peut stocker plusieurs valeurs dans la variable de type tuple.

t = (1, 4, -3)
t

(1, 4, -3)

type(t)

tuple

Les tuples prennent tout leur intéret en récupérant leurs valeurs séparées 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)

t= (1, 4, -3)
a= 1
b= 4
c= -3

Accés aux valeurs par index

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]

4

t[2]

-3

Méthodes des tuples

On peut citer:

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

len(t)

3

t.index(-3)

2

t.count(10)

0

Renvoie de plusieurs valeurs par 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-13-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é(notation pointée).

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](https://fr.wiktionary.org/wiki/mutable].

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