Python-Funktionen

Eine Funktion ist ein Block aus organisiertem, wiederverwendbarem Code, der verwendet wird, um eine einzelne oder zusammenhängende Aktion auszuführen.

Funktionen helfen, die Modularität von Anwendungen und die Wiederverwendung von Code zu verbessern. Sie wissen bereits, dass Python viele integrierte Funktionen bereitstellt, wie z. B. print(). Sie können auch eigene 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:

  • Funktionscodeblöcke beginnen mit dem Schlüsselwortdef, gefolgt vom Bezeichnernamen der Funktion und Klammern.()。
  • Alle eingehenden Parameter und Argumente müssen innerhalb der Klammern stehen. Die Klammern können verwendet werden, um Parameter zu definieren.
  • Die erste Anweisung einer Funktion kann optional ein Docstring sein — wird verwendet, um eine Funktionsbeschreibung zu speichern.
  • Der Funktionskörper beginnt mit einem Doppelpunkt und wird eingerückt.
  • return [expression]Beendet die Funktion und gibt optional einen Wert an den Aufrufer zurück. Ein return ohne Ausdruck entspricht der Rückgabe von None.

Syntax

def functionname( parameters ): "function_docstring" function_suite return [expression]

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

Beispiel

Das Folgende ist eine einfache Python-Funktion, die eine Zeichenkette als eingehenden Parameter entgegennimmt und sie auf dem Standardanzeigegerät ausgibt.

Beispiel (Python 2.0+)

def printme( str ): "Gibt die übergebene Zeichenkette auf dem Standardanzeigegerät aus." print str return

Aufruf einer Funktion

Das Definieren einer Funktion gibt der Funktion nur einen Namen, legt die darin enthaltenen Parameter und die Struktur des Codeblocks fest.

Sobald die Grundstruktur dieser Funktion vollständig ist, können Sie sie aus einer anderen Funktion oder direkt von der Python-Eingabeaufforderung aufrufen und ausführen.

Das folgende Beispiel ruft die Funktion printme() auf:

Beispiel (Python 2.0+)

#!/usr/bin/python # -*- coding: UTF-8 -*- # Funktion definieren def printme( str ): "Gibt eine beliebige übergebene Zeichenkette aus" print str return # Funktion aufrufen printme("Ich rufe eine benutzerdefinierte Funktion auf!") 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, und Variablen sind untypisiert:

a=[1,2,3] a="Beispiel"

Im obigen Code,[1,2,3]ist ein List-Typ,"Example"ist ein String-Typ, während die Variable a keinen Typ hat. Sie ist lediglich eine Referenz (ein Zeiger) auf ein Objekt. Sie kann ein Objekt vom Typ List sein oder 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=5und dann erneut zuweisena=10Hier wird tatsächlich ein neues int-Wertobjekt 10 erzeugt und dann a dazu gebracht, darauf zu zeigen, während 5 verworfen wird. Es ändert nicht den Wert von a; es ist äquivalent zum Erzeugen eines neuen a.

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

Parameterübergabe in Python-Funktionen:

  • Unveränderliche Typen:Ähnlich wie bei der Übergabe per Wert in C++, etwa bei Ganzzahlen, Zeichenketten, Tupeln. Beispielsweise übergibt fun(a) nur den Wert von a, ohne das Objekt a selbst zu beeinflussen. Wenn man beispielsweise den Wert von a innerhalb von fun(a) ändert, wird nur ein anderes kopiertes Objekt geändert, nicht a selbst.

  • Veränderliche Typen:Ähnlich wie bei der Übergabe per Referenz in C++, etwa bei Listen und Wörterbüchern. Beispielsweise übergibt fun(la) tatsächlich la selbst; 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.

Beispiel für die Übergabe eines unveränderlichen Objekts in Python

Beispiel (Python 2.0+)

#!/usr/bin/python # -*- coding: UTF-8 -*- def ChangeInt( a ): a = 10 b = 2 ChangeInt(b) print b # Das Ergebnis ist 2

Im Beispiel gibt es ein int-Objekt 2, und die Variable, die darauf zeigt, ist b. Wenn sie an die Funktion ChangeInt übergeben wird, wird die Variable b nach dem Prinzip der Übergabe per Wert kopiert, sodass sowohl a als auch b auf dasselbe int-Objekt zeigen. Wenn a=10 gilt, wird ein neues int-Wertobjekt 10 erzeugt, und a wird dazu gebracht, darauf zu zeigen.

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

Beispiel (Python 2.0+)

#!/usr/bin/python # -*- coding: UTF-8 -*- # Funktionsdefinition def changeme( mylist ): "Ändere die übergebene Liste" mylist.append([1,2,3,4]) print "Wert innerhalb der Funktion:", mylist return # Aufruf der changeme-Funktion mylist = [10,20,30] changeme( mylist ) print "Wert außerhalb der Funktion:", mylist

Im Beispiel verwenden das in die Funktion übergebene Objekt und das Objekt, dem am Ende neuer Inhalt hinzugefügt wird, 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
  • Standardargumente
  • Parameter variabler Länge

Erforderliche Parameter

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

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

Beispiel (Python 2.0+)

#!/usr/bin/python # -*- coding: UTF-8 -*- # Funktionsdefinition def printme( str ): "Gibt eine beliebige übergebene Zeichenkette aus" print str return # Rufe die Funktion printme auf printme()

Die Ausgabe des obigen Beispiels ist:

Traceback (most recent call last):
  File "test.py", line 11, in <module>
    printme()
TypeError: printme() takes exactly 1 argument (0 given)

Schlüsselwortargumente

Schlüsselwortargumente sind eng mit Funktionsaufrufen verbunden. 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 von der Reihenfolge in der Deklaration abweichen kann, da der Python-Interpreter Parameterwerte anhand der Parameternamen zuordnen kann.

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

Beispiel (Python 2.0+)

#!/usr/bin/python # -*- coding: UTF-8 -*- # Funktionsdefinition def printme( str ): "Gibt eine beliebige übergebene Zeichenkette aus" print str return # Rufe die Funktion printme auf printme( str = "My string")

Die Ausgabe des obigen Beispiels ist:

My string

Das folgende Beispiel zeigt deutlicher, dass die Reihenfolge der Schlüsselwortargumente keine Rolle spielt:

Beispiel (Python 2.0+)

#!/usr/bin/python # -*- coding: UTF-8 -*- # Funktionsdefinition 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="miki" )

Die Ausgabe des obigen Beispiels ist:

Name:  miki
Age  50

Standardargumente

Wenn beim Aufruf einer Funktion der Wert eines Standardparameters nicht übergeben wird, wird der Standardwert angenommen. Das folgende Beispiel gibt das Standardalter aus, wenn age nicht übergeben wird:

Beispiel (Python 2.0+)

#!/usr/bin/python # -*- coding: UTF-8 -*- # Funktionsdefinition 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="miki" ) printinfo( name="miki" )

Die Ausgabe des obigen Beispiels ist:

Name:  miki
Age  50
Name:  miki
Age  35

Parameter variabler Länge

Möglicherweise benötigen Sie eine Funktion, die mehr Parameter verarbeiten kann als in der ursprünglichen Deklaration angegeben. Diese Parameter werden Parameter mit variabler Länge genannt. Im Gegensatz zu den beiden oben genannten Typen werden sie in der Deklaration nicht benannt. Die grundlegende Syntax lautet wie folgt:

def functionname([formal_args,] *var_args_tuple ): "function_docstring" function_suite return [expression]

Variablennamen, denen ein Sternchen (*) vorangestellt ist, speichern alle unbenannten Parameter mit variabler Länge. Ein Beispiel für Parameter mit variabler Länge lautet wie folgt:

Beispiel (Python 2.0+)

#!/usr/bin/python # -*- coding: UTF-8 -*- # Funktionsdefinition def printinfo( arg1, *vartuple ): "Alle übergebenen Parameter ausgeben" print "Ausgabe:" print arg1 for var in vartuple: print var return # Aufruf der Funktion printinfo printinfo( 10 ) printinfo( 70, 60, 50 )

Die Ausgabe des obigen Beispiels ist:

输出:
10
输出:
70
60
50

Anonyme Funktionen

Python verwendet lambda, um anonyme Funktionen zu erstellen.

  • Lambda ist nur ein Ausdruck; der Funktionskörper ist viel einfacher als bei def.
  • Der Körper eines Lambda-Ausdrucks 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 Parameterliste oder im globalen Namensraum zugreifen.
  • Obwohl Lambda-Funktionen nur in einer Zeile geschrieben zu sein scheinen, sind sie nicht gleichwertig mit Inline-Funktionen in C oder C++, deren Zweck darin besteht, zu vermeiden, dass beim Aufruf kleiner Funktionen Stack-Speicher belegt wird, um die operative Effizienz zu erhöhen.

Syntax

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

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

Das folgende Beispiel:

Beispiel (Python 2.0+)

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

Die Ausgabe des obigen Beispiels ist:

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

return-Anweisung

Die return-Anweisung [expression] beendet die Funktion und gibt optional einen Ausdruck an den Aufrufer zurück. Eine return-Anweisung ohne Parameterwert gibt None zurück. Die vorherigen Beispiele haben nicht gezeigt, wie man einen Wert zurückgibt; das folgende Beispiel zeigt Ihnen, wie es geht:

Beispiel (Python 2.0+)

#!/usr/bin/python # -*- coding: UTF-8 -*- # Funktionsbeschreibung def sum( arg1, arg2 ): # Gibt die Summe von 2 Parametern zurück." total = arg1 + arg2 print "Innerhalb der Funktion:", total return total # Aufruf der Funktion sum total = sum( 10, 20 )

Die Ausgabe des obigen Beispiels ist:

函数内 :  30

Gültigkeitsbereich von Variablen

Nicht alle Variablen in einem Programm sind von jeder Stelle aus zugänglich. Die Zugriffsrechte hängen davon ab, wo die Variable zugewiesen wird.

Der Gültigkeitsbereich einer Variablen bestimmt, in welchem Teil des Programms Sie auf einen bestimmten Variablennamen zugreifen können. Die beiden grundlegendsten Gültigkeitsbereiche von Variablen sind wie folgt:
  • Globale Variablen
  • Lokale Variablen

Globale und lokale Variablen

Variablen, die innerhalb einer Funktion definiert werden, haben einen lokalen Gültigkeitsbereich, während diejenigen, die außerhalb einer Funktion definiert werden, einen globalen Gültigkeitsbereich haben.

Auf lokale Variablen kann nur innerhalb der Funktion zugegriffen werden, in der sie deklariert sind, während auf globale Variablen im gesamten Programm zugegriffen werden kann. Wenn eine Funktion aufgerufen wird, werden alle innerhalb der Funktion deklarierten Variablennamen zum Gültigkeitsbereich hinzugefügt. Wie im folgenden Beispiel:

Beispiel (Python 2.0+)

#!/usr/bin/python # -*- coding: UTF-8 -*- total = 0 # Dies ist eine globale Variable # Funktionsbeschreibung def sum( arg1, arg2 ): # Gibt die Summe von 2 Parametern zurück." total = arg1 + arg2 # total ist hier eine lokale Variable. print "Innerhalb der Funktion ist sie eine lokale Variable:", total return total # Aufruf der Funktion sum sum( 10, 20 ) print "Außerhalb der Funktion ist sie eine globale Variable:", total

Die Ausgabe des obigen Beispiels ist:

函数内是局部变量 :  30
函数外是全局变量 :  0
Weitere Erweiterungen