Detaillierte Einführung in die Python-Syntax-def() (besonders vollständig)

1. Was ist eine Funktion?

In Python ist eine Funktion ein wiederverwendbarer Codeblock, der eine bestimmte Aufgabe oder Operation ausführt. Funktionen können Eingabeparameter akzeptieren und Ausgabeergebnisse zurückgeben, wodurch der Zweck einer modularen und gekapselten Programmierung erreicht wird. Die Syntax zum Definieren von Funktionen in Python lautet wie folgt:

def function_name(parameters):
    """
    Function documentation string.
    """
    # Function body goes here.
    return [expression]

Darunter defist das Schlüsselwort, das die Funktion definiert, function_nameder Name der Funktion parametersund die Parameterliste der Funktion, eingeschlossen in Klammern. Mehrere Parameter werden durch Kommas getrennt. Wenn keine Parameter vorhanden sind, lassen Sie sie einfach leer. Der Funktionsname und die Parameterliste bilden die Signatur der Funktion, die zur eindeutigen Identifizierung und zum Aufruf der Funktion dient.

Der Hauptteil einer Funktion besteht aus Doppelpunkten und eingerückten Codeblöcken und enthält normalerweise einige Anweisungen und Ausdrücke zur Durchführung bestimmter Berechnungen oder Operationen. Die Dokumentationszeichenfolge einer Funktion ist eine optionale Zeichenfolge, die zur Beschreibung der Funktion, Parameter, Rückgabewerte und anderer Informationen der Funktion verwendet wird und help()über die integrierte Funktion angezeigt werden kann.

Nachdem die Funktion ausgeführt wurde, können Sie returndie Anweisung verwenden, um einen Wert (Ausdruck) zurückzugeben, oder Sie können keinen Wert zurückgeben. In diesem Fall wird standardmäßig zurückgegeben None.

Hier ist ein einfaches Beispiel, das zeigt, wie eine Funktion definiert und aufgerufen wird:

def add_numbers(a, b):
    """
    Add two numbers and return the result.
    """
    return a + b

x = 3
y = 4
z = add_numbers(x, y)
print(z)  # Output: 7

Im obigen Beispiel haben wir eine Funktion definiert add_numbers, die zwei Parameter akzeptiert aund bderen Summe zurückgibt. Dann setzen wir die Werte von xund yauf 3 bzw. 4 und rufen add_numbersdie Funktion auf, um ihre Summe zu berechnen, und weisen schließlich das Ergebnis der Variablen zu zund geben es aus.

2. Funktionsparameter

Funktionen in Python können mehrere Parameter akzeptieren, einschließlich Positionsparameter, Standardparameter, variable Parameter, Schlüsselwortparameter und andere verschiedene Parametertypen. Stellen wir sie einzeln vor:

2.1 Positionsparameter

Positionsparameter beziehen sich auf Parameter, die in der Reihenfolge der Parameterposition übergeben werden und auch als erforderliche Parameter bezeichnet werden. Beim Aufruf einer Funktion müssen entsprechend der Parameterliste in der Funktionsdefinition nacheinander entsprechend viele Positionsparameter übergeben werden. Zum Beispiel:

def greet_user(name):
    """
    Greet the user with a personalized message.
    """
    print(f"Hello, {name}!")

greet_user("Alice")  # Output: Hello, Alice!
greet_user("Bob")    # Output: Hello, Bob!

Im obigen Beispiel haben wir eine Funktion definiert greet_user, die einen Positionsparameter akzeptiert, nameum eine personalisierte Begrüßungsnachricht an den Benutzer zu senden. Dann rufen wir greet_userdie jeweiligen Funktionen auf und übergeben unterschiedliche Parameterwerte, um unterschiedliche Begrüßungsnachrichten auszugeben.

2.2 Standardparameter

Standardparameter beziehen sich auf feste Parameterwerte, die bei der Definition der Funktion angegeben werden. Sie können weggelassen werden oder Standardwerte verwenden. Wenn beim Aufruf der Funktion keine entsprechenden Parameter angegeben werden, werden stattdessen die Standardwerte verwendet. Zum Beispiel:

def greet_user(name, message="How are you doing?"):
    """
    Greet the user with a personalized message.
    """
    print(f"Hello, {name}! {message}")

greet_user("Alice")                  # Output: Hello, Alice! How are you doing?
greet_user("Bob", "Nice to meet you")# Output: Hello, Bob! Nice to meet you

Im obigen Beispiel haben wir greet_userdie Definition der Funktion geändert, einen Standardparameter hinzugefügt messageund seinen Standardwert auf „Wie geht es Ihnen?“ festgelegt.

Dann rufen wir die Funktionen separat auf greet_userund übergeben unterschiedliche Parameterwerte. Der erste Aufruf stellt nur die erforderlichen Parameter bereit name, daher wird der Standardwert „Wie geht es Ihnen?“ anstelle des fehlenden Parameterwerts verwendet. Der zweite Aufruf stellt explizit zwei Parameterwerte bereit und überschreibt somit die Standardwerte. In Funktionsdefinitionen müssen Standardparameter nach Positionsparametern platziert werden.

2.3 Variable Parameter

Variable Parameter beziehen sich auf Funktionen, die eine beliebige Anzahl von Parametern akzeptieren können, auch bekannt als Parameter variabler Länge. In Python gibt es zwei Arten von variadischen Argumenten: *args und **kwargs.

*args bedeutet, dass eine beliebige Anzahl von Positionsparametern akzeptiert wird. Die Parameter werden in ein Tupel gepackt und an die Funktion übergeben. Zum Beispiel:

def add_numbers(*nums):
    """
    Add any number of numbers and return the result.
    """
    total = 0
    for num in nums:
        total += num
    return total

sum1 = add_numbers(1, 2, 3)             # Output: 6
sum2 = add_numbers(4, 5, 6, 7, 8)       # Output: 30

Im obigen Beispiel definieren wir eine Funktion add_numbers, die eine beliebige Anzahl von Positionsargumenten mit variadischen *nums-Argumenten akzeptiert, diese dann summiert und das Ergebnis zurückgibt. Beachten Sie, dass bei Verwendung einer Schleife zur Verarbeitung aller Parameter innerhalb einer Funktion diese zunächst in ein Tupel gepackt werden müssen.

**kwargs bedeutet das Akzeptieren einer beliebigen Anzahl von Schlüsselwortparametern. Die Parameter werden in ein Wörterbuch (dict) gepackt und an die Funktion übergeben. Zum Beispiel:

def print_info(**kwargs):
    """
    Print out the key-value pairs of any number of keyword arguments.
    """
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="Alice", age=23, gender="female")
# Output:
# name: Alice
# age: 23
# gender: female

Im obigen Beispiel definieren wir eine Funktion print_info, die mithilfe von variadischen **kwargs eine beliebige Anzahl von Schlüsselwortargumenten akzeptiert und dann nacheinander den Namen und den Wert jedes Arguments ausgibt.

2.4 Schlüsselwortparameter

Schlüsselwortparameter beziehen sich auf Parameter, die explizit gemäß dem formalen Parameternamen übergeben werden und auch als benannte Parameter bezeichnet werden. Beim Aufruf einer Funktion können Sie den formalen Parameternamen verwenden, um den entsprechenden Parameterwert zu identifizieren und zu übergeben. Zum Beispiel:

def greet_user(name, message="How are you doing?"):
    """
    Greet the user with a personalized message.
    """
    print(f"Hello, {name}! {message}")

greet_user(name="Alice")                  # Output: Hello, Alice! How are you doing?
greet_user(message="Nice to meet you", name="Bob") # Output: Hello, Bob! Nice to meet you

Im obigen Beispiel verwenden wir formale Parameternamen, um die zu übergebenden Parameterwerte anzugeben und so die Bedeutung und Reihenfolge der Parameter klarer auszudrücken. Dies ist besonders nützlich, wenn die Schnittstelle komplex ist oder eine große Anzahl von Parametern aufweist.

3. Funktionsumfang

In Python haben Funktionen ihren eigenen Bereich, der den Zugriffsbereich von Variablen und Objekten darstellt. Innerhalb einer Funktion definierte Variablen sind lokale Variablen und können nur innerhalb der Funktion verwendet werden; außerhalb der Funktion definierte Variablen sind globale Variablen und können sowohl innerhalb als auch außerhalb der Funktion verwendet werden. Zum Beispiel:

x = 10 # Global variable

def print_x():
    """
    Print out the value of global variable x.
    """
    print(x)

print_x()  # Output: 10

Im obigen Beispiel haben wir eine globale Variable definiert xund print_xihren Wert dann in der Funktion ausgegeben. Da xes sich um eine globale Variable handelt, kann direkt innerhalb der Funktion auf sie zugegriffen und sie verwendet werden.

Wenn wir jedoch versuchen, den Wert einer globalen Variablen innerhalb der Funktion zu ändern, wird ein Fehler angezeigt. Um den Wert einer globalen Variablen innerhalb einer Funktion zu ändern, muss sie globalmit dem Schlüsselwort deklariert werden:

x = 10 # Global variable

def modify_x():
    """
    Modify the value of global variable x.
    """
    global x
    x = 20

modify_x()
print(x)  # Output: 20

Im obigen Beispiel definieren wir eine globale Variable xund modify_xverwenden dann globaldas Schlüsselwort in der Funktion, um zu deklarieren x, dass es sich um eine globale Variable handelt, sodass ihr Wert geändert werden kann. Nach dem Funktionsaufruf xwurde der Wert auf 20 geändert.

Beachten Sie, dass in Python die Namen lokaler Variablen und globaler Variablen nicht wiederholt werden können, da es sonst zu Namenskonflikten und Bereichsfehlern kommt. Wenn Sie den Wert einer globalen Variablen innerhalb einer Funktion verwenden möchten, ohne ihn zu ändern, können Sie globalihn mit dem Schlüsselwort referenzieren oder als Parameter an die Funktion übergeben.

4. Anonyme Funktionen

Eine anonyme Funktion (Lambda-Funktion) in Python ist ein spezieller Funktionstyp, der keinen Namen hat, normalerweise nur einen Ausdruck enthält und eine beliebige Anzahl von Argumenten akzeptieren kann. Die Syntax der anonymen Funktion lautet wie folgt:

lambda parameters: expression

Darunter lambdaist das Schlüsselwort und parametersdie Parameterliste. Mehrere Parameter werden durch Kommas getrennt. Wenn keine Parameter vorhanden sind, lassen Sie sie einfach leer. expressionEs handelt sich um den Funktionskörper, der zur Durchführung spezifischer Berechnungen oder Operationen und zur Rückgabe von Ergebnissen verwendet wird.

Hier ist beispielsweise ein Beispiel für die Verwendung der Lambda-Funktion zur Berechnung der Summe zweier Zahlen:

add_numbers = lambda x, y: x + y

sum1 = add_numbers(3, 4)      # Output: 7
sum2 = add_numbers(-5, 10)    # Output: 5

Im obigen Beispiel haben wir eine anonyme Funktion definiert add_numbers, die zwei Parameter x und y akzeptiert, ihre Summe berechnet und das Ergebnis zurückgibt. Dann rufen wir add_numbersdie Funktionen separat auf und übergeben unterschiedliche Parameterwerte, um unterschiedliche Ergebnisse auszugeben.

Anonyme Funktionen werden normalerweise für einfache, einmalige Vorgänge oder zur Übergabe als Argumente an andere Funktionen verwendet. Da anonyme Funktionen keine Namen haben, sparen Sie Code und verbessern die Lesbarkeit.

5. Zusammenfassung

In Python ist eine Funktion ein wiederverwendbarer Codeblock, der eine bestimmte Aufgabe oder Operation ausführt. Funktionen können Eingabeparameter akzeptieren und Ausgabeergebnisse zurückgeben, wodurch der Zweck einer modularen und gekapselten Programmierung erreicht wird. Funktionen in Python verfügen über mehrere Parametertypen, darunter Positionsparameter, Standardparameter, variable Parameter, Schlüsselwortparameter usw. Funktionen haben auch einen eigenen Bereich. Die Namen lokaler Variablen und globaler Variablen können nicht wiederholt werden. Sie müssen das Schlüsselwort verwenden, globalum den Wert globaler Variablen zu deklarieren und zu ändern. Schließlich unterstützt Python auch anonyme Funktionen (Lambda-Funktionen), die häufig für einfache, einmalige Operationen verwendet oder als Argumente an andere Funktionen übergeben werden.

Es ist immer noch dein Xiao Xiao!

Klicken Sie hier, um zu folgen! !