Types & structures de données Python : listes, tuples, dicts & sets

Choisissez le bon conteneur — list, tuple, dict ou set — et cessez de vous battre avec vos propres données.

Découvrez les types de données natifs de Python et les quatre conteneurs essentiels : les listes, les tuples, les dictionnaires et les sets. Voyez comment créer, indexer, ajouter, supprimer et parcourir chacun d’eux, quand choisir lequel, et comment la mutabilité change leur comportement.

Date de publication

26 juin 2026

Modifié

7 juillet 2026

AstucePoints clés
  • Cinq scalaires portent des valeurs uniques : int, float, str, bool et None — tout le reste se construit dessus.
  • Les listes sont votre conteneur par défaut — ordonnées, mutables, indexables. Tournez-vous vers elles en premier.
  • Les tuples sont des listes figées — ordonnés mais immuables. Utilisez-les pour des enregistrements fixes et comme clés de dict.
  • Les dicts associent des clés à des valeurs — l’outil idéal dès que vous diriez « chercher X par son nom ».
  • Les sets stockent des éléments uniques — déduplication instantanée et tests d’appartenance rapides.
  • La mutabilité décide du comportement — les objets mutables peuvent être modifiés sur place et aliasés ; les objets immuables, non. Ce seul fait explique la plupart des surprises des débutants.

Introduction

Presque tout programme Python n’est qu’une donnée posée dans un conteneur, que l’on remodèle. Choisissez le mauvais conteneur et vous lutterez contre le langage à chaque ligne — en cherchant les choses par balayage d’une liste, ou en tentant de modifier une valeur qui ne peut pas changer. Choisissez le bon et le code se lit comme le problème. Cette leçon parcourt les cinq types scalaires en une minute, puis passe son temps là où ça compte : les quatre conteneurs — list, tuple, dict, set — comment les construire, y faire entrer et sortir des données, les parcourir, et comment choisir entre eux.

Chaque résultat est réel — et vous pouvez l’exécuter vous-même sans rien installer : cliquez sur Try ▸ sous n’importe quel bloc pour l’exécuter en direct dans votre navigateur (Python démarre au premier Run, puis c’est instantané).

Types scalaires : les valeurs uniques

Les scalaires contiennent une seule valeur. Vous en utiliserez cinq en permanence. Les voici, créés et affichés :

count = 42            # int   — whole number
price = 19.99         # float — decimal number
name = "Datanovia"    # str   — text
is_active = True      # bool  — True or False
result = None         # NoneType — "no value yet"

print(count, price, name, is_active, result)
42 19.99 Datanovia True None

Quelques points à connaître d’emblée. int n’a pas de limite de taille en Python — 2 ** 100 fonctionne tout simplement. bool est techniquement une sorte d’int (True == 1), ce qui est tantôt pratique, tantôt surprenant. Et None n’est pas la même chose que 0, False ou "" — il signifie « rien ici », et vous le verrez comme valeur de retour par défaut des fonctions qui ne retournent rien.

Vérifiez ce que vous avez avec type() :

print(type(count), type(price), type(name), type(is_active), type(result))
<class 'int'> <class 'float'> <class 'str'> <class 'bool'> <class 'NoneType'>

Listes : ordonnées et mutables

Une list est votre bête de somme : une séquence ordonnée et modifiable écrite avec des crochets. Les éléments conservent leur position, peuvent se répéter et mélanger les types. Créez-en une et lisez les éléments par leur index (en comptant à partir de 0) :

fruits = ["apple", "banana", "cherry", "date"]

print(fruits[0])     # first item
print(fruits[-1])    # last item (negative counts from the end)
print(fruits[1:3])   # a slice: items 1 and 2 (stop is excluded)
apple
date
['banana', 'cherry']

Comme les listes sont mutables, vous pouvez les modifier sur place. Ajoutez avec .append() (un élément) ou .extend() (plusieurs) ; supprimez avec .remove() (par valeur) ou .pop() (par index, et qui vous rend l’élément) :

fruits.append("elderberry")     # add to the end
fruits.remove("banana")         # delete the first "banana"
dropped = fruits.pop(0)         # remove + return item at index 0

print("dropped:", dropped)
print("now:", fruits)
dropped: apple
now: ['cherry', 'date', 'elderberry']

Le parcours est direct — bouclez sur les éléments eux-mêmes, ou associez chacun à son index avec enumerate() :

for i, fruit in enumerate(fruits):
    print(i, fruit)
0 cherry
1 date
2 elderberry

Tuples : ordonnés et immuables

Un tuple est une liste qui ne peut pas changer. Même ordre et même indexation, mais une fois créé il est figé — écrit avec des parenthèses (ou de simples virgules). Utilisez un tuple quand un groupe de valeurs va ensemble et ne doit pas être modifié : des coordonnées, une couleur RVB, un enregistrement fixe.

point = (1920, 1080)        # a fixed pair
print(point[0], point[1])

width, height = point       # unpack into two names
print(width, height)
1920 1080
1920 1080

Essayez de modifier un tuple et Python vous arrête — c’est tout l’intérêt :

point[0] = 800
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[7], line 1
----> 1 point[0] = 800

TypeError: 'tuple' object does not support item assignment

Cette immutabilité vous apporte deux choses : une valeur dont vous pouvez être sûr qu’elle ne mutera pas dans votre dos, et la possibilité d’utiliser un tuple comme clé de dictionnaire ou comme membre de set (les listes ne peuvent ni l’un ni l’autre, justement parce qu’elles peuvent changer).

Dictionnaires : clé → valeur

Un dict associe des clés à des valeurs — construit avec des accolades et des paires key: value. Tournez-vous vers un dict dès que vous décririez la tâche par « chercher X par son nom ». Lisez avec [], mais préférez .get() quand une clé peut être absente (il retourne None au lieu de planter) :

person = {"name": "Alice", "age": 30, "city": "Lyon"}

print(person["name"])           # direct lookup
print(person.get("email"))      # missing key → None, no error
Alice
None

Les dicts sont mutables : affectez pour ajouter ou mettre à jour une clé, del pour en supprimer une :

person["email"] = "alice@example.com"   # add a new key
person["age"] = 31                       # update an existing one
del person["city"]                       # remove a key

print(person)
{'name': 'Alice', 'age': 31, 'email': 'alice@example.com'}

Parcourez un dict avec .items() pour obtenir clés et valeurs ensemble (un simple for k in person ne vous donne que les clés) :

for key, value in person.items():
    print(f"{key}: {value}")
name: Alice
age: 31
email: alice@example.com

Sets : éléments uniques

Un set est une collection non ordonnée de valeurs uniques, écrite avec des accolades (mais sans paires :). Les doublons disparaissent simplement, ce qui fait du set le moyen le plus rapide de dédupliquer et le moyen le plus rapide de demander « est-ce là-dedans ? » :

tags = {"python", "data", "python", "stats", "data"}
print(tags)                     # duplicates are gone
print("python" in tags)         # membership test — very fast
{'python', 'stats', 'data'}
True

Ajoutez avec .add(), supprimez avec .discard() (sans danger même si l’élément est absent). Les sets font aussi de vrais calculs ensemblistes — union, intersection, différence :

a = {1, 2, 3}
b = {3, 4, 5}

print(a | b)    # union — everything in either
print(a & b)    # intersection — only what's in both
print(a - b)    # difference — in a but not b
{1, 2, 3, 4, 5}
{3}
{1, 2}

Quel conteneur dois-je utiliser ?

Le choix se ramène à quatre questions : l’ordre compte-t-il, va-t-il changer, les éléments peuvent-ils se répéter, et comment cherchez-vous les choses. Ce tableau est l’aide-mémoire :

Conteneur Ordonné ? Mutable ? Doublons ? Tournez-vous vers lui quand…
list Oui Oui Oui Vous avez besoin d’une séquence ordonnée et modifiable (le choix par défaut)
tuple Oui Non Oui Le groupe est fixe — enregistrements, coordonnées, une clé de dict
dict Oui¹ Oui Clés uniques Vous cherchez les valeurs par nom / clé
set Non Oui Non Vous avez besoin d’unicité ou de tests rapides « est-ce là-dedans ? »

¹ Les dicts préservent l’ordre d’insertion (Python 3.7+), mais vous accédez toujours aux valeurs par clé, pas par position.

Convertir entre types

Les noms des conteneurs servent aussi de fonctions de conversion. Voici comment dédupliquer une liste, ou transformer une liste de paires en dict :

nums = [3, 1, 2, 2, 3, 1]

print(set(nums))            # list → set: drops duplicates
print(sorted(set(nums)))   # ...back to a sorted list of uniques
print(tuple(nums))         # list → tuple: freeze it

pairs = [("a", 1), ("b", 2)]
print(dict(pairs))         # list of pairs → dict
{1, 2, 3}
[1, 2, 3]
(3, 1, 2, 2, 3, 1)
{'a': 1, 'b': 2}

Vérifier les types de la bonne manière

Utilisez isinstance() plutôt que de comparer type() directement — c’est la vérification idiomatique et elle respecte les sous-classes :

value = [1, 2, 3]

print(isinstance(value, list))          # True
print(isinstance(value, (list, tuple))) # True if it's either
print(type(value) is list)              # works, but isinstance is preferred
True
True
True

Essayez en direct

Les blocs ci-dessus ont été exécutés au moment de la génération. Modifiez celui-ci et appuyez sur Run pour essayer Python par vous-même — il s’exécute dans votre navigateur via Pyodide (sans installation). Ou cliquez sur Try ▸ sous n’importe quel bloc ci-dessus pour y déposer son code.

Problèmes courants

KeyError à la lecture d’un dict. person["email"] lève une KeyError si la clé n’existe pas. Utilisez person.get("email") (retourne None) ou person.get("email", "n/a") (retourne une valeur par défaut) chaque fois que la clé peut être absente.

Modifier une liste pendant qu’on la parcourt. Supprimer des éléments d’une liste à l’intérieur d’une boucle for sur cette même liste saute des éléments — les index se décalent sous vos pieds. Parcourez plutôt une copie :

nums = [1, 2, 3, 4, 5]
for n in nums[:]:          # the [:] copy is what you loop over
    if n % 2 == 0:
        nums.remove(n)
print(nums)
[1, 3, 5]

Deux noms pointant sur une seule liste (aliasing). b = a ne copie pas une liste — les deux noms pointent sur le même objet, donc modifier l’un modifie « les deux ». Faites une vraie copie avec .copy() ou list(a) :

a = [1, 2, 3]
b = a            # alias — same list
b.append(99)
print("aliased:", a)       # a changed too

c = a.copy()     # independent copy
c.append(0)
print("copied a:", a)      # a is untouched
aliased: [1, 2, 3, 99]
copied a: [1, 2, 3, 99]

Questions fréquentes

Utilisez un tuple quand la collection est fixe et ne doit pas changer — une paire de coordonnées, une couleur RVB, une ligne de champs fixes. Les tuples signalent « ceci ne sera pas modifié », ils sont légèrement plus légers, et ils peuvent servir de clés de dictionnaire ou de membres de set (les listes ne le peuvent pas, car elles sont mutables). Si vous devez ajouter, supprimer ou réordonner des éléments, utilisez une list.

Convertissez-la en set puis de nouveau en liste : list(set(my_list)). Cela supprime les doublons instantanément. Le hic est qu’un set n’a pas d’ordre, donc le résultat peut être réordonné. Si l’ordre compte, utilisez sorted(set(my_list)) pour un résultat trié, ou list(dict.fromkeys(my_list)) pour conserver l’ordre d’apparition d’origine.

[] crée une list (ordonnée, mutable). () crée un tuple (ordonné, immuable) — ou ne fait que grouper une expression. {} crée un dict quand il contient des paires key: value, et un set quand il contient des valeurs nues. Notez qu’un {} vide est un dict vide ; pour un set vide vous devez écrire set().

Parce que b = a copie la référence, pas les données — les deux noms pointent sur le même objet liste, donc une modification par l’un est visible par l’autre. C’est ce qu’on appelle l’aliasing. Pour obtenir une liste indépendante, copiez-la explicitement avec a.copy() ou list(a).

Depuis Python 3.7, les dicts se souviennent de l’ordre d’insertion des clés, donc parcourir un dict est prévisible. Mais vous accédez toujours aux valeurs par clé, pas par position — person[0] cherche une clé 0, il ne retourne pas « le premier élément ». Si vous avez besoin d’un accès par position, utilisez une liste.

Testez vos connaissances

Travaillez chaque tâche dans la cellule Essayez en direct ci-dessus — modifiez et exécutez.

Tâche 1. Partez de scores = [88, 92, 92, 75, 88, 100]. Produisez une liste des scores uniques, triés du plus petit au plus grand.

Un set supprime les doublons ; sorted() retransforme n’importe quelle collection en liste ordonnée.

scores = [88, 92, 92, 75, 88, 100]
print(sorted(set(scores)))
[75, 88, 92, 100]

Convertissez en set pour retirer les répétitions, puis sorted() redonne une liste ordonnée.

Tâche 2. Vous avez user = {"name": "Sam", "role": "editor"}. Lisez la clé "email" sans planter si elle est absente, puis ajoutez un "email" de votre choix.

.get() est la lecture qui ne plante pas. Affecter à une nouvelle clé l’ajoute.

user = {"name": "Sam", "role": "editor"}
print(user.get("email"))        # None — no KeyError
user["email"] = "sam@example.com"
print(user)
None
{'name': 'Sam', 'role': 'editor', 'email': 'sam@example.com'}

.get() retourne None pour une clé absente au lieu de lever une KeyError ; l’affectation ajoute ensuite la clé.

Vérification rapide. Vous voulez stocker une paire fixe (latitude, longitude) et l’utiliser plus tard comme clé dans un dictionnaire de noms de lieux. Quel conteneur utilisez-vous, et pourquoi ?

Un tuple. Il est ordonné (latitude puis longitude), il est fixe (vous ne modifierez pas une paire de coordonnées sur place), et — le facteur décisif — seuls les objets immuables peuvent être des clés de dictionnaire. Une liste lèverait TypeError: unhashable type: 'list'.

Conclusion

Vous disposez maintenant des cinq scalaires et des quatre conteneurs, plus de l’idée unique qui les relie : la mutabilité. Les listes sont le choix modifiable par défaut, les tuples en sont la forme figée, les dicts cherchent par clé, et les sets gardent les choses uniques. Choisissez en vous demandant si l’ordre compte, s’il va changer, et comment vous retrouverez les éléments — le tableau ci-dessus est toute la décision.

À lire aussi : les compréhensions — la façon pythonique de construire listes & dicts en une ligne · les vecteurs & listes de R — comment les mêmes idées se présentent en R.

Réutilisation

Citation

BibTeX
@online{2026,
  author = {},
  title = {Types \& structures de données Python : listes, tuples, dicts
    \& sets},
  date = {2026-06-26},
  url = {https://www.datanovia.com/learn/programming/python-foundations/data-types-structures},
  langid = {fr}
}
Veuillez citer ce travail comme suit :
“Types & structures de données Python : listes, tuples, dicts & sets.” 2026. June 26. https://www.datanovia.com/learn/programming/python-foundations/data-types-structures.