[wiki: Fonctions] [#license ©]
Définir une nouvelle fonction
- Une fonction est définie par le mot-clé « def », suivit du nom de la fonction, de ses arguments entre parenthèse, et de « : ».
- Si pas de return, la fonction retourne None.
- On peut retourner explicitement une séquence, par exemple une série de résultats séparés par des virgules, qui seront groupés dans un tuple.
>>> def divs(x,y):
... res1 = x/y
... res2 = x//y
... return res1, res2
...- Une fonction est un objet appelable, que l’on exécute en appliquant des parenthèses (même vides).
>>> print(divs)
<function divs at ...>
>>> divs(2.,3.)
(0.6666666666666666, 0.0)
>>> res1
NameError: name 'res1' is not defined
- Les variables affectées sont des variables locales à la fonction.
>>> a = 1
>>> def f():
... a = 2
... print(a)
...
>>> f()
2
>>> def g():
... print(a)
...
>>> g()
1
- Ce n’est pas une pratique recommandée, mais si vous souhaitez faire des affectations à une variable extérieure à la fonction, vous pouvez la déclarer globale :
>>> def h():
... global a
... a = 3
...
>>> h()
>>> print(a)
3
Arguments par défaut
- On peut fournir des valeurs par défaut, en commençant par les derniers arguments.
- L’expression qui fournit la valeur par défaut est évaluée lors de la définition de la fonction
>>> i = 5
>>> def f(arg=i):
... return arg
>>> i = 6
>>> f()
5
- ATTENTION DANGER : evitez d’utiliser une valeur par defaut modifiable, car elle n’est évaluée qu’une seule fois puis réutilisée…
>>> def f(a, L=[]):
... L.append(a)
... return L
>>> for i in range(3):
... print f(i)
[0]
[0, 1]
[0, 1, 2]
Arguments nommés
- Lors d’un appel de fonction, on peut placer des arguments nommés en fin de liste.
>>> def test(s, i=2):
... print s, i
>>> test('abc', 1)
abc 1
>>> test('abc', i=1)
abc 1
>>> test(s='abc', i=1)
abc 1
>>> test(i=1, s='abc')
abc 1
>>> test(s='abc')
abc 2
Arguments non prédéfinis
- Dans une definition de fonction, l’auteur peut prévoir une variable spéciale pour recueillir une liste d’arguments non prédéfinis, préfixée
*. - L’auteur peut aussi prévoir une variable spéciale, préfixée
**et placée en dernier, pour recueillir les arguments nommés non prédéfinis.
>>> def func(n,*args,**kw):
... print 'n:', n
... print 'args:', args
... print 'kwargs:', kw
...
>>> func(1,2,3,4,a=5, b=6)
n: 1
args: (2, 3, 4)
kwargs: {'a': 5, 'b': 6}
- On peut aussi utiliser
*et**pour « dépaquetter » un tuple ou un dictionnaire dans un appel de fonction.
>>> x = (3, 4)
>>> y = {'a': 5, 'b': 6}
>>> func(1,2,*x,**y)
n: 1
args: (2, 3, 4)
kwargs: {'a': 5, 'b': 6}
>>> func(1,2,x,y)
n: 1
args: (2, (3, 4), {'a': 5, 'b': 6})
kwargs: {}
Fonctions intégrées (builtin)
#!python
print(values[,sep=' '][,end='\n'])
input([prompt])
round(x[, n=0])
type(obj) dir([object]) help([object]) repr(obj)
hasttr(object,attribut) isinstance(object,class)
globals() locals() eval(expression)
range([start=0],stop[,step=1])
len(seq) reversed(seq) sorted(seq)
sum(iterable)
#!comment
dir([object]) Retourne une liste des toutes les méthodes et attributs de object s’il est fourni, sinon retourne une liste de tous les objects du contexte courant. Cette fonction est essentiellement utilisée dans l’interpréteur interactif pour tester les objets.
eval(expression) Cette fonction analyse et exécute expression (qui doit être une chaine).
globals() Retourne un dictionnaire représentant les variables présente dans le contexte global.
hasttr(object, attribut) Retourne True si l’objet possède l’attribut en question.
help([object]) Affiche l’aide au sujet d’un objet si object est fourni, sinon affiche l’aide générale. Cette fonction est destinée à être utilisée dans l’interpréteur interactif.
input([prompt]) Si le paramètre prompt est fourni, alors il sera affiché sur la sortie standard. Dans tous les cas, la fonction lit une ligne écrite (dont saisie est interrompue par la touche entrée) et la retourne sous forme de chaine.
isinstance(object, class) Retourne True si object est une instance de class. class peut aussi être un tuple contenant plusieurs classes, et la fonction retournera True si object est une instance de l’un d’entre eux. Il s’agit de LA manière la plus correcte de vérifier le type d’un objet.
len(seq) Retourne la longueur de la séquence seq.
locals() Fait de même que globals(), mais avec le contexte local.
PYTHON 3 : print([obj1, ..., objn][, sep=' '][, end='\n']) Affiche obj1 jusque objn, séparés par sep, en ajoutant end à la fin. sep et end doivent être des chaines.
range([start=0], stop[, step=1]) Retourne un objet range, qui est un objet itérable équivalent à une liste d’entiers, commençant à start et finissant à end - 1, et séparés par le pas sep.
repr(obj) Affiche la représentation (définie par la méthode repr() de obj.
reversed(seq) Retourne l’inverse de la séquence passée en argument. Ceci est équivalent à seq.reverse(), exceptée que cette fonction retourne un nouvel objet, et peut donc être utilisée dans une boucle for.
round(x[, n=0]) Arrondit x à n décimales.
sorted(seq) Retourne une séquence triée à partir de seq. Cette fonction est équivalent à appeler la méthode seq.sort(), excepté le fait qu’elle retourne un nouvel objet (comme reversed()).
sum(iterable) Permet de sommer un itérable contenant uniquement des entiers.
type(obj) Cette fonction retourne la classe de obj. Elle ne devrait être utilisée que dans l’interpréteur interactif.Exercices
1. Écrire une fonction qui permet de convertir des francs en euros. (1€ = 6.55957F).
1. Écrire une fonction qui calcule le périmètre d’un cercle de rayon R (qui sera donc l’argument). Pour rappel : le périmètre est P = 2×π×R. On pourra prendre π = 3.14 ou, mieux, chercher un module qui contient ce nombre et l’utiliser.
import math
math.pi1. Écrire une fonction qui prend en argument un nombre n et qui calcule n! (n factorielle), sans utiliser la récursivité. Rappel : n! correspond à la multiplication des n premiers entiers avec la convention que 0! = 1. Ainsi, par exemple, 4! = 1×2×3×4 = 24.
1. Écrire une fonction qui prend deux arguments, l’un d’eux étant une fonction. La première fonction doit appliquer la fonction passée en argument au second argument, et renvoyer le résultat.
1. Écrire une fonction qui prend une date de naissance en argument et qui retourne le nombre de jours écoulés depuis.On pensera aux années bissextiles ; une année est bissextile si : elle est divible par 4 mais par par 100, elle est divisible par 400. On pourra utiliser le module datetime pour obtenir la date du jour courant automatiquement :
from datetime import datetime
today = datetime.today()
today = today.day, today.month, today.yearRéférences
© David Chamont, Laboratoire Leprince-Ringuet (LLR) / IN2P3 / CNRS, Ecole polytechnique / Université Paris-Saclaybr
© Ce(tte) œuvre est mise à disposition selon les termes de la Licence Creative Commons Attribution – Partage dans les Mêmes Conditions 4.0 International [=#license]