Python3 Funktionen

Eine Funktion ist ein organisierter, wiederverwendbarer Codeblock, der verwendet wird, um eine einzelne oder verwandte Funktionalität zu implementieren.

Funktionen verbessern die Modularität von Anwendungen und die Wiederverwendungsrate des Codes. Sie wissen bereits, dass Python viele integrierte Funktionen bereitstellt, wie z. B. print(). Sie können aber auch Ihre eigenen Funktionen erstellen, die als benutzerdefinierte Funktionen bezeichnet werden.

Eine Funktion definieren

Sie können eine Funktion mit der gewünschten Funktionalität definieren. Hier sind die einfachen Regeln:

  • Der Funktionscodeblock beginnt mit demdefSchlüsselwort, gefolgt vom Funktionsbezeichnernamen und Klammern.()。
  • Alle Eingabeparameter und Argumente müssen in die Klammern gesetzt werden; die Klammern können verwendet werden, um Parameter zu definieren.
  • Die erste Anweisung einer Funktion kann optional ein Docstring sein — verwendet, um die Funktionsbeschreibung zu speichern.
  • Der Funktionskörper beginnt mit einem Doppelpunkt:und ist eingerückt.
  • return [expression]Beendet die Funktion und gibt optional einen Wert an den Aufrufer zurück. Ein return ohne Ausdruck ist gleichbedeutend mit der Rückgabe von None.

Syntax

Python definiert Funktionen mit dem Schlüsselwort def, wobei das allgemeine Format wie folgt lautet:

def 函数名（参数列表）:
    函数体

Standardmäßig werden Parameterwerte und Parameternamen in der Reihenfolge abgeglichen, die in der Funktionsdeklaration definiert ist.

Beispiel

Verwenden wir eine Funktion, um "Hello World!" auszugeben:

#!/usr/bin/python3

def hello() :
    print("Hello World!")

hallo()

Eine komplexere Anwendung: Parametervariablen zur Funktion hinzufügen:

Beispiel (Python 3.0+)

Vergleiche zwei Zahlen und gib die größere zurück:

#!/usr/bin/python3 def max(a, b): if a > b: return a else: return b a = 4 b = 5 print(max(a, b))

Die Ausgabe des obigen Beispiels ist:

5

Beispiel (Python 3.0+)

Funktion zur Berechnung der Fläche:

#!/usr/bin/python3 # Funktion zur Berechnung der Fläche def area(width, height): return width * height def print_welcome(name): print("Willkommen", name) print_welcome("Beispiel") w = 4 h = 5 print("width =", w, " height =", h, " area =", area(w, h))

Die Ausgabe des obigen Beispiels ist:

Welcome Example
width = 4  height = 5  area = 20

Funktionsaufruf

Definieren einer Funktion: gibt der Funktion einen Namen, legt die in der Funktion enthaltenen Parameter und die Codeblockstruktur fest.

Nachdem die Grundstruktur dieser Funktion fertiggestellt ist, können Sie sie ausführen, indem Sie sie aus einer anderen Funktion oder direkt von der Python-Befehlszeile aus aufrufen.

Das folgende Beispiel ruft dieprintme()Funktion auf:

Beispiel (Python 3.0+)

#!/usr/bin/python3 # Funktion definieren def printme( str ): # Jede übergebene Zeichenkette ausgeben print (str) return # Funktion aufrufen printme("Ich möchte die benutzerdefinierte Funktion aufrufen!") printme("Dieselbe Funktion erneut aufrufen")

Die Ausgabe des obigen Beispiels ist:

I want to call a user-defined function! Call the same function again.

Parameterübergabe

In Python gehören Typen zu Objekten; Objekte haben unterschiedliche Typen, und Variablen haben keinen Typ:

a=[1,2,3]

a="Example"

Im obigen Code ist[1,2,3]vom Typ List,"Example"vom Typ String, während die Variable a keinen Typ hat. Sie ist lediglich eine Referenz auf ein Objekt (ein Zeiger) und kann sowohl auf ein Objekt vom Typ List als auch auf ein Objekt vom Typ String zeigen.

Veränderliche und unveränderliche Objekte

In Python sind Strings, Tupel und Zahlen unveränderliche Objekte, während list, dict usw. veränderliche Objekte sind.

  • Unveränderliche Typen:Variablenzuweisunga=5dann erneut zuweisena=10Hier wird tatsächlich ein neues int-Wertobjekt 10 erzeugt, dann wird a dazu gebracht, darauf zu zeigen, und 5 wird verworfen. Dies ändert nicht den Wert von a; es entspricht dem Neuerstellen von a.

  • Veränderliche Typen:Variablenzuweisungla=[1,2,3,4]dann erneut zuweisenla[2]=5Dies ändert den Wert des dritten Elements der Liste la; la selbst wird nicht bewegt, nur einige seiner internen Werte werden geändert.

Parameterübergabe von Python-Funktionen:

  • Unveränderliche Typen:Ähnlich wie die Wertübergabe (pass-by-value) in C++, etwa Ganzzahlen, Zeichenketten, Tupel. Zum Beispiel übergibt fun(a) nur den Wert von a, ohne das Objekt a selbst zu beeinflussen. Wenn der Wert von a innerhalb von fun(a) geändert wird, wird ein neues Objekt für a erzeugt.

  • Veränderliche Typen:Ähnlich wie die Referenzübergabe (pass-by-reference) in C++, etwa Listen, Dictionaries. Zum Beispiel übergibt fun(la) tatsächlich la; nach einer Änderung ist la außerhalb von fun ebenfalls betroffen.

In Python ist alles ein Objekt. Streng genommen können wir nicht von Übergabe per Wert oder Übergabe per Referenz sprechen; wir sollten von der Übergabe unveränderlicher Objekte und der Übergabe veränderlicher Objekte sprechen.

Python-Beispiel für die Übergabe unveränderlicher Objekte

Durch die Verwendung derid()-Funktion zur Überprüfung von Änderungen der Speicheradresse:

Beispiel (Python 3.0+)

def change(a): print(id(a)) # Zeigt auf dasselbe Objekt a=10 print(id(a)) # Ein neues Objekt a=1 print(id(a)) change(a)

Die Ausgabe des obigen Beispiels ist:

4379369136
4379369136
4379369424

Es ist zu erkennen, dass vor und nach dem Funktionsaufruf der formale Parameter und der aktuelle Parameter auf dasselbe Objekt verweisen (die Objekt-ID ist dieselbe). Nach der Änderung des formalen Parameters innerhalb der Funktion verweist der formale Parameter auf eine andere ID.

Beispiel für die Übergabe eines veränderlichen Objekts

Wenn der Parameter eines veränderlichen Objekts innerhalb einer Funktion geändert wird, dann wird in der Funktion, die diese Funktion aufgerufen hat, auch der ursprüngliche Parameter geändert. Zum Beispiel:

Beispiel (Python 3.0+)

#!/usr/bin/python3 # Beschreibung einer veränderlichen Funktion def changeme( mylist ): "Ändere die übergebene Liste." mylist.append([1,2,3,4]) print ("Wert innerhalb der Funktion:", mylist) return # Aufruf der Funktion changeme mylist = [10,20,30] changeme( mylist ) print ("Wert außerhalb der Funktion:", mylist)

Das an die Funktion übergebene Objekt und das Objekt, an das am Ende neuer Inhalt angehängt wird, verwenden dieselbe Referenz. Daher lautet die Ausgabe wie folgt:

函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

Parameters

Die folgenden formalen Parametertypen können beim Aufruf einer Funktion verwendet werden:

  • Erforderliche Parameter
  • Schlüsselwortargumente
  • Standardparameter
  • Parameter variabler Länge

Erforderliche Parameter

Erforderliche Parameter müssen in der richtigen Reihenfolge an die Funktion übergeben werden. Die Anzahl zum Zeitpunkt des Aufrufs muss mit der zum Zeitpunkt der Deklaration übereinstimmen.

Um die Funktion printme() aufzurufen, müssen Sie einen Parameter übergeben; andernfalls tritt ein Syntaxfehler auf:

Beispiel (Python 3.0+)

#!/usr/bin/python3 # Beschreibung einer veränderlichen Funktion def printme( str ): "Gib eine beliebige übergebene Zeichenkette aus." print (str) return # Aufruf der Funktion printme; das Weglassen des Parameters verursacht einen Fehler printme()

Die Ausgabe des obigen Beispiels ist:

Traceback (most recent call last):
  File "test.py", line 10, in <module>
    printme()
TypeError: printme() missing 1 required positional argument: 'str'

Schlüsselwortargumente

Schlüsselwortargumente stehen in engem Zusammenhang mit Funktionsaufrufen. Funktionsaufrufe verwenden Schlüsselwortargumente, um die übergebenen Parameterwerte zu bestimmen.

Die Verwendung von Schlüsselwortargumenten ermöglicht es, dass die Reihenfolge der Parameter in einem Funktionsaufruf nicht mit der Deklaration übereinstimmt, weil der Python-Interpreter Parameterwerte anhand des Parameternamens zuordnen kann.

Das folgende Beispiel verwendet Parameternamen beim Aufruf der Funktion printme():

Beispiel (Python 3.0+)

#!/usr/bin/python3 # Beschreibung einer veränderlichen Funktion def printme( str ): "Gib eine beliebige übergebene Zeichenkette aus." print (str) return # Rufe die Funktion printme auf printme( str = "Beispiel-Tutorial")

Die Ausgabe des obigen Beispiels ist:

Example

Das folgende Beispiel zeigt, dass die Verwendung von Funktionsparametern keine bestimmte Reihenfolge erfordert:

Beispiel (Python 3.0+)

#!/usr/bin/python3 # Veränderbare Funktionsbeschreibung def printinfo( name, age ): "Gibt eine beliebige übergebene Zeichenkette aus." print ("Name:", name) print ("Alter:", age) return # Rufe die Funktion printinfo auf printinfo( age=50, name="example" )

Die Ausgabe des obigen Beispiels ist:

名字:  example
年龄:  50

Standardparameter

Wenn eine Funktion aufgerufen wird und kein Argument übergeben wird, wird der Standardparameter verwendet. Im folgenden Beispiel wird, wenn kein Argument für age übergeben wird, der Standardwert verwendet:

Beispiel (Python 3.0+)

#!/usr/bin/python3 # Funktionsbeschreibung def printinfo( name, age = 35 ): "Gibt eine beliebige übergebene Zeichenkette aus" print ("Name:", name) print ("Alter:", age) return # Rufe die Funktion printinfo auf printinfo( age=50, name="example" ) print ("------------------------") printinfo( name="example" )

Ausgabe des obigen Beispiels:

名字:  example
年龄:  50
------------------------
名字:  example
年龄:  35

Parameter variabler Länge

Möglicherweise benötigen Sie eine Funktion, die mehr Argumente verarbeiten kann als ursprünglich deklariert. Diese Argumente werden Parameter variabler Länge genannt. Anders als die beiden oben erwähnten Parametertypen werden sie bei der Deklaration nicht benannt. Die grundlegende Syntax lautet wie folgt:

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

Mit einem hinzugefügten Sternchen*werden Parameter als Tupel importiert, das alle unbenannten variablen Parameter speichert.

Beispiel (Python 3.0+)

#!/usr/bin/python3 # Funktionsbeschreibung def printinfo( arg1, *vartuple ): "Beliebige übergebene Argumente ausgeben" print ("Ausgabe:") print (arg1) print (vartuple) # Aufruf der Funktion printinfo printinfo( 70, 60, 50 )

Ausgabe des obigen Beispiels:

输出: 
70
(60, 50)
Wenn beim Aufruf der Funktion keine Argumente angegeben werden, ist es ein leeres Tupel. Wir können auch keine unbenannten Variablen an die Funktion übergeben. Wie im folgenden Beispiel:

Beispiel (Python 3.0+)

#!/usr/bin/python3 # Funktionsbeschreibung def printinfo( arg1, *vartuple ): "Beliebige übergebene Argumente ausgeben" print ("Ausgabe:") print (arg1) for var in vartuple: print (var) return # Aufruf der Funktion printinfo printinfo( 10 ) printinfo( 70, 60, 50 )

Ausgabe des obigen Beispiels:

输出:
10
输出:
70
60
50

Es gibt auch den Fall, dass Parameter zwei Sternchen haben**Die grundlegende Syntax ist wie folgt:

def functionname([formal_args,] **var_args_dict ):
   "函数_文档字符串"
   function_suite
   return [expression]

Mit zwei hinzugefügten Sternchen**werden Parameter als Dictionary importiert.

Beispiel (Python 3.0+)

#!/usr/bin/python3 # Funktionsbeschreibung def printinfo( arg1, **vardict ): "Beliebige übergebene Argumente ausgeben" print ("Ausgabe:") print (arg1) print (vardict) # Aufruf der Funktion printinfo printinfo(1, a=2,b=3)

Ausgabe des obigen Beispiels:

输出: 
1
{'a': 2, 'b': 3}

Beim Deklarieren einer Funktion kann ein Sternchen in den Parametern*allein stehen, zum Beispiel:

def f(a,b,*,c):
    return a+b+c

Wenn das Sternchen allein steht*, dann müssen die Sternchen*Parameter danach per Schlüsselwort übergeben werden:

>>> def f(a,b,*,c):
...     return a+b+c
... 
>>> f(1,2,3)   # 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1,2,c=3) # 正常
6
>>>

Anonyme Funktionen

Python verwendetlambda, um anonyme Funktionen zu erstellen.

Das sogenannte Anonyme bedeutet, nicht mehrdefdie Standardform einer def-Anweisung zu verwenden, um eine Funktion zu definieren.

  • lambdaist nur ein Ausdruck, und der Funktionskörper istdefviel einfacher als def.
  • Der Körper einer Lambda-Funktion ist ein Ausdruck, kein Codeblock. In einem Lambda-Ausdruck kann nur begrenzte Logik gekapselt werden.
  • Lambda-Funktionen haben ihren eigenen Namensraum und können nicht auf Parameter außerhalb ihrer eigenen Argumentliste oder im globalen Namensraum zugreifen.
  • Obwohl eine Lambda-Funktion so aussieht, als könne sie nur in einer Zeile geschrieben werden, ist sie nicht gleichbedeutend mit einer Inline-Funktion in C oder C++. Der Zweck von Inline-Funktionen besteht darin, zu vermeiden, beim Aufruf kleiner Funktionen Stack-Speicher zu belegen, wodurch der Overhead von Funktionsaufrufen reduziert und die Ausführungsgeschwindigkeit des Codes verbessert wird.

Syntax

Die Syntax einer Lambda-Funktion enthält nur eine Anweisung, wie folgt:

lambda [arg1 [,arg2,.....argn]]:expression

Parameter a plus 10 setzen:

Beispiel

x = lambda a : a + 10 print(x(5))

Ausgabe des obigen Beispiels:

15

Das folgende Beispiel setzt eine anonyme Funktion mit zwei Parametern:

Beispiel (Python 3.0+)

#!/usr/bin/python3 # Funktionsbeschreibung sum = lambda arg1, arg2: arg1 + arg2 # Aufruf der Funktion sum print ("Der Wert nach der Addition ist:", sum( 10, 20 )) print ("Der Wert nach der Addition ist:", sum( 20, 20 ))

Ausgabe des obigen Beispiels:

相加后的值为 :  30
相加后的值为 :  40

Wir können eine anonyme Funktion in einer Funktion kapseln, sodass derselbe Code verwendet werden kann, um mehrere anonyme Funktionen zu erstellen.

Das folgende Beispiel kapselt eine anonyme Funktion in der Funktion myfunc und erstellt verschiedene anonyme Funktionen, indem unterschiedliche Parameter übergeben werden:

Beispiel

def myfunc(n): return lambda a : a * n mydoubler = myfunc(2) mytripler = myfunc(3) print(mydoubler(11)) print(mytripler(11))

Ausgabe des obigen Beispiels:

22
33

Weitere anonyme Funktionen finden Sie auch unter:Python lambda (anonyme Funktionen)

return-Anweisung

return [expression]Die Anweisung wird verwendet, um eine Funktion zu beenden und wahlweise einen Ausdruck an den Aufrufer zurückzugeben. Eine return-Anweisung ohne Argument gibt None zurück. Die vorherigen Beispiele haben nicht gezeigt, wie ein Wert zurückgegeben wird; das folgende Beispiel demonstriert die Verwendung der return-Anweisung:

Beispiel (Python 3.0+)

#!/usr/bin/python3 # Funktionsbeschreibung def sum( arg1, arg2 ): # Gibt die Summe der beiden Parameter zurück. total = arg1 + arg2 print ("Innerhalb der Funktion:", total) return total # Summenfunktion aufrufen total = sum( 10, 20 ) print ("Außerhalb der Funktion:", total)

Ausgabe des obigen Beispiels:

函数内 :  30
函数外 :  30

Nur positionale Parameter

Python 3.8 fügt eine Funktionsparameter-Syntax / hinzu, um anzugeben, dass Funktionsparameter die angegebenen Positionsparameter verwenden müssen und keine Schlüsselwortargumente verwenden können.

Im folgenden Beispiel müssen die Parameter a und b als Positionsargumente angegeben werden, c oder d können positionale oder Schlüsselwortparameter sein, und e und f müssen Schlüsselwortparameter sein:
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)

Die folgende Verwendung ist korrekt:

f(10, 20, 30, d=40, e=50, f=60)

Die folgende Verwendung verursacht einen Fehler:

f(10, b=20, c=30, d=40, e=50, f=60)   # b 不能使用关键字参数的形式
f(10, 20, 30, 40, 50, f=60)           # e 必须使用关键字参数的形式
Weitere Erweiterungen