Cet article décrit comment définir et appeler (exécuter) des fonctions en Python.
- Principes de base de la définition et de l’appel de fonction en Python
- Arguments positionnels et mots-clés
- Argument positionnel
- Argument de mot-clé
- Argument de position/mot-clé uniquement
- Argument par défaut
- Argument de longueur variable
- *args : reçoit plusieurs arguments sous forme de tuple
- **kwargs : recevez plusieurs arguments de mots clés sous forme de dictionnaire
- Décompressez les listes et les dictionnaires
- Valeur de retour
- Les bases du retour
- Fonction à renvoyer Aucune
- Spécifiez plusieurs valeurs de retour
Consultez l’article suivant pour les expressions lambda utilisées pour créer des fonctions anonymes.
La documentation officielle pour la définition de la fonction est :
Principes de base de la définition et de l’appel de fonction en Python
En Python, les fonctions sont définies avec des instructions def. Les paramètres sont spécifiés entre parenthèses (), et la valeur de retour est spécifiée avec return.
def function_name(param1, param2...):
do_something
return return_value
Lors de l’appel de la fonction définie, écrivez comme suit :
function_name(arg1, arg2...)
Exemple:
def add(a, b):
x = a + b
return x
x = add(3, 4)
print(x)
# 7
Les paramètres et les valeurs de retour par retour peuvent être omis s’ils ne sont pas nécessaires.
def hello():
print('Hello')
hello()
# Hello
Les détails sur les arguments et les valeurs de retour sont décrits ci-dessous.
Notez que bien qu’il soit recommandé de laisser deux lignes avant et après le bloc def dans la norme de codage Python PEP8, une seule ligne est laissée pour plus de commodité dans l’exemple de code.
Arguments positionnels et mots-clés
Les paramètres sont définis en les séparant par des virgules entre parenthèses de function_name(). L’exemple est une fonction simple qui génère les arguments tels quels, en utilisant la f-string.
def func(a, b, c):
print(f'a={a}, b={b}, c={c}')
Argument positionnel
Lors de l’appel, indiquez les valeurs dans l’ordre défini.
func(1, 10, 100)
# a=1, b=10, c=100
Si le nombre de valeurs spécifiées lors de l’appel de la fonction ne correspond pas au nombre de paramètres lors de la définition de la fonction, TypeError se produit.
# func(1)
# TypeError: func() missing 2 required positional arguments: 'b' and 'c'
# func(1, 10, 100, 1000)
# TypeError: func() takes 3 positional arguments but 4 were given
Argument de mot-clé
Vous pouvez spécifier une valeur sous la forme nom_paramètre=valeur lors de l’appel d’une fonction. Dans ce cas, ils peuvent être spécifiés dans n’importe quel ordre.
func(b=10, c=100, a=1)
# a=1, b=10, c=100
Tous les arguments n’ont pas besoin d’être spécifiés par des mots clés. Vous pouvez les spécifier par position puis par mot clé. Cependant, après avoir été spécifiés par des mots-clés, tous les arguments doivent être spécifiés par des mots-clés.
func(1, c=100, b=10)
# a=1, b=10, c=100
# func(a=1, 10, 100)
# SyntaxError: positional argument follows keyword argument
Argument de position/mot-clé uniquement
Argument positionnel uniquement (Python 3.8 ou version ultérieure)
Si / est utilisé comme paramètre lors de la définition d’une fonction, le paramètre avant / est défini comme positionnel uniquement.
Les paramètres positionnels uniquement ne peuvent pas être passés par mot-clé. Les paramètres suivant le / peuvent être passés par mot-clé.
def func_pos_only(a, b, /, c):
print(f'a={a}, b={b}, c={c}')
# func_pos_only(a=1, b=10, c=100)
# TypeError: func_pos_only() got some positional-only arguments passed as keyword arguments: 'a, b'
func_pos_only(1, 10, 100)
# a=1, b=10, c=100
func_pos_only(1, 10, c=100)
# a=1, b=10, c=100
Si vous définissez une fonction avec / à la fin, telle que func(a, b, c, /), tous les paramètres sont positionnels uniquement.
Le paramètre positionnel uniquement utilisant / est introduit dans Python 3.8 et n’est pas disponible dans les versions antérieures.
Argument de mot clé uniquement
Si * est utilisé comme paramètre lors de la définition d’une fonction, le paramètre après * est défini comme mot-clé uniquement.
Les paramètres spécifiques aux mots-clés doivent être spécifiés par mot-clé. Les paramètres avant * peuvent être spécifiés par position ou mot-clé.
def func_kw_only(a, b, *, c):
print(f'a={a}, b={b}, c={c}')
# func_kw_only(1, 10, 100)
# TypeError: func_kw_only() takes 2 positional arguments but 3 were given
func_kw_only(1, 10, c=100)
# a=1, b=10, c=100
func_kw_only(1, c=100, b=10)
# a=1, b=10, c=100
Si vous définissez une fonction avec * au début, telle que func(*, a, b, c), tous les paramètres sont uniquement des mots-clés.
Argument de position uniquement et argument de mot clé uniquement
Il est possible d’utiliser / et * en même temps. Les paramètres avant / ne concernent que la position et les paramètres après * ne concernent que les mots clés. Les paramètres entre / et * peuvent être positionnels ou mot-clé.
def func_pos_kw_only(a, /, b, *, c):
print(f'a={a}, b={b}, c={c}')
# func_pos_kw_only(1, 10, 100)
# TypeError: func_pos_kw_only() takes 2 positional arguments but 3 were given
# func_pos_kw_only(a=1, b=10, c=100)
# TypeError: func_pos_kw_only() got some positional-only arguments passed as keyword arguments: 'a'
func_pos_kw_only(1, 10, c=100)
# a=1, b=10, c=100
func_pos_kw_only(1, c=100, b=10)
# a=1, b=10, c=100
Vous ne pouvez pas utiliser / avant *.
# def func_pos_kw_only(a, *, b, /, c):
# print(f'a={a}, b={b}, c={c}')
# SyntaxError: invalid syntax
Argument par défaut
La valeur par défaut du paramètre peut être définie en définissant parameter_name=default_value lors de la définition de la fonction.
Si la valeur par défaut est définie, vous pouvez omettre l’argument lors de l’appel de la fonction. Bien sûr, si vous spécifiez une autre valeur, cette valeur sera utilisée.
def func_default(a, b, c=100):
print(f'a={a}, b={b}, c={c}')
func_default(1, 10)
# a=1, b=10, c=100
func_default(1, 10, 200)
# a=1, b=10, c=200
Placer un paramètre par défaut avant un paramètre ordinaire (paramètres sans valeur par défaut) à la définition de la fonction provoque une SyntaxError.
# def func_default(a=1, b, c=100):
# print(f'a={a}, b={b}, c={c}')
# SyntaxError: non-default argument follows default argument
Notez que si vous utilisez un objet modifiable tel qu’une liste ou un dictionnaire comme valeurs par défaut, les mêmes objets seront toujours utilisés lors de l’appel d’une fonction. Voir l’article suivant pour plus de détails.
Argument de longueur variable
Si vous ajoutez * et ** aux noms de paramètre lors de la définition d’une fonction, il devient un paramètre de longueur variable et vous pouvez spécifier n’importe quel nombre d’arguments lors de l’appel d’une fonction.
Par convention, les noms *args et **kwargs sont souvent utilisés, mais tant que * et ** sont dirigés, il n’y a aucun problème avec d’autres noms.
*args : reçoit plusieurs arguments sous forme de tuple
Si vous mettez * au début du nom, plusieurs arguments seront reçus sous forme de tuple.
def func_args(*args):
print(args)
func_args(1, 10)
# (1, 10)
func_args(1, 10, 100, 1000)
# (1, 10, 100, 1000)
**kwargs : recevez plusieurs arguments de mots clés sous forme de dictionnaire
Si vous mettez ** au début du nom, plusieurs arguments de mots clés seront reçus sous forme de dictionnaire (dict).
def func_kwargs(**kwargs):
print(kwargs)
func_kwargs(a=1, b=10)
# {'a': 1, 'b': 10}
func_kwargs(c=1, b=10, d=1000, a=100)
# {'c': 1, 'b': 10, 'd': 1000, 'a': 100}
Faites attention à l’ordre lorsque vous combinez avec des arguments positionnels ou avec *args et **kwargs. Voir l’article suivant pour plus de détails.
Décompresser les listes, les tuples et les dictionnaires
Déballer des listes ou des tuples
Si vous ajoutez * à une liste ou à un tuple lors de l’appel d’une fonction, les éléments sont décompressés et spécifiés en tant qu’arguments positionnels. TypeError est déclenché si le nombre d’éléments et le nombre d’arguments ne correspondent pas.
def func(a, b, c):
print(f'a={a}, b={b}, c={c}')
l = [1, 10, 100]
func(*l)
# a=1, b=10, c=100
l = [1, 10]
# func(*l)
# TypeError: func() missing 1 required positional argument: 'c'
Déballer les dictionnaires
Si vous ajoutez ** au dictionnaire lors de l’appel d’une fonction, ses clés et ses valeurs sont décompressées en tant que noms et valeurs des arguments et spécifiées en tant qu’arguments de mots-clés. S’il n’y a pas assez de clés pour correspondre au nom de l’argument, ou s’il y a des clés qui ne correspondent pas, TypeError est déclenché.
d = {'a': 1, 'b': 10, 'c': 100}
func(**d)
# a=1, b=10, c=100
d = {'a': 1, 'b': 10, 'x': 100}
# func(**d)
# TypeError: func() got an unexpected keyword argument 'x'
Pour plus d’informations, consultez l’article suivant.
Valeur de retour
Les bases du retour
La valeur de retour de la fonction est spécifiée par l’instruction return.
def func_return(a, b):
return a + b
x = func_return(3, 4)
print(x)
# 7
print(type(x))
# <class 'int'>
Le type de valeur de retour dépend du type d’argument et du traitement effectué par la fonction.
x = func_return(0.3, 0.4)
print(x)
# 0.7
print(type(x))
# <class 'float'>
Fonction à renvoyer Aucune
return n’est pas obligatoire dans une fonction et peut être omis s’il n’est pas nécessaire de renvoyer une valeur.
Une fonction qui omet return renvoie None. Dans l’exemple suivant, pass est utilisé car une erreur est déclenchée si rien n’est écrit dans le bloc def.
def func_none():
# do something
pass
x = func_none()
print(x)
# None
Si vous omettez la valeur après return, None est renvoyé.
def func_none2():
return
x = func_none2()
print(x)
# None
Bien sûr, vous pouvez explicitement écrire return None.
def func_none3():
return None
x = func_none3()
print(x)
# None
Spécifiez plusieurs valeurs de retour
Spécifier plusieurs valeurs séparées par des virgules après return renverra un tuple.
def func_return_multi(a, b):
return a + b, a * b, a / b
x = func_return_multi(3, 4)
print(x)
# (7, 12, 0.75)
print(type(x))
# <class 'tuple'>
Il est possible de déballer chaque valeur et de l’affecter à chaque variable.
x, y, z = func_return_multi(3, 4)
print(x)
# 7
print(y)
# 12
print(z)
# 0.75