12/10/2023

Cybersécurité & Confiance Numérique

(CCN)

Algorithmique et programmation avancée

avec Python

Pr. Fatima zahra SALMAM

[email protected]

Partie II :
Types, affectations, expressions
Les instructions de contrôle
Les fonctions

FZ SALMAM CCN-S1(2023/2024) 2

1
 12/10/2023

Les modes d’exécution

Deux modes d’exécution d’un code Python :

 Script Python:
 la plus classique pour ceux qui ont déjà travaillé avec d'autres langages de
programmation, est d'écrire des fichiers de code source (dont l'extension
est .py), puis d'exécuter ces fichiers, à la manière du C.
 Lors de l'exécution d’un script Python, la machine virtuelle tentera d'opérer
à des optimisations en produisant du byte-code dans un fichier
d'extension .pyc pour chaque fichier d'extension .py.
 Interpréteur de commandes Python:
 Depuis l’invite de commande, il est possible d'exécuter n’importe quelle
instruction Python en tapant cette instruction et en validant grâce à la
touche "Entrée" d’un clavier d'ordinateur standard.
 L'interpréteur exécute les instructions en temps réel, dès qu’elles sont
validées par l'utilisateur. Ainsi, il n’est pas possible d'exécuter plusieurs blocs
d'instructions en une seule fois.
FZ SALMAM CCN-S1(2023/2024) 3

Identificateurs et mots clés

Identificateurs :

Définition
Un identificateur est une suite de caractères servant à désigner les
différentes entités manipulées par un programme : variables, fonctions,
classes...

En Python, un identificateur est formé de lettres ou de chiffres. Il ne contient

pas d’espace. Le premier caractère doit obligatoirement être une lettre. Il
peut contenir le caractère “_” (underscore, en français “souligné”). Il est
sensible à la casse (distinction entre majuscule et minuscule).

Les identificateurs sont sensibles à la casse et ne doivent pas être un mot

réservé de Python

FZ SALMAM CCN-S1(2023/2024) 4

2
 12/10/2023

Identificateurs et mots clés

Style de nommage :

Il est important d’utiliser une politique cohérente de nommage des

identificateurs. Voici le style utilisé dans ce cours:

• nom_de_ma_variable pour les variables ;

• NOM_DE_MA_CONSTANTE pour les constantes ;
• maFonction, maMethode pour les fonctions et les méthodes ;
• MaClasse pour les classes ;
• UneExceptionError pour les exceptions ;
• nom_de_module pour les modules et pour tous les autres
identificateurs

Exemples :
NB_ITEMS = 12 # UPPER_CASE
class MaClasse : pass # TitleCase
def maFonction() : pass # camelCase
mon_id = 5 # lower_case
FZ SALMAM CCN-S1(2023/2024) 5

Identificateurs et mots clés

Les mots réservés de Python 3

Certains mots-clés de Python sont réservés, c'est-à-dire que vous ne pouvez

pas créer des objets portant ce nom. En voici la liste pour Python 3:

and del From None True

as elif global nonlocal try
assert else if not while
break except import or with
class False in pass yield
continue Finally is raise -
def For lambda return -

FZ SALMAM CCN-S1(2023/2024) 6

3
 12/10/2023

Notion d’expression

Définition
Une expression est une portion de code que l’interpréteur Python peut
évaluer pour obtenir une valeur.
Les expressions peuvent être simples ou complexes. Elles sont formées d’une
combinaison de littéraux représentant directement des valeurs,
d’identificateurs et d’opérateurs.

>>> id1 = 15.3

>>> id2 = id1 - 13
>>> if id2 > 0:
... id3 = 7
... else:
... id3 = -4

FZ SALMAM CCN-S1(2023/2024) 7

Les types de données

Définition
Le type d’une donnée caractérise sa nature (est-ce que c’est un entier, un
nombre à virgule, une chaîne de caractères ... ?) et par voie de conséquence
les opérations qu’il est possible de lui appliquer (on peut diviser des
nombres, mais peut être pas des chaînes de caractères).

Les types dans un langage informatique dépendent fortement du codage

utilisé pour représenter les données. En algorithmique, on peut parfois se
permettre d’utiliser des types «mathématiques» qui n’ont pas
d’implémentation réelle en machine.

FZ SALMAM CCN-S1(2023/2024) 8

4
 12/10/2023

Les types de données

Le type int

Le type int (entier) n’est limité en taille que par la mémoire de la machine.
Dans la plupart des autres langages les entiers sont codés sur un nombre fixe
de bits et ont un domaine de définition limité auquel il convient de faire
attention.
Les entiers littéraux sont décimaux par défaut, mais on peut aussi utiliser les
bases suivantes :

>>> 2013 # décimal (base 10)

2013
>>> 0b11111011101 # binaire (base 2)
2013
>>> 0o3735 # octal (base 8)
2013
>>> 0x7dd # hexadecimal (base 16)
2013

FZ SALMAM CCN-S1(2023/2024) 9

Les types de données

Le type int

Opérations arithmétiques:
>>> 20 + 3
23
>>> 20 - 3
17
>>> 20 * 3
60
>>> 20 ** 3
8000
>>> 20 / 3 # produit une division flottante, même entre deux
entiers ;
6.666666666666667
>>> 20 // 3 # produit une division entière.
6
>>> 20 % 3 # modulo (reste de la division entière)
2
>>> abs(3 - 20) # valeur absolue
17

FZ SALMAM CCN-S1(2023/2024) 10

10

5
 12/10/2023

Les types de données

Le type int

Bases usuelles: Un entier écrit en base 10 (par exemple 179) peut être
représenté en binaire, octal et hexadécimal en utilisant les syntaxes
suivantes:
>>> 0b10110011 # binaire
179
>>> bin(179)
’0b10110011’
>>> 0o263 # octal
179
>>> oct(179)
’0o263’
>>> 0xB3 # hexadécimal
179
>>> hex(179)
’0xb3’

FZ SALMAM CCN-S1(2023/2024) 11

11

Les types de données

Le type bool

Les deux seules valeur du type bool sont True et False. Ces deux valeurs
peuvent être entrées littéralement ou peuvent être le résultat d’opérateurs
de comparaison, comme >, <, >=, <=, == (égal), !=
(différent).

>>> 2 > 8
False
>>> 2 <= 8 < 15
True
Les opérateurs dont les opérandes sont des booléens sont les opérateurs
logiques or, and, not

>>> (3 == 3) or (9 > 24)

True
>>> (9 > 24) and (3 == 3)
False

FZ SALMAM CCN-S1(2023/2024) 12

12

6
 12/10/2023

Les types de données

Le type float

Un float est noté avec un point décimal (jamais avec une virgule) ou en
notation exponentielle avec un « e » symbolisant le « 10 puissance » suivi des
chiffres de l’exposant. Par exemple :
2.718 .02 -1.6e-19 6.023e23

• Les flottants supportent les mêmes opérations que les entiers.

• Ils ont une précision finie limitée (virgule flottante).
• L’import du module math autorise toutes les opérations
mathématiques usuelles. Par exemple :
>>> import math
>>> print(math.sin(math.pi/4))
0.7071067811865475
>>> print(math.degrees(math.pi))
180.0
>>> print(math.factorial(9))
362880
>>> print(math.log(1024, 2))
10.0
FZ SALMAM CCN-S1(2023/2024) 13

13

Les types de données

Le type complex

Les complexes sont écrits en notation cartésienne formée de deux flottants.

La partie imaginaire est suffixée par j :
>>> print(1j)
1j
>>> print((2+3j) + (4-7j))
(6-4j)
>>> print((9+5j).real)
9.0
>>> print((9+5j).imag)
5.0
Un module mathématique spécifique (cmath) leur est réservé :
>>> import cmath
>>> print(cmath.phase(-1 + 0j))
3.141592653589793
>>> print(cmath.polar(3 + 4j))
(5.0, 0.9272952180016122)
>>> print(cmath.rect(1., cmath.pi/4))
(0.7071067811865476+0.7071067811865475j)
FZ SALMAM CCN-S1(2023/2024) 14

14

7
 12/10/2023

Variables et affectation
Les variables

Dès que l’on possède des types de données, on a besoin des variables pour
stocker les données.

Définition
Une variable est un identificateur associé à une valeur. En Python, c’est une
référence d’objet.

En réalité, Python n’offre pas directement la notion de variable, mais plutôt

celle de référence d’objet.

FZ SALMAM CCN-S1(2023/2024) 15

15

Variables et affectation
L’ affectation

Définition
On affecte une variable par une valeur en utilisant le signe = (qui n’a rien à
voir avec l’égalité en math !). Dans une affectation, le membre de gauche
reçoit le membre de droite ce qui nécessite d’évaluer la valeur correspondant
au membre de droite avant de l’affecter au membre de gauche.

import math
a = 2
b = 7.2 * math.log(math.e / 45.12) - 2*math.pi
c = b ** a

Remarque! Pour ne pas confondre affectation et égalité, à l’oral, au lieu de

dire « a égal 2 », dites « a reçoit 2 ».

FZ SALMAM CCN-S1(2023/2024) 16

16

8
 12/10/2023

Variables et affectation
Affecter n’est pas comparer !

L’affectation a un effet (elle modifie l’état interne du programme en cours

d’exécution) mais n’a pas de valeur (on ne peut pas l’utiliser dans une
expression) :
>>> c = True
>>> s = (c = True) and True
File ”<stdin>”, line 1
s = (c = True) and True
^
SyntaxError: invalid syntax

La comparaison a une valeur (de type bool) utilisable dans une expression
mais n’a pas d’effet :
>>> c = ”a”
>>> s = (c == ”a”) and True
>>> s
True

FZ SALMAM CCN-S1(2023/2024) 17

17

Variables et affectation
Les variantes de l’affectation

Outre l’affectation simple, on peut aussi utiliser les formes suivantes :

>>> v = 4 # affectation simple
>>> v += 2 # affectation augmentée. Idem à v = v + 2 si v est déjà
référencé
>>> v
6
>>> c = d = 8 # d reçoit 8 puis c reçoit d (c et d sont des alias)
>>> c, d
(8, 8)
>>> e, f = 2.7, 5.1 # affectation parallèle d’un tuple
>>> (e, f)
(2.7, 5.1)
>>> g, h = [’G’, ’H’] # affectation parallèle d’une liste
>>> [g, h]
[’G’, ’H’]
>>> a = 3
>>> a, b = a + 2, a * 2 # toutes les expressions sont évaluées avant la
première affectation
>>> a, b
(5, 6)

FZ SALMAM CCN-S1(2023/2024) 18

18

9
 12/10/2023

Variables et affectation
Représentation graphiques des affectations

Les affectations relient les identificateurs aux données : si une donnée en

mémoire n’est plus reliée, le ramasse-miettes (garbage collector) de Python
la supprime automatiquement (car son nombre de références tombe à zéro) :

FZ SALMAM CCN-S1(2023/2024) 19

19

Les chaînes de caractères

Présentation

Définition
Une chaîne de caractères (string) est une séquence de caractères, c’est–à–
dire des caractères qui se suivent les uns derrières les autres. Une chaîne de
caractères peut ne contenir aucun caractère : on l’appelle chaîne vide.

Ce type de données est Non modifiable: signifie qu’une donnée, une fois
créée en mémoire, ne pourra plus être changée ; toute transformation
résultera en la création d’une nouvelle valeur distincte.

FZ SALMAM CCN-S1(2023/2024) 20

20

10
 12/10/2023

Les chaînes de caractères

Présentation

Trois syntaxes de chaîne sont disponibles. Remarquez que l’on peut aussi
utiliser le ’ à la place de ”, ce qui permet d’inclure une notation dans l’autre :

>>> syntaxe1 = "Première forme avec un retour à la ligne \n"

>>> print(syntaxe1)
Première forme avec un retour à la ligne
>>> syntaxe2 = r"Deuxième forme. Chaîne brute\n sans retour à la ligne"
>>> print(syntaxe2)
Deuxième forme. Chaîne brute\n sans retour à la ligne
>>> syntaxe3 = """
Troisième forme
multi-lignes
très utile pour
la documentation
"""
>>> print(syntaxe3)
Troisième forme
multi-lignes
très utile pour
la documentation

FZ SALMAM CCN-S1(2023/2024) 21

21

Les chaînes de caractères

Opérations sur les chaînes

Longueur : Égalité, différence

>>> s = ”abcde” >>> "abc" == 'abc'
>>> len(s) True
5 >>> "abc" != "ABC"
Concaténation : True
>>> s1 = ”abc” Ordre
>>> s2 = ”defg” >>> "bonjour" < "salut"
>>> s3 = s1 + s2 True
>>> s3 >>> "bonjour" > "Salut"
’abcdefg’ True
Répétition: Conversion numériques/chaînes
>>> s4 = ”Fi! ” >>> int ("34")
>>> s5 = s4 * 3 34
>>> s5 >>> float ("34")
’Fi! Fi! Fi! ’ 34.0
>>> str (45.7)
'45.7'

FZ SALMAM CCN-S1(2023/2024) 22

22

11
 12/10/2023

Les chaînes de caractères

Indexation simple

Pour indexer une chaîne, on utilise l’opérateur [] dans lequel l’index, un entier
signé qui commence à 0, indique la position d’un caractère :
>>> s = ”Rayons X” # len(s) ==> 7
>>> s[0]
’R’
>>> s[2]
’y’
>>> s[-1]
’X’
>>> s[-3]
’s’

FZ SALMAM CCN-S1(2023/2024) 23

23

Les chaînes de caractères

Extraction de sous-chaînes

Extraction de sous-chaînes. L’opérateur [start:end:step] avec 2 ou 3 index

séparés par le caractère : permet d’extraire des sous-chaînes (ou tranches)
d’une chaîne.
>>> s = ”Rayon X” # len(s) ==> 7
>>> s[1:4] # de l’index 1 compris à 4 non compris
’ayo’
>>> s[-2:] # de l’index -2 compris à la fin
’ X’
>>> s[:3] # du début à l’index 3 non compris
’Ray’
>>> s[3:] # de l’index 3 compris à la fin
’on X’
>>> s[::2] # du début à la fin, de 2 en 2
’RynX’
>>> s[::-1] # de la fin au début (retournement)
’X noyaR’

FZ SALMAM CCN-S1(2023/2024) 24

24

12
 12/10/2023

Les chaînes de caractères

Méthodes sur le traitement des chaînes.

Il existe de nombreuses méthodes (sortes de fonctions préfixées par l’objet ici

la chaîne) sur le traitement des chaînes.
Si a désigne une chaîne de caractères, grâce à la complétion, en
tapant a. suivi de la touche tabulation, on obtient la liste de toutes les
méthodes applicable aux chaînes. Ces méthodes sont :
a.capitalize a.isalnum a.join a.rsplit
a.casefold a.isalpha a.ljust a.rstrip
a.center a.isdecimal a.lower a.split
a.count a.isdigit a.lstrip a.splitlines
a.encode a.isidentifier a.maketrans a.startswith
a.endswith a.islower a.partition a.strip
a.expandtabs a.isnumeric a.replace a.swapcase
a.find a.isprintable a.rfind a.title
a.format a.isspace a.rindex a.translate
a.format_map a.istitle a.rjust a.upper
a.index a.isupper a.rpartition a.zfill
FZ SALMAM CCN-S1(2023/2024) 25

25

Les chaînes de caractères

Méthodes sur le traitement des chaînes.

Méthodes de test de l’état d’une chaîne: Des méthodes à valeur booléenne,

c’est-à-dire qu’elles retournent la valeur True ou False. isupper() et
islower() : retournent True si la chaîne ne contient respectivement que
des majuscules/minuscules

Méthodes retournant une nouvelle chaîne: lower(),upper(),

capitalize() et swapcase() : retournent respectivement une chaîne
en minuscule, en majuscule, en minuscule commençant par une majuscule,
ou en casse inversée.

FZ SALMAM CCN-S1(2023/2024) 26

26

13
 12/10/2023

Les chaînes de caractères

Méthodes sur le traitement des chaînes.

En tapant help(a.upper) par exemple, on obtient de l’aide sur la

méthode upper associée aux chaînes de caractères.

>>> a = "azert"
>>> help(a.upper)
Help on built-in function

upper: upper(...)
S.upper() -> string
Return a copy of the string S converted to uppercase.
>>> a.upper()
'AZERT'

FZ SALMAM CCN-S1(2023/2024) 27

27

Les entrées-sorties
Les entrées

Il s’agit de réaliser une saisie au clavier : la fonction standard input()

interrompt le programme, affiche une éventuelle invite à l’écran et attend
que l’utilisateur entre une donnée au clavier et la valide par Entrée.

>>> f1 = input(”Entrez un flottant : ”)

Entrez un flottant : 12.345
>>> type(f1)
<class ’str’>
>>> f2 = float(input(”Entrez un autre flottant : ”))
Entrez un autre flottant : 12.345
>>> type(f2)
<class ’float’>

La fonction input() effectue toujours une saisie en mode texte (la valeur
retournée est une chaîne) dont on peut ensuite changer le type (on dit aussi
« transtyper » ou cast en anglais).

FZ SALMAM CCN-S1(2023/2024) 28

28

14
 12/10/2023

Les entrées-sorties
Les sorties

La fonction print() se charge d’afficher la représentation textuelle des

informations qui lui sont données en paramètre, en plaçant un blanc
séparateur entre deux informations, et en faisant un retour à la ligne à la fin
de l’affichage (le séparateur et la fin de ligne peuvent être modifiés) :

>>> a, b = 2, 5
>>> print(a, b)
2 5
>>> print(”Somme :”, a + b)
Somme : 7
>>>> print(a - b, ”est la différence”)
-3 est la différence
>>> print(”Le produit de”, a, ”par”, b, ”vaut :”, a * b)
Le produit de 2 par 5 vaut : 10
>>> print(”On a <”, 2**32, a*b, ”> cas !”, sep=”~~~”)
On a <~~~4294967296~~~10~~~> cas !
>>> # pour afficher autre chose qu’un espace en fin de ligne :
>>> print(a, end=”@”)
2@

FZ SALMAM CCN-S1(2023/2024) 29

29

Les chaînes de caractères

Les séquences d’échappement

À l’intérieur d’une chaîne, le caractère antislash (\) permet de donner une

signification spéciale à certaines séquences de caractères :

\\ affiche un antislash
\’ apostrophe
\” guillemet
\a sonnerie (bip)
\b retour arrière
\f saut de page
\n saut de ligne
\r retour en début de ligne
\t tabulation horizontale
\v tabulation verticale
\N{nom} caractère sous forme de code Unicode nommé
\uhhhh caractère sous forme de code Unicode 16 bits
\Uhhhhhhhh caractère sous forme de code Unicode 32 bits
\ooo caractère sous forme de code octal
\xhh caractère sous forme de code hexadécimal

FZ SALMAM CCN-S1(2023/2024) 30

30

15
 12/10/2023

Partie II :
Types, affectations, expressions
Les instructions de contrôle
Les fonctions

FZ SALMAM CCN-S1(2023/2024) 31

31

Les instructions de contrôle

Instructions composées

Pour identifier les instructions composées, Python utilise la notion

d’indentation significative. Cette syntaxe, légère et visuelle, met en lumière
un bloc d’instructions et permet d’améliorer grandement la présentation et
donc la lisibilité des programmes sources.
Syntaxe
Une instruction composée se compose :
 d’une ligne d’en-tête terminée par deux-points ;
 d’un bloc d’instructions indenté par rapport à la ligne d’en-tête. On
utilise habituellement quatre espaces par indentation et on ne mélange
pas les tabulations et les espaces
Attention
Toutes les instructions au même niveau d’indentation appartiennent au
même bloc.

FZ SALMAM CCN-S1(2023/2024) 32

32

16
 12/10/2023

Conditions
Définition

Les tests (Conditions) sont un élément essentiel à tout langage informatique

si on veut lui donner un peu de complexité car ils permettent à l’ordinateur
de prendre des décisions si telle ou telle condition est vraie ou fausse. Pour
cela, Python utilise l’instruction if.

>>> x = 5
>>> if x < 0:
... print(”x est négatif”)
... elif x % 2 != 0:
... print(”x est positif et impair”)
... print (”ce qui est bien aussi !”)
... else:
... print(”x n’est pas négatif et est pair”)
...
x est positif et impair
ce qui est bien aussi !

FZ SALMAM CCN-S1(2023/2024) 33

33

Conditions
Test d’une valeur booléenne :

>>> x = 8
>>> estPair = (x % 2 == 0)
>>> estPair
True
>>> if estPair: # mieux que ”if estPair == True:”
... print(’La condition est vraie’)
...
La condition est vraie

FZ SALMAM CCN-S1(2023/2024) 34

34

17
 12/10/2023

Conditions
Syntaxe compacte:

Pour trouver, par exemple, le minimum de deux nombres, on peut utiliser

l’opérateur ternaire :
>>> x = 4
>>> y = 3
>>> if x < y: # écriture classique
... plus_petit = x
... else:
... plus_petit = y
...
>>> print(”Plus petit : ”, plus_petit)
Plus petit : 3
>>> plus_petit = x if x < y else y # utilisation de l’opérateur ternaire
>>> print(”Plus petit : ”, plus_petit)
Plus petit : 3

Remarque
L’opérateur ternaire est une expression qui fournit une valeur que l’on peut
utiliser dans une affectation ou un calcul.

FZ SALMAM CCN-S1(2023/2024) 35

35

Boucles
Boucles Tant Que (while)

En programmation, on appelle boucle un système d’instructions qui permet

de répéter un certain nombre de fois (voire indéfiniment) toute une série
d’opérations. En Python l’instruction while nous permet d’effectuer cette
répétition tant qu’une condition (exprimée sous forme d’expression
booléenne) est vérifiée. Le mot while signifie « tant que » en anglais.
>>> a = 0
>>> while (a < 7): # (n’oubliez pas le double point !)
... print(a)
... a = a + 1 # (n’oubliez pas l’indentation !)
0
1
2
3
4
5
6

FZ SALMAM CCN-S1(2023/2024) 36

36

18
 12/10/2023

Boucles
Boucles Tant Que (while) /Exercice

Considérons la suite (Un)n∈N :

U0=1
Un+1=2Un+3 pour n>=0

Calculer la valeur de U5

i = 0
u = 1.0 # Initialisation de la suite u_n dans u, flottant
while (i < 5):
u = 2.0*u + 3.0 # Calcul de u_i par la formule de récurrence
i = i + 1 # Incrémentation de i
print("u_5 =", u)

FZ SALMAM CCN-S1(2023/2024) 37

37

Boucles
Boucles Pour (for)

La boucle for de Python permet en fait d’itérer sur n’importe quel objet
itérable. Or l’objet range(a,b) est itérable et «contient» les entiers de a à
b-1 inclus.
>>> for lettre in ”ciao”:
... print(lettre)
...
c
i
a
o
>>> for x in [2, ’a’, 3.14]:
... print(x)
...
2
a
3.14
>>> for i in range(3):
... print(i)
...
0
1
FZ SALMAM 2 CCN-S1(2023/2024) 38

38

19
 12/10/2023

Ruptures de séquences
Interrompre une boucle : break

Sort immédiatement de la boucle for ou while en cours contenant

l’instruction :
>>> for x in range(1, 11):
... if x == 5:
... break
... print(x, end=” ”)
...
1 2 3 4
>>> print(”Boucle interrompue pour x =”, x)
Boucle interrompue pour x = 5

FZ SALMAM CCN-S1(2023/2024) 39

39

Ruptures de séquences
Court-circuiter une boucle : continue

Passe immédiatement à l’itération suivante de la boucle for ou while en

cours contenant l’instruction ; reprend à la ligne de l’en-tête de la boucle :

>>> for x in range(1, 11):

... if x == 5:
... continue
... print(x, end=” ”)
...
1 2 3 4 6 7 8 9 10
>>> # la boucle a sauté la valeur 5

FZ SALMAM CCN-S1(2023/2024) 40

40

20
 12/10/2023

Utilisation avancée des boucles

while - else

y = int(input(”Entrez un entier positif : ”))

while not(y > 0) :
y = int(input(’Entrez un entier positif, S.V.P. : ’))
x = y // 2

while x > 1:
if y % x == 0:
print(x, ”a pour facteur”, y)
break # voici l’interruption !
x -= 1
else :
print(y, ”est premier.”)

FZ SALMAM CCN-S1(2023/2024) 41

41

Utilisation avancée des boucles

while - else

>>> entiers = [2, 11, 8, 7, 5]

>>> cible = int(input(”Entrez un entier : ”))
Entrez un entier : 7
>>> for entier in entiers:
... if cible == entier:
... print(cible, ’est dans la séquence’, entiers)
... break # voici l’interruption !
... else:
... print(cible, ”n’est pas dans la séquence”, entiers)
...

FZ SALMAM CCN-S1(2023/2024) 42

42

21
 12/10/2023

Exercice

Constituez une liste semaine contenant les 7 jours de la semaine. Écrivez une
série d’instructions affichant les jours de la semaine (en utilisant une boucle
for), ainsi qu’une autre série d’instructions affichant les jours du week-end
(en utilisant une boucle while).

FZ SALMAM CCN-S1(2023/2024) 43

43

Exercice

Créez un script qui dessine un triangle comme celui-ci :

*
**
***
****
*****
******
*******
********
*********
**********

FZ SALMAM CCN-S1(2023/2024) 44

44

22
 12/10/2023

Partie II :
Types, affectations, expressions
Les instructions de contrôle
Les fonctions

FZ SALMAM CCN-S1(2023/2024) 45

45

Les fonctions
Fonctions/procédures

Les fonctions sont les éléments structurants de base de tout langage

procédural. Elles offrent différents avantages :
 Évitent la répétition : on peut « factoriser » une portion de code qui se
répète lors de l’exécution en séquence d’un script ;
 Mettent en relief les données et les résultats : entrées et sorties de la
fonction ;
 Permettent la réutilisation : mécanisme de l’import ;
 Décomposent une tâche complexe en tâches plus simples : conception
de l’application.

FZ SALMAM CCN-S1(2023/2024) 46

46

23
 12/10/2023

Les fonctions
Fonctions/procédures

FZ SALMAM CCN-S1(2023/2024) 47

47

Les fonctions
Fonctions vs procédures en Algorithmique

Il ne faut pas confondre procédure et fonction, même si leur définition, en

Python par exemple, est similaire :
 Une fonction calcule. Elle retourne quelque chose
Fonction nom_Fonct (liste de paramètres : type)
Variables identificateur : type
Début
Instruction(s)
Retourner Expression
Fin

 Une procédure n’a pas de valeur de retour

Procédure nom_proc(liste de paramètres : type)
Variables identificateurs : type
Début
Instruction(s)
FinRoc

FZ SALMAM CCN-S1(2023/2024) 48

48

24
 12/10/2023

Les fonctions
Les fonctions en Python
Définition
Une fonction est un ensemble d’instructions regroupées sous un nom et
s’exécutant à la demande.

Syntaxe
La définition d’une fonction se compose :
• du mot clé def suivi de l’identificateur de la fonction, de
parenthèses entourant les paramètres de la fonction séparés par des
virgules, et du caractère « deux points » qui termine toujours une
instruction composée ;
• d’une chaîne de documentation (ou docstring) indentée comme
le corps de la fonction ;
• du bloc d’instructions indenté par rapport à la ligne de définition, et
qui constitue le corps de la fonction.

FZ SALMAM CCN-S1(2023/2024) 49

49

Les fonctions
Les fonctions en Python

Exemples de fonctions en python:

def afficheAddMul(a, b) :
”””Calcule et affiche :
- la somme de a et b,
- le produit de a et b.
”””
somme = a + b
produit = a * b
print(”La somme de”, a, ” et”, b, ” est”, somme, ”et le produit”,
produit)

def addition(a, b):

return a + b

addition(10, 5)
# Renvoie 15
addition(10)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: addition() missing 1 required positional argument: 'b'

FZ SALMAM CCN-S1(2023/2024) 50

50

25
 12/10/2023

Les fonctions
Passage des arguments

Passage par affectation : chaque paramètre de la définition de la fonction

correspond, dans l’ordre, à un argument de l’appel. La correspondance se fait
par affectation des arguments aux paramètres.

FZ SALMAM CCN-S1(2023/2024) 51

51

Les fonctions
Passage des arguments

Exemple sans l’instruction return, ce qu’on appelle souvent une procédure.

Dans ce cas la fonction renvoie implicitement la valeur None :
def table(base, debut, fin) :
”””Affiche la table de multiplication des <base> de <debut> à <fin>.”””
n = debut
while n <= fin :
print(n, ’x’, base, ’=’, n * base)
n += 1
# exemple d’appel :
table(7, 2, 8)
# 2 x 7 = 14 3 x 7 = 21 4 x 7 = 28 5 x 7 = 35 6 x 7 = 42 7 x 7 = 49 8 x 7 =
56
# autre exemple du même appel, mais en nommant les paramètres ;
table(base=7, debut=2, fin=8)

FZ SALMAM CCN-S1(2023/2024) 52

52

26
 12/10/2023

Les fonctions
Passage des arguments

Exemple avec utilisation d’un return unique :

from math import pi

def cube(x) :
”””Retourne le cube de largument.”””
return x**3

def volumeSphere(r) :
”””Retourne le volume d’une sphère de rayon <r> ;”””
return 4.0 * pi * cube(r) / 3.0

# Saisie du rayon et affichage du volume

rayon = float(input(’Rayon : ’))
print(”Volume de la sphère =”, volumeSphere(rayon))

FZ SALMAM CCN-S1(2023/2024) 53

53

Les fonctions
Passage des arguments

Exemple avec utilisation d’un return multiple ::

from math import pi

def surfaceVolumeSphere(r) :
surf = 4.0 * math.pi * r**2
vol = surf * r/3
return surf, vol

# programme principal
rayon = float(input(’Rayon : ’))
s, v = surfaceVolumeSphere(rayon)
print(”Sphère de surface { :g} et de volume { :g}”.format(s, v))

FZ SALMAM CCN-S1(2023/2024) 54

54

27
 12/10/2023

Les fonctions
Passage d’une fonction en paramètre

Puisque en Python une variable peut référencer une fonction, on peut

transmettre une fonction comme paramètre :

>>> def f(x):

... return 2*x+1
...
>>> def g(x):
... return x//2
...
>>> def h(fonc, x):
... return fonc(x)
...
>>> h(f, 3)
7
>>> h(g, 4)
2

FZ SALMAM CCN-S1(2023/2024) 55

55

Les fonctions
Paramètres avec valeur par défaut

Il est possible de spécifier, lors de la déclaration, des valeurs par défaut à

utiliser pour les arguments. Cela permet, lors de l’appel, de ne pas avoir à
spécifier les paramètres correspondants:

>>> def accueil(nom, prenom, depart=”MP”, semestre=”S2”):

... print(prenom, nom, ”Département”, depart, ”semestre”, semestre)
...
>>> accueil(”Student”, ”Joe”)
Joe Student Département MP semestre S2
>>> accueil(”Student”, ”Eve”, ”Info”)
Eve Student Département Info semestre S2
>>> accueil(”Student”, ”Steph”, semestre=”S3”)
Steph Student Département MP semestre S3

FZ SALMAM CCN-S1(2023/2024) 56

56

28
 12/10/2023

Les fonctions
Nombre d’arguments arbitraire : passage d’un tuple de valeurs

Le passage d’un nombre arbitraire d’arguments est permis en utilisant la

notation d’un argument final *nom. Les paramètres surnuméraires sont alors
transmis sous la forme d’un tuple affecté à cet argument (que l’on appelle
généralement args).

def somme(*args) :
”””Renvoie la somme du tuple <args>.”””
resultat = 0
for nombre in args :
resultat += nombre
return resultat

# Exemples d’appel :
print(somme(23)) # 23
print(somme(23, 42, 13)) # 78

FZ SALMAM CCN-S1(2023/2024) 57

57

Les fonctions
Nombre d’arguments arbitraire : passage d’un dictionnaire

De la même façon, il est possible d’autoriser le passage d’un nombre

arbitraire d’arguments nommés en plus de ceux prévus lors de la définition
en utilisant la notation d’un argument final **nom. Les paramètres
surnuméraires nommés sont alors transmis sous la forme d’un dictionnaire
affecté à cet argument (que l’on appelle généralement kwargs pour keyword
args).

def unDict(**kwargs) :
return kwargs

# Exemples d’appels
## par des paramètres nommés :
print(unDict(a=23, b=42)) # {’a’ : 23, ’b’ : 42}

## en fournissant un dictionnaire :
mots = {’d’ : 85, ’e’ : 14, ’f’ :9}
print(unDict(**mots)) # {’d’ : 85, ’e’ : 14, ’f’ :9}

FZ SALMAM CCN-S1(2023/2024) 58

58

29
 12/10/2023

Les fonctions
Portée des variables

Le bloc principal s'appelle le bloc global, les variables qui y sont définies sont
appelées 'variables globales' et visibles par la fonction globals(). Dans les bloc
secondaires, les variables déclarées sont locales et visibles en
utilisant locals().

a = 10 # variable globale
def f():
a = 20 # variable locale
print(a)
f()
print(a)

FZ SALMAM CCN-S1(2023/2024) 59

59

Les fonctions
Règles des 3 portées L, G et I

La recherche des noms est d’abord locale (L), puis globale (G), enfin interne
(I):

FZ SALMAM CCN-S1(2023/2024) 60

60

30
 12/10/2023

Les fonctions
Règles des 3 portées L, G et I

Il se peut que vous souhaitiez passer outre ce comportement de Python et

modifier la valeur d'une variable extérieure. Pour ce faire, nous allons utiliser
le mot-clé global:
# x et fonc sont affectés dans le module => globaux

def fonc(y) : # y et z sont affectés dans fonc => locaux

global x # permet de modifier x ligne suivante
x = x + 2
z = x + y
return z

x = 99
print(fonc(1)) # 102
print(x) # 101

FZ SALMAM CCN-S1(2023/2024) 61

61

31