Einführung
In diesem Lab lernst du, wie du Python-Funktionen definierst und verwendest. Wir beginnen mit einfachen Beispielen und erhöhen die Komplexität schrittweise.
Lass uns loslegen!
Ziele
- Python-Funktionen
Grundlagen von Python-Funktionen
💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken
Definiere eine Python-Funktion
Um eine Python-Funktion zu definieren, musst du das Schlüsselwort def verwenden, gefolgt vom Funktionsnamen und einer Klammerfolge, die Argumente enthalten kann. Der Funktionskörper ist eingerückt und folgt dem :-Zeichen.
Öffne einen neuen Python-Interpreter.
python3Hier ist ein Beispiel für eine einfache Funktion, die ein einzelnes Argument x annimmt und das Quadrat von x zurückgibt:
def square(x):
return x ** 2In diesem Beispiel nimmt die square-Funktion ein einzelnes Argument x entgegen und gibt das Quadrat von x zurück. Der Wert wird an den Aufrufer zurückgegeben, indem der return-Befehl verwendet wird.
Um eine Funktion aufzurufen, verwendest du einfach den Funktionsnamen, gefolgt von einer Klammerfolge und allen erforderlichen Argumenten. Beispielsweise:
result = square(5) ## result ist 25
print(result)Wenn eine Funktion keinen return-Befehl hat, wird standardmäßig None zurückgegeben. Beispielsweise:
def square(x):
print(x ** 2)
result = square(5) ## result ist None
print(result)Du musst den Unterschied zwischen return und print verstehen. Der print-Befehl wird verwendet, um einen Wert auf dem Bildschirm auszugeben, während der return-Befehl verwendet wird, um einen Wert aus der Funktion zurückzugeben.
Es ist auch möglich, den return-Befehl verwenden, um die Ausführung einer Funktion frühzeitig zu beenden. Beispielsweise:
def find_first_positive(numbers):
for number in numbers:
if number > 0:
return number
return None
result = find_first_positive([-1, -2, 3, -4, 5]) ## result ist 3
print(result)In diesem Beispiel gibt die find_first_positive-Funktion die erste positive Zahl in der numbers-Liste zurück, oder None, wenn keine positiven Zahlen gefunden werden. Der return-Befehl beendet die Ausführung der Funktion, sobald eine positive Zahl gefunden wird.
Funktionsargumente
Manchmal ist es nützlich, Standardwerte für Funktionsargumente anzugeben. Auf diese Weise kann die Funktion ohne Angabe eines Werts für das Argument aufgerufen werden, und der Standardwert wird stattdessen verwendet.
Hier ist ein Beispiel für eine Funktion, die die Fläche eines Rechtecks berechnet. Sie nimmt zwei Argumente entgegen: die Länge und die Breite des Rechtecks. Wir können Standardwerte für beide Argumente angeben, sodass die Funktion mit nur einem Argument aufgerufen werden kann, wenn Länge und Breite gleich sind:
def rectangle_area(length, width=1):
return length * width
print(rectangle_area(5)) ## Ausgabe: 5
print(rectangle_area(5, 2)) ## Ausgabe: 10In diesem Beispiel hat das Argument width einen Standardwert von 1. Wenn die Funktion mit nur einem Argument aufgerufen wird, wird der Standardwert 1 für width verwendet.
Probier es selbst aus: Definiere eine Funktion namens power, die zwei Argumente entgegennimmt: eine Basis x und einen Exponenten n. Lasse den Exponenten-Parameter optional mit einem Standardwert von 2. Rufe dann die Funktion mit unterschiedlichen Werten für die Basis und den Exponenten auf.
def power(x, n=2):
return x ** n
print(power(2)) ## Ausgabe: 4
print(power(2, 3)) ## Ausgabe: 8Argument-Typ-Hinweis
In Python geben Funktionsargument-Typ-Hinweise den erwarteten Typ eines an eine Funktion übergebenen Arguments an. Sie wurden in Python 3.5 eingeführt und werden durch einen Doppelpunkt gefolgt vom Typ bezeichnet, der nach dem Argumentnamen in der Funktionsdefinition steht.
Typ-Hinweise sind optional und beeinflussen das Laufzeitverhalten des Codes nicht. Sie werden hauptsächlich von Tools wie IDEs und Lintern verwendet, um eine bessere Codeanalyse und Autovervollständigungssuggestionen zu liefern.
Betrachte beispielsweise die folgende Funktion, die zwei Argumente, eine Ganzzahl und einen String, entgegennimmt und deren Verkettung zurückgibt:
def concatenate(a: int, b: str) -> str:
return str(a) + b
print(concatenate(1, "world")) ## "1world"In diesem Beispiel geben die Typ-Hinweise int und str an, dass das erste Argument a eine Ganzzahl und das zweite Argument b ein String sein sollte.
Typ-Hinweise können auch mit Klassen und ihren Instanzen verwendet werden, beispielsweise:
class MyClass:
pass
def my_function(a: MyClass) -> None:
passEs ist erwähnenswert, dass Typ-Hinweise optional sind und das Laufzeitverhalten des Codes nicht beeinflussen. Sie werden hauptsächlich von Tools wie IDEs und Lintern verwendet, um eine bessere Codeanalyse und Autovervollständigungssuggestionen zu liefern.
Außerdem hat Python ein Modul namens typing, das nützliche Typen wie List, Tuple, Dict, Set etc. enthält, die verwendet werden können, um Hinweise über die Typen der Elemente in einer Sammlung zu geben.
from typing import List, Tuple
def my_function(a: List[int], b: Tuple[str, int]) -> None:
passEs ist eine gute Praxis, Typ-Hinweise in Ihrem Code zu verwenden, um ihn lesbarer und wartbarer zu machen.
Docstring
Ein Docstring ist ein String-Literal, das als erster Ausdruck in einer Modul-, Funktion-, Klasse- oder Methodendefinition vorkommt. Ein solches Docstring wird zum __doc__-Spezialattribut dieses Objekts.
Docstrings werden verwendet, um den Code zu dokumentieren und werden in einfachem Text geschrieben. Sie werden in Dreifachanführungszeichen """ eingeschlossen und werden normalerweise am Anfang der Funktionsdefinition platziert.
def my_function():
"""Dies ist ein Docstring."""
passDocstrings enthalten normalerweise eine kurze Beschreibung der Funktion, ihrer Argumente und ihres Rückgabewerts. Sie können auch eine längere Beschreibung des Verhaltens der Funktion enthalten.
def my_function(a: int, b: int) -> int:
"""Gibt die Summe von a und b zurück.
Args:
a (int): Die erste Zahl.
b (int): Die zweite Zahl.
Returns:
int: Die Summe von a und b.
"""
return a + bRückgabe mehrerer Werte
In Python kann eine Funktion mehrere Werte als Tuple zurückgeben. Hier ist ein Beispiel für eine Funktion, die den kleinsten und größten Wert einer Liste berechnet:
def min_max(numbers):
return min(numbers), max(numbers)
nums = [1, 2, 3, 4, 5]
min_val, max_val = min_max(nums)
print("Kleinster Wert:", min_val) ## Ausgabe: "Kleinster Wert: 1"
print("Größter Wert:", max_val) ## Ausgabe: "Größter Wert: 5"In diesem Beispiel gibt die min_max-Funktion ein Tuple zurück, das die kleinsten und größten Werte der numbers-Liste enthält. Das Tuple wird in die Variablen min_val und max_val aufgelöst, wenn die Funktion aufgerufen wird.
Hier ist ein weiteres Beispiel für die Rückgabe mehrerer Werte aus einer Funktion:
def get_student_info(name):
if name == "John":
return "John", "Doe", "Informatik"
elif name == "Jane":
return "Jane", "Smith", "Physik"
else:
return "Unbekannt", "Unbekannt", "Unbekannt"
first_name, last_name, major = get_student_info("John")
print("Vorname:", first_name) ## Ausgabe: "Vorname: John"
print("Nachname:", last_name) ## Ausgabe: "Nachname: Doe"
print("Studiengang:", major) ## Ausgabe: "Studiengang: Informatik"
first_name, last_name, major = get_student_info("Jane")
print("Vorname:", first_name) ## Ausgabe: "Vorname: Jane"
print("Nachname:", last_name) ## Ausgabe: "Nachname: Smith"
print("Studiengang:", major) ## Ausgabe: "Studiengang: Physik"
first_name, last_name, major = get_student_info("Bob")
print("Vorname:", first_name) ## Ausgabe: "Vorname: Unbekannt"
print("Nachname:", last_name) ## Ausgabe: "Nachname: Unbekannt"
print("Studiengang:", major) ## Ausgabe: "Studiengang: Unbekannt"In diesem Beispiel nimmt die get_student_info-Funktion einen Studentennamen entgegen und gibt ein Tuple zurück, das den Vornamen, Nachnamen und Studiengang des Studenten enthält. Das Tuple wird in separate Variablen aufgelöst, wenn die Funktion aufgerufen wird.
Wenn der Studentennamen nicht erkannt wird, gibt die Funktion ein Tuple mit "Unbekannt"-Werten zurück.
Schlüsselwortargumente
In Python kannst du Funktionsargumente mit "Schlüsselwortargumenten" angeben. Wenn du Schlüsselwortargumente verwendest, gibst du den Argumentnamen gefolgt vom Wert an, und die Argumente können in beliebiger Reihenfolge angegeben werden.
Hier ist ein Beispiel für eine Funktion, die zwei Argumente entgegennimmt: einen Namen und eine Nachricht:
def greet(name, message):
print("Hello, " + name + "! " + message)
greet(message="Wie geht es dir?", name="John") ## Ausgabe: "Hello, John! Wie geht es dir?"In diesem Beispiel wird die greet-Funktion mit den Argumenten "John" und "Wie geht es dir?" aufgerufen, aber die Argumente werden in einer anderen Reihenfolge angegeben als in der Funktion definiert. Indem du Schlüsselwortargumente verwendest, kannst du die Argumente in beliebiger Reihenfolge angeben und den Code lesbarer machen.
Du kannst auch Schlüsselwortargumente mit Positionsargumenten mischen, solange die Positionsargumente zuerst angegeben werden. Beispielsweise:
def greet(name, message):
print("Hello, " + name + "! " + message)
greet("John", message="Wie geht es dir?") ## Ausgabe: "Hello, John! Wie geht es dir?"In diesem Beispiel wird das name-Argument als Positionsargument und das message-Argument als Schlüsselwortargument angegeben.
Schlüsselwortargumente sind besonders nützlich, wenn eine Funktion eine große Anzahl von Argumenten hat oder wenn die Argumente Standardwerte haben. Beispielsweise:
def create_user(name, age=18, gender="unknown"):
print("Creating user:", name, age, gender)
create_user("John") ## Ausgabe: "Creating user: John 18 unknown"
create_user("Jane", gender="female") ## Ausgabe: "Creating user: Jane 18 female"
create_user("Bob", 25, "male") ## Ausgabe: "Creating user: Bob 25 male"In diesem Beispiel nimmt die create_user-Funktion drei Argumente entgegen: name, age und gender. Die age- und gender-Argumente haben Standardwerte, sodass sie optional sind. Indem du Schlüsselwortargumente verwendest, kannst du nur die Argumente angeben, die du bereitstellen möchtest, und die Standardwerte werden für die anderen verwendet.
Args und Kwargs
In Python kannst du die *args- und **kwargs-Syntax verwenden, um eine Funktion zu definieren, die eine variable Anzahl von Argumenten akzeptieren kann.
Die *args-Syntax wird verwendet, um eine variable Anzahl von nicht-Schlüsselwort-Argumenten an eine Funktion zu übergeben. Beispielsweise:
def print_numbers(*args):
for arg in args:
print(arg)
print_numbers(1, 2, 3, 4, 5) ## Ausgabe: 1, 2, 3, 4, 5
print_numbers(10, 20, 30) ## Ausgabe: 10, 20, 30In diesem Beispiel nimmt die print_numbers-Funktion eine variable Anzahl von Argumenten entgegen und druckt sie auf der Konsole aus. Die *args-Syntax wird verwendet, um die Funktion zu definieren, und die Argumente werden als Tuple an die Funktion übergeben.
Die **kwargs-Syntax wird verwendet, um eine variable Anzahl von Schlüsselwort-Argumenten an eine Funktion zu übergeben. Beispielsweise:
def print_keywords(**kwargs):
for key, value in kwargs.items():
print(key, ":", value)
print_keywords(name="John", age=30, city="New York")
## Ausgabe:
## name : John
## age : 30
## city : New York
print_keywords(country="USA", population=327000000)
## Ausgabe:
## country : USA
## population : 327000000In diesem Beispiel nimmt die print_keywords-Funktion eine variable Anzahl von Schlüsselwort-Argumenten entgegen und druckt sie auf der Konsole aus. Die **kwargs-Syntax wird verwendet, um die Funktion zu definieren, und die Argumente werden als Dictionary an die Funktion übergeben.
Du kannst die *args- und **kwargs-Syntax mit anderen Argumenten in einer Funktionsdefinition mischen, solange die *args- und **kwargs-Argumente zuletzt angegeben werden. Beispielsweise:
def print_info(title, *args, **kwargs):
print(title)
for arg in args:
print(arg)
for key, value in kwargs.items():
print(key, ":", value)
print_info("Person", "John", "Jane", "Bob", age=30, city="New York")
## Ausgabe:
## Person
## John
## Jane
## Bob
## age : 30
## city : New YorkIn diesem Beispiel nimmt die print_info-Funktion ein festeres Argument title, gefolgt von einer variablen Anzahl von nicht-Schlüsselwort-Argumenten (*args) und einer variablen Anzahl von Schlüsselwort-Argumenten (**kwargs). Die Argumente werden in der Reihenfolge übergeben, in der sie definiert sind: zuerst title, dann *args und schließlich **kwargs.
Die *args- und **kwargs-Syntax kann nützlich sein, wenn du eine flexible Funktion definieren möchtest, die eine variable Anzahl von Argumenten akzeptieren kann. Sie können auch den Code lesbarer machen, indem du vermeidest, harte Codierung von Argumentnamen in der Funktionsdefinition zu verwenden.
Hier ist ein Beispiel für eine Funktion, die *args und **kwargs verwendet, um ein Dictionary von Argumenten zu erstellen:
def create_dict(**kwargs):
return kwargs
my_dict = create_dict(name="John", age=30, city="New York")
print(my_dict) ## Ausgabe: {'name': 'John', 'age': 30, 'city': 'New York'}
my_dict = create_dict(a=1, b=2, c=3)
print(my_dict) ## Ausgabe: {'a': 1, 'b': 2, 'c': 3}In diesem Beispiel nimmt die create_dict-Funktion eine variable Anzahl von Schlüsselwort-Argumenten entgegen und gibt sie als Dictionary zurück. Die **kwargs-Syntax wird verwendet, um die Funktion zu definieren, und die Argumente werden als Dictionary an die Funktion übergeben.
Du kannst auch den *-Operator verwenden, um eine Liste oder ein Tuple in separate Argumente aufzulösen, wenn du eine Funktion aufrufst. Beispielsweise:
def print_numbers(*args):
for arg in args:
print(arg)
numbers = [1, 2, 3, 4, 5]
print_numbers(*numbers) ## Ausgabe: 1, 2, 3, 4, 5
tuple_of_numbers = (10, 20, 30)
print_numbers(*tuple_of_numbers) ## Ausgabe: 10, 20, 30In diesem Beispiel wird der *-Operator verwendet, um die numbers-Liste und das tuple_of_numbers-Tuple in separate Argumente aufzulösen, wenn die print_numbers-Funktion aufgerufen wird.
Du kannst auch den **-Operator verwenden, um ein Dictionary in Schlüsselwort-Argumente aufzulösen, wenn du eine Funktion aufrufst. Beispielsweise:
def print_keywords(**kwargs):
for key, value in kwargs.items():
print(key, ":", value)
my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
print_keywords(**my_dict)
## Ausgabe:
## name : John
## age : 30
## city : New York
another_dict = {'country': 'USA', 'population': 327000000}
print_keywords(**another_dict)
## Ausgabe:
## country : USA
## population : 327000000In diesem Beispiel wird der **-Operator verwendet, um das my_dict- und das another_dict-Dictionary in Schlüsselwort-Argumente aufzulösen, wenn die print_keywords-Funktion aufgerufen wird.
Lambda-Funktionen
In Python kannst du "Lambda-Funktionen" verwenden, um anonyme Funktionen zu erstellen. Lambda-Funktionen sind kleine Funktionen, die keinen Namen haben und normalerweise in einer einzigen Codezeile definiert und aufgerufen werden.
Hier ist ein Beispiel für eine Lambda-Funktion, die zwei Argumente entgegennimmt und ihre Summe zurückgibt:
sum = lambda x, y: x + y
result = sum(1, 2) ## result ist 3In diesem Beispiel wird das lambda-Schlüsselwort verwendet, um eine Lambda-Funktion zu definieren, die zwei Argumente x und y entgegennimmt und ihre sum zurückgibt. Die Lambda-Funktion wird der sum-Variablen zugewiesen und kann wie jede andere Funktion aufgerufen werden.
Kannst du eine normale Funktion verwenden, um die gleiche Funktion wie eine Lambda-Funktion zu definieren?
def sum(x, y):
return x + y
result = sum(1, 2) ## result ist 3Lambda-Funktionen werden oft als Kurzschreibweise für die Definition einfacher Funktionen verwendet. Sie sind besonders nützlich, wenn du eine Funktion als Argument an eine andere Funktion übergeben möchtest oder wenn du eine Funktion inline definieren möchtest.
Hier ist ein Beispiel für die Verwendung einer Lambda-Funktion als Argument für die sorted-Funktion:
words = ["apple", "banana", "cherry", "date"]
sorted_words = sorted(words, key=lambda x: len(x))
print(sorted_words) ## Ausgabe: ['apple', 'date', 'banana', 'cherry']In diesem Beispiel nimmt die sorted-Funktion eine Liste von Wörtern und eine "key"-Funktion entgegen, die angibt, wie die Wörter sortiert werden sollen. Die als key-Funktion übergebene Lambda-Funktion gibt die Länge jedes Wortes zurück, und die Wörter werden nach ihrer Länge sortiert.
Hier ist ein Beispiel für die Definition einer Lambda-Funktion inline:
result = (lambda x: x ** 2)(5) ## result ist 25In diesem Beispiel nimmt die Lambda-Funktion ein einzelnes Argument x entgegen und gibt das Quadrat von x zurück. Die Lambda-Funktion wird in einer einzigen Codezeile definiert und aufgerufen, und das result wird der result-Variablen zugewiesen.
Lambda-Funktionen werden in Python oft für kurze, einfache Funktionen verwendet, die nicht an anderer Stelle im Code wiederverwendet werden müssen. Sie sind eine bequeme Möglichkeit, kleine Funktionen auf dem fly zu definieren, ohne dass es erforderlich ist, eine separate Funktion mit dem def-Schlüsselwort zu definieren.
Lokaler und globaler Gültigkeitsbereich
In Python sind Variablen, die innerhalb einer Funktion definiert werden, für die Funktion "lokal" und nur innerhalb der Funktion verfügbar. Variablen, die außerhalb einer Funktion definiert werden, sind "global" und über das gesamte Programm verfügbar.
Hier ist ein Beispiel für eine globale Variable:
message = "Hello, world!"
def greet():
print(message)
greet() ## Ausgabe: "Hello, world!"In diesem Beispiel ist die message-Variable außerhalb der greet-Funktion definiert, also ist es eine globale Variable. Die greet-Funktion kann auf die message-Variable zugreifen und ausgeben, da sie über das gesamte Programm verfügbar ist.
Hier ist ein Beispiel für eine lokale Variable:
def greet(name):
message = "Hello, " + name + "!"
print(message)
greet("John") ## Ausgabe: "Hello, John!"
print(message) ## Ausgabe: NameError: name 'message' is not definedIn diesem Beispiel ist die message-Variable innerhalb der greet-Funktion definiert, also ist es eine lokale Variable. Die greet-Funktion kann auf die message-Variable zugreifen und ausgeben, ist aber außerhalb der Funktion nicht verfügbar. Wenn du versuchst, auf die message-Variable außerhalb der Funktion zuzugreifen, erhältst du einen NameError, da die Variable nicht definiert ist.
Du kannst auch das global-Schlüsselwort verwenden, um eine globale Variable innerhalb einer Funktion zu modifizieren. Beispielsweise:
message = "Hello, world!"
def greet():
global message
message = "Hello, Python!"
print(message)
greet() ## Ausgabe: "Hello, Python!"
print(message) ## Ausgabe: "Hello, Python!"In diesem Beispiel verwendet die greet-Funktion das global-Schlüsselwort, um die globale Variable message zu modifizieren. Die greet-Funktion gibt den修改变量 message 的值，并且 message 的值在函数外部也被修改了。
一般来说，避免使用全局变量是个好主意，因为它们会使代码更难理解和维护。通常最好将变量作为参数传递给函数，并将它们作为结果返回，而不是修改全局变量。
Verwenden einer Funktion als Argument für eine andere Funktion
In Python kannst du eine Funktion als Argument für eine andere Funktion übergeben. Dies wird als "Higher-Order-Funktion" bezeichnet. Hier ist ein Beispiel für eine Funktion, die eine andere Funktion als Argument nimmt und sie mehrmals aufruft:
def greet(name):
print("Hello, " + name + "!")
def call(func, args):
for arg in args:
func(arg)
names = ["John", "Jane", "Bob"]
call(greet, names) ## Ausgabe: "Hello, John!", "Hello, Jane!", "Hello, Bob!"In diesem Beispiel nimmt die call-Funktion zwei Argumente entgegen: eine Funktion func und eine Liste von Argumenten args. Sie ruft die func-Funktion mit jedem Element der args-Liste als Argument auf.
Probier es selbst aus: Definiere eine Funktion namens apply, die eine Funktion und eine Liste von Zahlen nimmt und eine neue Liste zurückgibt, die das Ergebnis der Anwendung der Funktion auf jedes Element der Liste enthält.
def square(x):
return x ** 2
def apply(func, numbers):
result = []
for number in numbers:
result.append(func(number))
return result
numbers = [1, 2, 3, 4, 5]
squared_numbers = apply(square, numbers)
print(squared_numbers) ## Ausgabe: [1, 4, 9, 16, 25]Dieser Schritt kann ein bisschen schwierig sein. Wenn du es nicht lösen kannst, brauchst du dich nicht zu sorgen. Du kannst es überspringen und später wieder darauf zurückkommen.
Zusammenfassung
Du solltest jetzt einen guten Überblick darüber haben, wie man mit Python-Funktionen umgeht. Hier sind einige der wichtigsten Punkte:
- Python-Funktionen sind Codeblöcke, die definiert, aufgerufen und wiederverwendet werden können.
- Du kannst eine Funktion mit dem
def-Schlüsselwort definieren, gefolgt vom Funktionsnamen und den Argumenten. - Der Funktionskörper sollte eingerückt sein, und du kannst das
return-Schlüsselwort verwenden, um einen Wert aus der Funktion zurückzugeben. - Du kannst Funktionsargumente mit "Schlüsselwortargumenten" angeben, die es dir ermöglichen, den Argumentnamen und den Wert beim Aufruf der Funktion anzugeben.
- Du kannst die
*args-Syntax verwenden, um eine Funktion zu definieren, die eine variable Anzahl von nicht-Schlüsselwort-Argumenten entgegennehmen kann, und die**kwargs-Syntax, um eine Funktion zu definieren, die eine variable Anzahl von Schlüsselwort-Argumenten entgegennehmen kann. - Du kannst das lambda-Schlüsselwort verwenden, um anonyme Funktionen zu erstellen, die in einer einzigen Codezeile definiert und aufgerufen werden.
- In Python sind Variablen, die innerhalb einer Funktion definiert werden, für die Funktion lokal und nur innerhalb der Funktion verfügbar. Variablen, die außerhalb einer Funktion definiert werden, sind global und über das gesamte Programm verfügbar.
- Es ist im Allgemeinen eine gute Idee, globale Variablen zu vermeiden und stattdessen Variablen als Argumente an Funktionen zu übergeben und als Ergebnisse zurückzugeben.
