Formation :

Python
Partie1 : Syntaxe du langage Python

Formateur
Rim AYARI ABID

01/04/2025
1
 Plan

Présentation du formateur
Le plan de la formation

01/04/2025
2
 Présentation du formateur

Rim AYARI ABID

 Docteur et ingénieur en Informatique

 Enseignant Universitaire
 Consultant en Python, Algorithmique, Programmation OO

01/04/2025
3
 Présentation des stagiaires

01/04/2025
4
 Plan de la formation_Partie 1

I. Présentation du langage
II. Les fonctions print() et input()
III. Les différents types natifs
IV. Les variables
V. Les types séquentiels
VI. Les structures conditionnelles
VII.Les boucles

01/04/2025 5
 Présentation du langage

Langage de programmation objet interprété

Simple, Puissant, Extensible, Gratuit

Disponible sur toutes les plateformes principales.

Gère ses ressources comme la mémoire et les descripteurs de fichiers sans

intervention de l’utilisateur, pas de pointeurs explicites

Supporte la surcharge des opérateurs et l’héritage multiple. Un programme écrit

avec le langage python est trois à cinq fois plus court qu’un programme écrit en
C/C++ ou java

Un temps de développement cinq à dix fois plus court.

 La configuration

Mise en place de l’environnement de travail

Commandes lunix pour installer Python
1) sudo apt-get install python3.12 (ou uniquement 3) : Pour installer python sous Ubuntu

2) sudo apt-get install python3-pip : Pour installer PIP (Package intaller Python)

3)sudo apt install idle-python3.12: Pour installer IDLE 3.12 du python

4)Pour démarrer l’IDLE sur le shell : idle-python3.12

Les fonctions print() et input()
 Les fonctions print() et input()

La fonction print()

Pour afficher, on utilise la fonction print().
print("bonjour")
a=5
print(a)

Il est possible de réaliser plusieurs affichages à la suite. Pour cela, on
sépare les éléments par des virgules.
a=5
print("a vaut", a)

IL est possible de formater l'affichage en utilisant des {} et la méthode
format()
nom = "Alice"
age = 30
print("Bonjour, je m'appelle {} et j'ai {} ans.".format(nom, age))
 Les fonctions print() et input()

La fonction print()

IL est possible également d'utiliser f-string (introduit en python 3.6) pour
formater l'affichage,
nom = "Alice"
age = 30
print(f"Bonjour, je m'appelle {nom} et j'ai {age} ans.")

IL est possible aussi de formater les nombres lorsque vous les afficherez
aux utilisateurs
 Les fonctions print() et input()

La fonction print() : Alignement du texte avec :<, :^, :>

Avec print on peut contrôler l’alignement d’un texte dans un espace
défini :

Exemple:
a:<10 → "Python" est aligné à gauche dans un espace de 10
a = "Python" caractères.
b = "Java" b:^10 → "Java" est centré dans un espace de 10 caractères.
c = "C++" c:>10 → "C++" est aligné à droite dans un espace de 10 caractères.
print(f"{a:<10}{b:^10}{c:>10}")
 Les fonctions print() et input()

La fonction print() : Ajout de remplissage avec un caractère spécifique

On peut aussi ajouter un caractère de remplissage avant le symbole

d’alignement (<, ^, >).
Exemple 1:
nom = "Alice"
print(f"{nom:.<10}")
print(f"{nom:.^10}")
print(f"{nom:.>10}")
Exemple 2:
print(f"{'Nom':<10}{'Score':>10}")
print("-" * 20)
print(f"{'Alice':<10}{95:>10}")
print(f"{'Bob':<10}{88:>10}")
print(f"{'Charlie':<10}{72:>10}")
 Les fonctions print() et input()

La fonction print()

La fonction print a un paramètre optionnel appelé end,

Il est utilisé pour spécifier la chaîne de caractères à ajouter à la fin de l'affichage.

Par défaut, end est "\n", ce qui signifie qu'un saut de ligne est ajouté après chaque
appel à la fonction print.

En utilisant une boucle for, on peut changer la valeur de end pour afficher les éléments
sur la même ligne.

l = [12, 7, 8, 4, 9]
for i in l:
print(i, end=' ')
 Les fonctions print() et input()

La fonction input()

Cette fonction permet de lire une chaine de caractères et l’enregistrer dans une
variable.
prenom = input("Entrez votre prénom : ")
print("Bonjour,", prenom)


La fonction input() renvoie toujours une chaîne de caractères.

Si vous souhaitez que l’utilisateur entre une valeur numérique, vous devrez donc
convertir la valeur entrée .

b = float(input("Entrez une donnée numérique : "))
Les commentaires
 Les commentaires en python


Les langages de programmation fournissent une méthode pour l’insertion de
commentaires au seins du code afin de fournir des informations supplémentaire.


Un commentaire est un texte qui sera ignoré lors de l’exécution du programme.


Les commentaires peuvent être utilisés pour expliquer une partie compliquée d’ un
programme


Les commentaires peuvent être utilisés pour mettre des indications dans le code,
comme le code source, la version du langage ou script
 Les commentaires en python


En Python, nous insérons un commentaire sur une seule ligne avec le
caractère # (un signe dièse).

# Ceci est un commentaire

# définir une variable de type entier

n=5

#Affichage de la variable

print("La valeur de n est :", n)


Pour insérer un commentaire sur plusieurs lignes en Python, on utilise le
symbole des guillemets doubles :
"""
Ceci est un commentaire en
plusieurs lignes
qui sera ignoré lors del'exécution
"""
Les chaînes de caractères
 Les chaînes de caractères


Une chaîne de caractères est une séquence de caractères et un caractère est un
symbole.

Pour créer une chaîne de caractères, on doit entourer les caractères
d'apostrophes (aussi appelées guillemets simples) ou de guillemets doubles :

variable_un = 'apostrophes'

variable_deux = "guillemets"

Il n'y a aucune différence entre les deux, c'est une question de style

Les guillemets doubles permettent d'insérer des guillemets simples dans les
phrases sans avoir besoin de les échapper avec un antislash /.

age = "J'ai 26 ans" # Avec guillemets doubles

age = 'J\'ai 26 ans' # Avec guillemets simples
 Les chaînes de caractères


Quand une chaine contient un nombre elle reste encore une chaine. Nous
pouvons convertir des nombres en chaines en utilisant int()

Pour les chaines de caracéres, le + est utlisé pour la concatenation

C1= “Bonjour”

C2 = “ Comment cava ?”

print(c1+c2)

On insère le \\ pour que le \ s’insére correctement dans la chaîne

Vous pouvez également écrire des chaînes de caractères sur plusieurs lignes en
utilisant trois guillemets au lieu d'un seul :

longue_phrase = '''Bonjour,
bienvenue à cette
formation
'''

Le \n n'apparait comme un saut de ligne que lorsqu'il est dans une chaîne de
caractères passée à la fonction print()
 Manipulation des chaînes de caractères

Changer la casse

La méthode upper()

"Bonjour".upper()
#BONJOUR
La méthode lower()
"BonJour".lower()
#bonjour
La méthode capitalize()
"bonjour tout le monde".capitalize()
#Bonjour tout le monde
 La méthode title()
"Bonjour tout le monde".title()
#Bonjour Tout Le Monde
 Manipulation des chaînes de caractères

Remplacer les éléments

 "Bonjour".replace ("jour", "soir")
#Bonsoir

 "Bonjour Bonjour".replace ("jour", "soir")

#Bonsoir Bonsoir

 "Bonjour Bonjour".replace (" ", "")

#BonjourBonjour

 "Bonjour Bonjour".replace (" ", "").replace("jour", "soir") #BonsoirBonsoir

 Manipulation des chaînes de caractères

Remplacer les éléments (strip())

" Bonjour ".strip() #Bonjour

" Bon jour ".strip() #Bon jour

" Bonjour ".strip(" ujor ") #Bon

" Bonjour ".rstrip(" ujor ") #Bon

" Bonjour ".lstrip(" ujor ") # Bonjour

 Manipulation des chaînes de caractères

Séparer et joindre les chaînes de caractères

"1, 2, 3, 4, 5".split(",") #['1', '2', '3', '4', '5']

 ".".join("Bonjour") #'B.o.n.j.o.u.r'

", ".join("1, 2, 3, 4, 5".split(", ")) #'1, 2, 3, 4, 5'

",".join([1,2,3,4,5]) #Erreur

",".join(['1','2','3','4','5']) #1,2,3,4,5
 Manipulation des chaînes de caractères

Découpage d’une chaîne de caractères


On peut extraire n’importe quelle section continue d’une chaine en utilisant
un opérateur deux points ( :)

Le deuxième nombre indique la fin de la sous chaine sans qu’il est inclus

Si le deuxième nombre est au-delà de la fin de la chaine, il s’arrête à la fin
S = "Formation Python"
print(S[0:4])
print(S[6:20])
print(S[:2])
print(S[8:])
print(S[:])
Les nombres
 Les nombres

Les nombres entiers


Un nombre entier est un nombre qui ne possède pas de décimales (chiffres
après la virgule)

En anglais, on appelle ces nombres des 'integer' (int en raccourci).

Les nombres entiers peuvent être positifs ou négatifs. 0 est également
considéré comme un nombre entier.

Quelques exemples de nombres entiers :
print(0)
print(-1)
print(6)
print(-9384)
print(100000)
 Les nombres

Les nombres entiers


La classe int est surtout utilisée pour convertir un objet en nombre entier.

a_float = 10.7542
a_int = int(a_float)
print(a_int)


En convertissant un nombre décimal en nombre entier, on se retrouve
uniquement avec les chiffres avant le point. Python n'arrondit donc pas le
nombre, il se contente d'enlever les décimales.

Vous ne pouvez passer à la classe int que des nombres décimaux, des
chaînes de caractères qui contiennent des nombres et des booléens (qui
sont un sous- type des nombres entiers).
 Les nombres

Les nombres entiers


Si vous essayez de convertir un autre type d'objet en nombre entier, vous
aurez une erreur de type ValueError :

# Conversions valides
print(int(5.0))
print(int(True))
print(int(False))
print(int("1587"))
print(int("-541.254"))

# Erreurs de type ValueError ou TypeError

print(int(None))
print(int("Bonjour"))
print(int([1, 2, 3]))
 Les nombres

Les nombres décimaux


Un nombre décimal est un nombre qui peut s'écrire avec un nombre fini de
chiffres après la virgule.

Avec Python, on utilise un point (notation anglaise) pour séparer les
décimales et non une virgule.

En anglais, on appelle ces nombres des 'floating point numbers' (float en
raccourci).

print(0.0)
print(10.2)
print(3.14159265359)
print(-205.344)
print(-1.0)
 Les nombres

Les nombres décimaux


Pour créer un nombre décimal on peut également utiliser la classe float

La classe float est surtout utilisée pour convertir un objet en nombre
décimal

a_int = 5

a_float = float(a_int)

print(a_float)

Vous ne pouvez passer à la classe float que des nombres entiers, des
chaînes de caractères qui contiennent des nombres et des booléens (qui
sont un sous- type des nombres entiers).

# Conversions valides # Conversions non valides

print(float(5)) print(float(None))
print(float(True)) print(float("Bonjour"))
print(float(False)) print(float([1, 2, 3]))
print(float("10.4"))
Les Booléens
 Les booléens

Les booléens

Un booléens est un objet qui ne peut prendre que deux valeurs : True et
False

C’est une sous classe des nombres entiers (0, 1)

issubclass(bool, int) #True


Le booléen True est donc similaire au nombre 1 et le booléen False au
nombre 0. Il est ainsi possible de réaliser des opérations mathématiques
entre un booléen et un entier :
print(True + 1)
print(True - 1)
print(False + 1)
print(False - 1)
print(True * 5)
print(False * 5)
print(True ** 4)
 Les opérateurs

Les opérateurs mathématiques


Python est une vraie calculatrice

Opérateurs de base : + - / *

print(5+3) #8

print(7-4) #3

print(20/4) #5.0

print(2*3) #6

On peut utiliser ces opérateurs avec les chaînes de caractères

print("Hello"+"World") #HelloWorld

print("Bonjour"*3) #BonjourBonjourBonjour

Autres opérateurs : % // **

%: modulo print(10%2) #0 print(6%4) #2

// : division entière print(10/3) #3.333333 print(10//3) #3

** : puissance print(2**4) #16
 Les opérateurs

Les opérateurs d’assignation


L’opérateur = permet d’assigner une valeur à une variable

i=5

Pour ajouter une valeur à cette même variable :

i=i+1

On utilise l’opérateur += i += 1

C’est disponible pour les autres opérateurs mathèmatiques

i += 1

i -= 1

i /= 1

i *= 1

i %= 1

i //= 1

i **= 1
 Les opérateurs

Les opérateurs de comparaison

Les opérateurs de comparaison sont : < > <= >= == !=

< Plus grand que

> Plus petit que

>= Plus grand ou égal à

<= Plus petit ou égal à

== Egal à is identique à

!= Différent de is not non identique à

Différence entre == et is

== : vérifier si deux valeurs sont égales

is : vérifier si deux objets sont les mêmes en mémoire

a = 10
a = [1 , 2, 3] id(a) b = 10
b = [1, 2, 3] id(b) a == b #True
a == b #True a is b #True
a is b #False # plage -5 à 256 : raisons d’optimisation
 Les opérateurs

Les opérateurs logiques

Les opérateurs de logiques sont : and or not


and Intersection

or Union

not Négation
print('True or True est', True or True)
print('True and False est', True and False)
print('not False est', not False)

Les variables
 Les variables en python

Les variables

Une variable permet de stocker un objet en mémoire.

Vous pouvez redéfinir à n'importe quel moment une variable en y associant un nouvel objet
x=5
x = 3.6

Comme vous l'avez vu, on utilise le symbole égal = pour assigner une valeur à une variable :
prenom = 'Paul'
age = 24
homme = True

Python est un langage dynamique, nous n'avons pas besoin de lui dire qu'un nombre est un
nombre ou qu'une chaîne de caractères est une chaîne de caractères

On peut utiliser la fonction id pour vérifier l'identifiant de l'espace mémoire dans lequel se
trouve un objet associé à une variable
 Les variables en python

Les assignations multiples


on peut lier plusieurs variables au même objet de cette manière :
a = b = c = 750
id(a) # 4426172464
id(b) # 4426172464
id(c) # 4426172464
Les assignations parallèles

On peut aussi demander à Python d'assigner plusieurs variables à plusieurs objets
différents de cette façon

a, b, c = 1, 2, 3
print(a)
print(b)
print(c)
 Les variables en python

Les constantes

En théorie, une constante est un type de variable qu'on ne peut pas modifier. Avec Python,
on les déclare toujours en majuscule :
PI = 3.14
PRIMARY_COLOR = "#FF00FF"

Cependant, avec Python, les constantes n'en sont pas vraiment car on peut leur assigner
des valeurs différentes à n'importe quel moment

Changer le type d’une variable


Python est un langage dynamiquement typé : Pas besoin d’indiquer quel est le type de la
variable et on peut changer le type à tout moment.

Python utilise souvent le "duck typing", qui se résume à "si ça ressemble à un canard et que
ça marche comme un canard, c'est probablement un canard".

Pour réaliser certaines opérations , on doit convertir une variable d’un type à l’autre
 Les variables en python

Les fonctions de conversion


int()

str()

float()
a = 10
b = "6"
b = int(b)
print (a+b) #16
print(type(b))


Avec Python 3
nombre = input("donner un nombre")
print(nombre) #10
print(type(nombre)) # <class ‘str’>
 Les variables en python

Les Règles et conventions de nommage


Il existe plusieurs conventions très suivies dans la communauté Python que vous
retrouverez sous le nom de PEP8.

Il est conseillé d'utiliser uniquement des lettres en minuscule et des tirets du
bas pour séparer les mots

Les constantes sont écrites en majuscule

Les noms de classes et les exceptions sont de la forme :
MaClasse
MyException

Donner à vos variables des noms qui ont du sens. évitez autant que possible les a1, a2, i,...

Les noms de variables à un caractère sont néanmoins autorisés pour les boucles et les

indices.
Les types séquentiels
 Les types séquentiels

Les listes

La plupart des variables ont une valeur propre, quand on met une nouvelle valeur dans la
variable, l’ancienne valeur est écrasée.

Une liste est simplement une structure de données muable et ordonnée dans laquelle on
peut stocker n'importe quel type d'objet.

Chaque objet contenu dans une liste est appelé un élément

Pour créer une liste, il faut placer ces éléments entre des crochets et les séparer par une
virgule.

On accède aux éléments d'une liste grâce à leur indice , c'est-à-dire leur position dans la
liste:
# liste vide
villes = []
# liste avec trois items de type str
villes = ['Paris', 'Lille', 'Lyon']
print(villes)
 Les types séquentiels

Les listes

On peut stocker des éléments différents comme des nombres, des booléens, des chaînes
de caractères et pourquoi pas d'autres listes. Tout ça au sein d'une seule et même liste.
liste_de_tout_et_rien = [5, 'Docstring', True, 9.5, 4, 'Python', ['autre liste'], False]
Les indices :

Dans une liste chaque élément est accessible grâce à sa position.

On appelle cette position un indice
villes = ['Paris', 'Lille', 'Lyon']
print(villes[0]) # 'Paris'
print(villes[1]) # 'Lille'
print(villes[2]) # 'Lyon'
Les indices négatives
 Les types séquentiels

Les listes
Les indices négatifs:

Les indices négatifs permettent d'accéder aux éléments d'une séquence (comme une liste
ou une chaîne de caractères) en partant de la fin de la séquence.

L'indice -1 fait référence au dernier élément de la séquence, -2 au deuxième élément en
partant de la fin, et ainsi de suite. Cela facilite l'accès aux éléments à partir de la fin sans
avoir à connaître la longueur totale de la séquence.
ma_liste = [1, 2, 3, 4, 5]

print(ma_liste[-1]) # Affiche le dernier élément : 5

print(ma_liste[-2]) # Affiche l'avant-dernier élément : 4
print(ma_liste[-3]) # Affiche l'avant-avant-dernier élément : 3

De même, vous pouvez utiliser des indices négatifs pour extraire des parties d'une chaîne
de caractères en partant de la fin :
ma_chaine = "Bonjour"

print(ma_chaine[-1]) # Affiche le dernier caractère : r

print(ma_chaine[-2]) # Affiche l'avant-dernier caractère : u
print(ma_chaine[-3]) # Affiche l'avant-avant-dernier caractère : o
 Les types séquentiels

Les listes

Muable :

Une liste peut être modifiée même après son assignation
villes = ['Paris', 'Lile', 'Lyon']
# J'ai mal orthographié exprès un élément, on va modifier ça :
villes[1] = 'Lille'
print(villes) # ['Paris', 'Lille', 'Lyon']

# Et si on ajoutait une ville ?

villes.append('Strasbourg')
print(villes) # ['Paris', 'Lille', 'Lyon', 'Strasbourg']

# J'ai jamais visité Lyon...

del villes[2]
print(villes) # ['Paris', 'Lille', 'Strasbourg']
 Les types séquentiels

Les listes

Les listes et les boucles :


On peut itérer sur une liste
villes = ['Lille', 'Lyon', 'Strasbourg']
for ville in villes:
print(ville.upper())
Créer une liste :

Il existe deux méthodes pour créer une liste vide : Avec les crochets → [] et Avec le
constructeur → list()
liste_vide = []
liste_vide = list()

Utiliser le constructeur list() pour convertir un autre objet en liste
site = 'Docstring'
site_to_liste = list(site)
print(site_to_liste) # ['D', 'o', 'c', 's', 't', 'r', 'i', 'n', 'g']
 Les types séquentiels

Les listes
Accéder à des éléments :

liste[indice] → Retourne l'élément associé à l'indice

liste[début:fin:pas] → Retourne le ou les éléments en fonction de l'intervalle précisé

liste[indice] → Retourne l'élément associé à l'indice

Pour accéder à un élément dans une liste, on utilise la notation entre crochets [ ] et l'indice
de l'élément.
villes = ['Paris', 'Lille', 'Lyon']
print(villes[1]) # 'Lille'
print(villes[-1]) # 'Lyon'
print(villes[3]) # IndexOutOfRange Error
print(villes[0:2]) # ['Paris', 'Lille']
print(villes[0::2]) # ['Paris', 'Lyon']
print(villes[0:]) # ['Paris', 'Lille', 'Lyon']
print(villes[:]) # ['Paris', 'Lille', 'Lyon']
 Les types séquentiels

Les listes

Ajouter des éléments

append(item) → Ajoute un item à la fin de la liste

insert(index, item) → Ajoute un item à la position indiquée en paramètre

extend(iterable) → Ajoute tous les items de la collection dans la liste
villes = ['Paris', 'Lille', 'Lyon']
villes.append('Strasbourg')
print(villes)'

Supprimer des éléments

del liste[indice] → Supprime un ou plusieurs éléments d'une liste. Peut aussi être utilisé
pour détruire complètement une liste.

liste.pop(indice) → Retire un élément de la liste. Si on ne précise pas d'indice, cela retire
automatiquement le dernier élément. Et surtout, cela permet de récupérer l'élément
supprimé.

liste.remove(item) → Supprime un élément de la liste.
 Les types séquentiels

Les tuples

Un tuple ne peut pas être modifié après l'assignation car c'est un objet immuable.

C'est la principale différence entre les tuples et les listes.

Les tuples sont généralement plus rapides et consomment moins de mémoire que les listes,
car ils sont immuables.

Création

Pour créer un tuple en Python, on utilise les parenthèses () puis on place les éléments à
l'intérieur en les séparant par une virgule.
t = () # Un tuple python vide
print(t) # ()

t = ('spam', 'eggs') # Un tuple python contenant deux chaînes de caractères

print(t) # ('spam', 'eggs')

t = ('spam', 'eggs', 9, ['one', 'two', 'three'], True) # Un tuple python avec des éléments de différents types
print(t) # ('spam', 'eggs', 9, ['one', 'two', 'three'], True)

t = ('spam', 'eggs', (1, 2, 3), 9.4, True) # Un tuple python contenant un autre tuple
print(t) # ('spam', 'eggs', (1, 2, 3), 9.4, True)
 Les types séquentiels

Les tuples

Créer un tuple avec un seul élément

Pour créer un tuple avec un seul élément, il faut ajouter une virgule après cet élément,
même si les parenthèses sont facultatives.
mon_tuple = (1,)
mon_tuple = 1,
La virgule est nécessaire pour différencier un tuple d'une simple expression entourée de
parenthèses. Sans la virgule, Python interpréterait l'expression comme une simple valeur
entourée de parenthèses et non comme un tuple. Voici un exemple pour illustrer ce point :

# Ceci n'est pas un tuple

pas_un_tuple = (1)
print(type(pas_un_tuple)) # Résultat : <class 'int'>

# Ceci est un tuple avec un seul élément

mon_tuple = (1,)
print(type(mon_tuple))
 Les types séquentiels

Les tuples
Accéder à des éléments

On peut utiliser les crochets [] pour accéder à un élément via son indice.

Comme pour toutes les structures de données en Python, le premier indice est 0.
t = ('spam', 'eggs')
print(t[0]) # 'spam'

Vous pouvez aussi accéder à l'élément d'un tuple en utilisant un indice négatif !

C'est pratique lorsque vous avez un tuple qui contient beaucoup de valeurs et que vous avez
besoin d'accéder aux dernières :
t = ('s', 'p', 'a', 'm')
print(t[-1]) # 'm'

Comme pour les listes, on utilise le slicing pour préciser un intervalle de recherche.

Pour rappel, la syntaxe pour le slicing est : [début:fin:pas]
t = ('d', 'o', 'c', 's', 't', 'r', 'i', 'n', 'g')
print(t[:3]) # ('d', 'o' 'c') # Tous les items jusqu'à l'index 3
print(t[3:]) # ('s', 't', 'r', 'i', 'n', 'g') # Tous les items à partir de l'index 3
print(t[2:6]) # ('c', 's', 't', 'r') # Tous les items compris enter l'index 2 et l'index 6
print(t[1::2]) # ('o', 's', 'r', 'n') #Un item sur deux à partir de l'index 1 et jusqu'à la fin du tuple
print(t[:]) # ('d', 'o', 'c', 's', 't', 'r', 'i', 'n', 'g') # Copie du tuple
 Les types séquentiels

Les tuples
Modifier un tuple
Les tuples sont des objets immuables. Cependant, on peut modifier les objets muables
stockés à l'intérieur d'un tuple comme les listes, les dictionnaires, etc
t = ('Salut', 'Bonjour', [1, 2, 3], 'Bonsoir')
t[0] = 'Hello' # TypeError: 'tuple' object does not support item assignment
t[2][0] = 9 # ('Salut', 'Bonjour', [9, 2, 3], 'Bonsoir')
Supprimer un tuple
On ne peut pas supprimer un élément en particulier d'un tuple car les tuples sont des objets
immuables. Par contre, on peut supprimer le tuple en entier grâce à l'instruction del :
t = ('Salut', 'Bonjour', [1, 2, 3], 'Bonsoir')
del t[0] # TypeError: 'tuple' object doesn't support item deletion
del t
print(t) # NameError: name 't' is not defined
Convertir les tuples Python en liste
Pour convertir un tuple en liste, nous pouvons utiliser la fonction intégrée list()
mon_tuple = (1, 2, 3, 4)
ma_liste = list(mon_tuple)
print(ma_liste) # Résultat : [1, 2, 3,4]
 Les types séquentiels

Les dictionnaires

Les dictionnaires sont des collections d'objets non-ordonnées.

Un dictionnaire est composé d'éléments et chaque élément se compose d'une paire clé:
valeur.

Comme les listes, les dictionnaires sont des objets muables et dynamiques. Ils peuvent être
modifiés.

Un dictionnaire peut contenir des objets de n'importe quel type et même inclure d'autres
dictionnaires.

Création
Pour créer un dictionnaire en Python, on utilise les accolades {} puis on insére des paires de
clés et de valeurs. Les paires à l'intérieur sont séparés par une virgule.
Les valeurs peuvent être de n'importe quel type alors que les clés doivent obligatoirement
être de type immuable !

Vous pouvez ainsi utiliser un float ou un tuple comme clé sans problème
 Les types séquentiels

Les dictionnaires
Création
d = {}
print(d)
# Dictionnaire dont les clés ne sont que des chaînes de caractères
d={
'Excellent': 'Admirable',
'Amusant': 'Comique',
'Immense': 'Vaste'
}
print(d)
# Dictionnaire dont les clés sont des objets de différents types
d={
1: 'one',
'deux': 2 ,
(3, 4, 5): 'liste',
9.9: 'neuf_point_neuf'
}
print(d)
 Les types séquentiels

Les dictionaires

Ajouter des éléments
Les dictionnaires étant des objets muables, ils sont faciles à modifier :
d={
'Excellent': 'Admirable',
'Amusant': 'Comique',
}
d['Excellent'] = 'Bon' # Clé existe déjà, remplace la valeur
d['Immense'] = 'Vaste' # Nouvelle clé, on créer la paire clé/valeur dans le dico
print(d)

Supprimer des éléments

Utiliser la méthode pop pour supprimer un élément et récupérer sa valeur dans une
variable

Utiliser la méthode popitem pour supprimer le dernier élément et récupérer un tuple
contenant la clé et sa valeur

Utiliser clear pour vider le dictionnaire

Supprimer entièrement le dictionnaire grâce à l'instruction del
 Les types séquentiels

Les dictionaires

Les dictionnaires et les boucles
On peut écrire une boucle qui parcourt toutes les entrées d’un dictionnaire. En fait, elle passe
par toutes les clés du dictionnaire et recherche les valeurs.
d={
'Excellent': 'Admirable',
'Amusant': 'Comique',
}
for key in d: #key in d.keys():
print(key)
Pour itérer sur les valeurs, Python met à notre disposition la méthode values :
for value in d.values():
print(value)
On peut combiner les deux résultats précédents grâce à la méthode items qui permet de
récupérer toutes les paires clés / valeurs :
for key, value in d.items():
print(key, value)
 Les types séquentiels

Les sets (ensembles) en Python


Un ensemble est une collection non ordonnée et non indexée d'éléments uniques.

Les sets sont très utiles lorsque vous devez effectuer des opérations ensemblistes telles que
l'union, l'intersection ou la différence entre des collections d'éléments.

les éléments à l'intérieur de l'ensemble sont uniques car les doublons ne sont pas autorisés
dans les ensembles.

La création:
Vous pouvez créer un ensemble en utilisant des accolades {} ou la fonction set() :
# Création d'un ensemble vide
set_vide = set()

# Création d'un ensemble avec quelques éléments

mon_set = {1, 2, 3, 4, 5}
 Les types séquentiels

Les sets (ensembles) en Python


Ajouter des éléments dans un ensemble :

Pour ajouter un élément à un ensemble, utilisez la méthode add():
# Ajout d’un élément
mon_set.add(6)


Supprimer des éléments dans un ensemble :
Pour supprimer un élément d'un ensemble, utilisez la méthode remove() ou discard().



La différence entre ces deux méthodes est que remove() génère une erreur si l'élément
n'est pas trouvé, tandis que discard() ne génère pas d'erreur.
# Supprimer un élément
mon_set.remove(3)
mon_set.discard(4)
 Les types séquentiels

Les sets (ensembles) en Python


Opérations ensemblistes :

Python fournit plusieurs opérations ensemblistes que vous pouvez effectuer sur des
ensembles
set1 = {1, 2, 3}
set2 = {3, 4, 5}

# Union de deux ensembles

union_set = set1.union(set2) # ou bien set1 | set2

# Intersection de deux ensembles

intersection_set = set1.intersection(set2) # ou bien set1 & set2

# Différence entre deux ensembles

difference_set = set1.difference(set2) # ou bien set1 - set2
 Les types séquentiels

L'énumération (enumerate) en Python


L'énumération est une fonction intégrée en Python qui vous permet de parcourir une
séquence (liste, tuple, chaîne de caractères, etc.) tout en gardant une trace de l'indice de
l'élément actuel.

Utilisation de enumerate() :

La fonction enumerate() retourne un objet "énumérable" qui produit des paires (index,
élément) à chaque itération dans une boucle for

ma_liste = ['a', 'b', 'c', 'd']

for index, element in enumerate(ma_liste):

print(f"L'élément '{element}' est à l'index {index}")

 Les types séquentiels

L'énumération (enumerate) en Python


Spécifier un indice de départ :

Par défaut, l'indice commence à 0, mais vous pouvez spécifier un indice de départ différent
en passant un argument supplémentaire à la fonction enumerate().

ma_liste = ['a', 'b', 'c', 'd']

for index, element in enumerate(ma_liste, start=1):

print(f"L'élément '{element}' est à l'index {index}")

 L’opérateur * et la fonction print()

L'opérateur * et la fonction print()


L’opérateur * est utilisé pour déballer (unpacking) des éléments d'une séquence (comme
une liste ou un tuple) lors de l'affichage.

Les éléments de la séquence seront séparés par des espaces et imprimés individuellement
plutôt que d'être affichés en tant que séquence.

# Définir une liste contenant quelques éléments

ma_liste = [1, 2, 3]
# Utiliser l'opérateur * pour déballer les éléments de la liste dans la fonction print
print(*ma_liste)
 Les fonctions “all” et “any”

“all” et “any”

"all" est une fonction intégrée (built-in) et non un mot-clé. La fonction "all" permet de
vérifier si tous les éléments d'une séquence (telle qu'une liste, un tuple, un ensemble, etc.)
sont évalués à True.

"any", renvoie True si au moins un élément de l'itérable est évalué à True
# Tous les éléments de la liste sont évalués à True
liste1 = [True, True, True]
resultat1 = all(liste1)
print(resultat1) # Output: True # Au moins un des éléments de la liste est évalué à True
liste3 = [False, False, True]
# Un des éléments de la liste est évalué à False
resultat3 = any(liste3)
liste2 = [True, False, True] print(resultat3) # Output: True
resultat2 = all(liste2) # Aucun des éléments de la liste est évalué à True
liste4 = [False, False, False]
print(resultat2) # Output: False resultat4 = any(liste4)
print(resultat4) # Output: False
Les structures conditionnelles
 Les structures conditionnelles


Chaque jour, nous sommes confrontés à des décisions.


Dans un programme, les conditions permettent de faire des choix
dépendants des différentes données que l’on peut retrouver dans notre
programme.

Grâce à des conditions, vous pouvez contrôler votre code et exécuter une
action A plutôt qu'une action B par exemple.


Quatre types de structures conditionnelles

Simples

Alternatives

A choix multiples

Imbriquées
 Les structures conditionnelles

Structure conditionnelle simple


Syntaxe d’une structure conditionnelle simple:
if condition:
code
...
suite du code
...

Python exécute le code qui se trouve à l'intérieur de votre structure
conditionnelle uniquement si la condition est vraie (True).

Si c'est False, le code n'est pas exécuté

Exemple :
age = 24
majorite = 18
if age >= majorite:
print("Je suis majeur !")
print("J'ai", age, "ans !")
 Les structures conditionnelles

Structure conditionnelle alternatives


Le mot clé else permet d'exécuter une condition si les conditions
précédentes ne sont pas vérifiées.

age = 15
majorite = 18
if age >= majorite:
print("Je suis majeur !")
else:
print("Je suis mineur..")
print("J'ai", age, "ans !")
 Les structures conditionnelles

Structure conditionnelle alternative


Le mot-clé elif (pour « else if », en français « sinon si ») permet d'ajouter
des conditions supplémentaires à une structure conditionnelle

age = 18
majorite = 18

if age > majorite :

print("Je suis majeur !")
elif age == majorite:
print("Tout juste majeur depuis aujourd'hui")
else:
print("Je suis mineur..")

print("J'ai", age, "ans !")

 Les structures conditionnelles

Structure conditionnelle à choix multiples


L’instruction match case permet d'exécuter une structure conditionnelle
à choix multiple :
Jour = int(input("entrer le numéro de jour entre 1-7\n"))
match (Jour):
case 1:
print("Lundi")
case 2:
print("Mardi")
case 3:
print("Mercredi")
case 4:
print("Jeudi")
case 5:
print("Vendredi")
case 6:
print("Samedi")
case 7:
print("Dimanche")
case _:
print("Nombre incorrect")
 Les structures conditionnelles

Structures conditionnelles imbriquées


Vous pouvez imbriquer une structure conditionnelle dans une autre structure, puis dans
une autre, et encore une autre, etc...

On appelle ça de l'imbrication en français (« nesting » en anglais).

age = 18
majorite = 18

if age >= majorite:

print("Je suis majeur !")
if age == majorite:
print("Tout juste majeur depuis aujourd'hui")
else:
print("Je suis mineur..")

print("J'ai", age, "ans !")

Les boucles
 Les boucles

Les boucles

Une boucle permet de recommencer plusieurs fois un bloc d’instructions.


Il y a deux sortes de boucles :


Si l’on sait à l’avance le nombre de fois que le bloc d’instruction doit être
exécuté, on utilise la boucle "Pour ....Allant de ....A…" : boucle for


Dans le cas contraire on utilise plutôt une boucle du type " Tant
Que....Faire c’est liée à une condition : boucle while
 Les boucles

La boucle for

On utilise la boucle for pour parcourir des objets itérables comme les
listes, les tuples ou encore les chaînes de caractères.

C'est une boucle commune à presque tous les langages de
programmation.

Syntaxe de la boucle for:
for value in object:
Code...


La variable value prend la valeur de chaque élément contenu dans object
à chaque itération.

La boucle for continue jusqu'à ce qu'on ait atteint le dernier élément de
object.
 Les boucles

La boucle for

Quelques exemples d'utilisation de la boucle for avec différents types
d'itérables :
for i in range(3):
print(i)
prenom = "John"
for lettre in prenom:
print(lettre)
for (p, name) in [(1, "Patrick"), (2, "John"), (3, "Marie")]:
print(p, name)

Comme pour les structures conditionnelles if..else, vous pouvez définir un
comportement par défaut pour votre boucle for grâce au mot-clé else.
fruits = ['Orange', 'Pomme', 'Banane', 'Cerise', 'Fraise']
for fruit in fruits:
print(fruit)
else:
print('Plus de fruits dans le panier')
 Les boucles

La boucle while

La boucle while est utilisée pour exécuter du code tant qu'une certaine
condition est vérifiée.

Cette boucle est très utile lorsqu'on ne sait pas combien de fois nous
devons itérer.

Syntaxe de la boucle for:
while condition:
code...

Exemple
i=0
while i < 10:
print('Salut')
i += 1
 Les boucles

La boucle while

Tout comme pour les boucles for, il est possible de définir un
comportement par défaut grâce au mot-clé else.

Le code à l'intérieur du else sera exécuté si la condition de votre boucle
while renvoie False.
i=0
while i < 3:
print('Salut')
i += 1
else:
print('Au revoir')
 Les boucles

L’instruction continue et break


L'instruction continue permet d'ignorer des valeurs lors de l'itération en
cours sans pour autant arrêter l'exécution.
fruits = ['Orange', 'Pomme', 'Banane', 'Cerise', 'Fraise']
for fruit in fruits:
if fruit == 'Cerise':
print('Pas fan des cerises')
continue #break
print(fruit)
print('On passe à la suite')

Il est important de noter que l'instruction continue n'arrête pas la boucle
au complet (comme le ferait l'instruction break), elle permet juste
d'ignorer le reste du code dans l'itération courante.
 Merci pour votre attention …

01/04/2025
81