Chapitre 4 Fonctions

INGENIEUR Agro-Industrie, GÉOLOGIE &
Environnement (IAGE)
Chapitre 4 : Fonctions

Prérequis :
 Interpréteur Python Installé et fonctionnel ;
 Connaissance sur la notion de variable en Python ;
 Utilisation basique des fonctions en Python ;
 Connaissance des types de bases Built-in.
Objectifs : A la fin de cette leçon chaque étudiant en classe de 1 ère Année Agro doit
être capable de :
 Expliquer la notion de type hint en moins de 50 mots ;

 Utiliser les types hint dans une fonction avec une performance de 100% ;
 Expliquer la notion d’objet mutable en moins de 50 mots ;
 Expliquer la notion d’objet immuable en moins de 50 mots ;
 Donner la différence entre un objet mutable et un objet immuable avec une
performance de 100% ;
 Déclarer un objet de type list avec une performance de 100% ;
 Manipuler une liste avec une performance de 100% ;
 Expliquer la notion de passage par référence avec une performance de 100% ;
 Expliquer la notion de passage par valeur avec une performance de 100% ;
 Donner la différence entre un argument passé par valeur et un argument passé
par référence dans une fonction avec une performance de 100% ;
 Expliquer la notion de variable locale avec une performance de 100% ;
 Expliquer la notion de variable globale avec une performance de 100% ;
 Expliquer la notion de splat de liste au niveau des appels d’une fonction avec
une performance de 100% ;
 Ecrire des fonctions avec des arguments variables avec une performance de
100% ;
 Utiliser des fonctions avec des arguments variables avec une performance de
100% ;
 Ecrire des fonctions avec des arguments possédant des valeurs par défaut avec
une performance de 100% ;
Introduction
Dans les chapitres précédents, nous avons appris à déclarer et utiliser sommairement
les fonctions en Python. Dans ce nouveau chapitre nous appesantirons un plus sur
cette notion. Afin de mieux manipuler les concepts avancés liés à l’utilisation des
fonctions nous introduirons également dans ce chapitre la notion de liste.
I. La notion de Liste
1. Notion de structure de données
Une Structure de données est une manière d’organiser les données pour les traiter plus
facilement. C’est l’implémentation d’un type abstrait. Un type abstrait est une
spécification mathématique d’un ensemble de données et de l’ensemble des opérations
qu’on peut effecteur sur elle. Une structure de données définie à cet effet comment
organiser les données, comment y avoir accès, quelles sont les opérations qu’on peut
appliquer sur ces données. On dénombre différente structure de données : variable,
constante, tableau, enregistrement, liste, etc.
2. C’est quoi une liste

Une liste est une collection d’objet séquentiel. Dans cette collection les objets sont
rangés suivant un ordre arbitraire. Une liste est donc un objet capable de contenir
d’autres objets de n’importe quel type. On peut donc avoir une liste contenant
plusieurs nombres entiers [1, 2, 3, 4, …], une liste contenant des valeurs flottantes,
une liste contenant des chaines de caractères, … et une liste mélangeant tous ces
objets.
3. Liste en python
Les listes en Python, font partir des objets mutables. C’est quoi un objet mutable ?
Python désigne comme mutable tout objet qui n’est pas immuable, c’est à dire qui
peut être modifié après sa création. Au premier chapitre, nous avons présenté un
ensemble de type d’objet. Tous ces types d’objets que nous avons présentés sont des
types immuables. Ainsi, après avoir créé un objet de type int, float, decimal, str,
complex, il n’est plus possible de les modifier.
En Python, les listes sont séquences, c’est-à-dire une collection ordonnée d’objets de
mêmes types ou de types différents séparés par des virgules. Les types en Python sont
de type list.
a. Déclaration d’une liste

Pour créer une liste, on peut utiliser la fonction list(), un peu comme pour un nombre
complexe, ou un entier, une chaîne de caractère ou un flottant. On peut également
créer une liste en utilisant l’opérateur crochet [ ] affecté à une variable. On peut y
ajouter la liste des éléments de cette liste, séparés les uns aux autres par des virgules.
Les exemples ci-dessous montre comment créer une liste.
Exemple
>>> liste = list() # une liste vide avec aucun élément
>>> liste
[]
>>> liste = list([1, 3]) # une liste deux éléments
>>> liste
[1, 3]
>>> liste = [1, 3, 5, 3+2j] #Une liste de 3 entier et un complexe
>>> liste
[1, 3, 5, (3+2j)]
>>> liste = [1, 3, 5, 3+2j, "bonjour", 'Python', 3.14] # une liste d’objet
de type différent
>>> liste
[1, 3, 5, (3+2j), 'bonjour', 'Python', 3.14]
>>> liste = [1, 3, 5, 3+2j, [1, 3+3j], 3.14, []] # Une liste peut contenir
d’autre liste évidemment !
>>> liste
[1, 3, 5, (3+2j), [1, (3+3j)], 3.14, []]
b. Accéder aux éléments d’une liste

Les listes sont une collection indexée. Ce qui signifie qu’on peut y accéder comme
nous l’avons fait avec les chaînes de caractères grâce à l’opérateur [ ]. Le premier
élément d’une liste se trouve donc à l’index 0 et le dernier est à n-1, si n est le nombre
d’élément de la liste. Voyons un peu tout ça avec un exemple concret.
>>> liste = [1, 3, 5, 3+2j] # Une liste de 4 éléments
>>> liste[0] # On accède au premier élément c’est-à-dire 1
1
>>> liste[3] # On accède au troisième élément
(3+2j)
>>> liste[4] # Attention accéder à un index supérieur ou égale au nombre
d’élément de la liste provoque une erreur d’index (IndexError).
Traceback (most recent call last):
File "<pyshell#21>", line 1, in <module>
liste[4]
IndexError: list index out of range
>>> liste[1:] # On peut effectuer des slides aussi comme avec les str
[3, 5, (3+2j)]
>>> liste[2] = "mutable" # on peut modifier des éléments
>>> liste
[1, 3, 'mutable', (3+2j)]
>>> autre = "Bonjour"
>>> autre[2]
'n'
>>> autre [2]= 'p' # Attention les chaine ne sont pas mutable par contre
Traceback (most recent call last):
File "<pyshell#27>", line 1, in <module>
autre [2]= 'p'
TypeError: 'str' object does not support item assignment
c. Operations sur les listes

Comme nous l’avons vu au premier chapitre qu’on peut déterminer la liste des
opérations applicables à un type via la commande dir(nom_du_type). Voyons un peu,
ce qu’il est possible de faire sur une liste dans un interpréteur Python avec la
commande dir(list).
>>> dir(list)
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__',

'__dir__', '__doc__', '__eq__', '__format__', '__ge__',
'__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__',
'__imul__', '__init__', '__init_subclass__', '__iter__', '__le__',
'__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__',
'__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append',
'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove',
'reverse', 'sort']
Intéressons-nous uniquement aux méthodes n’ayant pas d’Under score.
 append. La méthode append permet d’ajouter un élément dans une liste. Cela
est possible parce qu’une liste est un objet mutable c’est-à-dire qui peut
changer après sa création (Et oui ! la répétition est la mère des écoles  ).
Voyons ça dans un exemple.
>>> liste = []
>>> liste
[]
>>> liste.append(1)
>>> liste
[1]
>>> liste.append("ok")
>>> liste
[1, 'ok']
 clear. La méthode clear permet de retirer tous éléments d’une liste. Un exemple
pour illustrer tout ça.
>>> liste = [1, 3, 5, 3+2j]
>>> liste
[1, 3, 5, (3+2j)]
>>> liste.clear()
>>> liste
[]
 copy. La méthode copy, retourne une copie de tous les éléments d’une liste.
Une telle copie est appelée dans le jargon du langage Python Shallow Copy. Ce
qui est différent d’une deep copy. Pour l’instant ne cherchons pas à savoir la
différence, voyons plutôt comment utiliser la fonction copie dans un exemple.
>>> liste = [1, 3, 5, 3+2j]

>>> listecopy = liste.copy()
>>> listecopy
>>> id(liste) # la function id permet de determiner l’identifiant
d’un objet en Python. Deux objets différents on toujours un id
différent.
1935223728200
>>> id(listecopy)
1935223816456
>>> id(listecopy) == id(liste)
False
 Count, permet de déterminer le nombre d’occurrence d’un élément dans une
liste.
>>> liste = [1, 3, 5, 1, [1, 3+3j], 1, []]
>>> liste.count(1)
3
 Extend, permet d’étendre le contenu d’une liste par une autre liste.
>>> liste = [1, 3, 5, 1, [1, 3+3j], 1, []]
>>> liste1 = [3, 4, 'bonjour', "Monsieur"]
>>> liste.extend(liste1)
>>> liste
[1, 3, 5, 1, [1, (3+3j)], 1, [], 3, 4, 'bonjour', 'Monsieur']
 Index, retourne l’index de la première occurrence d’un objet dans une liste.
>>> liste = [1, 3, 5, 1, [1, 3+3j], 1, []]
>>> liste.index(1)
0
>>> liste.index(5)
2
 Pop, retire et retourne le dernier élément d’une liste.
>>> liste = [1, 3, 5, 1, [1, 3+3j], 1, []]
>>> last = liste.pop()
>>> liste
[1, 3, 5, 1, [1, (3+3j)], 1]
>>> last
[]
>>> last = liste.pop()
>>> last
1
>>> liste
[1, 3, 5, 1, [1, (3+3j)]]
 Remove, retire la première occurrence d’un objet dans une liste. L’objet à
retirer doit être spécifié comme argument à la fonction.
>>> liste = [1, 3, 5, 1, [1, 3+3j], 1, []]
>>> liste.remove(1)
>>> liste
[3, 5, 1, [1, (3+3j)], 1, []]

 Reverser, renverse le contenu d’une liste, la queue de la liste devient la tête et
vice-versa.
[3, 5, 1, [1, (3+3j)], 1, []]
>>> liste = [1, 3, 5, 1, [1, 3+3j], 1, []]
>>> liste.reverse()
>>> liste
[[], 1, [1, (3+3j)], 1, 5, 3, 1]
>>> liste.reverse()
>>> liste
[1, 3, 5, 1, [1, (3+3j)], 1, []]
 Sort, permet d’ordonner les éléments d’une liste.
>>> liste = [1, 10, 4, 2, 7, 30, 3]
>>> liste.sort()
>>> liste
[1, 2, 3, 4, 7, 10, 30]
>>> liste.sort(reverse=True)
>>> liste
[30, 10, 7, 4, 3, 2, 1]
d. Déterminer la taille d’une liste

Pour déterminer la taille d’une liste c’est-à-dire le nombre d’objet d’une liste on utilise
la fonction built-in len. Une fonction built-in (respectivement un type built-in) est une
fonction native définie dans Python, que vous n’avez pas besoin de déclarer. Nous
avons déjà eu à utiliser plusieurs fonction de ce type dans les chapitres précédents :
help(), list(), dir(), int(), etc. Voyons un peu dans un exemple comment utiliser cette
fonction built-in.
>>> liste = [1, 3, 5, 1, [1, 3+3j], 1, []]
>>> len(liste)
7
e. Conversion d’une liste en chaine de caractère
Il est possible de convertir un objet de type list en un objet de type str et vice versa. Ce
sont des opérations assez courantes lorsqu’il s’agit d’afficher le contenu d’une liste ou
de couper une chaîne en plusieurs parties. Ceci est encore plus utile lorsqu’on veut
modifier une chaîne de caractère. Il suffit de la transformer en un objet liste (objet
mutable), après les opérations de modifications transformer la liste en chaîne de
caractère (objet non mutable).
Pour convertir une chaîne en liste, on la découpe suivant un séparateur qu’on aura
choisi, à l’aide de la fonction split. Sans argument, la fonction split utilise l’espace
comme séparateur. Voyons un peu ça dans un exemple.
>>> chaine = "Bellle marquise, Vos beaux yeux, me font mourir d'amour"
>>> liste = chaine.split()

>>> liste
['Bellle', 'marquise,', 'Vos', 'beaux', 'yeux,', 'me', 'font', 'mourir',
"d'amour"]
>>> liste = chaine.split(',')
>>> liste
['Bellle marquise', ' Vos beaux yeux', " me font mourir d'amour"]
Pour effecteur l’opération inverse, c’est-à-dire transformer une liste en chaîne de

caractère, on utilise la fonction join. Voyons un peu ça sans un exemple.
>>> liste =['Bellle marquise', ' Vos beaux yeux', " me font mourir
d'amour"]
>>> chaine = ",".join(liste)
>>> chaine
"Bellle marquise, Vos beaux yeux, me font mourir d'amour"
f. Vérifier qu’un objet est dans une liste

Pour vérifier qu’un objet est dans un liste on utilise l’opérateur in comme avec les
chaînes de caractères. Voyons un peu cela dans un exemple :
>>> liste = [1,2,3,5,10]
>>> 3 in liste
True
>>> 11 in liste
False
II. Complément sur les fonctions

Dans le chapitre 2 nous avons présenté la notion de fonction en Python. Nous avons
vu, comment créer et utiliser les fonctions en Python. Dans cette section du chapitre 4,
nous allons aller un peu plus loin. Nous parlerons particulièrement des notions de
passage d’arguments, de variable globale et variable locale, d’argument variable, de
type hint, de valeur par défaut des arguments d’une fonction.
1. Passage d’argument
En programmation on distingue deux types de passage des arguments à une fonction.
Le passage par référence et le passage par valeur.
a. Passage par valeur

Un argument est passé par valeur si toute modification effectuée sur cet argument
dans le corps de la fonction n’a aucun impact sur l’objet passé comme argument
effectif après l’utilisation de la fonction. En python tous les objets immuables sont
passés par valeur. Voyons un peu tout cela à travers un exemple.
>>> def parvaleur(val):
if val > 0 :
val = 12
print(f"La valeur de la variable val est {val}")
else:
val = -12
print(f"La valeur de la variable val est {val}")
>>> value = 2
>>> parvaleur(value)
La valeur de la variable val est 12
>>> value
2
Comme on peut le voir dans cet exemple, toute modification effectuée sur le
paramètre effectif value, dans le corps de la fonction parvaleur, n’a aucune
répercussion après l’exécution de la fonction. En effet, cela est possible parce que la
fonction ne travaille pas avec l’objet passé en argument, mais plutôt avec une copie de
cet objet, ainsi toute modification de la copie, n’affecte pas l’objet copié.
b. Passage par référence

Un argument est passé par référence si toute modification effectuée sur ce paramètre
dans le corps de la fonction est valable après l’exécution de la fonction. En python,
tous types mutables sont passés par référence. Voyons un peu tout cela au travers d’un
exemple.
>>> liste= [1, 3, 5, 9]
>>> parreference(liste)
>>> liste
[1, 3, 5]
>>> liste
[1, 3]
>>> liste
[1]
>>> liste
[]
>>> liste
[1]
Dans cet exemple nous voyons que toute modification effectuée sur le paramètre
effectif liste, dans le corps de la fonction parreference, est valable après l’exécution
de la fonction. En effet, cela est possible parce qu’en Python, lorsque l’objet est
mutable, c’est la référence de l’objet qui est utilisé comme argument. Ainsi, toute
modification effectuée sur l’objet indiquant cette référence est valable même après
l’exécution de la fonction. L’exemple suivant démontre cela.
>>> def parreference(val):
print(f"{id(val)}")
if(len(val) > 0 ):
val.pop()
else:
val.append(1)
>>> liste = [1, 2]

>>> id(liste)
1935223734984
1935223734984
Dans cet exemple, nous voyons bien que l’identifiant de l’objet utilisé comme
argument est le même que l’objet passé comme argument.
2. Variable globale et variable locale

En informatique, notamment en programmation, lorsqu’on parle de fonction ou de
procédure, il faut nécessairement introduire la notion de variable globale et locale. En
programmation, une variable locale est une variable qui ne peut être utilisée que dans
la fonction ou le bloc où elle est définie. Une variable globale par contre est utilisée
dans tous le programme.
En python, toute variable déclarée à la racine d’un module est globale dans tout ce
module. Une variable déclarée dans une fonction ne sera visible que dans cette
fonction, elle est donc locale à la fonction. Voyons tout cela dans un exemple.
>>> x = "hello"
>>> def test():
... print x
>>> test()
hello
>>> x = False
>>> def test():
... x = "hello"
...
>>> test()
>>> x
False

Chapitre 4 Fonctions

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre 4 Fonctions

Transféré par

Droits d'auteur :

Formats disponibles

INGENIEUR Agro-Industrie, GÉOLOGIE &

Chapitre 4 : Fonctions

 Expliquer la notion de type hint en moins de 50 mots ;

2. C’est quoi une liste

a. Déclaration d’une liste

b. Accéder aux éléments d’une liste

c. Operations sur les listes

['add', 'class', 'contains', 'delattr', 'delitem',

Intéressons-nous uniquement aux méthodes n’ayant pas d’Under score.

>>> liste = [1, 3, 5, 3+2j]

[3, 5, 1, [1, (3+3j)], 1, []]

d. Déterminer la taille d’une liste

>>> liste = chaine.split()

Pour effecteur l’opération inverse, c’est-à-dire transformer une liste en chaîne de

f. Vérifier qu’un objet est dans une liste

II. Complément sur les fonctions

a. Passage par valeur

b. Passage par référence

>>> liste = [1, 2]

2. Variable globale et variable locale

>>> def test():

>>> def test():

Vous aimerez peut-être aussi