Python pour Débutants

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.

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.

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 ==.

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().

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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é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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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 en Python, illustré. Vois ce qui est partagé, ce qui est par instance, et ce que self.x = ... fait vraiment.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Apprends le module hashlib de Python depuis la base. Couvre les « empreintes » 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.

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.

Apprends les modules itertools et functools de Python depuis la base. Couvre les recettes d'itération via combinations / product / chain / accumulate, le verrouillage d'arguments avec partial, le pliage avec reduce, et l'accélération des appels avec la mémoïsation @lru_cache — avec des exercices pratiques exécutables.

Apprends les modules enum et dataclasses de Python depuis la base. Couvre le remplacement des chaînes magiques par Enum, la numérotation automatique avec IntEnum et auto, la génération automatique de __init__ / __eq__ / __repr__ via @dataclass, et l'évitement des pièges des valeurs par défaut mutables avec field(default_factory=list) — avec des exercices pratiques exécutables.

Apprends les modules contextlib et logging de Python depuis la base. Couvre l'écriture de tes propres gestionnaires de contexte avec @contextmanager, l'absorption d'exceptions spécifiques avec suppress, la gestion dynamique de ressources via ExitStack, et les journaux de qualité production avec routage par niveau et Formatter — avec des exercices pratiques exécutables.

Apprends async / await de Python depuis la base. Couvre pourquoi une version synchrone gaspille le temps d'attente, la définition de coroutines avec async def, l'attente de l'achèvement avec await, la différence entre asyncio.sleep et time.sleep, et asyncio.run vs le top-level await de Pyodide — avec des exercices pratiques exécutables.

Apprends asyncio avancé en Python. Couvre l'exécution concurrente de plusieurs coroutines avec asyncio.gather tout en préservant l'ordre d'entrée, la création de Task avec create_task, l'application de timeouts avec wait_for, et le motif producteur-consommateur via asyncio.Queue — avec des exercices pratiques exécutables.

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.

Un récapitulatif de 17 modules de la bibliothèque standard Python. Vue d'ensemble en 7 catégories, antisèche pour 20 situations, quand passer aux bibliothèques tierces (requests / pandas / NumPy / pytest / FastAPI / SQLAlchemy, etc.), et une feuille de route d'apprentissage après la bibliothèque standard — le tout illustré.