Cours de Python

Apprenez Python pas à pas dans votre navigateur — cours en ligne gratuit de 68 articles et 250 exercices pratiques. De print, variables et types de données aux if / for / fonctions / gestion des exceptions, classes et héritage, méthodes spéciales et POO, modules et packages pour organiser plusieurs fichiers, jusqu'à la bibliothèque standard (datetime / os / re / json / asyncio). Acquérez le plus rapidement possible des compétences Python utilisables en entreprise, même en partant de zéro. Aucune installation requise.

0/73テキスト終了（0%）

Les bases de Python

Ce que tu vas apprendre dans ce cours Python — Niveau pro, le plus rapidement possible
Une vue d'ensemble du programme complet du cours Python. Découvre quoi apprendre et dans quel ordre pour bâtir des compétences Python prêtes pour la production le plus rapidement possible — syntaxe, POO et bibliothèque standard — plus ce qui reste essentiel à l'ère de l'IA : des bases solides et la gestion d'erreurs.
Affichage et commentaires
Ton tout premier pas en Python. Un guide pour débutants qui couvre l'affichage à l'écran avec print(), les commentaires avec # et """, et l'insertion de valeurs avec les f-strings.
Variables et types de données
Un guide pour débutants sur les variables Python et les types de données — utiliser int et str, le typage dynamique et la réaffectation, les règles de nommage et les mots réservés, la convention des constantes, et la conversion entre int et str.
Booléens et construction de conditions
Un guide pour débutants sur le type booléen de Python — les deux valeurs True et False, comment les opérateurs de comparaison produisent des booléens, les opérateurs logiques and / or / not, et comment éviter la confusion classique entre = et ==.
Nombres et flottants (float)
Plongée dans les types numériques de Python — int vs float, l'opérateur de puissance ** et les affectations composées comme +=, la différence entre / et //, les pièges de précision des flottants, et la conversion avec int() et float().
Comment utiliser les chaînes Python (str)
Un guide complet sur le type chaîne (str) de Python. Apprends quand utiliser les guillemets simples, doubles ou triples ; comment l'indexation et le slicing extraient des caractères ; les méthodes de transformation comme upper/lower/replace/strip ; et les méthodes d'inspection comme count/find/startswith/isdigit — le tout avec des exercices pratiques exécutables.
Conversion entre nombres et chaînes
Un guide clair pour convertir entre nombres et chaînes en Python. Des bases de str() pour transformer un nombre en chaîne, et int() / float() pour transformer une chaîne en nombre, jusqu'à éviter TypeError / ValueError et convertir une chaîne décimale en entier — le tout avec des exercices exécutables.
Comment utiliser les listes Python (list)
Un guide complet sur le type liste de Python. Apprends la déclaration et l'indexation, le slicing pour extraire des tranches, les méthodes d'ajout et de suppression comme append/extend/insert/remove/pop, ainsi que sort/reverse/count/index — le tout avec des exercices exécutables.
Comment utiliser les dictionnaires Python (dict)
Un guide complet sur le type dict de Python. Déclarer des paires clé-valeur, la différence entre [] et .get() lors de l'accès, ajouter/mettre à jour/supprimer des entrées, lister les données avec keys / values / items, et vérifier l'existence d'une clé avec in — le tout avec des exercices pratiques exécutables.
Utiliser les tuples Python (tuple)
Un guide sur le type tuple de Python, centré sur ce qui le différencie d'une list. On y voit la déclaration avec des parenthèses, ce que signifie vraiment l'immuabilité, les méthodes count / index, le dépaquetage de plusieurs valeurs en une ligne, et pourquoi les tuples peuvent servir de clés de dict — avec des exercices exécutables dans le navigateur.
Comment utiliser les ensembles Python (set)
Un guide sur le type ensemble (set) de Python. Couvre les deux règles qui le définissent (pas de doublons, pas d'ordre), les opérations sur les éléments avec add / remove / discard / pop / clear, les opérations ensemblistes (union / intersection / difference / symmetric_difference), et les motifs concrets — déduplication et vérifications d'appartenance rapides — avec des exercices exécutables dans le navigateur.
Types mutables et immuables
Un parcours détaillé des types mutables et immuables en Python. Le piège de y = x qui fait partager la même boîte entre deux variables, pourquoi cela devient un bug, et comment copy() te donne une version indépendante — le tout avec des exercices exécutables dans le navigateur.
Récapitulatif des types Python — pourquoi les types comptent et la porte vers les classes
Un récapitulatif des types de données vus dans Python Basics. Revois ce qu'est vraiment un « type », compare dans un tableau quel type va avec quel usage, et fais un premier pas dans l'OOP — définir ton propre type avec class — le tout en schémas.
Exercices de récap des bases Python — Mets en code ce que tu as appris
Trois exercices qui rassemblent ce que tu as appris dans les bases Python — manipulation des chaînes, conversion de type, opérations ensemblistes et mutabilité. Écris du code, exécute-le et révise tout le chapitre d'un coup.

Syntaxe Python

if / elif / else et branchements avancés
Un regard plus approfondi sur les branchements conditionnels de Python — la logique multi-voies avec elif / else, la truthiness couvrant les chaînes vides et 0, l'opérateur ternaire, la différence entre is et ==, les vérifications de type avec isinstance, et les vérifications d'éléments avec in / not in — le tout avec des exercices pratiques exécutables.
Vérifications groupées avec all() et any()
Un guide à partir de zéro sur all() / any() pour juger en bloc les éléments d'une liste ou d'un tuple. Apprends all() pour « tout est-il True ? », any() pour « au moins un est-il True ? », leurs cas d'usage typiques, et comment les combiner avec for — le tout avec des exercices pratiques exécutables.
Listes en compréhension et expressions dict / set / génératrices — Construire des collections en une ligne
Un guide pratique des compréhensions Python : liste, dict, set, et expressions génératrices, avec le filtrage par if. Avec des exercices exécutables.
Boucles for avec range / enumerate / zip
Un parcours systématique de l'instruction for de Python. Boucler sur des listes et des dicts un élément à la fois, utiliser range() pour les boucles à compteur fixe, les boucles indexées avec enumerate(), l'itération parallèle sur plusieurs listes avec zip(), et le contrôle de boucle avec break / continue — le tout avec des exercices pratiques exécutables.
Boucles while et éviter les boucles infinies
Un guide à partir de zéro sur la boucle while de Python. Répéter tant qu'une condition tient, construire des conditions de terminaison pour éviter les boucles infinies, sortir de force avec break et sauter avec continue, et choisir entre for et while — le tout avec des exercices pratiques exécutables.
L'opérateur morse := pour affecter et tester en une ligne
Découvre l'opérateur morse := de Python 3.8 en exécutant chaque exemple en direct. Couvre la syntaxe de base pour affecter et tester en une seule ligne, les motifs typiques avec if et while, et des exercices exécutables pour bien l'ancrer.
Attraper les exceptions avec try / except
Découvre la gestion des exceptions de Python try / except en exécutant chaque exemple en direct. Couvre la différence entre erreurs de syntaxe et erreurs d'exécution, la forme de base de try / except, la capture de l'objet exception avec as e, le traitement séparé de plusieurs exceptions, le filet Exception, et le nettoyage avec finally — chaque sujet accompagné d'un exercice exécutable.
Lever des exceptions avec raise / Classes d'exceptions personnalisées
Apprends à **lever tes propres** exceptions en Python avec raise. Couvre les bases de raise ClasseException("message"), le motif if + raise pour la validation, et la définition de ta propre exception avec class MyError(Exception): pour l'attraper précisément avec try / except — le tout avec des exercices exécutables.
Définir des fonctions avec def — arguments, valeurs de retour, arguments par défaut et nommés
Découvre la définition de fonctions Python def en exécutant chaque exemple en direct. Couvre les bases de def et return, les arguments côté appelant et les valeurs de retour, les arguments par défaut et les arguments nommés — chaque sujet accompagné d'un exercice exécutable.
Arguments à longueur variable *args / **kwargs et valeurs de retour multiples
Apprends *args / **kwargs et les valeurs de retour multiples dans le navigateur. Les schémas couvrent les arguments positionnels et nommés, le dépaquetage avec *list / **dict, et les retours en tuple. Avec des exercices.
Arguments de fonction et références d'objets — les mutables se modifient à l'intérieur des fonctions
Apprends comment les arguments de fonction Python diffèrent selon le type. Pourquoi list/dict se propagent à l'appelant alors que int/str non, le motif .copy() pour protéger, et le piège des arguments par défaut mutables.
Fonctions internes et clôtures — maîtriser la portée avec global et nonlocal
Parcours la portée Python, les fonctions internes et les clôtures : la séparation entre globales et locales, quand utiliser global et nonlocal, et comment retourner une fonction qui se souvient des valeurs externes. Avec exercices.
Fonctions génératrices avec yield — produire des valeurs une à une pour économiser la mémoire
Parcours les fonctions génératrices Python : yield pour retourner les valeurs une par une, les récupérer avec next() et for, l'écart mémoire entre une liste et un générateur, et le chaînage avec yield from. Avec des exercices exécutables.
Fonctions d'ordre supérieur — traiter les fonctions comme arguments et valeurs de retour
Parcours les fonctions d'ordre supérieur Python dans le navigateur : affecter une fonction à une variable, la passer en callback pour échanger le comportement, brancher entre plusieurs callbacks, et retourner une clôture qui se souvient de son réglage. Avec exercices exécutables.
Expressions lambda — écrire des fonctions anonymes en une ligne
Apprends les expressions lambda Python depuis zéro en exécutant du code dans ton navigateur. Couvre la forme de base lambda args: expression, les arguments multiples, les expressions conditionnelles, les arguments par défaut, l'association avec les fonctions d'ordre supérieur comme la key de sorted, et quand revenir à def — le tout avec des exercices exécutables.
Décorateurs — ajouter du comportement aux fonctions avec @
Parcours les décorateurs Python dans ton navigateur, depuis les bases. Couvre la syntaxe @decorator, la forme standard def → return inner, le passage de n'importe quels arguments avec *args / **kwargs, les décorateurs avec arguments comme @repeat(3), et les usages réels dans des frameworks comme Flask et pytest. Avec exercices exécutables.
map() — appliquer une fonction à chaque élément d'une liste d'un coup
Un parcours exécutable dans le navigateur de la fonction map() de Python depuis zéro. Couvre les bases de map(function, iterable), la matérialisation des résultats avec list(), l'association avec les lambdas et les fonctions intégrées comme int, le passage de plusieurs iterables à la fois, et le choix entre map() et les compréhensions de liste — avec des exercices pratiques tout du long.
Récapitulatif de la syntaxe Python — Choisir entre flux de contrôle et fonctions
Un tour d'horizon de la syntaxe Python (flux de contrôle et fonctions). Une carte claire qui croise branchement conditionnel, boucles, gestion d'exceptions et applications des fonctions.
Exercices de récap de la syntaxe Python — Combiner flux de contrôle, fonctions et exceptions
Trois exercices qui rassemblent ce que tu as appris dans la syntaxe Python — flux de contrôle, fonctions, compréhensions, gestion d'exceptions et décorateurs — sous forme de problèmes de révision.

Programmation orientée objet en Python

Classes et instances — Définir ton propre type
Apprends les classes et instances Python depuis zéro. Découvre class, le rôle de self et __init__ pour fixer les attributs, le tout avec des schémas.
Le constructeur __init__ et le destructeur __del__
Un guide pratique de __init__ et __del__ en Python. Attributs requis, valeurs par défaut, et la méthode de nettoyage appelée à del ou à la fin du programme.
Variables de classe vs variables d'instance — Où vivent vraiment les valeurs
Variables de classe vs variables d'instance en Python, illustré. Vois ce qui est partagé, ce qui est par instance, et ce que self.x = ... fait vraiment.
Méthodes d'instance, de classe et statiques — Les trois types de méthodes
Apprends les trois types de méthodes Python — d'instance, de classe et statique — avec des schémas. Découvre l'utilisation de self / cls / sans premier argument et quand choisir chacune.
Méthodes spéciales — Apprendre à ta classe comment + et print se comportent
Tour des méthodes spéciales (dunder) Python. Définis + avec __add__, sépare les chaînes pour utilisateur et développeur avec __str__ / __repr__, redéfinis == significativement avec __eq__, plus les usages typiques de __call__, __len__ et __bool__. Pratique inclus.
L'héritage de classe — Réutiliser les fonctionnalités d'une classe existante
Tour de l'héritage de classe Python. Hérite des attributs et méthodes avec class Enfant(Parent):, surcharge des méthodes dans les sous-classes, appelle la logique du parent avec super().method(), et fait grandir les attributs en surchargeant __init__ — le pattern standard. Pratique inclus.
Héritage multiple et MRO — Hériter de plusieurs parents
Tour de l'héritage multiple Python. Combine des parents avec class Enfant(A, B):, vois comment l'**ordre de résolution des méthodes (MRO)** choisit parmi les méthodes de même nom, vérifie l'ordre avec __mro__, parcourt la linéarisation C3 pour l'héritage en diamant, et cible un parent par nom de classe. Pratique inclus.
Polymorphisme — Même nom de méthode, comportement différent par type
Tour du polymorphisme Python. Surcharge la méthode d'un parent par sous-classe pour que les appelants utilisent un seul nom quel que soit le type, traite des types mélangés dans une boucle, remplace les branches if type(...) par de la POO plus propre, et apprends le **duck typing**. Pratique inclus.
Variables privées et encapsulation — Accès sûr via getter / setter
Tour des variables privées et de l'encapsulation en Python. La différence entre l'underscore simple _name (privé par convention) et le double __name (name mangling), comment protéger les attributs avec getter/setter, le style raffiné des décorateurs @property / @xxx.setter, et la validation à l'intérieur du setter. Pratique inclus.
Entrées/sorties fichier — Lire et écrire en sécurité avec with open()
Tour des E/S fichier Python. Comment basculer entre lecture (r) / écriture (w) / ajout (a) avec with open(), et la différence entre read / readlines / readline, expliqués pas à pas.
Instruction with et gestionnaires de contexte — Ouverture/fermeture sûre avec __enter__ / __exit__
Tour de l'instruction with et des gestionnaires de contexte Python. Le mécanisme qui automatise l'acquisition et la libération de ressources, comment as reçoit la valeur de retour de __enter__, la garantie de nettoyage par __exit__, le rôle de exc_type / exc_val / traceback en cas d'exception, et des cas pratiques comme les fichiers et connexions DB. Pratique inclus.
Annotations de type — Laisse ton intention dans le code avec : int et -> str
Tour des annotations de type (type hints) Python. Comment effacer le doute « c'est quoi ce type d'argument ? » dans un langage typé dynamiquement, la signature de fonction def f(x: int) -> str:, quand écrire des annotations de variable name: str = "Alice" et quand non, le mécanisme des vérifications statiques par IDE et mypy, et le fait que les types ne sont pas appliqués à l'exécution. Pratique inclus.
Récapitulatif Python OOP — Regrouper données et comportement dans des classes
Récapitulatif de la POO en Python. Couvre les fondamentaux des classes, l'héritage et le polymorphisme, les méthodes spéciales (dunder), l'instruction with, l'encapsulation et les annotations de type sur l'ensemble de la série, avec des liens croisés vers chaque article.
Exercices de récap de la POO Python — Mets en code ce que tu as appris
Quatre exercices qui rassemblent ce que tu as appris dans la POO Python — définitions de classes avec méthodes spéciales, héritage, encapsulation et polymorphisme. Écris du code, exécute-le et révise tout le chapitre d'un coup.

Python Intermédiaire

Modules et packages — Importer depuis d'autres fichiers
Apprends les différences entre modules, packages et bibliothèques Python plus comment l'instruction import récupère des fonctions depuis d'autres fichiers. Couvre les bibliothèques standard vs tierces, importer tes propres modules, ce qui s'exécute au moment de l'import, le test __name__ == "__main__", et la combinaison de plusieurs modules — avec des exercices pratiques exécutables.
__init__.py et imports relatifs — Regrouper des fichiers en package
Apprends le rôle de __init__.py pour construire des packages Python et quand recourir aux imports absolus vs relatifs. Couvre le regroupement de plusieurs modules sous un seul dossier, la restriction de l'API publique avec les imports depuis le package, le mélange correct d'imports absolus et relatifs, et une disposition de dossiers de vrai projet — avec des exercices pratiques exécutables.
Catégories de la bibliothèque standard — Quand utiliser quoi
Obtiens une vue d'ensemble de la bibliothèque standard de Python répartie en 7 catégories. Gestion des dates, calculs numériques, E/S de données, concurrence — découvre quoi importer pour chaque situation.
sys et argparse — Infos runtime et analyse d'arguments
Apprends les modules sys et argparse de Python depuis la base. De la lecture des infos runtime avec sys.path / sys.argv / sys.exit à la construction d'analyseurs d'arguments structurés avec argparse — le tout en pratique.
os et pathlib — Chemins de fichiers et opérations sur les dossiers
Apprends les modules os.path et pathlib de Python depuis les bases. Construis des chemins indépendants de l'OS, liste et parcours récursivement les dossiers, et décompose les chemins en morceaux avec les objets Path — le tout en pratique.
shutil et tempfile — Opérations en masse et fichiers temporaires
Apprends shutil et tempfile de Python depuis la base. Opérations en masse sur les fichiers avec shutil.copy / shutil.move / shutil.rmtree, plus comment utiliser les fichiers temporaires en sécurité via tempfile.NamedTemporaryFile — le tout en pratique.
datetime et time — Travailler avec dates, heures et temps écoulé
Apprends les modules datetime / time / calendar de Python depuis la base. Couvre l'arithmétique de dates avec date / datetime / timedelta, la conversion de chaînes via strftime / strptime, et la mesure du temps écoulé avec time.perf_counter — le tout en pratique.
math et statistics — Calculs ponctuels et agrégation de données
Apprends les modules math et statistics de Python depuis la base. Couvre les calculs sur valeur unique avec math.sqrt / pi / floor / ceil / log, l'agrégation de données avec statistics.mean / median / mode / stdev, et la répartition des responsabilités entre les deux modules — avec des exercices pratiques exécutables.
decimal et fractions — Arithmétique précise sans erreurs de flottants
Apprends les modules decimal et fractions de Python depuis la base. Couvre le problème 0.1 + 0.2 != 0.3 avec float, le calcul monétaire exact avec Decimal (et pourquoi tu construis les Decimal depuis des chaînes), l'arithmétique avec Fraction qui réduit automatiquement, et le choix entre les trois types numériques — avec des exercices pratiques exécutables.
random et secrets — Choisir les bons nombres aléatoires
Apprends les modules random et secrets de Python depuis la base. Couvre les séquences pseudo-aléatoires reproductibles avec random.choice / randint / shuffle / sample plus seed, les jetons cryptographiquement sûrs avec secrets.token_hex / token_urlsafe, et quand utiliser l'un plutôt que l'autre — avec des exercices pratiques exécutables.
Expressions régulières re — Recherche de motifs et substitution
Apprends le module re de Python depuis la base. Couvre quand recourir à re.match / re.search / re.findall, la combinaison des métacaractères \d / \w / \s / * / + / ?, la capture de groupes avec ( ), la substitution avec re.sub, et la réutilisation de motifs avec re.compile — avec des exercices pratiques exécutables.
string et textwrap — Constantes de caractères, gabarits et formatage
Apprends les modules string et textwrap de Python depuis la base. Couvre les constantes de caractères comme string.ascii_letters / digits, la substitution de gabarit style $name avec string.Template, la suppression de l'indentation des chaînes triple-guillemets avec textwrap.dedent, et le retour à la ligne par largeur avec fill — avec des exercices pratiques exécutables.
pprint — Lire confortablement les dicts et lists imbriqués
Apprends le module pprint de Python depuis la base. Couvre comment pprint.pp préserve la structure lisible des dict / list imbriqués là où print échoue, la conversion en chaîne avec pformat, les options width / indent / sort_dicts, et son usage dans le débogage quotidien — avec des exercices pratiques exécutables.
json et csv — Lire et écrire des données structurées
Apprends les modules json et csv de Python depuis la base. Couvre la conversion entre objets Python et chaînes JSON avec json.dumps / loads, le formatage avec indent et ensure_ascii, la lecture et l'écriture par position avec csv.writer / reader, et les E/S basées sur les noms de colonnes avec DictWriter / DictReader — avec des exercices pratiques exécutables.
pickle et base64 — Sérialiser des objets et encoder du binaire en texte
Apprends les modules pickle et base64 de Python depuis la base. Couvre la sérialisation d'objets Python avec pickle.dumps / loads, la conversion de données binaires en texte et inversement avec base64.b64encode / b64decode, quand choisir la variante urlsafe, et les précautions de sécurité de pickle — avec des exercices pratiques exécutables.
hashlib — Calculer des valeurs de hachage pour les données
Apprends le module hashlib de Python depuis la base. Couvre les valeurs de hachage de longueur fixe via SHA-256, les trois propriétés (déterministe, effet d'avalanche, sens unique), la mise en œuvre de la détection d'altération et des contrôles d'intégrité, et pourquoi le stockage de mots de passe ne devrait pas reposer uniquement sur hashlib — avec des exercices pratiques exécutables.
collections — Counter / defaultdict / deque / namedtuple
Apprends le module collections de Python depuis la base. Couvre le comptage avec Counter et most_common, la gestion des clés manquantes avec defaultdict, les opérations en O(1) aux deux extrémités et les buffers circulaires via deque + maxlen, et l'accès par attribut plus la conversion en dict avec namedtuple — avec des exercices pratiques exécutables.
itertools et functools — Boîtes à outils d'itération et de composition de fonctions
Apprends les modules itertools et functools de Python depuis la base. Couvre l'itération avec combinations / product / chain / accumulate, le verrouillage d'arguments avec partial, et l'accélération des appels avec la mémoïsation lru_cache — avec des exercices pratiques exécutables.
enum et dataclasses — Constantes nommées et classes de données
Apprends les modules enum et dataclasses de Python depuis la base. Couvre les constantes nommées avec Enum et IntEnum / auto, la génération automatique de __init__ / __eq__ / __repr__ via @dataclass, et le choix entre field et frozen=True — avec des exercices pratiques exécutables.
contextlib — Gestion de ressources et with personnalisé
Apprends le module contextlib de Python depuis la base. Couvre l'écriture facile de ton propre with via @contextmanager et l'absorption d'exceptions spécifiques avec suppress — avec des exercices pratiques exécutables.
logging — Enregistrer au lieu de print
Apprends le module logging de Python depuis la base. Couvre le routage par niveau et la configuration basicConfig, le formatage unifié via Formatter, la sortie fichier via FileHandler, la configuration yaml + dictConfig, et la rotation via RotatingFileHandler — avec des exercices pratiques exécutables.
Bases d'async / await — Accélérer un programme en réutilisant le temps d'attente
Apprends async et await de Python depuis zéro. Coroutines, event loop, asyncio.sleep, asyncio.run et top-level await — illustrés avec des exercices pratiques.
asyncio Tasks — Exécution concurrente avec gather, Task et Queue
Apprends asyncio en Python pour du code concurrent : gather pour des exécutions parallèles, create_task pour lance-et-attends-plus-tard, wait_for pour les timeouts, et Queue pour producteur / consommateur.
threading et multiprocessing — Threads, processus et le GIL
Un parcours illustré des modules threading, multiprocessing et subprocess de Python. Couvre threads vs processus, la contrainte du GIL, l'utilisation de ThreadPoolExecutor et Pool, le choix entre charges I/O-bound, CPU-bound et commandes externes, et la comparaison avec les bibliothèques vectorisées comme NumPy — avec des schémas pour organiser les concepts.
Récapitulatif de la bibliothèque standard Python — 17 modules en 7 catégories
Un récapitulatif illustré de la série sur la bibliothèque standard Python. 17 modules organisés en 7 catégories, ce que sont les bibliothèques externes, la transition standard → externe, et les bibliothèques tierces incontournables par cas d'usage.
Conclusion du cours Python — Bravo d'être arrivé jusque-là
Un article pour celles et ceux qui ont parcouru les quatre chapitres du cours Python jusqu'au bout.