t = (1, 2, 3)
type(t)
tuple
| Contenus | Capacités attendues | Commentaires |
|---|---|---|
| p-uplets. p-uplets nommés | Écrire une fonction renvoyant un p-uplet de valeurs. |
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(chaîne 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:
tuple et listes list: des collections d’éléments ordonnés dans lesquels les valeurs sont accédées via un indice de position.namedtuple et les dictionnaires dict: ensemble d’éléments dans lesquels les valeurs sont accédées via une clef.En informatique, un tableau est une structure de données représentant une séquence finie d’éléments auxquels on peut accéder efficacement par leur indice, dans la séquence.
Il existe deux implémentations des tableaux en Python: les tuples et les listes.
(a, b, c)Les tuples sont des valeurs séparées par des virgules , entourées de parenthèses (..., ..., ...)` qui peuvent parfois être omises.
t = (1, 2, 3)
type(t)
tuple
# sans parenthèses
t = 1, 2, 3
type(t)
tuple
[a, b, c]Les valeurs de la collection sont entourées par des crochets [], leurs éléments sont séparés par des virgules.
tab = [ "a", "z" , "e"]
type(tab)
list
Outre la syntaxe, il y a plusieurs différences clés entre les tuples et les listes en Python:
Immutabilité : les tuples sont immuables, c’est-à-dire qu’une fois créés, ils ne peuvent pas être modifiés. Les listes, en revanche, sont mutables, c’est-à-dire que vous pouvez ajouter, supprimer ou remplacer des éléments dans une liste une fois qu’elle a été créée.
Performance : les tuples sont généralement plus rapides à créer et à accéder que les listes. Cela est dû à leur immutabilité, qui signifie qu’il n’y a pas besoin de gérer la modification des éléments dans un tuple.
Utilisation : les tuples sont souvent utilisés lorsque vous avez besoin de stocker des données qui ne doivent pas être modifiées, tandis que les listes sont utilisées lorsque vous avez besoin de stocker des données qui doivent être modifiées fréquemment.
Tuple
On peut stocker plusieurs valeurs de types différents.
t = (1, 2.0, "trois")
t
(1, 2.0, 'trois')
type(t)
tuple
L’accès se fait par un indice entier de position qui commence à 0. On place l’indice entre des crochets.
t[0]
1
t[1]
2.0
t[2]
'trois'
La longueur du tuple est obtenue grâce à la fonction len()
len(t)
3
Les tuples sont immutables, c’est-à-dire qu’on ne peut les modifier une fois qu’ils ont été créés.
t[0] = "un"
TypeError: 'tuple' object does not support item assignment
Liste
On peut stocker plusieurs valeurs de types différents.
tab = [1, 2.0, "trois"]
tab
[1, 2.0, 'trois']
type(tab)
list
L’accès se fait par un indice entier de position qui commence à 0. On place l’indice entre des crochets.
tab[0]
1
tab[1]
2.0
tab[2]
'trois'
La longueur de la liste est obtenue grâce à la fonction len()
len(tab)
3
Les listes sont mutables, c’est-à-dire qu’on peut les modifier une fois qu’elles ont été créés.
tab[0] = "un"
tab
['un', 2.0, 'trois']
ATTENTION: Dans les types construits, il faut bien distinguer l’indice et la valeur stockée à cet indice.
Python étant un langage objet, des méthodes sont ajoutées aux tableaux pour interagir facilement avec eux.
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) # ex: len(tab)
# appel d'une méthode d'objet
objet.méthode(arguments) # ex: tab.append(5)
Les tuples étant immuables ne présentent que deux méthodes qui sont décrites dans la documentation ou grâce à l’appel help(tuple)
index: indice de la première occurrence de l’élément cherché donné en argument.count: nombre d’éléments de valeur donnée en argument.t = (1, 1, 1, 2, 2)
# appel de la méthode index()
t.index(2)
3
t.count(1)
3
help(tuple)
Help on class tuple in module builtins:
class tuple(object)
| tuple(iterable=(), /)
|
| Built-in immutable sequence.
|
| If no argument is given, the constructor returns an empty tuple.
| If iterable is specified the tuple is initialized from iterable's items.
|
| If the argument is a tuple, the return value is the same object.
|
| Built-in subclasses:
| asyncgen_hooks
| MonthDayNano
| RefResolutionErrorAttributes
| TypeCheckerAttributes
| ... and 8 other subclasses
|
| Methods defined here:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return key in self.
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __getnewargs__(self, /)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __repr__(self, /)
| Return repr(self).
|
| __rmul__(self, value, /)
| Return value*self.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| See PEP 585
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
Les listes présentent de nombreuses méthodes en plus de celles des tuples qui vont permettre de les modifier.
Voici quelques utilisations courantes à retenir(la liste complète est dans la documentation!).
append, ou à un indice quelconque avec la méthode insert.# ajout à la fin
tab.append(4)
tab
['un', 2.0, 'trois', 4]
# ajout à l'indice 0(au début)
tab.insert(0, 'zéro')
tab
['zéro', 'un', 2.0, 'trois', 4]
pop(), ou à un indice quelconque avec la méthode pop(indice).tab.pop()
tab
['zéro', 'un', 2.0, 'trois']
tab.pop(1)
tab
['zéro', 2.0, 'trois']
help(list)
Help on class list in module builtins:
class list(object)
| list(iterable=(), /)
|
| Built-in mutable sequence.
|
| If no argument is given, the constructor creates a new empty list.
| The argument must be an iterable if specified.
|
| Methods defined here:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return key in self.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __gt__(self, value, /)
| Return self>value.
|
| __iadd__(self, value, /)
| Implement self+=value.
|
| __imul__(self, value, /)
| Implement self*=value.
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __repr__(self, /)
| Return repr(self).
|
| __reversed__(self, /)
| Return a reverse iterator over the list.
|
| __rmul__(self, value, /)
| Return value*self.
|
| __setitem__(self, key, value, /)
| Set self[key] to value.
|
| __sizeof__(self, /)
| Return the size of the list in memory, in bytes.
|
| append(self, object, /)
| Append object to the end of the list.
|
| clear(self, /)
| Remove all items from list.
|
| copy(self, /)
| Return a shallow copy of the list.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| extend(self, iterable, /)
| Extend list by appending elements from the iterable.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| insert(self, index, object, /)
| Insert object before index.
|
| pop(self, index=-1, /)
| Remove and return item at index (default last).
|
| Raises IndexError if list is empty or index is out of range.
|
| remove(self, value, /)
| Remove first occurrence of value.
|
| Raises ValueError if the value is not present.
|
| reverse(self, /)
| Reverse *IN PLACE*.
|
| sort(self, /, *, key=None, reverse=False)
| Sort the list in ascending order and return None.
|
| The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
| order of two equal elements is maintained).
|
| If a key function is given, apply it once to each list item and sort them,
| ascending or descending, according to their function values.
|
| The reverse flag can be set to sort in descending order.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __class_getitem__(...) from builtins.type
| See PEP 585
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
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.
t = ("α", "β", "γ")
a, b, c = t
print("t=", t)
print("a=", a)
print("b=", b)
print("c=", c)
t= ('α', 'β', 'γ')
a= α
b= β
c= γ
Habituellement, lorsque l’on souhaite permuter 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
Il s’agit d’une application courante des tuples. Prenons l’exemple d’une fonction qui renvoie les deux racines du trinôme.
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
Outre la méthode index(), on peut utiliser l’opérateur booléen in pur savoir si une valeur est dans la liste.
tab = [1, 3, 5]
print(3 in tab)
print(4 in tab)
True
False
Les tableaux étant des structures ordonnées finies, il est facile de les parcourir dans l’ordre avec une boucle bornée for.
En python, on peut réaliser l’itération sur les valeurs ou sur les indices si nécessaire. Cette dernière est plus compliquée, mais plus puissant, car on a alors accès à l’indice i et à la valeur tab[i]).
On fait une itération sur les valeurs du tableau en utilisant le mot-clé in.
tab = [12, -3, 15, -9, 17, 7]
for val in tab:
print(val)
12
-3
15
-9
17
7
C’est la méthode classique utilisée dans les langages impératifs.
t = (12, -3, 15, -9, 17, 7)
for i in range(len(t)):
val = t[i]
print("indice:", i, "valeur:", val)
indice: 0 valeur: 12
indice: 1 valeur: -3
indice: 2 valeur: 15
indice: 3 valeur: -9
indice: 4 valeur: 17
indice: 5 valeur: 7
Même si le choix du nom des variables d’itération vous appartient, on a l’habitude d’utiliser:
i, idx, j, k… pour les indexval, v, e… pour les valeurs des éléments du tableau.Ces deux méthodes fonctionnent aussi bien avec les tuples que les listes, mais également avec les chaînes de caractères str.
for lettre in "Bonjour":
print(lettre)B
o
n
j
o
u
rmot = "Bonjour"
for i in range(len(mot)):
val = mot[i]
print("indice:", i, "valeur:", val)indice: 0 valeur: B
indice: 1 valeur: o
indice: 2 valeur: n
indice: 3 valeur: j
indice: 4 valeur: o
indice: 5 valeur: u
indice: 6 valeur: r