🍱 Types de données

En Python, chaque valeur a un type qui détermine ce qu'on peut faire avec elle : additionner deux nombres, concaténer des textes, itérer sur une liste.

---

Types de base

Chaque valeur que tu manipules (entier, décimal, texte ou booléen) appartient à l'un de ces types.

Type	Description	Exemple
int	Nombre entier	x = 42
float	Nombre décimal	y = 3.14
str	Chaîne de caractères	nom = "Alice"
bool	Booléen (vrai ou faux)	actif = True

Liste (list)

Liste ordonnée et modifiable, définie avec des crochets [].

Opération	Syntaxe	Description
Créer	heros = ["Mario", "Link"]	Nouvelle liste
Accéder	element = heros[0]	Élément à l'index 0
Modifier	heros[0] = "Samus"	Remplacer un élément
Longueur	nb_elements = len(heros)	Nombre d'éléments
Présence	est_present = "Mario" in heros	Retourne True ou False
Ajouter (fin)	heros.append("Pikachu")	Ajoute à la fin
Insérer	heros.insert(1, "Samus")	Insère à l'index 1
Supprimer (valeur)	heros.remove("Samus")	Supprime la 1re occurrence
Supprimer (dernier)	element_retire = heros.pop()	Supprime et retourne le dernier élément
Supprimer (index)	element_retire = heros.pop(0)	Supprime et retourne l'élément à l'index 0
Trier (nouvelle liste)	liste_triee = sorted(heros)	Retourne une copie triée
Trier (en place)	heros.sort()	Modifie la liste directement
Combiner	liste_combinee = liste1 + liste2	Concatène deux listes
Copier	liste_copie = heros.copy()	Copie indépendante
Maximum	valeur_max = max(heros)	Plus grande valeur (nombres seulement)
Minimum	valeur_min = min(heros)	Plus petite valeur (nombres seulement)
Somme	total = sum(heros)	Somme de tous les éléments (nombres seulement)

Ensemble (set)

Ensemble non ordonné et sans doublons, défini avec des accolades {}.

Opération	Syntaxe	Description
Créer	couleurs = {"rouge", "vert", "bleu"}	Nouvel ensemble
Créer (vide)	couleurs = set()	Ensemble vide (pas {})
Présence	est_present = "rouge" in couleurs	Retourne True ou False
Ajouter	couleurs.add("jaune")	Ajoute un élément (sans doublon)
Supprimer (erreur si absent)	couleurs.remove("vert")	Lève une erreur si absent
Supprimer (sans erreur)	couleurs.discard("vert")	Ne fait rien si absent
Union	ensemble_union = a | b	Tous les éléments des deux ensembles
Intersection	ensemble_commun = a & b	Éléments communs aux deux ensembles
Différence	ensemble_diff = a - b	Éléments dans a mais pas dans b
Convertir en liste	ma_liste = list(couleurs)	Transforme l'ensemble en liste
Convertir une liste en ensemble	couleurs = set(ma_liste)	Transforme une liste en ensemble (sans doublons)
Longueur	nb_elements = len(couleurs)	Nombre d'éléments

Tuple (tuple)

Liste ordonnée et immuable, définie avec des parenthèses ().

Opération	Syntaxe	Description
Créer	coordonnees = (10, 20)	Nouveau tuple
Créer (sans parenthèses)	coordonnees = 10, 20	Équivalent avec parenthèses implicites
Convertir une liste	mon_tuple = tuple(ma_liste)	Transforme une liste en tuple
Convertir en liste	ma_liste = list(mon_tuple)	Transforme un tuple en liste
Accéder	element = coordonnees[0]	Élément à l'index 0
Indice négatif	dernier = coordonnees[-1]	Dernier élément
Longueur	nb_elements = len(coordonnees)	Nombre d'éléments
Présence	est_present = 10 in coordonnees	Retourne True ou False
Décomposer	x, y = coordonnees	Assigne chaque élément à une variable
Retour multiple	return a, b	Retourne plusieurs valeurs (tuple implicite)

Dictionnaire (dict)

Paires clé-valeur, défini avec des accolades {}.

Opération	Syntaxe	Description
Créer	experience = {"nom": "Électrolyse", "tentative": 2}	Nouveau dictionnaire
Créer (vide)	experience = {}	Dictionnaire vide
Accéder	valeur = experience["nom"]	Valeur associée à la clé
Ajouter / Modifier	experience["succes"] = True	Ajoute ou écrase la paire clé-valeur
Supprimer	del experience["tentative"]	Supprime la paire clé-valeur
Présence	cle_existe = "nom" in experience	Vérifie si la clé existe
Clés	liste_cles = experience.keys()	Retourne toutes les clés
Valeurs	liste_valeurs = experience.values()	Retourne toutes les valeurs
Paires	liste_paires = experience.items()	Retourne les paires (clé, valeur)
Longueur	nb_paires = len(experience)	Nombre de paires clé-valeur
Itérer (clés)	for cle in experience.keys():	Parcourir toutes les clés
Itérer (valeurs)	for val in experience.values():	Parcourir toutes les valeurs
Itérer (paires)	for cle, val in experience.items():	Parcourir clés et valeurs

Comparatif des collections

Caractéristiques des collections

Choisir la bonne structure dépend de ce dont tu as besoin : ordre, modifiabilité, unicité des éléments ou association clé-valeur.

Structure	Ordonnée	Modifiable	Doublons permis	Accès	Ajout	Suppression
list	✅	✅	✅	Par index [ ]	.append(), .insert()	.remove(), .pop()
tuple	✅	❌	✅	Par index [ ]	❌ (immuable)	❌ (immuable)
set	❌	✅	❌	Test présence in	.add()	.remove(), .discard()
dict	✅	✅	❌ (clés uniques)	Par clé d["clé"]	d["clé"] = valeur	del d["clé"]

Note : les dict conservent l'ordre d'insertion des clés.