COURS DE PYTHON

Programmation Orientée Objet & Expressions Régulières

Ce cours a été conçu pour te permettre de comprendre la programmation en Python de façon

simple et amusante. Même si tu as 12 ans, tu vas pouvoir suivre chaque explication !

Chaque notion est expliquée avec des exemples du quotidien, puis traduite en code
■ Python pas à pas. N'aie pas peur — c'est plus simple qu'il n'y paraît !

Cours Python — POO & Regex Page 1

 TABLE DES MATIÈRES

PARTIE 1 — PROGRAMMATION ORIENTÉE OBJET (POO)

Chapitre 1 — Introduction à la POO — Pourquoi des objets ?

Chapitre 2 — Classe et Objet — Le moule et le gâteau
Chapitre 3 — Attributs et Méthodes — Les caractéristiques et les actions
Chapitre 4 — Le Constructeur __init__ — La naissance de l'objet
Chapitre 5 — Types de Méthodes — Instance, Classe et Statique
Chapitre 6 — Adressage Indirect — Les alias
Chapitre 7 — Encapsulation — Protéger ses données
Chapitre 8 — Getters, Setters et @property
Chapitre 9 — L'Héritage — La famille des classes
Chapitre 10 — Surcharge et Redéfinition des Méthodes
Chapitre 11 — L'Abstraction — Les contrats de classe
Chapitre 12 — Méthodes Spéciales — __str__, __repr__, __del__
Chapitre 13 — Surcharge d'Opérateurs — +, -, *, <, ==...
Chapitre 14 — Les Listes en Python

PARTIE 2 — EXPRESSIONS RÉGULIÈRES (REGEX)

Chapitre 15 — Introduction aux Regex

Chapitre 16 — Les Caractères Spéciaux
Chapitre 17 — Les Classes de Caractères
Chapitre 18 — Les Quantificateurs
Chapitre 19 — Les Ancres ^ et $
Chapitre 20 — Le Module re — Fonctions Essentielles
Chapitre 21 — Options de Compilation
Chapitre 22 — Groupes et Motifs Nominatifs

Cours Python — POO & Regex Page 2

Cours Python — POO & Regex Page 3
 Introduction à la POO
Chapitre 1 - Pourquoi parler d'objets en programmation ?

Qu'est-ce que la POO ?

La Programmation Orientée Objet (POO) est une façon d'organiser son code en regroupant les
données et les actions qui les concernent dans des objets. C'est comme si ton programme était
composé de personnages, chacun avec ses propres caractéristiques et ses propres capacités.

Imagine une voiture : elle a une couleur, une marque, une vitesse. Elle peut aussi
■ accélérer, freiner, klaxonner. En POO, tout ça représente un objet !

Les 4 piliers de la POO

Pilier Explication simple

Cacher les données sensibles à l'intérieur de l'objet. Comme un

■■ Encapsulation
coffre-fort.

Une classe peut récupérer les caractéristiques d'une autre. Comme les
■■■■■ Héritage
enfants héritent des parents.

Un même nom de méthode peut faire des choses différentes selon

■ Polymorphisme
l'objet. Comme le verbe 'parler' : un chien aboie, un chat miaule.

On définit un modèle général sans rentrer dans les détails. Comme un

■ Abstraction
plan de maison.

Cours Python — POO & Regex Page 4

Cours Python — POO & Regex Page 5
 Classe et Objet
Chapitre 2 - Le moule et le gâteau

La Classe : le plan de construction

Une classe est comme un moule à gâteau ou un plan d'architecte. Elle décrit ce que sera l'objet
: quelles sont ses caractéristiques (attributs) et ce qu'il peut faire (méthodes). La classe elle-même
n'est pas l'objet — c'est juste le plan.

On crée une classe une seule fois. Mais on peut créer autant d'objets qu'on veut à partir
■ de cette classe !

L'Objet : l'instance créée

Un objet (ou instance) est la réalisation concrète d'une classe. Si la classe est le moule, l'objet est
le gâteau ! Chaque objet a ses propres valeurs pour les attributs, mais partage la même structure.

# Définir une classe (le moule)

class Voiture:
def __init__(self, marque):
[Link] = marque

# Créer des objets (les gâteaux)

v1 = Voiture('Dacia') # Objet 1
v2 = Voiture('Peugeot') # Objet 2

print([Link]) # Dacia
print([Link]) # Peugeot
print(type(v1)) # <class '__main__.Voiture'>

Les deux voitures sont créées à partir du même moule (classe Voiture) mais chacune a
■ sa propre marque. C'est ça, la puissance des objets !

Cours Python — POO & Regex Page 6

Cours Python — POO & Regex Page 7
 Attributs et Méthodes
Chapitre 3 - Les caractéristiques et les actions

Les Attributs
Les attributs sont les caractéristiques d'un objet. Pour une voiture, ce sont la couleur, la marque,
la vitesse... Pour une personne : le nom, l'âge...

Type d'attribut Description

Propre à chaque objet (ex: [Link]). Chaque voiture a sa propre

Attribut d'instance
couleur.

Partagé par tous les objets de la classe (ex: lieu_habitation =

Attribut de classe
'TERRE' pour tous les humains).

Les Méthodes
Les méthodes sont les actions qu'un objet peut réaliser. Pour une voiture : accélérer, freiner,
klaxonner. Ce sont simplement des fonctions définies à l'intérieur de la classe.

class Voiture:
def __init__(self, couleur, marque, vitesse=0):
[Link] = couleur # attribut d'instance
[Link] = marque
[Link] = vitesse

def accelerer(self, quantite): # méthode

[Link] += quantite

def freiner(self, quantite): # méthode

[Link] -= quantite
if [Link] < 0:
[Link] = 0

# Utilisation
voiture_bleue = Voiture('bleu', 'Peugeot', 20)
print(voiture_bleue.vitesse) # 20
voiture_bleue.accelerer(30)
print(voiture_bleue.vitesse) # 50
voiture_bleue.freiner(10)
print(voiture_bleue.vitesse) # 40

Cours Python — POO & Regex Page 8

 Le mot self désigne l'objet lui-même. Quand tu écris [Link], tu parles de la vitesse
■ de cette voiture précise. C'est obligatoire comme premier paramètre de toutes les
méthodes d'instance !

Cours Python — POO & Regex Page 9

Cours Python — POO & Regex Page 10
 Le Constructeur __init__
Chapitre 4 - La naissance de l'objet

À quoi sert __init__ ?

Le constructeur est la méthode spéciale __init__. Elle est appelée automatiquement dès qu'on
crée un nouvel objet. C'est là qu'on initialise toutes les données de l'objet.

Pense à __init__ comme la naissance d'un objet. Quand un bébé naît, on lui donne un
■ prénom, une couleur de yeux... C'est pareil pour un objet !

class Humain:
lieu_habitation = 'TERRE' # attribut de CLASSE (partagé)

def __init__(self, nom, age):

[Link] = nom # attribut d'INSTANCE (propre à chaque humain)
[Link] = age

# Création — __init__ s'appelle automatiquement

h = Humain('Adam', 20)
print([Link]) # Adam
print(h.lieu_habitation) # TERRE

Paramètres avec valeur par défaut

On peut donner des valeurs par défaut à certains paramètres de __init__. Cela rend la création
d'objets plus flexible.

class Voiture:
def __init__(self, marque, couleur='blanc', vitesse=0):
[Link] = marque
[Link] = couleur
[Link] = vitesse

v1 = Voiture('BMW', 'rouge', 100) # tous les paramètres

v2 = Voiture('Dacia') # seulement la marque
print([Link]) # blanc (valeur par défaut)
print([Link]) # 0 (valeur par défaut)

Cours Python — POO & Regex Page 11

Cours Python — POO & Regex Page 12
 Types de Méthodes
Chapitre 5 - Instance, Classe et Statique

1. Méthode d'instance (standard)

C'est la méthode la plus courante. Elle reçoit self en premier paramètre et peut accéder aux
attributs de l'objet.

2. Méthode de classe (@classmethod)

Elle reçoit cls (la classe elle-même) en premier paramètre. Elle peut accéder et modifier les
attributs de classe (partagés par tous les objets).

3. Méthode statique (@staticmethod)

Elle ne reçoit ni self ni cls. Elle ne peut pas accéder aux attributs. C'est une simple fonction rangée
dans la classe par commodité.

class Humain:
lieu_habitation = 'TERRE' # attribut de classe

def __init__(self, nom, age):

[Link] = nom
[Link] = age

# 1. Méthode d'INSTANCE — accède à self

def parler(self, message):
print(f'{[Link]} a dit : {message}')

# 2. Méthode de CLASSE — accède à cls

@classmethod
def changer_planete(cls, nouvelle_planete):
Humain.lieu_habitation = nouvelle_planete

# 3. Méthode STATIQUE — pas de self ni cls

@staticmethod
def definition():
print('Un être humain est un être vivant.')

h = Humain('Adam', 20)
[Link]('Bonjour !') # méthode d'instance
Humain.changer_planete('MARS') # méthode de classe

Cours Python — POO & Regex Page 13

 [Link]() # méthode statique

Methode 1er param Attrs instance Attrs classe

Instance self Oui Oui

Classe cls Non Oui

Statique - Non Non

Cours Python — POO & Regex Page 14

Cours Python — POO & Regex Page 15
 Adressage Indirect
Chapitre 6 - Les alias d'objets

Qu'est-ce qu'un alias ?

En Python, quand tu écris a = b pour des objets, tu ne copies pas l'objet : tu crées un alias,
c'est-à-dire un deuxième nom qui pointe vers le même objet. Si tu modifies l'un, l'autre change
aussi !

Imagine que personne1 et personne2 sont des adresses de maison. Si tu fais

■ personne1 = personne2, les deux adresses pointent vers la même maison. Modifier la
maison affecte les deux !

class Personne:
def __init__(self, nom):
[Link] = nom

p1 = Personne('SAMI')
p2 = Personne('Adam')

print([Link]) # SAMI
print([Link]) # Adam

# Adressage indirect : p1 pointe maintenant sur le même objet que p2

p1 = p2
print([Link]) # Adam (p1 et p2 désignent le même objet !)

Cours Python — POO & Regex Page 16

Cours Python — POO & Regex Page 17
 Encapsulation
Chapitre 7 - Protéger ses données

Pourquoi protéger les données ?

L'encapsulation consiste à contrôler l'accès aux attributs d'un objet. Tout le monde ne devrait pas
pouvoir lire ou modifier n'importe quelle donnée. Par exemple, ton salaire est une information
privée !

■ En Python, on distingue 3 niveaux d'accès selon la syntaxe du nom.

Niveau Syntaxe Exemple Accessible depuis

Public nom [Link] Partout

Protégé _nom self._age Classe + sous-classes (par convention)

Privé __nom self.__salaire Seulement dans la classe

class Personne:
def __init__(self, nom, age, salaire):
[Link] = nom # PUBLIC — accessible partout
self._age = age # PROTÉGÉ — par convention
self.__salaire= salaire # PRIVÉ — mangling: _Personne__salaire

def afficher_info(self):
print(f'Nom:{[Link]}, Age:{self._age}, Sal:{self.__salaire}')

p = Personne('Lina', 30, 50000)

print([Link]) # OK — public
print(p._age) # OK — protégé (déconseillé mais possible)
# print(p.__salaire) # ERREUR ! AttributeError
print(p._Personne__salaire) # 50000 — accès indirect (déconseillé)

Cours Python — POO & Regex Page 18

Cours Python — POO & Regex Page 19
 Getters, Setters et @property
Chapitre 8 - Accéder aux attributs privés en toute sécurité

Getters et Setters classiques

Un getter (lecteur) est une méthode qui lit un attribut privé. Un setter (écrivain) est une méthode
qui le modifie, tout en pouvant vérifier la valeur.

class Personne:
def __init__(self, nom, age):
self.__nom = nom
self.__age = age

def get_nom(self): # GETTER

return self.__nom

def set_nom(self, nom): # SETTER

self.__nom = nom

def get_age(self): # GETTER

return self.__age

def set_age(self, age): # SETTER avec vérification

if age >= 0:
self.__age = age
else:
print('Erreur : age négatif !')

p = Personne('Lina', 30)
p.set_age(-5) # Erreur : age négatif !
p.set_age(25)
print(p.get_age()) # 25

La Propriété @property (syntaxe moderne)

Le décorateur @property permet d'accéder à un attribut privé comme s'il était public, tout en
gardant le contrôle. C'est la façon pythonique de faire des getters/setters.

class Personne:
def __init__(self, nom, age):
self.__nom = nom
self.__age = age

@property # GETTER

Cours Python — POO & Regex Page 20

 def nom(self):
return self.__nom

@[Link] # SETTER
def nom(self, nom):
self.__nom = nom

@property
def age(self):
return self.__age

@[Link]
def age(self, age):
if age >= 0:
self.__age = age

p = Personne('LINA', 30)
print([Link]) # Appelle le getter — LINA
[Link] = 'KARIM' # Appelle le setter
print([Link]) # KARIM

Cours Python — POO & Regex Page 21

Cours Python — POO & Regex Page 22
 L'Héritage
Chapitre 9 - La famille des classes

Concept d'héritage
L'héritage permet à une classe enfant de récupérer automatiquement tous les attributs et
méthodes d'une classe parent. Comme les enfants héritent des traits de leurs parents !

Si Animal a une méthode manger(), alors Chien (qui hérite d'Animal) peut aussi manger()
■ sans que tu aies besoin de réécrire la méthode !

Héritage simple
class Animal: # Classe PARENT
def __init__(self, nom):
[Link] = nom

def manger(self):
print(f'{[Link]} mange.')

def dormir(self):
print(f'{[Link]} dort.')

class Chien(Animal): # Classe ENFANT — hérite d'Animal

def __init__(self, nom, race):
Animal.__init__(self, nom) # ou super().__init__(nom)
[Link] = race

def aboyer(self): # méthode spécifique à Chien

print(f'{[Link]} aboie. Race: {[Link]}')

rex = Chien('Rex', 'Labrador')

[Link]() # hérité d'Animal — Rex mange.
[Link]() # hérité d'Animal — Rex dort.
[Link]() # spécifique à Chien

print(isinstance(rex, Chien)) # True

print(isinstance(rex, Animal)) # True — un Chien EST un Animal

Héritage multiple
Python permet à une classe d'hériter de plusieurs parents à la fois. Le canard peut voler ET
nager !

Cours Python — POO & Regex Page 23

 class Volant:
def voler(self):
print('Je vole !')

class Nageant:
def nager(self):
print('Je nage !')

class Canard(Volant, Nageant): # hérite des DEUX

def caqueter(self):
print('Coin coin !')

donald = Canard()
[Link]() # de Volant
[Link]() # de Nageant
[Link]() # propre à Canard

# L'ordre de résolution : MRO

print([Link]())
# [Canard, Volant, Nageant, object]

Héritage en cascade (multi-niveaux)

class Vehicule:
def se_deplacer(self): print('Je me déplace.')

class Voiture(Vehicule):
def klaxonner(self): print('Tuut !')

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

def accelerer(self): print('Vroooom !')

ferrari = VoitureSport()
ferrari.se_deplacer() # de Vehicule
[Link]() # de Voiture
[Link]() # de VoitureSport

Cours Python — POO & Regex Page 24

Cours Python — POO & Regex Page 25
 Surcharge et Redéfinition
Chapitre 10 - Adapter les méthodes héritées

Redéfinition (Override)
La redéfinition consiste à réécrire une méthode de la classe parent dans la classe enfant. La
nouvelle version remplace l'ancienne.

class Animal:
def parler(self):
print('Un animal fait un bruit.')

class Chien(Animal):
def parler(self): # REDÉFINITION
print('Le chien aboie !')

class Chat(Animal):
def parler(self): # REDÉFINITION
print('Le chat miaule !')

Animal().parler() # Un animal fait un bruit.

Chien().parler() # Le chien aboie !
Chat().parler() # Le chat miaule !

Utiliser super() pour appeler le parent

super() permet d'appeler la méthode de la classe parent tout en ajoutant du comportement
spécifique à l'enfant.

class Animal:
def parler(self):
print('Un animal fait un bruit.')

class Chien(Animal):
def parler(self):
super().parler() # appelle [Link]()
print('Rex aboie aussi !')

Chien().parler()
# Un animal fait un bruit.
# Rex aboie aussi !

Surcharge du constructeur

Cours Python — POO & Regex Page 26

On peut simuler plusieurs constructeurs en utilisant des paramètres optionnels.

class Personne:
def __init__(self, nom=None, age=None):
[Link] = nom if nom else 'Inconnu'
[Link] = age if age else 0

p1 = Personne('Alice', 30)
p2 = Personne('Bob')
p3 = Personne()
print([Link], [Link]) # Alice 30
print([Link], [Link]) # Bob 0
print([Link], [Link]) # Inconnu 0

Cours Python — POO & Regex Page 27

Cours Python — POO & Regex Page 28
 L'Abstraction
Chapitre 11 - Les contrats de classe (ABC)

Qu'est-ce qu'une classe abstraite ?

Une classe abstraite est un modèle général que l'on ne peut pas instancier directement. Elle
définit des méthodes que les classes enfants doivent implémenter. C'est comme un contrat !

Imagine un contrat de travail qui dit : 'Tout employé DOIT savoir ' faire son rapport'.
■ Chaque type d'employé le fait à sa manière, mais tout le monde doit le faire.

from abc import ABC, abstractmethod

class Animal(ABC): # classe ABSTRAITE

@abstractmethod
def faire_son(self): # méthode abstraite = contrat
pass

# animal = Animal() # ERREUR ! On ne peut pas instancier une classe abstraite

class Chien(Animal):
def faire_son(self): # OBLIGATOIRE d'implémenter
return 'Ouaf !'

class Chat(Animal):
def faire_son(self):
return 'Miaou !'

animaux = [Chien(), Chat()]

for a in animaux:
print(a.faire_son()) # Ouaf ! puis Miaou !

from abc import ABC, abstractmethod

class Forme(ABC):
@abstractmethod
def aire(self):
pass

class Cercle(Forme):
def __init__(self, rayon):
[Link] = rayon
def aire(self):
return 3.14 * [Link] ** 2

Cours Python — POO & Regex Page 29

 c = Cercle(5)
print([Link]()) # 78.5

Cours Python — POO & Regex Page 30

Cours Python — POO & Regex Page 31
 Méthodes Spéciales
Chapitre 12 - __str__, __repr__, __del__, __dict__, __doc__

Le Destructeur __del__
Le destructeur est appelé automatiquement quand l'objet est supprimé. C'est l'opposé du
constructeur.

class Exemple:
def __init__(self, valeur):
[Link] = valeur
print(f'Objet créé : {[Link]}')

def __del__(self):
print(f'Objet détruit : {[Link]}')

e = Exemple(10) # Objet créé : 10

del e # Objet détruit : 10

__str__ et __repr__
__str__ définit ce qu'affiche print(objet) — une représentation lisible pour l'humain. __repr__
donne une représentation technique (pour les développeurs).

class Personne:
def __init__(self, nom, age):
[Link] = nom
[Link] = age

def __str__(self):
return f'Personne: {[Link]}, {[Link]} ans'

def __repr__(self):
return f"Personne('{[Link]}', {[Link]})"

p = Personne('Ali', 30)
print(p) # Personne: Ali, 30 ans (utilise __str__)
print(repr(p)) # Personne('Ali', 30) (utilise __repr__)

__dict__ et __doc__
class Exemple:
'''Cette classe est un exemple.''' # Documentation

Cours Python — POO & Regex Page 32

 attribut_classe = 'valeur'

def __init__(self, nom, age):

[Link] = nom
[Link] = age

e = Exemple('SAMI', 30)

# __dict__ : dictionnaire des attributs d'un objet

print(e.__dict__) # {'nom': 'SAMI', 'age': 30}

# Ajouter dynamiquement un attribut

e.__dict__['ville'] = 'Casablanca'
print(e.__dict__) # {'nom': 'SAMI', 'age': 30, 'ville': 'Casablanca'}

# __doc__ : documentation de la classe

print(Exemple.__doc__) # Cette classe est un exemple.

Cours Python — POO & Regex Page 33

Cours Python — POO & Regex Page 34
 Surcharge d'Opérateurs
Chapitre 13 - +, -, *, <, ==, != et bien plus

Principe
La surcharge d'opérateurs permet de définir ce que signifient des opérateurs comme +, -, ==
pour tes propres classes. Par exemple : additionner deux fractions ou comparer deux rectangles.

Opérateur Méthode spéciale

a+b __add__

a-b __sub__

a*b __mul__

a/b __truediv__

a == b __eq__

a != b __ne__

a<b __lt__

a <= b __le__

a>b __gt__

a >= b __ge__

str(a) __str__

Exemple : classe Fraction

class Fraction:
def __init__(self, num, den):
[Link] = num
[Link] = den

def __add__(self, other):

n = [Link] * [Link] + [Link] * [Link]
d = [Link] * [Link]
return Fraction(n, d)

def __str__(self):

Cours Python — POO & Regex Page 35

 return f'{[Link]}/{[Link]}'

f1 = Fraction(1, 2) # 1/2
f2 = Fraction(1, 3) # 1/3
print(f1 + f2) # 5/6

Exemple : classe Rectangle avec comparaisons

class Rectangle:
def __init__(self, largeur, hauteur):
[Link] = largeur
[Link] = hauteur

def aire(self):
return [Link] * [Link]

def __lt__(self, other): # <

return [Link]() < [Link]()

def __eq__(self, other): # ==

return [Link]() == [Link]()

def __str__(self):
return f'Rectangle({[Link]}x{[Link]})'

r1 = Rectangle(2, 3) # aire = 6
r2 = Rectangle(4, 5) # aire = 20
print(r1 < r2) # True
print(r1 == r2) # False

Cours Python — POO & Regex Page 36

Cours Python — POO & Regex Page 37
 Les Listes en Python
Chapitre 14 - La structure de données incontournable

Créer et accéder à une liste

Une liste est une collection ordonnée d'éléments. On la crée avec des crochets [ ]. Elle peut
contenir des entiers, des chaînes, des booléens, etc.

# Créer une liste

ma_liste = [10, 20, 30, 40]

# Accéder par index (commence à 0)

print(ma_liste[0]) # 10 — premier élément
print(ma_liste[-1]) # 40 — dernier élément
print(ma_liste[1:3]) # [20, 30] — sous-liste (slicing)

Ajouter et supprimer des éléments

ma_liste = [10, 20, 30]

ma_liste.append(40) # Ajouter en fin: [10,20,30,40]

ma_liste.extend([50, 60]) # Ajouter plusieurs: [10,20,30,40,50,60]
ma_liste.insert(1, 15) # Insérer à index 1: [10,15,20,30,40,50,60]

ma_liste.remove(30) # Supprimer la valeur 30

del ma_liste[1] # Supprimer l'index 1
dernier = ma_liste.pop() # Supprimer et retourner le dernier

Trier, parcourir et opérations utiles

ma_liste = [40, 10, 30, 20]

# Trier
ma_liste.sort() # [10, 20, 30, 40]
ma_liste.sort(reverse=True) # [40, 30, 20, 10]

# Parcourir
for element in ma_liste:
print(element)

# Opérations utiles
print(len(ma_liste)) # Taille
print(20 in ma_liste) # True — 20 est dans la liste ?

Cours Python — POO & Regex Page 38

 print(ma_liste.index(30)) # Position de 30
print(ma_liste.count(20)) # Nombre d'occurrences de 20

# Liste de listes (tableau 2D)

tableau = [[1, 2], [3, 4], [5, 6]]
print(tableau[1][0]) # 3

Cours Python — POO & Regex Page 39

 PARTIE 2 — EXPRESSIONS RÉGULIÈRES (REGEX)

Les expressions régulières (regex) sont des formules magiques pour chercher, valider et
transformer du texte. Elles semblent compliquées au début, mais avec de la pratique, tu verras
qu'elles sont très puissantes !

Cours Python — POO & Regex Page 40

Cours Python — POO & Regex Page 41
 Introduction aux Regex
Chapitre 15 - C'est quoi une expression régulière ?

Définition
Une expression régulière est une séquence de caractères qui définit un motif de recherche. Elle
permet de :

• Vérifier qu'une chaîne respecte un format (email valide ? téléphone ?)

• Rechercher des motifs dans un texte (trouver toutes les dates)
• Extraire des parties spécifiques d'un texte
• Remplacer du texte de manière complexe

Imagine que tu cherches tous les mots commençant par 'py' dans un document de 1000
■ pages. La regex le fait en une ligne de code !

Importer le module re
import re # toujours nécessaire pour utiliser les regex

texte = 'tac tic toc tqc t9c'

motif = r't.c' # le point . = n'importe quel caractère
resultats = [Link](motif, texte)
print(resultats) # ['tac', 'tic', 'toc', 'tqc', 't9c']

On utilise r'...' (raw string) pour écrire les motifs regex. Cela évite que Python interprète
■ les backslashes (\).

Cours Python — POO & Regex Page 42

Cours Python — POO & Regex Page 43
 Les Caractères Spéciaux
Chapitre 16 - . [ ] ^ $ \ | * + ?

Le point . — n'importe quel caractère

Le point correspond à n'importe quel caractère sauf le saut de ligne.

import re
texte = 'tac tic toc tqc t9c'
[Link](r't.c', texte) # ['tac', 'tic', 'toc', 'tqc', 't9c']

Les crochets [ ] — ensemble de caractères

Les crochets définissent un groupe de caractères acceptés. Seul un caractère parmi ceux listés
est accepté.

[Link](r'[aeiouy]', 'Python est amusant')

# ['y', 'o', 'e', 'a', 'u', 'a'] — toutes les voyelles

[Link](r'[0-9]', 'code 123') # ['1', '2', '3']

[Link](r'[a-zA-Z]', 'Python 3') # ['P','y','t','h','o','n']

# Négation avec ^ dans les crochets

[Link](r'[^a-z]', 'Python 3!') # ['P', ' ', '3', '!']

L'ancre ^ et $ (début et fin de ligne)

import re

# ^ : ancre de DÉBUT de ligne

texte = 'Bonjour monde\nBonjour Python'
[Link](r'^Bonjour', texte, [Link]) # ['Bonjour', 'Bonjour']

# $ : ancre de FIN de ligne

[Link](r'Python$', texte, [Link]) # ['Python']

Le backslash \ — échappement
Le backslash neutralise le sens spécial d'un caractère. Par exemple, \. cherche un vrai point (pas
n'importe quel caractère).

texte = 'Prix : 10$ pour chaque pièce.'

Cours Python — POO & Regex Page 44

 [Link](r'\.', texte) # ['.'] — cherche un point réel
[Link](r'\$', texte) # ['$'] — cherche un dollar réel

La barre verticale | — ou logique

texte = 'Durand, Durant, Dupont'
[Link](r'Durand|Durant', texte) # ['Durand', 'Durant']

texte2 = 'Aujourd hui c est ma, demain sera me ou je'

[Link](r'(lu|ma|me|je|ve|sa|di)', texte2) # ['ma', 'me', 'je']

Cours Python — POO & Regex Page 45

Cours Python — POO & Regex Page 46
 Les Classes de Caractères
Chapitre 17 - \d, \w, \s et leurs opposés

Les séquences d'échappement prédéfinies

Séquence Signification Opposé

\d Un chiffre [0-9] \D — tout sauf un chiffre

\w Un caractère alphanumérique [a-zA-Z0-9_] \W — tout sauf alphanumérique

\s Un espace, tabulation, saut de ligne \S — tout sauf espace

\b Délimiteur de mot (frontière) \B — pas de frontière de mot

\n Saut de ligne —

\t Tabulation —

import re

texte = 'Les nombres sont 123, 456, et 789.'

# \d+ : un ou plusieurs chiffres

[Link](r'\d+', texte) # ['123', '456', '789']

# \w : caractères alphanumériques
[Link](r'\w', 'Mot_123!') # ['M','o','t','_','1','2','3']

# \s : espaces et tabulations
[Link](r'\s', 'Mot1 Mot2') # [' ']

# \b : délimiteur de mot (cherche le mot exact 'écran')

[Link](r'\bécran\b', 'un écran écran écrans') # ['écran','écran']

# \D : tout sauf chiffre

[Link](r'\D', '123abc456') # ['a', 'b', 'c']

Cours Python — POO & Regex Page 47

Cours Python — POO & Regex Page 48
 Les Quantificateurs
Chapitre 18 - *, +, ?, { }

Les 4 quantificateurs essentiels

Quantificat
Signification Exemple
eur

* 0 ou plusieurs fois ab* : a, ab, abb, abbb...

+ 1 ou plusieurs fois ab+ : ab, abb, abbb... (pas 'a' seul)

? 0 ou 1 fois (optionnel) écran(s)? : écran ou écrans

{n} Exactement n fois [0-9]{3} : 3 chiffres exactement

{n,} Au moins n fois [0-9]{2,} : 2 chiffres minimum

{n,m} Entre n et m fois [0-9]{2,5} : 2 à 5 chiffres

import re

# * : zéro ou plusieurs b après a

[Link](r'ab*', 'aa ab abc abbb') # ['a', 'ab', 'ab', 'abbb']

# + : un ou plusieurs b après a
[Link](r'ab+', 'ab abb abbb a') # ['ab', 'abb', 'abbb']

# ? : s optionnel
[Link](r'écran(?:s)?', 'écran écrans') # ['écran', 'écrans']

# {2,5} : entre 2 et 5 chiffres

[Link](r'[0-9]{2,5}', '12345 12 123456 1')
# ['12345', '12', '123']

# {2} : exactement 2 chiffres

[Link](r'[0-9]{2}', '12 12344 78') # ['12', '12', '34', '78']

Cours Python — POO & Regex Page 49

Cours Python — POO & Regex Page 50
 Les Ancres ^ et $
Chapitre 19 - Début et fin de chaîne / ligne

Les ancres ne correspondent pas à des caractères mais à des positions dans le texte.

import re

# ^ ancre de début
texte = 'Depuis hier, il fait beau.\nDemain, il fera beau.'
[Link](r'^Depuis', texte, [Link]) # ['Depuis']
[Link](r'^Demain', texte, [Link]) # ['Demain']

# $ ancre de fin
texte2 = 'ligne une\nligne deux'
[Link](r'deux$', texte2, [Link]) # ['deux']

Sans [Link], ^ et $ s'appliquent uniquement au début et à la fin de toute la

■ chaîne. Avec [Link], ils s'appliquent à chaque ligne.

Cours Python — POO & Regex Page 51

Cours Python — POO & Regex Page 52
 Le Module re
Chapitre 20 - findall, search, split, sub, compile

[Link]() — Trouver toutes les correspondances

Retourne une liste de toutes les correspondances trouvées. Si aucune correspondance, retourne
une liste vide.

import re

texte = 'Durand et Durant sont amis.'

[Link](r'Duran(d|t)', texte) # ['d', 't']
# Note : avec groupe capturant, seul le groupe est retourné

[Link]() — Trouver la 1ère correspondance

Retourne un objet Match pour la première correspondance (ou None). Utilise .group() pour extraire
le résultat.

import re

texte = 'Nom: John, age: 45, ID: 12345'

expr = [Link](r'(\w+): (\d{2})')
match = [Link](texte)

if match:
print([Link](0)) # 'age: 45' — correspondance complète
print([Link](1)) # 'age' — 1er groupe
print([Link](2)) # '45' — 2ème groupe

[Link]() — Diviser une chaîne

import re

texte = 'Python est amusant'

[Link](r'\s', texte) # ['Python', 'est', 'amusant']
[Link](r'\s', texte, maxsplit=1) # ['Python', 'est amusant']

[Link]() — Remplacer des correspondances

import re

# Remplacer espaces par tirets

Cours Python — POO & Regex Page 53

 [Link](r'\s', '-', 'Python est amusant')
# 'Python-est-amusant'

# Supprimer les espaces multiples

[Link](r'\s+', ' ', 'Trop d espaces ici')
# 'Trop d espaces ici'

[Link]() — Compiler un motif

Quand on utilise le même motif plusieurs fois, il est plus efficace de le compiler d'abord avec
[Link](). Cela améliore les performances.

import re

# Compiler le motif une seule fois

expr = [Link](r'\d{1,3}')

# Utiliser le motif compilé sur plusieurs textes

[Link]('123 45 6789') # ['123', '45', '678', '9']
[Link]('99 1000 7') # ['99', '100', '0', '7']

Cours Python — POO & Regex Page 54

Cours Python — POO & Regex Page 55
 Options de Compilation
Chapitre 21 - IGNORECASE, MULTILINE, DOTALL, VERBOSE

[Link] (re.I) — Ignorer la casse

import re

# Sans option : sensible à la casse

[Link](r'[a-z]+', 'Bonjour') # ['onjour']

# Avec IGNORECASE : insensible à la casse

[Link](r'[a-z]+', 'Bonjour', [Link]) # ['Bonjour']

# Ou avec (?i) inline

[Link](r'(?i)[a-z]+', 'Bonjour') # ['Bonjour']

[Link] (re.M) — ^ et $ sur chaque ligne

texte = 'Première ligne\nDeuxième ligne\nTroisième ligne'

# Sans MULTILINE : ^ ne correspond qu'au début total

[Link](r'^Deuxième', texte) # []

# Avec MULTILINE : ^ correspond au début de chaque ligne

[Link](r'^Deuxième', texte, [Link]) # ['Deuxième']

[Link] (re.S) — Le . inclut les sauts de ligne

texte = 'Ligne un.\nLigne deux.'

# Sans DOTALL : le . ne passe pas le \n

[Link](r'Ligne.*deux', texte) # []

# Avec DOTALL : le . correspond à tout, y compris \n

[Link](r'Ligne.*deux', texte, [Link]) # ['Ligne un.\nLigne deux']

[Link] (re.X) — Commentaires dans le motif

Permet d'écrire des regex plus lisibles avec des espaces et des commentaires.

import re

# Difficile à lire
expr1 = [Link](r'\d{3}-\d{2}-\d{4}')

Cours Python — POO & Regex Page 56

 # Facile à lire avec VERBOSE
expr2 = [Link](r'''
\d{3} # Trois chiffres
- # Un tiret
\d{2} # Deux chiffres
- # Un autre tiret
\d{4} # Quatre chiffres
''', [Link])

[Link]('123-45-6789') # ['123-45-6789']

Cours Python — POO & Regex Page 57

Cours Python — POO & Regex Page 58
 Groupes et Motifs Nominatifs
Chapitre 22 - Capturer et nommer des parties du texte

Groupes capturants ( )
Les parenthèses créent des groupes qui capturent des parties de la correspondance. On peut
ensuite les extraire avec .group(1), .group(2), etc.

import re

texte = 'Alice Dupont, age 30'

expr = [Link](r'(\w+) (\w+), age (\d+)')
match = [Link](texte)

if match:
print([Link](0)) # 'Alice Dupont, age 30' — tout
print([Link](1)) # 'Alice' — 1er groupe
print([Link](2)) # 'Dupont' — 2ème groupe
print([Link](3)) # '30' — 3ème groupe

Motifs nominatifs (?P...)

On peut donner un nom à chaque groupe avec la syntaxe (?P<nom>...). C'est beaucoup plus
lisible et pratique !

import re

texte = 'Alice Dupont, age 30'

expr = [Link](
r'(?P<prenom>\w+) (?P<nom>\w+), age (?P<age>\d+)'
)
match = [Link](texte)

if match:
print([Link]('prenom')) # Alice
print([Link]('nom')) # Dupont
print([Link]('age')) # 30
print([Link]()) # {'prenom':'Alice', 'nom':'Dupont', 'age':'30
'}

Exemple concret : extraire une date

Cours Python — POO & Regex Page 59

 import re

motif_date = [Link](
r'(?P<jour>\d{1,2}) (?P<mois>\w+) (\d{4})'
)
texte = 'La Bastille le 14 juillet 1789'
match = motif_date.search(texte)

print([Link]()) # {'jour': '14', 'mois': 'juillet'}

print([Link]('jour')) # 14
print([Link]('mois')) # juillet

Référence à un groupe dans le motif (?P=nom)

On peut réutiliser un groupe déjà capturé pour trouver une répétition.

import re

# Chercher un mot répété deux fois de suite

expr = [Link](r'(?P<motif>\w+)\s(?P=motif)')
texte = 'motif motif autre texte'
match = [Link](texte)

if match:
print([Link]('motif')) # motif

Cours Python — POO & Regex Page 60

 RÉSUMÉ FINAL — Aide-mémoire

POO en bref

Concept En résumé

Classe Le moule, le plan de construction d'un objet

Objet Une instance concrète de la classe

__init__ Constructeur — s'exécute à la création de l'objet

self Référence à l'objet lui-même

Encapsulation Contrôle l'accès aux données (public, _protégé, __privé)

Héritage Une classe enfant hérite des attributs/méthodes du parent

@property Crée des getters/setters élégants

super() Appelle la méthode du parent

ABC Classe abstraite — définit un contrat à respecter

__str__ Définit l'affichage de l'objet avec print()

Regex en bref

Symbole / Fonction Signification

. N'importe quel caractère (sauf \n)

[abc] Un caractère parmi a, b ou c

[^abc] Tout sauf a, b, c

^ Début de ligne (ancre)

$ Fin de ligne (ancre)

* 0 ou plusieurs fois

+ 1 ou plusieurs fois

? 0 ou 1 fois

{n,m} Entre n et m fois

Cours Python — POO & Regex Page 61

 \d / \D Chiffre / Non-chiffre

\w / \W Alphanumérique / Non-alphanumérique

\s / \S Espace / Non-espace

\b Frontière de mot

a|b a ou b

(abc) Groupe capturant

(?P...) Groupe nommé

[Link]() Retourne toutes les correspondances

[Link]() Retourne la 1ère correspondance

[Link]() Remplace les correspondances

[Link]() Divise selon le motif

Félicitations ! Tu as parcouru tout le cours. La programmation s'apprend en pratiquant :

■ ouvre Python et teste tous ces exemples toi-même. Plus tu codes, plus ça devient naturel
!

Cours Python — POO & Regex Page 62