1
2
3
4
5
6
7
8
|
déf carré (x):
retour x**2
>> > carré
<fonction carré à 0x031AA230>
>>> dir(carré)
['__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__doc__', '__format__', '__get__', '__getattribute__', '__globals__', '__hash__', ' __init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__' , '__subclasshook__', 'func_closure' , 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']
>>> ;
|
Parmi eux, certains attributs de fonction importants sont les suivants :
1 __doc__ renvoie la chaîne de documentation de la fonction spécifiée.
1
2
3
4
5
6
|
def carré(x): """carré de retour du nombre donné""" retour x**2 >>> carré.__doc__
'carré de retour d'un nombre donné' |
2. __name__返回函数名字。
1
2
3
4
5
6
|
3. __module__返回函数定义所在模块的名字。
1
2
3
4
5
6
def carré(x) : """carré de retour du nombre donné""" retour x**2 >>> carré.__module__
'__main__' |
4. func_defaults renvoie un tuple contenant les valeurs de paramètres par défaut. Les paramètres par défaut seront discutés plus tard.
5. func_globals renvoie une référence de dictionnaire contenant des variables globales de fonction.
1
2
3
4
5
6
|
def carré(x): """carré de retour du nombre donné""" retour x**2 >>> carré.func_globaux
{' __builtins__' : <<🎜>module<🎜> <🎜>'__builtin__'<🎜> <🎜>(<🎜>construit<🎜>-<🎜>in<🎜>)<🎜>>, '__name__': '__main__', 'carré' : <<🎜>fonction <🎜>carré <🎜>à<🎜 > <🎜>0x10f099c08<🎜>>, '__doc__': Aucun, '__package__' : Aucun} |
6. func_dict返回支持任意函数属性的命名空间。
1
2
3
4
5
6
def carré(x) : """carré de retour du nombre donné""" retour x**2 >>> carré.func_dict
{} |
7. func_closure renvoie un tuple de corps de cellule, où le corps de cellule contient la liaison des variables libres de fonction. La fermeture sera discutée plus tard.
Les fonctions peuvent être transmises comme arguments à d'autres fonctions. Ces fonctions qui prennent d’autres fonctions comme arguments sont souvent appelées fonctions d’ordre supérieur et constituent une partie très importante de la programmation fonctionnelle. Un bon exemple de fonction d'ordre supérieur est la fonction map, qui prend une fonction et un itérateur comme arguments, applique la fonction à chaque élément de l'itérateur et renvoie une nouvelle liste. Nous allons le démontrer dans l'exemple suivant, où la fonction carrée définie précédemment et un itérateur numérique sont transmis à la fonction map.
1
2
|
>>> carte(carré, plage(10 )) [0, 1, 4, 9 , 16, 25, 36, 49, 64, 81]
|
De plus, les fonctions peuvent également être définies dans d'autres blocs de code de fonction et peuvent également être renvoyées à partir d'autres appels de fonction.
1
2
3
4
5
|
def extérieur() : outer_var = "variable externe" def intérieur() : retour outer_var retour intérieur |
Dans l'exemple ci-dessus, nous définissons une autre fonction interne à l'intérieur de la fonction externe, et lorsque la fonction externe est exécutée, la fonction interne sera renvoyée. De plus, comme tout autre objet Python, les fonctions peuvent également être affectées à des variables, comme ceci :
1
2
3
4
5
6
7
8
9
10
|
def extérieur () : retour var_outer retour intérieur >>> func = extérieur( ) >>> func <<🎜>fonction <🎜>intérieur <🎜>à<🎜> <🎜 > 0x031AA270<🎜>> >>> |
Dans l'exemple ci-dessus, lorsque la fonction externe est appelée, elle renverra une fonction et affectera la fonction renvoyée à la variable func. Enfin, la variable peut être appelée tout comme la fonction renvoyée :
1
2
|
>>> func() 'variable externe' | tbody>
1
2
|
def square(x):
return x**2
|
1 2
|
def carré(x) : retour x**2 |
Dans la fonction carrée ci-dessus, lorsque le module contenant la fonction est chargé dans l'interpréteur Python, ou si la fonction est définie dans le REPL Python, l'instruction de définition de fonction sera exécutée def carré(x). Cependant, cela a certaines implications pour les paramètres par défaut avec des structures de données mutables comme valeurs, que nous aborderons plus tard. L'exécution de la définition de fonction liera le nom de la fonction dans l'espace de noms local actuel (l'espace de noms peut être considéré comme un mappage du nom à la valeur, et ce mappage peut également être imbriqué. Les espaces de noms et les portées seront détaillés dans un autre didacticiel) Introduit) à un objet fonction, qui est un wrapper autour du code exécutable dans une fonction. Cet objet fonction contient une référence à l'espace de noms global actuel, qui fait référence à l'espace de noms global utilisé lors de l'appel de la fonction. De plus, la définition de fonction n'exécute pas le corps de la fonction, qui ne s'exécute que lorsque la fonction est appelée.
Paramètres d'appel de fonction
En plus des paramètres normaux, les fonctions Python prennent également en charge un nombre variable de paramètres. Ces paramètres se répartissent principalement en trois catégories décrites ci-dessous :
1. Valeurs des paramètres par défaut : Cela permet à l'utilisateur de définir certaines valeurs par défaut pour les paramètres de la fonction. Dans ce cas, la fonction peut être appelée avec moins d'arguments. Pour les arguments non fournis lors de l'appel de la fonction, Python utilisera les valeurs fournies par défaut comme valeurs d'argument. L'exemple suivant illustre cette utilisation :
1
2
|
def show_args(arg, def_arg=1, def_arg2=2) : retour "arg={}, def_arg={}, def_arg2={}". format(arg, def_arg, def_arg2) |
La définition de l'exemple de fonction ci-dessus contient un paramètre de position normale arg et deux paramètres par défaut def_arg et def_arg2. Cette fonction peut être appelée de l'une des manières suivantes :
(1) Seules les valeurs de paramètres de position autres que celles par défaut sont fournies. Dans cet exemple, les paramètres par défaut prennent les valeurs par défaut :
1
2
3
4
5
|
def show_args(arg, def_arg=1, def_arg2=2) : retour "arg={}, def_arg={}, def_arg2={}".format(arg, def_arg, def_arg2) >> ;> show_args("tranquillité")
'arg=tranquilité, def_arg=1, def_arg2=2' |
(2) Remplacez certaines valeurs de paramètres par défaut par les valeurs fournies, y compris les paramètres de position non par défaut :
1
2
3
4
5
|
def show_args(arg, def_arg =1, def_arg2=2): retour "arg={}, def_arg ={}, def_arg2={}".format (arg, def_arg, def_arg2 ) >>> show_args("tranquillité", "vers Houston")
'arg=tranquilité, def_arg=à Houston, def_arg2=2' |
(3) Fournissez des valeurs pour tous les paramètres, qui peuvent être utilisées pour remplacer les valeurs des paramètres par défaut :
1
2
3
4
5
|
def show_args(arg, def_arg=1, def_arg2=2) : retour "arg={}, def_arg={} , def_arg2={}".format(arg, def_arg, def_arg2) >>> show_args("tranquillité", "à Houston", "l'aigle a atterri")
'arg=tranquillité, def_arg=à Houston, def_arg2=l'aigle a atterri' |
Des précautions particulières doivent être prises lors de l'utilisation de structures de données par défaut mutables comme paramètres par défaut. Étant donné que la définition de la fonction n'est exécutée qu'une seule fois, ces structures de données mutables (valeurs de référence) ne sont créées qu'une seule fois lorsque la fonction est définie. Cela signifie que la même structure de données mutable sera utilisée pour tous les appels de fonction, comme indiqué dans l'exemple suivant :
1
2
3
4
5
6
7
8
|
Dans chaque appel de fonction, "Hello World" est ajouté à la liste def_arg Après avoir appelé la fonction deux fois, il y aura deux caractères "Hello World" dans l'argument par défaut. Ceci est important à noter lors de l’utilisation de paramètres par défaut variadiques comme valeurs par défaut. Les raisons de cela deviendront claires lorsque nous discuterons du modèle de données Python.
2. Paramètres de mots-clés : Vous pouvez également appeler des fonctions en utilisant des paramètres de mots-clés sous la forme "kwarg=value". Parmi eux, kwarg fait référence au nom du paramètre utilisé dans la définition de la fonction. Prenons comme exemple la fonction définie ci-dessous avec des paramètres par défaut et autres que ceux par défaut :
1
2
|
def show_args(arg, def_arg= 1) : retour "arg={}, def_arg={}".format(arg, def_arg) |
Pour démontrer l'appel d'une fonction à l'aide d'arguments de mots-clés, la fonction suivante peut être appelée de l'une des manières suivantes :
1
|
show_args
( arg="test"
|
1 |
show_args(test)
|
1 |
show_args(test)
|
1
|
show_args
(arg= "test"
|
1 |
show_args("test", 3)
|
1 |
show_args("test", 3 ) |
Dans un appel de fonction, les arguments de mot-clé ne doivent pas précéder les arguments non-mot-clé, donc l'appel suivant échouera :
1
|
show_args
( def_arg= 4) |
1 |
show_args("test", arg="testing")
|
1 |
show_args("test", arg= "tests") |
1
show_args (def_arg="tests", arg ="test") |
3. Liste de paramètres arbitraires : Python prend également en charge la définition d'une telle fonction, qui peut accepter n'importe quel nombre de paramètres passés sous forme de tuples, tutoriel Python Un exemple. de ceci ressemble à ceci :
1
2
|
def write_multiple_items(fichier, séparateur, *args) : fichier.écrire(séparateur.rejoindre (args)) |
N'importe quel nombre d'arguments doit suivre les arguments normaux. Dans cet exemple, un nombre illimité de paramètres existent après le fichier de paramètres et le séparateur. Voici un exemple d'appel de la fonction définie ci-dessus :
1
2
|
f = ouvrir( "test.txt", "wb") write_multiple_items(f, " ", "un", "deux", "trois", "quatre", "cinq") |
Les paramètres ci-dessus un, deux, trois, quatre et cinq sont regroupés pour former un tuple, accessible via le paramètre args.
Décompresser les paramètres de fonction
Parfois, les paramètres d'un appel de fonction peuvent exister sous la forme de tuples, de listes ou de dictionnaires. Ces paramètres peuvent être décompressés dans la fonction pour être invoqués à l'aide des opérateurs "*" ou "**". Prenons l'exemple de la fonction suivante. Cette fonction accepte deux paramètres de position et imprime les valeurs des deux paramètres.
1
2
3
|
def print_args(a, b) : imprimer a imprimer b |
Si les valeurs des paramètres fournies à la fonction sont sous forme de liste, alors nous pouvons décompresser ces valeurs directement dans la fonction, comme suit :
1
2
3
4
>> > ; args = [1 , 2 ] >>> print_args(*args) 1 2 |
De même, lorsque nous avons des mots-clés, nous pouvons utiliser un dictionnaire pour stocker la relation de mappage de kwarg à valeur, et utiliser l'opérateur "**" pour décompresser les paramètres du mot-clé dans la fonction. , comme suit :
1
2
3
4
5
6
7
8
|
>>> def perroquet (tension, état='a raide', action='voom'):
imprimer "-- Ce perroquet ne le ferait pas" , action,
imprimer "si tu mets", tension, "volts à travers.",
🎜>, état, "!"
>>> d = {"tension": "quatre millions", "état" : "sanglanté", "action " : "VOOM"}
>>> perroquet(**d)
>>> Ce perroquet ne't VOOM si vous mettez quatre millions volts à travers il. E's saignement' décédé
|
利用“*”和“**”定义函数
有时候,当定义一个函数时,我们之前可能不知道参数的数量。这就导致了下面签名的函数定义:
1
|
show_args(arg, *args, **kwargs)
Le paramètre "*args" représente la longueur de séquence de paramètres de position inconnue, tandis que "**kwargs" représente un dictionnaire contenant des relations de mappage de mots-clés et de valeurs, qui peuvent contenir n'importe quel nombre de mots-clés et mappage de valeurs et "*args" doit précéder "**kwargs" dans la définition de la fonction. Le code suivant illustre cette situation :
Les paramètres normaux doivent être fournis à la fonction, mais "*args" et "**kwargs" sont facultatifs, comme indiqué ci-dessous :
Dans les appels de fonction, les paramètres ordinaires sont fournis de la manière normale, tandis que les paramètres facultatifs peuvent être atteints dans l'appel de fonction sous forme décompressée. Fonctions anonymesPython prend également en charge les fonctions anonymes, qui sont créées à l'aide du mot-clé lambda. La forme d'une expression Lambda en Python est la suivante :
Une expression Lambda renvoie un objet fonction évalué et possède les mêmes propriétés que la fonction nommée. En Python, les expressions Lambda ne sont généralement utilisées que pour des fonctions très simples, comme ceci :
L'expression lambda ci-dessus fait la même chose que la fonction nommée ci-dessous : 1
2
def carré(x): retour x**2 |
Fonctions et fermetures imbriquées
Définir une fonction à l'intérieur d'une fonction crée une fonction imbriquée, comme indiqué ci-dessous :
1
2
3
4
5
6
7
|
```python def extérieur() : outer_var = "variable externe" retour outer_var retour intérieur ``` |
Dans ce type de définition de fonction, la fonction interne n'est valide qu'à l'intérieur de la fonction externe, donc lorsque la fonction interne doit être renvoyée (déplacée vers la portée externe) ou passée à une autre Lorsque vous travaillez avec des fonctions, il est souvent pratique d'utiliser des fonctions imbriquées. Dans la fonction imbriquée ci-dessus, une nouvelle instance de fonction imbriquée est créée à chaque fois que la fonction externe est appelée, car la définition de la fonction interne est exécutée à chaque fois que la fonction externe est exécutée et son corps de fonction ne sera pas exécuté.
Une fonction imbriquée a accès à l'environnement dans lequel elle a été créée, ce qui est le résultat direct de la sémantique de définition de fonction de Python. Une conséquence est que les variables définies dans la fonction externe peuvent être référencées dans la fonction interne, même après que la fonction externe a terminé son exécution.
1
2 3
4
5
6
7
8
9
10
11
|
def extérieur():
var_extérieur = "variable externe"
def intérieur():
retour outer_var
retour intérieur
> ;>> x = extérieur ()
>>> x
<fonction intérieure à 0x0273BCF0>
>>> x()
'variable externe'
|
Lorsque la fonction imbriquée interne fait référence à la variable dans l'extérieur function Quand , on dit que la fonction imbriquée est fermée par rapport à la variable de référence. Nous pouvons accéder à cette variable incluse en utilisant un attribut spécial "__closure__" de l'objet fonction, comme suit :
1
2
3
4
5
6
|
>>> cl = x.__closure__>>> cl(<<🎜><🎜>cellule <🎜>à<🎜> <🎜 > <🎜>0x029E4470<🎜><🎜>:<🎜><🎜> <🎜>str<🎜><🎜> <🎜 >objet<🎜><🎜> <🎜>à<🎜><🎜> <🎜>0x02A0FD90<🎜><🎜>>,) >>> > cl[0].cellule_contenu'variable externe'
Les fermetures en Python ont un comportement étrange. Dans Python 2.x et versions antérieures, les variables pointant vers des types immuables (tels que des chaînes et des nombres) ne peuvent pas être renvoyées dans les fermetures. L'exemple suivant illustre cela :
Une solution plutôt peu fiable consiste à utiliser un type mutable pour capturer la fermeture, comme ceci :
|