Types de données et structures de base en Python

Types primitifs

Python dispose de plusieurs types de base :

• Entiers (int) : précision arbitraire en Python 3
• Flottants (float) : nombres à virgule flottante (norme IEEE 754, double précision)
• Booléens (bool) : True ou False
• Chaînes de caractères (str) : immuables, encodées en Unicode

n = 42          # int
x = 3.14        # float
b = True        # bool
s = "Bonjour"   # str

Attention. La division / renvoie toujours un float. Pour la division entière, utiliser //.

>>> 7 / 2    # 3.5  (float)
>>> 7 // 2   # 3    (int)
>>> 7 % 2    # 1    (reste de la division euclidienne)

Listes

Une liste est une structure mutable et ordonnée. On accède aux éléments par leur indice (à partir de 0).

L = [1, 2, 3, 4, 5]
L[0]       # 1
L[-1]      # 5
L[1:3]     # [2, 3]  (slicing)
L.append(6)  # L = [1, 2, 3, 4, 5, 6]

Complexité : l'accès par indice est en $O(1)$, l'ajout en fin (append) est amorti en $O(1)$, l'insertion ou la suppression en position $i$ est en $O(n)$.

Tuples

Un tuple est une structure immuable et ordonnée.

t = (1, 2, 3)
t[0]   # 1
# t[0] = 10  # Erreur : les tuples sont immuables

Les tuples sont utilisés pour les retours multiples de fonctions et comme clés de dictionnaires (car ils sont hashables).

Dictionnaires

Un dictionnaire associe des clés à des valeurs. Implémenté par une table de hachage.

d = {"nom": "Euler", "prenom": "Leonhard", "annee": 1707}
d["nom"]          # "Euler"
d["domaine"] = "Mathématiques"  # ajout d'une entrée
"nom" in d        # True (test d'appartenance en O(1) en moyenne)

Complexité moyenne : accès, insertion, suppression en $O(1)$.

Ensembles

Un ensemble (set) est une collection non ordonnée d'éléments uniques.

S = {1, 2, 3, 2, 1}  # S = {1, 2, 3}
S.add(4)
S | {5, 6}   # union
S & {2, 3}   # intersection

Conversions de types

int("42")       # 42
float("3.14")   # 3.14
str(42)         # "42"
list("abc")     # ['a', 'b', 'c']