Langage Python

Résumé structuré des cours

Auteur : Said AGOUJIL

Année académique : 2024-2025

─────────────────────────────
Chapitres couverts :
01 – Introduction · 02 – Collections · 03 – Classes · 04 – Héritage
Chapitre 1 — Introduction à Python

1.1 L'Algorithmique
L'algorithmique est la base de la programmation. Un algorithme est la description d'un
processus logique, écrit en langage naturel, qui décrit une succession d'opérations à
exécuter dans un certain ordre et sous certaines conditions pour transformer des données
d'entrée en résultats de sortie.

Propriétés fondamentales d'un algorithme

• Chaque étape est décrite de façon précise
• Chaque étape est déterministe : elle produit des résultats uniques
• L'algorithme s'arrête après un nombre fini d'instructions
• Reçoit des données en entrée et produit des données en sortie

Exemple — Maximum de deux nombres

1. Saisir la valeur du 1er nombre a
2. Saisir la valeur du 2ème nombre b
3. Si a > b alors le maximum est a, sinon le maximum est b

1.2 Les Langages de Programmation

Un langage de programmation est un outil permettant de donner des ordres (instructions) à
la machine. À chaque instruction correspond une action du processeur.

Langages bas niveau

• Langage binaire : l'information est représentée sous forme de bits (0 ou 1)
• 1 octet = 8 bits — permet de coder tous les caractères alphanumériques
• Les opérations arithmétiques de base sont effectuées en binaire

Langages haut niveau

• Proche du langage humain (anglais) — compréhensible
• Portable : indépendant du matériel
• Permet la manipulation de données complexes (réels, objets, expressions)
• Nécessite un traducteur : compilateur ou interpréteur

1.3 Compilateur vs Interpréteur

Le compilateur traduit le programme entier en fichier exécutable avant l'exécution.
L'interpréteur traduit et exécute le programme instruction par instruction à chaque
lancement.

Comparaison
• Compilateur : exécution plus rapide, sécurité du code source, recompilation
nécessaire à chaque modification
• Interpréteur : exécution instantanée, pratique pour les débutants, mais plus lente
1.4 Historique et caractéristiques de Python
Python a été créé en 1989 par Guido van Rossum aux Pays-Bas. La première version
publique a été publiée en 1991. Il existe deux grandes versions : Python 2 (désormais
obsolète depuis 2020) et Python 3 (version actuelle recommandée). Les deux versions ne
sont pas rétrocompatibles.

Caractéristiques de Python
• Structuré et orienté objet
• Modulaire : peut être découpé en modules compilables séparément
• Universel : non limité à un domaine applicatif particulier
• Typé dynamiquement : le type est déterminé lors de l'affectation
• Portable : fonctionne sur tout système disposant d'un interpréteur Python
• Riche en bibliothèques : des milliers de packages disponibles

1.5 Variables et Types de données

Une variable est un emplacement mémoire nommé, dont le contenu peut changer au cours
de l'exécution du programme. En Python, le type est déterminé automatiquement lors de
l'affectation.

Règles de nommage
• Composé de lettres, chiffres et du symbole '_' — doit commencer par une lettre ou '_'
• Sensible à la casse : 'Ma_variable' ≠ 'ma_variable'
• Ne peut pas être un mot réservé Python (if, else, for, while, class…)

Types primitifs
• bool : booléen (True ou False)
• int : entier
• float : nombre flottant (double précision)
• str : chaîne de caractères

1.6 Opérateurs
Opérateurs arithmétiques
+, - (addition/soustraction) · * (multiplication) · / (division réelle) · // (division entière) · ** ou
pow() (puissance) · % (modulo)

Opérateurs relationnels
== · != · < · <= · > · >=

Opérateurs logiques
not (contraire) · and / & (et logique) · or / | (ou logique) · ^ (xor)

1.7 Saisie et Affichage

• input() : saisie au clavier — retourne toujours une chaîne (conversion nécessaire)
• print() : affichage à l'écran — supporte l'affichage de plusieurs valeurs
a = float(input("Saisir une valeur : "))
print("Résultat :", a)
Chapitre 2 — Collections et Instructions de Contrôle

2.1 Les Listes (list)

Une liste est une structure de données permettant de stocker plusieurs éléments de types
quelconques dans une seule variable. Les éléments sont ordonnés et accessibles par leur
indice (commençant à 0).

Opérations de base
• Création : maListe = [] ou maListe = [1, 2, 3]
• Taille : len(maListe)
• Accès par indice : maListe[2], dernier élément : maListe[-1]
• Sous-liste (slice) : maListe[0:2]
• Suppression d'un élément : del maListe[2]
• Inversion : [Link]() ou maListe[::-1]

Méthodes principales
• append(x) : ajouter un élément à la fin
• insert(i, x) : insérer un élément à la position i
• remove(x) : supprimer le premier élément égal à x
• pop() / pop(i) : retirer et retourner le dernier / i-ème élément
• sort() : trier la liste en place
• count(x) : compter les occurrences de x

2.2 Les Tuples (tuple)

Un tuple est similaire à une liste, mais ses éléments sont immuables : ils ne peuvent pas
être modifiés, remplacés ni supprimés après création.

Définition
t = ('a', 'b', 2) # tuple standard
t = () # tuple vide
t = ('a',) # tuple à 1 élément (virgule obligatoire)

Méthodes disponibles
• [Link](x) : nombre d'occurrences de x
• [Link](x) : position de la première occurrence de x
Les tuples supportent les opérateurs +, *, [], in/not in et les comparaisons standard.

2.3 Les Séquences

En Python, une séquence est une chaîne (str), une liste (list) ou un tuple. Les séquences
partagent des opérateurs communs : in, not in (appartenance), is, is not (identité d'objet
mutable).
Conversions entre séquences
• list('abc') → ['a', 'b', 'c']
• tuple(['a', 'b', 'c']) → ('a', 'b', 'c')
• Affectation parallèle : (x, y, z) = (1, 2, 3)

2.4 Les Dictionnaires (dict)

Un dictionnaire stocke des données sous forme de paires clé-valeur. Les clés sont
alphanumériques (ou des tuples de constantes) ; les listes ne peuvent pas être des clés.

Opérations de base
• Création : d = {} ou d = {'clé': valeur}
• Accès : d['clé']
• Affectation : d['clé'] = valeur
• Suppression : del d['clé']
• Test d'existence : 'clé' in d
• Taille : len(d)

Méthodes principales
• [Link]() : liste des clés
• [Link]() : liste des valeurs
• [Link]() : liste de paires (clé, valeur)
• [Link](key, default) : valeur ou default si clé absente
• [Link](key) : retirer et retourner la valeur associée à key
• [Link]() : vider le dictionnaire

2.5 Les Ensembles (set)

Un ensemble est une collection non ordonnée d'éléments uniques et hachables. Les
ensembles sont mutables, mais sans notion de position ou d'indice.

Création
• s = set() — ensemble vide
• s = {'a', 'b', 'c'} ou s = set(['a', 'b', 'c'])
• frozenset : ensemble non modifiable

Opérations ensemblistes
• Union : [Link](s2) ou s | s2
• Intersection : [Link](s2) ou s & s2
• Différence : [Link](s2) ou s - s2
• Différence symétrique : s.symmetric_difference(s2) ou s ^ s2
• Sous-ensemble : [Link](s2) / sur-ensemble : [Link](s2)

2.6 Instructions de Contrôle (if / elif / else)

Les instructions de contrôle permettent de modifier le flux d'exécution d'un programme en
fonction de conditions booléennes.
if condition:
bloc d'instructions
elif condition:
 bloc d'instructions
else:
bloc d'instructions
Forme condensée (opérateur ternaire) :
max = a if a > b else b

2.7 Les Boucles

Boucle while
Exécute un bloc tant qu'une condition est vraie. La clause else est exécutée quand la
condition devient fausse.
while condition:
bloc d'instructions
else:
bloc exécuté en fin de boucle

Boucle for
Itère sur les éléments d'un objet itérable (liste, tuple, chaîne, range…).
for element in iterateur:
bloc d'instructions
range([a], b, [c]) génère une séquence d'entiers de a à b-1 avec un pas de c.

Instructions break, continue, pass

• break : quitte immédiatement la boucle
• continue : passe directement à l'itération suivante
• pass : instruction vide — utile pour les corps de boucle vides

2.8 Les Fonctions

Une fonction est un bloc d'instructions nommé, réutilisable, défini avec le mot-clé def.
def maFonction(arg1, arg2, arg3=valeurDefaut):
bloc d'instructions
return résultat

Particularités
• Les paramètres sont passés par valeur (mais les listes/dicts sont passés par
référence)
• Valeurs par défaut : def maFonc(a, b=5) — b vaut 5 si non fourni
• Appel avec argument nommé : maFonc(a=8)
• Retour multiple via un tuple : return x, y (récupérable dans a, b = maFonc())
Chapitre 3 — Classes et Programmation Orientée
Objet

3.1 Principes de la POO

La Programmation Orientée Objet (POO) consiste à définir des objets logiciels et à les faire
interagir entre eux. Les objets modélisent des entités réelles (voiture, personne) ou des
concepts (date, couleur).

Trois concepts fondamentaux

• Classe : modèle ou type définissant les propriétés communes à un ensemble
d'objets
• Objet (instance) : entité créée à partir d'une classe, possédant une identité propre
• Encapsulation : protection des attributs internes, accessibles uniquement via des
méthodes

3.2 Déclaration d'une Classe

En Python, une classe est définie avec le mot-clé class. Par convention, les noms de
classes utilisent le CamelCase (ex. : NomDeClasse).
class NomDeLaClasse:
pass # corps vide

monObjet = NomDeLaClasse() # instanciation

3.3 Méthodes
Une méthode est une fonction définie dans une classe. Le premier paramètre est toujours
self, qui représente l'instance courante (la référence de l'objet).
def maMethode(self, [arguments]):
# corps de la méthode

3.4 Visibilité des Membres

La POO permet de contrôler l'accès aux attributs et méthodes. En Python, tout est public par
défaut ; la confidentialité repose sur des conventions de nommage :
• Public : nom standard — accessible partout
• Protégé : _nom (un tiret bas) — accessible par la classe et ses sous-classes
• Privé : __nom (deux tirets bas) — accessible uniquement dans la classe

3.5 L'Initialisateur __init__

La méthode __init__ est automatiquement invoquée lors de l'instanciation d'un objet. Elle
permet d'initialiser les attributs. Elle ne contient jamais de return.
class Voiture:
def __init__(self, marque):
 [Link] = marque # attribut d'instance
Remarque : __init__ est souvent appelée « constructeur » par abus de langage. Le vrai
constructeur est __new__, qui crée l'objet avant son initialisation.

3.6 Attributs d'Instance vs Attributs de Classe

Attribut d'instance
• Variable propre à chaque objet, définie dans __init__ via [Link]
• Sa valeur peut varier d'une instance à l'autre

Attribut de classe
• Variable partagée par toutes les instances de la classe
• Équivalent aux attributs statiques en C++

3.7 Méthodes Spéciales (Dunder methods)

Les méthodes spéciales (entourées de doubles tirets bas __) permettent de définir le
comportement des objets pour les opérations Python standards.

__str__ — représentation textuelle

Renvoie une chaîne de caractères représentant l'objet, utilisée par print().
def __str__(self):
return '%.2d:%.2d:%.2d' % (self.h, self.m, self.s)

Surcharge d'opérateurs
Python permet de redéfinir le comportement des opérateurs (+, -, *, /, ==, <, >…) pour les
objets d'une classe via des méthodes spéciales :
• __add__(self, other) → opérateur +
• __sub__(self, other) → opérateur -
• __mul__(self, other) → opérateur *
• __eq__(self, other) → opérateur ==
• __lt__(self, other) → opérateur <
• __len__(self) → fonction len()
• __str__(self) → fonction str() / print()
• __repr__(self) → représentation officielle de l'objet
Chapitre 4 — Héritage et Polymorphisme

4.1 Concept d'Héritage

L'héritage est un mécanisme fondamental de la POO qui permet à une classe (classe fille)
de réutiliser et d'étendre les fonctionnalités d'une autre classe (classe mère), sans modifier
ni copier son code source.

Ce que l'héritage permet

• Ajouter de nouvelles méthodes et attributs dans la classe fille
• Redéfinir (surcharger) des méthodes existantes de la classe mère
• Réutiliser le code existant et organiser les classes hiérarchiquement

4.2 Vocabulaire
• Classe mère / classe parente / super-classe : la classe dont on hérite
• Classe fille / sous-classe : la classe qui hérite

4.3 Déclaration d'une Sous-classe en Python

class ClasseMere:
"""une classe mère"""
pass

class ClasseFille(ClasseMere):
"""une classe fille héritant de la classe mère"""
pass

4.4 Constructeur de la Classe Fille

Le constructeur de la classe fille doit explicitement appeler le constructeur de la classe mère
pour initialiser les attributs hérités. Deux syntaxes sont possibles :

Syntaxe directe
def __init__(self, para1, para2):
ClasseMere.__init__(self, para1) # appel explicite

Syntaxe avec super()

def __init__(self, para1, para2):
super().__init__(para1) # recommandée pour héritage simple
Remarque : super() n'est utilisable que dans le cas d'un héritage simple.

4.5 La Classe object

En Python, toute classe hérite implicitement de la classe object, qui est l'ancêtre commun de
toutes les classes. Ainsi, si aucune classe mère n'est précisée, c'est object qui est utilisé par
défaut.
4.6 Constructeur et Destructeur
__new__ — le vrai constructeur
La méthode __new__ est le vrai constructeur. Elle est appelée avant la création de l'objet,
prend la classe en premier paramètre et retourne l'objet nouvellement créé. __init__ n'est
qu'un initialisateur.

__del__ — le destructeur
La méthode __del__ est appelée lorsque l'objet est supprimé, soit explicitement (del objet),
soit automatiquement par le garbage collector.
class MaClasse:
def __del__(self):
print('Objet détruit')

4.7 Polymorphisme
Le polymorphisme permet d'utiliser le même nom de méthode pour des comportements
différents selon la classe. En Python, cela se traduit par la redéfinition d'une méthode dans
la classe fille avec le même nom que dans la classe mère. Ce processus s'appelle la
redéfinition (ou surcharge) de méthode.
class Animal:
def parler(self):
print('...')

class Chien(Animal):
def parler(self): # redéfinition
print('Wouf !')

4.8 Héritage Multiple

Python supporte l'héritage multiple, qui permet à une classe fille de posséder plusieurs
classes mères et d'hériter ainsi de leurs attributs et méthodes.
class ClasseFille(ClasseMere1, ClasseMere2):
def __init__(self, p1, p2, p3):
ClasseMere1.__init__(self, p1)
ClasseMere2.__init__(self, p2)
Important : dans le cas d'un héritage multiple, super() ne peut pas être utilisé car il serait
ambigu (plusieurs classes mères possibles). Il faut appeler explicitement les constructeurs
de chaque classe mère.

4.9 Fonctions utilitaires

• isinstance(objet, Classe) : vérifie si un objet est une instance d'une classe donnée
• issubclass(ClasseFille, ClasseMere) : vérifie si une classe est sous-classe d'une
autre

Fin du résumé — Langage Python · Said AGOUJIL · 2024-2025