Erste Schritte mit Python-Funktionen

Um eine Funktion aufzurufen, müssen Sie den Namen und die Parameter der Funktion kennen, beispielsweise die Absolutwertfunktion abs, die einen Parameter erhält.

Sie können die Dokumentation direkt auf der offiziellen Website von Python anzeigen:
http://docs.python.org/2/library/functions.html#abs

Das können Sie Sehen Sie es sich auch an: Die interaktive Befehlszeile verwendet help(abs), um die Hilfeinformationen der abs-Funktion anzuzeigen.

Abs-Funktion aufrufen:

>>> abs(100)
100
>>> abs(-20)
20
>>> abs(12.34)
12.34

Wenn beim Aufruf einer Funktion die Anzahl der übergebenen Parameter falsch ist, wird ein TypeError gemeldet, und Python wird dies eindeutig tun sage dir: abs() hat nur einen Parameter, aber zwei sind gegeben:

>>> abs(1, 2)
Traceback (letzter Aufruf zuletzt):
Datei " ", Zeile 1, in
TypeError: abs() akzeptiert genau ein Argument (2 gegeben)

Wenn die Anzahl der übergebenen Argumente korrekt ist, aber Der Parametertyp kann von der Funktion nicht akzeptiert werden, es wird ein TypeError-Fehler gemeldet und eine Fehlermeldung ausgegeben: str ist der falsche Parametertyp:

>>>
Traceback (letzter Aufruf zuletzt):
Datei „“, Zeile 1, in
TypeError: bad operand type for abs(): 'str'

Die Vergleichsfunktion cmp(x, y) erfordert zwei Parameter. Wenn xy, gib 1 zurück:

>>> cmp(1, 2)
-1
>>> cmp(2, 1)
1
>>> )
0

Zu den häufig verwendeten in Python integrierten Funktionen gehören auch Datentypkonvertierungsfunktionen, wie z. B. die Funktion int(), die andere Datentypen in Ganzzahlen konvertieren kann:

>> ;> int('123')
123
>>> int(12.34)
12

str()-Funktion konvertiert andere Typen in str:

>>> str(123)
'123'
>>> str(1.23)
'1.23'

Funktionen schreiben:

Um in Python eine Funktion zu definieren, verwenden Sie die def-Anweisung, schreiben Sie den Funktionsnamen, Klammern, Parameter in Klammern und Doppelpunkt: und dann im Einzug Block Schreiben Sie den Funktionskörper und verwenden Sie die Return-Anweisung, um den Rückgabewert der Funktion zurückzugeben.

Nehmen wir das Beispiel der Anpassung einer my_abs-Funktion, die den absoluten Wert findet:

def my_abs(x):
if x >= 0:
return x else:
Return -x

Bitte beachten Sie, dass bei der Ausführung der Anweisungen im Funktionskörper nach der Ausführung von return die Funktion ausgeführt und das Ergebnis zurückgegeben wird. Daher kann durch bedingte Beurteilung und Schleifen eine sehr komplexe Logik innerhalb der Funktion implementiert werden.

Wenn keine Return-Anweisung vorhanden ist, wird das Ergebnis nach Ausführung der Funktion zurückgegeben, das Ergebnis ist jedoch None.

return None kann als return abgekürzt werden.

Mehrere Werte zurückgeben:

Kann eine Funktion mehrere Werte zurückgeben? Die Antwort ist ja.

Zum Beispiel muss man sich in Spielen oft von einem Punkt zum anderen bewegen. Anhand der Koordinaten, der Verschiebung und des Winkels können Sie die neuen Koordinaten berechnen:

# Das Mathematikpaket liefert sin ( ) und cos()-Funktionen referenzieren wir sie zunächst mit import:

import math
def move(x, y, step, angle):
nx = x + step * math.cos ( Winkel)
ny = y - step * math.sin(angle)
return nx, ny

Auf diese Weise können wir gleichzeitig den Rückgabewert erhalten:

> >> Tatsächlich ist dies nur eine Illusion. Die Python-Funktion gibt immer noch einen einzelnen Wert zurück:

>>> .pi / 6)
>> ;> print r

(151.96152422706632, 70.0)

Es stellt sich heraus, dass der Rückgabewert a ist Tupel!

Syntaktisch gesehen können Klammern jedoch weggelassen werden, wenn ein Tupel zurückgegeben wird, und mehrere Variablen können gleichzeitig ein Tupel empfangen und entsprechend der Position entsprechende Werte zuweisen. Daher gibt die Python-Funktion mehrere Werte zurück Gibt tatsächlich ein Tupel zurück, ist aber bequemer zu schreiben.

Rekursive Funktion:

Innerhalb der Funktion können weitere Funktionen aufgerufen werden. Eine Funktion ist rekursiv, wenn sie sich selbst intern aufruft.

Lassen Sie uns zum Beispiel die Fakultät n! = 1 * 2 * 3 * ... * n berechnen, dargestellt durch die Funktion fact(n). Es ist zu sehen:

def fact ( n):

if n==1:

return n * fact(n - 1)

Der Vorteil rekursiver Funktionen besteht darin, dass sie definiert sind Einfache und klare Logik. Theoretisch können alle rekursiven Funktionen in einer Schleife geschrieben werden, aber die Logik von Schleifen ist nicht so klar wie die von Rekursionen.

Achten Sie darauf, einen Stapelüberlauf zu verhindern, wenn Sie rekursive Funktionen verwenden. In Computern werden Funktionsaufrufe über die Datenstruktur des Stapels implementiert. Immer wenn ein Funktionsaufruf eingegeben wird, wird dem Stapel ein Stapelrahmen hinzugefügt. Da die Größe des Stapels nicht unendlich ist, führen zu viele rekursive Aufrufe zu einem Stapelüberlauf. Sie können versuchen, fact(10000) zu berechnen.

Die Definition der Funktion move(n, a, b, c) besteht darin, n Scheiben mit Hilfe von b von a nach c zu verschieben.

Referenzcode:

def move(n, a, b, c):
if n ==1:
print a, '-->', c
return
move(n-1, a, c, b)
print a, '-->', c
move(n-1, b, a, c)
move(4, 'A', 'B', 'C')

Der Weg zur Lösung des rekursiven Aufrufstapelüberlaufs liegt in der Endrekursionsoptimierung. Schwanzrekursion und Schleifen Der Effekt ist der gleiche, daher ist es auch möglich, die Schleife als spezielle Schwanzrekursivfunktion zu betrachten.

Tail-Rekursion bedeutet, dass sich die Funktion bei ihrer Rückkehr selbst aufruft und die Return-Anweisung keine Ausdrücke enthalten darf. Auf diese Weise kann der Compiler oder Interpreter die Endrekursion optimieren, sodass die Rekursion selbst unabhängig von der Häufigkeit des Aufrufs nur einen Stapelrahmen belegt und kein Stapelüberlauf auftritt.

Die obige Funktion fact(n) führt aufgrund der Rückgabe von n * fact(n - 1) einen Multiplikationsausdruck ein, sodass sie nicht endrekursiv ist. Um zur Schwanzrekursion zu wechseln, benötigen Sie etwas mehr Code, hauptsächlich um das Produkt jedes Schritts an die rekursive Funktion zu übergeben:

def fact(n):
return fact_iter(n, 1)def fact_iter (num, Produkt):
wenn num == 1: Produkt zurückgeben return fact_iter(num - 1, num * Produkt)

Wie Sie sehen können, geben Sie fact_iter(num - 1, num zurück * Produkt) gibt nur die rekursive Funktion selbst zurück und num * Produkt wird vor dem Aufruf der Funktion berechnet und hat keinen Einfluss auf den Funktionsaufruf. Der Aufruf von fact_iter(5, 1) entsprechend

fact(5) lautet wie folgt:

===> fact_iter(5, 1)
===> fact_iter(4 , 5)
===> fact_iter(3, 20)
===> fact_iter(2, 60)
===> fact_iter(1, 120)
== => 120

Wenn die Optimierung durchgeführt wird, wächst der Stapel nicht, sodass es unabhängig von der Häufigkeit des Aufrufs nicht zu einem Stapelüberlauf kommt.

Leider sind die meisten Programmiersprachen nicht für die Tail-Rekursion optimiert, und der Python-Interpreter ist nicht optimiert. Selbst wenn die obige Funktion fact(n) in Tail-Rekursion geändert wird, führt dies zu Problemen der Stapelüberlauf.

Standardparameter definieren:

Beim Definieren einer Funktion können Sie auch Standardparameter festlegen.

Zum Beispiel hat die int()-Funktion, die mit Python geliefert wird, tatsächlich zwei Parameter. Wir können entweder einen Parameter oder zwei Parameter übergeben:

>>> )
123
>>> int('123', 8)
83

Der zweite Parameter der int()-Funktion ist die Konvertierungsbasis, wenn nicht übergeben, der Standardwert ist dezimal (Basis=10). Bei Übergabe werden die übergebenen Parameter verwendet.

Es ist ersichtlich, dass die Standardparameter der Funktion zur Vereinfachung des Aufrufs verwendet werden. Sie müssen nur die erforderlichen Parameter übergeben. Bei Bedarf können jedoch zusätzliche Parameter übergeben werden, um die Standardparameterwerte zu überschreiben.

Lassen Sie uns eine Funktion definieren, die > n = n - 1 berechnet

s = s * x

s zurückgibt


Angenommen, dass die Anzahl der Quadrate am häufigsten berechnet wird , wir können den Standardwert von n auf 2 setzen:

def power(x, n=2):
s = 1

while n > 0:

n = n - 1

s = s * x

return s


Auf diese Weise ist es nicht erforderlich, zwei Parameter zur Berechnung des Quadrats zu übergeben:

>> ;> power(5)
25

Da die Parameter der Funktion von links nach rechts übereinstimmen, können die Standardparameter nur nach den erforderlichen Parametern definiert werden:

# OK:def fn1(a, b=1, c=2 ):
pass# Error:def fn2(a=1, b):

pass

Zuerst definieren eine Funktion, übergeben Sie eine Liste, fügen Sie ein END hinzu und geben Sie Folgendes zurück:

def add_end(L=[]):
L.append('END') return L

Das Ergebnis scheint gut zu sein, wenn Sie es normal aufrufen:

>>> add_end([1, 2, 3])[1, 2, 3, 'END']>>> add_end(['x', 'y', 'z']) ['x', 'y', 'z', 'END']

Wenn Sie es mit Standardparametern aufrufen, Das erste Ergebnis ist ebenfalls korrekt:

>> ;> add_end()['END']

Wenn add_end() jedoch erneut aufgerufen wird, ist das Ergebnis falsch :

>>> add_end()[ 'END', 'END']>>> add_end()['END', 'END', 'END']

Viele Anfänger sind verwirrt. Der Standardparameter ist [], aber die Funktion scheint sich die Liste zu „merken“, nachdem sie das letzte Mal „END“ hinzugefügt hat.

Der Grund wird wie folgt erklärt:

Wenn die Python-Funktion definiert ist, wird der Wert des Standardparameters L berechnet, also [], da der Standardparameter L auch a ist Variable, die auf das Objekt [] zeigt. Wenn sich bei jedem Aufruf der Funktion der Inhalt von L ändert, ändert sich der Inhalt des Standardparameters beim nächsten Aufruf und ist nicht mehr [], wenn die Variable aufgerufen wird Funktion definiert wurde.

Bei der Definition von Standardparametern ist also eines zu beachten: Die Standardparameter müssen auf unveränderliche Objekte verweisen!

Um das obige Beispiel zu modifizieren, können wir das unveränderliche Objekt None verwenden:

def add_end(L=None):
if L is None:
L = []
L.append('END') return L

Jetzt wird es kein Problem geben, egal wie oft Sie es aufrufen:

>>> add_end ()['END']>>> add_end()['END']

Warum sollten wir unveränderliche Objekte wie str und None entwerfen? Denn sobald ein unveränderliches Objekt erstellt wurde, können die Daten im Objekt nicht mehr geändert werden, wodurch Fehler durch die Änderung von Daten reduziert werden. Da das Objekt unverändert bleibt, besteht außerdem keine Notwendigkeit, das Objekt beim gleichzeitigen Lesen in einer Multitasking-Umgebung zu sperren, und beim gleichzeitigen Lesen treten überhaupt keine Probleme auf. Wenn wir ein Programm schreiben und ein unveränderliches Objekt entwerfen können, versuchen wir, es als unveränderliches Objekt zu entwerfen.

Variable Parameter definieren:

Wenn wir möchten, dass eine Funktion eine beliebige Anzahl von Parametern akzeptiert, können wir einen variablen Parameter definieren:

def fn(*args):
print args

Vor dem Namen des Variablenparameters steht ein *. Wir können 0, 1 oder mehr Parameter übergeben Variable Parameter: 🎜>>>> fn('a', 'b')

('a', 'b')

>>> ', ' c')
('a', 'b', 'c')




Der Python-Interpreter fügt den eingehenden Parametersatz zu einem Tupel zusammen und übergeben Sie es an gegebene variable Parameter. Behandeln Sie daher innerhalb der Funktion die Variablen args einfach als Tupel.

Schlüsselwortparameter:

Variable Parameter ermöglichen die Übergabe von 0 oder einer beliebigen Anzahl von Parametern. Diese variablen Parameter werden beim Aufruf der Funktion automatisch zu einem Tupel zusammengesetzt. Mit Schlüsselwortparametern können Sie 0 oder eine beliebige Anzahl von Parametern übergeben, die Parameternamen enthalten. Diese Schlüsselwortparameter werden automatisch zu einem Diktat innerhalb der Funktion zusammengestellt. Bitte sehen Sie sich das Beispiel an:

def person(name, age, **kw):

print('name:', name, 'age:', age, 'other:', kw)

Zusätzlich zu den erforderlichen Parametern Name und Alter akzeptiert die Funktion Person auch den Schlüsselwortparameter kw. Beim Aufruf dieser Funktion können Sie nur die erforderlichen Parameter übergeben:

>>> person('Michael', 30)
Name: Michael Alter: 30 andere: {}

Sie können auch eine beliebige Anzahl von Schlüsselwortparametern übergeben:

>>> person('Bob', 35, city='Peking')
Name: Bob Alter : 35 andere: {'city': 'Beijing'}>>> Person('Adam', 45, Geschlecht='M', Job='Ingenieur')
Name: Adam Alter: 45 andere: {'gender': 'M', 'job': 'Engineer'}

Wozu dienen Keyword-Parameter? Es kann die Funktionalität der Funktion erweitern. Beispielsweise erhalten wir in der Personenfunktion garantiert die beiden Parameter Name und Alter, wenn der Aufrufer jedoch bereit ist, weitere Parameter anzugeben, können wir diese auch erhalten. Stellen Sie sich vor, Sie führen eine Benutzerregistrierungsfunktion aus, mit Ausnahme des Benutzernamens und des Alters, die erforderlich sind. Die Verwendung von Schlüsselwortparametern zum Definieren dieser Funktion kann die Registrierungsanforderungen erfüllen.

Benannte Schlüsselwortparameter:

Für Schlüsselwortparameter kann der Aufrufer der Funktion beliebige unbegrenzte Schlüsselwortparameter übergeben. Was die Übergabe angeht, müssen Sie die kw-Prüfung innerhalb der Funktion bestehen.

Am Beispiel der Funktion person() wollen wir prüfen, ob Stadt- und Jobparameter vorhanden sind:

def person(name, age, **kw):

if 'city' In KW:# i CITY-Parameter

PASS

if 'job' in kw:# Have a job parameter

PASS

Print ('name:', name: ', Age, ' Other, 'Other', Other :', kw)

Aber der Aufrufer kann weiterhin uneingeschränkte Schlüsselwortargumente übergeben:

>>> , 24, Stadt ='Beijing', Adresse ='Chaoyang', Postleitzahl =123456)

Wenn Sie die Namen von Schlüsselwortparametern einschränken möchten, können Sie beispielsweise nur benannte Schlüsselwortparameter verwenden Erhalten Sie Stadt und Job als Schlüsselwortparameter. Die auf diese Weise definierte Funktion lautet wie folgt:

def person(name, age, *, city, job):

print(name, age, city, job)

Im Gegensatz zu Schlüsselwortparametern **kw erfordern benannte Schlüsselwortparameter ein spezielles Trennzeichen *, und die Parameter nach * werden als benannte Schlüsselwortparameter betrachtet.

Die Aufrufmethode lautet wie folgt:

>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

Benannte Schlüsselwortparameter müssen im Parameternamen übergeben werden, der sich von Positionsparametern unterscheidet. Wenn kein Parametername übergeben wird, meldet der Aufruf einen Fehler:

>>> person('Jack', 24, 'Beijing', 'Engineer')
Traceback (aktuellste call last):
Datei „“, Zeile 1, in TypeError: person() nimmt 2 Positionsargumente, aber 4 wurden angegeben

Aufgrund des fehlenden Parameters Wenn Sie beim Aufruf Stadt und Job benennen, behandelt der Python-Interpreter diese vier Parameter als Positionsparameter, die Funktion person() akzeptiert jedoch nur zwei Positionsparameter.

Benannte Schlüsselwortargumente können Standardwerte haben, was Aufrufe vereinfacht:

def person(name, age, *, city='Peking', job):
print(name , age, Stadt, Job)

Da der benannte Schlüsselwortparameter Stadt einen Standardwert hat, müssen Sie beim Aufruf von:

>>> keinen Stadtparameter übergeben (' Jack', 24, job='Engineer')
Jack 24 Beijing Engineer

Achten Sie bei der Verwendung benannter Schlüsselwortparameter besonders darauf, dass * kein Parameter, sondern ein Parameter ist spezielles Trennzeichen. Wenn * fehlt, erkennt der Python-Interpreter keine Positionsargumente und benannten Schlüsselwortargumente:

def person(name, age, city, job):
#Wenn * fehlt, werden Stadt und Job als behandelt Positionen Parameter
übergeben

Parameterkombination:

Funktionen in Python definieren, Sie können erforderliche Parameter, Standardparameter, variable Parameter, Schlüsselwortparameter und benannte Schlüsselwortparameter verwenden, diese fünf Parameter können in Kombination verwendet werden, mit der Ausnahme, dass variable Parameter nicht mit benannten Schlüsselwortparametern gemischt werden können. Bitte beachten Sie jedoch, dass die Reihenfolge der Parameterdefinitionen wie folgt lauten muss: erforderliche Parameter, Standardparameter, variadische Parameter/benannte Schlüsselwortparameter und Schlüsselwortparameter.

Definieren Sie beispielsweise eine Funktion, die die oben genannten Parameter enthält:

def f1(a, b, c=0, *args, **kw):
print('a = ', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)def f2(a, b, c=0, *, d, ** kw ):
print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)

Beim Aufruf der Funktion übergibt der Python-Interpreter automatisch die entsprechenden Parameter entsprechend der Parameterposition und dem Parameternamen.

>>> f1(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}>>> c=3)
a = 1 b = 2 c = 3 args = () kw = {}>>> f1(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}>>> f1(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}>>> f2(1, 2, d=99, ext=Keine )
a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}

Das Erstaunlichste ist, dass Sie durch ein Tupel und ein Diktat auch anrufen können die obige Funktion:

>>> args = (1, 2, 3, 4)>>> >> ;> f1(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'} >> ;> args = (1, 2, 3)>>> kw = {'d': 88, 'x': '#'}>>> *kw)
a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}

Also können Sie für jede Funktion so etwas wie func übergeben (*args, **kw), unabhängig davon, wie seine Argumente definiert sind.

Zusammenfassung

Pythons Funktionen verfügen über sehr flexible Parameterformen, die nicht nur einfache Aufrufe implementieren, sondern auch sehr komplexe Parameter übergeben können.

Die Standardparameter müssen unveränderliche Objekte verwenden. Wenn es sich um veränderliche Objekte handelt, treten beim Ausführen des Programms Logikfehler auf!

Achten Sie auf die Syntax zum Definieren variabler Parameter und Schlüsselwortparameter:

*args ist ein variabler Parameter und args empfängt ein Tupel; **kw ist der Schlüssel Wortparameter, kw erhält ein Diktat.

Und die Syntax zum Übergeben von Variablenparametern und Schlüsselwortparametern beim Aufruf einer Funktion:

Variablenparameter können direkt übergeben werden: func(1, 2, 3) oder zuerst Assemble die Liste oder das Tupel und übergeben Sie es dann über *args: func(*(1, 2, 3));

Schlüsselwortparameter können direkt übergeben werden: func(a=1, b=2) , Sie können das Diktat auch zuerst zusammenstellen und es dann über **kw: func(**{'a': 1, 'b': 2}) übergeben.

Die Verwendung von *args und **kw ist die Redewendung von Python. Natürlich können auch andere Parameternamen verwendet werden, am besten ist es jedoch, die Redewendung zu verwenden.

Benannte Schlüsselwortparameter werden verwendet, um die Parameternamen einzuschränken, die der Aufrufer übergeben kann, und um Standardwerte bereitzustellen.

Vergessen Sie nicht, beim Definieren benannter Schlüsselwortparameter das Trennzeichen * zu schreiben, da sonst Positionsparameter definiert werden.