🐍

Python — La
Référence Complète
Cours intensif — Semestre | 3ème Année Licence TI

ISET Jendouba | Département Informatique | 3ème Année Licence TI

 Plan du Cours

1 Introduction & Environnement 6 Encapsulation & Héritage

2 Types de Données 7 Méthodes Dunder

3 Contrôle de Flux 8 Exceptions & Fichiers

4 Fonctions et Modularité 9 Bibliothèques Standards

5 Classes et Objets 10 NumPy & Pandas (Data Science)

PARTIE I
Fondamentaux et
Structure
Algorithmique
Chapitres 1 à 4 · Installation · Types · Flux · Fonctions
Chapitre 1 — Pourquoi Python ?

• Créé en 1991 par Guido van Rossum (hommage aux Monty Python)
• Interprété, haut niveau, typage dynamique fort
• Multi-paradigme : impératif, objet, fonctionnel
• Domaines d'application :
• → Data Science & IA (NumPy, Pandas, TensorFlow, PyTorch)
• → Web (Django, Flask, FastAPI)
• → Automatisation & Scripting
• → Cybersécurité & Hacking éthique
• Classé régulièrement #1 par TIOBE et Stackoverflow Survey
• PyPI : +500 000 packages disponibles via pip
Chapitre 1 — Environnement Python

IDEs Recommandés PEP 8 — Conventions de Style

• VS Code (gratuit, extensions Python/Pylance) • Indentation : 4 espaces (jamais tabulations)
• PyCharm (JetBrains, version Community gratuite) • snake_case pour variables et fonctions
• Jupyter Notebook (Data Science, visualisation) • PascalCase pour les classes
• Thonny (idéal débutants) • MAJUSCULES pour les constantes
• IDLE (fourni avec Python — basique) • Longueur de ligne max : 79 caractères
• Docstrings obligatoires ("""...""")
• 2 lignes vides entre fonctions/classes
Chapitre 1 — Premier Programme & REPL

# Exécuter en mode interactif

$ python3
>>> print('Bonjour ISET Jendouba!')
Bonjour ISET Jendouba!
>>> 2 ** 10
1024

# Fichier [Link]
def main():
prenom = input('Votre prénom: ')
print(f'Bonjour {prenom} !')

if __name__ == '__main__':
main()

💡 Le bloc if __name__ == '__main__' permet d'exécuter le code seulement quand le fichier est lancé directement (pas
importé).
Chapitre 2 — Types Scalaires

• int (entier) — précision arbitraire : 2**100, 0xFF, 0b1010

• float (réel) — IEEE 754 : 3.14, 1.5e6, 3.2e-4
• bool (booléen) — sous-classe de int : True=1, False=0
• str (chaîne) — immuable, Unicode : 'texte', "texte", '''multi\nligne'''
• NoneType — absence de valeur : None (utiliser 'is None', jamais '== None')
• Conversions : int('42'), float('3.14'), str(42), bool(0)
• F-strings Python 3.6+ : f"Bonjour {nom}, score: {score:.2f}"
Chapitre 2 — Listes, Tuples et Sets

# Liste (mutable, ordonnée)

notes = [15, 18, 12, 17]
[Link](14) # [15, 18, 12, 17, 14]
[Link](reverse=True) # [18, 17, 15, 14, 12]
print(notes[0], notes[-1]) # 18 12

# Tuple (immuable) — unpacking

point = (3, 4)
x, y = point # x=3, y=4
a, *reste = (1, 2, 3, 4) # a=1, reste=[2,3,4]

# Set — éléments uniques

a = {1, 2, 3, 4}; b = {3, 4, 5, 6}
print(a & b) # {3, 4} intersection
print(a | b) # {1,2,3,4,5,6} union

💡 list=mutable ordonnée | tuple=immuable rapide | set=unique, opérations ensemblistes

Chapitre 2 — Dictionnaires

etudiant = {
'nom': 'Ben Ali', 'prenom': 'Mohamed',
'moyenne': 14.5, 'filiere': 'TI'
}

# Accès sécurisé
print([Link]('age', 20)) # 20 (valeur par défaut)

# Itération
for cle, val in [Link]():
print(f'{cle:10}: {val}')

# Compréhension de dictionnaire
notes = {'Ali': 15, 'Sana': 18, 'Omar': 11}
mentions = {n: 'Admis' if v>=10 else 'Ajourné'
for n, v in [Link]()}

💡 Les dictionnaires sont la structure la plus utilisée en Python pour les données structurées.
Chapitre 3 — Conditions

note = 14
if note >= 16: mention = 'Très Bien'
elif note >= 14: mention = 'Bien'
elif note >= 12: mention = 'Assez Bien'
elif note >= 10: mention = 'Passable'
else: mention = 'Ajourné'

# Expression ternaire
statut = 'Admis' if note >= 10 else 'Ajourné'

# Chaînage de comparaisons (pythonique)

x = 15
if 10 <= x <= 20: # équivaut à x>=10 and x<=20
print('x dans [10,20]')

# Opérateurs : and, or, not, in, is

if 'Ali' in ['Ali','Sana'] and note > 10:
print('Ali est admis')
Chapitre 3 — Boucles for et while

# for + range()
for i in range(1, 6): # 1,2,3,4,5
print(i, end=' ')

# enumerate — index + valeur

for i, val in enumerate(['a','b','c'], 1):
print(f'{i}: {val}')

# zip — itération parallèle

for nom, note in zip(['Ali','Sana'], [15, 18]):
print(f'{nom}: {note}')

# while avec break/continue

n = 10
while n > 0:
if n % 3 == 0: n -= 1; continue
print(n, end=' ')
n -= 1
Chapitre 3 — Compréhension de Listes

# [expression for elem in iterable if condition]

# Carrés de 0 à 9
carres = [x**2 for x in range(10)]
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Filtrage — seulement pairs

pairs = [x for x in range(20) if x % 2 == 0]

# Transformation
noms = ['alice','bob','charlie']
majuscules = [[Link]() for n in noms]

# Dict comprehension
notes = {'Ali':15,'Sana':18,'Omar':11}
admis = {n:v for n,v in [Link]() if v>=10}

# Set comprehension
consonnes = {c for c in 'Python' if c not in 'aeiouAEIOU'}

💡 Les compréhensions sont plus rapides et plus Pythoniques que les boucles traditionnelles.
Chapitre 4 — Fonctions

def calculer_moyenne(*notes, arrondi=2):

"""Calcule la moyenne des notes.
Args: *notes: notes numériques, arrondi: décimales
Returns: float
"""
if not notes: return 0
return round(sum(notes)/len(notes), arrondi)

# Appels variés
print(calculer_moyenne(15, 18, 12)) # 15.0
print(calculer_moyenne(15, 18, arrondi=1)) # 16.5

# Lambda + map + filter

notes = [15, 8, 18, 7, 12]
sur_100 = list(map(lambda n: n*5, notes))
admis = list(filter(lambda n: n>=10, notes))
tries = sorted(notes, key=lambda n: -n)

💡 Toujours écrire une docstring pour documenter vos fonctions (format Google ou NumPy).
Chapitre 4 — Décorateurs

import functools, time

def chronometre(f):
@[Link](f) # préserve les métadonnées
def wrapper(*args, **kwargs):
t0 = time.perf_counter()
result = f(*args, **kwargs)
t1 = time.perf_counter()
print(f'[{f.__name__}] {t1-t0:.4f}s')
return result
return wrapper

@chronometre
def fibonacci(n):
a, b = 0, 1
for _ in range(n): a, b = b, a+b
return a

fibonacci(1_000_000) # [fibonacci] 0.1523s

💡 Les décorateurs sont partout : @login_required (Django), @[Link] (Flask), @property...

PARTIE II

Programmation
Orientée Objet
Chapitres 5 à 7 · Classes · Héritage · Dunder Methods
Chapitre 5 — Concepts POO

• Paradigme orienté objet : organiser le code autour d'entités (objets)

• Classe : plan / gabarit / moule → Etudiant, Voiture, CompteBancaire
• Objet (instance) : réalisation concrète → etudiant1, ma_voiture
• Attribut d'instance : donnée propre à chaque objet ([Link])
• Attribut de classe : partagé par toutes les instances (compteur)
• Méthode : fonction appartenant à la classe (def se_presenter(self))
• 4 piliers : Encapsulation · Héritage · Polymorphisme · Abstraction
Chapitre 5 — Définir une Classe

class Etudiant:
etablissement = 'ISET Jendouba' # attribut de classe
compteur = 0

def __init__(self, nom, prenom, cin):

[Link] = nom # attributs d'instance
[Link] = prenom
[Link] = cin
[Link] = []
[Link] += 1

def ajouter_note(self, note):

if 0 <= note <= 20: [Link](note)
else: raise ValueError(f'Note invalide: {note}')

def moyenne(self):
return sum([Link])/len([Link]) if [Link] else 0

e = Etudiant('Ben Ali','Mohamed','12345')
e.ajouter_note(15); e.ajouter_note(18)
💡 self est la référence à l'objet
print(f'Moyenne: courant. Tous les paramètres
{[Link]():.2f}') self doivent
# Moyenne: être explicitement déclarés.
16.50
Chapitre 6 — Encapsulation & @property

class CompteBancaire:
def __init__(self, titulaire, solde=0):
[Link] = titulaire
self.__solde = solde # attribut privé (name mangling)

@property
def solde(self): # getter
return self.__solde

@[Link]
def solde(self, v): # setter avec validation
if v < 0: raise ValueError('Solde négatif interdit')
self.__solde = v

def deposer(self, m):

self.__solde += m
print(f'Dépôt +{m} DT → Solde: {self.__solde} DT')

c = CompteBancaire('Ali', 1000)
[Link](500) # Dépôt +500 DT → Solde: 1500 DT
💡 public, _protégé (convention),
print([Link]) # 1500__privé
(via(name mangling → _Classe__attribut)
getter)
Chapitre 6 — Héritage & Polymorphisme

class Forme:
def aire(self): raise NotImplementedError
def perimetre(self): raise NotImplementedError

class Rectangle(Forme):
def __init__(self, l, h):
self.l, self.h = l, h
def aire(self): return self.l * self.h
def perimetre(self): return 2*(self.l+self.h)

class Cercle(Forme):
import math
def __init__(self, r): self.r = r
def aire(self): return [Link] * self.r**2
def perimetre(self): return 2*[Link]*self.r

# Polymorphisme — même interface, comportements différents

formes = [Rectangle(5,3), Cercle(4), Rectangle(2,7)]
for f in formes:
print(f'{type(f).__name__}: aire={[Link]():.2f}')
💡 isinstance(obj, Classe) et issubclass(Enfant, Parent) pour vérifier les types.
Chapitre 7 — Méthodes Dunder (Magic Methods)

class Fraction:
def __init__(self, n, d):
from math import gcd
g = gcd(abs(n), abs(d))
self.n, self.d = n//g, d//g

def __str__(self): return f'{self.n}/{self.d}'

def __repr__(self): return f'Fraction({self.n},{self.d})'

def __add__(self, o):

return Fraction(self.n*o.d + o.n*self.d, self.d*o.d)

def __mul__(self, o):

return Fraction(self.n*o.n, self.d*o.d)

def __eq__(self, o): return self.n==o.n and self.d==o.d

def __lt__(self, o): return self.n*o.d < o.n*self.d

a = Fraction(1,2); b = Fraction(1,3)
print(a + b) # 5/6
💡 Les méthodes
print(a * b)dunder# permettent
1/6 l'intégration naturelle avec la syntaxe Python.
PARTIE III

Gestion des Données et

Systèmes
Chapitres 8 à 10 · Exceptions · Fichiers · NumPy · Pandas
Chapitre 8 — Gestion des Exceptions

def diviser(a, b):

try:
return a / b
except ZeroDivisionError:
print('Erreur: division par zéro')
return None
except TypeError as e:
print(f'Type invalide: {e}')
return None
finally:
print('Tentative de division effectuée')

# Exception personnalisée
class NoteInvalideError(ValueError):
def __init__(self, note):
super().__init__(f'Note {note} hors de [0,20]')
[Link] = note

def valider(note):
if not 0 <= note <= 20: raise NoteInvalideError(note)
💡 Le bloc finally est
return toujours exécuté — idéal pour libérer des ressources.
note
Chapitre 8 — Fichiers JSON & CSV

import json, csv

# JSON — écriture
data = [{'nom':'Ali','note':15},{'nom':'Sana','note':18}]
with open('[Link]','w',encoding='utf-8') as f:
[Link](data, f, ensure_ascii=False, indent=2)

# JSON — lecture
with open('[Link]','r',encoding='utf-8') as f:
loaded = [Link](f)

# CSV — écriture avec DictWriter

with open('[Link]','w',newline='',encoding='utf-8') as f:
w = [Link](f, fieldnames=['nom','note'])
[Link]()
[Link](data)

# CSV — lecture
with open('[Link]','r',encoding='utf-8') as f:
rows = list([Link](f))
💡 Toujours utiliser 'with open()' — fermeture automatique même en cas d'erreur.
Chapitre 9 — Modules os, datetime, math

import os, math

from datetime import datetime, date, timedelta

# os
print([Link]())
[Link]('data/2025', exist_ok=True)
fichiers = [Link]('.')

# datetime
now = [Link]()
print([Link]('%d/%m/%Y %H:%M')) # 15/01/2025 14:30
naissance = date(2003, 5, 20)
age = ([Link]() - naissance).days // 365
echeance = [Link]() + timedelta(days=30)

# math
print([Link](144)) # 12.0
print([Link](10)) # 3628800
print([Link](48, 18)) # 6
print(math.log2(1024)) # 10.0
Chapitre 10 — NumPy Essentiels

import numpy as np

# Création
notes = [Link]([15, 18, 12, 17, 9, 14])
zeros = [Link]((3, 4))
oeil = [Link](3) # matrice identité
seq = [Link](0,10,2) # [0 2 4 6 8]

# Opérations vectorisées (sans boucle !)

print(notes * 5) # [75 90 60 85 45 70]
print([Link]()) # 14.17
print([Link]()) # 2.99
print(notes[notes >= 12]) # [15 18 12 17 14] — masque booléen

# Algèbre linéaire
A = [Link]([[1,2],[3,4]])
B = [Link]([[5,6],[7,8]])
print(A @ B) # produit matriciel
print([Link](A)) # -2.0 (déterminant)

💡 NumPy est 10 à 100x plus rapide que les listes Python pour les calculs numériques.
Chapitre 10 — Pandas DataFrame

import pandas as pd

df = [Link]({
'Nom': ['Ali','Sana','Omar','Ines'],
'Filiere':['TI','SI','TI','RS'],
'Moyenne':[14.5, 17.8, 11.2, 15.0]
})

# Exploration
[Link](); [Link]()

# Sélection & Filtrage

admis = df[df['Moyenne'] >= 10]
ti = df[df['Filiere'] == 'TI']

# Nouvelles colonnes
df['Mention'] = df['Moyenne'].apply(
lambda m: 'TB' if m>=16 else 'B' if m>=14 else 'P')

# Groupement
💡 Pandas = Excel pour Python ! Lecture CSV, XLSX, SQL, JSON, API REST...
print([Link]('Filiere')['Moyenne'].agg(['mean','max']))
df.to_csv('[Link]', index=False)
PARTIE IV

Travaux Pratiques

4 TP progressifs · Algos · POO · Data Science · API Web

Vue d'ensemble des Travaux Pratiques

TP 1 Algorithmes Fondamentaux TP 2 Gestion de Bibliothèque (POO)

Tri à bulles, insertion, recherche. Héritage, encapsulation, @property.

Annuaire, compréhensions. Sauvegarde JSON, exceptions.

2h 3h

TP 3 Analyse de Données (Pandas) TP 4 API Web Flask

200 étudiants réels. REST CRUD livres & membres.

Statistiques, groupby, matplotlib. JSONify, errorhandler, cURL.

3h 4h
TP 2 — Bibliothèque (Architecture POO)

from datetime import date, timedelta

class Livre:
def __init__(self, isbn, titre, auteur, annee):
[Link] = isbn; [Link] = titre
[Link] = auteur; [Link] = True
def __str__(self):
s = '✓' if [Link] else '✗'
return f'[{s}] {[Link]} — {[Link]}'

class Emprunt:
DUREE = 14 # jours
def __init__(self, livre, membre):
[Link] = livre; [Link] = membre
[Link] = [Link]()
[Link] = [Link] + timedelta(days=[Link])
def en_retard(self):
return [Link]() > [Link]

# À implémenter : LivreNumerique, LivrePhysique, Membre, Bibliotheque

💡 Utiliser @property pour valider les attributs, json pour la persistance.
TP 4 — API Flask (Extrait)

from flask import Flask, jsonify, request, abort

app = Flask(__name__)

@[Link]('/api/livres', methods=['GET'])
def get_livres():
dispo = [Link]('disponible')
if dispo: return jsonify([l for l in LIVRES if l['dispo']])
return jsonify(LIVRES)

@[Link]('/api/livres', methods=['POST'])
def create_livre():
data = request.get_json()
if not all(k in data for k in ['isbn','titre','auteur']):
abort(400, 'Champs manquants')
[Link]({**data, 'disponible': True})
return jsonify(data), 201

@[Link](404)
def not_found(e): return jsonify(error=str(e)), 404

💡 Tester avec cURL,==

if __name__ Postman ou l'extension
'__main__': VS Code REST Client.
[Link](debug=True)
 🐍
Récapitulatif du Cours
Partie I Partie II Partie III Partie IV

Fondamentaux POO Data & Systèmes TP Pratiques

Types · Flux · Fonctions Classes · Héritage · Dunder NumPy · Pandas · Fichiers Algos · POO · API Web

Bon courage ! Python is awesome. 🚀