1 A.

Larhlimi

Introduction à Python
Présentation des outils de programmation
Dans cette introduction à Python pour la programmation élémentaire, nous pouvons
travailler en

ligne sur la plateforme Google Colab, ou installer et utiliser un environnement de

développement intégré, pour le calcul scientifique et pour la visualisation.

Vous pouvez installer sur votre ordinateur le logiciel gratuit Anaconda qui offre une
installation aisée de l’ensemble de l’environnement de développement nécessaire à ce
cours:

https://www.anaconda.com/download/

Exécution d’un premier programme

Voici un premier exemple de programme :

Voici un autre :

for i in [0, 1, 2]:

print("valeur :", i)
print("Fin")

Note
Pour exécuter ce code pas à pas, utiliser le lien
http://pythontutor.com/visualize.html#mode=edit.

La prochaine ligne à exécuter est indiquée par une flèche rouge. Une flèche verte signale la
ligne qui vient d’être exécutée.

L’affichage après exécution est :

valeur : 0
valeur : 1
valeur : 2
Fin

Quelques bases rapides en Python

2 A. Larhlimi

Utilisation en mode interactif

Note
Si vous n’utilisez pas Spyder mais IDLE, vous pouvez consulter cette introduction à IDLE.

Dans Spyder, on dispose d’une zone de fenêtre pour l’interpréteur de commandes IPython.

Son invite de commande est différente de celle de l’interpréteur Python standard (qui
est >>>). Elle se présente de la façon suivante :

In [1]:

Exemple de première utilisation de IPython :

In [1]: 3 * 4
Out[1]: 12

In [2]: 5 + 2
Out[2]: 7

Les parties qui débutent par In et Out correspondent aux entrées et sorties respectivement.

Premiers calculs
Testez les calculs suivants :

>>> 4 + 5
>>> 3 - 7 # les espaces sont optionnels
>>> 5 + 2 * 3 # la priorité des opérations mathématiques est-elle respectée
?
>>> (6 + 3) * 2

Pour calculer une puissance, on utilise **.

>>> 5**2

L’opérateur /
Avertissement
L’opérateur / ne donne pas les mêmes résultats suivant les versions de Python. En Python 2,
il réalise par défaut une division euclidienne, aussi appelée division entière (c’est-à-dire
une division dont le résultat est un entier). En Python 3, il réalise une division décimale
standard comme sur une calculatrice. En Python 2.7, on peut obtenir le même
comportement qu’en Python 3 grâce à l’instruction from __future__ import division.

Exemple

>>> 7 / 2
3.5

Pour réaliser une division entière, il faut utiliser // :

3 A. Larhlimi

>>> 7 // 2
3

L’opérateur %
L’opérateur % (appelé opérateur modulo) fournit le reste de la division entière d’un nombre
par un autre.

Exemple

>>> 7 % 2
1
>>> 6 % 2
0

Affectation
>>> a = 2
>>> a
2
>>> b = a + 3
>>> b
5

La première ligne contient l’instruction a = 2. Pour comprendre cette instruction, il faut

imaginer que les informations sont stockées dans des boîtes au sein de la mémoire de
l’ordinateur. Pour manipuler les informations, on donne des noms à ces boîtes. Ici on crée
une boîte appelée a et on lui affecte la valeur 2. Par la suite, on parlera de la variable a,
puisque a peut contenir des valeurs variables. Autrement dit, l’instruction a = 2 est une
instruction d”affection qui a pour effet de mettre la valeur 2 dans la variable a.

Affichage - la fonction print()
Pour afficher, on utilise la fonction print().

>>> print("bonjour")
bonjour
>>> a = 5
>>> print(a)
5

Il est possible de réaliser plusieurs affichages à la suite. Pour cela, on sépare les éléments
par des virgules.

>>> a = 5
>>> print("a vaut", a)
a vaut 5

Avertissement
En Python 2, on ne mettait pas de parenthèses.
4 A. Larhlimi

 Python 2 : print "a vaut", a
 Python 3 : print("a vaut", a)
Pour ne pas aller à la ligne et continuer sur la même ligne lors du prochain print :
 Python 2 : print "a vaut", a,
 Python 3 : print("a vaut", a, end=" ")
Il est possible avec Python 2.7 d’utiliser la syntaxe de Python 3 pour la fonction print grâce à
l’instruction from __future__ import print_function.

Voir aussi
https://python.developpez.com/cours/apprendre-python3/?page=page_4#L4

La fonction range()
Si vous avez besoin de créer sur une suite d’entiers, vous pouvez utiliser la fonction range().
Elle génère une suite arithmétique.

>>> range(10)
range(0, 10)

En Python 3, si on souhaite afficher les valeurs, il est nécessaire de convertir le résultat en

liste grâce à la fonction list(). Par exemple :

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Le nombre de fin qui lui est passé n’est jamais dans la liste générée. Par exemple, range(10)
génère 10 valeurs, exactement les indices des éléments d’une séquence de longueur 10. Il
est possible de faire commencer l’intervalle à un autre nombre, ou de spécifier un incrément
différent (même négatif) :

>>>
[5, 6, 7, 8, 9]
>>>4 list(range(0, 10, 3))
[0, 3, 6, 9]
>>> list(range(-10, -100, -30))
[-10, -40, -70]

De manière générale, on a :

range(valeur_initiale, borne_de_fin, pas)

Le pas peut être positif ou négatif. La valeur de la borne de fin (maximale ou minimale) n’est
jamais atteinte.

Exercice 1

Créer une liste contenant les entiers impairs allant de 10 à 20.

Accès aux éléments d’une liste

>>> a = list(range(1,10,2))
>>> a
5 A. Larhlimi

[1, 3, 5, 7, 9]
>>> a[0]
1
>>> a[2]
5

Pour accéder à un élément d’une liste, on indique entre crochets [] l’indice de l’élément.

Avertissement
En Python, l’indice du premier élément d’une liste est 0 (ceci est à distinguer d’autres
langages).

La fonction len()
La fonction len() renvoie le nombre d’éléments. Par exemple :

>>> a = list(range(7,10))
>>> a
[7, 8, 9]
>>> len(a)
3

Lecture d’informations au clavier - la fonction input()

x = int(input("Donnez un entier : "))

Par défaut, la fonction input() renvoie une chaîne de caractères. Il faut donc utiliser la

fonction int() qui permet d’obtenir un entier.

Autre exemple de programme

n = 3
print("Je vais vous demander", n, "nombres")
for i in range(n):
x = int(input("Donnez un nombre : "))
if x > 0:
print(x, "est positif")
else:
print(x, "est négatif ou nul")
print("Fin")

Pour faire une répétition : l’instruction for

for i in range(n):
bloc d'instructions

Pour faire un test : l’instruction if

if x > 0:
6 A. Larhlimi

print(x, "est positif")

else:
print(x, "est négatif ou nul")

Les différentes sortes d’instruction

 les instructions simples

 les instructions composées comme if ou for
 les blocs d’instructions
Voir aussi
https://python.developpez.com/cours/apprendre-python3/?page=page_5#L5

Règles générales d’écriture

Les identificateurs
Un identificateur est une suite de caractères servant à désigner les différentes entitées
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 mots-clés
Les mots réservés par le langage Python (if, for, etc.) ne peuvent pas être utilisés comme
identificateurs.

Voir aussi
Liste des mots-clés : https://python.developpez.com/cours/apprendre-python3/?
page=page_4#L4-C

Les commentaires
Les commentaires usuels:

# Ceci est un commentaire

Les commentaires en fin de ligne:

a = 2 # Ceci est un commentaire

7 A. Larhlimi

Tests (Instructions conditionnelles)

L’instruction if est la structure de test la plus simple. Sa syntaxe en Python fait intervenir la
notion de bloc. Nous allons d’abord étudier cette notion plus en détail.

Bloc d’instructions - Indentation

Un bloc est défini par une indentation obtenue en décalant le début des instructions vers la
droite grâce à des espaces en début de ligne (habituellement 4 espaces mais ce n’est pas
obligatoire). Toutes les instructions d’un même bloc doivent être indentées exactement au
même niveau (c’est-à-dire décalées à droite d’un même nombre d’espaces).

Un bloc peut contenir une ou plusieurs instructions, et notamment des instructions

composées (tests, boucles, etc.).

Instruction if
Syntaxe

if condition:
Instruction A

condition est une expression booléenne, c’est-à-dire une expression qui prend pour
valeur True (Vrai) ou False (Faux).

L”instruction A n’est exécutée que si la condition est vérifiée (c’est-à-dire si elle prend pour

valeur True).

L’instruction if est une instruction composée. Le : (deux-points) à la fin de la ligne introduit

le bloc d’instructions qui sera exécuté si la condition est vérifiée.

Exemple 1 avec condition vraie :

x = 15
if x > 10:
print(x, "est plus grand que 10")
print("Fin")
8 A. Larhlimi

Affichage après exécution :

15 est plus grand que 10

Fin

Exemple 1 avec condition fausse :

x = 3
if x > 10:
print x, "est plus grand que 10"
print "Fin"

Affichage après exécution :

Fin

Exemple 2 avec condition vraie :

x = 5
if x > 0:
print(x, "est plus grand que 0")
print("il est strictement positif")
print("Fin")

Dans cet exemple, le bloc après le if contient deux instructions.

L’instruction print("Fin") ne fait pas partie du bloc car elle n’est pas indentée.

Affichage après exécution :

5 est plus grand que 0

il est strictement positif
Fin

Exemple 2 avec condition fausse :

x = -2
if x > 0:
print(x, "est plus grand que 0")
print("il est strictement positif")
print("Fin")

Affichage après exécution :

Fin

Instruction if … else
Syntaxe

if condition:
9 A. Larhlimi

Instruction A
else:
Instruction B

Exemple où la condition est vraie :

x = 5
if x > 0:
print(x, "est positif")
else:
print(x, "est négatif ou nul")
print("Fin")

Affichage après exécution :

5 est strictement positif

Fin

Exemple où la condition est fausse :

x = -2
if x > 0:
print(x, "est positif")
else:
print(x, "est négatif ou nul")
print("Fin")

Affichage après exécution :

-2 est négatif ou nul

Fin

Une expression booléenne peut contenir les opérateurs de comparaison suivants :

Opérateur Signification

x == y x est égal à y

x != y x est différent de y

x>y x est plus grand que y

10 A. Larhlimi

Opérateur Signification

x<y x est plus petit que y

x >= y x est plus grand ou égal à y

x <= y x est plus petit ou égal à y

Exemple

>>> 3 < 4
True
>>> 3 > 4
False

Exercice 2:

Programme qui demande le nom et l’âge de

l’utilisateur et le montant plein tarif.

Si l’âge est inférieur à 18 ans, le programme donne

une remise de 30%.

Le programme doit afficher le montant à payer.

Opérateur logique and¶
>>> 2 < 3 and 3 < 4
True
>>> 2 < 3 and 3 > 4
False

Opérateur logique or
>>> 2 < 3 or 3 < 4
True
>>> 2 < 3 or 3 > 4
True
11 A. Larhlimi

Boucles
Les boucles s’utilisent pour répéter plusieurs fois l’exécution d’une partie du programme.

Boucles bornées et non bornées

Boucle bornée
Quand on sait combien de fois doit avoir lieu la répétition, on utilise généralement
une boucle for.

Boucle non bornée

Si on ne connait pas à l’avance le nombre de répétitions, on choisit une boucle while.

Boucle for
Exemple d’utilisation :

for i in [0, 1, 2, 3]:

print("i a pour valeur", i)

Affichage après exécution :

i a pour valeur 0
i a pour valeur 1
i a pour valeur 2
i a pour valeur 3

L’instruction for est une instruction composée, c’est-à-dire une instruction dont l’en-tête se

termine par deux-points :, suivie d’un bloc indenté qui constitue le corps de la boucle.

On dit que l’on réalise une itération de la boucle à chaque fois que le corps de la boucle est
exécuté.

Dans l’en-tête de la boucle, on précise après le mot-clé for le nom d’une variable (i dans
l’exemple ci-dessus) qui prendra successivement toutes les valeurs qui sont données après
le mot-clé in. On dit souvent que cette variable (ici i) est un compteur car elle sert à
numéroter les itérations de la boucle.

Il est possible d’obtenir le même résultat sans donner la liste des valeurs, mais en utilisant la
fontion range().

for i in range(4):
print("i a pour valeur", i)

Pour parcourir les indices d’une liste, il est possible de combiner range() et len() comme ci-
dessous :
12 A. Larhlimi

c = ["Ali", "est", "dans", "le", "jardin"]

for i in range(len(c)):
print("i vaut", i, "et c[i] vaut", c[i])

Affichage après exécution :

i vaut 0 et c[i] vaut Ali

i vaut 1 et c[i] vaut est
i vaut 2 et c[i] vaut dans
i vaut 3 et c[i] vaut le
i vaut 4 et c[i] vaut jardin

Rappel : La fonction len() renvoie le nombre d’éléments :

>>> c = ["Ali", "est", "dans", "le", "jardin"]

>>> len(c)
5

Dans l’exemple suivant, nous allons illustrer que la variable indiquée après for parcourt
toutes les valeurs de la liste donnée après in :

c = ["Ali", "est", "dans", "le", "jardin"]

for i in c:
print("i vaut", i)
>>>
i vaut Ali
i vaut est
i vaut dans
i vaut le
i vaut jardin

Boucle while
Syntaxe :

while condition:
Instruction A
13 A. Larhlimi

Exemple de programme :

x = 1
while x < 10:
print("x a pour valeur", x)
x = x * 2
print("Fin")

Affichage après exécution :

x a pour valeur 1
x a pour valeur 2
x a pour valeur 4
x a pour valeur 8
Fin

Exercice 3 :
p = 1
n =10
i=1
while i <= n:
p = p*i
i=i+1
print("P =", p)

Donner le résultat de sortie

que réalise ce programme

Le mot-clé while signifie tant que en anglais. Le corps de la boucle (c’est-à-dire le bloc

d’instructions indentées) sera répété tant que la condition est vraie.

Dans l’exemple ci-dessus, x sera multiplié par 2 tant que sa valeur reste inférieure à 10.

Remarque : Si la condition est fausse au départ, le corps de la boucle n’est jamais exécuté.
Si la condition reste toujours vraie, alors le corps de la boucle est répété indéfiniment.
14 A. Larhlimi

Comment choisir entre boucle for et

boucle while
En général, si on connaît avant de démarrer la boucle le nombre d’itérations à exécuter, on
choisit une boucle for. Au contraire, si la décision d’arrêter la boucle ne peut se faire que par
un test, on choisit une boucle while.

Note
Il est toujours possible de remplacer une boucle for par une boucle while.

Transformation d’une boucle for en un boucle while

for i in range(4):
print("i a pour valeur", i)

Le programme ci-dessus est équivalent à:

i = 0
while i < 4:
print("i a pour valeur", i)
i = i + 1

Voir aussi
https://python.developpez.com/cours/apprendre-python3/?page=page_6#L6-B

Exercice 4 :
Intérêts simples
Je place 1000,00 Dirham à 5 % pendant un an.
Au bout d'un an, les intérêts s'ajoutent à mon capital
qui devient :
1000,00+ 1000,00 x 5/100 = 1050,00
C +C x T
C =capital = 1000,00
T =taux = 5% = 0,05
Donner le programme qui demande la valeur du
capital et le valeur du taux d’intérêt et qui calcule le
montant du capital apres un ans.
15 A. Larhlimi

Exercice 4 (suite Bonus):

Les instructions break et continue, et la
clause else dans les boucles
L’instruction break
L’instruction break permet de « casser » l’exécution d’une boucle (while ou for). Elle fait sortir
de la boucle et passer à l’instruction suivante.

Exemple

for i in range(10):
print("debut iteration", i)
print("bonjour")
16 A. Larhlimi

if i == 2:
break
print("fin iteration", i)
print("apres la boucle")

Affichage après exécution :

debut iteration 0
bonjour
fin iteration 0
debut iteration 1
bonjour
fin iteration 1
debut iteration 2
bonjour
apres la boucle

Note
Dans le cas de boucles imbriquées, l’instruction break ne fait sortir que de la boucle la plus
interne.

Remarque : équivalent du do…while (faire…tant

que)
Dans de nombreux langages, il existe une instruction do…while qui permet de créer une
boucle pour laquelle on ne connaît pas à l’avance le nombre de répétition, mais qui doit
s’exécuter au moins une fois. Cette instruction n’existe pas en Python, mais on peut
facilement reproduire son fonctionnement de la façon suivante :

while True:
n = int(input("donnez un entier > 0 : "))
print("vous avez fourni", n)
if n > 0:
break
print("reponse correcte")

L’instruction continue
L’instruction continue permet de passer prématurément au tour de boucle suivant. Elle fait
continuer sur la prochaine itération de la boucle.

Exemple

for i in range(4):
print("debut iteration", i)
print("bonjour")
if i < 2:
continue
print("fin iteration", i)
print("apres la boucle")
17 A. Larhlimi

Affichage après exécution :

debut iteration 0
bonjour
debut iteration 1
bonjour
debut iteration 2
bonjour
fin iteration 2
debut iteration 3
bonjour
fin iteration 3
apres la boucle

La clause else dans une boucle

La clause else dans un boucle permet de définir un bloc d’instructions qui sera exécuté à la
fin seulement si la boucle s’est déroulée complétement sans être interrompue par un break.

Contrairement aux instructions présentes après la boucle, qui s’exécutent dans tous les cas
(avec ou sans interruption par un break), le bloc d’instructions défini dans la clause else ne
s’exécutera pas lors de l’interruption par un break. Après l’interruption, on passera
directement aux instructions après la boucle.

Autrement dit, le bloc de la clause else est exécuté lorsque la boucle se termine par

épuisement de la liste (avec for) ou quand la condition devient fausse (avec while), mais pas
quand la boucle est interrompue par un break. Ceci est illustré dans la boucle suivante, qui
recherche des nombres premiers :

for n in range(2, 8):

for x in range(2, n):
if n % x == 0:
print(n, "egale", x, "*", n/x)
break
else:
print(n, "est un nombre premier")

Affichage après exécution :

2 est un nombre premier

3 est un nombre premier
4 egale 2 * 2.0
5 est un nombre premier
6 egale 2 * 3.0
7 est un nombre premier
18 A. Larhlimi

Principaux types de données

Python est un langage à typage dynamique, ce qui signifie qu’il n’est pas nécessaire de
déclarer les variables avant de pouvoir leur affecter une valeur. La valeur que l’on affecte
possède un type qui dépend de la nature des données (nombre entier, nombre à virgule,
chaîne de caractères, etc). Le type du contenu d’une variable peut donc changer si on change
sa valeur.

La fonction type()
Pour connaître le type d’une donnée ou le type de la valeur d’une variable, il suffit d’utiliser la
fonction type().

Exemples :

>>> type(15)
int
>>> a = 15
>>> type(a)
int
>>> a = "toto"
>>> type(a)
str

Le type int (entier)
Ce type est utilisé pour stocker un entier, en anglais integer. Pour cette raison, on appelle ce
type int.

>>> type(128)
int

Le type float (flottant)
Ce type est utilisé pour stocker des nombres à virgule flottante, désignés en anglais par
l’expression floating point numbers. Pour cette raison, on appelle ce type : float. En français,
on parle de flottant.

Exemples :

>>> a = 14.5
>>> type(a)
float
>>> a = 11.
>>> type(a)
float
19 A. Larhlimi

>>> a
11.0
>>> a = 3.25e7
>>> type(a)
float
>>> a
3.25e+7

Le type str (chaîne de caractères)
Sous Python, une donnée de type str est une suite quelconque de caractères délimitée soit
par des apostrophes (simple quotes), soit par des guillemets (double quotes). str est
l’abréviation de string, qui veut dire chaîne en français.

>>> a = 'Bonjour'
>>> type(a)
str
>>> b = "Bonsoir"
>>> type(b)
str

Le type bool (booléen)
Le type bool est utilisé pour les booléens. Un booléen peut prendre les valeurs True ou False.

>>> a = True
>>> type(a)
bool
>>> b = not(a)
>>> b
False

Remarque : la fonction not est un opérateur logique qui renvoie l’opposé de la valeur

booléenne transmise. Pour True, on obtient False. Réciproquement, il renvoie False quand
on lui transmet True.

Le type list (liste)
Sous Python, on peut définir une liste comme une collection d’éléments séparés par des
virgules, l’ensemble étant enfermé dans des crochets.

Exemple :

>>> jour = ["lundi", "mardi", "mercredi", 1800, 20.357, "jeudi", "vendredi"]

>>> type(jour)
list
>>> jour
['lundi', 'mardi', 'mercredi', 1800, 20.356999999999999, 'jeudi', 'vendredi']
20 A. Larhlimi

Le type complex (complexe)
Python possède par défaut un type pour manipuler les nombres complexes. La partie
imaginaire est indiquée grâce à la lettre « j » ou « J ». La lettre mathématique utilisée
habituellement, le « i », n’est pas utilisée en Python car la variable i est souvent utilisé dans
les boucles.

Exemples :

>>> a = 2 + 3j
>>> type(a)
complex
>>> a
(2+3j)
>>> b = 1 + j
Traceback (most recent call last):
File "<pyshell#21>", line 1, in <module>
b = 1 + j
NameError: name 'j' is not defined
>>> b = 1 + 1j
>>> a * b
(-1+5j)
>>> 1j**2
(-1+0j)

Exercice 4 :
N=10
L=[]
For i in range(x) :
L.append(i*i)
Print(L)

1) Donner le résultat de l’affichage

2) Que réalise ce programme
3) Quelle le rôle la méthode append
21 A. Larhlimi

Fonctions en Python
Nous avons déjà rencontré diverses fonctions prédéfinies : print(), input(), range(), len().

Lorsqu’une tâche doit être réalisée plusieurs fois par un programme avec seulement des
paramètres différents, on peut l’isoler au sein d’une fonction. Cette approche est également
intéressante si la personne qui définit la fonction est différente de celle qui l’utilise. Par
exemple, nous avons déjà utilisé la fonction print() qui avait été définie par quelqu’un
d’autre.

Voir aussi
https://python.developpez.com/cours/apprendre-python3/?page=page_9

Définition d’une fonction - def

Syntaxe

La syntaxe Python pour la définition d’une fonction est la suivante :

def nom_fonction(liste de paramètres):

bloc d'instructions

Vous pouvez choisir n’importe quel nom pour la fonction que vous créez, à l’exception des
mots-clés réservés du langage, et à la condition de n’utiliser aucun caractère spécial ou
accentué (le caractère souligné « _ » est permis). Comme c’est le cas pour les noms de
variables, on utilise par convention des minuscules, notamment au début du nom (les noms
commençant par une majuscule seront réservés aux classes).

Corps de la fonction

Comme les instructions if, for et while, l’instruction def est une instruction composée. La

ligne contenant cette instruction se termine obligatoirement par un deux-points :, qui
introduisent un bloc d’instructions qui est précisé grâce à l’indentation. Ce bloc d’instructions
constitue le corps de la fonction.

Fonction sans paramètre

Exemple

def compteur3():
i = 0
while i < 3:
print(i)
i = i + 1

print("bonjour")
compteur3()
compteur3()
22 A. Larhlimi

Affichage après exécution :

bonjour
0
1
2
0
1
2

En entrant ces quelques lignes, nous avons défini une fonction très simple qui compte
jusqu’à 2. Notez bien les parenthèses, les deux-points, et l’indentation du bloc d’instructions
qui suit la ligne d’en-tête (c’est ce bloc d’instructions qui constitue le corps de la fonction
proprement dite).

Après la définition de la fonction, on trouve le programme principal qui débute par

l’instruction print("bonjour"). Il y a ensuite au sein du programme principal, l’appel de la
fonction grâce à compteur3().

Il est également possible de sauvegarder ce programme en tant que script au sein d’IDLE.
Après avoir exécuté ce script, pour utiliser à nouveau la fonction que nous venons de définir,
il suffit de l’appeler par son nom au niveau du shell. Ainsi :

>>> compteur3()

provoque l’affichage de :

0
1
2

Nous pouvons maintenant réutiliser cette fonction à plusieurs reprises, autant de fois que
nous le souhaitons.

Nous pouvons également l’incorporer dans la définition d’une autre fonction.

Exemple de fonction qui appelle une autre fonction

def compteur3():
i = 0
while i < 3:
print(i)
i = i + 1

def double_compteur3():
compteur3()
compteur3()

print("bonjour")
double_compteur3()

Exécuter
23 A. Larhlimi

Une première fonction peut donc appeler une deuxième fonction, qui elle-même en appelle
une troisième, etc.

Créer une nouvelle fonction offre l’opportunité de donner un nom à tout un ensemble
d’instructions. De cette manière, on peut simplifier le corps principal d’un programme, en
dissimulant un algorithme secondaire complexe sous une commande unique, à laquelle on
peut donner un nom explicite.

Une fonction est donc en quelque sorte une nouvelle instruction personnalisée, qu’il est
possible d’ajouter librement à notre langage de programmation.

Fonction avec paramètre

Exemple

def compteur(stop):
i = 0
while i < stop:
print(i)
i = i + 1

compteur(4)
compteur(2)

Exécuter

Affichage après exécution :

0
1
2
3
0
1

Pour tester cette nouvelle fonction, il nous suffit de l’appeler avec un argument.

Utilisation d’une variable comme argument

L’argument que nous utilisons dans l’appel d’une fonction peut être une variable.

Exemple

def compteur(stop):
i = 0
while i < stop:
print(i)
i = i + 1

a = 5
compteur(a)
24 A. Larhlimi

Exécuter

Affichage après exécution :

0
1
2
3
4

Avertissement
Dans l’exemple ci-dessus, l’argument que nous passons à la fonction compteur() est le
contenu de la variable a. A l’intérieur de la fonction, cet argument est affecté au
paramètre stop, qui est une tout autre variable.
Notez donc bien dès à présent que :
 Le nom d’une variable que nous passons comme argument n’a rien à voir avec le
nom du paramètre correspondant dans la fonction.
 Ces noms peuvent être identiques si vous le voulez, mais vous devez bien
comprendre qu’ils ne désignent pas la même chose (en dépit du fait qu’ils puissent
contenir une valeur identique).

Fonction avec plusieurs paramètres

Exemple

La fonction suivante utilise trois paramètres : start qui contient la valeur de départ, stop la

borne supérieure exclue comme dans l’exemple précédent et step le pas du compteur.

def compteur_complet(start, stop, step):

i = start
while i < stop:
print(i)
i = i + step

compteur_complet(1, 7, 2)

Exécuter

Affichage après exécution :

1
3
5

Note
25 A. Larhlimi

 Pour définir une fonction avec plusieurs paramètres, il suffit d’inclure ceux-ci entre
les parenthèses qui suivent le nom de la fonction, en les séparant à l’aide de virgules.
 Lors de l’appel de la fonction, les arguments utilisés doivent être fournis dans le
même ordre que celui des paramètres correspondants (en les séparant eux aussi à
l’aide de virgules). Le premier argument sera affecté au premier paramètre, le second
argument sera affecté au second paramètre, et ainsi de suite.

Variables locales, variables globales

Lorsqu’une fonction est appelée, Python réserve pour elle (dans la mémoire de
l’ordinateur) un espace de noms. Cet espace de noms local à la fonction est à distinguer de
l’espace de noms global où se trouvait les variables du programme principal. Dans l’espace
de noms local, nous aurons des variables qui ne sont accessibles qu’au sein de la fonction.
C’est par exemple le cas des variables start, stop, step et i dans l’exemple précédent.

A chaque fois que nous définissons des variables à l’intérieur du corps d’une fonction, ces
variables ne sont accessibles qu’à la fonction elle-même. On dit que ces variables sont
des variables locales à la fonction. Une variable locale peut avoir le même nom qu’une
variable de l’espace de noms global mais elle reste néanmoins indépendante.

Les contenus des variables locales sont stockés dans l’espace de noms local qui est
inaccessible depuis l’extérieur de la fonction.

Les variables définies à l’extérieur d’une fonction sont des variables globales. Leur contenu
est « visible » de l’intérieur d’une fonction, mais la fonction ne peut pas le modifier.

Exemple

def test():
b = 5
print(a, b)

a = 2
b = 7
test()
print(a, b)

Exécuter

Affichage après exécution :

2 5
2 7

Explications en vidéo

Utilisation d’une variable globale - global

Il peut se faire par exemple que vous ayez à définir une fonction qui soit capable de modifier
une variable globale. Pour atteindre ce résultat, il vous suffira d’utiliser l’instruction global.
26 A. Larhlimi

Cette instruction permet d’indiquer - à l’intérieur de la définition d’une fonction - quelles sont
les variables à traiter globalement.

On va ici créer une fonction qui a accès à la variable globale b.

def test():
global b
b = 5
print(a, b)

a = 2
b = 7
test()
print(a, b)

Exécuter

Affichage après exécution :

2 5
2 5

La présentation de cette page est inspirée par le livre de Gérard Swinnen « Apprendre à

programmer avec Python 3 » disponible sous licence CC BY-NC-SA 2.0.

« Vraies » fonctions et procédures

Pour les puristes, les fonctions que nous avons décrites jusqu’à présent ne sont pas tout à
fait des fonctions au sens strict, mais plus exactement des procédures. Une « vraie » fonction
(au sens strict) doit en effet renvoyer une valeur lorsqu’elle se termine. Une « vraie » fonction
peut s’utiliser à la droite du signe égale dans des expressions telles que y = sin(a). On
comprend aisément que dans cette expression, la fonction sin() renvoie une valeur (le sinus
de l’argument) qui est directement affectée à la variable y.

Voici un exemple extrêmement simple:

def cube(w):
return w**3
>>> cube(3)
27
>>> a = cube(4)
>>> a
64

Valeurs par défaut pour les paramètres

Dans la définition d’une fonction, il est possible de définir un argument par défaut pour
chacun des paramètres. On obtient ainsi une fonction qui peut être appelée avec une partie
seulement des arguments attendus.
27 A. Larhlimi

Exemples :

def politesse(nom, titre ="Monsieur"):

print("Veuillez agréer,", titre, nom, ", mes salutations distinguées.")
>>> politesse("Dupont")
Veuillez agréer, Monsieur Dupont , mes salutations distinguées.
>>> politesse('Durand', 'Mademoiselle')
Veuillez agréer, Mademoiselle Durand , mes salutations distinguées.

Lorsque l’on appelle cette fonction en ne lui fournissant que le premier argument, le second
reçoit tout de même une valeur par défaut. Si l’on fournit les deux arguments, la valeur par
défaut pour le deuxième est tout simplement ignorée.

Arguments avec étiquettes

Dans la plupart des langages de programmation, les arguments que l’on fournit lors de
l’appel d’une fonction doivent être fournis exactement dans le même ordre que celui des
paramètres qui leur correspondent dans la définition de la fonction.

Python autorise cependant une souplesse beaucoup plus grande. Si les paramètres
annoncés dans la définition de la fonction ont reçu chacun une valeur par défaut, sous la
forme déjà décrite ci-dessus, on peut faire appel à la fonction en fournissant les arguments
correspondants dans n’importe quel ordre, à la condition de désigner nommément les
paramètres correspondants.

Exemple :

def oiseau(voltage=100, etat="allumé", action="danser la java"):

print("Ce perroquet ne pourra pas", action)
print("si vous le branchez sur", voltage, "volts !")
print("L'auteur de ceci est complètement", etat)
>>> oiseau(etat="givré", voltage=250, action="vous approuver")
Ce perroquet ne pourra pas vous approuver
si vous le branchez sur 250 volts !
L'auteur de ceci est complètement givré
>>> oiseau()
Ce perroquet ne pourra pas danser la java
si vous le branchez sur 100 volts !
L'auteur de ceci est complètement allumé

Utilisation des fonctions dans un script

Pour cette première approche des fonctions, nous n’avons utilisé jusqu’ici que des fonctions
dans des scripts et pas de programme principal dans le script. Veuillez donc essayer vous-
même le petit programme ci-dessous, lequel calcule le volume d’une sphère a l’aide de la
formule :

V=43πR3V=43πR3
Exemple :
28 A. Larhlimi

import numpy as np

def cube(n):
return n**3

def volume_sphere(r):
return 4 / 3 * np.pi * cube(r)

r = float(input("Entrez la valeur du rayon : "))

print("Le volume de cette sphere vaut", volume_sphere(r))

A bien y regarder, ce programme comporte deux parties :

 les deux fonctions cube() et volume_sphere()

 le corps principal du programme.
Dans le corps principal du programme, il y a un appel de la fonction volume_sphere().

A l’intérieur de la fonction volume_sphere(), il y a un appel de la fonction cube().

Notez bien que les deux parties du programme ont été disposées dans un certain ordre :

 d’abord la définition des fonctions,

 et ensuite le corps principal du programme.
Cette disposition est nécessaire, parce que l’interpréteur exécute les lignes d’instructions du
programme l’une après l’autre, dans l’ordre où elles apparaissent dans le code source. Dans
le script, la définition des fonctions doit donc précéder leur utilisation.

Pour vous en convaincre, intervertissez cet ordre (en plaçant par exemple le corps principal
du programme au début), et prenez note du type de message d’erreur qui est affiché
lorsque vous essayez d’exécuter le script ainsi modifié.

En fait, le corps principal d’un programme Python constitue lui-même une entité un peu
particulière, qui est toujours reconnue dans le fonctionnement interne de l’interpréteur sous
le nom réservé __main__ (le mot « main » signifie « principal », en anglais. Il est encadré par
des caractères « souligné » en double, pour éviter toute confusion avec d’autres symboles).
L’exécution d’un script commence toujours avec la première instruction de cette entité
__main__, où qu’elle puisse se trouver dans le listing. Les instructions qui suivent sont alors
exécutées l’une après l’autre, dans l’ordre, jusqu’au premier appel de fonction. Un appel de
fonction est comme un détour dans le flux de l’exécution : au lieu de passer à l’instruction
suivante, l’interpréteur exécute la fonction appelée, puis revient au programme appelant
pour continuer le travail interrompu. Pour que ce mécanisme puisse fonctionner, il faut que
l’interpréteur ait pu lire la définition de la fonction avant l’entité __main__, et celle-ci sera
donc placée en général à la fin du script.

Dans notre exemple, l’entité __main__ appelle une première fonction qui elle-même en
appelle une deuxième. Cette situation est très fréquente en programmation. Si vous voulez
comprendre correctement ce qui se passe dans un programme, vous devez donc apprendre
à lire un script, non pas de la première à la dernière ligne, mais plutôt en suivant un
cheminement analogue à ce qui se passe lors de l’exécution de ce script. Cela signifie
concrètement que vous devrez souvent analyser un script en commençant par ses dernières
lignes !
29 A. Larhlimi

Résumé : structure d’un programme Python type

30 A. Larhlimi

Les listes Python

Dans cette leçon, nous allons découvrir un premier type de données

composites Python : les listes. Nous allons comprendre l’intérêt de ce type de
données et apprendre à les manipuler.

Présentation des listes Python

Jusqu’à présent, nous n’avons stocké qu’une seule valeur à la fois dans nos
variables. Les listes sont un type de données très particulier au sens où elles
représentent des données composées ou combinées. Une liste est en effet par
définition composée d’une suite de valeur ou d’éléments. 

Pour définir une nouvelle liste en Python, on va devoir utiliser une paire de
crochets [ ]. Nous allons placer les différents éléments de notre liste dans ces
crochets en les séparant par des virgules. On peut par exemple créer une liste
de 5 éléments et la placer dans une variable liste comme ceci :

Notre liste est ici composée de 5 valeurs de type numérique. On va pouvoir

stocker tous types de valeurs dans une liste, comme des chaines de caractères
par exemple :

De plus, vous devez savoir que tous les éléments d’une liste n’ont pas à être du
même type, on va très bien pouvoir créer des listes composées de nombres,
chaines et booléens par exemple :
31 A. Larhlimi

Note : Si vous avez déjà étudié un langage de script par le passé, les liste
doivent vous faire penser à ce qu’on appelle communément dans ces autres
langages des tableaux. En effet, les listes Python sont très proches des tableaux
(numérotés) qu’on peut retrouver dans de nombreux autres langages.

Récupérer une ou plusieurs valeurs dans

une liste
Les listes Python sont par défaut indexées ou indicées. Cela signifie que
chaque valeur d’une liste est lié à un indice qu’on va pouvoir utiliser pour
récupérer cette valeur en particulier.

Les listes possèdent des indices numériques qui commencent à 0. La première

valeur d’une liste possède donc toujours l’indice 0, la deuxième valeur l’indice
1, la troisième valeur l’indice 2 et etc.

Pour récupérer une valeur en particulier dans une liste, on va devoir préciser le
nom de la liste suivi de l’indice de cette valeur entre crochets. Notez que les
indices négatifs sont acceptés; dans ce cas on partira de la fin de la liste
(l’indice -1 correspond au dernier élément, -2 à l’avant dernier et etc.).

On va également pouvoir récupérer une tranche de valeurs dans une liste,

c’est-à-dire un ensemble de valeurs qui se suivent. Pour cela, on utilisera le
symbole : entre les crochets avec 0, 1 ou 2 indices autour.

Si on utilise : sans indice, alors une copie superficielle de la liste sera renvoyée.

Si on mentionne un indice avant : mais pas d’indice après, alors une copie
superficielle partielle de la liste de départ sera renvoyée, en commençant à
copier à partir de l’indice donné. Si au contraire on mentionne un indice
après : mais pas d’indice avant, une copie superficielle partielle de la liste de
départ sera renvoyée qui commence au début de la liste et jusqu’à l’indice
32 A. Larhlimi

donné. Enfin, si deux indice sont mentionnés de part et d’autre de :, la tranche
de valeurs correspondant à ces indices sera renvoyée.

Vous devez également savoir que ce qu’on a vu jusqu’ici sur les listes
s’applique également aux chaines de caractères. Les chaînes de caractères
peuvent en effet également être indexées, ce qui signifie qu’on peut accéder
aux caractères par leur position). Cela est logique après tout : les chaines de
caractères sont des “séquences” de caractères tandis que les listes sont des
“séquences” de valeurs.

Comme pour les listes, le premier caractère d’une chaîne possède l’indice 0, le
deuxième l’indice 1 et etc; On va également pouvoir utiliser des indices
négatifs et récupérer des tranches avec :.

Notez qu’il n’existe pas de type distinct pour les caractères en Python : un
caractère est simplement une chaîne de longueur 1.

Ajouter, supprimer, modifier des éléments

d’une liste
A la différence des types de données simples comme les chaines qui sont
immuables, les listes sont un type de données altérable ce qui signifie qu’on va
33 A. Larhlimi

pouvoir altérer leur structure ou modifier leur contenu en ajoutant, supprimant

ou remplaçant des valeurs.

En effet, vous devez bien comprendre qu’une fois qu’on définit une valeur
“chaine de caractères” par exemple, celle-ci ne peut plus être modifiée par la
suite. Les seules opération qu’on va pouvoir faire vont être de créer une
nouvelle chaine en concaténant deux chaines d’origine (qui une nouvelle fois
ne seront pas modifiées) ou de remplacer une chaine par une autre valeur en
affectant une nouvelle valeur dans une variable (ce qui a pour effet d’écraser la
chaine de départ).

Au contraire des chaines, on va tout à fait pouvoir ajouter, modifier ou

supprimer des valeurs dans une liste. Pour cela, on va mentionner le nom de
notre liste avec l’indice de la ou des éléments à ajouter / modifier et leur
affecter une nouvelle valeur. Les affectations de tranches sont possibles :

Notez finalement également qu’on va aussi pouvoir utiliser les opérateurs de

concaténation et de répétition avec des listes :