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

```python 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 `//`.

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

```python 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.

```python 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.

```python 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.

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

Conversions de types

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