programmation en python - igmigm.univ-mlv.fr/~alabarre/teaching/shnu/poly-shnu.pdfpython accorde une...

Programmation en Python

Anthony Labarre

Année académique 2017–2018

Table des matières

1 Introduction à Python 51.1 Particularités de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

1.1.1 Indentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51.1.2 Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71.1.3 Objets (non) modifiables . . . . . . . . . . . . . . . . . . . . . . . . . 71.1.4 Garbage collector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71.1.5 Messages d’erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.2 Installation de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81.3 Utilisation de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91.4 Environnements de développement recommandés . . . . . . . . . . . . . . . . 91.5 Conventions de style . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101.6 Configuration des éditeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

1.6.1 Geany. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101.6.2 PyCharm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2 Les bases du langage 132.1 Variables et types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2.1.1 Types de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132.1.2 Transtypage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142.1.3 Variables et affectations . . . . . . . . . . . . . . . . . . . . . . . . . 14

2.2 Opérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.2.1 Opérations sur les nombres . . . . . . . . . . . . . . . . . . . . . . . . 152.2.2 Opérations logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 162.2.3 Opérations sur les chaînes . . . . . . . . . . . . . . . . . . . . . . . . 162.2.4 Formes condensées . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2.3 Branchements conditionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . 172.3.1 Version basique du if . . . . . . . . . . . . . . . . . . . . . . . . . . 172.3.2 Alternative au if: le else . . . . . . . . . . . . . . . . . . . . . . . 172.3.3 Autres options: le mot clé elif . . . . . . . . . . . . . . . . . . . . . . 18

3 Structures itérables et boucles for 193.1 Boucles for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203.2 Un itérable particulier: range . . . . . . . . . . . . . . . . . . . . . . . . . . 213.3 Chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

3.3.1 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223.3.2 Manipulation de chaînes . . . . . . . . . . . . . . . . . . . . . . . . . 223.3.3 Itérer sur des chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3.4 Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

3

TABLE DES MATIÈRES TABLE DES MATIÈRES

3.5 Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243.5.1 Modification de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . 253.5.2 Copie de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253.5.3 Méthodes des listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3.6 Ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273.7 Dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

3.7.1 Déclaration et manipulation . . . . . . . . . . . . . . . . . . . . . . . 293.7.2 Itérer sur des dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . 29

3.8 La boucle while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

4 Les fonctions 314.1 Fonctions sans paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314.2 Fonction avec paramètre(s) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324.3 Renvoi de valeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324.4 Portée des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334.5 Compléments sur les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . 34

Programmation en Python 4

Chapitre 1. Introduction à Python

Chapitre 1

Introduction à Python

Sommaire1.1 Particularités de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

1.1.1 Indentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51.1.2 Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71.1.3 Objets (non) modifiables . . . . . . . . . . . . . . . . . . . . . . . . 71.1.4 Garbage collector . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71.1.5 Messages d’erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.2 Installation de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81.3 Utilisation de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91.4 Environnements de développement recommandés . . . . . . . . . . . . . 91.5 Conventions de style . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101.6 Configuration des éditeurs . . . . . . . . . . . . . . . . . . . . . . . . . . 10

1.6.1 Geany. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101.6.2 PyCharm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

1.1 Particularités de Python

Python est au départ un langage de script, qui a grandement évolué pour devenir un langageorienté objet et polyvalent. On peut exécuter du code Python soit sous la forme de programme,soit en tapant des lignes de code dans un interpréteur. Il est également possible de compiler lesprogrammes que l’on écrit. Voici quelques particularités de ce langage, qui vous permettront dele situer par rapport aux autres langages que vous connaissez.

1.1.1 Indentation

Dans les autres langages, l’indentation (le fait de décaler le début des lignes de code) que l’onrencontre est recommandée pour des raisons de lisibilité; en Python, elle est essentielle car elledélimite les blocs d’instructions et joue le rôle des accolades que l’on rencontre entre autres enC/C++ et Java. Voici par exemple un programme écrit en C affichant les nombres de 1 à 20 enprécisant lesquels sont divisibles par 3.



1 #include <stdio.h>2

3 int main(int argc, char **argv) {4 for(int i=1; i<21; ++i) {5 printf("%d", i);6 if(i % 3 == 0) {7 printf(" (multiple de 3)");8 }9 printf("\n");

10 }11 }

En guise de comparaison, voici un programme en Python qui fait exactement la même chose:

1 def main():2 for i in range(1, 21):3 print(i, end='')4 if not i % 3:5 print(' (multiple de 3)', end='')6 print()7

8 if __name__ == '__main__':9 main()

La première ligne d’un bloc est son entête et se termine par un “:”. On en retrouve déjà troisexemples ci-dessus, sur lesquels on reviendra plus tard:

1 def main():2 ...

1 for i in range(1, 21):2 ...

1 if not i % 3:2 ...

Les blocs se présentent donc comme suit:

1 entete du bloc:2 instruction 1 du bloc3 instruction 2 du bloc4 ...5 instruction hors bloc

Attention: Python interdit le mélange de tabulations et d’espaces pour l’indentation! Configurezdonc votre éditeur pour qu’il remplace toutes les tabulations par des espaces.



1.1.2 Types

Chaque variable en Python possède un type qui est pris en compte lors des opérations. Ce typeest déclaré explicitement ou implicitement dans la partie droite de l’expression déclarant lavariable: autrement dit, Python déduit lui-même le type de l’expression.

1 # ceci est un commentaire2 n = 23 # n est entier3 x = 3.14 # x est reel4 s = "bonjour" # s est une chaine de caracteres

Contrairement au C par exemple, on peut tout à fait changer le type d’une variable dansl’exécution d’un programme (mais ce n’est pas conseillé, sauf pour le passage d’un type denombres à un autre):

1 x = 3 + 5 # x est entier2 x = x / 2 # x devient reel3 x = [4, -1] # permis mais deconseille: x devient une liste

1.1.3 Objets (non) modifiables

Python met deux catégories d’objets à notre disposition: des objets modifiables et des objetsnon modifiables. On verra plus loin que cette distinction a son importance, notamment lors descopies de variables et des appels de fonctions.

1.1.4 Garbage collector

Comme en Java, il existe un garbage collector, qui se charge de détruire les variables inutil(isé)es.L’utilisateur n’a donc pas à se préoccuper de supprimer des variables. En cas de besoin, on peutaussi décider de les détruire soi-même avec l’instruction , mais c’est rarement nécessaire.

1.1.5 Messages d’erreurs

Les messages d’erreurs en Python sont généralement très explicites, et nous indiquent précisé-ment à quelle ligne il y a un problème. Voici quelques exemples pour se faire une idée):

1 >>> x = 37 / 02 Traceback (most recent call last):3 File "<stdin>", line 1, in <module>4 ZeroDivisionError: division by zero5 >>> y = "bonjour" - 56 Traceback (most recent call last):7 File "<stdin>", line 1, in <module>8 TypeError: unsupported operand type(s) for -: 'str' and 'int

'9 >>> import module_inexistant



10 Traceback (most recent call last):11 File "<stdin>", line 1, in <module>12 ImportError: No module named 'module_inexistant'

1.2 Installation de Python

On utilisera dans ce cours la version 3 de Python. Les instructions spécifiques à suivre dépendentde votre système d’exploitation (s’il n’est pas repris dans la liste ci-dessous, allez sur http://www.python.org et suivez les instructions correspondantes):

— Sous Ubuntu / Debian: ouvrez un terminal et tapez:

1 $ sudo apt-get install python3

— Sous Windows: téléchargez le programme d’installation sur http://www.python.org etsuivez le programme d’installation mais ajoutez python à la variable PATH!

FIGURE 1.1 – Option à activer lors de l’installation de Python sous Windows.

Sans cela, vous ne pourrez pas taper python dans le terminal;


http://www.python.org




1.3 Utilisation de Python

Il y a deux manières d’utiliser Python: soit en lançant l’interpréteur, soit en lançant un programmequ’on a écrit. Dans le mode interpréteur, il nous suffit d’ouvrir un terminal et de taper python3(ou python selon votre installation 1) pour qu’un interpréteur s’ouvre comme ci-dessous:

1 $ python32 Python 3.5.3 (default, Jan 19 2017, 14:11:04)3 [GCC 6.3.0 20170118] on linux4 Type "help", "copyright", "credits" or "license" for

more information.5 >>>

Les trois chevrons (>>>) indiquent que l’interpréteur attend une commande; on peut alorstaper ce qu’on veut comme code Python, et voir immédiatement le résultat. Il s’agit d’un modeinteractif, et les exemples du cours qui utiliseront cette notation indiqueront que le code estexécuté dans l’interpréteur. Pour sortir de l’interpréteur, on appuie sur Ctrl+D, ou on tapeexit().

Parfois, les exemples de code montrés dans l’interpréteur comporteront des points de suspension(. . .) en début de ligne:

1 >>> if 1 < 2 and 5 / 2 == 2.5:2 ... print("Python sait compter et calculer")3 ...4 Python sait compter et calculer

Ceci indique simplement que Python a compris que les lignes qui suivent l’entête d’un bloc fontpartie de ce bloc; il ne s’agit pas de quelque chose que vous devez vous-même écrire, et on ne lefera pas hors de l’interpréteur.

L’interpréteur est particulièrement utile quand on veut tester rapidement du code, car il n’estpas nécessaire d’écrire un programme entier puis de le lancer pour obtenir un résultat. Si enrevanche, on a écrit un programme nommé monprogramme.py que l’on désire exécuter, ilnous suffit de taper dans le terminal:

1 $ python3 monprogramme.py

Le programme s’exécutera alors, et on récupérera le terminal quand il se terminera.

1.4 Environnements de développement recommandés

PyCharm est l’un des environnements les plus complets, multi-plateformes et disposant d’uneversion gratuite. Il est disponible ici: https://www.jetbrains.com/pycharm/

D’autres éditeurs ou environnements existent, dont une sélection non exhaustive est donnéeci-dessous:

1. Dans le reste du document, on suppose que ce sera bien python3 .


https://www.jetbrains.com/pycharm/


— Geany: https://www.geany.org/— PyCharm:— Notepad+: https://notepad-plus-plus.org/— Kate: http://kate-editor.org/— SublimeText: https://www.sublimetext.com/— . . .

Quel que soit votre choix, il est important que l’éditeur de texte que vous utilisez propose lacoloration syntaxique. En outre, il est essentiel de le configurer, si ce n’est déjà fait, pour qu’ilremplace les espaces par des tabulations, sans quoi vous risquez de voir le message suivantquand vous exécutez un programme où vous mélangez les deux:

1 $ python3 test.py2 File "test.py", line 33 print("voila")4 ^5 TabError: inconsistent use of tabs and spaces in indentation

1.5 Conventions de style

Python accorde une liberté relative pour nommer les variables, les fonctions et les modules,mais il est recommandé de suivre quelques règles. Tant qu’à se plier à des conventions, utilisonscelles qui sont officiellement recommandées par PEP8, qu’on se contentera de résumer ici sansles justifier 2:

— l’indentation se fait à l’aide d’espaces, et non de tabulations: chaque niveau d’indentationcorrespond à 4 espaces;

— l’encodage du fichier doit être UTF-8 (Unicode);— les variables locales et les noms de fonctions doivent être en minuscules et disponibles

en ASCII; si plusieurs mots sont nécessaires, on les sépare par des underscores.

Pour vérifier si votre programme satisfait à ces exigences, tapez

1 $ pep8 monprogramme.py

dans un terminal. Si rien ne s’affiche, c’est que vous avez suivi toutes les recommandationscorrectement; sinon, les problèmes seront signalés.

1.6 Configuration des éditeurs

1.6.1 Geany.

— Edit→Preferences (ou Ctrl+Alt+P)→Editor→Indentation: mettez “Width” à 4 et cochez“Spaces”;

2. Voir https://www.python.org/dev/peps/pep-0008/ pour plus de détails.


https://www.geany.org/

https://notepad-plus-plus.org/

http://kate-editor.org/

https://www.sublimetext.com/

https://www.python.org/dev/peps/pep-0008/


— en ayant ouvert un fichier .py: Build→Set Build Commands: remplacez toutes lesoccurences de python par python3;

1.6.2 PyCharm.

Aucune configuration n’est nécessaire.


Chapitre 2. Les bases du langage

Chapitre 2

Les bases du langage

Sommaire2.1 Variables et types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2.1.1 Types de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132.1.2 Transtypage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142.1.3 Variables et affectations . . . . . . . . . . . . . . . . . . . . . . . . 14

2.2 Opérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.2.1 Opérations sur les nombres . . . . . . . . . . . . . . . . . . . . . . . 152.2.2 Opérations logiques . . . . . . . . . . . . . . . . . . . . . . . . . . 162.2.3 Opérations sur les chaînes . . . . . . . . . . . . . . . . . . . . . . . 162.2.4 Formes condensées . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2.3 Branchements conditionnels . . . . . . . . . . . . . . . . . . . . . . . . . 172.3.1 Version basique du if . . . . . . . . . . . . . . . . . . . . . . . . . 172.3.2 Alternative au if: le else . . . . . . . . . . . . . . . . . . . . . . 172.3.3 Autres options: le mot clé elif . . . . . . . . . . . . . . . . . . . . . 18

2.1 Variables et types

2.1.1 Types de base

Les valeurs et les variables qu’on manipule en Python possèdent un type, qui détermine lesopérations autorisées ainsi que leur comportement. Parmi les types les plus fréquents, on retrouveles suivants:

Type En Python Exemplesentier int 12, -4, 123545, . . .réel float 3.14159, -1.5, 12., 4.56e12, . . .booléen bool True (vrai) ou False (faux)indéfini, rien None Nonechaîne de caractères str 'bonjour', 'SHNU', . . .



Le type None est particulier (il correspond au null du C/C++) et permet de représenter desvariables n’ayant aucun type. On verra plus loin des situations dans lesquelles son utilisation estessentielle.

2.1.2 Transtypage

La fonction type()permet de connaître le type de son paramètre:

1 >>> type(3.14)2 <class 'float'>3 >>> type(True)4 <class 'bool'>5 >>> type("bonjour")6 <class 'str'>

Il arrive souvent qu’on ait une variable qui ne soit pas du “bon” type. Le transtypage consiste àconvertir une variable d’un type vers un autre. Par exemple, la fonction input()nous permetde récupérer des données entrées par l’utilisateur sous la forme d’une chaîne de caractères. Sil’on veut obtenir un nombre, on doit transtyper cette entrée:

1 >>> n = input("Entrez un nombre: ")2 353 >>> print("Voici ce nombre multiplie par 2:", int(n) * 2)4 70

Toutes les conversions ne sont pas permises, mais elles sont accessibles grâce à des fonctions deconversions portant le nom du type cible. En pratique, on utilise surtout:

— str qui fonctionne tout le temps;— int et float appliqués à une chaîne de caractères qui correspond à un nombre;

— Attention: int('3') fonctionne, mais pas int('3.5')!— int appliqué à un float pour tronquer les décimales;— bool qui donne False si son paramètre équivaut à 0, True sinon.

Voici quelques exemples d’utilisation du transtypage avec les résultats correspondants:

int(4.5)→ 4 int(-4.5)→ -4 int('0345')→ 345int('SHNU')→ erreur float(4)→ 4. float('4.5')→ 4.5str(4)→ '4' str(True)→ 'True' str(-4.5)→ '-4.5'bool(4)→ True bool(0)→ False bool('SHNU')→ True

2.1.3 Variables et affectations

Une variable est un nom qui référence une valeur en mémoire. Elle a le même type que la valeurqu’elle référence. L’affectation d’une variable consiste à lier un nom à une valeur:

1 x = 32 y = 'SHNU'



3 z = x + 2

On peut affecter à nouveau une même variable, et on perd alors le lien avec l’ancienne valeur.

Il y a certaines règles de nommage à respecter pour les variables:

— le caractère ‘underscore” _ est considéré comme une lettre;— on n’utilise jamais d’accent, de cédille, . . . ou d’espace;— les noms commencent par une lettre majuscule ou minuscule, puis sont composés de

lettres et de nombres:

— les mots réservés de Python (voir suite) ainsi que les noms de fonctions prédéfinies sontinterdits.

Les mots suivants sont réservés pour le langage, et on ne peut donc pas les utiliser pour nom-mer nos variables: False, None , True, and, as, assert, break, class, continue,def, del, elif, else, except, finally, for, from, global, if, import, in, is,lambda, nonlocal, not, or, pass, raise, return, try, while, with, yield. Plu-tôt que de retenir cette liste par cœur, soyez attentifs à ce qu’affiche votre éditeur: si le nom devariable que vous êtes en train d’écrire est en gras ou en couleur, c’est qu’il s’agit d’un motréservé.

2.2 Opérations

2.2.1 Opérations sur les nombres

Toutes les opérations usuelles que vous connaissez déjà sur les nombres sont disponibles. Letype du résultat dépendra des types d’entrée: comme le montre le tableau ci-dessous, sauf dansle cas d’une addition, c’est le type le plus général qui l’emporte.

+, −, ∗, ∗∗ int float

int int floatfloat float float

L’opération ** correspond à la puissance: x ** y calcule xy. La division (/) donne toujoursun float; si l’on veut tronquer la partie décimale pour obtenir un entier, on peut transtyperavec int ou plus simplement utiliser // qui nous donne le quotient de la division entière.

1 >>> 3 / 22 1.53 >>> 3 // 24 1

Le reste de la division entière est x % y, qui se dit “x modulo y”. Les opérations suivent lesrègles de priorités usuelles, et on peut utiliser des parenthèses, comme dans (4 + 2)* 1.5.



2.2.2 Opérations logiques

Les opérations logiques portent sur les valeurs booléennes et sont disponibles via les mots-cléssuivants:

— and: le ET logique, x and y vaut True seulement quand x et y valent True,— or: le OU logique, x or y vaut False seulement quand x et y valent False,— not: la négation logique, not True donne False et not False donne True.

Voici pour rappel les tables de vérité correspondantes:

p q p and q p or q not p

False False False False TrueFalse True False True TrueTrue False False True FalseTrue True True True False

On sera souvent confronté aux opérations sur les booléens, car les comparaisons produisent desbooléens comme résultats; étant données deux variables x et y, on peut demander:

— si leurs valeurs sont égales: x == y;— si leurs valeurs sont différentes: x != y;— quelle valeur est la plus grande, avec les opérateurs <, <=, >, >=.

2.2.3 Opérations sur les chaînes

Certains des opérateurs précédents marchent également sur les chaînes de caractères: + conca-tène deux chaînes, et une chaîne multipliée par un entier n concatène cette chaîne avec elle-mêmen− 1 fois. Les opérateurs de comparaison utilise l’ordre lexicographique, autrement dit celuidu dictionnaire.

1 >>> "bon" + "jour"2 "bonjour"3 >>> "shnu" * 34 "shnushnushnu"5 >>> "bonjour" <= "au revoir"6 False7 >>> "chaine" != "CHAINE"8 True

2.2.4 Formes condensées

Python permet également d’utiliser des expressions condensées pour les affectations. On peutainsi écrire:

— x += y au lieu de x = x + y;— x *= y au lieu de x = x * y;



— x /= y au lieu de x = x / y;— . . .

2.3 Branchements conditionnels

2.3.1 Version basique du if

Comme dans bien d’autres langages, le mot-clé if permet de n’exécuter du code que souscertaines conditions. Dans sa forme la plus simple, on déclare un bloc if comme suit:

1 # debut2 if expression:3 # instruction 1 du if4 # instruction 2 du if5 # ...6 # suite

début expression vraie?

bloc if

suitenon

oui

Dans ce qui précède, expression est une expression qui renvoie un booléen, et qui est doncévaluée à True ou False. Les instructions du bloc du if sont effectuées uniquement sil’expression est évaluée à True; dans tous les cas, le programme reprend à l’instruction aprèsif.

1 >>> if 1 < 2 and 5 / 2 == 2.5:2 ... print("Python sait compter et calculer")3 ...4 Python sait compter et calculer

Les conditions sont évaluées de gauche à droite, et Python n’évalue que celles qui sont néces-saires. Par exemple:

— dans le test if 2 < 1 and ..., ce qui suit le and n’est jamais évalué car 2 < 1est False et le résultat du and ne pourra donc jamais valoir True;

— dans le test if 2 > 1 or ..., ce qui suit le and n’est jamais évalué car 2 > 1 estTrue et le résultat du or vaudra donc True, peu importe ce qui suit le or.

Il est également possible de spécifier ce qu’il faut faire quand la condition n’est pas satisfaite,avec else, ou quand des conditions alternatives peuvent être satisfaites, avec elif.

2.3.2 Alternative au if: le else

La première variation avec un else se déclare comme suit:



1 # debut2 if expression:3 # instruction 1 du if4 # ...5 else:6 # instruction 1 du

else7 # ...8 # suite

début

expression vraie?

bloc if

suite

bloc else

nonoui

Les instructions du bloc du if sont effectuées uniquement si l’expression est évaluée à True.Les instructions du bloc du else sont effectuées uniquement si l’expression est évaluée àFalse. Dans tous les cas, le programme continue à l’instruction après if/ else.

2.3.3 Autres options: le mot clé elif

La seconde variation avec un ou plusieurs elif se déclare comme suit:

1 # debut2 if expression1:3 # bloc du if4 elif expression2:5 # bloc du elif6 else:7 # bloc du else8 # suite

début

expression1 vraie? expression2 vraie?

bloc if bloc elif

suite

bloc else

non

oui oui non

Le fonctionnement est le suivant:

— les instructions du bloc du if sont effectuées uniquement si expression1 vautTrue;

— les instructions du bloc du elif sont effectuées uniquement si expression1 vautFalse et expression2 vaut True;

— les instructions du bloc du else sont effectuées uniquement si expression1 vautFalse et expression2 vaut False.

On peut utiliser plusieurs elif; les conditions sont évaluées dans l’ordre où elles apparaissent,et seules les instructions du premier bloc dont la condition vaut True seront exécutées.

On n’est jamais obligé d’utiliser elif et else, mais si on décide de les utiliser:

— on doit suivre l’ordre if . . . elif . . . else (toujours en dernier);— on ne peut pas utiliser elif ni else sans les associer à un if précédent.


Chapitre 3. Structures itérables et boucles for

Chapitre 3

Structures itérables et boucles for

Sommaire3.1 Boucles for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203.2 Un itérable particulier: range . . . . . . . . . . . . . . . . . . . . . . . . 213.3 Chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

3.3.1 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

3.3.2 Manipulation de chaînes . . . . . . . . . . . . . . . . . . . . . . . . 22

3.3.3 Itérer sur des chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3.4 Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243.5 Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

3.5.1 Modification de listes . . . . . . . . . . . . . . . . . . . . . . . . . . 25

3.5.2 Copie de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

3.5.3 Méthodes des listes . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3.6 Ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273.7 Dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

3.7.1 Déclaration et manipulation . . . . . . . . . . . . . . . . . . . . . . 29

3.7.2 Itérer sur des dictionnaires . . . . . . . . . . . . . . . . . . . . . . . 29

3.8 La boucle while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

Une structure itérable est une structure qui contient plusieurs valeurs avec:

— une valeur initiale;— une notion de valeur suivante.

Cela ne veut pas nécessairement dire que la structure est ordonnée (cf. plus tard), mais simple-ment que Python sait comment parcourir exactement une fois tous les éléments de la structuredonnée dans un certain ordre.

Les chaînes de caractères sont un exemple simple de structure itérable qu’on a déjà rencontré.En effet:

— le premier élément de la structure est le premier caractère du texte (le plus à gauche);— la valeur suivante (si elle existe) est le caractère à droite du caractère qu’on vient de lire.



3.1 Boucles for

Python propose deux mécanismes de boucles: les boucles for et les boucles while, qui nouspermettent toutes deux de répéter des instructions un certain nombre de fois. On commencerapar couvrir les boucles for, car elles s’utilisent exclusivement avec des itérables et sont plusintuitives: elles ressemblent en effet au ∀ des mathématiques.

La syntaxe du for est la suivante:

1 for element in iterable:2 # instruction 1 du for3 # instruction 2 du for4 # ...5 # suite du programme

Schématiquement, l’action du for peut se représenter comme suit:

iterable vide? element← 1er element de iterable instructions du for

∃? élément suivant

suite

element← élément suivant

non

oui

non

oui

Les boucles for n’ont d’intérêt que si on dispose d’itérables à parcourir. Jusqu’à présent, onn’a rencontré que les chaînes de caractères comme structure itérable, qui nous permettent déjàde montrer comment marchent les boucles for sur du texte:

1 >>> for lettre in "bonjour":2 ... print(lettre)3 ...4 b5 o6 n7 j8 o9 u

10 r

Remarquons que l’on n’a pas expliqué à Python par quelle valeur il fallait commencer oucomment passer à la valeur suivante: c’est le type de l’itérable manipulé qui détermine automati-quement ces informations.

La variable utilisée dans la boucle for est une copie de la valeur manipulée. Ainsi, une boucleau format for element in iterable ne modifiera pas ce qui se trouve dans l’itérable,



puisqu’on manipule des copies de ses éléments. On verra plus tard comment modifier lesitérables modifiables manipulés.

3.2 Un itérable particulier: range

Les intervalles constituent un autre type de structure itérable intéressante que l’on rencontre trèssouvent quand on utilise des for.

Les intervalles s’obtiennent à l’aide d’un appel à la fonction range(). Il existe trois manièresde l’utiliser:

1. range(n), avec n ∈ N, renvoie l’intervalle des entiers de 0 à n− 1;

2. range(a, b), avec a, b ∈ N, renvoie l’intervalle des entiers de a à b− 1;

3. range(a, b, c), avec avec a, b, c ∈ N, renvoie l’intervalle des entiers a, a + c,a+2c, . . ., jusque b− 1 ou jusqu’au dernier nombre de la forme a+ kc inférieur ou égalà b− 1.

Quelques exemples d’utilisation des boucles for avec des range:

1 >>> for i in range(5):2 ... print(i)3 ...4 05 16 27 38 49 >>> for i in range(1, 10, 3):

10 ... print(i)11 ...12 113 414 7

La dernière forme est particulièrement utile quand on veut parcourir des nombres de manièredécroissante. En effet, range(a, b) donne un intervalle vide si a > b, puisqu’on ne peut pasatteindre b en augmentant a de 1. Il faut donc expliquer à Python que l’on veut atteindre b enajoutant −1 aux éléments successivement obtenus.

1 >>> for i in range(5, 0, -1):2 ... print(i)3 ...4 55 46 37 28 1



3.3 Chaînes

3.3.1 Déclaration

Les chaînes de caractères se déclarent soit à l’aide d’apostrophes, soit à l’aide de guillemets.

1 >>> x = 'cette declaration marche'2 >>> y = "et celle-ci aussi"

Si on déclare une chaîne qui contient des guillemets et des apostrophes, on doit utiliser lescaractères spéciaux '\'' et '\"':

1 >>> s = 'il a dit : "a l\'abordage !"'

On peut également déclarer des chaînes sur plusieurs lignes en utilisant des triples apostrophesou des triples guillemets:

1 s = '''Ceci est une2 chaine sur3 plusieurs lignes.'''

Les sauts de lignes seront encodés par le caractère \n. D’autres caractères spéciaux utiles sontprésentés ci-dessous:

— '\'': apostrophe— '\"': guillemet— '\n': saut de ligne— '\t': tabulation— '\\': backslash— '\b': efface le caractère précédent

3.3.2 Manipulation de chaînes

Pour connaître la taille d’une chaîne, on utilise la fonction len(chaine), qui nous renvoie lenombre de caractères qu’elle contient. Si l’on veut accéder aux éléments d’une chaîne, qui sontdes lettres, on peut le faire à l’aide de l’opérateur []. Attention, les indices d’une chaîne delongueur n commencent à 0 (et non à 1) et se terminent en n− 1 (et non en n)! De plus, seulsdes indices entiers sont autorisés.

1 >>> texte = 'ma chaine'2 >>> len(texte)3 94 >>> texte[6]5 'i'6 >>> texte[9]7 Traceback (most recent call last):8 File "<stdin>", line 1, in <module>9 IndexError: string index out of range

10 >>> texte[8.5]



11 Traceback (most recent call last):12 File "<stdin>", line 1, in <module>13 TypeError: string indices must be integers

Les chaînes ne sont pas modifiables. Si x contient une valeur de type str et que vous voulez lachanger, il faut faire une nouvelle affectation de x:

1 >>> x = 'toto'2 >>> x[0] = 'p'3 Traceback (most recent call last):4 File "<stdin>", line 1, in <module>5 TypeError: 'str' object does not support item assignment6 >>> x = 'poto'

Une manière de contourner ce problème est d’utiliser une liste de caractères plutôt qu’une chaîne(voir plus loin).

L’opérateur + permet de concaténer (ou de “coller”) deux chaînes. De même, multiplier unechaîne par un entier n concatène cette chaîne avec elle-même n− 1 fois:

1 >>> 'bon' + 'jour'2 'bonjour'3 >>> 'shnu' * 34 'shnushnushnu'

Bien d’autres opérations sur les chaînes sont disponibles sous la forme de méthodes, avec lanotation s.methode(). Un appel à dir(str) dans l’interpréteur Python en donne la liste;on verra les plus utiles d’entre elles dans les exercices.

3.3.3 Itérer sur des chaînes

Comme on connaît la longueur d’une chaîne s grâce à len(s), on peut en déduire les positionsvalides à l’aide de range(len(s)) et donc itérer sur les positions de la chaîne comme suit:

1 >>> texte = "mon texte"2 >>> for i in range(len(texte)):3 ... print(texte[i])4 ...5 m6 o7 n8 t9 e

10 x11 t12 e



Dans cet exemple, on se rend compte qu’il n’est jamais nécessaire de connaître la position deséléments qu’on affiche. On pourrait donc réécrire cette boucle de manière plus simple en itérantdirectement sur les éléments plutôt que sur les positions:

1 >>> texte = "mon texte"2 >>> for lettre in texte:3 ... print(texte)4 ...5 m6 o7 n8 t9 e

10 x11 t12 e

3.4 Tuples

Les tuples sont des itérables non-modifiables donnant plus de liberté que les chaînes. En effet, leschaînes de caractères ne peuvent contenir que du texte: les tuples nous permettent de mélangerdifférents types. On les déclare à l’aide de parenthèses:

1 >>> x = (4, 3, 1) # cree un tuple avec 3 entiers2 >>> x = 4, 3, 1 # meme resultat3 >>> y = (4,) # tuple avec un seul element4 >>> z = ('trois', -5, True)

Pour créer un tuple avec un seul élément, il faut utiliser une virgule, sinon on obtient un entier.Ce qu’on a vu pour les chaînes reste valable pour les tuples: les opérateurs [], in et + ainsique la fonction len() s’utilisent exactement de la même manière. Tout comme les chaînes, lestuples ne sont pas modifiables, et toute tentative d’affectation provoquera donc une erreur.

1 >>> mon_tuple = (4, 3, 1) # cree un tuple avec 3 entiers2 >>> mon_tuple[0] = 43 Traceback (most recent call last):4 File "<stdin>", line 1, in <module>5 TypeError: 'tuple' object does not support item assignment

3.5 Listes

Les listes sont des tuples modifiables. On les initialise à l’aide de crochets plutôt que deparenthèses:

1 >>> liste_1 = list() # liste vide2 >>> liste_2 = [] # autre liste vide



3 >>> liste_3 = [1, 2.0, '3']4 >>> liste_4 = list(range(1, 11)) # les entiers de 1 a 10

Ce qu’on a vu pour les chaînes et les tuples reste valable pour les listes: les opérateurs [], in et+ ainsi que la fonction len() s’utilisent exactement de la même manière.

3.5.1 Modification de listes

On peut à présent utiliser les crochets pour modifier les listes:

1 >>> liste_3 = [1, 2.0, '3']2 >>> for i in range(len(liste_3)):3 ... print("position", i, ": element =", liste_3[i])4 ...5 position 0 : element = 16 position 1 : element = 2.07 position 2 : element = 38 >>> liste_3[0] = -59 >>> liste_3

10 [-5, 2.0, '3']

On a déjà vu comment utiliser les boucles for pour parcourir des itérables, en utilisant soit lespositions, soit les éléments. Malheureusement, il n’est pas possible de modifier directement leséléments d’une liste:

1 >>> liste = [1, 2, 3]2 >>> for element in liste:3 ... element = 14 ...5 >>> liste6 [1, 2, 3] # aucun changement

On est obligé de recourir aux positions de la liste pour modifier ses éléments:

1 >>> liste = [1, 2, 3]2 >>> for i in range(len(liste)):3 ... liste[i] = 14 ...5 >>> liste6 [1, 1, 1]

3.5.2 Copie de listes

Attention, le fait que les listes sont modifiables a un impact important sur leur manipulation. Eneffet, les objets non-modifiables pouvaient être copiés et manipulés séparément sans impactsmutuels:



1 >>> x = 42 >>> y = x # copie la valeur de x dans y3 >>> x = 2 # ne modifie pas y4 >>> x, y5 (2, 4)

Ceci n’est plus vrai pour les listes:

1 >>> lst1 = [1, 2]2 >>> lst2 = lst1 # associe les deux noms au meme objet!3 >>> lst2[0] = 4 # modifie lst2[0] ET lst1[0]4 >>> lst1, lst25 ([4, 2], [4, 2])

Si l’on veut éviter ce comportement, on appellera la fonction list() pour réaliser la copie:

1 >>> lst1 = [1, 2]2 >>> lst2 = list(lst1) # copie le contenu de lst1 dans lst23 >>> lst2[0] = 4 # modifie seulement lst2[0]4 >>> lst1, lst25 ([4, 2], [4, 2])

On verra que ce “piège” existe pour tous les objets modifiables.

3.5.3 Méthodes des listes

La plupart des manipulations intéressantes sur les listes sont disponibles sous la forme deméthodes. Les méthodes des listes qui vous serviront le plus sont:

1. les ajouts:— lst.append(x): ajoute la valeur de x à la fin de lst;— lst.extend(lst2): ajoute tous les éléments de lst2 à la fin de lst;— lst.insert(i, elem): ajoute elem juste avant la position i;

1 >>> liste = list(range(3)) # liste == [0, 1, 2]2 >>> liste.extend([3, 4]) # liste == [0, 1, 2, 3,

4]3 >>> liste.append(5) # liste == [0, 1, 2, 3,

4, 5]4 >>> liste.insert(0, 2) # liste == [2, 0, 1, 2,

3, 4, 5]

2. les suppressions:— lst.pop(): supprime le dernier élément de lst et renvoie sa valeur;— lst.pop(i): supprime le i-ème élément de lst et renvoie sa valeur;— lst.remove(x): supprime la première occurrence de x dans la liste si elle le

contient (sinon, provoque une erreur);



1 >>> # suite de l'exemple precedent2 >>> liste.pop()3 54 >>> liste.pop(0)5 26 >>> liste.remove(3) # liste == [0, 1, 2, 4]

3. diverses autres méthodes:— lst.count(x): donne le nombre d’occurrences de x dans la liste;— lst.index(x): donne la position de la première occurrence de x dans la liste si

elle contient cet élément (sinon, provoque une erreur);— lst.sort(): trie la liste de manière croissante si tous ses éléments sont compa-

rables (sinon, provoque une erreur).

Les listes donnent l’impression qu’on peut oublier les chaînes et les tuples, car elles présententle double avantage d’être modifiables et de pouvoir mélanger les types. Cependant, on verrabientôt des situations dans lesquelles on ne peut pas utiliser les listes.

3.6 Ensembles

La structure set (‘ensemble” en anglais) permet de gérer efficacement un ensemble de données.Comme pour les listes et les tuples, on peut y mélanger les types. Par contre, comme on manipuledes ensembles:

1. chaque élément ne peut y être qu’une seule fois;

2. il n’y a pas d’ordre.

Le mécanisme utilisé pour que cette structure soit efficace impose aux éléments d’un set d’êtrenon modifiables. Mais les set eux-mêmes sont modifiables tout comme les listes.

Les set se déclarent comme les listes, mais avec des accolades:

1 >>> S = {3, 1, 4, 6, 2}

Ou à l’aide de la fonction set(iterable), aussi utile pour le transtypage:

1 >>> S = set([3, 1, 4, 6, 2])2 >>> ensemble_vide = set() # ou {}

Les manipulations ensemblistes habituelles en mathématique sur deux ensembles sont dispo-nibles via les opérations suivantes:

Opération Opérateur Méthode 1 Méthode 2

s ∪ t s | t s.union(t) s.update(t)s ∩ t s & t s.intersection(t) s.intersection_update(t)s \ t s - t s.difference(t) s.difference_update(t)s∆t s ^ t s.symmetric_difference(t) s.symmetric_difference_update(t)



Les méthodes de la colonne “Méthode 1” ainsi que les opérateurs présentés ne modifient pasles ensembles manipulés. Si l’on veut les modifier, on utilisera les méthodes de la colonne“Méthode 2” (par exemple: s.update(t)donne le même résultat que s = s.union(t)).

Ces méthodes ne marchent que si l’on manipule deux ensembles. Si l’on veut manipuler unensemble set un seul élément x:

— s.add(x) ajoute x à s;— s.remove(x) retire x de s si s le contient — sinon, elle provoque une erreur;— s.discard(x) retire x de s sans erreur si s ne le contient pas.— enfin, s.pop() (sans paramètre) retire et renvoie un élément aléatoire de s s’il n’est

pas vide — sinon, elle provoque une erreur.

Les opérations in et len() fonctionnent encore sur les ensembles; par contre, l’opérateur + nemarche plus, ni l’opérateur [] puisque l’absence d’ordre implique l’absence de positions.

Enfin, les comparaisons ensemblistes sont disponibles via les opérateurs suivants:

Opération Opérateur

s = t s == ts 6= t s != ts ⊂ t s < ts ⊆ t s <= t

Il existe également une structure permettant de représenter des ensembles non-modifiables: ils’agit de frozenset, qui est surtout utile quand on veut représenter des collections d’en-sembles. En effet, ceci échoue car les ensembles sont modifiables:

1 # sous-ensembles de {1, 2, 3} de taille 22 >>> S = set([set([1, 2]), set([1, 3]), set([2, 3])])

On doit donc écrire:

1 # sous-ensembles de {1, 2, 3} de taille 22 >>> S = set([frozenset([1, 2]), frozenset([1, 3]),3 frozenset([2, 3])])

Les commentaires faits sur l’affectation des listes s’appliquent également aux ensembles, puis-qu’il s’agit d’objets modifiables: il faut donc être prudent lors des affectations.

3.7 Dictionnaires

Les dictionnaires permettent d’associer une valeur à une clé. On peut les voir d’une cer-taine manière comme des listes dont les indices peuvent être des entiers ou n’importe quoid’autre, pourvu qu’il s’agisse d’un type non-modifiable. Les valeurs, par contre, peuvent êtremodifiables.



3.7.1 Déclaration et manipulation

On peut déclarer les dictionnaires comme suit:

1 >>> mon_dico = dict() # dictionnaire vide2 >>> notes_etudiants = {"Jean": 15, "Marie": 16}

On peut modifier les valeurs des clés existantes, et rajouter une association entre une nouvelleclé et une nouvelle valeur simplement en les affectant comme si la clé existait déjà:

1 >>> notes_etudiants["Jean"] = 0 # Jean a triche2 >>> notes_etudiants["Pierre"] = 14 # on vient de corriger

une autre copie3 >>> notes_etudiants["Marc"] += 1 # echoue: Marc n'existe

pas dans le carnet4 Traceback (most recent call last):5 File "<stdin>", line 1, in <module>6 KeyError: 'Marc'

Les clés, les valeurs et les associations sont disponibles à l’aide des trois méthodes suivantes:

1 >>> notes_etudiants.keys() # ou print(notes_etudiants)2 dict_keys(['Jean', 'Pierre', 'Marie'])3 >>> notes_etudiants.values()4 dict_values([0, 14, 16])5 >>> notes_etudiants.items()6 dict_items([('Jean', 0), ('Pierre', 14), ('Marie', 16)])

Les itérables renvoyés sont d’un type un peu particulier; si l’on veut les convertir vers des typesconnus, on peut toujours recourir au transtypage.

Les seuls opérateurs qui fonctionnent sur les dictionnaires sont ==, != et in. Attention, x indictionnaire vérifie si x appartient aux clés! Si l’on veut savoir si x appartient aux valeursdu dictionnaire, on utilisera la forme x in dictionnaire.values().

Python 3 nous autorise à créer des dictionnaires vides avec {}. Cette notation est déconseilléecar elle est source de confusion: en effet, 1 est un ensemble contenant 1, tandis que {} n’estpas un ensemble vide mais un dictionnaire vide. C’est pourquoi le test ensemble == {} nemarchera pas pour vérifier si un ensemble donné est vide.

Les commentaires faits sur l’affectation des listes s’appliquent également aux dictionnaires et auxensembles, puisqu’il s’agit d’objets modifiables: il faut donc être prudent lors des affectations.

3.7.2 Itérer sur des dictionnaires

On peut itérer sur des dictionnaires de plusieurs manières:

1 >>> for nom in notes_etudiants.keys():2 ... print(nom)3 ...



4 Jean5 Pierre6 Marie7 >>> for nom in notes_etudiants.keys():8 ... print(nom, ":", notes_etudiants[nom])9 ...

10 Jean : 011 Pierre : 1412 Marie : 1613 >>> # la meme chose en plus lisible:14 >>> for nom, note in notes_etudiants.items():15 ... print(nom, ":", note)16 ...17 Jean : 018 Pierre : 1419 Marie : 16

3.8 La boucle while

Il y a des situations où l’on a besoin d’une boucle, mais où:

— on ne dispose pas d’itérable à parcourir,— ou on ne sait pas combien d’itérations on veut effectuer,— ou encore, l’arrêt de la boucle dépend d’une condition plus complexe que ce qu’on a vu

avec les for.

Dans toutes ces situations, on utilisera une boucle while. La structure de cette boucle seprésente comme suit:

1 while condition:2 # instruction 13 # instruction 24 # ...5 # suite

condition vraie?

instructions

suitenon

oui

Le for s’arrête à la fin de l’itérable; dans le cas des boucles while, c’est à vous de vousassurer que la boucle se termine! Si jamais vous exécutez à partir du terminal un programme quine se termine pas, vous pouvez l’arrêter en appuyant sur Ctrl+C dans le terminal.


Chapitre 4. Les fonctions

Chapitre 4

Les fonctions

Sommaire4.1 Fonctions sans paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . 314.2 Fonction avec paramètre(s) . . . . . . . . . . . . . . . . . . . . . . . . . . 324.3 Renvoi de valeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324.4 Portée des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334.5 Compléments sur les fonctions . . . . . . . . . . . . . . . . . . . . . . . . 34

Une fonction est un bloc d’instructions réutilisable. Leur usage est essentiel en programmation,car notre but est d’avoir un programme clair, concis et lisible, ce qui nous permet de le mainteniret de le modifier beaucoup plus facilement, et de réutiliser certaines de ses parties dans d’autresprogrammes.

4.1 Fonctions sans paramètres

La syntaxe pour définir une fonction est la suivante:

1 def nom_fonction():2 # instruction 1 de la fonction3 # instruction 2 de la fonction4 # ...5 # instruction n de la fonction

Lors de la définition d’une fonction, le code n’est pas exécuté; il ne sera exécuté que lorsde l’appel de cette fonction, ce qu’on peut faire à tout moment dans le programme avec lacommande nom_fonction(). Le code suivant définit une fonction et illustre ce qui se passequand on l’appelle:

1 def appel():2 print('-' * 5, 'appel', '-' * 5)3

4

5 if __name__ == "__main__":6 print('bonjour')



7 appel()8 n = int(input('nombre = '))9 for i in range(n):

10 appel()

Chaque fois qu’on utilise l’instruction appel(), le programme interrompt le flot normald’instructions pour aller effectuer les instructions d’appel(). Une fois les instructions de lafonction appel() effectuées, le programme reprend là où il en était.

4.2 Fonction avec paramètre(s)

On a parfois envie que le comportement de la fonction change selon les appels. Pour cela, onpeut préciser à Python qu’elle doit posséder un ou plusieurs : il s’agit de noms de variablesauxquelles on devra affecter des valeurs lors de l’appel de la fonction.

1 def affiche(message):2 print('*' * (len(message) + 4))3 print('* ' + message + ' *')4 print('*' * (len(message) + 4))5

6

7 if __name__ == "__main__":8 affiche('bonjour')9 texte = input("Entrez un message:")

10 affiche(texte)

Ces paramètres sont nommés entre parenthèses dans la définition de la fonction. Lorsquel’on appelle la fonction, il faut passer les paramètres (le bon nombre et dans l’ordre!) entreparenthèses.

4.3 Renvoi de valeurs

On appelle souvent une fonction en vue de réaliser des calculs et d’obtenir un résultat. Ce résultatdoit être communiqué d’une manière ou d’une autre au code appelant la fonction: soit par unemodification des paramètres, soit par un de valeurs.

Ce renvoi de valeur s’implémente à l’aide de l’instruction . Elle interrompt l’exécution de lafonction, et renvoie la valeur spécifiée en paramètre.

1 def calcul(a, b, c):2 return a + b ** 2 + c ** 33 print(bonjour) # ne sera jamais execute!

Dans le code qui précède, l’affichage ne sera jamais exécuté car le nous fait sortir de la fonctionavant qu’on ne puisse l’atteindre. Ici, la valeur renvoyée est un nombre, mais l’on peut renvoyer



un résultat de n’importe quel type, que l’on peut ensuite récupérer dans une variable ou utiliserdirectement dans des calculs:

1 >>> y = calcul(1, 3.14, -5)2 >>> print(y - 5)3 -119.14044 >>> z = calcul(1, 2, 3) + calcul(4, 5, 6)

Qu’on le veuille ou non, en Python, toutes les fonctions renvoient une valeur; si l’on ne met pasde return dans une fonction, Python insère un return None à notre place.

4.4 Portée des variables

Comme dans bien d’autres langages, les variables en Python n’existent pas toujours dans tout leprogramme. La règle est la suivante:

1. une variable déclarée dans une fonction n’existe que dans cette fonction;

2. une variable déclarée dans un module n’existe que dans ce module.

Le schéma suivant permet d’y voir plus clair:

1 # des variables ici2

3 def fonction_1(parametres_1):4 # variables de la fonction 15

6

7 def fonction_2(parametres_2):8 # variables de la fonction 29

10

11 if __name__ = '__main__':12 # et des variables la

portée du programme

portée de la fonction 1

portée de la fonction 2



Le programme et ses fonctions définissent chacun des portées; une variable définie dans uneportée n’est accessible que dans celles que cette portée contient; ici:

1. les fonctions connaissent les variables du programme;

2. le programme n’a pas accès aux variables des fonctions;

3. fonction_1 ignore les variables de fonction_2 et vice versa.

Plus généralement, on fait une distinction entre les variables globales, qui existent dans toutle programme manipulé et sont accessibles au moins en lecture, et les variables locales, quin’existent que dans la définition d’une fonction (ou d’une classe, ou d’une méthode) et ne sontdonc pas accessibles en dehors. Les paramètres de la définition d’une fonction, ainsi que lesvariables déclarées dans sa définition, sont des variables locales propres à la fonction; ellesn’existeront donc que pendant l’exécution de la fonction, ne seront pas accessibles ailleurs, etn’existent plus après cet appel.

4.5 Compléments sur les fonctions

Les paramètres modifiables et non-modifiables portent bien leurs noms: dans l’exemple ci-dessous, l’appel à la fonction ne modifie pas son paramètre puisqu’il est non-modifiable:

1 def f(x):2 x = x + 13

4

5 if __name__ == "__main__":6 n = 37 f(n)8 print(n)

Par contre, la fonction dans l’appel ci-dessous modifie la liste passée en paramètre, puisque leslistes sont modifiables:

1 def ajoute(L, x):2 L.append(x) # on modifie L en ajoutant x3

4

5 if __name__ == "__main__":6 lst = [4, 5]7 ajoute(lst, 7) # L prend la valeur lst8 print(lst) # affiche [4,5,7]

Cela ne vaut que pour les paramètres modifiables; les variables affectées dans la fonction restentlocales. Ainsi, dans le code suivant, la liste est modifiée par le premier ; mais après l’affectationde la ligne 3, on manipule un objet qui n’a plus de rapport avec le paramètre passé à la fonction:

1 def f(L, x):2 L.append(x)3 L = list(range(3))



4 L.append(x)5

6

7 if __name__ == "__main__":8 lst = [4, 5]9 f(lst, 7)

10 print(lst)

Il est utile dans ce cas de se référer à une visualisation sur PythonTutor pour mieux comprendrece qui se passe.


http://www.pythontutor.com/visualize.html#code=def%20f%28L,%20x%29%3A%0A%20%20%20%20L.append%28x%29%20%0A%20%20%20%20L%20%3D%20list%28range%283%29%29%0A%20%20%20%20L.append%28x%29%0A%0A%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20lst%20%3D%20%5B4,%205%5D%0A%20%20%20%20f%28lst,%207%29%20%0A%20%20%20%20print%28lst%29%0A&cumulative=false&curInstr=0&heapPrimitives=false&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false

programmation en python - igmigm.univ-mlv.fr/~alabarre/teaching/shnu/poly-shnu.pdfpython accorde une...

Documents