PYTHON

MASTERY GUIDE
De débutant à développeur professionnel

Variables · POO · Décorateurs · Async · Tests · Design Patterns · Performance

# Python Mastery Guide Édition 2024 — Niveau Expert

import python as mastery

def become_a_pro():
skills = load_all_chapters()
practice(skills, daily=True)
return 'Expert'
PYTHON MASTERY GUIDE [Link]

Table des matières

Fondamentaux &
01 Syntaxe, types, variables, PEP 8 p.5
Environnement

02 Structures de données list, dict, set, tuple, collections p.7

03 Fonctions avancées Closures, décorateurs, generateurs p.9

Programmation Orientée
04 Classes, héritage, dunder methods p.11
Objet

Gestion des erreurs &

05 Exceptions, context managers, I/O p.13
fichiers

06 Modules & Packages Import, pip, virtualenv, __init__ p.15

Programmation
07 asyncio, coroutines, event loop p.17
asynchrone

08 Tests & Qualité du code pytest, unittest, coverage, linting p.19

Performance &
09 Profiling, numpy, multiprocessing p.21
Optimisation

Projet professionnel
10 CLI app, API REST, best practices p.23
complet

Python Pro Guide — Niveau Expert 1 Tous droits reserves

PYTHON MASTERY GUIDE [Link]

CHAPITRE 01

Fondamentaux & Environnement

Syntaxe Python, types de données, variables, opérateurs, environnements virtuels et
conventions PEP 8.

01
1.1 Environnement de développement

Avant de coder, installe un environnement propre. Voici le workflow professionnel pour tout
nouveau projet Python.

Terminal — Environnement virtuel

1 # 1. Créer un environnement virtuel

2 python -m venv .venv
3
4 # 2. L'activer (Linux/macOS)
5 source .venv/bin/activate
6
7 # 3. L'activer (Windows)
8 .venv\Scripts\activate
9
10 # 4. Installer les dépendances
11 pip install -r [Link]
12
13 # 5. Figer les versions
14 pip freeze > [Link]

✦ Toujours utiliser un venv !

Ne jamais installer de packages globalement avec pip. Chaque projet doit avoir son propre
environnement isolé.
Utilise pyenv + virtualenv ou Poetry pour une gestion avancée.

1.2 Types de données fondamentaux

Python est dynamiquement typé mais fortement typé : le type est déterminé à l'exécution, mais
les conversions implicites sont rares.

Python Pro Guide — Niveau Expert 2 Tous droits reserves

CHAPITRE 01 | Fondamentaux & Environnement [Link]

Mutabl
Type Exemple Description
e

int x = 42 Non Entier de précision arbitraire

float pi = 3.14159 Non Virgule flottante IEEE 754

complex z = 3+4j Non Nombre complexe

str name = "Alice" Non Séquence Unicode immuable

bytes b = b'hello' Non Séquence d'octets immuable

bool flag = True Non Sous-classe de int (0/1)

list lst = [1, 2, 3] Oui Tableau dynamique ordonné

tuple t = (1, 2, 3) Non Séquence ordonnée immuable

dict d = {'a': 1} Oui Table de hachage clé-valeur

set s = {1, 2, 3} Oui Ensemble sans doublons

1.3 Typage statique avec annotations

Depuis Python 3.5+, les type hints permettent d'annoter le code. Elles n'affectent pas l'exécution
mais améliorent la lisibilité et permettent à mypy de détecter des bugs.

Python Pro Guide — Niveau Expert 3 Tous droits reserves

PYTHON MASTERY GUIDE [Link]

Python — Type Hints (PEP 484)

1 from typing import Optional, Union, List, Dict, Tuple, Any

2 from typing import Callable, TypeVar, Generic
3
4 # Annotations de variables
5 name: str = 'Alice'
6 age: int = 30
7 scores: List[float] = [95.5, 87.3, 91.0]
8
9 # Fonction typée
10 def greet(name: str, age: int = 0) -> str:
11 return f'Bonjour {name}, tu as {age} ans'
12
13 # Union types (Python 3.10+: int | str)
14 def process(data: Union[int, str]) -> str:
15 return str(data)
16
17 # Optional = Union[T, None]
18 def find_user(user_id: int) -> Optional[dict]:
19 db: Dict[int, dict] = {}
20 return [Link](user_id)

● Type hints avancés

TypeVar pour les generics : T = TypeVar('T')
Protocol pour le duck typing structurel (PEP 544)
dataclasses pour les classes de données annotées
Literal['GET', 'POST'] pour les valeurs précises

1.4 Mémoire Python

Comprendre la gestion mémoire de Python est essentiel pour écrire du code performant et éviter
les fuites.

Python Pro Guide — Niveau Expert 4 Tous droits reserves

CHAPITRE 02 | Structures de données avancées [Link]

PILE (Stack) TAS (Heap)

x 0x1F2A int: 42 0x1F2A

y 0x2B3C
str: 'Hi' 0x2B3C

lst 0x3C4D

[1,2,3] 0x3C4D
fn 0x4D5E

Python gere automatiquement la memoire via le Garbage Collector

Python — Gestion mémoire

1 import sys
2
3 # Taille en mémoire d'un objet
4 x = [1, 2, 3, 4, 5]
5 print([Link](x)) # 120 bytes
6
7 # Compteur de références
8 import ctypes
9 a = [1, 2, 3]
10 b = a # même objet, refcount += 1
11 print(id(a) == id(b)) # True
12
13 # Interning des petits entiers (-5 à 256)
14 x = 256; y = 256
15 print(x is y) # True (même objet)
16 x = 257; y = 257
17 print(x is y) # False (objets différents)

Python Pro Guide — Niveau Expert 5 Tous droits reserves

PYTHON MASTERY GUIDE [Link]

CHAPITRE 02

Structures de données avancées

list, dict, set, tuple, collections module, comprehensions, slicing avancé et algorithmes.

02
2.1 Listes — techniques avancées

Python — Listes avancées

1 # List comprehensions avec conditions

2 pairs = [x**2 for x in range(20) if x % 2 == 0]
3
4 # Comprehension imbriquée (matrice)
5 matrix = [[i*j for j in range(5)] for i in range(5)]
6
7 # Slicing avancé [start:stop:step]
8 lst = list(range(10))
9 print(lst[::2]) # [0, 2, 4, 6, 8]
10 print(lst[::-1]) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
11 print(lst[2:8:2]) # [2, 4, 6]
12
13 # Unpacking avancé (Python 3+)
14 first, *rest = [1, 2, 3, 4, 5]
15 first, *middle, last = [1, 2, 3, 4, 5]
16
17 # Tri avancé
18 people = [('Alice', 30), ('Bob', 25), ('Carol', 35)]
19 sorted_by_age = sorted(people, key=lambda x: x[1])
20 sorted_multi = sorted(people, key=lambda x: (-x[1], x[0]))

2.2 Dictionnaires — techniques pro

Python Pro Guide — Niveau Expert 6 Tous droits reserves

CHAPITRE 03 | Fonctions avancées [Link]

Python — Dictionnaires avancés

1 # Dict comprehension
2 squares = {x: x**2 for x in range(10)}
3
4 # Merge de dicts (Python 3.9+)
5 d1 = {'a': 1, 'b': 2}
6 d2 = {'b': 3, 'c': 4}
7 merged = d1 | d2 # {'a':1, 'b':3, 'c':4}
8
9 # defaultdict — valeur par défaut automatique
10 from collections import defaultdict
11 word_count = defaultdict(int)
12 for word in [Link]():
13 word_count[word] += 1
14
15 # Counter — compter des éléments
16 from collections import Counter
17 c = Counter('abracadabra')
18 print(c.most_common(3)) # [('a',5),('b',2),('r',2)]
19
20 # OrderedDict (utile avant Python 3.7)
21 from collections import OrderedDict
22 od = OrderedDict([('un', 1), ('deux', 2)])

2.3 collections module — structures spécialisées

Structure Import Cas d'usage

Counter [Link] Compter des occurrences

defaultdict [Link] Dict avec valeur par défaut

OrderedDict [Link] Dict ordonné (pre 3.7)

deque [Link] File/pile double bout O(1)

namedtuple [Link] Tuple avec champs nommés

ChainMap [Link] Chaîner plusieurs dicts

heapq heapq File de priorité (min-heap)

bisect bisect Recherche dichotomique

Python Pro Guide — Niveau Expert 7 Tous droits reserves

PYTHON MASTERY GUIDE [Link]

Python — collections & heapq

1 from collections import deque, namedtuple

2 import heapq
3
4 # deque — O(1) append/pop des deux côtés
5 q = deque(maxlen=5)
6 [Link](1); [Link](0)
7 [Link](2) # décaler
8
9 # namedtuple — tuple lisible
10 Point = namedtuple('Point', ['x', 'y', 'z'])
11 p = Point(1.0, 2.0, 3.0)
12 print(p.x, p.y, p.z) # 1.0 2.0 3.0
13
14 # heapq — file de priorité
15 heap = []
16 [Link](heap, (3, 'tâche C'))
17 [Link](heap, (1, 'tâche A'))
18 [Link](heap, (2, 'tâche B'))
19 priority, task = [Link](heap) # (1, 'tâche A')

Python Pro Guide — Niveau Expert 8 Tous droits reserves

CHAPITRE 04 | Programmation Orientée Objet [Link]

CHAPITRE 03

Fonctions avancées
Closures, décorateurs, fonctions d'ordre supérieur, générateurs, coroutines et annotations
de fonctions.

03
3.1 Closures & fonctions d'ordre supérieur

Python — Closures & higher-order functions

1 # Closure — capture de variables libres

2 def make_multiplier(factor):
3 def multiply(x):
4 return x * factor # capture 'factor'
5 return multiply
6
7 double = make_multiplier(2)
8 triple = make_multiplier(3)
9 print(double(5)) # 10
10
11 # Fonctions d'ordre supérieur
12 from functools import reduce, partial, lru_cache
13
14 nums = [1, 2, 3, 4, 5]
15 squared = list(map(lambda x: x**2, nums))
16 evens = list(filter(lambda x: x%2==0, nums))
17 total = reduce(lambda a, b: a+b, nums) # 15
18
19 # partial — application partielle
20 add = lambda x, y: x + y
21 add10 = partial(add, 10)
22 print(add10(5)) # 15

3.2 Décorateurs

Un décorateur est une fonction qui enveloppe une autre fonction pour modifier ou étendre son
comportement sans la modifier.

Python Pro Guide — Niveau Expert 9 Tous droits reserves

PYTHON MASTERY GUIDE [Link]

@retry(max=3)

@log_calls

@cache

def ma_fonction():

Les decorateurs s'appliquent de bas en haut

Python — Décorateurs avancés

1 import functools, time, logging

2
3 # Décorateur simple
4 def timer(func):
5 @[Link](func) # preserve __name__ etc.
6 def wrapper(*args, **kwargs):
7 start = time.perf_counter()
8 result = func(*args, **kwargs)
9 elapsed = time.perf_counter() - start
10 print(f'{func.__name__} : {elapsed:.4f}s')
11 return result
12 return wrapper
13
14 # Décorateur avec paramètres
15 def retry(max_attempts=3, exceptions=(Exception,)):
16 def decorator(func):
17 @[Link](func)
18 def wrapper(*args, **kwargs):
19 for attempt in range(max_attempts):
20 try:
21 return func(*args, **kwargs)
22 except exceptions as e:
23 if attempt == max_attempts - 1:
24 raise
25 [Link](2 ** attempt) # backoff
26 return wrapper
27 return decorator
28
29 @timer
30 @retry(max_attempts=3, exceptions=(ConnectionError,))
31 def fetch_data(url: str) -> dict:
32 pass # appel HTTP ici

Python Pro Guide — Niveau Expert 10 Tous droits reserves

CHAPITRE 05 | Erreurs, Fichiers & Context Managers [Link]

3.3 Générateurs & expressions génératrices

Python — Générateurs

1 # Générateur — yield suspend l'exécution

2 def fibonacci():
3 a, b = 0, 1
4 while True:
5 yield a
6 a, b = b, a + b
7
8 fib = fibonacci()
9 print([next(fib) for _ in range(10)])
10 # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
11
12 # Expression génératrice — économise la mémoire
13 total = sum(x**2 for x in range(10**6)) # pas de liste en RAM
14
15 # send() — communication bidirectionnelle
16 def accumulator():
17 total = 0
18 while True:
19 value = yield total
20 total += value
21
22 acc = accumulator()
23 next(acc) # initialiser
24 print([Link](10)) # 10
25 print([Link](5)) # 15
26
27 # lru_cache — mémoïsation
28 @functools.lru_cache(maxsize=None)
29 def fib_memo(n: int) -> int:
30 if n < 2: return n
31 return fib_memo(n-1) + fib_memo(n-2)

▲ Attention avec lru_cache

Ne jamais utiliser lru_cache sur des méthodes d'instance sans précaution — cela maintient
des références et peut causer des fuites mémoire. Utilise functools.cached_property à la
place.

Python Pro Guide — Niveau Expert 11 Tous droits reserves

PYTHON MASTERY GUIDE [Link]

CHAPITRE 04

Programmation Orientée Objet

Classes, héritage, méthodes spéciales, métaclasses, descripteurs, abstract base classes
et design patterns.

04
4.1 Classes — anatomie complète

Python Pro Guide — Niveau Expert 12 Tous droits reserves

CHAPITRE 06 | Modules, Packages & Distribution [Link]

Python — Classe complète

1 from abc import ABC, abstractmethod

2 from dataclasses import dataclass, field
3 from typing import ClassVar
4
5 class Animal(ABC):
6 species_count: ClassVar[int] = 0 # variable de classe
7
8 def __init__(self, name: str, age: int):
9 [Link] = name
10 [Link] = age
11 self._energy = 100 # convention privé
12 self.__secret = 42 # name mangling
13 Animal.species_count += 1
14
15 # Méthode abstraite — doit être implémentée
16 @abstractmethod
17 def speak(self) -> str: ...
18
19 # Property — getter/setter propre
20 @property
21 def energy(self) -> int: return self._energy
22
23 @[Link]
24 def energy(self, value: int):
25 self._energy = max(0, min(100, value))
26
27 # Méthode de classe
28 @classmethod
29 def create_default(cls) -> 'Animal': ...
30
31 # Méthode statique
32 @staticmethod
33 def is_valid_age(age: int) -> bool:
34 return 0 <= age <= 150
35
36 # Dunder methods
37 def __repr__(self) -> str:
38 return f'Animal(name={[Link]!r}, age={[Link]})'
39
40 def __eq__(self, other) -> bool:
41 return isinstance(other, Animal) and [Link] == [Link]
42
43 def __lt__(self, other) -> bool:
44 return [Link] < [Link]
45
46 def __hash__(self) -> int: # si __eq__ défini, __hash__ requis
47 return hash([Link])

Python Pro Guide — Niveau Expert 13 Tous droits reserves

PYTHON MASTERY GUIDE [Link]

4.2 Héritage & MRO

Animal
# Attributs
+nom: str
+age: int
# Methodes
__init__()
Chien parler() Chat
__str__()
# Attributs # Attributs
+race: str +couleur: str
# Methodes # Methodes
aboyer() miauler()
fetch() griffer()

Diagramme UML — Heritage Python

Python — Héritage & MRO

1 class Dog(Animal):
2 def __init__(self, name: str, age: int, breed: str):
3 super().__init__(name, age) # appel parent
4 [Link] = breed
5
6 def speak(self) -> str:
7 return f'Woof! Je suis {[Link]}'
8
9 # MRO — Method Resolution Order
10 # print(Dog.__mro__)
11
12 # Héritage multiple & super()
13 class A:
14 def method(self): return 'A'
15
16 class B(A):
17 def method(self): return 'B > ' + super().method()
18
19 class C(A):
20 def method(self): return 'C > ' + super().method()
21
22 class D(B, C): # MRO: D -> B -> C -> A
23 pass
24
25 print(D().method()) # 'B > C > A'

4.3 dataclasses — classes de données modernes

Python Pro Guide — Niveau Expert 14 Tous droits reserves

CHAPITRE 07 | Programmation Asynchrone [Link]

Python — dataclasses

1 from dataclasses import dataclass, field

2 from typing import List
3
4 @dataclass(frozen=True, order=True) # immuable + comparable
5 class Point:
6 x: float
7 y: float
8 z: float = 0.0
9
10 def distance(self) -> float:
11 return (self.x**2 + self.y**2 + self.z**2) ** 0.5
12
13 @dataclass
14 class Team:
15 name: str
16 members: List[str] = field(default_factory=list)
17 _score: int = field(default=0, repr=False)
18
19 def add_member(self, member: str) -> None:
20 [Link](member)
21
22 # Usage
23 p1 = Point(3.0, 4.0)
24 p2 = Point(1.0, 2.0)
25 print(sorted([p1, p2])) # ordre automatique

✦ Choisir entre dataclass, namedtuple et TypedDict

dataclass : données mutables avec méthodes — usage général
frozen dataclass : immuable, hashable, remplace namedtuple
TypedDict : pour typer les dicts JSON existants
namedtuple : compatibilité ancienne code, léger

Python Pro Guide — Niveau Expert 15 Tous droits reserves

PYTHON MASTERY GUIDE [Link]

CHAPITRE 05

Erreurs, Fichiers & Context Managers

Hiérarchie des exceptions, création d'exceptions custom, context managers, pathlib et
gestion I/O avancée.

05
5.1 Exceptions — hiérarchie et bonnes pratiques

Python — Exceptions

1 # Exceptions personnalisées
2 class AppError(Exception):
3 """Erreur de base de l'application."""
4 def __init__(self, message: str, code: int = 0):
5 super().__init__(message)
6 [Link] = code
7
8 class ValidationError(AppError): pass
9 class DatabaseError(AppError): pass
10
11 # try / except / else / finally
12 def safe_divide(a: float, b: float) -> float:
13 try:
14 result = a / b
15 except ZeroDivisionError:
16 raise ValidationError('Diviseur ne peut pas être 0', 400)
17 except TypeError as e:
18 raise ValidationError(f'Type invalide: {e}', 422)
19 else:
20 return result # si aucune exception
21 finally:
22 pass # toujours exécuté
23
24 # ExceptionGroup (Python 3.11+)
25 try:
26 raise ExceptionGroup('multiple', [ValueError(), TypeError()])
27 except* ValueError as eg:
28 print(f'ValueError: {[Link]}')

5.2 Context Managers — le protocole with

Python Pro Guide — Niveau Expert 16 Tous droits reserves

CHAPITRE 08 | Tests & Qualité du code [Link]

Python — Context Managers

1 from contextlib import contextmanager, suppress

2 import contextlib
3
4 # Context manager avec classe
5 class DatabaseConnection:
6 def __init__(self, url: str):
7 [Link] = url
8 [Link] = None
9
10 def __enter__(self):
11 [Link] = connect([Link])
12 return [Link]
13
14 def __exit__(self, exc_type, exc_val, exc_tb):
15 if [Link]:
16 [Link]()
17 return False # ne pas supprimer l'exception
18
19 # Context manager avec générateur (plus concis)
20 @contextmanager
21 def timer_context(label: str):
22 import time
23 start = time.perf_counter()
24 try:
25 yield
26 finally:
27 elapsed = time.perf_counter() - start
28 print(f'{label}: {elapsed:.4f}s')
29
30 # suppress — ignorer certaines exceptions
31 with suppress(FileNotFoundError):
32 [Link]('fichier_peut_ne_pas_exister.tmp')

5.3 Pathlib — gestion moderne des fichiers

Python Pro Guide — Niveau Expert 17 Tous droits reserves

PYTHON MASTERY GUIDE [Link]

Python — Pathlib & I/O

1 from pathlib import Path

2 import json, csv
3
4 # Chemins orientés objet
5 project = Path('/home/user/project')
6 config = project / 'config' / '[Link]'
7
8 # Opérations courantes
9 [Link](parents=True, exist_ok=True)
10 config.write_text([Link]({'debug': True}), encoding='utf-8')
11 data = [Link](config.read_text())
12
13 # Glob — rechercher des fichiers
14 py_files = list([Link]('*.py'))
15 print(f'{len(py_files)} fichiers Python')
16
17 # Informations sur le fichier
18 stat = [Link]()
19 print(f'Taille: {stat.st_size} bytes')
20 print(f'Extension: {[Link]}') # .json
21 print(f'Nom: {[Link]}') # settings
22
23 # Lecture CSV
24 import csv
25 with open('[Link]', newline='') as f:
26 reader = [Link](f)
27 rows = list(reader)

Python Pro Guide — Niveau Expert 18 Tous droits reserves

CHAPITRE 09 | Performance & Optimisation [Link]

CHAPITRE 06

Modules, Packages & Distribution

Organisation du code, import system, création de packages, [Link], publication
sur PyPI.

06
6.1 Système d'import avancé

Python — Import system

1 # Structure d'un package Python

2 # my_package/
3 # __init__.py
4 # core/
5 # __init__.py
6 # [Link]
7 # [Link]
8 # tests/
9 # test_models.py
10 # [Link]
11
12 # __init__.py — API publique du package
13 from .[Link] import User, Product
14 from .[Link] import format_date
15 __all__ = ['User', 'Product', 'format_date']
16
17 # Import relatif vs absolu
18 from .models import User # relatif
19 from my_package.models import User # absolu
20
21 # Import dynamique
22 import importlib
23 module = importlib.import_module('my_package.[Link]')
24 cls = getattr(module, 'User')

6.2 [Link] — configuration moderne

Python Pro Guide — Niveau Expert 19 Tous droits reserves

PYTHON MASTERY GUIDE [Link]

[Link]

1 # [Link] (PEP 517/518 — remplace [Link])

2 [build-system]
3 requires = ['hatchling']
4 build-backend = '[Link]'
5
6 [project]
7 name = 'my-package'
8 version = '1.0.0'
9 description = 'Mon super package Python'
10 readme = '[Link]'
11 requires-python = '>=3.11'
12 license = {text = 'MIT'}
13
14 dependencies = [
15 'requests>=2.28',
16 'pydantic>=2.0',
17 ]
18
19 [[Link]-dependencies]
20 dev = ['pytest', 'mypy', 'ruff']
21 docs = ['mkdocs', 'mkdocs-material']
22
23 [[Link]]
24 my-cli = 'my_package.cli:main'

● Outils modernes Python

ruff — linter ultra-rapide (remplace flake8 + isort)
mypy — vérification statique des types
black — formateur de code automatique
pytest — framework de tests
hatch / poetry — gestion de dépendances et packaging

Python Pro Guide — Niveau Expert 20 Tous droits reserves

CHAPITRE 10 | Projet Professionnel Complet [Link]

CHAPITRE 07

Programmation Asynchrone
asyncio, coroutines, event loop, async/await, aiohttp, gestion des tâches et timeouts.

07
7.1 asyncio — fondamentaux

async fetch_data() async write_file()

Event
Loop

async query_db() async send_email()

asyncio Event Loop — concurrence cooperative

Python Pro Guide — Niveau Expert 21 Tous droits reserves

PYTHON MASTERY GUIDE [Link]

Python — asyncio

1 import asyncio
2 from typing import AsyncIterator
3
4 # Coroutine simple
5 async def fetch_url(url: str) -> str:
6 await [Link](1) # I/O simulée
7 return f'Data from {url}'
8
9 # Lancer plusieurs tâches en parallèle
10 async def main():
11 urls = ['[Link] '[Link] '[Link]
12
13 # gather — toutes les tâches en parallèle
14 results = await [Link](*[fetch_url(u) for u in urls])
15
16 # TaskGroup (Python 3.11+) — annulation automatique
17 async with [Link]() as tg:
18 tasks = [tg.create_task(fetch_url(u)) for u in urls]
19 results2 = [[Link]() for t in tasks]
20
21 # Timeout
22 try:
23 async with [Link](5.0):
24 result = await fetch_url('[Link]
25 except TimeoutError:
26 print('Timeout!')
27
28 [Link](main())

7.2 Async generators & context managers

Python Pro Guide — Niveau Expert 22 Tous droits reserves

PYTHON MASTERY GUIDE [Link]

Python — Async avancé

1 # Générateur asynchrone
2 async def paginate(url: str) -> AsyncIterator[dict]:
3 page = 1
4 while True:
5 data = await fetch_page(url, page)
6 if not data: break
7 for item in data:
8 yield item
9 page += 1
10
11 async def process_all():
12 async for item in paginate('[Link]
13 await process(item)
14
15 # Context manager asynchrone
16 from contextlib import asynccontextmanager
17
18 @asynccontextmanager
19 async def db_transaction(conn):
20 await [Link]()
21 try:
22 yield conn
23 await [Link]()
24 except Exception:
25 await [Link]()
26 raise
27
28 # Semaphore — limiter la concurrence
29 sem = [Link](10) # max 10 requêtes simultanées
30
31 async def limited_fetch(url: str) -> str:
32 async with sem:
33 return await fetch_url(url)

✦ asyncio vs threading vs multiprocessing

asyncio : I/O bound — réseau, fichiers, BDD (1 thread, concurrence coopérative)
threading : I/O bound + bibliothèques non-async (GIL libéré pendant I/O)
multiprocessing : CPU bound — calculs intensifs (contourne le GIL)

Python Pro Guide — Niveau Expert 23 Tous droits reserves

PYTHON MASTERY GUIDE [Link]

CHAPITRE 08

Tests & Qualité du code

pytest, fixtures, mocking, couverture de code, TDD, property-based testing et CI/CD.

08
8.1 pytest — framework de tests professionnel

Python Pro Guide — Niveau Expert 24 Tous droits reserves

PYTHON MASTERY GUIDE [Link]

pytest — tests professionnels

1 # tests/test_models.py
2 import pytest
3 from [Link] import Mock, patch, AsyncMock
4
5 # Fixture — setup/teardown réutilisables
6 @[Link]
7 def sample_user() -> dict:
8 return {'id': 1, 'name': 'Alice', 'email': 'alice@[Link]'}
9
10 @[Link](scope='session')
11 def db_connection():
12 conn = create_connection(':memory:')
13 yield conn
14 [Link]()
15
16 # Parametrize — tester plusieurs cas
17 @[Link]('value,expected', [
18 (0, True), (42, False), (-1, False), (100, False),
19 ])
20 def test_is_zero(value, expected):
21 assert is_zero(value) == expected
22
23 # Test avec mock
24 def test_fetch_user(sample_user):
25 with patch('[Link]') as mock_get:
26 mock_get.return_value.json.return_value = sample_user
27 result = fetch_user(1)
28 assert result['name'] == 'Alice'
29 mock_get.assert_called_once()
30
31 # Test asynchrone
32 @[Link]
33 async def test_async_fetch():
34 result = await async_fetch('[Link]
35 assert result is not None

Python Pro Guide — Niveau Expert 25 Tous droits reserves

PYTHON MASTERY GUIDE [Link]

pytest — configuration & commandes

1 # [Link] ou [Link]
2 [[Link].ini_options]
3 testpaths = ['tests']
4 addopts = '-v --tb=short --cov=src --cov-report=html'
5 asyncio_mode = 'auto'
6
7 # Lancer les tests
8 pytest # tous les tests
9 pytest -k 'test_user' # filtrer par nom
10 pytest -x # arrêter au premier échec
11 pytest --lf # seulement les tests qui ont échoué
12 pytest -v --tb=long # verbose avec traceback complet
13
14 # Coverage
15 pytest --cov=src --cov-report=term-missing
16 # Objectif : > 90% de couverture

✦ Bonnes pratiques de tests

Arrange / Act / Assert (AAA) — structure claire de chaque test
Un test = une seule assertion logique (peut avoir plusieurs assert)
Tests indépendants — aucun test ne doit dépendre d'un autre
Nommer clairement : test_quoi_quand_attendu

Python Pro Guide — Niveau Expert 26 Tous droits reserves

PYTHON MASTERY GUIDE [Link]

CHAPITRE 09

Performance & Optimisation

Profiling, numpy, algorithmes, caching, multiprocessing, Cython et techniques
d'optimisation avancées.

09
9.1 Profiling — identifier les goulots

Python — Profiling

1 import cProfile, pstats, io

2 import timeit
3 from memory_profiler import profile
4
5 # cProfile — profiler de production
6 profiler = [Link]()
7 [Link]()
8 # ... votre code ...
9 [Link]()
10 stats = [Link](profiler).sort_stats('cumulative')
11 stats.print_stats(20) # top 20 fonctions
12
13 # timeit — mesurer des snippets précis
14 result = [Link](
15 stmt='sum(range(10000))',
16 number=1000
17 )
18 print(f'{result/1000*1000:.3f} ms par appel')
19
20 # line_profiler — profiler ligne par ligne
21 # pip install line_profiler
22 # @profile (décorateur kernprof)
23 def slow_function():
24 total = 0
25 for i in range(10000): # <- ligne lente
26 total += i * i
27 return total
28
29 # Utiliser SnakeViz pour visualiser
30 # python -m cProfile -o [Link] my_script.py
31 # snakeviz [Link]

Python Pro Guide — Niveau Expert 27 Tous droits reserves

PYTHON MASTERY GUIDE [Link]

Technique Gain typique Cas d'usage

list comprehension vs
2-5x plus rapide Construire des listes
boucle

dict/set lookup vs list

O(1) vs O(n) Recherche de valeurs
search

10-100x plus
numpy arrays vs listes Calculs numériques
rapide

lru_cache / cache 10-1000x Fonctions pures répétées

slots dans les classes 20-50% mémoire Millions d'instances

N x mémoire
generator vs list Grands datasets
économisée

Nx (N = nb de
multiprocessing CPU-bound tasks
CPU)

100x pour I/O

asyncio Réseau, BDD, fichiers
bound

Python Pro Guide — Niveau Expert 28 Tous droits reserves

PYTHON MASTERY GUIDE [Link]

Python — Optimisation avancée

1 import numpy as np
2 from functools import lru_cache
3
4 # numpy — opérations vectorisées
5 a = [Link]([1, 2, 3, 4, 5], dtype=np.float64)
6 b = [Link](10**6)
7
8 # Opérations sur tout le tableau à la fois
9 result = [Link](a**2 + a**2) # vectorisé
10 matrix = [Link](1000, 1000)
11 eigenvalues = [Link](matrix)
12
13 # __slots__ — réduire l'empreinte mémoire
14 class Point:
15 __slots__ = ('x', 'y', 'z') # interdit __dict__
16
17 def __init__(self, x, y, z):
18 self.x, self.y, self.z = x, y, z
19
20 # multiprocessing — contourner le GIL
21 from multiprocessing import Pool
22
23 def cpu_intensive(n: int) -> int:
24 return sum(i**2 for i in range(n))
25
26 with Pool() as pool: # un processus par CPU
27 results = [Link](cpu_intensive, [10**6]*8)

Python Pro Guide — Niveau Expert 29 Tous droits reserves

PYTHON MASTERY GUIDE [Link]

CHAPITRE 10

Projet Professionnel Complet

Construire une API REST avec FastAPI, Pydantic, SQLAlchemy, tests complets, Docker
et déploiement.

10
10.1 Architecture du projet

Architecture API REST

1 # Structure d'une API REST professionnelle

2 #
3 # api/
4 # __init__.py
5 # [Link] <- FastAPI app
6 # [Link] <- Paramètres (pydantic-settings)
7 # [Link] <- Connexion SQLAlchemy
8 # models/
9 # [Link] <- Modèles SQLAlchemy (ORM)
10 # [Link]
11 # schemas/
12 # [Link] <- Schémas Pydantic (validation)
13 # routers/
14 # [Link] <- Routes /users
15 # [Link] <- Routes /products
16 # services/
17 # user_service.py <- Logique métier
18 # tests/
19 # [Link] <- Fixtures partagées
20 # test_users.py
21 # Dockerfile
22 # [Link]
23 # [Link]

10.2 FastAPI — API moderne et typée

Python Pro Guide — Niveau Expert 30 Tous droits reserves

PYTHON MASTERY GUIDE [Link]

FastAPI — API REST complète

1 # [Link]
2 from fastapi import FastAPI, Depends, HTTPException, status
3 from pydantic import BaseModel, EmailStr, Field
4 from typing import Annotated
5
6 app = FastAPI(title='Mon API', version='1.0.0')
7
8 # Schéma Pydantic — validation automatique
9 class UserCreate(BaseModel):
10 name: str = Field(min_length=2, max_length=50)
11 email: EmailStr
12 password: str = Field(min_length=8)
13
14 class UserResponse(BaseModel):
15 id: int
16 name: str
17 email: str
18 model_config = {'from_attributes': True}
19
20 # Dependency Injection
21 def get_db() -> Generator:
22 db = SessionLocal()
23 try: yield db
24 finally: [Link]()
25
26 DB = Annotated[Session, Depends(get_db)]
27
28 # Routes
29 @[Link]('/users', response_model=UserResponse,
30 status_code=status.HTTP_201_CREATED)
31 async def create_user(user: UserCreate, db: DB) -> UserResponse:
32 existing = [Link](User).filter([Link] == [Link]).first()
33 if existing:
34 raise HTTPException(status_code=400, detail='Email déjà utilisé')
35 db_user = User(**user.model_dump())
36 [Link](db_user)
37 [Link]()
38 return db_user
39
40 @[Link]('/users/{user_id}', response_model=UserResponse)
41 async def get_user(user_id: int, db: DB) -> UserResponse:
42 user = [Link](User, user_id)
43 if not user:
44 raise HTTPException(status_code=404, detail='Utilisateur non trouvé')
45 return user

Python Pro Guide — Niveau Expert 31 Tous droits reserves

PYTHON MASTERY GUIDE [Link]

10.3 Dockerfile & Docker Compose

Dockerfile & docker-compose

1 # Dockerfile — multi-stage build

2 FROM python:3.12-slim AS builder
3 WORKDIR /app
4 COPY [Link] .
5 RUN pip install --no-cache-dir build && python -m build
6
7 FROM python:3.12-slim AS runtime
8 WORKDIR /app
9 COPY --from=builder /app/dist/*.whl .
10 RUN pip install --no-cache-dir *.whl && rm *.whl
11 EXPOSE 8000
12 CMD ["uvicorn", "[Link]:app", "--host", "[Link]"]
13
14 # [Link]
15 services:
16 api:
17 build: .
18 ports: ['8000:8000']
19 env_file: .env
20 depends_on: [db]
21 db:
22 image: postgres:16
23 volumes: ['pgdata:/var/lib/postgresql/data']
24 environment:
25 POSTGRES_DB: mydb
26 POSTGRES_USER: user
27 POSTGRES_PASSWORD: secret

● Checklist développeur Python professionnel

Code versionne avec Git + branches feature + PR reviews
CI/CD : GitHub Actions — lint, test, build, deploy
Documentation : docstrings Google style + mkdocs
Monitoring : Sentry (erreurs) + Prometheus (métriques)
Securite : bandit (scan), dependabot (MAJ deps)

10.4 Prochaines étapes vers l'expertise

Domaine Technologies Ressources

Python Pro Guide — Niveau Expert 32 Tous droits reserves

PYTHON MASTERY GUIDE [Link]

FastAPI, Django,
Web Backend [Link]
SQLAlchemy

Data Science Pandas, NumPy, Matplotlib [Link]

Machine
Scikit-learn, PyTorch, TF [Link]
Learning

DevOps/Cloud Docker, K8s, AWS/GCP [Link]

Architecture Design Patterns, DDD, Clean [Link]

Open Source Contribuer sur GitHub [Link]/explore

Félicitations — tu as parcouru l'intégralité du guide Python Pro !

La maîtrise vient de la pratique quotidienne et de la construction de projets réels. Code chaque
jour, contribue à l'open-source, et n'arrête jamais d'apprendre.

Python Pro Guide — Niveau Expert 33 Tous droits reserves