Python : Niveau Expert

Décorateurs, Métaclasses et Dunder Methods

La métaprogrammation permet d'écrire du code qui manipule du code ou modifie le comportement du langage.

# Décorateur complexe avec arguments
def cache_result(fonction):
    memo = {}
    def wrapper(*args):
        if args not in memo:
            memo[args] = fonction(*args)
        return memo[args]
    return wrapper

@cache_result
def calcul_long(n):
    return n * n

# Métaclasses : Personnaliser la création de classes
class Singleton(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class Database(metaclass=Singleton):
    def __init__(self):
        print("Connexion établie")

db1 = Database()
db2 = Database() # Ne ré-affiche pas le message

Héritage Multiple, Mixins et Slots

# Optimisation mémoire avec __slots__
class Point:
    __slots__ = ('x', 'y')
    def __init__(self, x, y):
        self.x = x
        self.y = y

# Pattern Factory
class ShapeFactory:
    @staticmethod
    def get_shape(type):
        if type == "circle": return Circle()
        if type == "square": return Square()

Threading, Multiprocessing et Asyncio

Comprenez le GIL (Global Interpreter Lock) et comment le contourner.

• Asyncio : Boucle d'événements pour les tâches I/O intensive.
• Multiprocessing : Pour paralléliser sur plusieurs cœurs CPU.

import asyncio

async def call_api(id):
    print(f"Appel API {id}...")
    await asyncio.sleep(1)
    return {"id": id, "data": "success"}

async def main():
    results = await asyncio.gather(call_api(1), call_api(2))
    print(results)

asyncio.run(main())

Type Hints, MyPy et Tests Unitaires

Le typage statique optionnel rend le code plus robuste et facile à maintenir.

from typing import List, Optional, Union

def process_items(items: List[str]) -> Optional[int]:
    if not items: return None
    return len(items)

# Tests avec pytest
def test_process():
    assert process_items(["a", "b"]) == 2
    assert process_items([]) is None

NumPy, Pandas et Profiling

Pour l'analyse de données massive, utilisez des bibliothèques C-optimisées.

import numpy as np
# Calcul vectorisé (beaucoup plus rapide qu'une boucle for)
arr = np.array([1, 2, 3])
print(arr * 2) # [2, 4, 6]

Utilisez cProfile pour identifier les goulots d'étranglement dans votre code.

Pipelines de déploiement et Docker

Apprenez à packager vos projets avec Poetry, à gérer les environnements avec Docker et à automatiser avec GitHub Actions.

Fonctionnalités récentes et puissantes

1. Structural Pattern Matching (match-case)

Une alternative puissante au switch-case, capable de déstructurer des objets.

def process_command(cmd):
    match cmd.split():
        case ["quit"]:
            exit()
        case ["load", filename]:
            print(f"Chargement de {filename}")
        case ["move", x, y] if int(y) > 0:
            print(f"Déplacement vers {x}, {y}")
        case _:
            print("Commande inconnue")

2. TaskGroups (Asyncio 3.11+)

Une manière plus sûre de gérer plusieurs tâches asynchrones.

import asyncio

async def main():
    async with asyncio.TaskGroup() as tg:
        tg.create_task(call_api(1))
        tg.create_task(call_api(2))
    # Attend la fin de toutes les tâches. Si l'une échoue, les autres sont annulées.

3. Type Parameter Syntax (3.12+)

Syntaxe simplifiée pour les génériques.

def get_first[T](items: list[T]) -> T:
    return items[0]

4. F-strings avancées

Utilisez des guillemets et des expressions complexes directement dans vos f-strings.

print(f"Résultat: {round(valeur, 2)=}") # Affiche le nom et la valeur !

Django & Flask

Créez des applications web puissantes et scalables.

Flask : Léger et flexible

from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "Bonjour depuis Flask !"

if __name__ == "__main__":
    app.run()

Django : Le framework "Batteries Included"

Django offre tout par défaut : Auth, ORM, Admin Panel, Sécurité.

# Exemple de modèle Django
from django.db import models

class Article(models.Model):
    titre = models.CharField(max_length=200)
    contenu = models.TextField()
    date_publication = models.DateTimeField(auto_now_add=True)