ISIMM
Programmation Python 1
CPI1
2026
Plan
01 Introduction
02 Les variables
03 Les fonctions print et input
04 Les conteneurs de bases
05 Les structures conditionnelles
06 Les structures itératives
01 Introduction
Python est l’un des langages de programmation les plus populaires au monde.
Simple à utiliser, riche en fonctionnalités et soutenu par un large écosystème de
bibliothèques et de frameworks.
Sa syntaxe claire et épurée le rend particulièrement adapté aux débutants.
Langage de haut niveau, utilisé en Data science, Automatisation, Intelligence
artificielle, Développement web
Reconnu pour sa lisibilité, ce qui facilite: L’écriture du code, Sa compréhension et
Sa maintenance.
Grâce à son fort support de bibliothèques, il n’est pas nécessaire de tout
développer à partir de zéro.
01 Introduction
Python est un langage de programmation:
libre
multi-plateformes
multi-paradigmes
distribué avec une riche bibliothèque standard
01 Introduction
Histoire de Python
Python est un langage de programmation qui a été créé en 1989 par Guido van
Rossum aux Pays-Bas.
La première version publique de ce langage a été publiée en 1991.
01 Introduction
Compilation & Interprétation
01 Introduction
Installation
Afin de pouvoir développer en langage Python, il est nécessaire d'installer les
outils suivants :
Télécharger et installer le langage Python depuis le site officiel Python.
Télécharger et installer un IDE Python : de nombreux choix s’offre à vous :
Pycharm, PyScripter, Wing.
02 Les variables
Qu'est-ce qu’une variable ?
Une variable est définie par un nom dans un langage de programmation, lors
que pour l'ordinateur il s'agit d'une référence désignant une adresse
mémoire (i.e. un emplacement précis dans la mémoire).
On attribue une valeur à une variable en utilisant l’opérateur d’affectation (=).
- Les variables sont utilisées sans être déclarés et leurs types dépenden
de leurs contenus : Typage dynamique.
- Une variable peut changer de type sans qu’il ait d’erreurs.
- Python est sensible à la casse, ce qui signifie que les variables TesT,
test ou TEST sont différentes.
02 Les variables
Les types élémentaires
Python propose 4 types simples de base qui sont :
Les entiers (integer ou int),
Les réels (float)
Les booléens (bool)
Les nombres complexes (complex)
Les chaines de caractères (str)
02 Les variables
Les types élémentaires
Classe int: Le type int (entier) n’est pas limité en taille que par la mémoire de la
machine.
Classe float: Un float est noté avec un point décimal (jamais avec une virgule)
un “e” symbolisant le “10 puissance”. Les flottants supportent les mêmes
opérations que les entiers. Ils ont une précision infinie limitée.
Classe booléenne: Deux valeurs possibles: False et True.
Classe complexe: Les complexes sont écrits en notation cartésienne formée
de deux flottants. La partie imaginaire est suffixée par j.
Classe str: Une chaîne de caractère est une suite de caractères entourée par
deux apostrophes $'$ ou deux guillemets $"$. Les éléments d’une chaîne s
sont indexés de 0 à len(s)-1, accessibles par l’opérateur [].
02 Les variables
Opérations sur les variables
Python classe les opérateurs selon les groupes suivants:
Opérateurs logiques
Opérateurs arithmétiques
Opérateurs d’affectation
Raccourcis d’auto-affectation
Conversion de type
Les fonctions print et input
La fonction print: Permet d’afficher des informations sur la sortie standard, sous forme de texte.
Les fonctions print et input
La fonction print: Permet d’afficher des informations sur la sortie standard, sous forme de texte.
Les fonctions print et input
La fonction input: Permet de récupérer un str à partir de l’entrée standard.
Les fonctions print et input
La fonction input: Permet de récupérer un str à partir de l’entrée standard.
Les conteneurs de bases
Les classes itérables ou conteneurs permettent de conserver une collection d’objets. Ces classes peuvent se ramifier selon
deux critères :
La mutabilité : classes modifiables (list, set, dict) et classes non modifiables (range, str et tuple).
L’ordre : classes ordonnées appelées encore séquences (str, tuple, list, range) et classes non ordonnées (set et dict).
Les conteneurs de bases
Les classes itérables ou conteneurs permettent de conserver une collection d’objets. Ces classes peuvent se ramifier selon
deux critères :
La mutabilité : classes modifiables (list, set, dict) et classes non modifiables (range, str et tuple).
L’ordre : classes ordonnées appelées encore séquences (str, tuple, list, range) et classes non ordonnées (set et dict).
Les conteneurs de bases
Les itérables ordonnés / Les séquences
Les itérables ordonnés, appelés encore séquences (tuple, liste et chaîne), conservent l’ordre dans
lequel les éléments ont été créés. Ainsi, chaque élément d’une séquence possède un indice indiquant
sa position relative par rapport aux autres éléments. Les indices commencent à partir de 0 pour un
parcours de la gauche vers la droite. Un intervalle défini par range, également considéré comme une
séquence, est un itérable ou conteneur formé par une succession d’entiers. range(debut, fin, pas)
génère l’intervalle [debut, fin [ par pas entier relatif égal à pas.
Les conteneurs de bases
Les itérables ordonnés / Les séquences
Les conteneurs de bases
Les itérables ordonnés / Les séquences
Les conteneurs de bases
Les itérables ordonnés / Les séquences
La classe str: Une chaîne est une séquence non modifiable et ordonnée de caractères. Le tableau
suivant résume les principales opérations applicables aux chaînes.
Les conteneurs de bases
Les itérables ordonnés / Les séquences
Les conteneurs de bases
Les itérables ordonnés / Les séquences
Les conteneurs de bases
Les itérables ordonnés / Les séquences
La classe list: Une liste est une séquence, ordonnée et modifiable, d’éléments éventuellement
hétérogènes séparés par une virgule et délimitée par une paire de crochets.
Les conteneurs de bases
Les itérables ordonnés / Les séquences
Les conteneurs de bases
Les itérables ordonnés / Les séquences
La classe tuple: Un tuple est une séquence, ordonnée et non modifiable, d’éléments éventuellement
hétérogènes séparés par une virgule.
Les conteneurs de bases
Les itérables non ordonnés
La classe set: Un ensemble est une collection d'éléments distincts non ordonnés et encadrés par des
accolades. La classe set représente la notion d’ensemble en mathématique. Un ensemble doit
impérativement comporter des éléments non modifiables. La création d'ensembles de listes, de
dictionnaires ou d'ensembles déclenche une erreur.
Les conteneurs de bases
Les itérables non ordonnés
Les conteneurs de bases
Les itérables non ordonnés
La classe dict: Un dictionnaire est une structure modifiable et non ordonnée d'associations (clé :
valeur). Les clés sont impérativement des objets non modifiables. L'utilisation de listes, de
dictionnaires ou d'ensembles comme clé déclenche une erreur. Les valeurs sont des objets de
classes quelconques.
Les conteneurs de bases
Les itérables non ordonnés
Les conteneurs de bases
Construction des itérables en compréhension
La construction des itérables en compréhension permet de générer des conteneurs de façon concise
et élégante. On peut créer des listes en compréhension, des tuples en compréhension, des
ensembles en compréhension et des dictionnaires en compréhension à l'aide du constructeur de la
classe ou les délimiteurs des itérables mutables.
1. Listes en compréhension:
[expression for indice_1 in iterable_1 if condition_1 … for indice_n in iterable_n if condition_n ]
ou encore
list(expression for indice_1 in iterable_1 if condition_1 … for indice_n in iterable_n if condition_n )
Les conteneurs de bases
Construction des itérables en compréhension
Les conditions if sont facultatives (conditions de filtrage).
L’ordre d’imbrication des boucles est de la gauche vers la droite.
On peut utiliser le constructeur list à la place des délimiteurs.
expression peut elle même être un itérable en compréhension.
Les conteneurs de bases
Construction des itérables en compréhension
>>> L= [ i for i in range(1, 21, 2) ]
L [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
>>> L=[ (i,j) for i in range(1,3) for j in range(1,4) ]
L [(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3)]
>>> L=[i*j for i in range(1,5) for j in range(1,5) ] ;
L [1, 2, 3, 4, 2, 4, 6, 8, 3, 6, 9, 12, 4, 8, 12, 16]
>>> L=[(i,j) for i in range(1,5) if i%2 for j in range(1,5) if (i+j)%2==0];
L [(1, 1), (1, 3), (3, 1), (3, 3)]
>>>[[(100*i+j)//2 if j%2==0 else 100*i+j for j in range(1,i+1)] for i in range(1,5)]
[[101], [201, 101], [301, 151, 303], [401, 201, 403, 202]]
Les conteneurs de bases
Construction des itérables en compréhension
2. Tuples en compréhension:
tuple( expression for indice_1 in iterable_1 if condition_1 … for indice_n in iterable_n if condition_n )
Attention : sans le constructeur tuple, la construction en compréhension produit un générateur et non
pas un tuple.
Exemple:
tuple((i,j) for i in range(1,5) if i%2 for j in range(1,5) if (i+j)%2==0 )
((1, 1), (1, 3), (3, 1), (3, 3))
Les conteneurs de bases
Construction des itérables en compréhension
[Link] en compréhension:
set(expression for indice_1 in iterable_1 if condition_1 … for indice_n in iterable_n if condition_n )
ou encore
{ expression for indice_1 in iterable_1 if condition_1 … for indice_n in iterable_n if condition_n}
Exemple:
e={(x,y) for x in range(5) if x%2 for y in range(5) if y%2==0 }
# ou bien
e=set((x,y) for x in range(5) if x%2 for y in range(5) if y%2==0)
{(1, 2), (3, 2), (3, 0), (1, 4), (1, 0), (3, 4)}
05 Les structures conditionnelles
05 Les structures conditionnelles
age = 25
if age <= 12:
print("Child.")
elif age <= 19:
print("Teenager.")
elif age <= 35:
print("Young adult.")
else:
print("Adult.")
# Output: Young adult.
05 Les structures conditionnelles
05 Les structures conditionnelles
code = 404
match code:
case 200:
print("OK")
case 404:
print("Not Found")
case 500:
print("Server Error")
case _:
print("Unknown status")
05 Les structures conditionnelles
Python permet de créer des expressions dont l’évaluation dépend d’une condition.
Principe :
Si la condition est True → on évalue expression1
Sinon → on évalue expression2
Syntaxe générale :
expr1 if condition else expr2
⚠️ Cette construction ne permet pas l’utilisation de elif mais on peut imbriquer
plusieurs expressions conditionnelles.
expr1 if cond1 else expr2 if cond2 else expr3
05 Les structures conditionnelles
Exemple 1:
x=5
y=3
m = x if x > y else y
Exemple 2:
L1 = [-1, 0, 5, 3]
L2 = [0 if x < 0 else x for x in L1]
Exemple 3:
x = int(input("? "))
result = ">0" if x > 0 else "<0" if x < 0 else "=0"
print(result)
06 Les structures itératives
Boucle non conditionnelle (for)
Permet d’exécuter un bloc pour chaque élément d’un itérable.
Syntaxe :
for v in iterable:
bloc
Exemple : calcul du produit des éléments d’une liste
p=1
for v in [1, 8, 7]:
p *= v
print(p)
Avantage :
- Simple et lisible
- Très utilisée pour parcourir des collections
06 Les structures itératives
Boucle conditionnelle (while)
Permet d’exécuter un bloc d’instructions tant que la condition est vraie (True).
Caractéristiques :
- La condition est testée avant chaque itération
- Si la condition est False, le bloc n’est jamais exécuté
Syntaxe :
while condition:
bloc
Exemple : calcul du PGCD de deux entiers
while x % y != 0:
x, y = y, x % y
print(y)
06 Les structures itératives
Boucle avec condition d’arrêt (break)
Permet d’exécuter un bloc jusqu’à ce qu’une condition d’arrêt devienne vraie.
Principe :
- La condition d’arrêt est testée après l’exécution du bloc
- On utilise l’instruction break pour sortir de la boucle
Syntaxe :
while True:
bloc
if condition_arret:
break
06 Les structures itératives
Boucle avec condition d’arrêt (break)
Permet d’exécuter un bloc jusqu’à ce qu’une condition d’arrêt devienne vraie.
Exemple : saisie d’une voyelle
while True:
v = input("Saisir une voyelle : ")
if v in ['a', 'e', 'i', 'o', 'u', 'y']:
break
Exercice 1:
Étant donnée une liste Python, écrivez une fonction qui permute chaque paire d’éléments adjacents. La permutation doit se
faire directement dans la liste.
Exemple 1
Entrée : lst = [1, 2, 3, 4]
Sortie attendue : [2, 1, 4, 3]
Exemple 2
Entrée : lst = [5, 8, 9]
Sortie attendue : [8, 5, 9]
Exercice 2 - Corrigé:
def permute_paires(lst):
for i in range(0, len(lst) - 1, 2):
lst[i], lst[i+1] = lst[i+1], lst[i]
return lst
Exercice 2:
Étant donné un tableau d’entiers nums de longueur n et un entier target, trouvez trois entiers distincts dans nums tels que leur
somme soit la plus proche possible de target. Retournez la somme de ces trois entiers.
Exemple 1
Entrée : nums = [-1, 2, 1, -4], target = 1
Sortie : 2
Explication :
La somme la plus proche de la cible est 2 :
−1+2+1=2-1 + 2 + 1=2
Exemple 2
Entrée : nums = [0, 0, 0], target = 1
Sortie : 0
Explication :
La somme la plus proche de la cible est 0 :
0+0+0=00 + 0 + 0 =0
Exercice 2 - Corrigé:
def threeSumClosest(nums, target):
[Link]()
best = nums[0] + nums[1] + nums[2]
for i in range(len(nums) - 2):
l, r = i + 1, len(nums) - 1
while l < r:
s = nums[i] + nums[l] + nums[r]
if abs(s - target) < abs(best - target):
best = s
if s < target:
l += 1
elif s > target:
r -= 1
else:
return s
return best
Exercice 3:
La suite Count and Say (compter et décrire) est une suite de chaînes de caractères définie récursivement
comme suit :
countAndSay(1) = "1"
countAndSay(n) est obtenu en appliquant le codage par longueurs (Run-Length Encoding – RLE) sur
countAndSay(n - 1).
Codage RLE: Le Run-Length Encoding (RLE) consiste à remplacer une séquence de caractères identiques
consécutifs par nombre d’occurrences) + (le caractère).
Exemple 1
Pour la chaîne : "3322251"
On obtient : "23321511"
Exercice 2 - Corrigé:
def countAndSay(n):
result = "1"
for _ in range(1, n):
current = ""
count = 1
for i in range(1, len(result)):
if result[i] == result[i - 1]:
count += 1
else:
current += str(count) + result[i - 1]
count = 1
# Ajouter le dernier groupe
current += str(count) + result[-1]
result = current
return result