Programme Officiel
Contenus Capacités attendues Commentaires
p-uplets. p-uplets nommés Écrire une fonction renvoyant un p-uplet de valeurs.
Lien vers le programme complet

Tableau à une dimension.png

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(entiers), float(nombres à virgule flottante) bool(booléen), str(châine de caractères)

Nous allons maintenant voir des types construits qui sont des collections d'objets de type simple assemblés dans ce que l'on appelle une structure de données.

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.


Entrée

(1, 2, 3)

Résultat

(1, 2, 3)

Entrée

# sans parenthèses
1, 2, 3

Résultat

(1, 2, 3)

Entrée

type((1, 2, 3))

Résultat

tuple

Accés aux valeurs par index

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


Entrée

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

Résultat

(1, 2.0, 'trois')

Entrée

type(t)

Résultat

tuple

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


Entrée

t[0]

Résultat

1

Entrée

t[1]

Résultat

2.0

Entrée

t[2]

Résultat

'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.
Différence entre méthode et fonction

La différence entre méthode et fonction sera approfondie en terminale lors de l'étude de la programmation orientée objet. Pour l'instant nous pouvons simplement dire qu'il s'agit d'une fonction attachée à un objet qui s'appelle en utilisant une notation pointée.

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

Entrée

print(t)

Sortie

(1, 2.0, 'trois')


Entrée

len(t)

Résultat

3

Entrée

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

Entrée

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.


Entrée

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.


Entrée

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

Sortie

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.


Entrée

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)

Résultat

(-1.0, 1.0)

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


Entrée

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

Sortie

racine 1: -1.4142135623730951
racine 2: 1.4142135623730951

Particularités des tuples

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


Entrée

(False, "un", 2.0, 3)

Résultat

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


Entrée

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


Entrée

from collections import namedtuple

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

Résultat

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


Entrée

e.age

Résultat

17

Entrée

e.spécialité

Résultat

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