Programmation Python A l'Intention des étudiants

Master-I, INH, Boumerdes

Qu'est ce qu'un langage de programmation?

A programming language is a language designed to communicate
instructions to a machine, particularly a computer. It provides a set of rules
and syntax that allow developers to write code, which is then translated into
a format that the computer can understand and execute.

Here are the key characteristics of a programming language:



Syntax and Semantics:

Like human languages, programming languages have a defined syntax (the rules for
how code must be written) and semantics (the meaning of the code).


Instructions:

They allow programmers to specify a sequence of operations the computer should

perform, such as calculations, data manipulation, or controlling hardware.


Abstraction:

Many programming languages provide levels of abstraction, allowing developers to

work with higher-level concepts without needing to understand the intricate details of
the underlying hardware.


Translation:
 Code written in a programming language must be translated into machine code (binary
instructions) that the computer's processor can directly execute. This translation is
typically done by a compiler or an interpreter.

Paradigms:

Programming languages can adhere to different programming paradigms, such as

procedural, object-oriented, functional, or logical, each offering a distinct approach to
problem-solving and code organization.
Examples of popular programming languages include:


Python:

Known for its readability and versatility, used in web development, data science, and
AI.


Java:

A robust, object-oriented language widely used for enterprise applications and Android
development.


JavaScript:

Primarily used for interactive web development, running in web browsers.



C++:
 A powerful language used for system programming, game development, and high-
performance applications.

C#:

Developed by Microsoft, used for Windows applications, game development with

Unity, and web development with [Link].
 1. Programmation Python
Sans grand discours introductif, entrons dans le vif du sujet, avec les
suppositions suivantes :

 L'étudiant à qui s'adresse ce cours est familier avec l'utilisation d'un

ordinateur (PC).
 Téléchargé Python depuis l'adresse officielle:
[Link]
 Après Installation de python ouvrir son IDE en faisant click sur son
executable IDLE. (rechercher IDLE dans la barre de recherche )
 Afficher le IDLE shell, qui sera notre outil de travail que je montre ci-
dessous:

1.1 mode interactif

exemple 1
Open a terminal or command prompt

>>> 2 + 3
5
exemple 2
>>> greeting = "Hello, world!"
>>> print(greeting)
Hello, world!

Exit the session

To exit interactive mode, you can use one of these commands:
 exit()

 quit()

1.2 Mode script

 Steps to Run a Python Script:
 Write the code: Create a new file in a text editor or IDE and write your Python program.
 Save the file: Save the file with a .py extension (e.g., my_script.py).

 Open a terminal or command prompt: Navigate to the directory where the script is
saved.
 Execute the script: Type python my_script.py (replacing my_script.py with your file's
name) and press Enter.
Examples:

 Perform calculations:

Type mathematical expressions directly and press Enter.

o >>> 5 + 3 (Addition)

o >>> 10 * 2 (Multiplication)

o >>> 20 / 4 (Division)

o >>> 2 ** 3 (Exponentiation)

1.3 Python operators

These are used for mathematical calculations.

Operator Name Example Result

+ Addition 5 + 2 7

- Subtraction 5 - 2 3

* Multiplication 5 * 2 10

/ Division 5 / 2 2.5

% Modulus 5 % 2 1 (remainder)

** Exponentiation 5 ** 2 25
 // Floor Division 5 // 2 2 (removes remainder)

1.4 Variables and variables and data types

In Python, variables are used to store data, and data types classify the kind of
data a variable holds. Python is dynamically typed, meaning you don't explicitly declare
a variable's type; it's inferred from the assigned value.

Variables:
 A variable is a name assigned to a value, acting as a placeholder for data in your
program.

 You create a variable by assigning a value to a name using the = operator.

 Variable names must start with a letter or an underscore, and can contain letters,
numbers, and underscores. They are case-sensitive.
Python
# Examples of variable assignment
my_integer = 10
my_float = 3.14
my_string = "Hello, Python!"
is_active = True

Data Types:
Python has several built-in data types, categorized as follows:

 Numeric Types:

o int (Integers): Whole numbers, positive or negative, without decimal points (e.g., 5, -
100).

o float (Floating-point numbers): Numbers with a decimal point (e.g., 3.14, 0.5).

o complex (Complex numbers): Numbers with a real and imaginary part (e.g., 1 + 2j).
 Sequence Types:

o str (Strings): Sequences of characters enclosed in single or double quotes

(e.g., "Python", 'coding').

o list (Lists): Ordered, mutable collections of items, enclosed in square brackets (e.g., [1,
2, 3], ['apple', 'banana']).
o tuple (Tuples): Ordered, immutable collections of items, enclosed in parentheses
(e.g., (1, 2, 3), ('red', 'green')).

o range: Represents an immutable sequence of numbers.

 Mapping Type:

o dict (Dictionaries): Unordered collections of key-value pairs, enclosed in curly braces

(e.g., {'name': 'Alice', 'age': 30}).
 Set Types:

o set (Sets): Unordered collections of unique elements, enclosed in curly braces

(e.g., {1, 2, 3}).

o frozenset: Immutable version of a set.

 Boolean Type:

o bool (Booleans): Represents truth values, either True or False.

 None Type:
o NoneType: Represents the absence of a value, with None being the only value of this
type.
You can determine the data type of a variable using the type() function:
Python
x=5
print(type(x)) # Output: <class 'int'>

y = "Hello"
print(type(y)) # Output: <class 'str'>

1.4 Coonversion (function str)

 In Python, converting various data types to strings (type casting to str) is a

common operation. The primary method for this is the built-in str() function.
 The str() function takes an object as an argument and returns its string
representation.
 Example:
number = 123
string_number = str(number)
print(f"Type of number: {type(number)}")
# Type of number: <class 'int'>
print(f"Type of string_number: {type(string_number)}")
# Type of string_number: <class 'str'>
print(f"Value: {string_number}")
# Output: Value: 123
 [Link]

1.5. Les Structures conditionnelles en Python

1.5.1. conditions: if / elif / else

Les structures conditionnelles permettent d'ajouter de la logique dans l'exécution du

code.

Grâce à des conditions, vous pouvez contrôler votre code et exécuter une action A
plutôt qu'une action B par exemple.

Syntaxe
En Python, on écrit une structure conditionnelle grâce au mot clé if :
if condition:
code
...

suite du code
...
Python exécute le code qui se trouve à l'intérieur de votre structure conditionnelle
uniquement si la condition est vraie ( True ).
Si c'est False , le code n'est pas exécuté.
En Python, None et 0 sont des valeurs interprétées comme False
Autre chose, vous devez ajouter deux points : après la condition lors de la déclaration
du if , sans quoi votre code ne fonctionnera pas.
De même, vous devez indenter votre code à l'intérieur de votre structure conditionnelle
pour qu'il soit correctement interprété par Python.

La première ligne indentée marque le début du bloc de code et cela s'arrête à la

première ligne qui ne l'est plus.

age = 24
MAJORITE = 18

if age >= MAJORITE:

print("Je suis majeur !")

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

Dans cet exemple, je souhaite vérifier qu'un utilisateur est majeur.

Je définis une variable age qui correspond à l'âge de l'utilisateur fictif puis une
constante MAJORITE qui est assignée à la valeur 18 , l'âge légal de la majorité en France.
Je démarre ma structure conditionnelle avec le mot-clé if suivi de la condition age >=
MAJORITE et de deux-points :
Si la variable age est égale à 18 ou plus, j'indente mon code et j'affiche le message Je
suis majeur !

Dans tous les cas, le programme se termine par l'affichage de l'âge de l'utilisateur.

if / else
Dans le premier exemple, notre code faisait quelque chose de particulier uniquement si
l'utilisateur était majeur.

Qu'en est-il s'il est mineur ?

Le mot clé else permet d'exécuter une condition si les conditions précédentes ne sont
pas vérifiées.
On doit l'écrire au même niveau d'indentation que le if , finir par deux- points : puis
indenter notre code.

age = 15
MAJORITE = 18

if age >= MAJORITE:

 print("Je suis majeur !")
else:
print("Je suis mineur..")

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

if / elif / else
Le mot-clé elif (pour « else if », en français « sinon si ») permet d'ajouter des
conditions supplémentaires à une structure conditionnelle.
On peut ajouter autant de elif que nécessaire.
Si la condition testée dans le if est False alors on testera celles du/des elif . Si toutes
ces conditions retournent False alors on exécutera le code se trouvant dans le else .

age = 18
MAJORITE = 18

if age > MAJORITE:

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

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

Imbriquer des structures conditionnelles

Vous pouvez imbriquer une structure conditionnelle dans une autre structure, puis dans
une autre, et encore une autre, etc...

On appelle ça de l'imbrication en français (« nesting » en anglais).

Il suffit de déclarer votre nouvelle structure à l'intérieur de la précédente avec une

indentation.

Vous imbriquez ainsi, grâce à l'indentation, plusieurs structures les unes dans les
autres, comme des poupées russes :

age = 18
MAJORITE = 18

if age >= MAJORITE:

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

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

Il est conseillé de ne pas trop abuser de cette imbrication pour que votre code reste
lisible et facile à suivre.

[Link]

1.5.2 Opérateurs de comparaisons

 == : égalité (pour des nombres ou des chaînes).

 != : inégalité (pour des nombres ou des chaînes).
 > >= < <= : comparaison
 is, is not permettent de comparer l'identité des objets (voir ci-dessous).

Traitement de None dans les conditions :

 None == None est vrai

 None != None est faux
 None != 0 est vrai (idem pour n'importe quel nombre : None != 1, None
!= -1, ...)
 None == 0 est faux (idem pour n'importe quel nombre)
 None != 'a' est vrai (idem pour n'importe quelle chaine)
 None != [] est vrai, None != {} est vrai (pareil pour structure non vide)
 None < 0 et None > 0 renvoient des exceptions

Opérateurs booléens :

 and, or, not

  le 'and' et le 'or' sont shortcut/short-circuit, c'est à dire que le deuxième
membre n'est évalué que si c'est nécessaire pour obtenir la valeur
booléenne finale.

xor en python : bool(a) != bool(b)

On ne peut pas faire d'assignation dans une condition comme en c.
Comparaison de 2 objets :

 avant python3, cmp(x, y) renvoie -1 si x < y, 1 si x > y, 0 si x = y.

 en python3, utiliser à la place : (x > y) - (x < y)

Attention :

 4 > 32 est False bien sûr.

 mais '4' > '32' est True, car comparaison de chaînes (et quand ce
sont des variables de type chaîne, on ne s'en rend pas toujours compte
!)

Attention à la comparaison entre types différents en python :

 si on compare un numérique avec une string, c'est toujours le

numérique le plus petit : 40 < '3' est True !!! C'est une cause de bugs
fréquente quand on a oublié de convertir en numériques, et en python3,
ça lève une exception (plus un problème).
 sinon, si on compare 2 objets de types différents, c'est le nom du type
qui est utilisé : [1, 2] < (1, 2) donne True, car 'list' est avant 'tuple' !!!
Mais en python3, ça lève une exception.

is, is not : pour savoir si 2 objets mutables sont réellement les mêmes :
 myList = ['a', 'b']; myList2 = ['a', 'b']
 myList == myList2 renvoie True.
 myList is myList renvoie True.
 myList is myList2 renvoie False.
 myList is not myList2 renvoie True.
 on a le même comportement avec des tuples ou des dictionnaires.
 par contre, pas le même comportement avec des chaînes :
o myString = 'abc'; myString2 = 'abc'; myString is
myString2 renvoie True, car les 2 variables pointent vers la même
chaîne !
o par contre, myString = 'abc'; myString2 = 'ab'; myString2 +=
'c'; myString is myString2 renvoie False !
[Link]

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 fonction 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 :

c = ["Ahmed", "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 Ahmed

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 = ["Ahmed", "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 = ["Ahmed", "est", "dans", "le", "jardin"]

for i in c:
print("i vaut", i)

i vaut Ahmed
i vaut est
i vaut dans
i vaut le
i vaut jardin

Boucle while
Syntaxe :

while condition:
Instruction A

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
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.

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
[Link]
python3/?page=page_6#L6-B

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")
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")
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
Tuples en Python
A partir des types de base (int, float, etc.), il est possible d’en élaborer de nouveaux. On
les appelle des types construits.

Un exemple de type construit est le tuple. Il permet de créer une collection ordonnée
de plusieurs éléments. En mathématiques, on parle de p-uplet. Par exemple, un
quadruplet est constitué de 4 éléments.

Les tuples ressemblent aux listes, mais on ne peut pas les modifier une fois qu’ils ont été
créés.
On dit qu’un tuple n’est pas mutable.

On le définit avec des parenthèses.

>>>a = (3, 4, 7)
>>>type(a)
<class 'tuple'>
Parfois, les tuples ne sont pas entourés de parenthèses, même s’il s’agit quand même de
tuples.

Ainsi, on peut utiliser la notation suivante :

>>> b, c = 5, 6
>>> b
5
>>>c
6

En fait, cela revient à :

>>> (b, c) = (5, 6)

Cette syntaxe avec plusieurs variables à gauche du signe = peut aussi être utilisée avec
une variable unique à droite si celle-ci contient un tuple.

>>> a = (3, 4)
>>> u, v = a
>>> u
3
>>> v
4

Comment écrire une fonction qui renvoie un p-uplet de valeurs ?

Il est très facile de créer une fonction qui renvoie un tuple. Il suffit d’indiquer ce tuple
après return .

def test():
return 3, 4

>>> a = test()
>>> a
(3, 4)
>>> b, c = test()
>>> b
3
>>> c
4

Note

Après return, il aurait été possible d’utiliser une notation avec des parenthèses pour le
tuple, par exemple return (3, 4).

Comment itérer sur les éléments d’un tuple ?

Comme une liste, il est possible de parcourir un tuple avec une boucle for.

for i in a:
print(i)

Résultat

3
4

La valeur d’un élément du tuple est obtenue en utilisant la même syntaxe que pour une
liste.

>>> a[0]
3
>>> a[1]
4

Comment créer un tuple qui contient un seul élément ?

Si on utilise seulement des parenthèses, on n’obtient pas le résultat escompté.

>>> a = (3)
>>> a
3
>>> type(a)
int

En effet, les parenthèses sont alors considérées comme celles d’une expression
mathématique, comme par exemple dans 3*(4+1) .

Pour créer un tuple contenant un seul élément, il faut donc utiliser une syntaxe
spécifique qui contient une virgule.

>>> b = (3,)
>>> b
(3,)
>>> type(b)
<class 'tuple'>

Si on veut récupérer l’unique valeur présente dans le tuple, on va pouvoir utiliser les
approches suivantes :

Première approche

>>> c = b[0]
>>> c
3

Deuxième approche

>>> d, = b
>>> d
3

La deuxième approche avec une virgule d, = b est plus légère que la syntaxe qui utilise
des crochets c = b[0] .

Il est possible d’utiliser la syntaxe nom_de_variable, = aussi avec une liste à un élément.

>>> u = [5]
>>> v, = u
>>> v
5

Dictionnaires en Python
Comme on l’a vu avec les listes et les tuples, à partir des types de base (int, float, etc.) il
est possible d’élaborer de nouveaux types qu’on appelle des types construits.

Un nouvel exemple de type construit est le dictionnaire.

Les éléments d’une liste ou d’un tuple sont ordonnés et on accéde à un élément grâce à
sa position en utilisant un numéro qu’on appelle l”indice de l’élément.
Un dictionnaire en Python va aussi permettre de rassembler des éléments mais ceux-ci
seront identifiés par une clé. On peut faire l’analogie avec un dictionnaire de français où
on accède à une définition avec un mot.

Contrairement aux listes qui sont délimitées par des crochets, on utilise
des accolades pour les dictionnaires.

>>> mon_dictionnaire = {"voiture": "véhicule de transport terrestre", "vélo":

"véhicule à deux roues"}
Un élément a été défini ci-dessus dans le dictionnaire en précisant une clé au moyen
d’une chaîne de caractères suivie de : puis de la valeur associée

clé: valeur

On accède à une valeur du dictionnaire en utilisant la clé entourée par des crochets
avec la syntaxe suivante :

>>> mon_dictionnaire["voiture"]
'véhicule à quatre roues'

Comment construire une entrée dans un

dictionnaire ?
Il est très facile d’ajouter un élément à un dictionnaire. Il suffit d’affecter une valeur pour la
nouvelle clé.

>>> mon_dictionnaire["tricycle"] = "véhicule à trois roues"

>>> mon_dictionnaire
{'voiture': 'véhicule à quatre roues',
'vélo': 'véhicule à deux roues',
'tricycle': 'véhicule à trois roues'}
Le type d’un dictionnaire est dict .

>>> type(mon_dictionnaire)
dict
Il est aussi possible d’utiliser des valeurs d’autres types.

Voici un exemple où les valeurs sont des entiers.

>>> nombre_de_roues = {"voiture": 4, "vélo": 2}

type(nombre_de_roues)
dict
>>> nombre_de_roues["vélo"]
2

Comment créer un dictionnaire ?

Nous avons vu ci-dessous qu’il était possible de créer un dictionnaire avec des accolades qui
entourent les éléments. Une autre approche possible consiste à créer un dictionnaire vide et à
ajouter les éléments au fur et à mesure.

>>> nombre_de_pneus = {}
>>> nombre_de_pneus["voiture"] = 4
>>> nombre_de_pneus["vélo"] = 2
>>> nombre_de_pneus
{'voiture': 4, 'vélo': 2}

Comment parcourir un dictionnaire ?

On utilise items() .
Exemple pour une boucle for avec un indice i
>>> nombre_de_roues = {"voiture": 4, "vélo": 2, "tricycle": 3}

>>> for i in nombre_de_roues.items():

print(i)
('voiture', 4)
('vélo', 2)
('tricycle', 3)
Autre exemple pour une boucle for avec deux indices : cle et valeur

for cle, valeur in nombre_de_roues.items():

print("l'élément de clé", cle, "vaut", valeur)
l'élément de clé voiture vaut 4
l'élément de clé vélo vaut 2
l'élément de clé tricycle vaut 3

Fonctions en Python
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.

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

[Link]

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()
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()

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)

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)

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 :

 o Le nom d’une variable que nous passons comme argument n’a rien à
voir avec le nom du paramètre correspondant dans la fonction.
o 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)

Affichage après exécution :

1
3
5

Note

o 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.
o 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)
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 . 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)
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.

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 :

Exemple :

import numpy as np

def cube(n):
return n**3

def volume_sphere(r):
return 4 / 3 * [Link] * 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 :

o les deux fonctions cube() et volume_sphere()

o 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 :

o d’abord la définition des fonctions,

o 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 !
Résumé : structure d’un programme
Python type
Voir aussi

[Link]

précédent
Dictionnaires en Python

suivant
Modules et importations

o Définition d’une fonction - def

o Variables locales, variables globales
o « Vraies » fonctions et procédures
o Valeurs par défaut pour les paramètres
o