■

FORMATION
PYTHON
COMPLÈTE & PROFESSIONNELLE

De Zéro à Expert — Bases · Web · Mobile · Scripts · Cybersécurité

Ton formateur t'a tout transmis. Il ne reste plus qu'à coder.

Formation rédigée avec ❤■ pour toi — 2025

■ Table des Matières

# Chapitre Thème

01 Fondations Installation, Syntaxe, Variables, Types

02 Structures de données Listes, Tuples, Dicts, Sets

03 Contrôle du flux If, Boucles, Compréhensions

04 Fonctions & Modules def, lambda, *args, imports

05 POO Classes, Héritage, Magie Python

06 Fichiers & Exceptions I/O, try/except, Context managers

07 Bibliothèques standard os, sys, re, datetime, json, csv

08 Développement Web Flask, FastAPI, Django — projets réels

09 Bases de données SQLite, SQLAlchemy, PostgreSQL

10 Data Science NumPy, Pandas, Matplotlib, Seaborn

11 Dev Mobile Kivy, BeeWare — apps Android/iOS

12 Scripts & Automatisation Selenium, BeautifulSoup, Requests, Cron

13 Cybersécurité Scapy, Nmap, CTF, Pentest Python

14 Frameworks avancés Async, Typer, Pydantic, Celery

15 Projet Final Application complète de A à Z

Formation Python Complète • Page 2

 ■■
CHAPITRE 01
Les Fondations

Installation · Syntaxe · Variables · Types de données

Formation Python Complète • Page 3

 1.1 — Pourquoi Python ?

Python est aujourd'hui le langage de programmation le plus populaire au monde. Créé par Guido van Rossum en
1991, il est connu pour sa lisibilité, sa simplicité et sa puissance. Que tu veuilles faire du web, de l'intelligence
artificielle, de la cybersécurité ou de l'automatisation — Python est là.

Avantage Explication

Syntaxe claire Python ressemble presque à de l'anglais naturel

Polyvalent Web, IA, scripts, sécurité, jeux, mobile...

Communauté énorme Des millions de bibliothèques disponibles (PyPI)

Interactif Teste du code ligne par ligne dans le terminal

Gratuit & Open Source Aucun coût, accessible à tous

1.2 — Installation de Python

Sur Windows :

# 1. Va sur [Link]
# 2. Télécharge Python 3.12+
# 3. IMPORTANT: Coche 'Add Python to PATH'
# 4. Vérifie dans le terminal:
python --version
# Output: Python 3.12.x

Sur macOS / Linux :

# macOS (avec Homebrew)

brew install python3

# Ubuntu / Debian
sudo apt update && sudo apt install python3 python3-pip

# Vérification
python3 --version

■■ INFO
Installe VS Code comme éditeur de code (gratuit). Ajoute l'extension 'Python' par
Microsoft. C'est ton environnement de travail principal.

1.3 — Ton premier programme

La tradition veut que le premier programme affiche 'Hello, World!'. C'est ton baptême de codeur !

Formation Python Complète • Page 4

 # Mon premier programme Python
print('Hello, World!')
print('Je suis en train de devenir un expert Python !')

# Output:
# Hello, World!
# Je suis en train de devenir un expert Python !

■ CONSEIL
La fonction print() affiche du texte à l'écran. C'est ton meilleur ami pour déboguer
et tester.

1.4 — Variables et Types de données

Une variable est une boîte dans laquelle tu stockes une valeur. En Python, pas besoin de déclarer le type — Python
le devine tout seul (c'est ce qu'on appelle le typage dynamique).

# === ENTIERS (int) ===

age = 25
annee = 2025
temperature = -5

# === DÉCIMAUX (float) ===

prix = 19.99
pi = 3.14159
note = 18.5

# === TEXTE (str) ===

prenom = 'Alice'
message = "Bonjour tout le monde !"
multi = '''Texte
sur plusieurs
lignes'''

# === BOOLÉENS (bool) ===

est_majeur = True
a_paye = False

# === AUCUNE VALEUR (NoneType) ===

resultat = None

Connaître le type d'une variable :

age = 25
print(type(age)) # <class 'int'>
print(type(3.14)) # <class 'float'>
print(type('Alice')) # <class 'str'>
print(type(True)) # <class 'bool'>

Formation Python Complète • Page 5

 1.5 — Opérations mathématiques

Opérateur Signification & Exemple

+ Addition : 5+3=8

- Soustraction : 10 - 4 = 6

* Multiplication : 4 * 7 = 28

/ Division : 15 / 4 = 3.75

// Division entière: 15 // 4 = 3

% Modulo (reste) : 15 % 4 = 3

** Puissance : 2 ** 8 = 256

# Calculs courants
a, b = 10, 3
print(a + b) # 13
print(a - b) # 7
print(a * b) # 30
print(a / b) # 3.3333...
print(a // b) # 3 (partie entière)
print(a % b) # 1 (reste)
print(a ** b) # 1000 (10 puissance 3)

1.6 — Les chaînes de caractères (Strings)

Les strings sont fondamentales en Python. Apprends à les manipuler comme un chef !

Formation Python Complète • Page 6

nom = 'Alice'
age = 30
ville = 'Paris'

# === F-STRINGS (méthode moderne, recommandée) ===

message = f'Je suis {nom}, j ai {age} ans et je vis a {ville}.'
print(message)

# === Méthodes essentielles des strings ===

texte = ' Bonjour le Monde '

print([Link]()) # supprime espaces: 'Bonjour le Monde'

print([Link]()) # minuscules: ' bonjour le monde '
print([Link]()) # majuscules: ' BONJOUR LE MONDE '
print([Link]('o','0')) # remplace lettres
print(len(texte)) # longueur: 20

# Découper une string

phrase = 'Python est génial'
mots = [Link](' ') # ['Python', 'est', 'génial']
print(mots[0]) # 'Python' (index 0 = premier)

# Vérifications
print('Python' in phrase) # True
print([Link]('Python')) # True
print([Link]('génial')) # True

■ EXPERT
Les f-strings (f'...') sont la façon MODERNE d'insérer des variables dans du texte.
Utilise toujours cette syntaxe, elle est plus lisible et plus rapide.

1.7 — Entrée utilisateur (input)

# Demander une valeur à l'utilisateur

prenom = input('Quel est ton prénom ? ')
print(f'Bonjour {prenom} !')

# ATTENTION: input() retourne TOUJOURS une string

# Pour avoir un nombre, il faut convertir:
age_str = input('Quel est ton âge ? ')
age = int(age_str) # convertit en entier

# Raccourci:
age = int(input('Quel est ton âge ? '))

# Exemple complet:
nom = input('Ton nom : ')
annee_naissance = int(input('Année de naissance : '))
age = 2025 - annee_naissance
print(f'{nom}, tu as environ {age} ans.')

Formation Python Complète • Page 7

 ■■ ATTENTION
Toujours convertir le résultat de input() si tu attends un nombre. int() pour entier,
float() pour décimal.

■■ Exercices du Chapitre 1

Pratique, pratique, pratique ! Voici tes exercices :

• • Exercice 1 : Crée un programme qui demande le prénom, le nom et l'âge de l'utilisateur, puis affiche une
phrase de présentation.
• • Exercice 2 : Crée une calculatrice simple qui demande deux nombres et affiche leur somme, différence, produit
et quotient.
• • Exercice 3 : Demande le rayon d'un cercle et calcule son aire (PI * r²) et son périmètre (2 * PI * r).
• • Exercice 4 : Prends une phrase et affiche : sa longueur, en majuscules, en minuscules, et si elle contient le
mot 'Python'.

■ EXPERT
Ne recopie pas les solutions. Essaie par toi-même, fais des erreurs, cherche pourquoi
ça ne marche pas. C'est comme ça qu'on apprend vraiment.

Formation Python Complète • Page 8

 ■
CHAPITRE 02
Structures de Données

Listes · Tuples · Dictionnaires · Ensembles

Formation Python Complète • Page 9

 2.1 — Les Listes (list)

Une liste est une collection ordonnée et modifiable d'éléments. C'est l'une des structures les plus utilisées en
Python.

# Créer une liste

fruits = ['pomme', 'banane', 'cerise', 'mangue']
nombres = [1, 2, 3, 4, 5]
mixte = ['Alice', 30, True, 3.14] # types différents OK
vide = []

# Accéder aux éléments (index commence à 0)

print(fruits[0]) # 'pomme' (premier)
print(fruits[-1]) # 'mangue' (dernier)
print(fruits[1:3]) # ['banane', 'cerise'] (slicing)

# Modifier
fruits[0] = 'fraise'
print(fruits) # ['fraise', 'banane', 'cerise', 'mangue']

# Ajouter
[Link]('kiwi') # ajoute à la fin
[Link](1, 'raisin') # insère en position 1

# Supprimer
[Link]('banane') # supprime par valeur
dernier = [Link]() # supprime et retourne le dernier
del fruits[0] # supprime par index

# Infos
print(len(fruits)) # nombre d'éléments
print('kiwi' in fruits) # True/False
print([Link]('pomme'))# nombre d'occurrences

Opérations avancées :

Formation Python Complète • Page 10

 nombres = [3, 1, 4, 1, 5, 9, 2, 6]

# Trier
[Link]() # tri en place: [1,1,2,3,4,5,6,9]
[Link](reverse=True) # décroissant
tries = sorted(nombres) # retourne une nouvelle liste

# Inverser
[Link]()

# Concaténer
a = [1, 2, 3]
b = [4, 5, 6]
c = a + b # [1,2,3,4,5,6]
[Link](b) # modifie a directement

# Copier (IMPORTANT!)
copie = [Link]() # vraie copie indépendante
# PAS: copie = a (ce serait juste un alias!)

■■ ATTENTION
Ne fais JAMAIS liste2 = liste1 pour copier une liste. Tu aurais deux variables
pointant vers le MÊME objet. Utilise liste2 = [Link]().

2.2 — Les Tuples

Un tuple est comme une liste IMMUABLE — on ne peut pas le modifier après création. Utilisé pour des données
constantes ou des retours multiples de fonctions.

# Créer un tuple
coordonnees = (48.8566, 2.3522) # Paris
couleurs_rgb = (255, 128, 0) # Orange
singleton = (42,) # tuple à 1 élément (virgule!)

# Accès identique aux listes

print(coordonnees[0]) # 48.8566
print(len(couleurs_rgb))# 3

# Déballage (unpacking) - super pratique!

lat, lon = coordonnees
r, g, b = couleurs_rgb
print(f'Latitude: {lat}, Longitude: {lon}')

# Retour multiple d'une fonction

def min_max(liste):
return min(liste), max(liste)

minimum, maximum = min_max([3,1,4,1,5,9])

print(f'Min: {minimum}, Max: {maximum}') # Min: 1, Max: 9

2.3 — Les Dictionnaires (dict)

Formation Python Complète • Page 11

Un dictionnaire stocke des paires clé → valeur. C'est la structure la plus puissante de Python, utilisée partout.

# Créer un dictionnaire
personne = {
'nom': 'Alice',
'age': 28,
'ville': 'Lyon',
'actif': True
}

# Lire des valeurs

print(personne['nom']) # 'Alice'
print([Link]('email', 'Non défini')) # sécurisé

# Modifier / Ajouter
personne['age'] = 29 # modifier
personne['email'] = 'a@[Link]' # ajouter

# Supprimer
del personne['actif']
email = [Link]('email') # supprime et retourne

# Parcourir
for cle, valeur in [Link]():
print(f'{cle}: {valeur}')

# Clés et valeurs
print(list([Link]())) # ['nom', 'age', 'ville']
print(list([Link]())) # ['Alice', 29, 'Lyon']

# Vérifier l'existence
print('nom' in personne) # True

Dictionnaires imbriqués (très fréquents en API/JSON) :

etudiants = {
'Alice': {'note': 18, 'matiere': 'Python'},
'Bob': {'note': 15, 'matiere': 'JavaScript'},
'Eve': {'note': 20, 'matiere': 'Python'},
}

# Accéder à une valeur imbriquée

print(etudiants['Alice']['note']) # 18

# Ajouter un étudiant
etudiants['Charlie'] = {'note': 17, 'matiere': 'Rust'}

# Trouver le meilleur étudiant

meilleur = max(etudiants, key=lambda e: etudiants[e]['note'])
print(f'Meilleur: {meilleur}') # Eve

2.4 — Les Ensembles (set)

Formation Python Complète • Page 12

Un set est une collection non ordonnée sans doublons. Parfait pour supprimer les duplicatas et faire des opérations
ensemblistes.

# Créer un set
fruits = {'pomme', 'banane', 'cerise', 'pomme'} # doublon ignoré
print(fruits) # {'pomme', 'banane', 'cerise'}

# Depuis une liste (supprime les doublons!)

liste_avec_doublons = [1, 2, 2, 3, 3, 3, 4]
unique = set(liste_avec_doublons)
print(unique) # {1, 2, 3, 4}

# Opérations ensemblistes
a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7}

print(a | b) # Union: {1,2,3,4,5,6,7}

print(a & b) # Intersection: {3,4,5}
print(a - b) # Différence: {1,2}
print(a ^ b) # Différence symétrique: {1,2,6,7}

# Vérification (très rapide!)

print(3 in a) # True — plus rapide que dans une liste

■ EXPERT
Utilise un set quand tu dois vérifier souvent si un élément existe dans une
collection. C'est beaucoup plus rapide qu'une liste pour cette opération.

■ Récapitulatif des structures

Structure Ordonné ? Modifiable ? Doublons ? Syntaxe

list Oui Oui Oui [1, 2, 3]

tuple Oui Non Oui (1, 2, 3)

dict Oui* Oui Clés: Non {'a': 1}

set Non Oui Non {1, 2, 3}

■■ Exercices du Chapitre 2

• • Exercice 1 : Crée une liste de 5 pays, trie-la alphabétiquement, ajoute un pays et supprime-en un.
• • Exercice 2 : Crée un dictionnaire 'carnet' avec 3 contacts (nom, téléphone, email). Ajoute, modifie et supprime
un contact.
• • Exercice 3 : Donne une liste avec des doublons [1,2,2,3,3,3,4,5,5] et affiche les valeurs uniques, leur nombre
et si le nombre 7 est présent.
• • Exercice 4 : Crée un dictionnaire de notes {'Alice':18, 'Bob':14, 'Eve':20} et calcule la moyenne, trouve le
meilleur et le moins bon.

Formation Python Complète • Page 13

 ■
CHAPITRE 03
Contrôle du Flux

Conditions · Boucles · Compréhensions

Formation Python Complète • Page 14

3.1 — Conditions (if / elif / else)

age = 20

if age >= 18:

print('Tu es majeur')
elif age >= 13:
print('Tu es adolescent')
else:
print('Tu es enfant')

# Opérateurs de comparaison
# == égal != différent
# > supérieur >= supérieur ou égal
# < inférieur <= inférieur ou égal

# Opérateurs logiques
x = 15
if x > 10 and x < 20: # ET
print('x est entre 10 et 20')

if x < 5 or x > 10: # OU

print('x est hors de [5,10]')

if not (x == 0): # NON

print('x est non nul')

# Condition ternaire (sur une ligne)

statut = 'majeur' if age >= 18 else 'mineur'
print(statut)

■■ ATTENTION
L'indentation (4 espaces) est OBLIGATOIRE en Python. C'est elle qui délimite les
blocs de code. Si tu oublies d'indenter, ton programme plantera.

3.2 — Boucle for

Formation Python Complète • Page 15

# Parcourir une liste
fruits = ['pomme', 'banane', 'cerise']
for fruit in fruits:
print(f'Fruit: {fruit}')

# range() - générer des nombres

for i in range(5): # 0, 1, 2, 3, 4
print(i)

for i in range(1, 11): # 1, 2, 3, ..., 10

print(i)

for i in range(0, 20, 2): # 0, 2, 4, ..., 18 (pas de 2)

print(i)

# enumerate() - index + valeur

langages = ['Python', 'JavaScript', 'Rust']
for i, lang in enumerate(langages):
print(f'{i+1}. {lang}')

# zip() - parcourir 2 listes ensemble

noms = ['Alice', 'Bob', 'Eve']
scores = [18, 14, 20]
for nom, score in zip(noms, scores):
print(f'{nom}: {score}/20')

3.3 — Boucle while

Formation Python Complète • Page 16

 # Boucle tant que la condition est vraie
compteur = 0
while compteur < 5:
print(f'Compteur: {compteur}')
compteur += 1

# Exemple pratique: deviner un nombre

import random
secret = [Link](1, 100)
essais = 0

while True:
guess = int(input('Devine le nombre (1-100): '))
essais += 1
if guess < secret:
print('Trop petit!')
elif guess > secret:
print('Trop grand!')
else:
print(f'Bravo! Trouvé en {essais} essais!')
break # sort de la boucle

# continue - passe à l'itération suivante

for i in range(10):
if i % 2 == 0:
continue # saute les pairs
print(i) # affiche: 1, 3, 5, 7, 9

3.4 — Compréhensions de listes (List Comprehensions)

C'est une des fonctionnalités les plus élégantes de Python. Elle permet de créer des listes en une seule ligne.

Formation Python Complète • Page 17

 # Syntaxe: [expression for element in iterable if condition]

# CLASSIQUE vs PYTHONIQUE

# Classique (verbeux):
carres = []
for i in range(10):
[Link](i ** 2)

# Pythonique (list comprehension):

carres = [i**2 for i in range(10)]
print(carres) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Avec condition
pairs = [i for i in range(20) if i % 2 == 0]
print(pairs) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# Transformation de strings
fruits = ['pomme', 'banane', 'cerise']
majusc = [[Link]() for f in fruits]
print(majusc) # ['POMME', 'BANANE', 'CERISE']

# Dict comprehension
noms = ['Alice', 'Bob', 'Eve']
scores = [18, 14, 20]
carnet = {nom: score for nom, score in zip(noms, scores)}
print(carnet) # {'Alice': 18, 'Bob': 14, 'Eve': 20}

# Set comprehension
uniques = {x**2 for x in [-3, -2, -1, 0, 1, 2, 3]}
print(uniques) # {0, 1, 4, 9}

■ EXPERT
Les list comprehensions sont la marque d'un développeur Python confirmé. Entraîne-toi
à les utiliser — elles rendent le code plus lisible et plus rapide.

■■ Exercices du Chapitre 3

• • Exercice 1 : Affiche la table de multiplication de 1 à 10 avec des boucles.

• • Exercice 2 : Crée une liste des 20 premiers nombres de Fibonacci avec une boucle.
• • Exercice 3 : En une ligne de list comprehension, extrais les mots de plus de 4 lettres d'une phrase.
• • Exercice 4 : Crée un jeu de devinette : le programme choisit un nombre entre 1 et 50, l'utilisateur a 7 essais
max.

Formation Python Complète • Page 18

 ■■
CHAPITRE 04
Fonctions & Modules

def · lambda · *args · imports

Formation Python Complète • Page 19

 4.1 — Définir une fonction

# Syntaxe de base
def saluer(prenom):
message = f'Bonjour, {prenom} !'
return message

# Appel de la fonction
resultat = saluer('Alice')
print(resultat) # Bonjour, Alice !

# Paramètres avec valeur par défaut

def saluer(prenom, langue='fr'):
if langue == 'fr':
return f'Bonjour, {prenom} !'
elif langue == 'en':
return f'Hello, {prenom}!'
return f'Hi, {prenom}'

print(saluer('Bob')) # Bonjour, Bob !

print(saluer('Alice', 'en')) # Hello, Alice!

# Retourner plusieurs valeurs

def statistiques(liste):
return min(liste), max(liste), sum(liste)/len(liste)

mini, maxi, moy = statistiques([3, 1, 4, 1, 5, 9])

print(f'Min:{mini} Max:{maxi} Moy:{moy:.2f}')

Arguments avancés — *args et **kwargs :

# *args: nombre variable d'arguments positionnels

def addition(*nombres):
return sum(nombres)

print(addition(1, 2)) # 3
print(addition(1, 2, 3, 4)) # 10
print(addition(10, 20, 30)) # 60

# **kwargs: arguments nommés

def profil(**infos):
for cle, valeur in [Link]():
print(f'{cle}: {valeur}')

profil(nom='Alice', age=28, ville='Paris')

# Combinaison
def super_fonction(*args, **kwargs):
print('Args:', args)
print('Kwargs:', kwargs)

super_fonction(1, 2, 3, nom='Alice', actif=True)

Formation Python Complète • Page 20

 4.2 — Fonctions Lambda

Les lambdas sont des fonctions anonymes en une seule ligne. Utilisées souvent avec map(), filter() et sorted().

# Lambda simple
carre = lambda x: x ** 2
print(carre(5)) # 25

double = lambda x: x * 2
add = lambda x, y: x + y

# Utilisation avec sorted()

etudiants = [
{'nom': 'Alice', 'note': 18},
{'nom': 'Bob', 'note': 14},
{'nom': 'Eve', 'note': 20},
]
# Trier par note (croissant)
tries = sorted(etudiants, key=lambda e: e['note'])
# Trier par note (décroissant)
tries = sorted(etudiants, key=lambda e: e['note'], reverse=True)

# map() - applique une fonction à chaque élément

nombres = [1, 2, 3, 4, 5]
carres = list(map(lambda x: x**2, nombres))
print(carres) # [1, 4, 9, 16, 25]

# filter() - garde seulement les vrais

pairs = list(filter(lambda x: x % 2 == 0, nombres))
print(pairs) # [2, 4]

4.3 — Modules et imports

Formation Python Complète • Page 21

 # Importer un module entier
import math
print([Link]) # 3.141592...
print([Link](16)) # 4.0
print([Link](4.2)) # 5
print([Link](4.8)) # 4

# Importer des fonctions spécifiques

from math import pi, sqrt, factorial
print(sqrt(25)) # 5.0
print(factorial(5)) # 120

# Importer avec alias

import random as rnd
print([Link](1, 6)) # dé à 6 faces
print([Link](['pile', 'face']))

# Module datetime
from datetime import datetime, date
maintenant = [Link]()
print([Link]('%d/%m/%Y %H:%M'))

# Module os
import os
print([Link]()) # répertoire courant
print([Link]('.')) # liste les fichiers
[Link]('mon_dossier', exist_ok=True)

Créer ton propre module :

# Fichier: [Link]
def addition(a, b):
return a + b

def aire_cercle(rayon):
import math
return [Link] * rayon ** 2

PI = 3.14159

# ==============================
# Dans un autre fichier: [Link]
import calculs

print([Link](5, 3)) # 8
print(calculs.aire_cercle(7)) # 153.93...
print([Link]) # 3.14159

# Ou avec from/import
from calculs import addition, aire_cercle
print(addition(10, 20)) # 30

Formation Python Complète • Page 22

■ EXPERT
Organise ton code en modules dès que tu dépasses 100-150 lignes. Un bon code est
modulaire, réutilisable et facile à tester.

4.4 — Portée des variables (Scope)

# Variable LOCALE (dans la fonction)

def ma_fonction():
locale = 'Je suis locale'
print(locale) # OK

ma_fonction()
# print(locale) # ERREUR! non accessible ici

# Variable GLOBALE
compteur = 0

def incrementer():
global compteur # déclare qu'on veut la globale
compteur += 1

incrementer()
incrementer()
print(compteur) # 2

■■ ATTENTION
Évite les variables globales autant que possible. Passe les valeurs en paramètres et
retourne les résultats. Ton code sera plus propre et testable.

Formation Python Complète • Page 23

 ■■
CHAPITRE 05
Programmation Orientée Objet

Classes · Héritage · Méthodes spéciales

Formation Python Complète • Page 24

 5.1 — Classes et Objets

La POO permet de modéliser le monde réel en créant des 'objets' qui regroupent données et comportements. C'est
le paradigme dominant dans l'industrie.

class Animal:
# Attribut de classe (partagé par tous)
royaume = 'Animalia'

# Constructeur (appelé à la création)

def __init__(self, nom, espece, age):
[Link] = nom # attribut d'instance
[Link] = espece
[Link] = age
[Link] = True

# Méthode
def presenter(self):
return f'Je suis {[Link]}, un {[Link]} de {[Link]} ans.'

def anniversaire(self):
[Link] += 1
print(f'{[Link]} a maintenant {[Link]} ans!')

# Représentation string
def __str__(self):
return f'Animal({[Link]}, {[Link]})'

# Créer des objets (instances)

rex = Animal('Rex', 'Chien', 3)
mimi = Animal('Mimi', 'Chat', 7)

print([Link]())
[Link]()
print(rex) # Animal(Rex, Chien)
print([Link]) # Animalia

5.2 — Héritage

Formation Python Complète • Page 25

class Vehicule:
def __init__(self, marque, vitesse_max):
[Link] = marque
self.vitesse_max = vitesse_max
[Link] = 0

def accelerer(self, increment):

[Link] = min([Link] + increment, self.vitesse_max)
print(f'{[Link]}: {[Link]} km/h')

def freiner(self, decrement):

[Link] = max(0, [Link] - decrement)

def __str__(self):
return f'{[Link]} ({self.vitesse_max} km/h max)'

class Voiture(Vehicule): # hérite de Vehicule

def __init__(self, marque, vitesse_max, nb_portes):
super().__init__(marque, vitesse_max) # appelle parent
self.nb_portes = nb_portes

def klaxonner(self):
print(f'{[Link]}: TUUUT!')

class Moto(Vehicule):
def __init__(self, marque, vitesse_max):
super().__init__(marque, vitesse_max)

def faire_wheelie(self):
if [Link] > 60:
print('WHEELIE!')

# Utilisation
ferrari = Voiture('Ferrari', 320, 2)
ducati = Moto('Ducati', 280)

[Link](100)
[Link]()
[Link](80)
ducati.faire_wheelie()

■■ INFO
super() appelle le constructeur de la classe parente. C'est essentiel quand tu fais
de l'héritage pour initialiser correctement tous les attributs.

5.3 — Méthodes spéciales (Dunder Methods)

Formation Python Complète • Page 26

class Vecteur:
def __init__(self, x, y):
self.x = x
self.y = y

def __str__(self): # print(v)

return f'Vecteur({self.x}, {self.y})'

def __repr__(self): # représentation debug

return f'Vecteur(x={self.x}, y={self.y})'

def __add__(self, autre): # v1 + v2

return Vecteur(self.x + autre.x, self.y + autre.y)

def __mul__(self, scalaire): # v * 3

return Vecteur(self.x * scalaire, self.y * scalaire)

def __len__(self): # len(v)

import math
return int([Link](self.x**2 + self.y**2))

def __eq__(self, autre): # v1 == v2

return self.x == autre.x and self.y == autre.y

v1 = Vecteur(3, 4)
v2 = Vecteur(1, 2)
print(v1) # Vecteur(3, 4)
print(v1 + v2) # Vecteur(4, 6)
print(v1 * 2) # Vecteur(6, 8)
print(len(v1)) # 5

Formation Python Complète • Page 27

 ■
CHAPITRE 06
Fichiers & Exceptions

I/O · try/except · Context managers

Formation Python Complète • Page 28

6.1 — Lire et écrire des fichiers

# Écrire dans un fichier

with open('[Link]', 'w', encoding='utf-8') as f:
[Link]('Bonjour!\n')
[Link]('Ceci est mon fichier.\n')

# Lire tout le fichier

with open('[Link]', 'r', encoding='utf-8') as f:
contenu = [Link]()
print(contenu)

# Lire ligne par ligne

with open('[Link]', 'r', encoding='utf-8') as f:
for ligne in f:
print([Link]())

# Lire toutes les lignes dans une liste

with open('[Link]', 'r', encoding='utf-8') as f:
lignes = [Link]()

# Ajouter à un fichier existant (append)

with open('[Link]', 'a', encoding='utf-8') as f:
[Link]('Nouvelle ligne ajoutee!\n')

# Travailler avec JSON

import json

donnees = {'nom': 'Alice', 'age': 28, 'langages': ['Python', 'Rust']}

# Écrire JSON
with open('[Link]', 'w') as f:
[Link](donnees, f, indent=2)

# Lire JSON
with open('[Link]', 'r') as f:
loaded = [Link](f)
print(loaded['nom']) # Alice

6.2 — Gestion des exceptions (try/except)

Formation Python Complète • Page 29

# Structure de base
try:
nombre = int(input('Entrez un nombre: '))
resultat = 10 / nombre
print(f'Résultat: {resultat}')
except ValueError:
print('Erreur: Ce n est pas un nombre!')
except ZeroDivisionError:
print('Erreur: Division par zéro!')
except Exception as e:
print(f'Erreur inattendue: {e}')
else:
print('Tout s est bien passé!') # si pas d exception
finally:
print('Ce bloc s execute TOUJOURS') # nettoyage

# Lever une exception

def diviser(a, b):
if b == 0:
raise ValueError('Le diviseur ne peut pas être 0')
return a / b

# Exceptions personnalisées
class AgeInvalideError(Exception):
def __init__(self, age):
[Link] = age
super().__init__(f'Age invalide: {age}. Doit etre entre 0 et 150.')

def valider_age(age):
if not 0 <= age <= 150:
raise AgeInvalideError(age)
return True

■ EXPERT
Sois précis dans tes except: attrap les exceptions spécifiques, pas juste 'except
Exception'. Cela aide à déboguer et à comprendre les vrais problèmes.

Formation Python Complète • Page 30

 ■
CHAPITRE 07
Bibliothèques Standard

os · sys · re · datetime · json · csv

Formation Python Complète • Page 31

7.1 — Module os — Gestion du système

import os

# Navigation
print([Link]()) # répertoire courant
[Link]('/tmp') # changer de répertoire

# Fichiers et dossiers
[Link]('projet/src', exist_ok=True)
[Link]('[Link]', '[Link]')
[Link]('[Link]')
[Link]('dossier_vide')

# Lister les fichiers

for item in [Link]('.'):
chemin = [Link]('.', item)
if [Link](chemin):
taille = [Link](chemin)
print(f'{item}: {taille} octets')

# Variables d environnement
home = [Link]('HOME', '/home/user')
path = [Link]('PATH')

# Informations système
print([Link]) # 'nt' (Windows) ou 'posix' (Unix)
print([Link]) # '\\' ou '/'

7.2 — Expressions régulières (re)

Formation Python Complète • Page 32

import re

# Chercher un pattern
texte = 'Mon email est alice@[Link] et bob@[Link]'

# Trouver tous les emails

pattern_email = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'
emails = [Link](pattern_email, texte)
print(emails) # ['alice@[Link]', 'bob@[Link]']

# Valider un numéro de téléphone FR

def valider_tel(tel):
pattern = r'^(\+33|0)[1-9](\d{2}){4}$'
return bool([Link](pattern, tel))

print(valider_tel('0612345678')) # True
print(valider_tel('123')) # False

# Remplacer du texte
texte = 'le prix est 19.99 euros et 45.50 euros'
resultat = [Link](r'\d+\.\d+', '[Link]', texte)
print(resultat) # 'le prix est [Link] euros et [Link] euros'

# Groupes de capture
date_str = '2025-03-15'
match = [Link](r'(\d{4})-(\d{2})-(\d{2})', date_str)
if match:
annee, mois, jour = [Link]()
print(f'Année: {annee}, Mois: {mois}, Jour: {jour}')

■■ INFO
Les expressions régulières semblent complexes au début. Utilise [Link] pour
tester tes patterns en temps réel. Avec de la pratique, ça devient naturel.

Formation Python Complète • Page 33

 ■
CHAPITRE 08
Développement Web

Flask · FastAPI · Django — APIs & Applications web

Formation Python Complète • Page 34

 8.1 — Flask — Le micro-framework

Flask est le framework web le plus simple pour démarrer. Parfait pour des APIs et des petites applications.

# pip install flask

from flask import Flask, request, jsonify

app = Flask(__name__)

# Base de données simulée

utilisateurs = [
{'id': 1, 'nom': 'Alice', 'email': 'alice@[Link]'},
{'id': 2, 'nom': 'Bob', 'email': 'bob@[Link]'},
]

# Route principale
@[Link]('/')
def accueil():
return '<h1>Bienvenue sur mon API Flask!</h1>'

# API GET - Tous les utilisateurs

@[Link]('/api/users', methods=['GET'])
def get_users():
return jsonify(utilisateurs)

# API GET - Un utilisateur par ID

@[Link]('/api/users/<int:user_id>', methods=['GET'])
def get_user(user_id):
user = next((u for u in utilisateurs if u['id'] == user_id), None)
if user:
return jsonify(user)
return jsonify({'erreur': 'Utilisateur non trouvé'}), 404

# API POST - Créer un utilisateur

@[Link]('/api/users', methods=['POST'])
def create_user():
data = request.get_json()
new_user = {'id': len(utilisateurs)+1, **data}
[Link](new_user)
return jsonify(new_user), 201

if __name__ == '__main__':
[Link](debug=True, port=5000)

8.2 — FastAPI — L'API moderne et ultra-rapide

FastAPI est le framework de référence pour les APIs professionnelles. Il génère automatiquement la documentation
et valide les données.

Formation Python Complète • Page 35

# pip install fastapi uvicorn
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional

app = FastAPI(title='Mon API', version='1.0.0')

# Modèle de données avec validation automatique

class Utilisateur(BaseModel):
nom: str
email: str
age: Optional[int] = None

class UtilisateurDB(Utilisateur):
id: int

db = []

@[Link]('/')
def accueil():
return {'message': 'Bienvenue sur mon API FastAPI!'}

@[Link]('/users', response_model=list[UtilisateurDB])
def lister_users():
return db

@[Link]('/users', response_model=UtilisateurDB, status_code=201)

def creer_user(user: Utilisateur):
new_user = UtilisateurDB(id=len(db)+1, **[Link]())
[Link](new_user)
return new_user

@[Link]('/users/{user_id}')
def get_user(user_id: int):
user = next((u for u in db if [Link] == user_id), None)
if not user:
raise HTTPException(status_code=404, detail='Non trouvé')
return user

# Lancement: uvicorn main:app --reload

# Documentation auto: [Link]

■ EXPERT
FastAPI génère automatiquement une documentation interactive (Swagger UI) accessible
sur /docs. C'est un gain de temps énorme en développement d'API.

8.3 — Django — Le framework complet

Formation Python Complète • Page 36

# pip install django
# django-admin startproject monsite
# python [Link] startapp blog

# [Link] — Définir les données

from [Link] import models

class Article([Link]):
titre = [Link](max_length=200)
contenu = [Link]()
date_pub = [Link](auto_now_add=True)
auteur = [Link](max_length=100)
publie = [Link](default=False)

def __str__(self):
return [Link]

class Meta:
ordering = ['-date_pub']

# [Link] — Logique métier

from [Link] import render, get_object_or_404
from .models import Article

def liste_articles(request):
articles = [Link](publie=True)
return render(request, 'blog/[Link]', {'articles': articles})

def detail_article(request, pk):

article = get_object_or_404(Article, pk=pk, publie=True)
return render(request, 'blog/[Link]', {'article': article})

# [Link]
from [Link] import path
from . import views

urlpatterns = [
path('', views.liste_articles, name='liste'),
path('<int:pk>/', views.detail_article, name='detail'),
]

Framework Cas d'usage Apprentissage Performance

Flask APIs simples, prototypes Facile Bonne

FastAPI APIs pro, microservices Moyen Excellente

Django Sites web complets, CMS, e-commerce Plus long Très bonne

Formation Python Complète • Page 37

 ■■
CHAPITRE 09
Bases de Données

SQLite · SQLAlchemy · PostgreSQL

Formation Python Complète • Page 38

9.1 — SQLite avec Python

import sqlite3

# Connexion (crée le fichier si inexistant)

conn = [Link]('ma_base.db')
cursor = [Link]()

# Créer une table

[Link]('''
CREATE TABLE IF NOT EXISTS utilisateurs (
id INTEGER PRIMARY KEY AUTOINCREMENT,
nom TEXT NOT NULL,
email TEXT UNIQUE NOT NULL,
age INTEGER,
actif BOOLEAN DEFAULT 1
)
''')

# Insérer des données

[Link](
'INSERT INTO utilisateurs (nom, email, age) VALUES (?, ?, ?)',
('Alice', 'alice@[Link]', 28)
)

# Insertion multiple
utilisateurs = [
('Bob', 'bob@[Link]', 35),
('Eve', 'eve@[Link]', 24),
('Charlie','charlie@[Link]',30),
]
[Link](
'INSERT INTO utilisateurs (nom, email, age) VALUES (?, ?, ?)',
utilisateurs
)

[Link]() # Sauvegarder

# Lire les données

[Link]('SELECT * FROM utilisateurs WHERE age > 25')
resultats = [Link]()
for row in resultats:
print(row) # (id, nom, email, age, actif)

# Mettre à jour
[Link](
'UPDATE utilisateurs SET age = ? WHERE nom = ?',
(29, 'Alice')
)

# Supprimer
[Link]('DELETE FROM utilisateurs WHERE nom = ?', ('Bob',))

[Link]()
[Link]()

Formation Python Complète • Page 39

■■ ATTENTION
Utilise TOUJOURS des paramètres (?) au lieu de formater les strings SQL directement.
Cela protège contre les injections SQL, la faille de sécurité la plus courante.

9.2 — SQLAlchemy ORM

# pip install sqlalchemy

from sqlalchemy import create_engine, Column, Integer, String, Boolean
from [Link] import DeclarativeBase, Session

# Connexion
engine = create_engine('sqlite:///[Link]', echo=False)

class Base(DeclarativeBase):
pass

# Modèle
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
nom = Column(String(100), nullable=False)
email = Column(String(200), unique=True)
age = Column(Integer)
actif = Column(Boolean, default=True)

def __repr__(self):
return f'User(id={[Link]}, nom={[Link]})'

# Créer les tables

[Link].create_all(engine)

# CRUD complet
with Session(engine) as session:
# CREATE
alice = User(nom='Alice', email='alice@[Link]', age=28)
[Link](alice)
[Link]()

# READ
users = [Link](User).filter([Link] > 20).all()
user = [Link](User).filter_by(nom='Alice').first()

# UPDATE
[Link] = 29
[Link]()

# DELETE
[Link](user)
[Link]()

Formation Python Complète • Page 40

 ■
CHAPITRE 10
Data Science

NumPy · Pandas · Matplotlib · Seaborn

Formation Python Complète • Page 41

10.1 — NumPy — Calcul scientifique

# pip install numpy

import numpy as np

# Créer des tableaux

a = [Link]([1, 2, 3, 4, 5])
b = [Link]((3, 4)) # matrice 3x4 de 0
c = [Link]((2, 2)) # matrice 2x2 de 1
d = [Link](0, 10, 0.5) # de 0 à 10 par pas 0.5
e = [Link](100) # 100 nombres aléatoires [0,1]

# Opérations vectorisées (rapides!)

x = [Link]([1, 2, 3, 4, 5])
print(x * 2) # [2 4 6 8 10]
print(x ** 2) # [1 4 9 16 25]
print(x + 10) # [11 12 13 14 15]

# Statistiques
data = [Link](100, 15, 1000) # distribution normale
print(f'Moyenne: {[Link]():.2f}')
print(f'Ecart-type: {[Link]():.2f}')
print(f'Min: {[Link]():.2f}, Max: {[Link]():.2f}')

# Matrices
A = [Link]([[1, 2], [3, 4]])
B = [Link]([[5, 6], [7, 8]])
print(A @ B) # Multiplication matricielle
print([Link](A)) # Déterminant

10.2 — Pandas — Manipulation de données

Formation Python Complète • Page 42

# pip install pandas
import pandas as pd

# Créer un DataFrame
data = {
'Nom': ['Alice', 'Bob', 'Eve', 'Charlie', 'Dave'],
'Age': [28, 35, 24, 30, 27],
'Ville': ['Paris', 'Lyon', 'Marseille', 'Paris', 'Lyon'],
'Salaire':[45000, 55000, 38000, 60000, 42000],
}
df = [Link](data)

# Exploration
print([Link]()) # 5 premières lignes
print([Link]) # (5, 4)
print([Link]) # types des colonnes
print([Link]()) # statistiques

# Filtrer
parisiens = df[df['Ville'] == 'Paris']
seniors = df[df['Age'] > 30]
bien_payes = df[df['Salaire'] > 50000]

# Sélectionner colonnes
noms_ages = df[['Nom', 'Age']]

# Ajouter une colonne

df['Salaire_mensuel'] = df['Salaire'] / 12

# Groupby
moy_par_ville = [Link]('Ville')['Salaire'].mean()
print(moy_par_ville)

# Trier
df_tries = df.sort_values('Salaire', ascending=False)

# Lire/Écrire CSV
df.to_csv('[Link]', index=False)
df2 = pd.read_csv('[Link]')

# Valeurs manquantes
[Link]() # supprimer les NaN
[Link](0) # remplacer NaN par 0

■ EXPERT
Pandas est la bibliothèque DATA la plus utilisée en Python. Si tu veux travailler
dans la data science ou l'analyse, maîtrise-la parfaitement.

Formation Python Complète • Page 43

 ■
CHAPITRE 11
Scripts & Automatisation

Requests · BeautifulSoup · Selenium · Cron

Formation Python Complète • Page 44

11.1 — Requests — Appels HTTP

# pip install requests

import requests

# GET simple
response = [Link]('[Link]
print(response.status_code) # 200
data = [Link]()
print(f'Nom: {data["name"]}')
print(f'Repos: {data["public_repos"]}')

# GET avec paramètres

params = {'q': 'python', 'sort': 'stars', 'per_page': 5}
r = [Link]('[Link] params=params)
repos = [Link]()['items']
for repo in repos:
print(f'{repo["name"]}: {repo["stargazers_count"]} stars')

# POST avec authentification

headers = {'Authorization': 'Bearer MON_TOKEN',
'Content-Type': 'application/json'}
payload = {'title': 'Mon issue', 'body': 'Description...'}
r = [Link](
'[Link]
json=payload, headers=headers
)

# Télécharger un fichier
url = '[Link]
r = [Link](url, stream=True)
with open('[Link]', 'wb') as f:
for chunk in r.iter_content(chunk_size=8192):
[Link](chunk)

11.2 — BeautifulSoup — Web Scraping

Formation Python Complète • Page 45

# pip install beautifulsoup4 requests
import requests
from bs4 import BeautifulSoup

# Scraper une page

url = '[Link]
response = [Link](url)
soup = BeautifulSoup([Link], '[Link]')

# Trouver des éléments

titre = [Link]('h1')
titres = soup.find_all('h2')
articles = soup.find_all('article', class_='product_pod')

for article in articles[:5]:

titre = [Link]('h3').find('a')['title']
prix = [Link]('p', class_='price_color').text
dispo = [Link]('p', class_='availability').[Link]()
print(f'{titre}: {prix} ({dispo})')

# Sélecteurs CSS (comme JavaScript!)

liens = [Link]('[Link]-primary')
for lien in liens:
print([Link]('href'))

■■ ATTENTION
Le scraping doit être éthique: vérifie le fichier [Link] du site, respecte les
délais entre requêtes, et n'utilise pas les données à des fins malveillantes.

11.3 — Selenium — Automatisation du navigateur

Formation Python Complète • Page 46

# pip install selenium
from selenium import webdriver
from [Link] import By
from [Link] import Keys
from [Link] import WebDriverWait
from [Link] import expected_conditions as EC
import time

# Démarrer le navigateur
driver = [Link]() # ou Firefox()
driver.maximize_window()

try:
# Naviguer
[Link]('[Link]

# Attendre et cliquer
wait = WebDriverWait(driver, 10)
search = [Link](EC.presence_of_element_located(
([Link], 'q')
))
search.send_keys('Python programmation')
search.send_keys([Link])

# Récupérer les résultats

[Link](2)
resultats = driver.find_elements(By.CSS_SELECTOR, 'h3')
for r in resultats[:5]:
print([Link])

# Screenshot
driver.save_screenshot('[Link]')

finally:
[Link]() # TOUJOURS fermer!

Formation Python Complète • Page 47

 ■
CHAPITRE 12
Cybersécurité avec Python

Scapy · Cryptographie · Pentest · CTF

Formation Python Complète • Page 48

12.1 — Avertissement Éthique

■■ ATTENTION
IMPORTANT: Ces connaissances sont à utiliser UNIQUEMENT de façon éthique et légale:
CTF, bug bounty avec autorisation, tests sur tes propres systèmes. L'utilisation non
autorisée de ces techniques est un crime dans la plupart des pays. Be a White Hat,
not a Black Hat.

12.2 — Cryptographie avec Python

# pip install cryptography

from [Link] import Fernet
import hashlib, secrets

# === Chiffrement symétrique (Fernet/AES) ===

# Générer une clé
cle = Fernet.generate_key()
f = Fernet(cle)

# Chiffrer
message = b'Message secret!'
chiffre = [Link](message)
print(f'Chiffré: {chiffre}')

# Déchiffrer
dechiffre = [Link](chiffre)
print(f'Déchiffré: {[Link]()}')

# === Hachage (mots de passe) ===

mdp = 'MonMotDePasse123!'

# SHA-256
h = hashlib.sha256([Link]()).hexdigest()
print(f'SHA256: {h}')

# Avec sel (salt) - méthode recommandée

import hashlib
sel = secrets.token_hex(16)
hash = hashlib.sha256(f'{sel}{mdp}'.encode()).hexdigest()
print(f'Sel: {sel}')
print(f'Hash: {hash}')

# === Générer des tokens sécurisés ===

token = secrets.token_urlsafe(32)
print(f'Token API: {token}')

12.3 — Analyse réseau avec Scapy

Formation Python Complète • Page 49

# pip install scapy
# /!\ Nécessite les droits root/admin
from [Link] import *

# === Ping (ICMP) ===

def ping(host):
packet = IP(dst=host)/ICMP()
reponse = sr1(packet, timeout=2, verbose=0)
if reponse:
print(f'{host} est en ligne!')
return True
print(f'{host} ne répond pas.')
return False

ping('[Link]') # Ping Google DNS

# === Port Scanner simple ===

def scan_ports(host, ports):
ouverts = []
for port in ports:
# SYN scan (half-open)
pkt = IP(dst=host)/TCP(dport=port, flags='S')
rep = sr1(pkt, timeout=1, verbose=0)
if rep and [Link](TCP):
if rep[TCP].flags == 0x12: # SYN-ACK
[Link](port)
# Reset
send(IP(dst=host)/TCP(dport=port,flags='R'),
verbose=0)
return ouverts

# Scanner les ports communs

ports_communs = [21,22,23,25,53,80,443,3306,5432,8080]
# resultats = scan_ports('[Link]', ports_communs)

12.4 — Outils de sécurité courants

Formation Python Complète • Page 50

# === Analyseur de mots de passe ===
import re

def analyser_mdp(mdp):
score = 0
retours = []

if len(mdp) >= 12:

score += 2
else:
[Link]('Utilisez au moins 12 caractères')

if [Link](r'[A-Z]', mdp):
score += 1
else:
[Link]('Ajoutez des majuscules')

if [Link](r'[0-9]', mdp):
score += 1
else:
[Link]('Ajoutez des chiffres')

if [Link](r'[!@#$%^&*(),.?":{}|<>]', mdp):
score += 2
else:
[Link]('Ajoutez des caractères spéciaux')

niveaux = {5:'FORT', 4:'BON', 3:'MOYEN', 0:'FAIBLE'}

niveau = next(v for k,v in sorted([Link](), reverse=True)
if score >= k)
return {'score': score, 'niveau': niveau, 'conseils': retours}

r = analyser_mdp('MonSuperMdp2025!')
print(f'Niveau: {r["niveau"]} ({r["score"]}/6)')

■■ INFO
Pour apprendre la cybersécurité éthiquement: HackTheBox, TryHackMe, PicoCTF sont
d'excellentes plateformes CTF légales où tu peux pratiquer librement.

Formation Python Complète • Page 51

 ■
CHAPITRE 13
Frameworks Avancés

Async/Await · Typer · Pydantic · Tests · Packaging

Formation Python Complète • Page 52

13.1 — Programmation Asynchrone (async/await)

import asyncio
import aiohttp # pip install aiohttp
import time

# Version SYNCHRONE (lente)

# def fetch_sync(url): ...
# Prend 10s pour 10 URLs

# Version ASYNCHRONE (rapide)

async def fetch(session, url):
async with [Link](url) as response:
return await [Link]()

async def fetch_all(urls):

async with [Link]() as session:
taches = [fetch(session, url) for url in urls]
resultats = await [Link](*taches)
return resultats

# Exemple pratique
async def main():
urls = [
'[Link]
'[Link]
'[Link]
]
debut = [Link]()
resultats = await fetch_all(urls)
fin = [Link]()
print(f'{len(resultats)} URLs récupérées en {fin-debut:.1f}s')
# ~1s au lieu de 3s!

[Link](main())

13.2 — Tests avec pytest

Formation Python Complète • Page 53

# pip install pytest
# Fichier: test_calculs.py

import pytest

# Fonction à tester
def diviser(a, b):
if b == 0:
raise ValueError('Division par zéro')
return a / b

# Tests
def test_division_normale():
assert diviser(10, 2) == 5.0
assert diviser(9, 3) == 3.0

def test_division_par_zero():
with [Link](ValueError):
diviser(10, 0)

def test_division_negatives():
assert diviser(-10, 2) == -5.0
assert diviser(10, -2) == -5.0

@[Link]('a,b,expected', [
(10, 2, 5.0),
(9, 3, 3.0),
(1, 4, 0.25),
])
def test_parametres(a, b, expected):
assert diviser(a, b) == expected

# Lancer: pytest test_calculs.py -v

13.3 — Typer — CLI professionnels

Formation Python Complète • Page 54

# pip install typer rich
import typer
from rich import print
from typing import Optional

app = [Link](help='Mon outil CLI professionnel')

@[Link]()
def saluer(
nom: str = [Link](..., help='Ton prénom'),
fois: int = [Link](1, help='Combien de fois'),
upper: bool = [Link](False, help='En majuscules'),
):
'"""Salue quelqu un."""'
message = f'[bold green]Bonjour {nom}![/bold green]'
if upper:
message = [Link]()
for _ in range(fois):
print(message)

@[Link]()
def info():
'"""Affiche les infos système."""'
import platform, sys
print(f'[blue]Python:[/blue] {[Link]}')
print(f'[blue]OS:[/blue] {[Link]()} {[Link]()}')

if __name__ == '__main__':
app()

# Usage:
# python [Link] saluer Alice --fois 3
# python [Link] saluer ALICE --upper
# python [Link] --help

Formation Python Complète • Page 55

 ■
CHAPITRE 14
Projet Final

Application Complète de A à Z

Formation Python Complète • Page 56

 ■ Projet : API de Gestion de Tâches (To-Do)

Tu vas construire une API REST complète avec FastAPI + SQLAlchemy + tests automatisés. Ce projet regroupe
tout ce que tu as appris.

Architecture du projet :

todo_app/
■■■ [Link] # Point d'entrée FastAPI
■■■ [Link] # Modèles SQLAlchemy
■■■ [Link] # Schémas Pydantic
■■■ [Link] # Configuration DB
■■■ routers/
■ ■■■ [Link] # Routes des tâches
■ ■■■ [Link] # Routes des utilisateurs
■■■ tests/
■ ■■■ test_api.py # Tests automatisés
■■■ [Link]

[Link] :

from sqlalchemy import create_engine

from [Link] import sessionmaker, DeclarativeBase

DATABASE_URL = 'sqlite:///./[Link]'
engine = create_engine(DATABASE_URL, connect_args={'check_same_thread': False})
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

class Base(DeclarativeBase):
pass

def get_db():
db = SessionLocal()
try:
yield db
finally:
[Link]()

[Link] :

Formation Python Complète • Page 57

 from sqlalchemy import Column, Integer, String, Boolean, DateTime, ForeignKey
from [Link] import relationship
from datetime import datetime
from database import Base

class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True, index=True)
email = Column(String, unique=True, index=True)
nom = Column(String)
hashed_pwd = Column(String)
tasks = relationship('Task', back_populates='owner')

class Task(Base):
__tablename__ = 'tasks'
id = Column(Integer, primary_key=True, index=True)
titre = Column(String, index=True)
description = Column(String, nullable=True)
terminee = Column(Boolean, default=False)
priorite = Column(Integer, default=1) # 1=basse, 3=haute
created_at = Column(DateTime, default=[Link])
owner_id = Column(Integer, ForeignKey('[Link]'))
owner = relationship('User', back_populates='tasks')

[Link] :

Formation Python Complète • Page 58

from fastapi import FastAPI, Depends, HTTPException
from [Link] import Session
from database import engine, get_db, Base
from models import Task
from pydantic import BaseModel
from typing import Optional

[Link].create_all(bind=engine)

app = FastAPI(
title='To-Do API',
description='API de gestion de tâches',
version='1.0.0'
)

class TaskCreate(BaseModel):
titre: str
description: Optional[str] = None
priorite: int = 1

class TaskResponse(TaskCreate):
id: int
terminee: bool
class Config:
from_attributes = True

@[Link]('/tasks', response_model=list[TaskResponse])
def lister_taches(db: Session = Depends(get_db)):
return [Link](Task).all()

@[Link]('/tasks', response_model=TaskResponse, status_code=201)

def creer_tache(task: TaskCreate, db: Session = Depends(get_db)):
db_task = Task(**[Link]())
[Link](db_task)
[Link]()
[Link](db_task)
return db_task

@[Link]('/tasks/{task_id}/done', response_model=TaskResponse)
def marquer_terminee(task_id: int, db: Session = Depends(get_db)):
task = [Link](Task).filter([Link] == task_id).first()
if not task:
raise HTTPException(status_code=404, detail='Tâche non trouvée')
[Link] = True
[Link]()
return task

@[Link]('/tasks/{task_id}', status_code=204)
def supprimer_tache(task_id: int, db: Session = Depends(get_db)):
task = [Link](Task).filter([Link] == task_id).first()
if not task:
raise HTTPException(status_code=404, detail='Tâche non trouvée')
[Link](task)
[Link]()

Formation Python Complète • Page 59

■ EXPERT
Lance avec: uvicorn main:app --reload Documentation auto: [Link]
Tu verras toutes tes routes testables directement dans le navigateur!

Formation Python Complète • Page 60

 ■■ Ta Roadmap vers l'Excellence

Objectifs Ressources

Bases: variables, types, conditions, boucles Chapitres 1-3 + 2h/j de pratique

Fonctions, modules, POO, fichiers Chapitres 4-6 + mini-projets

Bibliothèques standard, data structures avancées Chapitres 7 + exercices

Développement web: Flask puis FastAPI Chapitre 8 + construire une API

Bases de données + Data Science intro Chapitres 9-10

Scripts, automatisation, scraping Chapitre 11 + projet perso

Cybersécurité éthique, crypto, outils Chapitre 12 + CTF débutant

Projet final, contribution open source Chapitre 14 + GitHub

■ Ressources recommandées

• • Documentation officielle : [Link] — Ta Bible

• • Pratique : LeetCode, HackerRank, Codewars pour les algorithmes
• • CTF & Sécurité : HackTheBox, TryHackMe, PicoCTF
• • Projets open source : Contribue sur GitHub pour te faire remarquer
• • Communauté : r/learnpython, Stack Overflow, Discord Python

■ Conseils du Formateur

■ EXPERT
Code CHAQUE JOUR, même 20 minutes. La régularité bat l'intensité. Un projet imparfait
terminé vaut mille projets parfaits abandonnés.

■ CONSEIL
Construis des projets RÉELS dès que possible. Crée un bot Discord, automatise une
tâche de ta vie quotidienne, scrape les prix d'un site. Apprends en faisant.

■■ INFO
Lis du code des autres. Explore les repos populaires sur GitHub. Voir comment les
experts structurent leur code t'apprendra plus qu'un livre.

Tu as maintenant toutes les clés. Le reste n'appartient qu'à toi.

Bonne chance, futur Expert Python. ■■

Formation Python Complète • Page 61