Tutoriel avec exemple sur la programmation avec python

(1)

Programmation en Python

Anthony Labarre

(2)

(3)

Table des matières

1 Introduction à Python 5

1.1 Particularités de Python . . . 5

1.1.1 Indentation . . . 5

1.1.2 Types . . . 7

1.1.3 Objets (non) modifiables . . . 7

1.1.4 Garbage collector . . . 7

1.1.5 Messages d’erreurs . . . 7

1.2 Installation de Python . . . 8

1.3 Utilisation de Python . . . 9

1.4 Environnements de développement recommandés . . . 9

1.5 Conventions de style . . . 10

1.6 Configuration des éditeurs . . . 10

1.6.1 Geany. . . 10

1.6.2 PyCharm. . . 11

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

2.1.1 Types de base . . . 13

2.1.2 Transtypage . . . 14

2.1.3 Variables et affectations . . . 14

2.2 Opérations . . . 15

2.2.1 Opérations sur les nombres . . . 15

2.2.2 Opérations logiques . . . 16

2.2.3 Opérations sur les chaînes . . . 16

2.2.4 Formes condensées . . . 16

2.3 Branchements conditionnels . . . 17

2.3.1 Version basique du if . . . 17

2.3.2 Alternative au if: le else . . . 17

2.3.3 Autres options: le mot clé elif . . . 18

3 Structures itérables et boucles for 19 3.1 Boucles for . . . 20

3.2 Un itérable particulier: range . . . 21

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

(4)

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

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

4 Les fonctions 31 4.1 Fonctions sans paramètres . . . 31

4.2 Fonction avec paramètre(s) . . . 32

4.3 Renvoi de valeurs . . . 32

4.4 Portée des variables . . . 33

(5)

Chapitre 1. Introduction à Python

Chapitre 1

Introduction à Python

Sommaire

1.1 Particularités de Python. . . 5 1.1.1 Indentation . . . 5 1.1.2 Types . . . 7

1.1.3 Objets (non) modifiables . . . 7

1.1.4 Garbage collector . . . 7

1.1.5 Messages d’erreurs . . . 7

1.2 Installation de Python . . . 8

1.3 Utilisation de Python . . . 9

1.4 Environnements de développement recommandés . . . 9

1.5 Conventions de style . . . 10

1.6 Configuration des éditeurs . . . 10

1.6.1 Geany. . . 10

1.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 langage orienté 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 les programmes que l’on écrit. Voici quelques particularités de ce langage, qui vous permettront de le 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’on rencontre est recommandée pour des raisons de lisibilité; en Python, elle est essentielle car elle délimite les blocs d’instructions et joue le rôle des accolades que l’on rencontre entre autres en C/C++ et Java. Voici par exemple un programme écrit en C affichant les nombres de 1 à 20 en précisant lesquels sont divisibles par 3.

(6)

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à trois exemples 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 bloc 3 instruction 2 du bloc

4 ...

5 instruction hors bloc

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

(7)

1.1.2 Types

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

1 # ceci est un commentaire 2 n = 23 # n est entier 3 x = 3.14 # x est reel

4 s = "bonjour" # s est une chaine de caracteres

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

1 x = 3 + 5 # x est entier 2 x = x / 2 # x devient reel

3 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 objets non modifiables. On verra plus loin que cette distinction a son importance, notamment lors des copies 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 peut aussi 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 / 0

2 Traceback (most recent call last): 3 File "<stdin>", line 1, in <module> 4 ZeroDivisionError: division by zero 5 >>> y = "bonjour" - 5

6 Traceback (most recent call last): 7 File "<stdin>", line 1, in <module>

8 TypeError: unsupported operand type(s) for -: 'str' and 'int

'

(8)

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épendent de votre système d’exploitation (s’il n’est pas repris dans la liste ci-dessous, allez sur http: //www.python.orget 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 surhttp://www.python.orget suivez le programme d’installation mais ajoutez python à la variable PATH!

FIGURE1.1 – Option à activer lors de l’installation de Python sous Windows. Sans cela, vous ne pourrez pas taper python dans le terminal;

(9)

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 programme qu’on a écrit. Dans le mode interpréteur, il nous suffit d’ouvrir un terminal et de taper python3 (ou python selon votre installation1_{) pour qu’un interpréteur s’ouvre comme ci-dessous:}

1 $ python3

2 Python 3.5.3 (default, Jan 19 2017, 14:11:04) 3 [GCC 6.3.0 20170118] on linux

4 Type "help", "copyright", "credits" or "license" for

more information.

5 >>>

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

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 font partie de ce bloc; il ne s’agit pas de quelque chose que vous devez vous-même écrire, et on ne le fera pas hors de l’interpréteur.

L’interpréteur est particulièrement utile quand on veut tester rapidement du code, car il n’est pas nécessaire d’écrire un programme entier puis de le lancer pour obtenir un résultat. Si en revanche, on a écrit un programme nommé monprogramme.py que l’on désire exécuter, il nous 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’une version gratuite. Il est disponible ici:https://www.jetbrains.com/pycharm/

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

(10)

— 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 la coloration syntaxique. En outre, il est essentiel de le configurer, si ce n’est déjà fait, pour qu’il remplace les espaces par des tabulations, sans quoi vous risquez de voir le message suivant quand vous exécutez un programme où vous mélangez les deux:

1 $ python3 test.py

2 File "test.py", line 3 3 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, utilisons celles qui sont officiellement recommandées par PEP8, qu’on se contentera de résumer ici sans les justifier2_:

— l’indentation se fait à l’aide d’espaces, et non de tabulations: chaque niveau d’indentation correspond à 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 recommandations correctement; 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”;

(11)

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

1.6.2 PyCharm.

(12)

(13)

Chapitre 2. Les bases du langage

Chapitre 2

Les bases du langage

Sommaire

2.1 Variables et types . . . 13 2.1.1 Types de base . . . 13 2.1.2 Transtypage . . . 14 2.1.3 Variables et affectations . . . 14 2.2 Opérations . . . 15

2.2.1 Opérations sur les nombres . . . 15

2.2.2 Opérations logiques . . . 16

2.2.3 Opérations sur les chaînes . . . 16

2.2.4 Formes condensées . . . 16

2.3 Branchements conditionnels . . . 17

2.3.1 Version basique du if . . . 17

2.3.2 Alternative au if: le else . . . 17

2.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 les opérations autorisées ainsi que leur comportement. Parmi les types les plus fréquents, on retrouve les suivants:

Type En Python Exemples

entier int 12, -4, 123545, . . .

réel float 3.14159, -1.5, 12., 4.56e12, . . .

booléen bool True(vrai) ouFalse(faux) indéfini, rien None None

(14)

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

2.1.2 Transtypage

La fonctiontype()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 fonctioninput()nous permet de récupérer des données entrées par l’utilisateur sous la forme d’une chaîne de caractères. Si l’on veut obtenir un nombre, on doit transtyper cette entrée:

1 >>> n = input("Entrez un nombre: ") 2 35

3 >>> 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 de conversions portant le nom du type cible. En pratique, on utilise surtout:

— strqui fonctionne tout le temps;

— intetfloatappliqués à une chaîne de caractères qui correspond à un nombre;

— Attention:int('3')fonctionne, mais pasint('3.5')! — intappliqué à unfloatpour tronquer les décimales;

— boolqui donneFalsesi son paramètre équivaut à 0,Truesinon.

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

int(4.5)→ 4 int(-4.5)→ -4 int('0345')→ 345

int('SHNU')→ erreur float(4)→ 4. float('4.5')→ 4.5

str(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 valeur qu’elle référence. L’affectation d’une variable consiste à lier un nom à une valeur:

1 x = 3

(15)

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

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 de variable que vous êtes en train d’écrire est en gras ou en couleur, c’est qu’il s’agit d’un mot ré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. Le type du résultat dépendra des types d’entrée: comme le montre le tableau ci-dessous, sauf dans le cas d’une addition, c’est le type le plus général qui l’emporte.

+, −, ∗, ∗∗ int float

int int float

float float float

L’opération ** correspond à la puissance: x ** y calcule xy. La division (/) donne toujours

unfloat; si l’on veut tronquer la partie décimale pour obtenir un entier, on peut transtyper

avecintou plus simplement utiliser // qui nous donne le quotient de la division entière.

1 >>> 3 / 2 2 1.5

3 >>> 3 // 2 4 1

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

(16)

2.2.2 Opérations logiques

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

— and: le ET logique, xandy vautTrueseulement quand x et y valentTrue, — or: le OU logique, xory vautFalseseulement quand x et y valentFalse, — not: la négation logique,not TruedonneFalseetnot FalsedonneTrue. Voici pour rappel les tables de vérité correspondantes:

p q pandq porq notp

False False False False True

False True False True True

True False False True False

True True True True False

On sera souvent confronté aux opérations sur les booléens, car les comparaisons produisent des boolé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 concaconca-tène cette chaîne avec elle-même n − 1 fois. Les opérateurs de comparaison utilise l’ordre lexicographique, autrement dit celui du dictionnaire.

1 >>> "bon" + "jour" 2 "bonjour"

3 >>> "shnu" _{* 3} 4 "shnushnushnu"

5 >>> "bonjour" <= "au revoir" 6 False

7 >>> "chaine" != "CHAINE" 8 True

2.2.4 Formes condensées

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

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

(17)

— 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é ifpermet de n’exécuter du code que sous certaines conditions. Dans sa forme la plus simple, on déclare un blocifcomme suit:

1 # debut 2 if expression: 3 # instruction 1 du if 4 # instruction 2 du if 5 # ... 6 # suite

début expression vraie?

bloc if

suite non

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 duif sont effectuées uniquement si l’expression est évaluée àTrue; dans tous les cas, le programme reprend à l’instruction après

if.

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 testif 2 < 1 and ..., ce qui suit leandn’est jamais évalué car 2 < 1

estFalseet le résultat duandne pourra donc jamais valoirTrue;

— dans le testif 2 > 1 or ..., ce qui suit leandn’est jamais évalué car 2 > 1 est

Trueet le résultat duorvaudra doncTrue, peu importe ce qui suit leor.

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

2.3.2 Alternative au if: le else

(18)

1 # debut 2 if expression: 3 # instruction 1 du if 4 # ... 5 else: 6 # instruction 1 du else 7 # ... 8 # suite début expression vraie? bloc if suite bloc else non oui

Les instructions du bloc duifsont 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èsif/else.

2.3.3 Autres options: le mot clé elif

La seconde variation avec un ou plusieurselifse déclare comme suit:

1 # debut 2 if expression1: 3 # bloc du if 4 elif expression2: 5 # bloc du elif 6 else: 7 # bloc du else 8 # 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 vaut

True;

— les instructions du bloc duelifsont effectuées uniquement si expression1 vaut

Falseet expression2 vautTrue;

— les instructions du bloc duelsesont effectuées uniquement si expression1 vaut

Falseet expression2 vautFalse.

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

On n’est jamais obligé d’utiliserelifetelse, mais si on décide de les utiliser: — on doit suivre l’ordreif. . . elif. . . else(toujours en dernier);

(19)

Chapitre 3. Structures itérables et boucles for

Chapitre 3

Structures itérables et boucles for

Sommaire

3.1 Boucles for . . . 20

3.2 Un itérable particulier: range . . . 21

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

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

3.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 comsimple-ment parcourir exactesimple-ment une fois tous les élésimple-ments de la structure donné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.

(20)

3.1 Boucles for

Python propose deux mécanismes de boucles: les bouclesforet les boucleswhile, qui nous permettent toutes deux de répéter des instructions un certain nombre de fois. On commencera par couvrir les bouclesfor, car elles s’utilisent exclusivement avec des itérables et sont plus intuitives: elles ressemblent en effet au ∀ des mathématiques.

La syntaxe duforest la suivante:

1 for element in iterable:

2 # instruction 1 du for

3 # instruction 2 du for

4 # ...

5 # suite du programme

Schématiquement, l’action duforpeut 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 bouclesforn’ont d’intérêt que si on dispose d’itérables à parcourir. Jusqu’à présent, on n’a rencontré que les chaînes de caractères comme structure itérable, qui nous permettent déjà de montrer comment marchent les bouclesforsur du texte:

1 >>> for lettre in "bonjour":

2 ... print(lettre) 3 ... 4 b 5 o 6 n 7 j 8 o 9 u 10 r

Remarquons que l’on n’a pas expliqué à Python par quelle valeur il fallait commencer ou comment 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 boucleforest une copie de la valeur manipulée. Ainsi, une boucle au formatfor element in iterablene modifiera pas ce qui se trouve dans l’itérable,

(21)

puisqu’on manipule des copies de ses éléments. On verra plus tard comment modifier les ité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ès souvent quand on utilise desfor.

Les intervalles s’obtiennent à l’aide d’un appel à la fonctionrange(). Il existe trois manières de 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 bouclesforavec desrange:

1 >>> for i in range(5): 2 ... print(i) 3 ... 4 0 5 1 6 2 7 3 8 4 9 >>> for i in range(1, 10, 3): 10 ... print(i) 11 ... 12 1 13 4 14 7

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

1 >>> for i in range(5, 0, -1): 2 ... print(i) 3 ... 4 5 5 4 6 3 7 2 8 1

(22)

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 les caractè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 apostrophes ou des triples guillemets:

1 s = '''Ceci est une 2 chaine sur

3 plusieurs lignes.'''

Les sauts de lignes seront encodés par le caractère \n. D’autres caractères spéciaux utiles sont pré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 fonctionlen(chaine), qui nous renvoie le nombre de caractères qu’elle contient. Si l’on veut accéder aux éléments d’une chaîne, qui sont des lettres, on peut le faire à l’aide de l’opérateur []. Attention, les indices d’une chaîne de longueur n commencent à 0 (et non à 1) et se terminent en n − 1 (et non en n)! De plus, seuls des indices entiers sont autorisés.

1 >>> texte = 'ma chaine' 2 >>> len(texte)

3 9

4 >>> 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]

(23)

13 TypeError: string indices must be integers

Les chaînes ne sont pas modifiables. Si x contient une valeur de typestret que vous voulez la changer, il faut faire une nouvelle affectation de x:

1 >>> x = 'toto' 2 >>> x[0] = 'p'

5 TypeError: 'str' object does not support item assignment 6 >>> 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 une chaîne par un entier n concatène cette chaîne avec elle-même n − 1 fois:

1 >>> 'bon' + 'jour' 2 'bonjour'

3 >>> 'shnu' _{* 3} 4 'shnushnushnu'

Bien d’autres opérations sur les chaînes sont disponibles sous la forme de méthodes, avec la notation 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 positions valides à l’aide derange(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 m 6 o 7 n 8 t 9 e 10 x 11 t 12 e

(24)

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érant directement sur les éléments plutôt que sur les positions:

1 >>> texte = "mon texte" 2 >>> for lettre in texte:

3 ... print(texte) 4 ... 5 m 6 o 7 n 8 t 9 e 10 x 11 t 12 e

3.4 Tuples

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

1 >>> x = (4, 3, 1) # cree un tuple avec 3 entiers 2 >>> x = 4, 3, 1 # meme resultat

3 >>> y = (4,) # tuple avec un seul element 4 >>> z = ('trois', -5, True)

Pour créer untupleavec 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 [],inet + ainsi que la fonctionlen()s’utilisent exactement de la même manière. Tout comme les chaînes, les tuples ne sont pas modifiables, et toute tentative d’affectation provoquera donc une erreur.

1 >>> mon_tuple = (4, 3, 1) # cree un tuple avec 3 entiers 2 >>> mon_tuple[0] = 4

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 de parenthèses:

1 >>> liste_1 = list() # liste vide

(25)

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 [],inet +ainsi que la fonctionlen()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 = 1 6 position 1 : element = 2.0 7 position 2 : element = 3 8 >>> liste_3[0] = -5 9 >>> liste_3 10 [-5, 2.0, '3']

On a déjà vu comment utiliser les bouclesforpour parcourir des itérables, en utilisant soit les positions, 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 = 1

4 ...

5 >>> liste

6 [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] = 1

4 ...

5 >>> liste 6 [1, 1, 1]

3.5.2 Copie de listes

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

(26)

1 >>> x = 4

2 >>> y = x # copie la valeur de x dans y 3 >>> x = 2 # ne modifie pas y

4 >>> x, y 5 (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, lst2 5 ([4, 2], [4, 2])

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

1 >>> lst1 = [1, 2]

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

4 >>> lst1, lst2 5 ([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 de mé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);

(27)

1 >>> # suite de l'exemple precedent 2 >>> liste.pop()

3 5

4 >>> liste.pop(0) 5 2

6 >>> 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ésentent le double avantage d’être modifiables et de pouvoir mélanger les types. Cependant, on verra bientôt des situations dans lesquelles on ne peut pas utiliser les listes.

3.6 Ensembles

La structureset(‘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 manipule des 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’unsetd’être non modifiables. Mais lesseteux-mêmes sont modifiables tout comme les listes.

Lessetse déclarent comme les listes, mais avec des accolades:

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

Ou à l’aide de la fonctionset(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)

(28)

Les méthodes de la colonne “Méthode 1” ainsi que les opérateurs présentés ne modifient pas les 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 un ensemble 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érationsinetlen()fonctionnent encore sur les ensembles; par contre, l’opérateur + ne marche 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 == t s 6= t s != t s ⊂ t s < t s ⊆ t s <= t

Il existe également une structure permettant de représenter des ensembles non-modifiables: il s’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 2

2 >>> S = set([set([1, 2]), set([1, 3]), set([2, 3])])

On doit donc écrire:

1 # sous-ensembles de {1, 2, 3} de taille 2

2 >>> 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 quoi d’autre, pourvu qu’il s’agisse d’un type non-modifiable. Les valeurs, par contre, peuvent être modifiables.

(29)

3.7.1 Déclaration et manipulation

On peut déclarer les dictionnaires comme suit:

1 >>> mon_dico = dict() # dictionnaire vide

2 >>> notes_etudiants = {"Jean": 15, "Marie": 16}

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

1 >>> notes_etudiants["Jean"] = 0 # Jean a triche

2 >>> notes_etudiants["Pierre"] = 14 # on vient de corriger

une autre copie

3 >>> notes_etudiants["Marc"] += 1 # echoue: Marc n'existe

pas dans le carnet

4 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 types connus, on peut toujours recourir au transtypage.

Les seuls opérateurs qui fonctionnent sur les dictionnaires sont ==, != etin. Attention, x in

dictionnairevérifie si x appartient aux clés! Si l’on veut savoir si x appartient aux valeurs du dictionnaire, on utilisera la forme x in dictionnaire.values().

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

Les commentaires faits sur l’affectation des listes s’appliquent également aux dictionnaires et aux ensembles, 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)

(30)

4 Jean 5 Pierre 6 Marie

7 >>> for nom in notes_etudiants.keys():

8 ... print(nom, ":", notes_etudiants[nom])

9 ...

10 Jean : 0 11 Pierre : 14 12 Marie : 16

13 >>> # la meme chose en plus lisible:

14 >>> for nom, note in notes_etudiants.items():

15 ... print(nom, ":", note)

16 ...

17 Jean : 0 18 Pierre : 14 19 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 lesfor.

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

1 while condition: 2 # instruction 1 3 # instruction 2 4 # ... 5 # suite condition vraie? instructions suite non oui

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

(31)

Chapitre 4. Les fonctions

Chapitre 4

Les fonctions

Sommaire

4.1 Fonctions sans paramètres . . . 31

4.2 Fonction avec paramètre(s) . . . 32

4.3 Renvoi de valeurs . . . 32

4.4 Portée des variables . . . 33

4.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 maintenir et de le modifier beaucoup plus facilement, et de réutiliser certaines de ses parties dans d’autres programmes.

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 fonction

3 # instruction 2 de la fonction

4 # ...

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 lors de l’appel de cette fonction, ce qu’on peut faire à tout moment dans le programme avec la commande nom_fonction(). Le code suivant définit une fonction et illustre ce qui se passe quand on l’appelle: 1 def appel(): 2 print('-' _{* 5,} 'appel', '-' _{* 5)} 3 4 5 if __name__ == "__main__": 6 print('bonjour')

(32)

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 normal d’instructions pour aller effectuer les instructions d’appel(). Une fois les instructions de la fonction 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, on peut préciser à Python qu’elle doit posséder un ou plusieurs : il s’agit de noms de variables auxquelles 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. Lorsque l’on appelle la fonction, il faut passer les paramètres (le bon nombre et dans l’ordre!) entre parenthè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ésultat doit être communiqué d’une manière ou d’une autre au code appelant la fonction: soit par une modification 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 la fonction, et renvoie la valeur spécifiée en paramètre.

1 def calcul(a, b, c):

2 return a + b ** 2 + c ** 3

3 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 fonction avant qu’on ne puisse l’atteindre. Ici, la valeur renvoyée est un nombre, mais l’on peut renvoyer

(33)

Chapitre 4. Les fonctions

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

1 >>> y = calcul(1, 3.14, -5) 2 >>> print(y - 5)

3 -119.1404

4 >>> 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 pas

dereturndans une fonction, Python insère unreturn 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 le programme. 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 ici 2 3 def fonction_1(parametres_1): 4 # variables de la fonction 1 5 6 7 def fonction_2(parametres_2): 8 # variables de la fonction 2 9 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

(34)

Le programme et ses fonctions définissent chacun des portées; une variable définie dans une porté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 tout le programme manipulé et sont accessibles au moins en lecture, et les variables locales, qui n’existent que dans la définition d’une fonction (ou d’une classe, ou d’une méthode) et ne sont donc pas accessibles en dehors. Les paramètres de la définition d’une fonction, ainsi que les variables déclarées dans sa définition, sont des variables locales propres à la fonction; elles n’existeront donc que pendant l’exécution de la fonction, ne seront pas accessibles ailleurs, et n’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 + 1 3 4 5 if __name__ == "__main__": 6 n = 3 7 f(n) 8 print(n)

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

1 def ajoute(L, x):

2 L.append(x) # on modifie L en ajoutant x 3

4

5 if __name__ == "__main__": 6 lst = [4, 5]

7 ajoute(lst, 7) # L prend la valeur lst

8 print(lst) # affiche [4,5,7]

Cela ne vaut que pour les paramètres modifiables; les variables affectées dans la fonction restent locales. Ainsi, dans le code suivant, la liste est modifiée par le premier ; mais après l’affectation de 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)

(35)

Chapitre 4. Les fonctions 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 à unevisualisation sur PythonTutorpour mieux comprendre ce qui se passe.