Cours Complet de Python

De A à Z : Maîtrisez tous les concepts fondamentaux

Variables • Types • Fonctions • Boucles • Conditions • Structures de données

Réalisé par madame BANHAR FADWA

 Les Variables en Python

Qu'est-ce qu'une variable ? Règles de nommage

Une variable est un conteneur nommé qui stocke une valeur en Doit commencer par une lettre ou un underscore (_)
mémoire. En Python, les variables sont dynamiquement typées .
Peut contenir des lettres, chiffres et underscores

# Déclaration simple Ne peut pas contenir d'espaces ou de caractères spéciaux

age = 25 Sensible à la casse : age ≠ Age
nom = "Alice"
Ne peut pas être un mot-clé Python
prix = 19.99
est_actif = True
# ✓ Valides
nom_utilisateur = "Bob"
Affectation multiple age2 = 30
_compteur = 0
# Plusieurs variables en une ligne
x, y, z = 10, 20, 30 # ✗ Invalides
2age = 30
# Même valeur pour plusieurs variables nom-utilisateur = "Bob"
a = b = c = 100 for = 5

# Échange de valeurs
x, y = y, x Conventions
 Les Types de Données
int Entier (Integer)
Conversion de types
Nombres entiers positifs, négatifs ou zéro.

age = 25 | compteur = -10 | grand = 999999999 Fonction Exemple

int() int("25") → 25
float Flottant (Floating Point)
Nombres décimaux avec virgule flottante. float() float("3.14") → 3.14

prix = 19.99 | pi = 3.14159 | sci = 2.5e-3

str() str(100) → "100"

bool() bool(0) → False

str Chaîne de caractères (String)
Séquence de caractères entre guillemets.
Vérifier le type
nom = "Alice" | message = 'Bonjour !'
x = 42
bool Booléen (Boolean) type (x) # <class 'int'>

Valeur logique : True ou False.

isinstance (x, int) # True
est_actif = True | termine = False isinstance (x, str) # False

complex Nombre complexe 💡 Astuce : Python détermine automatiquement le type lors de

Nombres avec partie réelle et imaginaire (j). l'affectation (typage dynamique).
 La Fonction print() en Détail

Paramètres de print() Formatage avec f-strings

nom = "Alice"
Paramètre Description Défaut
age = 25
sep Séparateur entre valeurs '' print(f"Je suis {nom}, {age} ans")
# Je suis Alice, 25 ans
end Caractère de fin '\n'
prix = 19.99
file Destination de sortie stdout print(f"Prix: {prix:.2f}€")
# Prix: 19.99€

Le paramètre sep
Méthode format()
print("Python", "Java", "C++", sep=" - ")
print("Nom: {}, Age: {}".format("Bob", 30))
# Python - Java - C++
print("A", "B", "C", sep="") # Nom: Bob, Age: 30
print("{1} {0}".format("monde", "Bonjour"))
# ABC
# Bonjour monde
print("{n} a {a} ans".format(n="Claire", a=28))
Le paramètre end # Claire a 28 ans

print("Bonjour", end=" ")

print("monde!") Opérateur %
# Bonjour monde!
for i in range(5): print("Nombre: %d" % 42)

print(i, end=" | ") # Nombre: 42

print("%s a %d ans" % ("David", 35))
 La Fonction input() et Interaction
Syntaxe de base Validation des données
La fonction input() permet de récupérer les données saisies par # Méthode 1 : try-except
l'utilisateur. Elle retourne toujours une chaîne de caractères try:
(str). age = int(input("Âge : "))
print("Âge valide :", age)
# Syntaxe except ValueError:
variable = input("Message : ") print("Erreur : nombre invalide")

# Exemple # Méthode 2 : isdigit()

nom = input("Votre nom : ") nombre = input("Nombre : ")
print("Bonjour", nom) if [Link]():
print("C'est un nombre")
⚠️Important : input() retourne toujours une chaîne ! else:
print("Pas un nombre")
Conversion des types
Exemples pratiques
# Convertir en entier
age = int(input("Âge : ")) # Calculatrice simple
a = float(input("Premier nombre : "))
# Convertir en flottant b = float(input("Deuxième nombre : "))
prix = float(input("Prix : ")) somme = a + b
print(f"Résultat : {somme}")
# Vérifier le type
print(type(age)) # <class 'int'> # Saisie multiple
 Les Chaînes de Caractères

Indexation et Slicing Méthodes principales

Chaque caractère possède un indice (position). Les indices commencent upper() lower()
à 0. Majuscules Minuscules

texte = "PYTHON" strip() split()

Enlève espaces Divise en liste
0 1 2 3 4 5

P Y T H O N replace() find()
Remplace texte Trouve position

-6 -5 -4 -3 -2 -1
count() join()
Compte occurrences Joint éléments

texte = "PYTHON"
print(texte[0]) # P Exemples pratiques
print(texte[-1]) # N
print(texte[1:4]) # YTH nom = " alice "
print(texte[:3]) # PYT print([Link]().upper()) # ALICE
print(texte[3:]) # HON
print(texte[::2]) # PTO (pas de 2) phrase = "Python est génial"
mots = [Link]()
# ['Python', 'est', 'génial']
Caractères d'échappement
print("Ligne 1\nLigne 2") # \n = saut de ligne texte = "Bonjour tout le monde"

print("Tab\tici") # \t = tabulation nouveau = [Link]("monde", "Python")

print("Il dit \"Bonjour\"") # \" = guillemet # "Bonjour tout le Python"

 Les Opérateurs en Python
Arithmétiques Comparaison Exemples pratiques
Op. Description Exemple Op. Description Résultat a = 10
b=3
+ Addition 5+2=7 == Égal à 5 == 2 → False
# Arithmétiques
- Soustraction 5-2=3 != Différent de 5 != 2 → True
print(a + b) # 13

* Multiplication 5 * 2 = 10 > Supérieur à 5 > 2 → True print(a // b) # 3

print(a % b) # 1
/ Division 5 / 2 = 2.5 < Inférieur à 5 < 2 → False print(a ** 2) # 100

// Division entière 5 // 2 = 2 >= Supérieur ou égal 5 >= 5 → True # Comparaison

print(a > b) # True
% Modulo 5%2=1 <= Inférieur ou égal 5 <= 2 → False
print(a == b) # False
** Puissance 5 ** 2 = 25
Logiques # Logiques
x = True
Op. Description y = False
print(x and y) # False
and ET logique (True si les deux sont True) print(x or y) # True
print(not x) # False
or OU logique (True si au moins un est True)

Priorité :
not NON logique (inverse la valeur) 1. ** (puissance)
2. *, /, //, %
 Les Structures Conditionnelles
La structure if Conditions multiples
Exécute un bloc de code si une condition est True . Combiner avec and, or, not.

age = 18 age = 20
if age >= 18: permis = True
print("Vous êtes majeur")
# Opérateur AND
La structure if-else if age >= 18 and permis:
print("Vous pouvez conduire")
Exécute un bloc si vrai, sinon un autre bloc.
# Opérateur OR
age = 16
if age < 12 or age > 65:
if age >= 18:
print("Tarif réduit")
print("Majeur")
else:
print("Mineur") Conditions imbriquées
age = 25
La structure if-elif-else etudiant = True

Permet de tester plusieurs conditions successives.

if age >= 18:
note = 15 if etudiant:
if note >= 16: print("Adulte étudiant")
print("Très bien") else:
elif note >= 14: print("Adulte actif")
print("Bien")
elif note >= 12: Opérateur ternaire
print("Assez bien")
 La Boucle while
Syntaxe et principe while avec else
La boucle while répète un bloc de code tant que la condition est Le bloc else s'exécute si la boucle se termine normalement.
vraie. n=5
# Syntaxe de base while n > 0:
while condition: print(n)
# Instructions à répéter n -= 1
else:
# Exemple : Compter de 0 à 4 print("Terminé !")
compteur = 0
while compteur < 5: Exemples pratiques
print(compteur)
compteur += 1 Accumulateur
# Affiche : 0, 1, 2, 3, 4
# Somme des nombres de 1 à 10
⚠️Attention : Modifiez la condition pour éviter les boucles infinies ! somme = 0
i=1

break et continue while i <= 10:

somme += i
# break : sortir de la boucle i += 1
i=0 print(somme) # 55
while i < 10:
if i == 5: Validation d'entrée
break
nombre = -1
print(i)
while nombre < 0:
i += 1
nombre = int(input("Nombre positif : "))
print(f"Vous avez saisi : {nombre}")
# continue : passer à l'itération suivante
i=0
Boucle infinie contrôlée
while i < 5:
 La Boucle for
Syntaxe de base Parcourir des séquences
La boucle for permet d'itérer sur une séquence (liste, chaîne, # Parcourir une chaîne
range, etc.). for lettre in "Python":
print(lettre, end=" ")
# Syntaxe générale
#Python
for element in sequence:
# instructions
# Parcourir une liste
fruits = ["pomme", "banane"]
# Exemple simple
for fruit in fruits:
for i in range(5):
print(fruit)
print(i)
# Sortie: 0 1 2 3 4
break et continue
La fonction range() # break : arrête la boucle
for i in range(10):
Syntaxe Description Exemple
if i == 5:
range(stop) De 0 à stop-1 range(5) → 0,1,2,3,4 break
print(i) # 0 1 2 3 4
De start à stop-
range(start, stop) range(2, 7) → 2,3,4,5,6
1
# continue : passe à l'itération suivante
range(start, stop, range(0, 10, 2) → for i in range(5):
Avec pas if i == 2:
step) 0,2,4,6,8
continue
# Compter à rebours print(i) # 0 1 3 4
for i in range(5, 0, -1):
print(i) Boucles imbriquées
# Sortie: 5 4 3 2 1
# Table de multiplication
 Les Listes
Création et accès Méthodes principales Exemples pratiques
Une liste est une collection ordonnée et Méthode Description nombres = [5, 2, 8, 1, 9]
modifiable d'éléments.
append(x) Ajoute x à la fin
# Ajouter
# Création insert(i, x) Insère x à la position i [Link](3)
fruits = ["pomme", "banane"] # [5, 2, 8, 1, 9, 3]
nombres = [1, 2, 3, 4, 5] remove(x) Supprime 1ère occurrence
mixte = [1, "texte", True] pop(i) Supprime et retourne élément # Insérer
vide = [] [Link](0, 10)
clear() Vide la liste
# [10, 5, 2, 8, 1, 9, 3]
# Accès par indice sort() Trie la liste
print(fruits[0]) # pomme # Supprimer
print(fruits[-1]) # banane reverse() Inverse l'ordre
[Link](8)
count(x) Compte occurrences de x dernier = [Link]()
# Slicing # dernier = 3
index(x) Retourne l'indice de x
print(nombres[1:4]) # [2, 3, 4]
print(nombres[:3]) # [1, 2, 3] # Trier
print(nombres[::2]) # [1, 3, 5] Opérations [Link]()
# [1, 2, 5, 9, 10]
a = [1, 2, 3]
Modification b = [4, 5, 6]
# Inverser
fruits[0] = "fraise" [Link]()
# Concaténation
# ["fraise", "banane"] # [10, 9, 5, 2, 1]
c = a + b # [1,2,3,4,5,6]

fruits[1:2] = ["kiwi"]
# ["fraise", "kiwi"]
# Répétition Compréhension
d = a * 2 # [1,2,3,1,2,3]
# Liste de carrés
# Longueur carres = [x**2 for x in range(5)]
 Les Tuples et Ensembles
Les Tuples Les Ensembles (Sets)
Un tuple est une collection ordonnée et immuable . Un ensemble est une collection non ordonnée d'éléments
uniques .
Création
Création
# Avec parenthèses
coordonnees = (10, 20) # Avec accolades
fruits = ("pomme", "banane") nombres = {1, 2, 3, 4, 5}
fruits = {"pomme", "banane"}
# Sans parenthèses
point = 5, 10 # Avec set()
ensemble = set([1, 2, 2, 3])
# Tuple d'un élément # {1, 2, 3}
singleton = (42,)
# Ensemble vide
Accès et opérations vide = set()

t = (1, 2, 3, 4, 5)
Opérations
# Accès par indice a = {1, 2, 3, 4}
print(t[0]) # 1 b = {3, 4, 5, 6}
print(t[-1]) # 5
# Union
# Slicing print(a | b) # {1, 2, 3, 4, 5, 6}
print(t[1:4]) # (2, 3, 4)
# Intersection
# Méthodes print(a & b) # {3, 4}
print([Link](2)) # 1
print(len(t)) # 5 # Différence
print(a - b) # {1, 2}
Unpacking
# Différence symétrique
 Les Dictionnaires
Structure clé-valeur Modification Parcourir un dictionnaire
Un dictionnaire stocke des paires clé: # Ajouter/Modifier notes = {
valeur . Les clés doivent être uniques. personne["age"] = 26 "Alice": 18,
personne["email"] = "a@[Link]" "Bob": 15
# Création }
personne = { # Supprimer
"nom": "Alice", del personne["ville"] # Parcourir les clés
"age": 25, for nom in notes:
"ville": "Paris" # pop() print(nom)
} age = [Link]("age")
# age = 26 # Clés et valeurs
# Dictionnaire vide for nom, note in [Link]():
vide = {} # Vider print(f"{nom}: {note}")
vide2 = dict() [Link]()
# Parcourir les valeurs
# Avec dict()
d = dict(a=1, b=2)
Méthodes principales for note in [Link]():
print(note)
Méthode Description
Accès aux valeurs Exemples pratiques
keys() Retourne toutes les clés
# Avec crochets # Compter occurrences
values() Retourne toutes les valeurs
print(personne["nom"]) texte = "python"
# Alice items() Retourne paires clé-valeur
compteur = {}
get(k, d) Valeur de k ou d si absent for lettre in texte:
# Avec get() (sûr) compteur[lettre] = \
age = [Link]("age") update(d) Fusionne avec dict d
[Link](lettre, 0) + 1
# 25 pop(k) Supprime et retourne k # {'p':1, 'y':1, ...}

# Valeur par défaut # Fusionner

 Les Fonctions
Définition et syntaxe Valeurs de retour
# Retour simple
Une fonction est un bloc de code réutilisable qui effectue une
def carre(x):
tâche spécifique. return x * x
# Syntaxe de base
def nom_fonction(parametres): # Retours multiples
return resultat def stats(liste):
return min(liste), max(liste), sum(liste)
# Exemple simple
def saluer(nom): mini, maxi, total = stats([1, 2, 3, 4, 5])
return f"Bonjour, {nom} !" # mini=1, maxi=5, total=15

message = saluer("Alice") Portée des variables

print(message) # Bonjour, Alice !
# Variable globale
compteur = 0
Paramètres et arguments
def incrementer():
# Plusieurs paramètres global compteur
def addition(a, b): compteur += 1
return a + b
# Variable locale
resultat = addition(5, 3) # 8 def calculer():
x = 10 # Locale
# Paramètres par défaut return x * 2
def puissance(nombre, exposant=2):
return nombre ** exposant Exemple pratique
print(puissance(5)) # 25 def est_pair(nombre):
print(puissance(5, 3)) # 125 return nombre % 2 == 0

def filtrer_pairs(liste):
Arguments nommés resultat = []
for n in liste:
def afficher_info(nom, age, ville):
if est_pair(n):
print(f"{nom}, {age} ans, {ville}")
[Link](n)
 Python et les Mathématiques
Fonctions de base Algorithme : Factorielle Suite de Fibonacci
Fonction Description def factorielle(n): def fibonacci(n):
"""Calcule n!""" """Retourne les n premiers termes"""
abs(x) Valeur absolue
if n == 0 or n == 1: if n <= 0:
round(x, n) Arrondir à n décimales return 1 return []
resultat = 1 elif n == 1:
pow(x, y) x puissance y
for i in range(2, n + 1): return [0]
min() Minimum resultat *= i suite = [0, 1]
max() Maximum return resultat for i in range(2, n):
[Link](suite[-1] + suite[-2])
sum() Somme d'une liste
print(factorielle(5)) # 120 return suite
print(factorielle(0)) # 1
print(abs(-15)) # 15
print(fibonacci(10))
print(round(3.14159, 2)) # 3.14
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
print(pow(2, 3)) # 8 Algorithme : PGCD
nombres = [1, 5, 3, 9, 2] def pgcd(a, b): Moyenne et écart-type
print(min(nombres)) # 1 """Plus Grand Commun Diviseur"""
print(max(nombres)) # 9 while b != 0: def moyenne(liste):
print(sum(nombres)) # 20 a, b = b, a % b return sum(liste) / len(liste)
return a
Module math def ecart_type(liste):
print(pgcd(48, 18)) # 6 moy = moyenne(liste)
variance = sum((x - moy)**2
import math
for x in liste) / len(liste)
Nombres premiers return variance ** 0.5
# Constantes
print([Link]) # 3.14159... def est_premier(n):
notes = [12, 15, 18, 14, 16]
print(math.e) # 2.71828... """Vérifie si n est premier"""
print(moyenne(notes)) # 15.0
if n < 2:
# Fonctions return False
print([Link](16)) # 4.0 for i in range(2, int(n**0.5) + 1): Puissance rapide
print([Link](3.2)) # 4 if n % i == 0:
print([Link](3.8)) # 3 return False def puissance_rapide(base, exp):
return True """Calcul de puissance optimisé"""
Module random if exp == 0:
print(est_premier(17)) # True return 1
print(est_premier(20)) # False elif exp % 2 == 0:
import random
moitie = puissance_rapide(base, exp // 2)