Académique Documents
Professionnel Documents
Culture Documents
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
>myvar = "John"
>my_var = "Jean"
>_my_var = "John"
>myVar = "John"
>MYVAR = "Jean"
>myvar2 = "Jean
>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.
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.
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 = y = z = "Orange"
Dans l'exemple ci-dessus, les trois variables ont pour valeur la chaîne "Orange".
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.
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.
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
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 :
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.
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
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
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.
Une chaîne littérale peut être affectée à une variable, comme indiqué ci-dessous.
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.
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.
Page 6 of 13
>>> str(100)
'100'
>>> str(-10)
'-10'
>>> str(True)
'True' (vrai)
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.
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
Page 7 of 13
Une liste peut contenir plusieurs listes internes comme éléments accessibles à l'aide d'index.
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)
<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)
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.
Les tuples ne peuvent pas être déclarés avec un seul élément, sauf s'ils sont suivis d'une virgule.
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.
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() .
Le constructeur tuple() est utilisé pour convertir tout itérable en type tuple.
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.
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.
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.
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}
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
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 :
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é.
Page 12 of 13
Le dict est la classe de tous les dictionnaires, comme indiqué ci-dessous.
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.
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.
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) .
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
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)
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.
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.
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
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
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)
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)
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 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.
price = 50
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]
Page 3 of 5
price = 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
Sortie
Toutes les conditions if , elif et else doivent commencer au même niveau d'indentation, sinon l'erreur
IndentationError sera levée.
Page 4 of 5
prix = 50
price = 50
price = 50
quantity = 5
amount = price*quantity
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)
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 :
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")
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 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.
Sortie
10
20
30
40
50
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
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.
Sortie :
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.
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
>>> 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.
Sortie :
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 :
Page 3 of 5
Sortie :
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 :
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 :
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é.
Sortie :
Hello Guest
Hello Steve
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