1
2
3
4
5
6
7
8
|
def Quadrat (x):
zurück x**2
>> > Quadrat
<Funktion Quadrat um 0x031AA230>
>>> dir(Quadrat)
['__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']
>>> ;
|
Dazu gehören einige wichtige Funktionsattribute:
1. __doc__ gibt die Dokumentationszeichenfolge der angegebenen Funktion zurück.
1
2
3
4
5
6
|
def quadratisch(x): """gibt das Quadrat der gegebenen Zahl zurück""" return x**2 >>> quadratisch.__doc__
'Rückgabequadrat der gegebenen Zahl' |
2. __name__返回函数名字.
1
2
3
4
5
6
|
3. __module__返回函数定义所在模块的名字.
1
2
3
4
5
6
def quadratisch(x): """gibt das Quadrat der angegebenen Zahl zurück""" return x**2 >>> quadratisch.__module__
'__main__' |
4. func_defaults gibt ein Tupel mit Standardparameterwerten zurück. Standardparameter werden später besprochen.
5. func_globals gibt eine Wörterbuchreferenz zurück, die globale Funktionsvariablen enthält.
1
2
3
4
5
6
|
def quadratisch(x): """gibt das Quadrat der gegebenen Zahl zurück""" return x**2 >>> quadratisch.func_globals
{' __builtins__': <<🎜>module<🎜> <🎜>'__builtin__'<🎜> <🎜>(<🎜>gebaut<🎜>-<🎜>in<🎜>)<🎜>>, '__name__': '__main__', 'square': <<🎜>Funktion <🎜>Quadrat <🎜>at<🎜 > <🎜>0x10f099c08<🎜>>, '__doc__': Keine, '__package__': Keine} |
6. func_dict返回支持任意函数属性的命名空间.
1
2
3
4
5
6
def quadratisch(x): """gibt das Quadrat der angegebenen Zahl zurück""" return x**2 >>> quadratisch.func_dict
{} |
7. func_closure gibt ein Zellkörper-Tupel zurück, wobei der Zellkörper die Bindung funktionsfreier Variablen enthält. Auf den Abschluss wird später eingegangen.
Funktionen können als Argumente an andere Funktionen übergeben werden. Diese Funktionen, die andere Funktionen als Argumente verwenden, werden oft als Funktionen höherer Ordnung bezeichnet und bilden einen sehr wichtigen Teil der funktionalen Programmierung. Ein gutes Beispiel für eine Funktion höherer Ordnung ist die Map-Funktion, die eine Funktion und einen Iterator als Argumente akzeptiert, die Funktion auf jedes Element im Iterator anwendet und eine neue Liste zurückgibt. Wir werden dies im folgenden Beispiel demonstrieren, in dem die zuvor definierte Quadratfunktion und ein numerischer Iterator an die Kartenfunktion übergeben werden.
1
2
|
>>> Karte(quadratisch, range(10 )) [0, 1, 4, 9 , 16, 25, 36, 49, 64, 81]
|
Darüber hinaus können Funktionen auch innerhalb anderer Funktionscodeblöcke definiert werden und auch von anderen Funktionsaufrufen zurückgegeben werden.
1
2
3
4
5
|
def outer(): outer_var = "äußere Variable" def inner(): return outer_var return inner |
Im obigen Beispiel definieren wir eine weitere innere Funktion innerhalb der äußeren Funktion, und wenn die äußere Funktion ausgeführt wird, wird die innere Funktion zurückgegeben. Darüber hinaus können Funktionen wie jedes andere Python-Objekt auch Variablen zugewiesen werden, wie folgt:
1
2
3
4
5
6
7
8
9
10
|
def outer (): return outer_var return inner >>> func = outer( )
>>> func <<🎜>Funktion <🎜>inner <🎜>at<🎜> <🎜 > 0x031AA270<🎜>> >>> |
Im obigen Beispiel gibt die äußere Funktion beim Aufruf eine Funktion zurück und weist die zurückgegebene Funktion der Variablen func zu. Schließlich kann die Variable genau wie die zurückgegebene Funktion aufgerufen werden:
1
2
|
>>> func() 'outer variable' | tbody>
1
2
|
def square(x):
return x**2
|
1 2
|
def quadratisch(x): return x**2 |
In der obigen Quadratfunktion wird die Funktionsdefinitionsanweisung def ausgeführt, wenn das Modul, das die Funktion enthält, in den Python-Interpreter geladen wird oder wenn die Funktion in der Python-REPL definiert ist Quadrat(x). Dies hat jedoch einige Auswirkungen auf Standardparameter mit veränderlichen Datenstrukturen als Werten, auf die wir später eingehen werden. Durch die Ausführung der Funktionsdefinition wird der Funktionsname an den aktuellen lokalen Namespace gebunden (der Namespace kann als Zuordnung von Name zu Wert betrachtet werden, und diese Zuordnung kann auch verschachtelt werden. Namespaces und Bereiche werden in einem anderen Tutorial detailliert beschrieben. Eingeführt) zu einem Funktionsobjekt, das einen Wrapper um den ausführbaren Code in einer Funktion darstellt. Dieses Funktionsobjekt enthält einen Verweis auf den aktuellen globalen Namespace, der auf den globalen Namespace verweist, der beim Aufruf der Funktion verwendet wurde. Darüber hinaus führt die Funktionsdefinition nicht den Funktionskörper aus, der nur ausgeführt wird, wenn die Funktion aufgerufen wird.
Funktionsaufrufparameter
Python-Funktionen unterstützen neben normalen Parametern auch eine variable Anzahl von Parametern. Diese Parameter fallen hauptsächlich in drei Kategorien, wie unten beschrieben:
1. Standardparameterwerte: Dies ermöglicht dem Benutzer, einige Standardwerte für die Parameter der Funktion zu definieren. In diesem Fall kann die Funktion mit weniger Argumenten aufgerufen werden. Für Argumente, die beim Aufruf der Funktion nicht angegeben werden, verwendet Python die bereitgestellten Standardwerte als diese Argumentwerte. Das folgende Beispiel veranschaulicht diese Verwendung:
1
2
|
def show_args(arg, def_arg=1, def_arg2=2) : return "arg={}, def_arg={}, def_arg2={}". format(arg, def_arg, def_arg2) |
Die Definition der obigen Beispielfunktion enthält einen normalen Positionsparameter arg und zwei Standardparameter def_arg und def_arg2. Diese Funktion kann auf eine der folgenden Arten aufgerufen werden:
(1) Es werden nur nicht standardmäßige Positionsparameterwerte bereitgestellt. In diesem Beispiel nehmen die Standardparameter die Standardwerte an:
1
2
3
4
5
|
def show_args(arg, def_arg=1, def_arg2=2) : zurück "arg={}, def_arg={}, def_arg2={}".format(arg, def_arg, def_arg2) >> ;> show_args("tranquility")
'arg=tranquility, def_arg=1, def_arg2=2' |
(2) Überschreiben Sie einige Standardparameterwerte mit den bereitgestellten Werten, einschließlich nicht standardmäßiger Positionsparameter:
1
2
3
4
5
|
def show_args(arg, def_arg =1, def_arg2=2): return "arg={}, def_arg ={}, def_arg2={}".format (arg, def_arg, def_arg2 ) >>> show_args("tranquility", "to Houston")
'arg=tranquility, def_arg=to Houston, def_arg2=2' |
(3) Geben Sie Werte für alle Parameter an, die zum Überschreiben der Standardparameterwerte verwendet werden können:
1
2
3
4
5
|
def show_args(arg, def_arg=1, def_arg2=2): return "arg={}, def_arg={} , def_arg2={}".format(arg, def_arg, def_arg2) >>> show_args("tranquility", "nach Houston", "der Adler ist gelandet")
'arg=tranquility, def_arg=to Houston, def_arg2=der Adler ist gelandet' |
Besondere Vorsicht ist geboten, wenn veränderbare Standarddatenstrukturen als Standardparameter verwendet werden. Da die Funktionsdefinition nur einmal ausgeführt wird, werden diese veränderlichen Datenstrukturen (Referenzwerte) nur einmal bei der Definition der Funktion erstellt. Dies bedeutet, dass für alle Funktionsaufrufe dieselbe veränderbare Datenstruktur verwendet wird, wie im folgenden Beispiel gezeigt:
1
2
3
4
5
6
7
8
|
Bei jedem Funktionsaufruf wird „Hello World“ zur def_arg-Liste hinzugefügt. Nach zweimaligem Aufruf der Funktion sind zwei „Hello World“-Zeichen im Standardargument enthalten. Dies ist wichtig zu beachten, wenn variadische Standardparameter als Standardwerte verwendet werden. Die Gründe dafür werden deutlich, wenn wir das Python-Datenmodell diskutieren.
2. Schlüsselwortparameter: Sie können Funktionen auch aufrufen, indem Sie Schlüsselwortparameter in der Form „kwarg=value“ verwenden. Unter diesen bezieht sich kwarg auf den Parameternamen, der in der Funktionsdefinition verwendet wird. Nehmen Sie als Beispiel die unten definierte Funktion mit Standard- und Nicht-Standardparametern:
1
2
|
def show_args(arg, def_arg= 1): return "arg={}, def_arg={}".format(arg, def_arg) |
Um den Aufruf einer Funktion mit Schlüsselwortargumenten zu demonstrieren, kann die folgende Funktion auf eine der folgenden Arten aufgerufen werden:
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 ) |
In einem Funktionsaufruf dürfen Schlüsselwortargumente nicht vor Nicht-Schlüsselwortargumenten stehen, daher schlägt der folgende Aufruf fehl:
1
|
show_args
( def_arg= 4) |
1 |
show_args("test", arg="testing")
|
1 |
show_args("test", arg= "testing") |
| 1
show_args (def_arg="testing", arg ="test") |
3. Beliebige Parameterliste: Python unterstützt auch die Definition einer solchen Funktion, die eine beliebige Anzahl von Parametern akzeptieren kann, die in Form von Tupeln übergeben werden, Python-Tutorial Ein Beispiel davon sieht so aus:
1
2
|
def write_multiple_items(file, Trennzeichen, *args): Datei.schreiben(separator.join (args)) |
Auf die normalen Argumente müssen beliebig viele Argumente folgen. In diesem Beispiel sind nach der Parameterdatei und dem Trennzeichen beliebig viele Parameter vorhanden. Hier ist ein Beispiel für den Aufruf der oben definierten Funktion:
1
2
|
f = open( "test.txt", "wb") write_multiple_items(f, " ", "one", "two", "drei", "vier", "fünf") |
Die oben genannten Parameter eins, zwei, drei, vier und fünf werden zu einem Tupel gebündelt, auf das über den Parameter args zugegriffen werden kann.
Funktionsparameter entpacken
Manchmal können die Parameter eines Funktionsaufrufs in Form von Tupeln, Listen oder Wörterbüchern vorliegen. Diese Parameter können innerhalb der Funktion zum Aufruf mithilfe der Operatoren „*“ oder „**“ entpackt werden. Nehmen Sie als Beispiel die folgende Funktion. Diese Funktion akzeptiert zwei Positionsparameter und gibt die Werte der beiden Parameter aus.
1
2
3
|
def print_args(a, b): print a print b |
Wenn die der Funktion bereitgestellten Parameterwerte in Listenform vorliegen, können wir diese Werte wie folgt direkt in die Funktion entpacken:
1
2
3
4
>> > ; args = [1 , 2 ] >>> print_args(*args) 1 2 |
In ähnlicher Weise können wir bei Schlüsselwörtern ein Wörterbuch verwenden, um die Zuordnungsbeziehung von Kwarg zu Wert zu speichern, und den Operator „**“ verwenden, um die Schlüsselwortparameter in die Funktion zu entpacken , wie folgt:
|
1
2
3
4
5
6
7
8
|
>>> def Papagei (Spannung, Zustand='a steif', Aktion='voom'):
drucken "-- Dieser Papagei würde nicht" , Aktion,
Drucken "wenn man", Spannung, "Volt durch".,
🎜>,Zustand, "!"
>>> d = {"Spannung": "vier Millionen", "state": "bleedin' demised", "action ": "VOOM"}
>>> Papagei(**d)
>>> Dieser Papagei würde't VOOM wenn Sie vier geben Millionen Volt durch es. E's bleedin' abgestorben
|
利用“*“和“**“定义函数
有时候，当定义一个函数时，我们之前可能不知道参数的数量.这就导致了下面签名的函数定义:
1
|
show_args(arg, *args, **kwargs)
Der Parameter „*args“ stellt die Sequenzlänge des unbekannten Positionsparameters dar, während „**kwargs“ ein Wörterbuch mit Schlüsselwort- und Wertzuordnungsbeziehungen darstellt, das eine beliebige Anzahl von Schlüsselwörtern und enthalten kann Wertzuordnung und „*args“ muss in der Funktionsdefinition vor „**kwargs“ stehen. Der folgende Code veranschaulicht diese Situation:
Normale Parameter müssen für die Funktion bereitgestellt werden, aber „*args“ und „**kwargs“ sind optional, wie unten gezeigt:
Bei Funktionsaufrufen werden gewöhnliche Parameter auf normale Weise bereitgestellt, während optionale Parameter im Funktionsaufruf in entpackter Form erreicht werden können. Anonyme FunktionenPython unterstützt auch anonyme Funktionen, die mit dem Schlüsselwort Lambda erstellt werden. Die Form eines Lambda-Ausdrucks in Python ist wie folgt:
Ein Lambda-Ausdruck gibt ein ausgewertetes Funktionsobjekt zurück und hat dieselben Eigenschaften wie die benannte Funktion. In Python werden Lambda-Ausdrücke normalerweise nur für sehr einfache Funktionen verwendet, wie zum Beispiel:
Der Lambda-Ausdruck oben macht dasselbe wie die benannte Funktion unten: 1
2
def quadratisch(x): return x**2 |
Verschachtelte Funktionen und Abschlüsse
Das Definieren einer Funktion innerhalb einer Funktion erstellt eine verschachtelte Funktion, wie unten gezeigt:
1
2
3
4
5
6
7
|
```python def außen(): outer_var = "outer variable" def inner(): return outer_var return inner ``` |
Bei dieser Art von Funktionsdefinition ist die innere Funktion nur innerhalb der äußeren Funktion gültig, also wenn die innere Funktion zurückgegeben (in den äußeren Bereich verschoben) oder an eine andere übergeben werden muss Bei der Arbeit mit Funktionen ist es oft praktisch, verschachtelte Funktionen zu verwenden. In der obigen verschachtelten Funktion wird bei jedem Aufruf der äußeren Funktion eine neue verschachtelte Funktionsinstanz erstellt. Dies liegt daran, dass die Definition der inneren Funktion bei jeder Ausführung der äußeren Funktion ausgeführt wird und ihr Funktionskörper nicht ausgeführt wird.
Eine verschachtelte Funktion hat Zugriff auf die Umgebung, in der sie erstellt wurde, was ein direktes Ergebnis der Funktionsdefinitionssemantik von Python ist. Eine Konsequenz ist, dass in der äußeren Funktion definierte Variablen in der inneren Funktion referenziert werden können, selbst nachdem die äußere Funktion die Ausführung abgeschlossen hat.
1
2 3
4
5
6
7
8
9
10
11
|
def außen():
outer_var = "äußere Variable"
def innere():
return outer_var
Rückkehr innerlich
> ;>> x = außen ()
>>> x
<Funktion inner at 0x0273BCF0>
>>> x()
'äußere Variable'
|
Wenn sich die innere verschachtelte Funktion auf die Variable in der äußeren bezieht Funktion Wenn wir sagen, dass die verschachtelte Funktion relativ zur Referenzvariablen geschlossen ist. Auf diese eingeschlossene Variable können wir über ein spezielles Attribut „__closure__“ des Funktionsobjekts wie folgt zugreifen:
1
2
3
4
5
6
|
>>> > cl = x.__closure__>>> cl(<<🎜><🎜>Zelle <🎜>at<🎜> <🎜 > <🎜>0x029E4470<🎜><🎜>:<🎜><🎜> <🎜>str<🎜><🎜> <🎜 >Objekt<🎜><🎜> <🎜>at<🎜><🎜> <🎜>0x02A0FD90<🎜><🎜>>,) >>> > cl[0].Zelle_Inhalt'äußere Variable'
Abschlüsse in Python haben ein seltsames Verhalten. In Python 2.x und niedriger können Variablen, die auf unveränderliche Typen (z. B. Zeichenfolgen und Zahlen) verweisen, nicht innerhalb von Abschlüssen zurückgesendet werden. Folgendes Beispiel verdeutlicht dies:
Eine eher unzuverlässige Lösung besteht darin, einen veränderlichen Typ zu verwenden, um den Abschluss zu erfassen, wie folgt:
|