Cours Python

Les fondations : déclarer des variables, identifier les types, effectuer des calculs, prendre des décisions et afficher dans la console.

1. 1.1Variables et typesDonner un nom à une valeur, découvrir son type avec type(), connaître int / float / str / bool / None.~10 min
2. 1.2OpérateursArithmétique (y compris // et **), comparaison, logique booléenne avec and / or / not, précédence.~10 min
3. 1.3Conditionnels : if, elif, elseExécuter du code différent selon une condition ; le rôle de l'indentation.~10 min
4. 1.4Affichage et f-stringsprint() pour afficher des valeurs, f-strings pour composer du texte avec l'interpolation `{var}`.~8 min

Répéter, sauter, gérer les erreurs : les structures qui font réagir le programme aux données et aux problèmes.

1. 2.1Boucles for et rangeItérer sur une séquence avec for, générer des intervalles numériques avec range(start, stop, step).~10 min
2. 2.2Boucles whileRépéter tant qu'une condition reste vraie ; quand préférer while à for.~8 min
3. 2.3break, continue et else dans les bouclesSortir prématurément d'une boucle, sauter une itération, utiliser la clause particulière for…else.~10 min
4. 2.4Gestion des erreurs : try/exceptCapturer des exceptions spécifiques, distinguer try/except/else/finally, lever des erreurs avec raise.~12 min

Les quatre collections intégrées : list (séquence mutable), tuple (séquence immutable), dict (table d'association clé-valeur) et set (collection d'éléments uniques).

1. 3.1ListesCréer, y accéder par indice et slice, ajouter et supprimer, trier. La séquence que vous utiliserez le plus.~12 min
2. 3.2Tuples et unpackingSéquences immutables, packing et unpacking, échange sans variable temporaire, * pour le reste.~10 min
3. 3.3DictionnairesTables d'association clé→valeur, accès avec [] et .get, itérer sur keys/values/items, dict.setdefault.~12 min
4. 3.4EnsemblesCollections d'éléments uniques, opérations sur les ensembles (& | - ^), test d'appartenance en temps O(1).~10 min

Manipuler du texte (méthodes, slicing) et des nombres (math, conversions de type) de manière idiomatique.

1. 4.1Méthodes des chaînesLes méthodes les plus utilisées : upper/lower, strip, split/join, replace, startswith/endswith, find/in.~12 min
2. 4.2Slicing et indexationIndices positifs et négatifs, slice [start:stop:step], inversion de chaîne, sous-chaînes.~10 min
3. 4.3Nombres et module mathint, float, division réelle vs entière, modulo %, abs/round/min/max, math.sqrt, math.pi.~10 min
4. 4.4Conversions de typeint(), float(), str(), bool() : transtypage explicite, parsing d'entrées, vérité (truthiness) des valeurs.~10 min

Définir des fonctions avec def, retourner des valeurs, gérer les paramètres par défaut, *args/**kwargs et lambda.

1. 5.1def et returnSyntaxe def, return (explicite et implicite None), paramètres positionnels, docstrings.~12 min
2. 5.2Paramètres par défaut et nommésValeurs par défaut, appels avec arguments nommés, ordre positionnels-avant-nommés, piège des valeurs par défaut mutables.~12 min
3. 5.3*args et **kwargsFonctions à nombre variable d'arguments : *args rassemble les positionnels, **kwargs rassemble les nommés. Unpacking lors de l'appel.~12 min
4. 5.4Lambda et fonctions d'ordre supérieurFonctions anonymes avec lambda, utilisation avec sorted/max/min, quand préférer def, sorted(..., key=...).~10 min

List/dict/set comprehensions, generator expressions et les outils fondamentaux du module itertools.

1. 6.1List comprehensionSyntaxe [expression for x in iter if cond], transformation, filtrage, imbrication.~12 min
2. 6.2Dict et set comprehensionSyntaxe {k: v for ...} et {x for ...} pour construire des dictionnaires et des ensembles de manière déclarative.~10 min
3. 6.3Generator expressionsSyntaxe (... for ... in ...), itération paresseuse (lazy), mémoire constante, sum/any/all sur les générateurs.~10 min
4. 6.4itertools essentielsLes fonctions les plus utilisées : enumerate, zip, chain, count, repeat, combinations.~12 min

Programmation orientée objets en Python : classes, héritage, méthodes spéciales (dunder), importations et organisation en modules.

1. 7.1Classes et instancesclass, __init__, attributs et méthodes d'instance, self, attributs de classe vs d'instance.~14 min
2. 7.2HéritageSous-classes, super(), surcharge de méthodes, isinstance, MRO de base.~12 min
3. 7.3Méthodes spéciales (dunder)__str__, __repr__, __eq__, __len__ : intégrer vos objets avec le langage.~12 min
4. 7.4import et modulesimport, from ... import, alias as, organisation en modules, if __name__ == "__main__".~10 min

Les modules de la bibliothèque standard que vous rencontrerez quotidiennement : json, datetime, collections, re.

1. 8.1JSON : sérialisation et parsingjson.dumps / json.loads, correspondance des types Python ↔ JSON, indent, sort_keys, default.~10 min
2. 8.2datetime : dates et heuresdatetime.now(), date/time/datetime/timedelta, formatage avec strftime, parsing avec strptime, arithmétique.~12 min
3. 8.3collections : Counter et defaultdictCounter pour les comptages, defaultdict pour les dictionnaires auto-initialisés, namedtuple comme enregistrement léger.~12 min
4. 8.4Module re : regex en Pythonre.search / re.match / re.findall / re.sub, flags, chaînes brutes r"...", groupes nommés.~12 min

Les pratiques modernes de Python : type hints, dataclasses, context managers et décorateurs. Le code que vous écrivez en 2025.

1. 9.1Type hints : annoter les typesAnnotations de paramètres et de retours, list[int] / dict[str, int], Optional, Union, introduction à mypy.~12 min
2. 9.2dataclasses : classes de données sans boilerplate@dataclass, field(default_factory=...), frozen=True, équivalent de __init__/__repr__/__eq__.~12 min
3. 9.3Context managers : with et __enter__/__exit__with open(...), écrire son propre gestionnaire de contexte avec __enter__/__exit__, contextlib.contextmanager.~12 min
4. 9.4Décorateurs : fonctions modifiant des fonctionsFonctions d'ordre supérieur, syntaxe @decorator, functools.wraps, exemple @timeit.~14 min