🐍 Python – Le Guide Ultime

Python est un langage interprété (pas compilé au sens C++/Java), haut niveau, et multi-plateforme. Il est célèbre pour sa syntaxe claire, lisible (presque de l'anglais) et sa philosophie "Batteries Included" (une bibliothèque standard très riche).

Caractéristiques Clés

• Typage Dynamique Fort :
  - Dynamique : Pas besoin de déclarer le type (x = 5, puis x = "hello" est OK). Le type est vérifié au moment de l'exécution (runtime).
  - Fort : Interdit les opérations "magiques" (5 + "hello" -> lève une TypeError, contrairement à JavaScript qui concaténerait en "5hello").
• Interprété : Le code est lu ligne par ligne par un interpréteur (le plus courant : CPython).
• Lisibilité (Indentation) : Utilise l'indentation (le "whitespace", 4 espaces par convention) pour définir les blocs de code (au lieu de {...}), forçant un code propre.

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Readability counts.
...

# Convention: utiliser le snake_case
user_name = "Alice"
user_age = 30
is_admin = True # Note: True/False (Majuscule)
rien = None     # Le "Nul" de Python

# f-strings (formatage moderne)
print(f"User {user_name} a {user_age} ans.")

# L'Indentation (pas de '{...}')
if user_age > 18:
    print("Majeur")
else:
    print("Mineur")

Types Scalaires (Simples)

• str : String (Chaîne). ("Hello" ou 'Hello').
• int : Entier (123, -42).
• float : Flottant (3.14159).
• bool : Booléen (True, False).
• None : Le "Nul" de Python (None).

Strings (str) - Méthodes & f-strings

# f-strings (Le "must-know")
nom = "Alice"
age = 30
print(f"Bonjour {nom}, vous avez {age} ans.")
print(f"Calcul: { (age * 2) / 3 :.2f }") # f"Pi vaut: 3.14"

# Méthodes courantes
ligne = "  Bonjour, ceci est un test.  "
print(ligne.strip()) # "Bonjour, ceci est un test." (Enlève whitespace)
print(ligne.split(',')) # ["  Bonjour", " ceci est un test.  "]
print(ligne.startswith("Bonjour")) # False (à cause de l'espace)
print(ligne.strip().startswith("Bonjour")) # True

# Joindre une liste de strings
mots = ["Python", "est", "génial"]
phrase = " ".join(mots) # "Python est génial"

Slicing (Découpage)

Syntaxe [start:stop:step] (stop est *exclu*). Fonctionne sur les listes, tuples, et strings.

items = [0, 10, 20, 30, 40, 50, 60]

# De l'index 1 (inclus) à 4 (exclu)
print(items[1:4]) # [10, 20, 30]

# Du début à l'index 3 (exclu)
print(items[:3]) # [0, 10, 20]

# De l'index 3 (inclus) à la fin
print(items[3:]) # [30, 40, 50, 60]

# Du début à la fin, un item sur 2 (step)
print(items[::2]) # [0, 20, 40, 60]

# Inverser une liste/string
print(items[::-1]) # [60, 50, 40, 30, 20, 10, 0]

ma_liste = [10, "hello"]
ma_liste.append(True) # [10, "hello", True]
ma_liste.pop(0) # Retire index 0 -> ["hello", True]
print(ma_liste[0]) # "hello"
ma_liste[0] = "world" # ["world", True]

mon_tuple = (10, "hello")
# mon_tuple[0] = 99 # ERREUR!

# Unpacking (très courant)
x, y = mon_tuple # (x=10, y="hello")

user = {"name": "Alice", "age": 30}
print(user["name"]) # "Alice"
print(user.get("job", "N/A")) # "N/A" (défaut)
user["age"] = 31

# Itération
for key, value in user.items():
    print(f"{key} -> {value}")

ma_liste = [1, 2, 2, 3, 1]
mon_set = set(ma_liste) # {1, 2, 3}
print(2 in mon_set) # True (très rapide)

set_a = {1, 2, 3}
set_b = {3, 4, 5}
print(set_a | set_b) # Union: {1, 2, 3, 4, 5}
print(set_a & set_b) # Intersection: {3}

Addon (Stdlib) : collections

• defaultdict : Un dict qui ne lève jamais de KeyError.
  compteur = defaultdict(int) -> compteur["mot"] += 1 (marche même si "mot" n'existe pas, il vaut 0).
• namedtuple : Un tuple où l'on peut accéder aux champs par un nom.
  Point = namedtuple("Point", ["x", "y"]) -> p = Point(10, 20) -> print(p.x) (affiche 10).

Le code "Pythonic" est une façon d'écrire du code qui est "idiomatique", lisible, et qui utilise les forces du langage. La "List Comprehension" en est l'exemple parfait. C'est une façon de créer une liste en une seule ligne lisible.

1. List Comprehension [ ... ]

Objectif : Créer une liste des carrés des 10 premiers chiffres pairs.

carres_pairs = []
for i in range(10):
    if i % 2 == 0:
        carres_pairs.append(i * i)

carres_pairs = [i * i for i in range(10) if i % 2 == 0]

# Syntaxe: 
# [ (ce que je veux) for (item) in (iterable) if (condition) ]

2. Dict & Set Comprehensions { ... }

# Dict Comprehension
# {clé: valeur for ...}
carres_dict = {i: i * i for i in range(5)}
# Résultat: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# Set Comprehension
ma_liste = [1, 2, 2, 3, 1]
mon_set = {x for x in ma_liste}
# Résultat: {1, 2, 3}

3. Generator Expression ( ... ) & yield

Si la liste est immense (ex: 1 milliard), une "list comprehension" va saturer la RAM. On utilise une "Generator Expression" (avec (...)). Elle ne calcule les valeurs qu'à la demande (lazy).

# Ceci ne calcule RIEN, c'est un "générateur"
carres_gen = (i * i for i in range(1000000000))

# 'yield' est la façon de créer un générateur dans une fonction
def gen_carres(n):
    for i in range(n):
        yield i * i # "Pause" et renvoie la valeur

# Le calcul se fait ici, un par un
for c in carres_gen:
    print(c)
    if c > 100:
        break # Ne calcule pas les 999 millions restants

4. Context Manager (with open)

Ne *jamais* gérer des fichiers manuellement (f.open(), f.close()). La "bonne" façon est d'utiliser with, qui gère le finally (fermeture) pour vous.

# La façon "Pythonic" de gérer les ressources
with open("mon_fichier.txt", "r") as f:
    contenu = f.read()
# (Ici, 'f' est automatiquement fermé, même si une erreur a eu lieu)

Python est un langage orienté objet (POO). Tout est objet (même les fonctions).

Classe, __init__, et self

self est l'équivalent du this (en Java/JS). C'est le premier argument de *chaque* méthode d'instance. __init__ est le constructeur.

# 1. Définition de la classe
class Utilisateur:
    
    # 2. Constructeur (lancé à la création)
    def __init__(self, nom, email):
        # 3. 'self' fait référence à l'instance
        self.nom = nom
        self.email = email
        self.est_actif = True

    # 4. Méthode d'instance
    def saluer(self):
        return f"Bonjour, je suis {self.nom}."

# 5. Instanciation
user_1 = Utilisateur("Alice", "alice@mail.com")
print(user_1.nom) # "Alice"

Héritage & super()

# 1. La classe "Enfant" hérite de "Utilisateur"
class Admin(Utilisateur):
    
    def __init__(self, nom, email, permissions):
        # 2. On appelle le constructeur parent (Utilisateur)
        super().__init__(nom, email)
        self.permissions = permissions
        
    # 3. On "override" (surcharge) la méthode parent
    def saluer(self):
        return f"[ADMIN] Bonjour, je suis {self.nom}."

Méthodes Magiques (Dunder)

Méthodes spéciales (__nom__) qui définissent le comportement de l'objet.

class Livre:
    def __init__(self, titre, auteur):
        self.titre = titre
        self.auteur = auteur
        
    # 'str(livre)' ou 'print(livre)'
    def __str__(self):
        return f"'{self.titre}' par {self.auteur}"
        
    # 'repr(livre)' (Pour le débug)
    def __repr__(self):
        return f"Livre(titre='{self.titre}')"
        
    # 'len(livre)'
    def __len__(self):
        return len(self.titre)
        
livre = Livre("Dune", "F. Herbert")
print(livre) # "'Dune' par F. Herbert"

Les "décorateurs" (@) sont des "addons" pour les fonctions. Ce sont des fonctions qui "enveloppent" d'autres fonctions pour modifier leur comportement.

@staticmethod vs @classmethod

@property (Getters & Setters "Pythonic")

La "mauvaise" façon (style Java) est user.get_email(). La façon "Pythonic" est d'utiliser @property pour qu'une méthode se comporte comme un attribut.

class Utilisateur:
    def __init__(self, prenom, nom):
        self._email = f"{prenom}.{nom}@mail.com"

    @property
    def email(self):
        return self._email # Getter

    @email.setter
    def email(self, nouvelle_valeur):
        self._email = nouvelle_valeur # Setter

@dataclass (Python 3.7+)

Écrire __init__ et __repr__ est répétitif. Ce décorateur le fait pour vous.

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __repr__(self):
        return f"Point(x={self.x}, y={self.y})"

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

Python a une cadence de sortie annuelle (en octobre). Les versions "modernes" (post 3.5) ont ajouté des fonctionnalités majeures. La transition Python 2 -> 3 (2008) a été un événement majeur, mais Python 2 est mort et n'est plus supporté depuis 2020.

match / case (Python 3.10+)

Le "switch/case" de Python, mais en beaucoup plus puissant.

def http_status(status):
    match status:
        case 200:
            return "OK"
        case 404:
            return "Not Found"
        case 418:
            return "I'm a teapot"
        case 400 | 401 | 403: # (Pattern "OU")
            return "Client Error"
        case 500 | 501 | 502 | 503:
            return "Server Error"
        case _: # (Wildcard)
            return "Unknown"

Modules, Packages & import

• Module : Un simple fichier Python (ex: utils.py).
• Package : Un dossier de modules (ex: mon_projet/) qui contient un fichier spécial __init__.py (qui peut être vide).

# 1. Importer un module entier (de la bibliothèque standard)
import os
print(os.getcwd()) # Affiche le dossier courant

# 2. Importer un objet spécifique d'un module
from datetime import datetime, timedelta
print(datetime.now() + timedelta(days=1))

# 3. Importer son propre code
# (si mon_app/utils.py existe)
from mon_app.utils import ma_fonction

# 4. Importer avec un alias (TRÈS courant en Data Science)
import pandas as pd
df = pd.DataFrame()

pip (Package Manager) & venv (Isolation)

Problème : Projet A a besoin de django==3.0. Projet B a besoin de django==4.0. On ne peut pas les installer "globalement".
Solution : venv (Virtual Environment). Crée un "silo" (dossier) avec une installation Python isolée pour *chaque* projet.

Workflow (Cheat-sheet) :

# 1. Créer l'environnement virtuel (dans le dossier 'venv')
$ python3 -m venv venv

# 2. L'ACTIVER (change le shell)
$ source venv/bin/activate
(venv) $  <-- Le prompt change !

# 3. Installer des packages (uniquement dans 'venv')
(venv) $ pip install requests
(venv) $ pip install django

# 4. Geler les dépendances
(venv) $ pip freeze > requirements.txt

# 5. (Sur une autre machine) Installer depuis le fichier
(venv) $ pip install -r requirements.txt

# 6. Quitter l'environnement
(venv) $ deactivate
$

Python est un pilier majeur du développement web back-end, avec trois frameworks dominants et un outil essentiel pour les tâches de fond.

C'est le *deuxième* pilier majeur de Python (et peut-être le plus grand aujourd'hui). Python est le langage n°1 de la Data Science et de l'IA.

Ces outils ("plugins" ou "addons") ne font pas partie du langage, mais sont *essentiels* à tout projet Python professionnel pour garantir la qualité, la maintenabilité et la reproductibilité.

Outils de Qualité de Code (Linters & Formatters)

Outils de Test & Dépendance

Librairies "Plugins" Incontournables (PyPI)