# Aide-mémoire Python : syntaxe, boucles, fonctions, listes, dictionnaires, méthodes de chaînes et commandes du terminal

URL: https://skillaria.top/fr/guides/python/aide-memoire-python

Aide-mémoire Python sur une page : syntaxe et indentation, types de données, opérateurs, conditions, boucles for et while, compréhensions, fonctions, fonctions intégrées, méthodes des chaînes, des listes, des dictionnaires et des ensembles, exceptions, fichiers, classes, modules de la bibliothèque standard et commandes du terminal. Chaque table contient des exemples prêts à coller dans l'interpréteur.

Cet aide-mémoire Python réunit sur une seule page tout ce qu'il faut avoir sous la main pendant les premiers mois : la syntaxe, les boucles, les fonctions intégrées, les méthodes des chaînes, des listes et des dictionnaires, ainsi que les commandes du terminal. Chaque tableau est une référence courte avec des exemples de fonctionnement, que vous pouvez coller directement dans l'interpréteur interactif (REPL).

## Bases de la syntaxe Python

La particularité principale du langage : les blocs sont délimités par l'indentation, et non par des accolades. Après une ligne qui se termine par deux-points (`if`, `for`, `def`, `class`), les lignes suivantes sont décalées de 4 espaces. Mélanger tabulations et espaces est interdit : vous obtiendrez une `IndentationError`.

| Construction | Exemple | Explication |
| --- | --- | --- |

| Commentaire | `# texte` | tout ce qui suit # jusqu'à la fin de la ligne est ignoré |

| Variable | `age = 25` | le type n'est pas déclaré, il est déterminé par la valeur |

| Affectation multiple | `a, b = 1, 2` | dépaquetage ; échange de valeurs : `a, b = b, a` |

| Affichage | `print("Bonjour", name)` | les arguments sont séparés par un espace |

| Saisie | `s = input("Nom : ")` | renvoie toujours une chaîne |

| f-chaîne | `f"{name} : {price:.2f}"` | insertion d'expressions et format |

| Annotation de type | `count: int = 0` | indication pour l'IDE et les vérificateurs, non contrôlée à l'exécution |

| Bloc vide | `pass` | espace réservé là où la syntaxe exige un corps |

| Import | `from math import sqrt` | importation d'un module ou d'un nom depuis un module |

### Types de données

| Type | Littéral | Modifiable |
| --- | --- | --- |

| `int` | `42`, `1_000_000` | non |

| `float` | `3.14`, `1e-3` | non |

| `bool` | `True`, `False` | non |

| `str` | `"texte"`, `'texte'`, `"""plusieurs lignes"""` | non |

| `list` | `[1, 2, 3]` | oui |

| `tuple` | `(1, 2)`, `(1,)` | non |

| `dict` | `{"a": 1}` | oui |

| `set` | `{1, 2}`, vide — `set()` | oui |

| `NoneType` | `None` | — |

### Opérateurs

| Groupe | Opérateurs | Exemple → résultat |
| --- | --- | --- |

| Arithmétique | `+ - * / // % **` | `7 // 2` → 3, `7 % 2` → 1, `2 ** 10` → 1024 |

| Comparaison | `== != < > <= >=` | `1 < x < 10` — chaîne de comparaisons |

| Logique | `and or not` | `x or "par défaut"` |

| Appartenance | `in`, `not in` | `"a" in "abc"` → True |

| Identité | `is`, `is not` | `x is None` |

| Affectation | `+= -= *= /=`, `:=` | `if (n := len(s)) > 10: ...` |

## Conditions et filtrage par motifs

```
if score >= 90:
    grade = "A"
elif score >= 70:
    grade = "B"
else:
    grade = "C"

status = "adulte" if age >= 18 else "enfant"   # opérateur ternaire

match command:
    case "start":
        print("Démarrage")
    case "stop" | "exit":
        print("Arrêt")
    case _:
        print("Commande inconnue")
```

Sont considérés comme faux : `False`, `None`, `0`, la chaîne vide et les collections vides. C'est pourquoi on écrit simplement `if items` au lieu de `if len(items) > 0`.

## Boucles en Python : syntaxe de for et while

### Boucle for

Syntaxe de la boucle for en Python : `for variable in séquence:`, suivie du corps indenté. La boucle parcourt tout objet itérable : une chaîne, une liste, un dictionnaire, un fichier, un `range`.

```
for i in range(5):              # 0 1 2 3 4
    print(i)

for i in range(10, 0, -2):      # 10 8 6 4 2
    print(i)

for i, fruit in enumerate(["pomme", "poire"], start=1):
    print(i, fruit)

for name, score in zip(names, scores):
    print(name, score)

for key, value in prices.items():
    print(key, value)
```

### Boucle while

```
attempts = 3
while attempts > 0:
    password = input("Mot de passe : ")
    if password == "secret":
        print("Connexion réussie")
        break
    attempts -= 1
else:
    print("Plus de tentatives")   # exécuté si la boucle n'a pas été interrompue par break
```

| Instruction | Ce qu'elle fait |
| --- | --- |

| `break` | quitte la boucle immédiatement |

| `continue` | passe à l'itération suivante |

| `else` d'une boucle | s'exécute si la boucle s'est terminée sans `break` |

| `range(stop)`, `range(start, stop, step)` | suite de nombres, `stop` n'est pas inclus |

### Compréhensions de listes

```
squares = [x ** 2 for x in range(10)]
evens = [x for x in numbers if x % 2 == 0]
lengths = {word: len(word) for word in words}
unique = {c.lower() for c in text}
total = sum(x * x for x in range(100))   # expression génératrice
```

## Fonctions

```
def greet(name: str, greeting: str = "Bonjour") -> str:
    """Renvoie un message d'accueil."""
    return f"{greeting}, {name} !"

def total(*args, **kwargs):
    return sum(args), kwargs

square = lambda x: x * x
print(greet("Anna"))                 # Bonjour, Anna !
print(greet("Anna", greeting="Salut"))  # Salut, Anna !
```

| Élément | Signification |
| --- | --- |

| `def f(a, b=1)` | paramètre avec une valeur par défaut |

| `*args` | nombre quelconque d'arguments positionnels (tuple) |

| `**kwargs` | nombre quelconque d'arguments nommés (dictionnaire) |

| `return` | renvoie une valeur ; sans lui, la fonction renvoie `None` |

| `lambda x: ...` | petite fonction anonyme d'une seule expression |

| `global`, `nonlocal` | modification d'une variable d'une portée extérieure |

N'utilisez pas une valeur par défaut modifiable comme `def f(items=[])` : la liste est créée une seule fois et se remplit d'un appel à l'autre. La bonne écriture est `items=None`, puis à l'intérieur `if items is None: items = []`.

## Fonctions intégrées Python

Les fonctions intégrées de Python sont disponibles sans import. Ce sont les fonctions principales, présentes dans presque tous les scripts.

| Fonction | Ce qu'elle fait | Exemple → résultat |
| --- | --- | --- |

| `print()` | affiche des valeurs | `print(1, 2, sep="-")` → 1-2 |

| `input()` | lit une chaîne au clavier | `int(input())` |

| `len()` | longueur d'une collection ou d'une chaîne | `len("abc")` → 3 |

| `type()` | type d'un objet | `type(3.0)` → <class 'float'> |

| `isinstance()` | vérification de type | `isinstance(5, int)` → True |

| `int() float() str() bool()` | conversion de types | `int("42")` → 42 |

| `list() tuple() set() dict()` | création de collections | `list("ab")` → ['a', 'b'] |

| `range()` | intervalle de nombres | `list(range(3))` → [0, 1, 2] |

| `enumerate()` | couples (indice, élément) | `list(enumerate("ab"))` → [(0, 'a'), (1, 'b')] |

| `zip()` | assemble des séquences deux à deux | `list(zip([1, 2], "ab"))` → [(1, 'a'), (2, 'b')] |

| `sum() min() max()` | somme, minimum, maximum | `max([3, 7, 1])` → 7 |

| `abs() round()` | valeur absolue et arrondi | `round(3.14159, 2)` → 3.14 |

| `sorted()` | nouvelle liste triée | `sorted(words, key=len, reverse=True)` |

| `reversed()` | itérateur dans l'ordre inverse | `list(reversed([1, 2]))` → [2, 1] |

| `map() filter()` | appliquer une fonction / filtrer | `list(map(str, [1, 2]))` → ['1', '2'] |

| `any() all()` | au moins un / tous vrais | `all(x > 0 for x in nums)` |

| `open()` | ouvre un fichier | `open("a.txt", encoding="utf-8")` |

| `help() dir()` | aide et liste des attributs | `help(str.split)`, `dir(list)` |

| `id() hash()` | identifiant et empreinte d'un objet | `hash("a")` |

Le meilleur aide-mémoire est toujours à portée de main : la fonction `help()` dans le REPL. `help(dict)` affiche toutes les méthodes d'un dictionnaire avec leur description, et `dir(obj)` donne la liste des noms disponibles.

## Méthodes des chaînes

Les chaînes en Python sont immuables : chaque méthode renvoie une nouvelle chaîne. Les tranches fonctionnent comme pour les listes : `s[1:4]`, et `s[::-1]` pour inverser.

| Méthode | Exemple → résultat |
| --- | --- |

| `upper() lower()` | `"Py".upper()` → 'PY' |

| `capitalize() title()` | `"hello world".title()` → 'Hello World' |

| `strip() lstrip() rstrip()` | `" hi \n".strip()` → 'hi' |

| `split(sep)` | `"a,b,c".split(",")` → ['a', 'b', 'c'] |

| `join(iterable)` | `"-".join(["a", "b"])` → 'a-b' |

| `replace(old, new)` | `"rose".replace("r", "p")` → 'pose' |

| `find() index()` | `"hello".find("l")` → 2 ; absent — -1 (pour `index` — erreur) |

| `count()` | `"banana".count("a")` → 3 |

| `startswith() endswith()` | `"file.py".endswith(".py")` → True |

| `isdigit() isalpha() isspace()` | `"123".isdigit()` → True |

| `removeprefix() removesuffix()` | `"test_a".removeprefix("test_")` → 'a' |

| `zfill() center() ljust()` | `"7".zfill(3)` → '007' |

| `format()` | `"{} + {}".format(1, 2)` → '1 + 2' |

## Commandes des listes Python

La liste est une collection ordonnée et modifiable. La plupart des méthodes modifient la liste sur place et renvoient `None` : `a = a.sort()` est donc une erreur fréquente.

| Opération | Ce qu'elle fait | Exemple |
| --- | --- | --- |

| `append(x)` | ajoute à la fin | `a.append(4)` |

| `extend(iter)` | ajoute tous les éléments | `a.extend([5, 6])` |

| `insert(i, x)` | insère à un indice | `a.insert(0, "premier")` |

| `remove(x)` | supprime la première occurrence de la valeur | `a.remove(3)` |

| `pop(i)` | supprime et renvoie l'élément (par défaut le dernier) | `last = a.pop()` |

| `clear()` | vide la liste | `a.clear()` |

| `index(x)` | indice de la première occurrence | `a.index("b")` |

| `count(x)` | nombre d'occurrences | `a.count(1)` |

| `sort()` | trie sur place | `a.sort(key=str.lower)` |

| `reverse()` | inverse sur place | `a.reverse()` |

| `copy()` | copie superficielle | `b = a.copy()` |

| `del a[i]` | suppression par indice ou par tranche | `del a[1:3]` |

| Tranches | `a[start:stop:step]` | `a[-1]` — le dernier, `a[:3]` — les trois premiers |

## Commandes des dictionnaires Python

| Opération | Ce qu'elle fait | Exemple |
| --- | --- | --- |

| `d[key]` | valeur de la clé ; clé absente — `KeyError` | `d["name"]` |

| `get(key, default)` | valeur ou valeur de secours | `d.get("age", 0)` |

| `d[key] = value` | ajouter ou modifier | `d["city"] = "Lyon"` |

| `keys() values() items()` | clés, valeurs, paires | `for k, v in d.items():` |

| `update()` | fusionner avec un autre dictionnaire | `d.update({"a": 1})` |

| `d1 | d2` | nouveau dictionnaire fusionné | `merged = defaults | user` |

| `pop(key, default)` | supprime et renvoie la valeur | `d.pop("tmp", None)` |

| `popitem()` | supprime la dernière paire ajoutée | `d.popitem()` |

| `setdefault(key, value)` | renvoie la valeur, ou la crée si la clé est absente | `d.setdefault("tags", []).append("py")` |

| `key in d` | vérifie la présence d'une clé | `if "name" in d:` |

| `dict.fromkeys()` | dictionnaire à partir des clés avec une valeur commune | `dict.fromkeys("abc", 0)` |

| `len(d)`, `del d[key]` | taille et suppression | `del d["old"]` |

### Tuples et ensembles

| Opération | Exemple → résultat |
| --- | --- |

| Dépaquetage d'un tuple | `x, y = (3, 4)` |

| Ajouter à un ensemble | `s.add(5)`, supprimer — `s.discard(5)` |

| Union / intersection | `{1, 2} | {2, 3}` → {1, 2, 3} ; `{1, 2} & {2, 3}` → {2} |

| Différence | `{1, 2} - {2}` → {1} |

| Supprimer les doublons d'une liste | `list(dict.fromkeys(items))` — en conservant l'ordre |

## Exceptions et fichiers

```
try:
    number = int(input("Nombre : "))
except ValueError as err:
    print("Ce n'est pas un nombre :", err)
else:
    print("Succès")
finally:
    print("Toujours exécuté")

with open("data.txt", "w", encoding="utf-8") as f:
    f.write("ligne\n")

with open("data.txt", encoding="utf-8") as f:
    for line in f:
        print(line.rstrip())
```

| Exception | Quand elle apparaît |
| --- | --- |

| `SyntaxError`, `IndentationError` | erreur de syntaxe ou d'indentation |

| `NameError` | nom non défini (faute de frappe) |

| `TypeError` | opération avec un type inadapté : `"1" + 1` |

| `ValueError` | bon type, mais valeur incorrecte : `int("abc")` |

| `IndexError`, `KeyError` | indice ou clé inexistant |

| `FileNotFoundError` | fichier introuvable |

| `ZeroDivisionError` | division par zéro |

## Classes

```
from dataclasses import dataclass

class Dog:
    def __init__(self, name: str):
        self.name = name

    def bark(self) -> str:
        return f"{self.name} : Ouaf !"

@dataclass
class Point:
    x: float
    y: float

print(Dog("Rex").bark())   # Rex : Ouaf !
print(Point(1, 2))         # Point(x=1, y=2)
```

## Modules intégrés de Python

La bibliothèque standard est installée avec l'interpréteur : il suffit de faire un `import`.

| Module | À quoi il sert | Exemple |
| --- | --- | --- |

| `math` | calcul mathématique | `math.sqrt(16)` → 4.0 |

| `random` | nombres aléatoires | `random.randint(1, 6)`, `random.choice(items)` |

| `datetime` | date et heure | `datetime.date.today()` |

| `pathlib` | chemins et fichiers | `Path("data").glob("*.csv")` |

| `os`, `sys` | système, variables d'environnement, arguments | `os.environ.get("HOME")`, `sys.argv` |

| `json` | lecture et écriture de JSON | `json.loads(text)`, `json.dumps(obj, ensure_ascii=False)` |

| `csv` | tableaux CSV | `csv.DictReader(f)` |

| `collections` | Counter, defaultdict, deque | `Counter("banana").most_common(1)` → [('a', 3)] |

| `itertools` | combinaisons et enchaînement d'itérateurs | `itertools.chain(a, b)` |

| `re` | expressions régulières | `re.findall(r"\d+", s)` |

| `time` | pauses et mesure du temps | `time.sleep(1)`, `time.perf_counter()` |

| `asyncio` | code asynchrone | `asyncio.run(main())` |

Python 3.15 introduit l'import paresseux (PEP 810) : `lazy import pandas as pd` reporte le chargement du module jusqu'à sa première utilisation, si bien qu'un script avec des dépendances lourdes démarre nettement plus vite.

## Commandes Python dans le terminal

Ce groupe regroupe les commandes pour lancer l'interpréteur et installer des bibliothèques. Sous Windows, on écrit en général `python` ou `py` à la place de `python3`.

| Commande | Ce qu'elle fait |
| --- | --- |

| `python3 --version` | affiche la version |

| `python3` | ouvre la console interactive REPL (sortie avec `exit()`) |

| `python3 script.py` | lance un fichier |

| `python3 -c "print(2 + 2)"` | exécute une seule ligne |

| `python3 -m venv .venv` | crée un environnement virtuel |

| `source .venv/bin/activate` / `.venv\Scripts\activate` | active l'environnement (Linux, macOS / Windows) |

| `python3 -m pip install requests` | installe un paquet |

| `pip list`, `pip freeze > requirements.txt` | liste des paquets et sauvegarde |

| `pip install -r requirements.txt` | installe les dépendances d'un fichier |

| `python3 -m http.server 8000` | serveur web simple dans le dossier courant |

| `uv init`, `uv add requests`, `uv run main.py` | projet, dépendance et lancement avec le gestionnaire uv |

## Erreurs fréquentes des débutants

- **Comparer avec `=`** — dans une condition, il faut `==` ; un seul `=` est une affectation.
- **Deux-points oublié** après `if`, `for`, `def` : cela donne une `SyntaxError`.
- **Additionner une chaîne et un nombre** : `"Âge : " + 25` provoque une erreur ; écrivez `f"Âge : {25}"`.
- **Modifier une liste pendant son parcours** — parcourez une copie `for x in a[:]` ou construisez une nouvelle liste.
- **`input()` renvoie une chaîne** — pour un calcul, enveloppez-la dans `int()` ou `float()`.

## Conclusion

La syntaxe de Python repose sur l'indentation, les deux-points et un petit nombre de constructions : conditions, boucles for et while, fonctions, classes. Ajoutez une vingtaine de fonctions intégrées et les méthodes des chaînes, des listes et des dictionnaires : vous couvrez la plupart des tâches du quotidien. Gardez cet aide-mémoire sous la main ; quand les tableaux deviendront familiers, passez aux modules et à l'asynchrone. Tout cela est présenté pas à pas, avec la pratique, dans le cours « Python 3.15 : de débutant à expert ».

## FAQ

**Combien d'espaces faut-il pour l'indentation en Python ?**

Selon la norme PEP 8, 4 espaces par niveau. L'essentiel est de rester cohérent dans tout le bloc et de ne pas mélanger avec les tabulations.

**Quelle différence entre une liste et un tuple ?**

La liste est modifiable : on peut la compléter et la trier sur place ; le tuple ne se modifie pas, il peut donc servir de clé de dictionnaire et représenter un ensemble de valeurs fixe.

**Comment voir toutes les méthodes d'un objet directement dans Python ?**

Appelez dir(obj) pour la liste des noms et help(obj) pour leur description ; par exemple, help(str) affiche toutes les méthodes des chaînes.

**Quelle différence entre sort() et sorted() ?**

La méthode list.sort() trie la liste elle-même et renvoie None, tandis que la fonction sorted() renvoie une nouvelle liste et accepte toute collection itérable.

**Faut-il un point-virgule en fin de ligne en Python ?**

Non. Le point-virgule permet de séparer plusieurs instructions sur une même ligne, mais dans un code normal chaque instruction commence sur sa propre ligne.


---
Source: Skillaria.Top (https://skillaria.top)