INTRODUCTION À PYTHON

Module Fondamentaux
Pour professionnels débutants en programmation

1 2 3 4 5 6

S1 S2 S3 S4 S5 S6
Env. Vars Cond. Boucles Fonct. Data

6 séances × 3 heures | 18 heures de formation | Exercices progressifs inclus

 SÉANCE 1/6

Environnement & Premiers Pas

Découvrir Python, installer l'environnement, écrire ses premières
lignes

⏱ Durée : 3 heures | Niveau : Débutant | Python 3.x

Pourquoi Python ?

Séance 1
Pourquoi Python ? Panorama du langage

• Langage créé en 1991 par Guido van Rossum — # Code Python

simple, lisible, puissant # Votre premier programme Python

• Syntaxe proche du langage naturel : facile à print("Bonjour, le monde !")
apprendre pour les débutants # Python est lisible
• Langage n°1 mondial selon TIOBE Index (2024) age = 30
if age >= 18:
• Utilisé en data science, IA, automatisation, web, print("Vous êtes majeur")
sciences, finance else:
• print("Vous êtes mineur")
Gratuit, open-source, vaste communauté et
bibliothèques
• Python = un couteau suisse numérique pour le
professionnel moderne
Installation & Environnement de travail

• Installer Python 3.x depuis [Link] (ou # Code Python

Anaconda pour la data) # Vérifier votre installation

• Choisir un éditeur : VS Code (recommandé), # Dans le terminal :
# python --version
PyCharm IDLE # → Python 3.11.x
• Extension VS Code : Python (Microsoft) →
autocomplétion, débogage # Lancer l'interpréteur interactif :
# python
• Terminal / invite de commandes : lancer python
ou python3 >>> 2 + 2
4
• Jupyter Notebook : interface interactive, idéale >>> print("Ça fonctionne !")
pour apprendre Ça fonctionne !
• Vérifier l'installation : python --version dans le
terminal
Structure d'un programme Python

• Pas d'accolades {} comme en Java/C : Python # Code Python

utilise l'INDENTATION # Exemple de structure Python

• L'indentation (4 espaces) définit les blocs de code # (notez l'indentation : 4 espaces)

• Commentaires avec # (ignorés par Python, pour nom = "Alice" # variable

les humains) age = 28 # entier
• Une instruction par ligne (en général) if age > 18:
• Sensible à la casse : age ≠ Age ≠ AGE print("Majeure") # bloc indenté
print("Bienvenue")
• Pas de point-virgule obligatoire en fin de ligne
# Fin du bloc : retour à gauche
print("Programme terminé")
✏️ EXERCICES PRATIQUES

Séance 1 — Prise en main de Python

★ Facile

1. Installez Python et VS Code. Créez un fichier [Link] et affichez votre nom avec print().

★ Facile

2. Utilisez l'interpréteur interactif pour calculer : 15 * 4, 100 / 7, 2 ** 10. Observez les résultats.

★★ Moyen

3. Écrivez un programme qui affiche 5 lignes avec des informations personnelles (nom, ville, métier, âge, passion).
✅ RÉCAP SÉANCE 1 — Ce que vous avez appris

✓ Python : historique et usages professionnels ✓ Indentation comme structure de code

✓ Installation Python + VS Code configuré ✓ Commentaires avec #

✓ print() pour afficher du texte ✓ Utilisation de l'interpréteur interactif

 SÉANCE 2/6

Variables, Types & Opérateurs

Stocker des données, comprendre les types, effectuer des calculs

⏱ Durée : 3 heures | Niveau : Débutant | Python 3.x

Les briques fondamentales

Séance 2
Les Variables

• Une variable = une boîte nommée qui stocke une # Code Python

valeur en mémoire # Déclaration de variables

• Déclaration directe : pas besoin de déclarer le prenom = "Marie"
age = 35
type (typage dynamique) salaire = 2500.50
• Convention de nommage : minuscules, mots est_actif = True
séparés par _ (snake_case)
# Réaffectation
• Le signe = est une AFFECTATION (pas une égalité age = 36 # la valeur change
mathématique) age = age + 1 # auto-incrémentation
print(age) # affiche 37
• On peut réaffecter une variable à tout moment
• Noms interdits : chiffres en début, mots réservés # Affectation multiple
(if, for, while…) x, y, z = 1, 2, 3
a = b = c = 0
Les Types de Données Fondamentaux

• int : entiers → 42, -10, 0, 1_000_000 # Code Python

• float : décimaux → 3.14, -0.5, 2.0 # Les types en action

entier = 42
• str : chaînes de caractères → "Bonjour", 'Python' decimal = 3.14
• bool : booléens → True / False (majuscule !) texte = "Formation Python"
booleen = True
• type() : fonction qui retourne le type d'une
variable print(type(entier)) # <class 'int'>
print(type(texte)) # <class 'str'>
• Conversion (cast) : int(), float(), str(), bool()
# Conversion de types
age_str = "25"
age_int = int(age_str) # "25" → 25
prix_str = str(19.99) # 19.99 → "19.99"
Opérateurs Arithmétiques & de Comparaison

• Arithmétiques : + - * / // % ** (division entière, # Code Python

modulo, puissance) # Arithmétique

• / toujours retourne un float | // retourne un int print(10 / 3) # 3.333...
print(10 // 3) # 3 (division entière)
• % : reste de la division (ex : 10 % 3 = 1) print(10 % 3) # 1 (reste)
• print(2 ** 8) # 256
** : puissance (ex : 2 ** 8 = 256)
• Comparaison : == != > < >= <= → retourne # Comparaisons
True/False x = 10
print(x > 5) # True
• ATTENTION : = est affectation, == est print(x == 10) # True
comparaison print(x != 7) # True

# Opérateurs logiques
print(x > 5 and x < 20) # True
print(x < 0 or x > 5) # True
print(not True) # False
Saisie utilisateur & Formatage de texte

• input() : lire une saisie clavier → retourne # Code Python

TOUJOURS une str # Saisie et f-strings

• Convertir la saisie si besoin : age = nom = input("Votre prénom : ")
age = int(input("Votre âge : "))
int(input("Votre âge : "))
• f-string (Python 3.6+) : le moyen moderne # f-string (recommandé)
d'insérer des variables print(f"Bonjour {nom}, vous avez {age}
ans !")
• Syntaxe f-string : f"Texte {variable} texte"
• # Calcul avec affichage formaté
format() : ancienne méthode compatible toutes
annee_naissance = 2024 - age
versions print(f"Vous êtes né(e) vers
• print() avec sep et end : contrôler séparateur et {annee_naissance}")
fin de ligne
# Formatage de nombres
prix = 1999.5
print(f"Prix : {prix:.2f} €")
# Affiche : Prix : 1999.50 €
✏️ EXERCICES PRATIQUES

Séance 2 — Variables, Types & Opérateurs

★ Facile

1. Créez des variables pour représenter une facture : produit (str), quantité (int), prix_unitaire (float). Calculez et affichez le
total avec une f-string.

★★ Moyen

2. Demandez à l'utilisateur son année de naissance, calculez son âge approximatif et affichez si l'utilisateur est né avant ou
après 2000.

★★★ Avancé

3. Calculez l'IMC d'une personne (poids / taille²). Saisir poids et taille, afficher l'IMC arrondi à 1 décimale. Bonus : afficher
la catégorie (normal si entre 18.5 et 25).
✅ RÉCAP SÉANCE 2 — Ce que vous avez appris

✓ Variables : déclaration, nommage, réaffectation ✓ Opérateurs arithmétiques et modulo

✓ Types : int, float, str, bool ✓ Opérateurs de comparaison

✓ Conversion de types (cast) ✓ input() et f-strings

 SÉANCE 3/6

Conditions & Logique

if / elif / else — Programmer des décisions

⏱ Durée : 3 heures | Niveau : Débutant | Python 3.x

 🔀
Prendre des décisions

Séance 3
La structure if / elif / else

• Le programme peut choisir quel bloc exécuter # Code Python

selon une condition # Structure complète

• if condition: → exécuté si la condition est True note = int(input("Note (0-20) : "))

• elif condition: → "sinon si" (autant de elif que if note >= 16:
nécessaire) print("Très bien !")
elif note >= 14:
• else: → bloc par défaut si aucune condition n'est print("Bien")
vraie elif note >= 10:
• print("Passable")
Les blocs sont délimités par l'INDENTATION (4
else:
espaces) print("Insuffisant")
• Une condition peut être n'importe quelle
expression booléenne # Conditions multiples
age = 25
if age >= 18 and age <= 65:
print("Âge actif")
Opérateurs Logiques : and, or, not

• and : les DEUX conditions doivent être vraies → A # Code Python

and B # Opérateurs logiques

• or : AU MOINS UNE condition doit être vraie → A temperature = 22
soleil = True
or B
• not : inverse la valeur booléenne → not True = if temperature > 20 and soleil:
False print("Bonne journée pour sortir !")

• Priorité : not > and > or (utiliser () pour clarifier) # Vérification d'appartenance
• jour = "lundi"
in : vérifie la présence dans une séquence → "a"
if jour in ["samedi", "dimanche"]:
in "chat" print("Week-end !")
• not in : vérifie l'absence → 5 not in [1,2,3] else:
print("Jour de semaine")

# not
connecte = False
if not connecte:
print("Veuillez vous connecter")
Conditions imbriquées & Ternaire

• On peut imbriquer des if dans d'autres if (nested # Code Python

conditions) # Imbrication
• Chaque niveau d'imbrication ajoute 4 espaces age = 20
permis = True
d'indentation
• Éviter plus de 3 niveaux d'imbrication (lisibilité) if age >= 18:
if permis:
• Expression ternaire : valeur_si_vrai if condition print("Vous pouvez conduire")
else valeur_si_faux else:
• print("Passez le permis d'abord")
Utile pour des affectations conditionnelles
else:
simples sur une ligne print("Trop jeune pour conduire")
• Préférer if/else classique pour la lisibilité si la
logique est complexe # Expression ternaire
statut = "majeur" if age >= 18 else "mineur"
print(f"Statut : {statut}")

# Équivalent if/else
prix = 100
remise = 20 if prix > 50 else 0
✏️ EXERCICES PRATIQUES

Séance 3 — Conditions & Logique

★ Facile

1. Calculateur de remise : demandez un montant d'achat. Appliquez 5% si > 100€, 10% si > 200€, 15% si > 500€. Affichez le
montant final.

★★ Moyen

2. FizzBuzz : demandez un nombre. Affichez "Fizz" s'il est divisible par 3, "Buzz" par 5, "FizzBuzz" par les deux, sinon le
nombre lui-même.

★★★ Avancé

3. Simulateur de connexion : demandez un login et un mot de passe. Définissez des valeurs correctes dans le code. Affichez
"Accès autorisé" ou "Accès refusé" avec le nombre de tentatives restantes (max 3).
✅ RÉCAP SÉANCE 3 — Ce que vous avez appris

✓ Structure if / elif / else ✓ Conditions imbriquées

✓ Opérateurs logiques : and, or, not ✓ Expression ternaire

✓ Opérateurs d'appartenance : in / not in ✓ Bonne pratique : éviter l'imbrication excessive

 SÉANCE 4/6

Boucles : for & while

Répéter, itérer, automatiser des tâches

⏱ Durée : 3 heures | Niveau : Débutant | Python 3.x

 🔄
Répéter & Automatiser

Séance 4
La boucle for

• for : itère sur une séquence (liste, range, chaîne, # Code Python

etc.) # Boucle for basique

• range(n) : génère les entiers de 0 à n-1 for i in range(5):
print(i) # 0, 1, 2, 3, 4
• range(début, fin) : de début à fin-1
• # Range avec début et fin
range(début, fin, pas) : avec un pas personnalisé for i in range(1, 11):
• for ch in texte : parcourir caractère par caractère print(i) # 1 à 10
• La variable d'itération prend chaque valeur à # Parcourir une chaîne
chaque tour for lettre in "Python":
print(lettre) # P, y, t, h, o, n

# Tables de multiplication
for i in range(1, 11):
print(f"7 × {i} = {7 * i}")
La boucle while

• while condition: → répète tant que la condition # Code Python

est True # Boucle while basique

• La condition est vérifiée AVANT chaque itération compteur = 0
while compteur < 5:
• DANGER : boucle infinie si la condition ne devient print(f"Tour n°{compteur}")
jamais False compteur += 1 # incrémenter !
• Toujours prévoir une sortie (modifier la variable # Attente de saisie valide
de condition) reponse = ""
• while reponse != "oui" and reponse != "non":
Utile quand on ne sait pas à l'avance combien de
reponse = input("Oui ou non ? ")
tours faire print(f"Vous avez dit : {reponse}")
• Souvent utilisée pour attendre une saisie valide
de l'utilisateur # Accumulation
total = 0
n = int(input("Nombre de valeurs : "))
for _ in range(n):
val = float(input("Valeur : "))
total += val
print(f"Somme : {total}")
break, continue & else dans les boucles

• break : interrompt immédiatement la boucle en # Code Python

cours # break et continue

• continue : saute l'itération actuelle, passe à la for i in range(10):
if i == 5:
suivante break # stoppe à 5
• else après for/while : exécuté si la boucle se if i % 2 == 0:
termine SANS break continue # saute les pairs
print(i) # affiche 1, 3
• Boucles imbriquées : une boucle dans une autre
(break n'affecte que la plus interne) # Recherche avec break/else
cible = 7
• enumerate() : obtenir l'index ET la valeur lors for i in range(10):
d'un for if i == cible:
• Bonne pratique : éviter les boucles imbriquées print(f"Trouvé : {i}")
break
profondes else:
print("Non trouvé")

# enumerate
fruits = ["pomme", "banane", "cerise"]
for idx, fruit in enumerate(fruits):
print(f"{idx}: {fruit}")
✏️ EXERCICES PRATIQUES

Séance 4 — Boucles for & while

★ Facile

1. Affichez la table de multiplication de 1 à 10 pour un chiffre saisi par l'utilisateur. Utilisez une boucle for.

★★ Moyen

2. Jeu de devinette : le programme choisit un nombre entre 1 et 100. L'utilisateur a 7 tentatives. Indiquez "trop grand" /
"trop petit" à chaque essai. Utilisez un while.

★★★ Avancé

3. Calculez la somme, la moyenne, le min et le max d'une liste de notes saisies par l'utilisateur. Arrêtez la saisie quand
l'utilisateur entre -1.
✅ RÉCAP SÉANCE 4 — Ce que vous avez appris

✓ Boucle for avec range() ✓ Clause else sur les boucles

✓ Boucle while et condition d'arrêt ✓ enumerate() pour index + valeur

✓ break et continue ✓ Accumulation de valeurs dans une boucle

 SÉANCE 5/6

🐍
Fonctions

Organiser le code, éviter les répétitions, créer des outils réutilisables

⏱ Durée : 3 heures | Niveau : Débutant | Python 3.x

 📦
Organiser & Réutiliser

Séance 5
Définir et appeler une fonction

• def nom_fonction(paramètres): — le mot-clé def # Code Python

définit une fonction # Définir une fonction

• Le corps de la fonction est indenté (4 espaces) def dire_bonjour():
print("Bonjour tout le monde !")
• Appel de la fonction : nom_fonction(arguments)
• # Appel
Une fonction peut ne prendre aucun paramètre dire_bonjour() # Bonjour tout le monde !
• Convention : noms en snake_case, verbe d'action dire_bonjour() # Réutilisable !
(calculer_tva, afficher_menu)
# Avec paramètre
• DRY principle : Don't Repeat Yourself — factoriser def saluer(prenom):
ce qui se répète print(f"Bonjour, {prenom} !")

saluer("Alice") # Bonjour, Alice !

saluer("Bob") # Bonjour, Bob !
Paramètres, Arguments & Valeur de retour

• Paramètres : noms dans la définition | Arguments # Code Python

: valeurs à l'appel # Paramètres avec défaut

• Valeur par défaut : def f(x, y=10) — y est def calculer_tva(prix, taux=0.20):
return prix * taux
optionnel
• Arguments nommés : f(y=5, x=3) — ordre libre print(calculer_tva(100)) # 20.0
print(calculer_tva(100, 0.10)) # 10.0
• return : renvoie une valeur et QUITTE la fonction
• Sans return explicite → la fonction retourne None # Retour multiple
def diviser(a, b):
• On peut retourner plusieurs valeurs : return a, b quotient = a // b
(tuple) reste = a % b
return quotient, reste

q, r = diviser(17, 5)
print(f"17 ÷ 5 = {q} reste {r}")
# 17 ÷ 5 = 3 reste 2
Portée des variables (Scope)

• Variable locale : définie dans une fonction, # Code Python

inexistante à l'extérieur # Scope en action

• Variable globale : définie en dehors, accessible compteur = 0 # variable globale
partout en lecture def incrementer(n):
• global : mot-clé pour MODIFIER une variable resultat = n + 1 # locale
globale depuis une fonction (à éviter) return resultat # bonne pratique

• Bonne pratique : passer les données via # Mauvaise pratique (à éviter)

paramètres/retour, pas via global def incrementer_global():
global compteur
• LEGB rule : Local → Enclosing → Global → Built-in compteur += 1
(ordre de recherche)
• Fonctions pures : ne modifient pas l'état extérieur # Bonne pratique
def compter(val):
(meilleures pratiques) return val + 1

compteur = compter(compteur)
print(compteur) # 1
✏️ EXERCICES PRATIQUES

Séance 5 — Fonctions
★ Facile

1. Créez 3 fonctions : calculer_perimetre_rectangle(l, h), calculer_aire_rectangle(l, h), calculer_diagonale(l, h). Testez avec
l=5 et h=3.

★★ Moyen

2. Créez une fonction convertir_temperature(valeur, unite) qui convertit Celsius↔Fahrenheit et Celsius↔Kelvin selon
l'unité donnée ('C', 'F', 'K').

★★★ Avancé

3. Créez une fonction est_premier(n) qui retourne True si n est un nombre premier, False sinon. Utilisez-la pour afficher
tous les nombres premiers jusqu'à 100.
✅ RÉCAP SÉANCE 5 — Ce que vous avez appris

✓ Définir une fonction avec def ✓ return : retourner une valeur

✓ Paramètres et arguments ✓ Portée des variables (scope)

✓ Valeurs par défaut ✓ Principe DRY : factoriser le code

 SÉANCE 6/6

🐍
Listes, Dictionnaires & Mini-
Projet
Organiser les données — Synthèse du module

⏱ Durée : 3 heures | Niveau : Débutant | Python 3.x

 📚
Structures de Données

Séance 6
Les Listes

• Liste = collection ordonnée, modifiable, # Code Python

d'éléments de types variés # Création et manipulation

• Déclaration : ma_liste = [1, "texte", True, 3.14] fruits = ["pomme", "banane", "cerise"]

• Indexation : ma_liste[0] (premier) | ma_liste[-1] # Accès

(dernier) print(fruits[0]) # pomme
print(fruits[-1]) # cerise
• Slicing : ma_liste[1:4] extrait du 2e au 4e élément
• Méthodes : .append(), .insert(), .remove(), .pop(), # Modification
[Link]("datte")
.sort(), .len()
[Link](1, "abricot")
• Parcourir : for elem in liste | for i, elem in [Link]("banane")
enumerate(liste)
# Slicing
print(fruits[1:3]) # ['abricot', 'cerise']

# Infos
print(len(fruits)) # nombre d'éléments
print("pomme" in fruits) # True
Les Dictionnaires

• Dictionnaire = collection de paires clé:valeur # Code Python

(mapping) # Dictionnaire : fiche contact

• Déclaration : mon_dict = {"clé": valeur, "nom": contact = {
"nom": "Alice Dupont",
"Alice"} "age": 32,
• Accès : mon_dict["nom"] ou "email": "alice@[Link]",
mon_dict.get("nom", "défaut") "actif": True
}
• Ajout/Modification : mon_dict["age"] = 30
• # Accès sécurisé
Suppression : del mon_dict["age"] ou
print(contact["nom"])
mon_dict.pop("age") print([Link]("tel", "Non renseigné"))
• Parcourir : .keys(), .values(), .items() pour clés et
valeurs # Modification
contact["age"] = 33

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

# Liste de dicts (base de données légère)

employes = [{"nom": "Bob", "dept": "IT"},
{"nom": "Eve", "dept": "RH"}]
Listes & Dicts : Méthodes essentielles

• sorted(liste) : retourne une nouvelle liste triée # Code Python

• [Link]() : trie en place (modifie la liste # Méthodes pratiques

originale) notes = [15, 12, 18, 9, 16, 11]

• sum(), min(), max() : calculs rapides sur une liste print(sum(notes)) # 81

de nombres print(max(notes)) # 18
print(min(notes)) # 9
• list comprehension : [expr for x in liste if cond] — print(sum(notes)/len(notes)) # 13.5
syntaxe concise
• # List comprehension
[Link]() : fusionner deux dictionnaires
admis = [n for n in notes if n >= 10]
• Imbrication : liste de dicts, dict de listes → print(admis) # [15, 12, 18, 16, 11]
structures complexes
doubles = [n * 2 for n in notes]

# Tri
classement = sorted(notes, reverse=True)
print(classement) # [18, 16, 15, 12, 11, 9]
🚀 MINI-PROJET FINAL — Gestionnaire de Contacts

Créez un gestionnaire de contacts en ligne de commande qui combine toutes les notions du module.

1. Ajouter un contact
Saisir nom, prénom, téléphone, email → stocker dans un dict, ajouter à une liste

2. Afficher tous les contacts

Parcourir la liste, afficher chaque contact formaté avec f-strings

3. Rechercher un contact
Demander un nom, parcourir la liste, afficher si trouvé sinon message

4. Supprimer un contact
Trouver par nom et supprimer de la liste

5. Statistiques
Nombre total de contacts, afficher la liste triée par nom
✏️ EXERCICES PRATIQUES

Séance 6 — Structures de données

★ Facile

1. Créez une liste de 5 villes. Triez-la, affichez la 1ère et la dernière, ajoutez une ville, supprimez-en une.

★★ Moyen

2. Créez un dictionnaire représentant votre profil (nom, age, poste, compétences:liste). Affichez chaque champ et ajoutez
une nouvelle compétence.

★★★ Avancé

3. Mini-projet : implémentez le gestionnaire de contacts complet avec menu interactif, les 5 fonctionnalités, des fonctions
séparées pour chaque opération.
✅ RÉCAP SÉANCE 6 — Ce que vous avez appris

✓ Listes : création, indexation, méthodes ✓ sorted(), sum(), min(), max()

✓ Dictionnaires : clé-valeur, accès, parcours ✓ Structures imbriquées

✓ List comprehension ✓ Mini-projet : gestionnaire de contacts

🎓 BILAN DU MODULE — Introduction à Python

Environnement Boucles
S1 S4
print, indentation, commentaires for, while, break, continue

Variables & Types Fonctions

S2 S5
int, float, str, bool, opérateurs def, return, scope, DRY

Conditions Données
S3 S6
if / elif / else, and / or / not listes, dicts, mini-projet

✅ 18 heures • 6 projets • 18 exercices • Python 3.x — Félicitations à tous !