Chap 3 Introduction À Python Suite 2 [PDF]

Zitiervorschau

1

A. Larhlimi

Introduction à Python Présentation des outils de programmation Dans cette introduction à Python pour la programmation élémentaire, nous pouvons travailler en ligne sur la plateforme Google Colab, ou installer et utiliser un environnement de développement intégré, pour le calcul scientifique et pour la visualisation. Vous pouvez installer sur votre ordinateur le logiciel gratuit Anaconda qui offre une installation aisée de l’ensemble de l’environnement de développement nécessaire à ce cours: https://www.anaconda.com/download/

Exécution d’un premier programme Voici un premier exemple de programme :

Voici un autre :

for i in [0, 1, 2]: print("valeur :", i) print("Fin")

Note Pour exécuter ce code pas à pas, utiliser le lien http://pythontutor.com/visualize.html#mode=edit. La prochaine ligne à exécuter est indiquée par une flèche rouge. Une flèche verte signale la ligne qui vient d’être exécutée. L’affichage après exécution est : valeur : 0 valeur : 1 valeur : 2 Fin

Quelques bases rapides en Python

2

A. Larhlimi

Utilisation en mode interactif Note Si vous n’utilisez pas Spyder mais IDLE, vous pouvez consulter cette introduction à IDLE. Dans Spyder, on dispose d’une zone de fenêtre pour l’interpréteur de commandes IPython. Son invite de commande est différente de celle de l’interpréteur Python standard (qui est >>>). Elle se présente de la façon suivante : In [1]:

Exemple de première utilisation de IPython : In [1]: 3 * 4 Out[1]: 12 In [2]: 5 + 2 Out[2]: 7

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

Premiers calculs Testez les calculs suivants : >>> >>> >>> ? >>>

4 + 5 3 - 7 5 + 2 * 3

# les espaces sont optionnels # la priorité des opérations mathématiques est-elle respectée

(6 + 3) * 2

Pour calculer une puissance, on utilise **. >>> 5**2

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

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

3

A. Larhlimi

>>> 7 // 2 3

L’opérateur % L’opérateur % (appelé opérateur modulo) fournit le reste de la division entière d’un nombre par un autre. Exemple >>> 7 % 2 1 >>> 6 % 2 0

Affectation >>> >>> 2 >>> >>> 5

a = 2 a b = a + 3 b

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

Affichage - la fonction print() Pour afficher, on utilise la fonction print(). >>> print("bonjour") bonjour >>> a = 5 >>> print(a) 5

Il est possible de réaliser plusieurs affichages à la suite. Pour cela, on sépare les éléments par des virgules. >>> a = 5 >>> print("a vaut", a) a vaut 5

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

4

A. Larhlimi

 Python 2 : print "a vaut", a  Python 3 : print("a vaut", a) Pour ne pas aller à la ligne et continuer sur la même ligne lors du prochain print :  Python 2 : print "a vaut", a,  Python 3 : print("a vaut", a, end=" ") Il est possible avec Python 2.7 d’utiliser la syntaxe de Python 3 pour la fonction print grâce à l’instruction from __future__ import print_function. Voir aussi https://python.developpez.com/cours/apprendre-python3/?page=page_4#L4

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

En Python 3, si on souhaite afficher les valeurs, il est nécessaire de convertir le résultat en liste grâce à la fonction list(). Par exemple : >>> list(range(10)) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Le nombre de fin qui lui est passé n’est jamais dans la liste générée. Par exemple, range(10) génère 10 valeurs, exactement les indices des éléments d’une séquence de longueur 10. Il est possible de faire commencer l’intervalle à un autre nombre, ou de spécifier un incrément différent (même négatif) : >>> [5, 6, 7, 8, 9] >>>4 list(range(0, 10, 3)) [0, 3, 6, 9] >>> list(range(-10, -100, -30)) [-10, -40, -70]

De manière générale, on a : range(valeur_initiale, borne_de_fin, pas) Le pas peut être positif ou négatif. La valeur de la borne de fin (maximale ou minimale) n’est jamais atteinte. Exercice 1

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

Accès aux éléments d’une liste >>> a = list(range(1,10,2)) >>> a

5

A. Larhlimi

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

Pour accéder à un élément d’une liste, on indique entre crochets [] l’indice de l’élément. Avertissement En Python, l’indice du premier élément d’une liste est 0 (ceci est à distinguer d’autres langages).

La fonction len() La fonction len() renvoie le nombre d’éléments. Par exemple : >>> >>> [7, >>> 3

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

Lecture d’informations au clavier - la fonction input() x = int(input("Donnez un entier : "))

Par défaut, la fonction input() renvoie une chaîne de caractères. Il faut donc utiliser la fonction int() qui permet d’obtenir un entier.

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

Pour faire une répétition : l’instruction for for i in range(n): bloc d'instructions

Pour faire un test : l’instruction if if x > 0:

6

A. Larhlimi

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

Les différentes sortes d’instruction

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

Règles générales d’écriture Les identificateurs Un identificateur est une suite de caractères servant à désigner les différentes entitées manipulées par un programme : variables, fonctions, classes… En Python, un identificateur est formé de lettres ou de chiffres. Il ne contient pas d’espace. Le premier caractère doit obligatoirement être une lettre. Il peut contenir le caractère « _ » (underscore, en français « souligné »). Il est sensible à la casse (distinction entre majuscule et minuscule).

Les mots-clés Les mots réservés par le langage Python (if, for, etc.) ne peuvent pas être utilisés comme identificateurs. Voir aussi Liste des mots-clés : https://python.developpez.com/cours/apprendre-python3/? page=page_4#L4-C

Les commentaires Les commentaires usuels: # Ceci est un commentaire

Les commentaires en fin de ligne: a = 2 # Ceci est un commentaire

7

A. Larhlimi

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

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

Instruction if Syntaxe if condition: Instruction A

condition est une expression booléenne, c’est-à-dire une expression qui prend pour

valeur True (Vrai) ou False (Faux). L”instruction A n’est exécutée que si la condition est vérifiée (c’est-à-dire si elle prend pour valeur True). L’instruction if est une instruction composée. Le : (deux-points) à la fin de la ligne introduit le bloc d’instructions qui sera exécuté si la condition est vérifiée. Exemple 1 avec condition vraie : x = 15 if x > 10: print(x, "est plus grand que 10") print("Fin")

8 Affichage après exécution : 15 est plus grand que 10 Fin

Exemple 1 avec condition fausse : x = 3 if x > 10: print x, "est plus grand que 10" print "Fin"

Affichage après exécution : Fin

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

Dans cet exemple, le bloc après le if contient deux instructions. L’instruction print("Fin") ne fait pas partie du bloc car elle n’est pas indentée. Affichage après exécution : 5 est plus grand que 0 il est strictement positif Fin

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

Affichage après exécution : Fin

Instruction if … else Syntaxe if condition:

A. Larhlimi

9

A. Larhlimi

Instruction A else: Instruction B

Exemple où la condition est vraie : x = 5 if x > 0: print(x, "est positif") else: print(x, "est négatif ou nul") print("Fin")

Affichage après exécution : 5 est strictement positif Fin

Exemple où la condition est fausse : x = -2 if x > 0: print(x, "est positif") else: print(x, "est négatif ou nul") print("Fin")

Affichage après exécution : -2 est négatif ou nul Fin

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

Opérateur

Signification x == y

x est égal à y

x != y

x est différent de y

x>y

x est plus grand que y

10

A. Larhlimi

Opérateur

Signification x= y

x est plus grand ou égal à y

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

Exercice 2: Programme qui demande le nom et l’âge de l’utilisateur et le montant plein tarif. Si l’âge est inférieur à 18 ans, le programme donne une remise de 30%. Le programme doit afficher le montant à payer. Opérateur logique and¶ >>> 2 < 3 and 3 < 4 True >>> 2 < 3 and 3 > 4 False

Opérateur logique or >>> 2 < 3 or 3 < 4 True >>> 2 < 3 or 3 > 4 True

11

A. Larhlimi

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

Boucles bornées et non bornées Boucle bornée Quand on sait combien de fois doit avoir lieu la répétition, on utilise généralement une boucle for. Boucle non bornée Si on ne connait pas à l’avance le nombre de répétitions, on choisit une boucle while.

Boucle for Exemple d’utilisation : for i in [0, 1, 2, 3]: print("i a pour valeur", i)

Affichage après exécution : i i i i

a a a a

pour pour pour pour

valeur valeur valeur valeur

0 1 2 3

L’instruction for est une instruction composée, c’est-à-dire une instruction dont l’en-tête se termine par deux-points :, suivie d’un bloc indenté qui constitue le corps de la boucle. On dit que l’on réalise une itération de la boucle à chaque fois que le corps de la boucle est exécuté. Dans l’en-tête de la boucle, on précise après le mot-clé for le nom d’une variable (i dans l’exemple ci-dessus) qui prendra successivement toutes les valeurs qui sont données après le mot-clé in. On dit souvent que cette variable (ici i) est un compteur car elle sert à numéroter les itérations de la boucle. Il est possible d’obtenir le même résultat sans donner la liste des valeurs, mais en utilisant la fontion range(). for i in range(4): print("i a pour valeur", i)

Pour parcourir les indices d’une liste, il est possible de combiner range() et len() comme cidessous :

12

A. Larhlimi

c = ["Ali", "est", "dans", "le", "jardin"] for i in range(len(c)): print("i vaut", i, "et c[i] vaut", c[i])

Affichage après exécution : i i i i i

vaut vaut vaut vaut vaut

0 1 2 3 4

et et et et et

c[i] c[i] c[i] c[i] c[i]

vaut vaut vaut vaut vaut

Ali est dans le jardin

Rappel : La fonction len() renvoie le nombre d’éléments : >>> c = ["Ali", "est", "dans", "le", "jardin"] >>> len(c) 5

Dans l’exemple suivant, nous allons illustrer que la variable indiquée après for parcourt toutes les valeurs de la liste donnée après in : c = ["Ali", "est", "dans", "le", "jardin"] for i in c: print("i vaut", i) >>> i vaut i vaut i vaut i vaut i vaut

Ali est dans le jardin

Boucle while Syntaxe : while condition: Instruction A

13

A. Larhlimi

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

Affichage après exécution : x a x a x a x a Fin

pour pour pour pour

valeur valeur valeur valeur

1 2 4 8

Exercice 3 : p = 1 n =10 i=1 while i 0: break print("reponse correcte")

L’instruction continue L’instruction continue permet de passer prématurément au tour de boucle suivant. Elle fait continuer sur la prochaine itération de la boucle. Exemple for i in range(4): print("debut iteration", i) print("bonjour") if i < 2: continue print("fin iteration", i) print("apres la boucle")

17

A. Larhlimi

Affichage après exécution : debut iteration bonjour debut iteration bonjour debut iteration bonjour fin iteration 2 debut iteration bonjour fin iteration 3 apres la boucle

0 1 2

3

La clause else dans une boucle La clause else dans un boucle permet de définir un bloc d’instructions qui sera exécuté à la fin seulement si la boucle s’est déroulée complétement sans être interrompue par un break. Contrairement aux instructions présentes après la boucle, qui s’exécutent dans tous les cas (avec ou sans interruption par un break), le bloc d’instructions défini dans la clause else ne s’exécutera pas lors de l’interruption par un break. Après l’interruption, on passera directement aux instructions après la boucle. Autrement dit, le bloc de la clause else est exécuté lorsque la boucle se termine par épuisement de la liste (avec for) ou quand la condition devient fausse (avec while), mais pas quand la boucle est interrompue par un break. Ceci est illustré dans la boucle suivante, qui recherche des nombres premiers : for n in range(2, 8): for x in range(2, n): if n % x == 0: print(n, "egale", x, "*", n/x) break else: print(n, "est un nombre premier")

Affichage après exécution : 2 3 4 5 6 7

est un nombre est un nombre egale 2 * 2.0 est un nombre egale 2 * 3.0 est un nombre

premier premier premier premier

18

A. Larhlimi

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

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

type(15) a = 15 type(a) a = "toto" type(a)

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

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

19

A. Larhlimi

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

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

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

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

Remarque : la fonction not est un opérateur logique qui renvoie l’opposé de la valeur booléenne transmise. Pour True, on obtient False. Réciproquement, il renvoie False quand on lui transmet True.

Le type list (liste) Sous Python, on peut définir une liste comme une collection d’éléments séparés par des virgules, l’ensemble étant enfermé dans des crochets. Exemple : >>> jour = ["lundi", "mardi", "mercredi", 1800, 20.357, "jeudi", "vendredi"] >>> type(jour) list >>> jour ['lundi', 'mardi', 'mercredi', 1800, 20.356999999999999, 'jeudi', 'vendredi']

20

A. Larhlimi

Le type complex (complexe) Python possède par défaut un type pour manipuler les nombres complexes. La partie imaginaire est indiquée grâce à la lettre « j » ou « J ». La lettre mathématique utilisée habituellement, le « i », n’est pas utilisée en Python car la variable i est souvent utilisé dans les boucles. Exemples : >>> a = 2 + 3j >>> type(a) complex >>> a (2+3j) >>> b = 1 + j Traceback (most recent call last): File "", line 1, in b = 1 + j NameError: name 'j' is not defined >>> b = 1 + 1j >>> a * b (-1+5j) >>> 1j**2 (-1+0j)

Exercice 4 : N=10 L=[] For i in range(x) : L.append(i*i) Print(L) 1) Donner le résultat de l’affichage 2) Que réalise ce programme 3) Quelle le rôle la méthode append

21

A. Larhlimi

Fonctions en Python Nous avons déjà rencontré diverses fonctions prédéfinies : print(), input(), range(), len(). Lorsqu’une tâche doit être réalisée plusieurs fois par un programme avec seulement des paramètres différents, on peut l’isoler au sein d’une fonction. Cette approche est également intéressante si la personne qui définit la fonction est différente de celle qui l’utilise. Par exemple, nous avons déjà utilisé la fonction print() qui avait été définie par quelqu’un d’autre. Voir aussi https://python.developpez.com/cours/apprendre-python3/?page=page_9

Définition d’une fonction - def Syntaxe La syntaxe Python pour la définition d’une fonction est la suivante : def nom_fonction(liste de paramètres): bloc d'instructions

Vous pouvez choisir n’importe quel nom pour la fonction que vous créez, à l’exception des mots-clés réservés du langage, et à la condition de n’utiliser aucun caractère spécial ou accentué (le caractère souligné « _ » est permis). Comme c’est le cas pour les noms de variables, on utilise par convention des minuscules, notamment au début du nom (les noms commençant par une majuscule seront réservés aux classes). Corps de la fonction Comme les instructions if, for et while, l’instruction def est une instruction composée. La ligne contenant cette instruction se termine obligatoirement par un deux-points :, qui introduisent un bloc d’instructions qui est précisé grâce à l’indentation. Ce bloc d’instructions constitue le corps de la fonction.

Fonction sans paramètre Exemple def compteur3(): i = 0 while i < 3: print(i) i = i + 1 print("bonjour") compteur3() compteur3()

22

A. Larhlimi

Affichage après exécution : bonjour 0 1 2 0 1 2

En entrant ces quelques lignes, nous avons défini une fonction très simple qui compte jusqu’à 2. Notez bien les parenthèses, les deux-points, et l’indentation du bloc d’instructions qui suit la ligne d’en-tête (c’est ce bloc d’instructions qui constitue le corps de la fonction proprement dite). Après la définition de la fonction, on trouve le programme principal qui débute par l’instruction print("bonjour"). Il y a ensuite au sein du programme principal, l’appel de la fonction grâce à compteur3(). Il est également possible de sauvegarder ce programme en tant que script au sein d’IDLE. Après avoir exécuté ce script, pour utiliser à nouveau la fonction que nous venons de définir, il suffit de l’appeler par son nom au niveau du shell. Ainsi : >>> compteur3()

provoque l’affichage de : 0 1 2

Nous pouvons maintenant réutiliser cette fonction à plusieurs reprises, autant de fois que nous le souhaitons. Nous pouvons également l’incorporer dans la définition d’une autre fonction. Exemple de fonction qui appelle une autre fonction def compteur3(): i = 0 while i < 3: print(i) i = i + 1 def double_compteur3(): compteur3() compteur3() print("bonjour") double_compteur3()

Exécuter

23

A. Larhlimi

Une première fonction peut donc appeler une deuxième fonction, qui elle-même en appelle une troisième, etc. Créer une nouvelle fonction offre l’opportunité de donner un nom à tout un ensemble d’instructions. De cette manière, on peut simplifier le corps principal d’un programme, en dissimulant un algorithme secondaire complexe sous une commande unique, à laquelle on peut donner un nom explicite. Une fonction est donc en quelque sorte une nouvelle instruction personnalisée, qu’il est possible d’ajouter librement à notre langage de programmation.

Fonction avec paramètre Exemple def compteur(stop): i = 0 while i < stop: print(i) i = i + 1 compteur(4) compteur(2)

Exécuter Affichage après exécution : 0 1 2 3 0 1

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

Utilisation d’une variable comme argument L’argument que nous utilisons dans l’appel d’une fonction peut être une variable. Exemple def compteur(stop): i = 0 while i < stop: print(i) i = i + 1 a = 5 compteur(a)

24

A. Larhlimi

Exécuter Affichage après exécution : 0 1 2 3 4

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

Fonction avec plusieurs paramètres Exemple La fonction suivante utilise trois paramètres : start qui contient la valeur de départ, stop la borne supérieure exclue comme dans l’exemple précédent et step le pas du compteur. def compteur_complet(start, stop, step): i = start while i < stop: print(i) i = i + step compteur_complet(1, 7, 2)

Exécuter Affichage après exécution : 1 3 5

Note

25

A. Larhlimi  

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

Variables locales, variables globales Lorsqu’une fonction est appelée, Python réserve pour elle (dans la mémoire de l’ordinateur) un espace de noms. Cet espace de noms local à la fonction est à distinguer de l’espace de noms global où se trouvait les variables du programme principal. Dans l’espace de noms local, nous aurons des variables qui ne sont accessibles qu’au sein de la fonction. C’est par exemple le cas des variables start, stop, step et i dans l’exemple précédent. A chaque fois que nous définissons des variables à l’intérieur du corps d’une fonction, ces variables ne sont accessibles qu’à la fonction elle-même. On dit que ces variables sont des variables locales à la fonction. Une variable locale peut avoir le même nom qu’une variable de l’espace de noms global mais elle reste néanmoins indépendante. Les contenus des variables locales sont stockés dans l’espace de noms local qui est inaccessible depuis l’extérieur de la fonction. Les variables définies à l’extérieur d’une fonction sont des variables globales. Leur contenu est « visible » de l’intérieur d’une fonction, mais la fonction ne peut pas le modifier. Exemple def test(): b = 5 print(a, b) a = 2 b = 7 test() print(a, b)

Exécuter Affichage après exécution : 2 5 2 7

Explications en vidéo

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

26

A. Larhlimi

Cette instruction permet d’indiquer - à l’intérieur de la définition d’une fonction - quelles sont les variables à traiter globalement. On va ici créer une fonction qui a accès à la variable globale b. def test(): global b b = 5 print(a, b) a = 2 b = 7 test() print(a, b)

Exécuter Affichage après exécution : 2 5 2 5

La présentation de cette page est inspirée par le livre de Gérard Swinnen « Apprendre à programmer avec Python 3 » disponible sous licence CC BY-NC-SA 2.0.

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

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

27

A. Larhlimi

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

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

Arguments avec étiquettes Dans la plupart des langages de programmation, les arguments que l’on fournit lors de l’appel d’une fonction doivent être fournis exactement dans le même ordre que celui des paramètres qui leur correspondent dans la définition de la fonction. Python autorise cependant une souplesse beaucoup plus grande. Si les paramètres annoncés dans la définition de la fonction ont reçu chacun une valeur par défaut, sous la forme déjà décrite ci-dessus, on peut faire appel à la fonction en fournissant les arguments correspondants dans n’importe quel ordre, à la condition de désigner nommément les paramètres correspondants. Exemple : def oiseau(voltage=100, etat="allumé", action="danser la java"): print("Ce perroquet ne pourra pas", action) print("si vous le branchez sur", voltage, "volts !") print("L'auteur de ceci est complètement", etat) >>> oiseau(etat="givré", voltage=250, action="vous approuver") Ce perroquet ne pourra pas vous approuver si vous le branchez sur 250 volts ! L'auteur de ceci est complètement givré >>> oiseau() Ce perroquet ne pourra pas danser la java si vous le branchez sur 100 volts ! L'auteur de ceci est complètement allumé

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

V=43πR3V=43πR3 Exemple :

28

A. Larhlimi

import numpy as np def cube(n): return n**3 def volume_sphere(r): return 4 / 3 * np.pi * cube(r) r = float(input("Entrez la valeur du rayon : ")) print("Le volume de cette sphere vaut", volume_sphere(r))

A bien y regarder, ce programme comporte deux parties :  les deux fonctions cube() et volume_sphere()  le corps principal du programme. Dans le corps principal du programme, il y a un appel de la fonction volume_sphere(). A l’intérieur de la fonction volume_sphere(), il y a un appel de la fonction cube(). Notez bien que les deux parties du programme ont été disposées dans un certain ordre :  d’abord la définition des fonctions,  et ensuite le corps principal du programme. Cette disposition est nécessaire, parce que l’interpréteur exécute les lignes d’instructions du programme l’une après l’autre, dans l’ordre où elles apparaissent dans le code source. Dans le script, la définition des fonctions doit donc précéder leur utilisation. Pour vous en convaincre, intervertissez cet ordre (en plaçant par exemple le corps principal du programme au début), et prenez note du type de message d’erreur qui est affiché lorsque vous essayez d’exécuter le script ainsi modifié. En fait, le corps principal d’un programme Python constitue lui-même une entité un peu particulière, qui est toujours reconnue dans le fonctionnement interne de l’interpréteur sous le nom réservé __main__ (le mot « main » signifie « principal », en anglais. Il est encadré par des caractères « souligné » en double, pour éviter toute confusion avec d’autres symboles). L’exécution d’un script commence toujours avec la première instruction de cette entité __main__, où qu’elle puisse se trouver dans le listing. Les instructions qui suivent sont alors exécutées l’une après l’autre, dans l’ordre, jusqu’au premier appel de fonction. Un appel de fonction est comme un détour dans le flux de l’exécution : au lieu de passer à l’instruction suivante, l’interpréteur exécute la fonction appelée, puis revient au programme appelant pour continuer le travail interrompu. Pour que ce mécanisme puisse fonctionner, il faut que l’interpréteur ait pu lire la définition de la fonction avant l’entité __main__, et celle-ci sera donc placée en général à la fin du script. Dans notre exemple, l’entité __main__ appelle une première fonction qui elle-même en appelle une deuxième. Cette situation est très fréquente en programmation. Si vous voulez comprendre correctement ce qui se passe dans un programme, vous devez donc apprendre à lire un script, non pas de la première à la dernière ligne, mais plutôt en suivant un cheminement analogue à ce qui se passe lors de l’exécution de ce script. Cela signifie concrètement que vous devrez souvent analyser un script en commençant par ses dernières lignes !

29

A. Larhlimi

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

30

A. Larhlimi

Les listes Python Dans cette leçon, nous allons découvrir un premier type de données composites Python : les listes. Nous allons comprendre l’intérêt de ce type de données et apprendre à les manipuler.  

Présentation des listes Python Jusqu’à présent, nous n’avons stocké qu’une seule valeur à la fois dans nos variables. Les listes sont un type de données très particulier au sens où elles représentent des données composées ou combinées. Une liste est en effet par définition composée d’une suite de valeur ou d’éléments.  Pour définir une nouvelle liste en Python, on va devoir utiliser une paire de crochets [ ]. Nous allons placer les différents éléments de notre liste dans ces crochets en les séparant par des virgules. On peut par exemple créer une liste de 5 éléments et la placer dans une variable liste comme ceci :

Notre liste est ici composée de 5 valeurs de type numérique. On va pouvoir stocker tous types de valeurs dans une liste, comme des chaines de caractères par exemple :

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

31

A. Larhlimi

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

Récupérer une ou plusieurs valeurs dans une liste Les listes Python sont par défaut indexées ou indicées. Cela signifie que chaque valeur d’une liste est lié à un indice qu’on va pouvoir utiliser pour récupérer cette valeur en particulier. Les listes possèdent des indices numériques qui commencent à 0. La première valeur d’une liste possède donc toujours l’indice 0, la deuxième valeur l’indice 1, la troisième valeur l’indice 2 et etc. Pour récupérer une valeur en particulier dans une liste, on va devoir préciser le nom de la liste suivi de l’indice de cette valeur entre crochets. Notez que les indices négatifs sont acceptés; dans ce cas on partira de la fin de la liste (l’indice -1 correspond au dernier élément, -2 à l’avant dernier et etc.).

On va également pouvoir récupérer une tranche de valeurs dans une liste, c’est-à-dire un ensemble de valeurs qui se suivent. Pour cela, on utilisera le symbole : entre les crochets avec 0, 1 ou 2 indices autour. Si on utilise : sans indice, alors une copie superficielle de la liste sera renvoyée. Si on mentionne un indice avant : mais pas d’indice après, alors une copie superficielle partielle de la liste de départ sera renvoyée, en commençant à copier à partir de l’indice donné. Si au contraire on mentionne un indice après : mais pas d’indice avant, une copie superficielle partielle de la liste de départ sera renvoyée qui commence au début de la liste et jusqu’à l’indice

32

A. Larhlimi

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

Vous devez également savoir que ce qu’on a vu jusqu’ici sur les listes s’applique également aux chaines de caractères. Les chaînes de caractères peuvent en effet également être indexées, ce qui signifie qu’on peut accéder aux caractères par leur position). Cela est logique après tout : les chaines de caractères sont des “séquences” de caractères tandis que les listes sont des “séquences” de valeurs. Comme pour les listes, le premier caractère d’une chaîne possède l’indice 0, le deuxième l’indice 1 et etc; On va également pouvoir utiliser des indices négatifs et récupérer des tranches avec :.

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

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

33

A. Larhlimi

pouvoir altérer leur structure ou modifier leur contenu en ajoutant, supprimant ou remplaçant des valeurs. En effet, vous devez bien comprendre qu’une fois qu’on définit une valeur “chaine de caractères” par exemple, celle-ci ne peut plus être modifiée par la suite. Les seules opération qu’on va pouvoir faire vont être de créer une nouvelle chaine en concaténant deux chaines d’origine (qui une nouvelle fois ne seront pas modifiées) ou de remplacer une chaine par une autre valeur en affectant une nouvelle valeur dans une variable (ce qui a pour effet d’écraser la chaine de départ). Au contraire des chaines, on va tout à fait pouvoir ajouter, modifier ou supprimer des valeurs dans une liste. Pour cela, on va mentionner le nom de notre liste avec l’indice de la ou des éléments à ajouter / modifier et leur affecter une nouvelle valeur. Les affectations de tranches sont possibles :

Notez finalement également qu’on va aussi pouvoir utiliser les opérateurs de concaténation et de répétition avec des listes :