Cursus Science de l’Ingénieur

Parcours EEAT niveau 3

Cours : Calcul scientifique

Introduction au langage Python

Dr MALONG Yannick
 Table des matières
variable 3
1 variables 2
2 création de variables 2
3 Casting 2
4 Nommer les variables 2
4.1 Camel case 2
4.2 Pascal Case 2
4.3 Snake case 2
5 Attribution de valeurs 2
5.1 Affectation de variables multiples 2
5.2 Une valeur à plusieurs variables 2
5.3 Déballer une collection 2
6 Entrée et sortie de l'utilisateur 2
6.1 Sortie 2
6.2 Entrée utilisateur 2
Type_de_Données 8
1 Types de données 2
1.1 Type de données numériques 2
1.1.1 Entiers (int) 2
1.1.1.1 *Binaire 2
1.1.1.2 *Octal 2
1.1.1.3 *Hexadécimal 2
1.1.2 Floats 2
1.1.3 Complexe 2
1.2 Type de données texte (type String) 2
1.3 Type de séquence (type collecteur) 2
1.3.1 Liste 2
1.3.1.1 Accès aux éléments de la liste 2
1.3.1.2 Classe de liste 2
1.3.2 Tuples 2
1.3.2.1 Accès aux éléments du tuple 2
1.3.2.2 Mettre à jour ou supprimer des éléments de Tuple 2
1.3.2.3 Classe de tuple 2
1.4 Types d'ensembles 2
1.5 Type de mappage (Dictionnaire) 2
1.5.1 Accès au dictionnaire 2
Operateurs 21
1 Opérateurs 2
1.1 Opérateurs arithmétiques 2
1.2 Opérateurs de comparaison 2
1.3 Opérateurs d'assignation 2
1.4 Opérateurs logiques 2
decision 25
 1 Prise de décision 2
1.1 Instruction Else 1
1.2 Déclaration Elif 1
1.3 Conditions if, elif, else imbriquées 1
Boucle 30
1 Boucles Python 1
1.1 Boucle while 1
1.1.1 La boucle infinie 1
1.2 Boucle For 1
fonction 34
1 Python - Fonctions 1
1.1 Définir une fonction 1
1.2 Paramètres de la fonction 1
1.2.1 Paramètres multiples 1
1.2.2 Fonction avec des arguments de type mot-clé 1
1.2.3 Argument de mot-clé **kwarg 1
1.3 Paramètre avec une valeur par défaut 1
1.4 Fonction avec valeur de retour 1
variables
Une variable est un conteneur qui stocke des valeurs de données. Ce conteneur est une zone de mémoire qui
n'est disponible et utilisée que pendant l'exécution du programme. Bien que chaque variable soit associée à une
zone de la mémoire de l'ordinateur, l'adresse du conteneur varie d'un ordinateur à l'autre ou d'une instance
d'exécution du code à l'autre. d'exécution du code à l'autre. En python, les variables sont faciles à utiliser et sont
constituées de concepts simples que l'on rencontre en programmant. Nous verrons ci-dessous comment créer
des variables et leur attribuer des valeurs, ainsi que leur donner des types et les imprimer.

1. création de variables
Contrairement à d'autres langages de programmation comme C, C++, java, C#, ... python n'a pas de commande
pour déclarer une variable. En python, une variable est créée lorsqu'une valeur lui est attribuée. Par exemple :

> x = 2
> y = "melvin"

D'après l'exemple ci-dessus, nous voyons que les variables en Python n'ont pas besoin de type de déclaration
par défaut. Le langage Python est un langage à typage dynamique, ce qui signifie que le type est attribué
dynamiquement en fonction de la valeur. en fonction de la valeur

> x = 2
> x = "hello world

nous voyons que x passe du type int au type str sans qu'aucune erreur ne se produise. C'est vraiment bien tout
cela, mais une question se pose : * "comment pouvons-nous spécifier un type de données à une
variable ? "* . Ne vous inquiétez pas, nous allons le faire à l'aide du concept suivant : Casting.

2. Casting
Casting d'une variable signifie que l'on donne un type de données spécifique à cette variable. Exemple :

> x = st(2)
> y = int(2)
> z = float(2)

En faisant cela, nous nous assurons que la valeur attribuée est réellement du type souhaité. Pour obtenir le type
d'une variable, nous pouvons simplement utiliser la fonction type() .

Exemple :

> x = 2
> type(x)
<classe 'int'>
> y = str(2)
> type(y)
<classe 'str'>

Après avoir vu ce qu'est une variable et su comment les créer, nous allons examiner les différentes règles autour
Page 1 of 5
des variables

3. Nommer les variables

Bien que python soit typé dynamiquement et flexible, comme d'autres langages de programmation, nous
devons suivre certaines règles pour nommer les variables.
Le nom d'une variable doit commencer par une lettre ou le caractère de soulignement.
Un nom de variable ne peut pas commencer par un chiffre
Le nom d'une variable ne peut contenir que des caractères alphanumériques et des caractères de
soulignement (A-z, 0-9 et _ ).
Les noms de variables sont sensibles à la casse (age, Age et AGE sont trois variables différentes).
Les noms de variables ne peuvent pas être des mots-clés réservés en Python (for, int, in, ...).
Exemple de noms de variables légaux :

>myvar = "John"
>my_var = "Jean"
>_my_var = "John"
>myVar = "John"
>MYVAR = "Jean"
>myvar2 = "Jean

Exemple de noms de variables illégaux :

>2myvar = "Jean"
>my-var = "Jean"
>My-var = "Jean"

Si un nom de variable est composé de plusieurs mots, les trois techniques suivantes peuvent vous aider à en
améliorer la lisibilité
La Camel case
Pascal case
Snake case

Camel case
Chaque mot, sauf le premier, commence par une majuscule. Un exemple peut être vu ci-dessous
myVariableName = "John"

Pascal Case
Chaque mot commence par une majuscule. L'exemple ci-dessous nous montre ce qu'est une casse pascale
MyVariableName = "John"

Snake case
Chaque mot est séparé par un caractère de soulignement. Nous avons une illustration de la casse serpent ci-
Page 2 of 5
dessous
`` my_variable_name = "John"```

4. Attribution de valeurs
Ci-dessus, nous avons donné des exemples d'affectation simple de variables, c'est-à-dire l'attribution d'une
valeur à une seule variable. En python, nous pouvons assigner de nombreuses valeurs à de nombreuses
variables, nous pouvons également assigner une valeur à de nombreuses variables ainsi que de nombreuses
valeurs à une variable. plusieurs valeurs à une variable ; dans ce cas, nous l'appellerons un collecteur.

Affectation de variables multiples

Vous pouvez déclarer plusieurs variables et attribuer des valeurs à chaque variable dans une seule instruction,
comme indiqué ci-dessous.

x, y, z = 10, 20, 30

Dans l'exemple ci-dessus, la première valeur int 10 sera affectée à la première variable x, la deuxième valeur à la
deuxième variable y, et la troisième valeur à la troisième variable z. L'affectation des valeurs aux variables doit se
faire dans le même ordre que celui dans lequel elles ont été déclarées.
Vous pouvez également déclarer différents types de valeurs aux variables dans une seule instruction, comme
indiqué ci-dessous.

x, y, z = 10, 'Hello', True

L'attribution d'une valeur à chaque variable individuelle séparée par une virgule entraînera une erreur de
syntaxe, comme illustré ci-dessous.

> x = 10, y = 'Bonjour', z = Vrai

> SyntaxError : can't assign to literal (Impossible d'assigner à un littéral)

Remarque : assurez-vous que le nombre de variables correspond au nombre de valeurs, sinon

vous obtiendrez une erreur.

Une valeur à plusieurs variables

Vous pouvez affecter une valeur à plusieurs variables sur une même ligne :

x = y = z = "Orange"

Dans l'exemple ci-dessus, les trois variables ont pour valeur la chaîne "Orange".

Déballer une collection

Décompresser une collection signifie extraire ses valeurs dans des variables. L'exemple ci-dessous montre
Page 3 of 5
comment fonctionne le déballage

> fruits = ["pomme", "banane", "cerise"].

x, y, z = fruits

Si nous imprimons les différentes valeurs des variables x, y et z, nous obtiendrons "pomme" comme valeur de x,
"banane" comme valeur de y et "cerise" comme valeur de z

_nous devrions noter que le nombre de valeurs stockées dans notre collecteur et le nombre de
variables sont identiques.

5. Entrée et sortie de l'utilisateur

Sortie
En Python, l'instruction print est souvent utilisée pour afficher les variables.

x = "hello world" # (Bonjour monde)

print(x)

on peut utiliser le caractère + pour combiner à la fois du texte et une variable

x = "world"
print("hello" + x)

Le caractère "+" est utilisé comme un opérateur mathématique lorsque les deux opérandes sont des nombres. Si
les deux opérandes sont des chaînes de caractères, nous appellerons l'opération "concaténation".
Remarque : Il existe de nombreuses façons d'imprimer des données, mais nous utiliserons la méthode ci-dessus
pour produire des données__.

Entrée utilisateur
Lorsque nous faisons de la programmation, il existe certaines étapes où nous aurons besoin que l'utilisateur
interagisse avec le programme que nous écrivons. En effet, tous les utilisateurs ont des objectifs différents par
rapport à notre programme, qui doit donc être interactif pour les satisfaire.
Pour ce faire, nous utiliserons la fonction input() pour obtenir l'entrée de l'utilisateur.
Dans l'exemple ci-dessous, nous allons utiliser la fonction input() pour affecter une valeur utilisateur à une
variable.

x = input("entrez un nombre : ")

print(x)
------------
Entrez un nombre : 4
4

Dans l'exemple ci-dessus, l'utilisateur entre 4 et la valeur est assignée à la variable x puis imprimée sur la console
Page 4 of 5
avec la fonction print() . sur la console.
L'exemple ci-dessus pourrait encore être écrit comme suit :

print("entrez un nombre")
x = input()
print(x)
---------------
Entrez un nombre
4
4

Nous pourrions faire du casting de données en utilisant la fonction input() .

Dans l'exemple ci-dessus, imaginons qu'au lieu d'un nombre, l'utilisateur entre une lettre, alors que se passera-t-
il ?
Voyons ce qui se passe ci-dessous :

print("entrez un nombre")
x = input()
print(x)
------------
entrez un nombre
a
a

D'après ce qui précède, nous voyons que le type de la valeur saisie par l'utilisateur n'est pas le type souhaité.
Pour résoudre ce problème, nous allons utiliser le data pour forcer l'entrée de l'utilisateur à être du type désiré.

print("entrez un nombre")
x = int(input())
print(x)

Avec ceci, si l'utilisateur entre un type non désiré, la console retournera une erreur.

----------
enter a number
a
Traceback (most recent call last):
File "C:\Users\Daley\Documents\Learning_Python\variables.py", line 2, in <module>
x = int(input())
ValueError: invalid literal for int() with base 10: 'a'

Page 5 of 5
Types de données
Précédemment, lorsque nous parlions des variables, nous avons dit qu'elles pouvaient être utilisées pour stocker
des données d'un type donné en mémoire pendant l'exécution de notre programme. La question qui se pose est
de savoir ce qu'est un type de données? .
Dans ce chapitre, nous verrons ce que sont les types de données et nous nous concentrerons sur les principaux
types de données utilisés dans la programmation python en donnant des exemples et à la fin nous ferons
quelques exercices pratiques.
Nous pouvons définir un type de données comme une classification ou une catégorisation d'un élément de
données. Cela signifie que les données sont toujours classées sous une étiquette donnée lors de la
programmation. Cela permet de s'assurer que les données remplissent certaines conditions ou ont des
propriétés spécifiques par rapport aux objectifs que nous poursuivons. Certains de ces objectifs peuvent être :
l'optimisation de l'utilisation de la mémoire
l'optimisation des résultats obtenus
le traitement des données
et bien d'autres encore
En python, nous disposons de types de données intégrés présents sous les catégories suivantes :

Type de texte : str

Types numériques : int, float, complex

Types de séquence : list, tuple, range

Type de mappage : dict

Type set : set, frozenset

Type booléen : bool

Types binaires : bytes, bytearray, memoryview

Sur la base du type de données de la variable, l'interpréteur alloue la mémoire et décide de ce qui peut être
stocké dans la mémoire réservée. Par conséquent, en attribuant différents types de données aux variables, vous
pouvez stocker des entiers, des décimaux ou des caractères dans ces variables.

1. Type de données numériques

Les types de données numériques stockent des valeurs numériques. Les objets numériques (ou variables
numériques) sont créés lorsque vous leur attribuez une valeur.
Python prend en charge trois types numériques différents :
int (entiers signés)
float (valeurs réelles à virgule flottante)
complex (nombres complexes)

Page 1 of 13
Entiers (int)
En Python, les entiers sont des nombres entiers nuls, positifs ou négatifs, sans partie fractionnaire et ayant une
précision illimitée, par exemple 0, 100, -10. Les exemples suivants sont des littéraux d'entiers valides en Python.

>>> 0
0
>>> 1222
1222
>>> 9203
9203
>>> 442000000000000000000000
442000000000000000000000

Les entiers peuvent être des valeurs binaires, octales, hexadécimales.

>>> 0b11011000 # binaire

216
>>> 0o12 # octal
10
>>> 0x12 # hexadécimal
15

Toutes les variables entières sont des objets de la classe int . Nous pouvons utiliser la méthode type() pour
obtenir le nom de la classe, comme indiqué ci-dessous.

>>>type(100)
<class 'int'> # le type de x est int
>>> x= 0o12 # on donne à x une valeur en octal
>>> type(x)
<class 'int'> # le type de x est int
>>> money=5000000000000000000000000000000000000000000
>>> type(money) # le type de money est int
<classe 'int'>

Les zéros de tête dans les entiers non nuls ne sont pas autorisés, par exemple 000121 est un nombre invalide,
0000 est 0.

>>> x=01234567890
Erreur de syntaxe : jeton invalide

Python ne nous permet pas d'utiliser les virgules comme délimiteur comme dans la vie réelle (1000== 1 000). A
la place, Python utilise le trait de soulignement _ comme délimiteur.

>>> x = 10_000
>>> x
10000

La fonction int() convertit une chaîne ou un flottant en un nombre entier.

Page 2 of 13
 >>> int('10')
10
>>> int('-10.5')
-10

*Binaire
Un nombre ayant 0b avec huit chiffres dans la combinaison de 0 et 1 représente les nombres binaires en Python.
Par exemple, 0b11011000 est un nombre binaire équivalent à l'entier 216.

>>> x=0b11011000
>>> x
216
>>> x=0b_1101_1000
>>> x
216

*Octal
Un nombre ayant 0o ou 0O comme préfixe représente un nombre octal. Par exemple, 0O12 est équivalent au
nombre entier 10.

>> x=0o12
>>> x
10

*Hexadécimal
Un nombre avec 0x ou 0X comme préfixe représente un nombre hexadécimal. Par exemple, 0x12 est équivalent
au nombre entier 18.

>>> x=0x12
>>> x
18

Floats
En Python, les nombres à virgule flottante (float) sont des nombres réels positifs et négatifs avec une partie
fractionnaire dénotée par le symbole décimal . ou la notation scientifique E ou e , comme 12,4, 1e04, -5,2.

>>> f=1.5
>>> f
1.5
>>> type(f)
<classe 'float'>

Tout comme les entiers, les flottants peuvent être séparés par un trait de soulignement _ .

Page 3 of 13
 >>> f = 12_34.5
>>> f
1234.5

Les flottants ont une taille maximale qui dépend de votre système. Le flottant qui dépasse la taille maximale de
votre système est appelé inf, Inf, INFINITY ou infini . Le flottant 2e400 sera considéré comme l'infini par de
nombreux systèmes.

>>> f = 2e400
>> f
inf

Nous pouvons utiliser les notations scientifiques pour représenter les flottants ayant plusieurs chiffres. Par
exemple :

>>> f=1e3
>>> f
1000.0

Nous pouvons utiliser la fonction float() pour convertir des chaînes de caractères et des entiers en flottants.

>>> float('5.5')
5.5
>>> float('5')
5.0
>>> float('1e3')
1000.0
>>> float('-Infinity')
-inf

Complexe
Un nombre complexe est un nombre avec des composantes réelles et imaginaires. Par exemple, 5 + 6j est
un nombre complexe où 5 est la composante réelle et 6 multiplié par j est une composante imaginaire.

>>> a=5+2j
>>> a
(5+2j)
>>> type(a)
<classe 'complexe'>

Vous devez utiliser j ou J comme composant imaginaire. L'utilisation d'un autre caractère entraînera une
erreur de syntaxe.

>>> a=5+2k
SyntaxError : syntaxe invalide
>>> a=5+j
Erreur de syntaxe : syntaxe non valide
>>> a=5i+2j
Erreur de syntaxe : syntaxe invalide

Page 4 of 13
 2. Type de données texte (type String)
En Python, la chaîne est un type de données de séquence immuable. Il s'agit de la séquence de caractères
Unicode enveloppée dans des guillemets simples, doubles ou triples.
Les éléments suivants sont des chaînes de caractères valides en Python.

This is a string in Python' # chaîne entre guillemets simples

"This is a string in Python" # chaîne entre guillemets doubles
''Ceci est une chaîne en Python'' # chaîne entre guillemets triples # chaîne entre
guillemets triples
"""Ceci est une chaîne en Python"" # chaîne entre guillemets triples # chaîne entre
guillemets triples

Une chaîne littérale peut être affectée à une variable, comme indiqué ci-dessous.

>>> str1= "Ceci est une chaîne de caractères en Python".

>>> print(str1)
Ceci est une chaîne de caractères en Python
>>> str2="Ceci est une chaîne en Python"
>>> print(str2)
Ceci est une chaîne de caractères en Python

Les chaînes de caractères de plusieurs lignes doivent être intégrées dans des guillemets triples, comme indiqué
ci-dessous.

str1=''''Ceci est
la première
chaîne de caractères multi-lignes.
'''
print(str1)
------------
Ceci est
la première
Chaîne de caractères à plusieurs lignes.

Si une chaîne de caractères doit contenir des guillemets doubles, elle doit être écrite entre guillemets simples.
De même, si une chaîne de caractères comprend des guillemets simples, elle doit être écrite entre guillemets
doubles.

str1='Welcome to "Python Tutorial" on TutorialsTeacher'

print(str1)
---------------
Bienvenue à 'Python Tutorial' sur TutorialsTeacher

str2="Bienvenue à 'Python Tutorial' sur TutorialsTeacher"

print(str2)
----------------
Bienvenue à 'Python Tutorial' sur TutorialsTeacher

Nous pouvons utiliser la fonction len() pour récupérer la longueur d'une chaîne de caractères.

Page 5 of 13
 >>> greet='Hello'
>>> len(greet)
5

Une séquence est définie comme une collection ordonnée d'éléments. Par conséquent, une chaîne de caractères
est une collection ordonnée de caractères. La séquence utilise un index, commençant par zéro, pour extraire un
certain élément (un caractère dans le cas d'une chaîne).

>>> greet='hello'
>>> greet[0]
'h'
>>> greet[1]
'e'
>>> greet[2]
'l'
>>> greet[3]
'l'
>>> greet[4]
'o'
>>> greet[5] # erreur si index > len(string)-1
Traceback (dernier appel le plus récent) :
Fichier "<pyshell#2>", ligne 1, dans <module>
greet[5]
IndexError : indice de chaîne hors de l'intervalle

Python supporte également l'indexation négative, en commençant par -(longueur de la chaîne) jusqu'à -1.

>>> greet='hello'
>>> greet[-5]
'h'
>>> greet[-4]
'e'
>>> greet[-3]
'l'
>>> greet[-2]
'l'
>>> greet[-1]
'o'

La chaîne de caractères est un objet immuable. Il n'est donc pas possible de la modifier. La tentative d'attribuer
des caractères différents à un certain indice entraîne des erreurs.

>>> greet='hello'
>>> greet[0]='A'
Traceback (dernier appel le plus récent) :
Fichier "<pyshell#2>", ligne 1, dans <module>
greet[0]='A'
Erreur de type : l'objet 'str' ne prend pas en charge l'affectation d'éléments.

Utilisez la fonction str() pour convertir un nombre en une chaîne de caractères.

Page 6 of 13
 >>> str(100)
'100'
>>> str(-10)
'-10'
>>> str(True)
'True' (vrai)

3. Type de séquence (type collecteur)

Les types de données séquentielles sont appelés collecteurs de données en Python. Ils contiennent un ou
plusieurs éléments de différents types de données. Les différents éléments sont généralement contenus entre
crochets [] , accolades {} ou parenthèses () et sont séparés les uns des autres par une virgule.

Ces séquences peuvent être des listes, des dictionnaires ou des tuples. Une séquence peut également contenir
une autre séquence et apporte ainsi de nombreuses possibilités au développeur.

Liste
En Python, la liste est un type de séquence mutable. Un objet liste contient un ou plusieurs éléments de
différents types de données entre les crochets [] séparés par une virgule. L'exemple suivant déclare la variable
lists.

mylist=[] # liste vide

print(mylist)

names=["Melvin", "Adrien", "Henri", "Merveille"] # liste de chaînes de caractères

print(names)

item=[1, "Jeff", "Computer", 75.50, True] # liste avec des données de différents types
print(item)

Une liste peut contenir un nombre illimité de données, en fonction des limites de la mémoire de votre
ordinateur.

nums=
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37

Accès aux éléments de la liste

Les éléments de la liste sont accessibles à l'aide d'un index basé sur zéro entre crochets []. Les index
commencent à zéro et sont incrémentés de un pour chaque élément. Accéder à un élément en utilisant un
index plus grand que le nombre total d'éléments de la liste entraînerait une IndexError .

names=["Melvin", "Adrien", "Henri", "Merveille"]

print(names[0]) # renvoie "Melvin".
print(names[1]) # renvoie "Adrien".
print(names[2]) # renvoie "Henri".
print(names[3]) # renvoie "Merveille".
print(names[4]) # renvoie IndexError : list index out of range (erreur d'indexation)

Page 7 of 13
Une liste peut contenir plusieurs listes internes comme éléments accessibles à l'aide d'index.

nums=[1, 2, 3, [4, 5, 6, [7, 8, [9]]], 10]

print(names[0]) # renvoie 1
print(names[1]) # renvoie 2
print(names[3]) # retourne [4, 5, 6, [7, 8, [9]]]
print(names[4]) # renvoie 10
print(names[3][0]) # renvoie 4
print(noms[3][3])
print(nums[3][3][0]) # renvoie 7
print(nums[3][3][2]) # renvoie [9]

Classe de liste
Tous les objets de liste sont des objets de la classe list de Python. Utilisez le constructeur list() pour convertir
d'autres types de séquence tels que tuple, set, dictionnaire, string en liste.

nums=[1,2,3,4]
print(type(nums))

mylist=list('Hello')
print(mylist)

nums=list({1:'one',2:'two'})
print(nums)

nums=list((10, 20, 30))

print(nums)

nums=list({100, 200, 300})

print(nums)

nous obtenons les résultats suivants :

<classe 'liste'>
['H', 'e', 'l', 'l', 'o']
[1, 2]
[10, 20, 30]
[100, 200, 300]

Tuples
Un tuple est une collection immuable (non modifiable) d'éléments de différents types de données. Il s'agit d'une
collection ordonnée, qui conserve donc l'ordre des éléments dans lequel ils ont été définis.
Les tuples sont définis en plaçant les éléments entre parenthèses () , séparés par une virgule. L'exemple suivant
déclare une variable de type tuple.

Page 8 of 13
 tpl=() # tuple vide
print(tpl)

names = ('Melvin', 'Henri', 'Adrien', 'Merveille') # tuple de type chaîne de caractères

print(names)

nums = (1, 2, 3, 4, 5) # tuple d'entiers

print(nums)

employee=(1, 'Steve', True, 25, 12000) # tuple de données hétérogènes

print(employé)

Cependant, il n'est pas nécessaire de mettre les éléments du tuple entre parenthèses. L'objet tuple peut inclure
des éléments séparés par une virgule sans parenthèses.

names = 'Melvin', 'Henri', 'Adrien', 'Merveille' # tuple de chaînes de caractères

print(noms)

nums = 1, 2, 3, 4, 5 # tuple d'entiers

print(nums)

Les tuples ne peuvent pas être déclarés avec un seul élément, sauf s'ils sont suivis d'une virgule.

names = ('Melvin') # considéré comme un type de chaîne de caractères

print(noms)
print(type(names))

names = ('Melvin',) # tuple avec un seul élément

print(noms)
print(type(noms))

Accès aux éléments du tuple

L'accès à chaque élément du tuple se fait par l'index entre les crochets [] . Un index commence par zéro et se
termine par (nombre d'éléments - 1), comme indiqué ci-dessous.

noms = ('Melvin', 'Bill', 'Reed', 'Yash')

print(names[0]) # Imprime 'Melvin'.
print(names[1]) # Imprime 'Bill'.
print(names[2]) # Imprime 'Reed'.
print(names[3]) # Imprime 'Yash'.

nums = (1, 2, 3, 4, 5)
print(nums[0]) # imprime 1
print(nums[1]) # imprime 2
print(nums[4]) # imprime 5

Le tuple supporte également l'indexation négative, comme le type liste. L'index négatif pour le premier élément
commence à partir de -nombre d'éléments et se termine par -1 pour le dernier élément.
Si l'élément à l'index spécifié n'existe pas, alors l'erreur "index out of range" sera lancée.

Page 9 of 13
 >>> noms[5]
Traceback (dernier appel le plus récent) :
Fichier "<stdin>", ligne 1, dans <module>.
IndexError : l'index du tuple est hors de portée

Les éléments de tuple peuvent être décompressés et assignés à des variables, comme indiqué ci-dessous.
Cependant, le nombre de variables doit correspondre au nombre d'éléments d'un tuple, sinon une erreur sera
lancée.

Mettre à jour ou supprimer des éléments de Tuple

Les tuple sont immuables. Ainsi, une fois qu'un tuple est créé, toute opération visant à modifier son contenu
n'est pas autorisée. Par exemple, si vous essayez de modifier ou de supprimer un élément du tuple names , vous
obtiendrez une erreur.

>>> noms = ('Melvin', 'Adrien', 'Henri', 'Merveille')

>>> noms[0] = "Ewane
Traceback (dernier appel le plus récent) :
Fichier "<stdin>", ligne 1, dans <module>
TypeError : L'objet 'tuple' ne supporte pas l'affectation d'éléments.

>>> del names[0]

Traceback (dernier appel le plus récent) :
File "<stdin>", line 1, in <module>
TypeError : L'objet 'tuple' ne supporte pas la suppression d'éléments.

Cependant, vous pouvez supprimer un tuple entier en utilisant le mot-clé del .

>>> del noms

Classe de tuple
Le type sous-jacent d'un tuple est la classe de tuple. Vérifiez le type d'une variable en utilisant la fonction
type() .

names = ('Melvin', 'Henri', 'Adrien', 'Merveille') # tuple de chaînes de caractères

print(type(names))
-------------
<classe 'tuple'>

Le constructeur tuple() est utilisé pour convertir tout itérable en type tuple.

tpl = tuple([1,2,3,4,5]) # convertit une liste en tuple

print(tpl)

4. Types d'ensembles
Un ensemble est une collection mutable d'objets hachables distincts, comme la liste et le tuple. C'est une
collection d'objets non ordonnée, ce qui signifie qu'elle n'enregistre pas la position ou l'ordre d'insertion des
éléments et qu'elle ne peut donc pas accéder aux éléments à l'aide d'index.
Page 10 of 13
L'ensemble est une implémentation Python de l'ensemble en mathématiques. Un objet set possède des
méthodes appropriées pour effectuer des opérations mathématiques comme l'union, l'intersection, la différence,
etc.
Un objet set contient un ou plusieurs éléments, pas nécessairement du même type, qui sont séparés par une
virgule et encadrés par des accolades {}. L'exemple suivant définit un objet set avec des nombres pairs.

>>> nums = {1, 2, 2, 3, 4, 4, 5, 5}

>>> nums
{1, 2, 3, 4, 5}

L'ordre des éléments dans l'ensemble n'est pas nécessairement le même que l'ordre donné au moment de
l'affectation. Python optimise la structure d'un ensemble pour effectuer des opérations sur celui-ci, comme défini
en mathématiques.
Seuls les objets immuables (et hachables) peuvent faire partie d'un objet set. Les nombres (entiers, flottants, ainsi
que complexes), les chaînes de caractères et les objets tuple sont acceptés, mais les objets set, list et dictionnaire
ne le sont pas.

>>> myset = {(10,10), 10, 20} # valide

>>> myset
{10, 20, (10, 10)}
>>> myset = {[10, 10], 10, 20} # ne peut pas ajouter une liste
Traceback (dernier appel le plus récent) :
Fichier "<pyshell#9>", ligne 1, dans <module>
myset = {[10, 10], 10, 20}
TypeError : unhashable type : 'list'.
>>> myset = { {10, 10}, 10, 20} # ne peut pas ajouter un ensemble
Traceback (dernier appel le plus récent) :
Fichier "<pyshell#9>", ligne 1, dans <module>
myset = { {10, 10}, 10, 20}
TypeError : unhashable type : 'set' (erreur de type)

Dans l'exemple ci-dessus, (10,10) est un tuple, il fait donc partie de l'ensemble. Cependant, [10,10] est une liste,
et un message d'erreur s'affiche indiquant que la liste n'est pas hachable. (Le hachage est un mécanisme en
informatique qui permet une recherche plus rapide des objets dans la mémoire de l'ordinateur).
Même si les objets mutables ne sont pas stockés dans un ensemble, l'ensemble lui-même est un objet mutable.
Nous utilisons la fonction set() pour créer un ensemble vide. Des accolades vides créeront un dictionnaire
vide au lieu d'un ensemble vide.

>>> emp = {} # crée un dictionnaire vide

>>> type(emp)
<classe 'dict'>
>>> s = set() # crée un ensemble vide
>>> type(s)
<classe 'set'>

La fonction set() permet également de convertir un objet de type chaîne, tuple ou dictionnaire en un objet
de type set, comme indiqué ci-dessous.

Page 11 of 13
 >>> s = set('Hello') # convertit une chaîne en ensemble
>>> s
{'l', 'H', 'o', 'e'}
>>> s = set((1,2,3,4,5)) # convertit un tuple en ensemble
>>> s
{1, 2, 3, 4, 5}
>>> d = {1 : 'One', 2 : 'Two'}
>>> s = set(d) # convertit un dict en ensemble
>>> s
{1, 2}

5. Type de mappage (Dictionnaire)

Le dictionnaire est une collection non ordonnée qui contient des paires clé:valeur séparées par des virgules entre
crochets. Les dictionnaires sont optimisés pour récupérer les valeurs lorsque la clé est connue.
L'exemple suivant déclare un objet dictionnaire.

numNames={1 : "One", 2 : "Two", 3 : "Three"} # int key, string value

Ci-dessus, numNames est un objet dictionnaire qui contient des paires clé-valeur à l'intérieur de {} . Le côté
gauche de : est une clé, et le côté droit est une valeur. La clé doit être unique et un objet immuable. Un nombre,
une chaîne ou un tuple peuvent être utilisés comme clé. Par conséquent, les dictionnaires suivants sont
également valides :

d = {} # dictionnaire vide

numNames={1 : "One", 2 : "Two", 3 : "Three"} # clé int, valeur string

decNames={1.5 : "Un et demi", 2.5 : "Deux et demi", 3.5 : "Trois et demi"} # clé float,
valeur string

romanNums = {'I':1, 'II':2, 'III':3, 'IV':4, 'V':5} # clé chaîne de caractères, valeur int

Cependant, un dictionnaire avec une liste comme clé n'est pas valide, car la liste est mutable :

dict_obj = {["Mango", "Banana"] : "Fruit", ["Blue", "Red"] : "Couleur"}

Mais une liste peut être utilisée comme une valeur.

dict_obj = {"Fruit" :["Mango", "Banana"], "Color" :["Blue", "Red"]}

La même clé ne peut pas apparaître plus d'une fois dans une collection. Si la clé apparaît plus d'une fois, seule la
dernière sera retenue. La valeur peut être de n'importe quel type de données. Une valeur peut être affectée à
plus d'une clé.

>>> numNames = {1 : "One", 2 : "Two", 3 : "Three", 2 : "Two", 1 : "One"}

>>> numNames
{1 : "One", 2 : "Two", 3 : "Three"}

Page 12 of 13
Le dict est la classe de tous les dictionnaires, comme indiqué ci-dessous.

>>> numNames = {1 : "One", 2 : "Two", 3 : "Three", 2 : "Two", 1 : "One"}

>>> type(numNames)
<classe 'dict'>

Un dictionnaire peut également être créé en utilisant la méthode du constructeur dict().

>>> emptydict = dict()

>>> emptydict
{}
>>> numdict = dict(I='un', II='deux', III='trois')
>>> numdict
{'I' : 'un', 'II' : 'deux', 'III' : 'trois'}

Accès au dictionnaire
Le dictionnaire est une collection non ordonnée, il n'est donc pas possible d'accéder à une valeur à l'aide d'un
index ; à la place, une clé doit être spécifiée entre les crochets, comme illustré ci-dessous.

>>> numNames = {1:"One", 2:"Two", 3:"Three", 2:"Two", 1:"One"}

>>> numNames[1]
One
>>> numNames[2]
Two

Note : Les clés sont sensibles à la casse. Si la clé spécifiée n'existe pas, une erreur sera levée.

Utilisez la méthode get() pour récupérer la valeur de la clé même si les clés ne sont pas connues. Elle renvoie
None si la clé n'existe pas au lieu de lever une erreur.

>>> numNames = {1 : "One", 2 : "Two", 3 : "Three", 2 : "Two", 1 : "One"}

>>> numNames.get(1)
One

Page 13 of 13
Opérateurs
Les opérateurs sont des symboles spéciaux qui effectuent une opération sur les opérandes et renvoient le
résultat. Par exemple, 5 + 6 est une expression où + est un opérateur qui effectue une opération d'addition
arithmétique sur l'opérande numérique de gauche 5 et l'opérande de droite 6 et renvoie une somme de deux
opérandes comme résultat.

>>> 5 + 6
11

Python inclut le module operator qui comprend des méthodes sous-jacentes pour chaque opérateur. Par
exemple, l'opérateur + appelle la méthode operator.add(a,b) .

>>> import operator

>>> operator.add(5, 6)
11
>>> operator.__add__(5, 6)
11

Python comprend les catégories d'opérateurs suivantes :

Opérateurs arithmétiques
Opérateurs d'assignation
Opérateurs de comparaison
Opérateurs logiques
Opérateurs d'identité
Opérateurs de test d'appartenance
Opérateurs binaires
Nous nous concentrerons ci-dessous sur les opérateurs arithmétiques, d'affectation, de comparaison et logiques.
Nous vous encourageons à faire des recherches sur les trois autres.

Les opérateurs d'identité et d'appartenance seront utilisés plus tard dans la prise de décision et
les boucles.

Opérateurs arithmétiques
Les opérateurs arithmétiques effectuent l'opération mathématique courante sur les opérandes numériques.
Les opérateurs arithmétiques renvoient le type de résultat qui dépend du type d'opérandes, comme ci-dessous.
1. Si l'un des opérandes est un nombre complexe, le résultat est converti en complexe ;
2. Si l'un des opérandes est un nombre à virgule flottante, le résultat est converti en virgule flottante. 3 ;
3. Si les deux opérandes sont des nombres entiers, le résultat est un nombre entier et aucune conversion
n'est nécessaire.
Le tableau suivant liste tous les opérateurs arithmétiques en Python : nous supposons que a =10 et b=12

Opérateur arithmétique Opérateur Fonction Exemple

Page 1 of 4
 Opérateur arithmétique Opérateur Fonction Exemple
Addition : Somme de deux opérandes + operator.add(a,b) a+b=22
Soustraction : Opérande de gauche - operator.sub(a,b) a-b=-2
moins opérande de droite
Multiplication * operator.mul(a,b) a*b
Exponentiation : Opérande de gauche ** operator.pow(a,b) a**b=1000000000000
élevé à la puissance de celui de droite
Division / operator.truediv(a,b) a/b=0.833333333333333334
Division plancher : équivalent à // operator.floordiv(a,b) a//b=0 et b//a=1
math.floor(a/b)
Modulus : Rappel de a/b % operator.mod(a, b) a%b=0

a = 21
b = 10
c=0
c=a+b
print ("Ligne 1 - La valeur de c est ", c)
c=a-b
print ("Ligne 2 - La valeur de c est ", c)
c=a*b
print ("Ligne 3 - La valeur de c est ", c)
c=a/b
print ("Ligne 4 - La valeur de c est ", c)
c=a%b
print ("Ligne 5 - La valeur de c est ", c)
a=2
b=3
c = a**b
print ("Ligne 6 - La valeur de c est ", c)
a = 10
b=5
c = a//b
print ("Ligne 7 - La valeur de c est ", c)

Que retournera chaque instruction print dans l'exemple ci-dessus ?

Opérateurs de comparaison
Les opérateurs de comparaison comparent deux opérandes et renvoient un booléen, soit Vrai, soit Faux. Ils sont
également appelés opérateurs relationnels. Le tableau suivant liste les opérateurs de comparaison en Python et
nous supposons que a=10 et b=12.

Opérateur de Fonction Description Exemple

comparaison
== operator.gt(a,b) Vrai si l'opérande de gauche est supérieur à a==b
celui de droite renvoie
Faux

Page 2 of 4
 Opérateur de Fonction Description Exemple
comparaison
!= opérateur.ne(a,b) Vrai si les opérandes ne sont pas égaux a!=b .
renvoie Vrai
> operator.gt(a,b) Vrai si l'opérande de gauche est supérieur à a>b renvoie
celui de droite False
< operator.lt(a,b) Vrai si l'opérande de gauche est inférieur à a<b renvoie .
celui de droite True
>= operator.ge(a,b) Vrai si l'opérande de gauche est supérieur ou a>=b .
égal à celui de droite renvoie
False
<= opérateur.le(a,b) Vrai si l'opérande de gauche est inférieur ou a<=b .
égal à l'opérande de droite renvoie Vrai

Nous utiliserons principalement ces opérateurs lorsqu'une décision doit être prise avant l'exécution de certaines
instructions.

Opérateurs d'assignation
Les opérateurs d'affectation sont utilisés pour attribuer des valeurs aux variables. Le tableau suivant liste tous les
opérateurs arithmétiques de Python.

Opérateur Fonction Exemple .

= x=10
+= operator.iadd(a,b) x+=2 renvoie x = 12
-= operator.isub(a,b) x-=5 renvoie x = 7
*= operator.imul(a,b) x*=2 renvoie x = 14
/= operator.itruediv(a,b) x/=2 renvoie x = 7
//= operator.floordiv(a,b) x//=2 renvoie x =3
%= operator.imod(a,b) x%=2 renvoie x = 1

Complétons l'exemple ci-dessous en donnant les réponses des instructions d'impression

Page 3 of 4
 a = 21
b = 10
c=0
c=a+b
print ("Ligne 1 - La valeur de c est ", c)
c += a
print ("Ligne 2 - La valeur de c est ", c )
c *= a
print ("Ligne 3 - La valeur de c est ", c )
c /= a
print ("Ligne 4 - La valeur de c est ", c )
c=2
c %= a
print ("Ligne 5 - La valeur de c est ", c)
c **= a
print ("Ligne 6 - La valeur de c est ", c)
c //= a
print ("Line 7 - Value of c is ", c)

Opérateurs logiques
Les opérateurs logiques sont utilisés pour combiner deux expressions booléennes. Les opérations logiques sont
généralement applicables à tous les objets et prennent en charge les tests de vérité, les tests d'identité et les
opérations booléennes. Nous supposons que x=5 et y=6

Opérateur Description Exemple .

et Vrai si les deux sont vrais x > 1 et y <10 retourne Vrai .
ou Vrai si au moins l'un des deux est vrai x > 6 ou y <10 renvoie Vrai .
Not Retourne Vrai si une expression est fausse et vice-versa not x > 1 retourne Faux .

Page 4 of 4
Prise de décision
Par défaut, les instructions du script sont exécutées de manière séquentielle, de la première à la dernière. Si la
logique de traitement l'exige, le flux séquentiel peut être modifié de deux manières :
Python utilise le mot-clé if pour implémenter le contrôle de la décision. La syntaxe Python pour l'exécution
conditionnelle d'un bloc est la suivante :

if [expression booléenne] :
déclaration1
instruction2
...
déclaration

Toute expression booléenne valant True ou Faux apparaît après le mot-clé if. Utilisez le symbole : et
appuyez sur la touche Entrée après l'expression pour commencer un bloc avec une indentation accrue. Une ou
plusieurs instructions écrites avec le même niveau d'indentation seront exécutées si l'expression booléenne est
évaluée à Vrai .

Pour terminer le bloc, diminuez l'indentation. Les instructions qui suivent le bloc seront exécutées sans tenir
compte de la condition "si". L'exemple suivant illustre la condition "si". Le site

price = 50

if price < 100:

print("price is less than 100")

Dans l'exemple ci-dessus, l'expression prix < 100 est évaluée à Vrai , elle va donc exécuter le bloc. Le bloc
if commence à la nouvelle ligne après : et toutes les déclarations sous la condition if commencent avec une
indentation accrue, soit un espace ou une tabulation. Ci-dessus, le bloc "if" ne contient qu'une seule instruction.
L'exemple suivant contient plusieurs instructions dans la condition "if".

price = 50
quantity = 5
if price*quantity < 500:
print("price*quantity is less than 500")
print("price = ", price)
print("quantity = ", quantity)

Le code ci-dessus lorsqu'il est exécuté donne le résultat suivant :

price*quantity is less than 500

price = 50
quantity = 5

Ci-dessus, la condition if contient plusieurs instructions avec la même indentation. Si toutes les instructions ne
sont pas dans la même indentation, que ce soit un espace ou une tabulation, alors il y aura une
IdentationError .

Page 1 of 5
 price = 50
quantity = 5
if price*quantity < 500:
print("price is less than 500")
print("price = ", price)
print("quantity = ", quantity)

l'erreur suivante se produira :

print("quantity = ", quantity)

^
IdentationError: unexpected indent

Les instructions ayant le même niveau d'indentation que la condition if ne seront pas prises en compte dans le
bloc if. Elles seront prises en compte en dehors de la condition if.

price = 50
quantity = 5
if price*quantity < 100:
print("price is less than 500")
print("price = ", price)
print("quantity = ", quantity)
print("No if block executed.")

Si nous avons plusieurs conditions, nous pouvons utiliser plusieurs instructions if. L'exemple suivant montre
l'utilisation de plusieurs instructions if.

price = 100

if price > 100:

print("price is greater than 100")

if price == 100:
print("price is 100")

if price < 100:

print("price is less than 100")

Remarquez que chaque bloc if contient une déclaration dans une indentation différente, et c'est valable parce
qu'ils sont différents les uns des autres.

Il est recommandé d'utiliser 4 espaces ou une tabulation comme niveau d'indentation par défaut
pour plus de lisibilité.

Instruction Else
Avec l'instruction "if", la condition "else" peut être utilisée pour définir un autre bloc d'instructions à exécuter si
l'expression booléenne de la condition "if" vaut "False".

Page 2 of 5
 if [boolean expression]:
statement1
statement2
...
statementN
else:
statement1
statement2
...
statementN

Comme mentionné précédemment, le bloc indenté commence après le symbole : , après l'expression
booléenne. Il sera exécuté lorsque la condition est "Vrai". Nous avons un autre bloc qui doit être exécuté lorsque
la condition if est False . Tout d'abord, complétez le bloc if par un backspace et écrivez else , mettez le
symbole : devant le nouveau bloc pour le commencer, et ajoutez les instructions requises dans le bloc.

Exemple d'instruction else ci-dessous :

price = 50

if price >= 100:

print("price is greater than 100")
else:
print("price is less than 100")

Dans l'exemple ci-dessus, la condition if price >= 100 est False , donc le bloc else sera exécuté. Le bloc
else peut également contenir plusieurs instructions avec la même indentation ; sinon, il déclenchera le message
IndentationError .

Notez que vous ne pouvez pas avoir plusieurs blocs else , et qu'il doit être le dernier bloc.

Déclaration Elif
La condition elif est utilisée pour inclure plusieurs expressions conditionnelles après la condition if ou entre
les conditions if et else .

if [boolean expression]:
[statements]
elif [boolean expresion]:
[statements]
elif [boolean expresion]:
[statements]
else:
[statements]

Le bloc elif est exécuté si la condition spécifiée est évaluée à True.

Exemple : Conditions "if-elif

Page 3 of 5
 price = 100

if price > 100:

print("price is greater than 100")
elif price == 100:
print("price is 100")
elif price < 100:
print("price is less than 100")

Sortie

price is 100

Dans l'exemple ci-dessus, les conditions elif sont appliquées après la condition if. Python évaluera la
condition if et si elle est évaluée à False, il évaluera les blocs elif et exécutera le bloc elif dont l'expression
est évaluée à True. Si plusieurs conditions elif deviennent vraies, alors le premier bloc elif sera exécuté.
L'exemple suivant illustre les conditions if , elif et else .
Exemple : Conditions "if-elif-else

price = 50

if price > 100:

print("price is greater than 100")
elif price == 100:
print("price is 100")
else price < 100:
print("price is less than 100")

Sortie

price is less than 100

Toutes les conditions if , elif et else doivent commencer au même niveau d'indentation, sinon l'erreur
IndentationError sera levée.

Exemple : Indentation non valide

Page 4 of 5
 prix = 50

price = 50

if price > 100:

print("price is greater than 100")
elif price == 100:
print("price is 100")
else price < 100:
print("price is less than 100")
---------------------------------
elif price == 100:
^
IdentationError: unindent does not match any outer indentation level

Conditions if, elif, else imbriquées

Python supporte les conditions imbriquées if , elif et else . La condition intérieure doit avoir une
indentation plus grande que la condition extérieure, et toutes les instructions d'un même bloc doivent avoir la
même indentation.
Exemple : Conditions "if-elif-else" imbriquées

price = 50
quantity = 5
amount = price*quantity

if amount > 100:

if amount > 500:
print("Amount is greater than 500")
else:
if amount < 500 and amount > 400:
print("Amount is")
elif amount < 500 and amount > 300:
print("Amount is between 300 and 500")
else:
print("Amount is between 200 and 500")
elif amount == 100:
print("Amount is 100")
else:
print("Amount is less than 100")

Page 5 of 5
Boucles Python
En général, les instructions sont exécutées séquentiellement - La première instruction d'une fonction est
exécutée en premier, suivie de la seconde, et ainsi de suite. est exécutée en premier, suivie de la seconde, et ainsi
de suite. Il peut arriver que vous deviez d'exécuter un bloc de code plusieurs fois.
Les langages de programmation fournissent diverses structures de contrôle qui permettent des chemins
d'exécution plus complexes. chemins d'exécution plus complexes.
Une instruction de boucle nous permet d'exécuter une instruction ou un groupe d'instructions plusieurs fois. Le
schéma suivant illustre une instruction de boucle.
Le langage de programmation Python propose les types de boucles suivants pour répondre aux besoins de
bouclage exigences.
boucle while : répète une instruction ou un groupe d'instructions tant qu'une condition donnée est
VRAIE. Elle teste la condition avant d'exécuter le corps de la boucle.
boucle for : exécute une séquence d'instructions plusieurs fois et abrège le code qui gère la boucle.
abrège le code qui gère la variable de la boucle.
Boucles imbriquées : Vous pouvez utiliser une ou plusieurs boucles à l'intérieur d'une autre boucle while
ou for.
Nous nous concentrerons principalement sur les boucles while et for.
Les boucles imbriquées seront traitées plus tard dans nos sessions d'exercices.

Boucle while
Une instruction de boucle while en langage de programmation Python exécute de manière répétée une
instruction cible cible tant qu'une condition donnée est vraie.

expression while :
instruction(s)

Ici, l'instruction(s) peut être une seule instruction ou un bloc d'instructions avec une indentation uniforme.
indentation uniforme. La condition peut être une expression quelconque, et true une valeur non nulle. La boucle
itère tant que la condition est vraie.
Lorsque la condition devient fausse, le contrôle du programme passe à la ligne qui suit immédiatement la
boucle. qui suit immédiatement la boucle.
En Python, toutes les déclarations indentées par le même nombre d'espaces caractères après une construction
de programmation sont considérées comme faisant partie de la boucle. après une construction de
programmation sont considérées comme faisant partie d'un seul bloc de code. Python utilise l'indentation
comme méthode de regroupement des instructions.
L'exemple ci-dessous montre comment utiliser une boucle while .
num =0

Page 1 of 4
 alors que num < 5 :
num = num + 1
print('num = ', num)

Nous aurons la sortie suivante :

num = 1
num = 2
num = 3
num = 4
num = 5

Ici, le bloc répétitif après l'instruction while consiste à incrémenter la valeur d'une variable entière et à l'imprimer.
Avant le début du bloc, la variable num est initialisée à 0. Jusqu'à ce qu'elle soit inférieure à 5, num est
incrémentée de 1 et imprimée pour afficher la séquence de chiffres, comme ci-dessus.
Toutes les instructions du corps de la boucle doivent commencer avec la même indentation, sinon une
IndentationError sera générée.

num =0
pendant que num < 5 :
num = num + 1
print('num = ', num)

Sortie :

print('num = ', num)

^
IndentationError : indentation inattendue

Les boucles sont des outils formidables lorsqu'elles sont utilisées correctement en programmation, mais
lorsqu'on les utilise, on rencontre de temps en temps des boucles infinies.

La boucle infinie
Une boucle devient une boucle infinie si une condition ne devient jamais FAUX. Vous devez être prudent lorsque
vous utilisez des boucles while, car il est possible que cette condition ne devienne jamais un fausse. Il en résulte
une boucle qui ne se termine jamais. Une telle boucle est appelée une boucle infinie.
Exemple de boucle infinie :

val = 1
while val==1 :
print("hello")

Le code ci-dessus affichera "hello" à l'infini.

Nous devrions éviter autant que possible les boucles infinies lors de l'écriture de programmes.

Page 2 of 4
Boucle For
En Python, le mot-clé for fournit un mécanisme plus complet pour constituer une boucle. La boucle for est
utilisée avec des types de séquence tels que liste, tuple, set, range, etc.
Le corps de la boucle for est exécuté pour chaque élément membre de la séquence. Par conséquent, elle ne
nécessite pas la vérification explicite d'une expression booléenne contrôlant la boucle (comme dans la boucle
while).

pour x dans la séquence :

instruction1
instruction2
...
instructionN

Pour commencer, la variable x dans l'instruction for fait référence à l'élément situé à l'indice 0 dans la
séquence. Le bloc d'instructions avec une indentation uniforme accrue après le symbole : sera exécuté. La
variable x fait maintenant référence à l'élément suivant et répète le corps de la boucle jusqu'à ce que la
séquence soit épuisée.
L'exemple suivant illustre la boucle for avec l'objet liste.

nums = [10, 20, 30, 40, 50]

pour i dans nums :
print(i)

Sortie

10
20
30
40
50

L'exemple suivant démontre la boucle for avec un objet tuple.

nombres = (10, 20, 30, 40, 50)

pour i dans nums :
print(i)

Sortie

10
20
30
40

L'objet de tout type de données de séquence Python peut être itéré à l'aide de l'instruction for .

Page 3 of 4
 Exemple : Boucle For avec une chaîne de caractères
for char in 'Hello' :
print (char)

Sortie :

H
e
l
l
o

La boucle for suivante itère sur le dictionnaire en utilisant la méthode items() .

numNames = { 1 : 'One', 2 : 'Two', 3 : 'Three'}

for paire in numNames.items() :
print(paire)

Sortie

(1, 'One')
(2, 'Two')
(3, 'Three')

La paire clé-valeur peut être décomposée en deux variables dans la boucle for pour obtenir la clé et la valeur
séparément.

numNames = { 1:'One', 2: 'Two', 3: 'Three'}

for k,v in numNames.items():
print("key = ", k , ", value =", v)

Sortie :

key = 1, value = One

key = 2, value = Two
key = 3, value = Three

Page 4 of 4
Python - Fonctions
Python comprend de nombreuses fonctions intégrées. Ces fonctions effectuent une tâche prédéfinie et peuvent
être appelées dans n'importe quel programme, selon les besoins. Toutefois, si vous ne trouvez pas de fonction
intégrée adaptée à vos besoins, vous pouvez en définir une. Nous allons maintenant voir comment définir et
utiliser une fonction dans un programme Python.

Définir une fonction

Une fonction est un bloc réutilisable d'instructions de programmation conçu pour effectuer une certaine tâche.
Pour définir une fonction, Python fournit le mot-clé def . Voici la syntaxe de la définition d'une fonction.

def function_name(parameters):
"""docstring"""
statement1
statement2
...
...
return [expr]

Le mot-clé def est suivi d'un identifiant approprié comme nom de la fonction et de parenthèses. Un ou
plusieurs paramètres peuvent éventuellement être mentionnés entre parenthèses. Le symbole : après les
parenthèses commence un bloc indenté.
La première déclaration du corps de la fonction peut être une chaîne de caractères, appelée docstring . Elle
explique la fonctionnalité de la fonction/classe. Le docstring n'est pas obligatoire.
Le corps de la fonction contient une ou plusieurs instructions qui effectuent certaines actions. Il peut également
utiliser le mot-clé pass .
La dernière instruction du bloc fonction peut être l'instruction return. Elle renvoie un contrôle d'exécution à
l'environnement d'appel. Si une expression est ajoutée devant return, sa valeur est également renvoyée au code
appelant.
L'exemple suivant définit la fonction greet().

def greet():
"""This function displays 'Hello World!'"""
print('Hello World!')

Ci-dessus, nous avons défini la fonction greet() . La première déclaration est une docstring qui mentionne ce
que fait cette fonction. La deuxième comme est une méthode print qui affiche la chaîne spécifiée à la
console. Notez qu'elle n'a pas d'instruction de retour.
Pour appeler une fonction définie, il suffit d'utiliser son nom comme déclaration n'importe où dans le code. Par
exemple, la fonction ci-dessus peut être appelée en utilisant les parenthèses, greet() .
Exemple : Appel d'une fonction définie par l'utilisateur

greet()

Sortie :
Page 1 of 5
 Hello World !

Par défaut, toutes les fonctions retournent None si l'instruction de retour n'existe pas.
Exemple : Appel d'une fonction définie par l'utilisateur

val = greet()
print(val)

Sortie

Aucun

La fonction help() affiche la docstring, comme indiqué ci-dessous.

Exemple : Appel d'une fonction définie par l'utilisateur (dans la console python)

>>> help(greet)
Help on function greet in module __main__:
greet()
This function displays 'Hello World!'

Paramètres de la fonction
Il est possible de définir une fonction pour recevoir un ou plusieurs paramètres (également appelés arguments)
et les utiliser pour le traitement à l'intérieur du bloc fonction. Les paramètres/arguments peuvent recevoir des
noms formels appropriés. La fonction greet() est maintenant définie pour recevoir un paramètre de type
chaîne de caractères appelé name . À l'intérieur de la fonction, l'instruction print() est modifiée pour afficher
le message d'accueil adressé au paramètre reçu.
Exemple : Fonction paramétrée

def greet(name):
print ('Hello ', name)
greet('Steve') # calling function with argument
greet(123)

Sortie :

Hello Steve
Hello 123

Les noms des arguments utilisés dans la définition de la fonction sont appelés arguments/paramètres formels.
Les objets réellement utilisés lors de l'appel de la fonction sont appelés arguments/paramètres réels.
Les paramètres de la fonction peuvent avoir une annotation pour spécifier le type du paramètre en utilisant la
syntaxe parameter:type . Par exemple, l'exemple suivant annote le paramètre de type string.

Page 2 of 5
Exemple :

def greet(name:str):
print ('Hello ', name)
greet('Steve') # calling function with string argument
greet(123) # raise an error for int argument

Paramètres multiples
Une fonction peut avoir plusieurs paramètres. La fonction suivante prend trois arguments.

def greet(name1, name2, name3):

print ('Hello ', name1, ' , ', name2 , ', and ', name3)
greet('Steve', 'Bill', 'Yannick') # calling function with string argument

Sortie :

Hello Steve, Bill, and Yannick

La fonction suivante fonctionne avec un nombre quelconque d'arguments.

def greet(*names):
i=0
print('Hello ', end='')
while len(names) > i:
print(names[i], end=', ')
i+=1
greet('Steve', 'Bill', 'Yash')
greet('Steve', 'Bill', 'Yash', 'Kapil', 'John', 'Amir')

Sortie :

Hello Steve, Bill, Yash,

Hello Steve, Bill, Yash, Kapil, John, Amir

Fonction avec des arguments de type mot-clé

Afin d'appeler une fonction avec des arguments, le même nombre d'arguments réels doit être fourni.
Cependant, une fonction peut être appelée en passant les valeurs des paramètres en utilisant les noms des
paramètres dans n'importe quel ordre. Par exemple, l'exemple suivant transmet des valeurs en utilisant les noms
des paramètres.

def greet(firstname, lastname):

print ('Hello', firstname, lastname)
# passing parameters in any order using keyword argument
greet(lastname='Jobs', firstname='Steve')

Page 3 of 5
Sortie :

Hello Steve Jobs

Argument de mot-clé **kwarg

La fonction peut avoir un seul paramètre préfixé par **. Ce type de paramètre est initialisé à un nouveau
mappage ordonné recevant tout argument mot-clé excédentaire, et se transforme par défaut en un nouveau
mappage vide du même type.

def greet(**person):
print('Hello ', person['firstname'], person['lastname'])
greet(firstname='Steve', lastname='Jobs')
greet(lastname='Jobs', firstname='Steve')
greet(firstname='Bill', lastname='Gates', age=55)
greet(firstname='Bill') # raises KeyError

Sortie :

Hello Steve Jobs

Hello Steve Jobs
Hello Bill Gates

Lorsque vous utilisez le paramètre ** , l'ordre des arguments n'a pas d'importance. Cependant, le nom des
arguments doit être le même. Accédez à la valeur des arguments de mot-clé en utilisant
paramter_name['keyword_argument'] .
Si la fonction accède à l'argument mot-clé mais que le code appelant ne passe pas cet argument mot-clé, alors
elle lèvera l'exception KeyError , comme indiqué ci-dessous.

def greet(**person):
print('Hello ', person['firstname'], person['lastname'])
greet(firstname='Bill') # raises KeyError, must provide 'lastname' arguement

Sortie :

Traceback (most recent call last):

File "<pyshell#21>", line 1, in <module>
greet(firstname='Bill')
File "<pyshell#19>", line 2, in greet
print('Hello ', person['firstname'], person['lastname'])
KeyError: 'lastname'

Paramètre avec une valeur par défaut

Lors de la définition d'une fonction, des valeurs par défaut peuvent être attribuées à ses paramètres. Cette valeur
par défaut est remplacée si un argument réel approprié est transmis lors de l'appel de la fonction. Toutefois, si
l'argument réel n'est pas fourni, la valeur par défaut sera utilisée dans la fonction.

Page 4 of 5
La fonction greet() suivante est définie avec le paramètre name ayant la valeur par défaut 'Guest'. Il ne sera
remplacé que si un argument réel est passé.

def greet(name = 'Guest') :

print ('Hello', name)
greet()
greet('Steve')

Sortie :

Hello Guest
Hello Steve

Fonction avec valeur de retour

La plupart du temps, nous avons besoin du résultat de la fonction pour l'utiliser dans d'autres processus. Par
conséquent, lorsqu'une fonction retourne, elle doit également retourner une valeur.
Une fonction définie par l'utilisateur peut également retourner une valeur à l'environnement d'appel en plaçant
une expression devant l'instruction de retour. Dans ce cas, la valeur renvoyée doit être affectée à une variable.

Exemple : Valeur de retour

def sum(a, b) :
return a + b

La fonction ci-dessus peut être appelée et fournir la valeur, comme indiqué ci-dessous.

total=sum(10, 20)
print(total)
total=sum(5, sum(10, 20))
print(total)

Sortie :

30
35

Page 5 of 5