Die Bedeutung von Funktionen als Bürger erster Klasse in Python

Die Bedeutung von Funktionen als Bürger erster Klasse in Python

Funktionen sind erstklassige Bürger in Python und Funktionen sind Objekte. Funktionen in Python haben den Status erstklassiger Bürger, was das Schreiben von Funktionen wie Funktionen höherer Ordnung, Abschlüssen und Dekoratoren in Python erleichtert und auch in der funktionalen Programmierung weit verbreitet ist.

In Programmiersprachen kann ein Objekt als „Bürger erster Klasse“ bezeichnet werden, wenn es eine der folgenden drei Bedingungen erfüllt:

kann in einer Variablen gespeichert werden.

Kann als Argument an eine Funktion übergeben werden.

Kann als Rückgabewert einer Funktion verwendet werden.

Funktionen in Python erfüllen diese Bedingungen und werden daher First-Class-Bürger genannt.

Funktionen können in Variablen gespeichert werden

Der folgende Code definiert beispielsweise eine Funktion add(x, y), um zwei Zahlen zu addieren, und weist die Funktion dann der Variablen func zu:

def add(x, y):
    return x + y

func = add #func 变量保存了函数 add 的引用
result = func(1, 2) #可以像调用普通函数一样来调用它func
print(result) # 输出：3

Funktion, die als Parameter an die Funktion übergeben wird

Der Beispielquellcode lautet wie folgt:

def add(x, y):
    return x + y

def subtract(x, y):
    return x - y

def apply(func, x, y):
    return func(x, y)

result1 = apply(add, 3, 4)    # 调用 add 函数并将其作为参数传递给 apply 函数
result2 = apply(subtract, 3, 4)   # 调用 subtract 函数并将其作为参数传递给 apply 函数

print(result1)    # 输出：7
print(result2)    # 输出：-1

Im obigen Beispiel haben wir drei Funktionen add(), subtract() und apply() definiert. Unter diesen akzeptiert die Funktion apply() drei Parameter: eine Funktion func und zwei Werte x und y. Es ruft func(x, y) auf und gibt das Ergebnis zurück. Als nächstes haben wir die Funktion apply() zweimal aufgerufen, das erste Mal wurde die Funktion add() als Parameter übergeben und das zweite Mal wurde die Funktion subtract() als Parameter übergeben. Auf diese Weise können bestimmte Rechenoperationen durch Funktionsparameter spezifiziert und unterschiedliche Ergebnisse erzielt werden.

Die Übergabe von Funktionen als Parameter an Funktionen ist eine der gängigen Programmiertechniken in der Programmiersprache Python, die Funktionen vielseitiger und flexibler macht.

Funktionen können als Rückgabewerte von Funktionen verwendet werden

Der Beispielquellcode lautet wie folgt:

def calculator(operation):
    def add(x, y):
        return x + y

    def subtract(x, y):
        return x - y

    if operation == 'add':
        return add
    elif operation == 'subtract':
        return subtract
    else:
        return None

# 返回 add 函数并将其赋值给 calc_add 变量
calc_add = calculator('add')

# 调用 calc_add 函数计算结果
result = calc_add(3, 4)

print(result)    # 输出：7

Im obigen Beispiel haben wir eine Calculator()-Funktion definiert, die eine String-Parameteroperation akzeptiert und je nach Parameter unterschiedliche Funktionen zurückgibt. Gibt die Additionsfunktion add() zurück, wenn der Operationsparameter „add“ ist; gibt die Subtraktionsfunktion subtract() zurück, wenn der Operationsparameter „subtract“ ist; andernfalls wird None zurückgegeben.

Als nächstes rufen wir die Funktion rechner() auf und weisen ihren Rückgabewert der Variablen calc_add zu. Da wir den Parameter „add“ übergeben haben, enthält die Variable calc_add einen Verweis auf die Additionsfunktion add(). Schließlich verwenden wir die Funktion calc_add(), um die Summe von 3 und 4 zu berechnen und das Ergebnis 7 zu erhalten.

Eine Verwendung einer Funktion als Rückgabewert. Durch die Rückgabe verschiedener Funktionen können wir dafür sorgen, dass dieselbe Funktion unterschiedliche Funktionen implementiert, wodurch die Wiederverwendbarkeit und Flexibilität des Codes verbessert wird.

Eine Funktion kann eine Funktion als Argument annehmen und als Ergebnis eine neue Funktion zurückgeben

Der Beispielquellcode lautet wie folgt:

def add_suffix(func):
    def wrapper(text):
        return func(text) + "!"
    return wrapper

def greet(name):
    return "Hello, " + name

greet_with_exclamation = add_suffix(greet)
print(greet_with_exclamation("Alice")) # Hello, Alice!

In diesem Beispiel definieren wir zwei Funktionen:

Die Funktion add_suffix nimmt eine Funktion als Argument (hier func) und gibt als Ergebnis eine neue Funktion (die intern definierte Wrapper-Funktion) zurück.

Die Greet-Funktion begrüßt jemanden und gibt die entsprechende Begrüßungszeichenfolge zurück.

Wir rufen add_suffix auf und übergeben ihm die Greet-Funktion als Argument. Innerhalb der Funktion „add_suffix“ wird ein neuer Funktions-Wrapper definiert, der der ursprünglichen Funktion (hier der Funktion „greet“) ein Ausrufezeichen-Suffix hinzufügt. Schließlich gibt die Funktion add_suffix diesen neuen Funktionswrapper zurück.

Beim Aufruf von „greet_with_exclamation“ wird tatsächlich die interne Wrapper-Funktion aufgerufen und das geänderte Begrüßungsergebnis abgerufen.

Dieses Beispiel veranschaulicht das Konzept von Funktionen höherer Ordnung, bei denen eine Funktion eine andere Funktion als Argument übernimmt und eine neue Funktion zurückgibt. Dieses Muster ist in vielen Situationen sehr nützlich, da es den Code flexibler und wiederverwendbar macht. Allerdings kann die Verwendung dieser Methode den Code lang und komplex machen, insbesondere wenn mehrere Funktionen dekoriert werden müssen.

Wenn Sie das obige Beispiel ändern und den decorator verwenden , ist der Code prägnanter und lesbarer:

def add_suffix(func):
    def wrapper(text):
        return func(text) + "!"
    return wrapper

@add_suffix
def greet(name):
    return "Hello, " + name

print(greet("Alice")) # Hello, Alice!

Hier definieren wir einen Dekorator add_suffix, der eine Funktion als Argument akzeptiert und eine neue Funktion zurückgibt. Wir wenden den Dekorator auf die Begrüßungsfunktion an, indem wir @add_suffix vor der Definition der Begrüßungsfunktion hinzufügen.

Die Rolle eines Dekorateurs besteht darin, zusätzliche Funktionalität oder Verhalten hinzuzufügen, ohne die ursprüngliche Funktionsdefinition zu ändern. In diesem Fall fügt der Dekorateur add_suffix nach der ursprünglichen Begrüßungsausgabe ein Ausrufezeichen hinzu.

Durch die Verwendung eines Dekorators können wir vermeiden, die Dekoratorfunktion explizit aufzurufen, um eine neue Funktion zu generieren, sondern den syntaktischen Zucker @decorator_name direkt verwenden, um den Dekorator beim Definieren der Funktion anzuwenden. Mit anderen Worten, der syntaktische Zucker des Dekorators vereinfacht die Schritte für die Verwendung von Dekoratoren und erfordert nicht mehr den manuellen Aufruf von Dekoratorfunktionen und Zuweisungsvorgängen.

Durch die Verwendung eines Dekorators können wir vermeiden, die Dekoratorfunktion explizit aufzurufen, um eine neue Funktion zu generieren, sondern den syntaktischen Zucker @decorator_name direkt verwenden, um den Dekorator beim Definieren der Funktion anzuwenden. „Syntactic Sugar“ bezieht sich auf eine spezielle Syntax in einer Programmiersprache, die es Programmierern ermöglicht, bestimmte gängige Programmiermuster oder -operationen prägnanter und lesbarer auszudrücken. Obwohl diese syntaktischen Zucker keinen Einfluss auf die Funktionen und Fähigkeiten der Programmiersprache selbst haben, können sie die Lesbarkeit, Wartbarkeit und Entwicklungseffizienz des Codes erheblich verbessern.

In Python sind Dekoratoren ein typischer syntaktischer Zucker. Mit der Decorator-Syntax können wir Funktionen prägnanter und intuitiver definieren und Funktionen zusätzliche Funktionen hinzufügen, wie zum Beispiel:

@my_decorator
def my_function():
    # Funktionskörper
Unter diesen ist @my_decorator ein syntaktischer Zucker, der tatsächlich dem folgenden Code entspricht :

def my_function():
    # Funktion
my_function = my_decorator(my_function)

Weitere Informationen zu Dekoratoren finden Sie unter https://blog.csdn.net/cnds123/article/details/115588075