Séance 2: Fonctions et variables

Séance 2: Fonctions et variables
Cours d’informatique de BCPST 1
Table des matières
1 Variables dans Python
2 Fonctions
2.1 Syntaxe . . . . . . . . . . . . . . . . . . .
2.2 Une première fonction . . . . . . . . . .
2.3 La commande return . . . . . . . . . . .
2.4 Des fonctions avec plusieurs arguments
2.5 Des fonctions avec plusieurs sorties . . .
2.6 Une fonction comme argument . . . . .
2.7 Notion d’argument optionnel . . . . . .
2.8 Affichage des variables intermédiaires .
2.9 Ajout de documentation . . . . . . . . .
2
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. .
. .
. .
.
.
5
5
6
6
6
7
7
7
8
8
3 Portée des variables
3.1 Notions de variables locales et globales . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2 Commandes global et locals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
9
10
4 Exercices
10
Séance 2:
1.
Fonctions et variables
Variables dans Python
Lors de la première séance, les commandes envoyées à Python étaient des expressions à évaluer,
Python répondait à nos demandes et, une fois la réponse donnée, celle-ci était immédiatement oubliée.
Pour pouvoir conserver en mémoire un résultat et le réutiliser, nous allons voir la notion de variable.
Pour créer une variable, il faut attribuer un nom à cette variable et lui affecter une valeur à l’aide de
l’opérateur d’affectation =. Le nom de la variable est une suite de lettres (minuscules ou majuscules)
et de chiffres, qui doit toujours commencer par une lettre. Une variable peut s’appeler par exemple
a, a1, toto... Il est d’usage de choisir des termes explicites pour faciliter la lecture du code. Une fois
affectée, la valeur de la variable peut être utilisée dans un calcul en faisant référence à son nom.
Toute instruction d’affectation doit s’écrire :
variable = expression.
L’expression est évaluée, et si elle a un sens, la valeur retournée est stockée dans la variable et Python
ne renvoie rien.
L’instruction a = 2 sera donc traduite par l’interpréteur en :
• demande au noyau le droit d’utiliser une partie de la RAM (la taille d’un entier) et note sa
place
• stocke l’entier 2 dans ce bloc qui est donc converti en binaire.
Désormais, l’interpréteur remplacera la lettre a par le contenu de ce bloc mémoire. Plus tard, on
pourra changer la valeur de a, en écrivant a = 3 ou bien a = a + 5.
Taper les opérations suivantes dans l’interprète de commande.
largeur = 12
longueur = 42
aire = longueur * largeur
print ("L'aire du rectangle est égale à", aire)
On note au passage qu’une affectation ne retourne aucun résultat. Pour voir la valeur de la variable, il
suffit d’écrire le nom de cette variable dans la console et de valider :
largeur
aire
Dans l’explorateur de variables (−→ WORKSPACE −→ TOOLS/WORKSPACE), on peut visualiser à
tout moment la table de référencement des différentes variables actives lors de votre session de travail.
Taper les opérations suivantes dans l’interprète de commande.
largeur = 20
largeur
aire # inchangée (pas de rétroaction)
On voit alors la modification de la valeur dans l’explorateur de variables et on remarque que la valeur
de la variable aire n’a pas été modifiée. Le calcul aire = longueur * largeur qu’on a effectué
utilise les valeurs des variables au moment où il a été exécuté et n’établit en aucune manière une
liaison particulière entre les variables elles-mêmes.
Lycée Pierre-Gilles de Gennes/ ENCPB 2016-2017
page 2
Séance 2:
Fonctions et variables
Une variable déjà affectée peut être réaffectée par une donnée quelconque, d’un autre type éventuellement. L’ancienne valeur de la variable est alors oubliée. On peut même écraser (mais c’est très
dangereux) les valeurs classiques que sont e ou π.
Taper les opérations suivantes dans l’interprète de commande.
4=w
w=4
# Le nom de la variable doit se trouver à gauche de l'égalité.
w+1
w==5
w==4
x
w=x
x=w+7
x
a=[x,w]
2w
2* w
2* a
Il est possible, en se plaçant dans l’explorateur de variables, de supprimer une variable devenue
inutile. On peut aussi utiliser la commande del comme le montre le prochain exemple. On va voir
aussi qu’on peut créer simultanément plusieurs variables.
(Adriane ,Thierry) = ("Top","Formidable")
Thierry
x = y = z = 0
x
y, z
del(Thierry)
Thierry
id('Adriane ') # id donne l'adresse mémoire où se trouve la variable.
id(x)
Il y a quelques règles à respecter dans la dénomination des variables :
• le nom de variables doit commencer par une lettre (on peut utiliser a2, mais pas 2a) ;
• on peut utiliser un chiffre ou un _, mais ni espace, ni accents, ni point ;
Lycée Pierre-Gilles de Gennes/ ENCPB 2016-2017
page 3
Séance 2:
Fonctions et variables
• on ne peut pas non plus écrire du x(t) ou du f(x) ;
On verra dans la suite comment définir une fonction en Python.
• il y a des noms réservés : and, as, assert, break, class, continue, def, del, elif, else,
except, False, finally, for, from, global, if, import, in, is, lambda, None, nonlocal, not,
or, pass, raise, return, True, try, while, with, yield.
Pour vous en convaincre, taper les opérations suivantes dans l’interprète de commande.
x(t)=5
if=3
xé=5 #Fonctionne avec Pyzo mais éviter les accents
Le signe = ne signifie pas qu’il y a identité entre les deux membres. Il signifie que le résultat du second
membre (de droite) est stocké à une adresse référencée par la variable du premier membre. Ainsi, le
premier membre (à gauche) est toujours réduit à un identificateur de variable.
Pour l’illustrer, taper les opérations suivantes dans l’interprète de commande.
a=2
a=a+1
a
a==a+1
L’instruction a=a+1 n’est pas une égalité mathématique, elle signifie que la variable a va prendre la
valeur de a à laquelle on a ajouté 1. La commande a=a+1 est si classique dans les boucles (que l’on
verra lors des prochaines séances) qu’une écriture simplifiée existe :
a+= 1
a
b=12
b+=10
b
a+=-2
a
a+=a
a
Dernière chose à noter : on peut faire plusieurs affectations en même temps. On pourra, si on veut
affecter a, b et c, écrire l’instruction suivante :
[a, b, c]= L,
où L est une liste déjà définie.
Lycée Pierre-Gilles de Gennes/ ENCPB 2016-2017
page 4
Séance 2:
Fonctions et variables
Cela revient à écrire :
a=L[0] ; b=L[1] ; c=L[2].
Tester :
L=range (4)
L
[a, b, c, d, e]= L
[a, b, c, d]= L # Il faut mettre le bon nombre d'éléments !
d
2.
Fonctions
2.1
Syntaxe
Une fonction est un bloc d’instructions qui a reçu un nom, dont le fonctionnement dépend d’un
certain nombre de paramètres (les arguments de la fonction) et qui renvoie un résultat (contrairement
aux procédures, qui ne retournent pas de résultat et se contentent d’agir sur l’environnement).
Python connait déjà quelques fonctions.
Taper les opérations suivantes dans l’interprète de commande.
print ("J'adore l'informatique ")
cos (3 * 2) # cos est dans la bibliothèque math
cos est une fonction et print une procédure. Il est facile de faire la distinction en utilisant l’interprète
de commande IPython : lorsqu’on applique une fonction, elle fournit un résultat qui se trouve à la
suite du mot Out (c’est la sortie). L’intérêt de définir une fonction est de pouvoir l’utiliser par la suite
à l’intérieur d’autres calculs.
Nous pouvons aussi créer de nouvelles fonctions. Pour ce faire, on utilise l’éditeur de scripts, la syntaxe
pour créer une fonction est la suivante :
def nomdelafonction (arguments ):
bloc
d'instructions
à réaliser
return résultat
Après avoir écrit l’instruction finale (celle qui contient return), il faut appuyer sur la touche F5 et
enregistrer le fichier dans votre répertoire de travail (en le nommant par exemple TD2.py).
Quelques remarques :
• Le nom d’une fonction doit être court et significatif (éviter f par exemple).
• Le symbole ":" qui se trouve au bout de la première ligne est discret mais indispensable. Les
instructions que l’on trouve en dessous de la première ligne après les deux points forment
ce qu’on appelle le corps de la fonction. Ce corps est constitué des commandes qui sont
interprétées au fur et à mesure par Python à chaque fois que l’on fait appel à la fonction.
• Il est crucial de respecter l’indentation, c’est-à-dire le retrait à droite, par rapport à def, du
corps de la fonction. C’est une spécificité du langage Python qui utilise l’indentation pour
délimiter le corps de la fonction.
Lycée Pierre-Gilles de Gennes/ ENCPB 2016-2017
page 5
Séance 2:
2.2
Fonctions et variables
Une première fonction
Voici un premier exemple de fonction qui prend en argument un réel r et qui donne l’aire d’un cercle
de rayon r. Écrire les instructions suivantes dans l’éditeur de scripts.
def aire_cercle (r):
import math
aire = math.pi * r * r
return(aire)
Après avoir enregistré votre fichier, repasser dans la console pour tester la fonction.
aire_cercle (1)
aire_cercle (5)
2.3
La commande return
Quelques subtilités à connaitre sur la fonction return :
• Toute fonction a au moins un return, même celle qui ne renvoie rien (elle renvoie () si on veut
être précis) : elle finit par return().
• Dans un return, on n’a pas nécessairement qu’une seule variable : on peut avoir une expression
faisant intervenir plusieurs variables, ou même un couple de variables.
La fonction suivante, par exemple, prend en entrée deux nombres et renvoie la différence entre
ces deux nombres.
def diff(a,b):
return(b-a)
• Dans return, on peut n’avoir que la variable d’entrée. Il s’agit alors d’une fonction qui modifie et
renvoie son entrée.
def double(a):
a * =2
return a
• Une fonction peut contenir plusieurs return, en particulier lorsque la fonction contient des tests.
Elle se termine au premier return évalué.
def absolue(x):
if x >= 0:
return(x)
return(-x)
Cette fonction est tout simplement la fonction valeur absolue.
Avoir plusieurs return permet de gagner du temps de processeur, on sort de la fonction dès que
l’on a l’information importante.
2.4
Des fonctions avec plusieurs arguments
Une fonction peut avoir zéro, un ou plusieurs arguments. La fonction suivante calcule le périmètre
d’un rectangle connaissant les longueurs de ses deux côtés.
def peri(a,b):
return 2 * (a + b)
Lycée Pierre-Gilles de Gennes/ ENCPB 2016-2017
page 6
Séance 2:
Fonctions et variables
Une fois que Python a acquis cette fonction, on peut lui demander :
peri (3,7)
2.5
Des fonctions avec plusieurs sorties
Une fonction peut retourner plusieurs sorties, c’est le cas par exemple si on modifie un peu notre
première fonction :
def aire_cercle_bis (r):
import math
aire = math.pi * r * r
return(aire , r+10)
Dans la console, on écrit par exemple
aire_cercle_bis (5)
pour constater que cette fonction renvoie deux sorties.
2.6
Une fonction comme argument
Une fonction est une variable comme les autres, elle peut donc être une entrée d’une autre fonction.
Écrire les instructions suivantes dans l’éditeur de scripts.
def eval_translate (f, a):
b=f(a)+12
return(b)
Utiliser maintenant la console pour tester la fonction.
eval_translate (aire_cercle , 5)
import math
eval_translate (math.sin , 5)
2.7
Notion d’argument optionnel
Si on tape peri(5) sur la console, Python renvoie :
TypeError: peri () missing 1 required positioned argument 'b'
On peut constater sur ce dernier exemple qu’une erreur se produit si on ne donne pas exactement le
bon nombre d’arguments d’une fonction. Il est possible de modifier ceci en précisant les valeurs par
défaut que doivent prendre certains arguments d’une fonction si on ne précise pas leur valeur.
Écrire les instructions suivantes dans l’éditeur de scripts.
def peri(a, b=12):
return 2 * (a+b)
Avec cette nouvelle définition, si on oublie de préciser le deuxième paramètre, ce dernier sera pris par
défaut comme valant 12. Repasser maintenant dans la console pour tester.
peri (5)
peri (5,7)
Lycée Pierre-Gilles de Gennes/ ENCPB 2016-2017
page 7
Séance 2:
2.8
Fonctions et variables
Affichage des variables intermédiaires
À l’exception du résultat, les variables qui interviennent dans la fonction ne s’affichent pas. Si l’on
souhaite tout de même les voir à l’écran (typiquement, pour contrôler le bon déroulement de notre
fonction), on peut forcer leur affichage à l’aide de la commande print.
Écrire les instructions suivantes dans l’éditeur de scripts.
import math as m
import cmath as cm
def reelle(z) :
theta = cm.phase(z) # Cet argument est donné en radians.
print("L'argument vaut ", theta * 180 / m.pi ,".")
x = abs(z) * cm.cos(theta)
print("La partie réelle vaut ",x, ".")
return x
Écrire alors dans la console :
x = reelle(m.sqrt (3) + 1j)
x
La fonction reelle affiche l’argument et la partie réelle du nombre donné en entrée, mais son résultat
est uniquement la partie réelle.
4!
L’instruction print ne fournit pas un résultat.
Vous pouvez créer cette fonction :
def plusun(z):
print(z+1)
puis écrire ceci dans la console :
a=plusun (10)
type(a)
a+3 # Pas d'opération possible.
2.9
Ajout de documentation
Il est possible (voire recommandé !) de rajouter une documentation à la fonction, c’est-à-dire une
description des arguments et du résultat de la fonction. Cette documentation doit être écrite entre
triples guillemets sur la ou les ligne(s) suivant le mot-clé def, ce qui donne :
def nomdelafonction (arguments ):
""" documentation de la fonction """
bloc
d'instructions
à réaliser
return résultat
On obtient ensuite la documentation d’une fonction en tapant help(nomdelafonction).
def plusun(z) :
""" Affiche z + 1"""
print(z + 1)
Il suffit maintenant de taper help(plusun) dans la console. On peut essayer aussi help(cos),
help(atan).
Lycée Pierre-Gilles de Gennes/ ENCPB 2016-2017
page 8
Séance 2:
Fonctions et variables
3.
Portée des variables
3.1
Notions de variables locales et globales
Nous avons déjà introduit dans plusieurs fonctions des variables qui n’étaient pas des paramètres de
la fonction. Par exemple, en écrivant les instructions suivantes dans l’éditeur de scripts, on crée la
fonction mensonge et la variable i :
i = 42
def mensonge ():
i = 10
print("i vaut ", i)
On passe après dans la console :
i
mensonge ()
i
La variable i créée dans la fonction mensonge est dite locale à la fonction. Son nom a peu d’importance : c’est une variable muette. Elle n’a rien à voir avec la variable de même nom i existant en dehors
de cette fonction. Python crée ces variables locales pour pouvoir exécuter la fonction mais les oublie
une fois la fonction terminée. Il est donc impossible d’accéder à une variable locale en dehors de la
fonction où elle est définie. Par contre, cela permet une plus grande liberté puisqu’il est alors possible
d’utiliser les mêmes noms de variables locales dans des fonctions différentes.
Les variables définies en dehors de toute fonction sont dites globales. Cela signifie que Python connait
les valeurs de ces variables tout au long du script et qu’il est donc possible d’y accéder à n’importe
quel niveau, c’est-à-dire à l’extérieur ou à l’intérieur d’une fonction. Mais attention, toute modification
de cette variable globale effectuée dans le corps d’une fonction n’a d’effet qu’à l’intérieur de la fonction.
Une fois sortie de la fonction, la variable globale reprend la valeur qu’elle avait avant la création de la
fonction.
Créer la fonction suivante.
def moinsa(z) :
b=z+a
# b et z sont des variables locales.
return b
Écrire alors dans la console :
a=2
moinsa (10)
b
b = 5
# b est une variable globale.
moinsa (15)
b
Quand on écrit moinsun(z), on crée une variable locale b. Quand on crée la variable globale b en
tapant b = 5 puis qu’on exécute la fonction, cela n’affecte pas la valeur de la variable globale b.
Lycée Pierre-Gilles de Gennes/ ENCPB 2016-2017
page 9
Séance 2:
3.2
Fonctions et variables
Commandes global et locals
• La commande global, à l’intérieur d’une fonction, permet de créer ou de modifier le contenu
d’une variable globale à l’intérieur du bloc d’instructions d’une fonction.
• À l’intérieur d’une fonction, la commande locals() demande à Python la liste des variables
locales (avec leurs valeurs).
Taper ceci dans l’éditeur de scripts :
i = 42
def ok(z):
global i
a = 7
b = 8 + z
i = 10
print(locals ())
print("i vaut ", i)
puis tester ceci dans la console :
i
a
ok(3)
i
a
4.
Exercices
-) Exercice 1 :
Écrire un script permettant l’échange de deux variables a et b :
1. en utilisant l’affectation simultanée (c’est-à-dire en écrivant (a, b) = (b, a)) ;
2. sans utiliser l’affectation simultanée.
-) Exercice 2 :
Écrire un programme qui prend en entrée deux paramètres a et b et qui renvoie la phrase : "La somme
de a et b est s et leur moyenne est m.", avec s la somme de a et b et m leur moyenne.
-) Exercice 3 :
Définir une fonction prenant en argument un temps exprimé en secondes et affichant ensuite ce temps
en jours, heures, minutes et secondes.
-) Exercice 4 :
1. Charger la bibliothèque random et se renseigner sur la fonction random.
2. Créer une variable D qui simule un dé, c’est-à-dire une commande qui génère aléatoirement un
entier entre 1 et 6 puis l’affecte à la variable D.
3. Simplifier la commande de la question précédente à l’aide de la fonction randint.
Lycée Pierre-Gilles de Gennes/ ENCPB 2016-2017
page 10