Programmation Scientifique avec Python

riadh BEN NESSIB

2025-10-28
Table of contents

1 Introduction 5
1.1 Plan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2 Introduction à Python 6
2.1 Environnement Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1.1 EDI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1.2 Packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1.3 Distribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1.4 Online . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1.5 Préparer l’Environnement de Travail . . . . . . . . . . . . . . . . . 6
2.1.6 Crée un répertoire de travail : CoursPSP . . . . . . . . . . . . . . . 6
2.2 Le Langage Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2.2 Caractéristiques principales . . . . . . . . . . . . . . . . . . . . . . 6
2.3 Syntaxe et Implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3.1 Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3.2 Implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3.3 Le lien entre syntaxe et implémentation . . . . . . . . . . . . . . . 7
2.4 Typage Fort et Dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.4.1 Typage Fort (Sécurité des Opérations) . . . . . . . . . . . . . . . . 8
2.4.2 Typage Dynamique (Flexibilité du Code) . . . . . . . . . . . . . . . 8
2.5 Les Mots-clés de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.5.1 Définition et Rôle � . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.5.2 Le module keyword . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.6 Espace des noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.6.1 Fonctionnement et Rôle . . . . . . . . . . . . . . . . . . . . . . . . 10
2.6.2 Les Trois Niveaux d’Espaces de Noms . . . . . . . . . . . . . . . . 10
2.6.3 Fonctions pour Examiner les Espaces de Noms . . . . . . . . . . . . 11
2.7 Espace mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.7.1 Tout est Objet en Python . . . . . . . . . . . . . . . . . . . . . . . 11
2.7.2 Anatomie des Objets . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.7.3 Taille des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.7.4 Attention : Profondeur et Contenu des Conteneurs . . . . . . . . . 13
2.7.5 Hiérarchie des objets . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.7.6 Les Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.7.7 Le module operator . . . . . . . . . . . . . . . . . . . . . . . . . . 13

1
3 Variables et Fonctions 15
3.1 Entrés-Sorties des données . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.2 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.2.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.2.2 Affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.3 Nommage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.3.1 Règles de nommage . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.3.2 Notation CamelCase et snake_case . . . . . . . . . . . . . . . . . . 16
3.4 Affichage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.4.1 print() : La Fonction d’Affichage . . . . . . . . . . . . . . . . . . 16
3.4.2 .format() : La Méthode de Formatage . . . . . . . . . . . . . . . 16
3.4.3 Exemple : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.4.4 f-string : La Meilleure Pratique Actuelle (Python 3.6+) . . . . . . . 17
3.4.5 Avantages Majeurs des f-strings : . . . . . . . . . . . . . . . . . . . 17
3.5 Notation Scientifique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.6 Les types de données Python . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.6.1 Liste des objets les plus utilisés . . . . . . . . . . . . . . . . . . . . 18
3.7 Types simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.7.1 string . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.7.2 Type bool (True/False) . . . . . . . . . . . . . . . . . . . . . . . . 19
3.7.3 Type int (Nombres Entiers) . . . . . . . . . . . . . . . . . . . . . . 19
3.7.4 Type float (Nombres Réels) . . . . . . . . . . . . . . . . . . . . . 20
3.7.5 Type complex (Nombres Complexes) . . . . . . . . . . . . . . . . . 22
3.7.6 Fonctions Mathématiques Internes . . . . . . . . . . . . . . . . . . 22
3.7.7 Fonctions Mathématiques Standard: Le module ‘math’ . . . . . . . 25
3.8 Types composés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.8.1 tuple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.8.2 liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.8.3 intervalle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.8.4 ensemble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.8.5 dictionnaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.9 Data flow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.9.1 if else elif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.9.2 for while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.10 Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.10.1 définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.10.2 paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.10.3 variables internes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.10.4 arguments args et kwargs . . . . . . . . . . . . . . . . . . . . . . . 27
3.10.5 lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.11 Les modules en python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.12 Les fichiers de données en python . . . . . . . . . . . . . . . . . . . . . . . 27

4 Conclusion 28

2
List of Figures

3
List of Tables

4
Chapter 1

Introduction

Ce cours est conçu pour vous guider, que vous soyez étudiant, chercheur ou professionnel,
à travers les fondamentaux de la programmation en Python, en mettant l’accent sur ses
applications scientifiques. Nous commencerons par les bases du langage pour rapidement
nous plonger dans l’utilisation des bibliothèques incontournables comme NumPy pour le
calcul numérique, Matplotlib pour la visualisation de données, ainsi que Pandas pour la
manipulation et l’analyse de données. Nous explorerons également des sujets plus avancés
tels que le calcul scientifique avec SciPy et Sympy. ## Objectifs

1.1 Plan

5
Chapter 2

Introduction à Python

2.1 Environnement Python

2.1.1 EDI
2.1.2 Packages
2.1.3 Distribution
2.1.4 Online
2.1.5 Préparer l’Environnement de Travail
La première étape pour ce cours de programmation scientifique est d’établir un environ-
nement de travail fiable.
• Installation des distributions Python : Python 3.x est la version de référence.
Pour la science, des distributions spécialisées comme Anaconda sont souvent
recommandées, car elles incluent nativement les bibliothèques cruciales comme
NumPy et Pandas.
• Utilisation des EDIs (Environnements de Développement Intégrés) :
Des outils comme VS Code ou PyCharm offrent des fonctionnalités avancées
(débogage, autocomplétion) qui accélèrent le développement.
• Les options en ligne (Online) : Des plateformes comme Jupyter Notebooks
(souvent via Google Colab) permettent d’exécuter du code Python dans un navigateur,
idéales pour la documentation et le partage de projets scientifiques.

2.1.6 Crée un répertoire de travail : CoursPSP

2.2 Le Langage Python
2.2.1 Introduction
Le langage Python est un langage de programmation interprété, orienté objet et multi-
paradigme. Il est souvent utilisé pour son côté simple et intuitif, mais aussi pour sa grande
flexibilité et sa puissance. Python est disponible sous licence libre et est disponible sur de
nombreux systèmes d’exploitation.

2.2.2 Caractéristiques principales

• Interprété : Le code Python est exécuté ligne par ligne, ce qui permet de corriger les
erreurs en temps réel.
• Orienté objet : Python supporte le paradigme orienté objet, ce qui permet de créer
des classes et des objets pour organiser le code.

6
 • mathématiques : Python est doté d’une bibliothèque de fonctions mathématiques
puissantes, ce qui en fait un langage idéal pour les applications scientifiques et
techniques.

2.3 Syntaxe et Implémentation

2.3.1 Syntaxe
La syntaxe est l’ensemble des règles formelles qui régissent la manière dont un programme
doit être écrit pour être valide et interprétable par l’interpréteur Python. C’est l’équivalent
de la grammaire d’une langue naturelle.
• Rôle : Elle détermine si le code est correctement structuré. Si vous violez la syntaxe,
l’interpréteur générera une SyntaxError et refusera d’exécuter le code.
• Exemples en Python :
– Indentation : L’utilisation correcte des espaces pour définir les blocs de code
(boucles, fonctions, conditions).
– Mots-clés : L’utilisation correcte de mots réservés comme if, for, def, class,
etc.
– Déclaration de variables : La règle qu’un nom de variable ne doit pas
commencer par un chiffre.
– Ponctuation : L’utilisation de deux-points (:) à la fin d’une ligne d’instruction
de bloc, ou l’utilisation correcte des guillemets pour les chaînes de caractères.
Analogie : En français, la syntaxe exige que le verbe s’accorde avec le sujet.
Si vous écrivez “Je sont…”, vous avez une erreur de syntaxe. En Python, si vous
écrivez def ma_fonction (sans les deux-points), vous avez une SyntaxError.

2.3.2 Implémentation
L’implémentation, ou sémantique, est la manière dont la logique du programme
est réalisée en utilisant la syntaxe du langage. Elle se concentre sur ce que fait le
programme, et non sur la validité de sa structure.
• Rôle : Elle s’assure que le code, une fois exécuté, produit le résultat attendu et
résout le problème spécifié. Un programme peut être syntaxiquement correct mais
sémantiquement incorrect (il ne fait pas ce qu’il est censé faire).
• Exemples en Python :
– Erreur de logique : Si vous écrivez resultat = a - b alors que le problème
exigeait une addition (a + b). Le code est valide, mais l’implémentation est
fausse.
– Choix de structures de données : Décider d’utiliser une liste (list) plutôt
qu’un dictionnaire (dict) pour stocker des données.
– Algorithme : Le choix de l’algorithme de tri (tri à bulles, tri rapide, etc.) à
utiliser pour ordonner une liste de nombres.

2.3.3 Le lien entre syntaxe et implémentation

Un programme doit être à la fois :
1. Syntaxiquement correct pour être interprété.

7
 2. Sémantiquement correct (bonne implémentation) pour produire un résultat utile.
Si le code passe l’étape de l’interprétation (pas d’erreur de syntaxe), mais qu’une erreur
survient pendant l’exécution (par exemple, division par zéro ou tentative d’accéder à un
index de liste inexistant), on parle alors d’erreur d’exécution ou d’erreur logique (liée
à l’implémentation), et non d’erreur de syntaxe.

2.4 Typage Fort et Dynamique

Python est un langage à la fois fortement typé et à typage dynamique.

2.4.1 Typage Fort (Sécurité des Opérations)

Un langage fortement typé interdit les opérations entre des types incompatibles sans
conversion explicite.
Python
nombre = 10
texte = "ans"
# Tentative d'additionner des types incompatibles:
# print(nombre + texte)
# -> TypeError: La multiplication ou l'addition est bien définie,
# mais pas entre int et str (typage fort).

2.4.2 Typage Dynamique (Flexibilité du Code)

Le type d’une variable est vérifié à l’exécution. L’intérêt principal est le Polymorphisme
(la capacité d’une fonction à traiter des objets de types différents). C’est la base du Duck
Typing : “Si ça marche comme un canard et que ça cancane comme un canard, alors
c’est un canard.”
Un intérêt du typage dynamique: les arguments des fonctions Python
def double(x): # le type de x n'est pas précisé
"""Fonction polymorphique qui fonctionne si x supporte l'opérateur *."""
return x * 2
print(double(4)) # x est un <class 'int'>, résultat: 8
print(double('4')) # x est un <class 'str'>, résultat: 44
print(double([1, 2])) # x est une <class 'list'>, résultat: [1, 2, 1, 2]

2.5 Les Mots-clés de Python

Un mot-clé (ou keyword en anglais) est un mot qui est réservé par le langage de program-
mation Python, et qui a une signification spéciale et prédéfinie pour l’interpréteur.

2.5.1 Définition et Rôle �

Les mots-clés sont les blocs de construction du langage et sont utilisés pour :
1. Définir la structure et le flux de contrôle (boucles, conditions).
2. Déclarer des entités (fonctions, classes, modules).
3. Représenter des valeurs spécifiques (booléens, absence de valeur).
Règle essentielle : Vous ne pouvez jamais utiliser un mot-clé Python comme nom de
variable, de fonction, de classe ou de toute autre entité que vous définissez. Tenter de le
faire résultera en une erreur de syntaxe (SyntaxError).

8
 ** Exemples de Mots-Clés en Python**
Python possède un nombre relativement petit de mots-clés (actuellement 35 dans Python
3.12).

Catégorie Mot-clé Signification

Logique/Contrôle if, else, elif Utilisé pour les instructions
conditionnelles.
for, while, break, Utilisé pour les boucles et
continue leur contrôle.
Définition def Définit une fonction.
class Définit une classe.
import, from Importe des modules
externes.
Valeurs True, False Les deux valeurs
booléennes.
None Représente l’absence de
valeur ou de nullité.
Gestion d’Erreurs try, except, finally, Gère les erreurs d’exécution
raise (exceptions).

Par exemple, le mot if indique à l’interpréteur qu’une instruction conditionnelle commence.

Si vous essayez d’écrire if = 10, l’interpréteur ne le comprendra pas car il attend une
condition après le mot if.

2.5.2 Le module keyword

Le module keyword fourni la liste complète des mots-clés en Python. 35 mots clés : input
print, abs, sum ….. 4 mots softs : _ case match type Note : on ne peut pas nommer une
variable avec un mot réservé!
1
2 from keyword import kwlist,softkwlist
3
4 print('Key Words:')
5 for i,kw in enumerate(kwlist,start=1):
6 print(i,' : ',kw)
7 print('Soft Key Words:')
8 for i,skw in enumerate(softkwlist,start=1):
9 print(i,' : ',skw)
1 Key Words:
2 1 : False
3 2 : None
4 3 : True
5 4 : and
6 5 : as
7 6 : assert
8 7 : async
9 8 : await
10 9 : break
11 10 : class
12 11 : continue
13 12 : def
14 13 : del
15 14 : elif
16 15 : else
17 16 : except
18 17 : finally
19 18 : for
20 19 : from
21 20 : global
22 21 : if
23 22 : import
24 23 : in
25 24 : is
26 25 : lambda
27 26 : nonlocal

9
28 27 : not
29 28 : or
30 29 : pass
31 30 : raise
32 31 : return
33 32 : try
34 33 : while
35 34 : with
36 35 : yield
37 Soft Key Words:
38 1 : _
39 2 : case
40 3 : match
41 4 : type

2.6 Espace des noms

L’espace de noms (ou namespace) est un concept fondamental en Python qui définit un
système pour nommer les objets (variables, fonctions, classes, etc.) et garantir que
ces noms sont uniques et accessibles dans un contexte donné.
Imaginez l’espace de noms comme un dictionnaire de Python : il établit une correspon-
dance entre les noms que vous utilisez et les objets réels en mémoire.

2.6.1 Fonctionnement et Rôle

[Link] 1. Organisation et Non-Conflit
Le rôle principal de l’espace de noms est d’éviter les conflits de noms.
• Sans espace de noms, si deux modules différents définissaient chacun une fonction
appelée ouvrir(), le programme ne saurait pas laquelle utiliser.
• Grâce aux espaces de noms, vous pouvez avoir module_A.ouvrir() et
module_B.ouvrir(), et Python sait exactement à quel objet vous faites
référence.

[Link] 2. Le Dictionnaire Nom-Objet

Chaque espace de noms est implémenté en interne comme un dictionnaire.

Clé (Key) Valeur (Value)

Le Nom de l’objet (la chaîne de caractères, La Référence de l’objet lui-même en
ex: 'ma_variable') mémoire (son identité/adresse).

Lorsque vous écrivez x = 10, le nom 'x' est inséré dans l’espace de noms actuel, pointant
vers l’objet 10.

2.6.2 Les Trois Niveaux d’Espaces de Noms

En Python, les noms sont résolus selon une hiérarchie stricte appelée LEGB (Local,
Enclosing, Global, Built-in). C’est l’ordre dans lequel Python recherche un nom lorsqu’il
est appelé :

10
Niveau Nom Python Durée de Vie Contenu Typique
Local Espace de noms Temporaire : créé Variables définies à
Local lors de l’appel d’une l’intérieur de la
fonction, détruit à la fonction.
fin de son exécution.
Enclosing Espace de noms Similaire au Local, Variables des
Englobant mais concerne les fonctions parentes
fonctions imbriquées immédiates.
(ou nested
functions).
Global Espace de noms Jusqu’à la fin de Variables définies au
Global l’exécution du script niveau supérieur du
ou du module. module (hors de
toute fonction).
Built-in Espace de noms Démarré au Fonctions et classes
Intégré lancement de intégrées de Python
l’interpréteur et (ex: print, len,
jamais détruit. str, object).

[Link] Exemple de Résolution (LEGB)

Python
x = 10 # GLOBAL
def fonction_externe():
y = 20 # ENCLOSING
def fonction_interne():
z = 30 # LOCAL
print(len("test")) # len est dans BUILT-IN
print(y) # Python cherche y (non trouvé en Local), puis le trouve en
fonction_interne()
# Python cherche x (non trouvé en Local/Enclosing), puis le trouve en GLOBAL
print(x)

2.6.3 Fonctions pour Examiner les Espaces de Noms

Vous pouvez inspecter le contenu des espaces de noms courants à l’aide des fonctions
suivantes :

Fonction Espace de Noms Renvoyé

locals() Retourne un dictionnaire des noms dans
l’espace Local (les variables de la fonction
actuelle).
globals() Retourne un dictionnaire des noms dans
l’espace Global (les variables du module
actuel).
vars(module) Retourne le dictionnaire des noms d’un
objet (module, classe ou instance).

2.7 Espace mémoire

2.7.1 Tout est Objet en Python
En Python, toute donnée ou entité manipulée est un objet. Un objet est une structure de
données en mémoire qui possède trois caractéristiques essentielles :
1. Identité (id): Son adresse en mémoire (unique).

11
 2. Type (type): Sa classe (ex: int, str).
3. Valeur: Les données qu’il contient.

2.7.2 Anatomie des Objets

Chaque objet est défini par ses attributs :

Attribut Description Exemple

Propriétés (Variables) Les données qui décrivent [Link]
l’état de l’objet.
Méthodes (Fonctions) Les actions ou [Link]()
fonctionnalités que l’objet
peut exécuter.

� Note: La classe de base de tous les objets en Python est object.

La fonction interne dir() permet de lister tous les attributs (méthodes et propriétés) d’un
objet ou d’une classe.
Python
# 'Bonjour' est un objet de type str
texte = "Bonjour"
print(dir(texte))
# Affiche la liste des attributs, y compris 'upper', 'lower', etc.
1 S=dir(str)
2 print(S)
3 I=dir(int)
4 print(I)
5 F=dir(float)
6 print(F)
7 B=dir(bool)
8 print(B)

2.7.3 Taille des objets

Pour trouver la taille en mémoire d’un objet Python quelconque, on utilise la fonction
intégrée [Link]().
Cette fonction est l’outil standard pour obtenir la taille d’un objet en octets. Vous devez
l’importer du module standard sys.
Python
import sys
# Exemple 1 : Taille d'un entier simple
nombre = 42
taille_int = [Link](nombre)
print(f"La taille de l'objet int (42) est : {taille_int} octets")
# Affiche généralement : La taille de l'objet int (42) est : 28 octets
# Exemple 2 : Taille d'une chaîne de caractères
texte = "Hello Python"
taille_str = [Link](texte)
print(f"La taille de la chaîne '{texte}' est : {taille_str} octets")
# Affiche : La taille de la chaîne 'Hello Python' est : 61 octets
# (Note : 49 octets de base + 2 octets par caractère)
# Exemple 3 : Taille d'une liste vide
liste_vide = []
taille_liste = [Link](liste_vide)
print(f"La taille d'une liste vide est : {taille_liste} octets")

12
# Affiche généralement : La taille d'une liste vide est : 56 octets

2.7.4 Attention : Profondeur et Contenu des Conteneurs

Il est crucial de noter que [Link]() ne retourne que la taille de l’objet
conteneur lui-même (l’espace nécessaire pour la structure et les références), et non la
taille totale des objets qu’il contient.
Si vous avez besoin de la taille totale et récursive d’un objet (conteneur + contenu), vous
devez écrire votre propre fonction qui utilise [Link]() et parcourt récursivement
tous les éléments du conteneur (list, dict, tuple, etc.).

2.7.5 Hiérarchie des objets

Python est un langage orienté objet (OOP). Les objets sont organisés en hiérarchie, avec
une classe de base appelée object.
Voici une représentation simplifiée de la hiérarchie des objets en Python :
object
��� int
��� float
��� bool
��� str
��� list
��� tuple
��� dict
��� set
��� function
��� class
��� module
��� file

2.7.6 Les Opérateurs

Catégories d’Opérateurs :
1. Numériques: +, -, *, /, //, %, **
2. Affectation: =, +=, -=, *=
3. Comparaison: ==, !=, >, <, is, in
4. Accès/Conteneur: ., [], () . : [Link] [] : objet[clé] () : objet(arguments)
Derrière chaque opération Python se cache une méthode spéciale (ou méthode mag-
ique), nommée avec des doubles __underscores__. C’est ainsi que l’interpréteur sait
comment un objet de tel type doit se comporter.

Méthode Utilisation
Opération Magique Classique Équivalent Objets
Addition __add__ x + y x.__add__(y)
Accès à un attribut __getattribute__ x.y x.__getattribute__('y')
Indexation __getitem__ x[y] x.__getitem__(y)

2.7.7 Le module operator

� Le module standard operator regroupe ces méthodes magiques sous forme
de fonctions pour une utilisation simplifiée (ex: [Link](2, 5) est
équivalent à 2 * 5).

13
1 import operateur
2 L=dir(operateur)
3 print(L)
4 for index,name in enumerate(L):
5 print(index, '--->',name)
6 print(L[98])
7 from operateur import mul
8 print(mul(2,5))

14
 Chapter 3

Variables et Fonctions

3.1 Entrés-Sorties des données

3.2 Variables
3.2.1 Définition
Une variable est une zone de mémoire de l’ordinateur dans laquelle une valeur donnée
est stockée.

3.2.2 Affectation
variable=valeur
Types d’affectations
1. Simple > x=1 > y=2 > z=3 >
2. Multiple > x,y,z=1,2,3
3. Parallèle > x=y=z=0
Note : une variable est définie par un nom (identificateur) pour le programmeur et une
adresse par python.
namespce (noms) : identificateur , adresse memoire (objets) : type,taille,valeur…..
1
2 x=2025
3 print('nom de la variable : x')
4 print('valeur de la variable : ', x)
5 print('adresse de la variable : ',id(x))
6
7 # On va modifier la variable x!
8 x=x+1
9 print('nom de la variable : x')
10 print('valeur de la variable : ', x)
11 print('adresse de la variable : ',id(x))
12

3.3 Nommage
3.3.1 Règles de nommage
• Les noms de variables doivent commencer par une lettre (a-z, A-Z) ou un underscore
(_).
• Ils peuvent contenir des lettres, des chiffres (0-9) et des underscores, mais ne peuvent
pas commencer par un chiffre.

15
 • Les noms de variables ne doivent pas être des mots réservés de Python (comme if,
for, while, etc.).
• Les noms doivent être significatifs et refléter leur contenu ou leur usage.
• Python est sensible à la casse (X=1 et x=1 sont deux variables différentes)
• Les noms de variables ne doivent pas contenir d’espaces.
• Les noms de variables ne doivent pas contenir de caractères spéciaux (comme !, @,
#, $, etc.).
• Les noms de variables ne doivent pas commencer par un underscore suivi d’un chiffre
(par exemple, _1variable est invalide).

3.3.2 Notation CamelCase et snake_case

• CamelCase : Chaque mot commence par une majuscule, sans espaces ni underscores.
Utilisé principalement pour les noms de classes.
– Exemple : MaClasse, MonObjet
• snake_case : Tous les mots sont en minuscules, séparés par des underscores. Utilisé
pour les noms de variables et de fonctions.
– Exemple : ma_variable, fonction_de_traitement

3.4 Affichage
3.4.1 print() : La Fonction d’Affichage
print() est la fonction la plus fondamentale pour afficher des données sur la console
(sortie standard).

Concept Description
Rôle Prendre un ou plusieurs arguments, les
convertir en chaînes de caractères si
nécessaire, et les afficher séquentiellement.
Caractéristiques Par défaut, elle insère un espace entre
chaque argument (défini par le paramètre
sep=' ') et ajoute un saut de ligne (\n)
à la fin (défini par le paramètre end='\n').

Paramètres Clés :
• sep (séparateur) : Modifie la chaîne insérée entre les arguments.
– Exemple : print(1, 2, 3, sep='-') affichera 1-2-3.
• end (fin) : Modifie la chaîne ajoutée à la fin de la sortie (remplace le saut de ligne
par défaut).
– Exemple : print('Début', end='...') affichera Début... et le prochain
print continuera sur la même ligne.

3.4.2 .format() : La Méthode de Formatage

La méthode .format() est une technique de formatage de chaînes plus ancienne mais
encore très utilisée. Elle permet de remplacer des champs de remplacement désignés
par des accolades {} dans une chaîne, par des valeurs de variables.

16
Concept Description
Rôle Insérer des valeurs de variables dans une
chaîne et appliquer des règles de formatage
complexes (précision décimale, alignement,
etc.).
Syntaxe "[chaîne avec des
{}]".format(valeur1, valeur2, ...)

3.4.3 Exemple :
Python
position = 5.60
vitesse = 2.5
temps=11.25
position =position+vitesse*temps
# Utilisation des indices de position ou des noms (optionnel)
message = "Le mobile est à la position {} après {} s ."
print([Link](position, temps))
Dans cet exemple, :.2f est un spécificateur qui demande d’afficher la valeur numérique
avec deux décimales (.2f).

3.4.4 f-string : La Meilleure Pratique Actuelle (Python 3.6+)

Les f-strings (pour formatted string literals) sont la méthode recommandée en Python
moderne pour combiner des expressions et du texte dans une seule chaîne de caractères.
Elles sont plus concises et plus rapides que .format().

Concept Description
Rôle Rendre le formatage de chaîne direct, lisible
et performant.
Syntaxe Préfixer la chaîne par la lettre f et placer
les variables ou expressions directement
entre les accolades {}.

Exemple :
nom = "Riadh"
age = 30
annee_naissance = 2025 - age
# On préfixe la chaîne par 'f'
print(f"{nom} a {age} ans et est née en {annee_naissance}.")

3.4.5 Avantages Majeurs des f-strings :

1. Concision : Les variables sont écrites directement dans la chaîne.
2. Expressions : Vous pouvez insérer des expressions Python complètes (comme
2025 - age ci-dessus) directement dans les accolades.
3. Formatage Intégré : Tous les spécificateurs de formatage utilisés par .format()
(:.2f, :>10s pour l’alignement, etc.) fonctionnent également dans les f-strings.
Exemple de formatage avancé avec f-string :
Python

17
 pi = 3.14159265
# Affichage avec 3 décimales et aligné à droite sur 10 caractères
print(f"La valeur de Pi est : {pi: >10.3f}")
# Affiche : La valeur de Pi est : 3.142 (Notez les espaces avant 3.142)

3.5 Notation Scientifique

3.6 Les types de données Python
Python fournit plusieurs types de données de base, tels que les entiers, les flottants, les
chaînes de caractères, les booléens, les listes, les tuples, les dictionnaires et les ensembles.
Voici quelques exemples de types de données de base en Python :
• Entiers : 1, 2, 3, 4, 5
• Flottants : 1.0, 2.5, 3.14
•
• Chaînes
… de caractères : “Hello World!”
Voici un exemple de code Python qui déclare et affiche les types de différentes variables :
1 i=1
2 r=1.0
3 c=1j
4 s='1'
5 b=2>3
6 un_tuple=(1,2,3)
7 une_liste=[1,2,'trois']
8 un_ensemble={1,2,3,4}
9 un_dictionnaire={'nom':'riadh','age':38,'taille':1.72,'est_marié':True}
10 un_intervalle=range(1,16,3)
11 print(type(i),type(r),type(s),type(c),type(b),type(un_tuple),type(une_liste),type(un_e
12

3.6.1 Liste des objets les plus utilisés

1. bool
2. int
3. float
4. complex
5. str
6. list
7. tuple
8. range
9. dict
10. set
11. iterator
12. generator
13. NoneType
14. function
15. Objet-fichier-texte
16. module
17. class
18. object

3.7 Types simples

3.7.1 string
Pour manipuler les chaines de caratères taper dir(str) et trouver les méthodes les plus
importantes.
1
2 # liste des méthodes de str

18
3 liste_attributs=dir(str)
4 print(liste_attributs)

3.7.2 Type bool (True/False)

3.7.3 Type int (Nombres Entiers)
1
2 # liste des attributs (propriétés et méthodes) de int
3 liste_attributs=dir(int)
4 print(liste_attributs)
Les méthodes de int sont : ['bit_length', 'conjugate', 'denominator',
'from_bytes', 'imag', 'numerator', 'real', 'to_bytes'].
• Si 𝑛 est un int, la méthode n.bit_length() retourne le nombre de chiffres présents
dans l’écriture binaire de 𝑛.
• La méthode de classe int.from_bytes(B, byteorder="big") retourne la conver-
sion en base 10 d’une séquence d’octets 𝐵. L’argument optionnel signed=True
interprète 𝐵 comme la traduction d’une écriture binaire en complément à deux (pour
représenter les entiers négatifs).
• Si 𝑛 est un int, la méthode n.to_bytes(Nb, byteorder="big") convertit 𝑛 en
hexadécimal et écrit le résultat sous la forme d’une chaîne de 𝑁 𝑏 bytes.
Exemples :
>>> n = 345
>>> n.bit_length()
9 # 345 en binaire est 0b101011001 (9 chiffres)
>>> int.from_bytes(b"\x01\x59", byteorder="big")
345
>>> int.from_bytes(b"\xfc", byteorder="big", signed=True)
-4 # b'\xfc' est la notation en complément à deux de -4 sur un octet
>>> (345).to_bytes(2, byteorder="big")
b'\x01Y' # soit b'\x01\x59'

[Link] Opérations élémentaires

Les opérations fondamentales sous Python sont:

Opération Code Exemple

Addition + 4 + 11
Soustraction - 2 − 13
Multiplication * 4∗5
Division / 1/10
Division entière // 34//5 est le quotient euclidien de 34 par 5
Reste entier % 34%4 pour 34 modulo 4
Exposant ** 5 ∗ ∗4 pour 54

Exemples :
>>> 5**(1/2) # calcul de la racine carrée de 5
2.23606797749979
>>> x = -6
>>> -x
6
>>> 23.2 // 5.3 # quotient euclidien
4.0
>>> 23.2 % 5.3 # reste euclidien
2.0

19
 3.7.4 Type float (Nombres Réels)
1
2 # liste des attributs (propriétés et méthodes) de float
3 liste_attributs=dir(float)
4 print(liste_attributs)
On écrit un nombre à virgule (float) comme ceci :
>>> x = 2.315
>>> y = 12.0
Le séparateur décimal est un point (et non une virgule), Python étant un langage d’origine
anglo-saxonne. On peut utiliser l’écriture scientifique : le nombre 2, 3 × 10−3 , par exemple,
s’écrit:
>>> x = 2.3e-3
>>> x = 2.3E-3 # sans espaces
Les méthodes de float sont: ['as_integer_ratio', 'conjugate', 'fromhex',
'hex', 'imag', 'is_integer', 'real'].
• Si x est un float, la méthode x.as_integer_ratio() retourne une paire
(numérateur, dénominateur) sous forme de tuple qui représente la fraction
irréductible correspondant à x.
• La méthode de classe [Link](s) retourne le float correspondant écrit en
base 10, à partir d’une chaîne s contenant l’écriture hexadécimale.
• Si x est un float, la méthode [Link]() retourne la conversion en base 16 de x sous
forme de str.
• Si x est un float, la méthode x.is_integer() retourne True si x est entier, False
sinon.
Exemples :
>>> x = 4.5
>>> x.as_integer_ratio()
(9,2)
>>> [Link]("0xa5fc.015d")
42492.00532531738
>>> [Link]()
'0x1.2000000000000p+2'
Remarque La méthode fromhex est une méthode de classe contrairement à hex, par
exemple, qui est une méthode d’instance.

[Link] Type int versus type float

• Python effectue les opérations sur les int (entiers) de manière exacte. Il n’y a
aucune limitation dans la taille des entiers (sauf mémoire ou lenteur).
• Avec les float (nombres décimaux), on n’obtient pas toujours le résultat exact, mais
plutôt un ordre de grandeur.
– Exemple de multiplication avec int (résultat exact).
– Exemple de multiplication avec float (résultat approché) : a * b donne
1.2193263124676116e+36.
Python est capable de traiter des nombres décimaux de valeur absolue comprise entre
10−323 et approximativement 1, 7976931 × 10308 .
• Les nombres inférieurs à 10−324 sont traités comme 0.

20
 • Les nombres qui dépassent la limite deviennent inf (infini)35. Par exemple, x =
10.0**308 est 1e+308 36363636, mais x + x et x * x donnent inf.
Observation intéressante :
Python
>>> 0 == 0.0
True
>>> 0 is 0.0
False # 0 et 0.0 sont deux objets distincts

[Link] Représentation des floats

Python travaille en binaire et est incapable d’encoder de manière exacte les nombres
décimaux dont l’écriture binaire est illimitée. Par conséquent, un nombre simple comme 0,1
pose problème, car son écriture binaire est périodique : 0.0 0011 0011 0011 0011....
La machine est obligée de tronquer, ne stockant qu’une approximation41. Python ne
conserve que 55 décimales de l’écriture binaire, ce qui fait que 0,1 est en fait égal à:
0, 100 000 000 000 000 005 551 ...
Preuve de l’approximation :
Python
>>> 0.1 + 0.1 + 0.1 - 0.3
5.551115123125783e-17
>>> 0.1 + 0.1 + 0.1 == 0.3
False
Pour faire tomber le masque, on peut utiliser:
>>> (0.1).as_integer_ratio()
(3602879701896397, 36028797018963968)
>>> from decimal import Decimal
>>> Decimal(0.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
Les calculs avec les float ne sont que des approximations, mais suffisantes pour la plupart
des applications.
La parade à ces dysfonctionnements existe avec les modules decimal et fractions.

[Link] Module decimal

L’appel à getcontext() révèle les paramètres par défaut, notamment prec=28 (précision
exigée). Cette précision peut être modifiée : getcontext().prec = 100.
Un nouveau type numérique est introduit : Decimal.
Pour définir le nombre 0,1 de manière exacte, il faut convertir la chaîne "0.1" via la
fonction Decimal:
>>> from decimal import *
>>> x = Decimal("0.1")
>>> x
Decimal('0.1')
Attention : Decimal(0.1) n’obtiendra pas 0,1 mais l’approximation Python du float
0.152.
Le type Decimal supporte toutes les opérations élémentaires et les fonctions internes
dédiées au calcul numérique. Il possède également des méthodes propres.

21
[Link] Module fractions
Le module fractions introduit le type Fraction.
>>> from fractions import *
>>> Fraction(7, 9)
Fraction(7, 9)
>>> Fraction(70, 10)
Fraction(7, 1)
Le type Fraction supporte toutes les opérations élémentaires et les fonctions inverses. Le
module fractions contient aussi la fonction gcd (plus grand commun diviseur) :
>>> gcd(24, 8)
8

3.7.5 Type complex (Nombres Complexes)

On écrit un nombre complexe 𝑎 + 𝑖 𝑏 comme ceci :
>>> z = 2.3 + 4.01j On notera que c’est la lettre j qui joue le rôle de l’imaginaire 𝑖.
Les méthodes et attributs sont: ['conjugate', 'imag', 'real'].
• Si z est un complex, alors [Link] est la partie réelle de z et [Link] est la partie
imaginaire (ce sont des attributs-données et non des méthodes).
• La méthode [Link]() retourne le conjugué de z.
Exemples :
>>> z = 5 + 7j
(5+7j)
>>> [Link]
5
>>> [Link]
75 # Note: La valeur '75' est présente dans la source.
>>> [Link]()
(5-7j)
>>> abs(z) # module de z
8.602325267042627
>>> u = 1j # u=j est interdit
>>> u**2
-1

Élément Description Exemple

[Link] (Attribut) Partie réelle du nombre z = 5+7j; print([Link])
complexe z. →5
[Link] (Attribut) Partie imaginaire du z = 5+7j; print([Link])
nombre complexe z. →7
[Link]() (Méthode) Retourne le conjugué du z = 5+7j;
nombre complexe z. print([Link]())
→ (5 − 7𝑗)
abs(z) (Fonction intégrée) Retourne le module du z = 5+7j; print(abs(z))
nombre complexe z. → 8.602...

3.7.6 Fonctions Mathématiques Internes

Nous décrivons ici les fonctions abs, int, round, divmod, pow, float, sum, eval, complex,
min, max et range.

22
[Link] Fonction valeur absolue : abs
Retourne la valeur absolue. Si le nombre est de type complex, retourne le module.

[Link] Fonction troncature : int

Retourne la troncature à l’unité (équivalent à [Link]).
>>> int(55.7)
55
>>> int(-55.7)
-55

[Link] Fonction arrondir : round

Sert à arrondir à la décimale désirée.
>>> round(1.239, 2)
1.24
>>> round(2.675, 2)
2.67
• round(x, n) retourne un float, mais round(x) sans le deuxième argument retourne
un int.

[Link] Fonction division euclidienne : divmod

Retourne le quotient et le reste de la division euclidienne sous forme de tuple.
>>> divmod(88, 5)
(17, 3)
>>> divmod(45.6, 5)
(9.0, 0.6000000000000001)

[Link] Fonction float

Transforme un nombre ou une chaîne de caractères en un float.
>>> float('25/8')
3.125
>>> float(True)
1.0

[Link] Fonction puissance : pow

Si 𝑎 et 𝑏 sont des nombres, pow(a, b) retourne 𝑎𝑏 . Si trois arguments sont fournis, pow(a,
b, n) retourne 𝑎𝑏 modulo 𝑛.
>>> pow(5, 1.5)
11.180339887498949
>>> pow(3, 4, 5)
1

[Link] Fonction de sommation : sum

Pour sommer les termes de n’importe quel itérable.
>>> sum([1, 2, 10])
13
>>> sum(range(8, 15))
77

23
[Link] Fonction d’évaluation : eval
Pour évaluer une chaîne de caractères (à condition qu’elle soit évaluable).
>>> expression = "2+3*10"
>>> eval(expression)
32

[Link] Fonction complex

Pour transformer un str ou deux nombres en un complexe.
>>> complex(3, 8)
(3+8j)
>>> complex("3+8j")
(3+8j)

[Link] Fonctions min et max

Pour évaluer respectivement le minimum et le maximum de n’importe quel itérable.
>>> L = [-6.78, -120.3, 8.8, 78]
>>> min(L)
-120.3
>>> max(L)
78

[Link] Fonction range

Pour fabriquer des plages d’entiers (séquences régulières).
>>> r = range(3, 11, 2)
>>> list(r)
[3, 5, 7, 9]

[Link] Objet NaN et nombres infinis

En informatique, NaN signifie not a number. Pour Python, NaN ou nan ne sont pas des
mots réservés.
>>> NaN
NameError: name 'NaN' is not defined
Pourtant, Python connaît la notion de NaN:
>>> x = float("NaN") # x est de type float, qu'on appelle "nan"
>>> x
nan
>>> type(x)
<class 'float'>
Python connaît aussi les notions de ∞ et −∞ :
>>> INF = float("inf")
>>> INF
inf
>>> type(INF)
<class 'float'>
Ces deux dernières sont des float (par convention). Il n’y a pas d’équivalent chez int
(inutile de taper int('inf')).
On notera ceci :
• float('inf') est le plus grand des float.
• float('-inf') est le plus petit des float]

24
 Le module math possède les fonctions testant (isinf(x), isnan(x)) pour savoir si une
donnée est un infini ou un nan.
Python
>>> from math import isinf, isnan
>>> INF = float("inf")
>>> NINF = float("-inf")
>>> NAN = float("nan")
>>> isinf(INF)
True
>>> isinf(NINF)
True
>>> isnan(NAN)
True
>>> isnan(INF)
False
Python calcule avec les infinis selon les règles mathématiques usuelles.
>>> INF - INF
nan
>>> INF / INF
nan
>>> 1 / INF
0.0
>>> INF + INF
inf
Dès que dans un calcul apparaît un nan, le résultat final est nan. Les informations disent
que nan est absorbant.
La comparaison d’égalité (==) entre deux nan donne True. En revanche, les comparaisons
(<=, <, >=, >) entre deux nan donnent False.
>>> x = float("nan")
>>> y = float("nan")
>>> x == y
True
>>> x < y
False
Pour ce qui est de la comparaison is : rien d’anormal.
>>> x = float("nan")
>>> y = float("nan")
>>> x is y
False
>>> x is not y
True

3.7.7 Fonctions Mathématiques Standard: Le module ‘math’

Le module math contient toutes les fonctions mathématiques standard (trigonométriques,
hyperboliques, logarithmes et puissances).
1
2 # liste des méthodes de math
3 liste_méthodes=dir(math)
4 print(liste_méthodes)
Il contient également des fonctions utilitaires comme :
• [Link](a, b, rel_tol=1e-09, abs_tol=0.0) : Pour tester si deux flot-
tants 𝑎 et 𝑏 sont « proches »].
– rel_tol : Tolérance relative. Si le plus grand des deux nombres est grand,
cette tolérance est multipliée par sa valeur. Par défaut, elle vaut 10−9 .
– abs_tol : Tolérance absolue. Si les nombres sont petits, on lui préfère la
tolérance absolue].

25
Exemple d’utilisation de isclose :
>>> from math import isclose
>>> 0.1 + 0.1 + 0.1 == 0.3
False
>>> isclose(0.1 + 0.1 + 0.1, 0.3)
True

[Link] Constantes mathématiques

Les constantes usuelles se trouvent dans le module math :
• [Link] : 𝜋
• math.e : 𝑒 (base du logarithme népérien)
• [Link] : 𝜏 = 2𝜋
• [Link] : ∞
• [Link] : NaN

[Link] Fonctions usuelles

Le module math fournit les fonctions suivantes:

Fonctions mathématiques Description

[Link](x) Plafond : retourne le plus petit entier ≥ 𝑥
[Link](x) Plancher : retourne le plus grand entier ≤ 𝑥
[Link](x) Troncature : retourne la partie entière
[Link](x, y) Retourne la valeur absolue de 𝑥 avec le
signe de 𝑦
[Link](x, y) Reste de la division 𝑥/𝑦
[Link](a, b) Plus grand commun diviseur
[Link](x, y) Hypoténuse : √𝑥2 + 𝑦2
[Link](a, b) Plus petit commun multiple
[Link](x, y) Reste de 𝑥 par rapport à 𝑦 (selon la norme
IEEE 754)
[Link](n, k) Nombre de permutations
[Link](n, k) Nombre de combinaisons (binomial)
[Link](n) Factorielle 𝑛!
[Link](x) Fonction Gamma
[Link](x) Logarithme de la valeur absolue de Gamma
[Link](x) Fonction d’erreur
[Link](x) Fonction d’erreur complémentaire

[Link] Fonctions trigonométriques

Les arguments des fonctions trigonométriques sont en radians.

Fonctions trigonométriques
[Link](x) Sinus
[Link](x) Cosinus
[Link](x) Tangente
[Link](x) Arcsinus
[Link](x) Arccosinus
[Link](x) Arctangente
math.atan2(y, x) Arctangente de 𝑦/𝑥 (gestion des quadrants)
[Link](x) Conversion radians vers degrés
[Link](x) Conversion degrés vers radians

26
[Link] Fonctions hyperboliques

Fonctions hyperboliques
[Link](x) Sinus hyperbolique
[Link](x) Cosinus hyperbolique
[Link](x) Tangente hyperbolique
[Link](x) Arcsinus hyperbolique
[Link](x) Arccosinus hyperbolique
[Link](x) Arctangente hyperbolique

[Link] Fonctions de puissance et logarithmiques

Fonctions
[Link](x) Racine carrée
[Link](x) Exponentielle 𝑒𝑥
[Link](x) Logarithme népérien ln(𝑥)
[Link](x, b) Logarithme de base 𝑏
math.log10(x) Logarithme de base 10
math.log2(x) Logarithme de base 2
[Link](x, y) Puissance 𝑥𝑦
math.expm1(x) 𝑒𝑥 − 1
math.log1p(x) ln(1 + 𝑥)

3.8 Types composés

3.8.1 tuple
3.8.2 liste
3.8.3 intervalle
3.8.4 ensemble
3.8.5 dictionnaire
3.9 Data flow
3.9.1 if else elif
3.9.2 for while
3.10 Les fonctions
3.10.1 définition
3.10.2 paramètres
3.10.3 variables internes
3.10.4 arguments args et kwargs
3.10.5 lambda
3.11 Les modules en python
3.12 Les fichiers de données en python

27
Chapter 4

Conclusion

28