Einführung in die Python-Grundlagen – Funktion

8. Funktion

1. Eine Funktion ist ein benannter Codeblock, der zum Abschließen einer bestimmten Arbeit verwendet wird. Def-Funktionsdefinition unter Angabe des Funktionsnamens. Bei der Definition einer Funktion legen wir die Namen und Positionen der -Parameter fest und die Schnittstellendefinition der -Funktion ist abgeschlossen. Für den Aufrufer der Funktion reicht es aus, zu wissen, wie er die richtigen Parameter übergibt und welchen Wert die Funktion zurückgibt . Die komplexe Logik innerhalb der Funktion ist gekapselt weiß es nicht.

2. Um eine bestimmte, durch eine Funktion definierte Aufgabe auszuführen, rufen Sie die Funktion auf. Wenn Sie dieselbe Aufgabe mehrmals in einem Programm ausführen, müssen Sie nicht wiederholt Code schreiben, um die Aufgabe abzuschließen. Sie müssen lediglich die Funktion aufrufen, die die Aufgabe ausführt, und Python den Code ausführen lassen.

3. Funktion höherer Ordnung heißt im Englischen Funktion höherer Ordnung

8.1 Tatsächliche Parameter und formale Parameter

Formale Parameter : Informationen zum Abschluss der Funktion, die für ihre Arbeit erforderlich sind.

Tatsächliche Parameter: Informationen, die beim Aufruf der Funktion an die Funktion übergeben werden.

8.2 Übergabe von Parametern

Die Funktionsdefinition kann mehrere formale Parameter enthalten, daher kann der Funktionsaufruf auch mehrere tatsächliche Parameter enthalten. Es gibt viele Möglichkeiten, tatsächliche Parameter an die Funktion zu übergeben. Dazu muss die Reihenfolge der tatsächlichen Parameter mit der Reihenfolge der formalen Parameter übereinstimmen ; Wörter, in denen jeder tatsächliche Parameter durch aus Variablennamen und -werten zusammengesetzte Listen und Wörterbücher dargestellt wird, können ebenfalls verwendet werden.

8.2.1 Positionsparameter

1. Wenn Sie eine Funktion aufrufen, muss Python jeden tatsächlichen Parameter im Funktionsaufruf einem formalen Parameter in der Funktionsdefinition zuordnen. Die einfache Zuordnung basiert auf der Reihenfolge der tatsächlichen Parameter. Diese Assoziation wird als Positionsargument bezeichnet.

2. In einer Funktion können Sie nach Bedarf eine beliebige Anzahl von Positionsargumenten verwenden, und Python ordnet die tatsächlichen Parameter im Funktionsaufruf der Reihe nach den entsprechenden formalen Parametern in der Funktionsdefinition zu.

3. Wenn Sie Positionsargumente zum Aufrufen einer Funktion verwenden und die Reihenfolge der Argumente falsch ist, ist die Ausgabe nicht korrekt.

8.2.2 Schlüsselwortargumente und Schlüsselwortparameter

Schlüsselwortargumente sind (Name-Wert-)Paare, die an die Funktion übergeben werden. Sie verknüpfen den Namen und den Wert direkt im Argument, sodass bei der Übergabe des Arguments an die Funktion keine Verwirrung entsteht. Schlüsselwortargumente machen es überflüssig, sich Gedanken über die Reihenfolge der Argumente in einem Funktionsaufruf zu machen, und geben den Zweck jedes Werts im Funktionsaufruf klar an.

describe_pet(animal_type='hamster', pet_name='harry')

describe_pet(

animal_type='hamster', pet_name='harry')

>>> person('Bob', 35, city='Beijing')

name: Bob age: 35 other: {'city': 'Beijing'}

>>> person('Adam', 45, gender='M', job='Engineer')

name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

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

>>> person('Bob', 35, city='Peking')

Name: Bob Alter: 35 Sonstiges: {'Stadt': 'Beijing'}>>> Person('Adam', 45, Geschlecht='M', Job='Ingenieur')

def add_end(L=None):

    if L is None:

        L = []

    L.append('END')

    return L

Name: Adam Alter: 45 Sonstiges: {'Geschlecht': 'M', 'Job': 'Ingenieur'}

8.2.3 Standardwert

Beim Schreiben einer Funktion können Sie für jeden Formalparameter einen Standardwert angeben. Wenn ein tatsächlicher Parameter für einen formalen Parameter in der aufrufenden Funktion bereitgestellt wird, verwendet Python den angegebenen tatsächlichen Parameterwert; andernfalls wird der Standardwert des formalen Parameters verwendet. Daher können nach der Zuweisung von Standardwerten zu formalen Parametern die entsprechenden tatsächlichen Parameter im Funktionsaufruf weggelassen werden. Die Verwendung von Standardwerten vereinfacht Funktionsaufrufe und zeigt deutlich typische Verwendungszwecke der Funktion an. Der größte Vorteil besteht darin, dass die Schwierigkeit beim Aufrufen von Funktionen verringert werden kann.

def calc(*numbers):

    sum = 0

    for n in numbers:

        sum = sum + n * n

    return sum

Standardparameter müssen auf unveränderliche Objekte verweisen!

>>> calc(1, 2)

5

>>> calc()

0

tbody>

def add_end(L=None):

>>> nums = [1, 2, 3]

>>> calc(*nums)

14

wenn L None ist: L = [] L.append('END') return L

8.2.4 Variable Parameter Im Vergleich zur Definition eines Listen- oder Tupelparameters erfordert die Definition eines variablen Parameters nur ein *-Zeichen vor dem Parameter. Innerhalb der Funktion erhält die Parameternummer ein Tupel, sodass der Funktionscode völlig unverändert bleibt. Beim Aufruf dieser Funktion können jedoch beliebig viele Parameter übergeben werden, darunter auch 0 Parameter.

def calc(*numbers): sum = 0 für n in Zahlen: sum = sum + n * n return sum

>>> calc(1, 2)5>>> calc()0

　Python Ermöglicht das Hinzufügen eines *-Zeichens vor der Liste oder dem Tupel und die Übergabe der Elemente der Liste oder des Tupels an variable Parameter:

>>> nums = [1, 2, 3]>>> calc(*nums)14

*nums bedeutet, dass alle Elemente der Nums-Liste als variable Parameter übergeben werden.

8.2.5 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.

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

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

    print(name, age, city, job)

def person(name, age, *, Stadt, Job):

print(name, age, city, job)

und Schlüsselwortparameter ** kw Anders ausgedrückt erfordern benannte Schlüsselwortparameter ein spezielles Trennzeichen *, und die Parameter, die auf * folgen, werden als benannte Schlüsselwortparameter behandelt.

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

    print(name, age, args, city, job)

Wenn in der Funktionsdefinition bereits ein variabler Parameter vorhanden ist, benötigt der folgende benannte Schlüsselwortparameter kein spezielles Trennzeichen mehr*:

>>> person('Jack', 24, 'Beijing', 'Engineer')

Traceback (most recent call last):

  File "", line 1, in

TypeError: person() takes 2 positional arguments but 4 were given

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

print(name, age, args, city, job)

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

def person(name, age, *, city='Beijing', job):

    print(name, age, city, job)

> >> Person('Jack', 24, 'Peking', 'Ingenieur')

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

Jack 24 Beijing Engineer

Traceback (letzter Anruf zuletzt):

Datei „“, Zeile 1 , in < module>

TypeError: person() nimmt 2 Positionsargumente, aber 4 wurden angegeben

Weil der Parameter Name Stadt beim Aufruf und Job fehlt, behandelt der Python-Interpreter diese 4 Parameter als Positionsparameter, aber die Funktion person() akzeptiert nur 2 Positionsparameter.

Benannte Schlüsselwortparameter können Standardwerte (Standardwerte) haben, wodurch Aufrufe vereinfacht werden:

tr>

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

print(name, age, city, job)

def nop():

    pass

Da der benannte Schlüsselwortparameter „city“ einen Standardwert hat, müssen Sie beim Aufruf von

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

Jack 24 Beijing Engineer

td>

Vergessen Sie beim Definieren benannter Schlüsselwortparameter nicht, das Trennzeichen * zu schreiben, wenn keine variablen Parameter vorhanden sind, da die Definition sonst positionell ist Parameter.

8.2.5 Äquivalente Funktionsaufrufe

Die Ausgabeergebnisse sind die gleichen, aber die Aufrufmethoden sind unterschiedlich.

Hinweis: Es spielt keine Rolle, welche Aufrufmethode Sie verwenden, solange der Funktionsaufruf die gewünschte Ausgabe erzeugt. Verwenden Sie einfach die Aufrufmethode, die für Sie am einfachsten zu verstehen ist.

8.2.6 Leere Funktion (Pass)

Wenn Sie eine leere Funktion definieren möchten, die nichts tut, können Sie die Pass-Anweisung verwenden:

Die pass-Anweisung bewirkt nichts. Wenn Sie beispielsweise noch nicht herausgefunden haben, wie der Funktionscode geschrieben wird, können Sie zuerst einen pass einfügen, damit der Code ausgeführt werden kann .

def nop():

>>> x, y = move(100, 100, 60, math.pi / 6)

>>> print(x, y)

151.96152422706632 70.0

pass

>>> r = move(100, 100, 60, math.pi / 6)

>>> print(r)

(151.96152422706632, 70.0)

8.2.7 Fehler bei tatsächlichen Parametern vermeiden Es werden keine tatsächlichen Parameter angegeben, die tatsächliche Parameterreihenfolge ist falsch und das tatsächliche Parameterformat (Anführungszeichen usw.) wird nicht beachtet. 8.2.8 globale Anweisung (globale Variable) Wenn Sie den in einer globalen Variablen in einer Funktion gespeicherten Wert ändern möchten, müssen Sie die globale Anweisung für die Variable verwenden. 8.3 Rückgabewert Eine Funktion zeigt die Ausgabe nicht immer direkt an, sondern kann stattdessen einige Daten verarbeiten und einen Wert oder eine Reihe von Werten zurückgeben. Der von einer Funktion zurückgegebene Wert wird als Rückgabewert bezeichnet. Der Rückgabewert der Funktion wird mit der return-Anweisung zurückgegeben. Innerhalb einer Funktion können Sie die Return-Anweisung verwenden, um einen Wert an die Codezeile zurückzugeben, die die Funktion aufgerufen hat. Mit Rückgabewerten können Sie Ihr Hauptprogramm vereinfachen, indem Sie den größten Teil des Programmaufwands in Funktionen verlagern. 8.3.1 Mehrere Werte zurückgeben Die Anweisung „import math“ bedeutet den Import des Mathematikpakets und ermöglicht es nachfolgendem Code, auf Sin, Cos und andere Funktionen im Mathematikpaket zu verweisen. Sie können mehrere Werte zurückgeben. table> Tatsächlich ist dies jedoch nur eine Illusion, die Python-Funktion gibt immer noch einen einzelnen Wert zurück:

>>> , math.pi / 6)>>> print(x, y)151.96152422706632 70.0

>>> r = move(100, 100, 60, math.pi / 6)>>> print(r) ( 151.96152422706632, 70.0)

Der Rückgabewert ist ein 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 Funktion von Python, die mehrere Werte zurückgibt, tatsächlich ein Tupel zurück. aber es ist bequemer zu schreiben.

8.3.2 Den Aktualparameter optional machen

Verwenden Sie die if-Anweisung, um zu bestimmen, ob dieser Aktualparameter benötigt wird.

8.3.3 Wörterbuch zurückgeben

Die Funktion kann jede Art von Wert zurückgeben, einschließlich komplexerer Datenstrukturen wie Listen und Wörterbücher.

8.3.4 Rückgabefunktion

Neben der Annahme von Funktionen als Parameter können Funktionen höherer Ordnung auch Funktionen als Ergebniswerte zurückgeben. Wenn Sie nicht sofort summieren müssen, können Sie das Summierungsergebnis nicht zurückgeben, sondern die Summationsfunktion zurückgeben:

def lazy_sum(*args):

    def sum():

        ax = 0

        for n in args:

            ax = ax + n

        return ax

    return sum

def lazy_sum(*args):

def sum():

>>> f = lazy_sum(1, 3, 5, 7, 9)

>>> f

.sum at 0x101c6ed90>

ax = 0

>>> f()

25

für n in args:

ax = ax + n

return ax

>>> f1 = lazy_sum(1, 3, 5, 7, 9)

>>> f2 = lazy_sum(1, 3, 5, 7, 9)

>>> f1==f2

False

return sum

Wenn wir lazy_sum() aufrufen, Zurückgegeben wird nicht das Summationsergebnis, sondern die Summationsfunktion:

> ;> f = lazy_sum(1, 3, 5, 7, 9)

def get_formatted_name(first_name, last_name):  

            """返回整洁的姓名"""   

　　full_name = first_name + ' ' + last_name   

　　return full_name.title()

while True:   

　　print("nPlease tell me your name:")   

　　print("(enter 'q' at any time to quit)")   

　　f_name = input("First name: ")   

　　if f_name == 'q':       

　　　　break   

　　l_name = input("Last name: ")   

　　if l_name == 'q':       

　　　　break   

formatted_name = get_formatted_name(f_name, l_name)   

print("nHello, " + formatted_name + "!")

>>> f

.sum at 0x101c6ed90> ;

Wenn die Funktion f aufgerufen wird, wird das Ergebnis der Summe tatsächlich berechnet:

def count():

    def f(j):

        def g():

            return j*j

        return g

    fs = []

    for i in range(1, 4):

        fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()

return fs

>>> f1, f2, f3 = count()

>>> f1()

1

>>> f2()

4

>>> f3()

9

>>> f()25

　Hinweis: Wenn wir lazy_sum() aufrufen, gibt jeder Aufruf eine neue Funktion zurück, auch wenn dieselben Parameter übergeben werden:

>>> f1 = lazy_sum(1, 3, 5, 7, 9)> ;>> f2 = lazy_sum(1, 3, 5, 7, 9)>>> f1==f2Falsch

　 Die Aufrufergebnisse von f1() und f2() beeinflussen sich nicht gegenseitig. 8.3.5 Verwenden von Funktionen mit while

def get_formatted_name(first_name, last_name): """Den ordentlichen Namen zurückgeben""" full_name = first_name + ' ' + last_name return full_name.title() while True: print("nBitte sagen Sie mir Ihren Namen:") print("(zum Beenden können Sie jederzeit 'q' eingeben)") f_name = input("Vorname: ") if f_name == 'q': break l_name = input("Nachname: ") if l_name == 'q': break formatted_name = get_formatted_name(f_name, l_name) print("nHello, " + formatted_name + "!")

8.3.6 Abschluss Bei der Rückgabe eines Abschlusses ist Folgendes zu beachten: Die Rückgabefunktion verweist nicht auf Schleifenvariablen oder Variablen, die dies tun nachträglich ändern. Wenn Sie auf eine Schleifenvariable verweisen müssen, besteht die Methode darin, eine Funktion zu erstellen und die Parameter der Funktion zu verwenden, um den aktuellen Wert der Schleifenvariablen zu binden. Unabhängig davon, wie sich die Schleifenvariable anschließend ändert, ändert sich der an den Funktionsparameter gebundene Wert Der Nachteil besteht darin, dass der Code länger ist. Sie können ihn mit Lambda-Funktionen kürzen.

def count(): def f(j): def g(): return j*j return g fs = [] for i in range( 1, 4): fs.append(f(i)) # f(i) wird sofort ausgeführt, daher wird der aktuelle Wert von i an f() übergebenreturn fs>>> f1, f2, f3 = count()>>> > ;> f2()4>>> f3()

8.3.7 Anonyme Funktion Lambda

Wenn wir eine Funktion übergeben, müssen wir die Funktion manchmal nicht explizit definieren. Es ist bequemer, die anonyme Funktion direkt zu übergeben.

In Python gibt es begrenzte Unterstützung für anonyme Funktionen. Nehmen wir immer noch die Funktion map() als Beispiel: Bei der Berechnung von f(x)=x2 können Sie neben der Definition einer Funktion von f(x) auch direkt eine anonyme Funktion übergeben:

table>

Aus dem Vergleich geht hervor, dass die anonyme Funktion lambda x: x * x tatsächlich ist:

>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))

[1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> list(map(lambda x: x * x, [1, 2, 3, 4 , 5, 6, 7, 8, 9]))

[1, 4, 9, 16, 25, 36, 49, 64, 81]

def f(x):

    return x * x

def f(x):

>>> f = lambda x: x * x

>>> f

at 0x101c6ef28>

>>> f(5)

25

return x * x

Das Schlüsselwort Lambda stellt eine anonyme Funktion dar, das x vor dem Doppelpunkt stellt den Funktionsparameter dar. Anonyme Funktionen haben eine Einschränkung, das heißt, sie können nur einen Ausdruck haben. Es ist nicht erforderlich, einen Rückgabewert zu schreiben. Die Verwendung anonymer Funktionen bietet einen Vorteil, da die Funktion keinen Namen hat, sodass Sie sich keine Sorgen über Funktionsnamenkonflikte machen müssen. Darüber hinaus ist die anonyme Funktion auch ein Funktionsobjekt. Sie können die anonyme Funktion auch einer Variablen zuweisen und diese dann zum Aufrufen der Funktion verwenden: >>> f = lambda x: x * x>>> Funktion bei 0x101c6ef28>>>> f(5)25

8.4 Übergabe einer Liste

für Namen in Namen: Sie werden es oft nützlich finden, eine Liste an eine Funktion zu übergeben. Diese Liste kann Namen, Zahlen oder komplexere Objekte enthalten . (wie ein Wörterbuch). Sobald eine Liste an eine Funktion übergeben wird, kann die Funktion direkt auf deren Inhalt zugreifen. Verwenden Sie die folgenden Funktionen, um die Effizienz der Verarbeitung von Listen zu verbessern.

8.4.1 Ändern Sie die Liste in der Funktion

　1. Nachdem Sie die Liste an die Funktion übergeben haben, kann die Funktion sie ändern. Alle innerhalb der Funktion an dieser Liste vorgenommenen Änderungen sind dauerhaft, sodass Sie große Datenmengen effizient verarbeiten können.

　2. Append-Pop hinzufügen oder löschen

　3. Eine Funktion schließt eine Aufgabe ab und Funktionen können sich gegenseitig aufrufen. Optimieren Sie Funktionen, um Wartung und Änderung zu erleichtern.

8.4.2 Es ist verboten, die Funktion zu ändern

Um dieses Problem zu lösen, können Sie auf diese Weise eine Kopie der Liste anstelle des Originals an die Funktion übergeben; Die Funktion wirkt sich nur auf die Kopie und nicht auf das Original aus.

　function_name(list_name[:]), [:] entspricht dem Kopieren.

8.5 Übergeben Sie eine beliebige Anzahl tatsächlicher Parameter (Variablenparameter)

Manchmal wissen Sie nicht im Voraus, wie viele tatsächliche Parameter eine Funktion akzeptieren muss. Glücklicherweise ermöglicht Python das Sammeln Beliebige Anzahl tatsächlicher Parameter aus der aufrufenden Anweisung. Die Anzahl der Argumente.

def make_pizza(*toppings):

Das Sternchen im Parameternamen *toppings weist Python an, ein leeres Tupel namens toppings zu erstellen und alle empfangenen Werte in diesem Tupel zu kapseln. Die print-Anweisung im Funktionskörper generiert eine Ausgabe, um zu demonstrieren, dass Python sowohl den Aufruf der Funktion mit einem Wert als auch den Aufruf der Funktion mit drei Werten bewältigen kann. Es behandelt verschiedene Aufrufe auf ähnliche Weise. Beachten Sie, dass Python die Argumente in einem Tupel kapselt, auch wenn die Funktion nur einen einzelnen Wert empfängt.

8.5.1 Positionsargumente und Variablenargumente kombinieren

Wenn Sie möchten, dass eine Funktion verschiedene Arten von Argumenten akzeptiert, müssen Sie eine beliebige Anzahl formaler Parameter in die Funktionsdefinition aufnehmen. Python gleicht zunächst Positionsargumente und Schlüsselwortargumente ab und sammelt dann die verbleibenden Argumente im letzten formalen Parameter.

8.5.2 Verwendung variabler Argumente und Schlüsselwortargumente

Def build_profile(first, last, **user_info):

Definitionsanforderungen der Funktion build_profile() Stellt ein erstes und bereit Nachnamen, wobei der Benutzer beliebig viele Name-Wert-Paare angeben kann. Die beiden Sternchen im formalen Parameter **user_info weisen Python an, ein leeres Wörterbuch mit dem Namen user_info zu erstellen und alle empfangenen Name-Wert-Paare in dieses Wörterbuch zu kapseln. In dieser Funktion kann wie in jedem anderen Wörterbuch auf die Name-Wert-Paare in user_info zugegriffen werden.

für Schlüssel, Wert in user_info.items():   

　 Profil[Schlüssel] = Wert

user_profile = build_profile('albert', 'einstein',location=' Princeton', field='physics')

8.5.3 Parameterkombinationen verwenden

　1. Definieren Sie Funktionen in Python. Sie können erforderliche Parameter, Standardparameter, variable Parameter, Schlüsselwortparameter und benannte Parameter verwenden Schlüsselwortparameter, diese fünf Parameter können in Kombination verwendet werden. Bitte beachten Sie jedoch, dass die Reihenfolge der Parameterdefinition sein muss: Erforderliche Parameter, Standardparameter, variable Parameter, benannte Schlüsselwortparameter und Schlüsselwortparameter.

2. Python-Funktionen verfügen über eine sehr flexible Parameterform, die nicht nur einfache Aufrufe implementieren, sondern auch sehr komplexe Parameter übergeben kann.

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

4. Achten Sie auf die Syntax zum Definieren von Variablenparametern und Schlüsselwortparametern:

5. *args ist ein variabler Parameter und args empfängt ein Tupel; **kw ist ein Schlüsselwortparameter und kw erhält ein Diktat.

　7. Und die Syntax zur Übergabe variabler Parameter und Schlüsselwortparameter beim Aufruf einer Funktion:

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

übergeben. Die Schlüsselwortparameter können direkt übergeben werden: func(a=1 , b=2 ), können Sie das Diktat 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.

8.5.4 Rekursive Parameter

Innerhalb einer Funktion können Sie andere Funktionen aufrufen. Wenn eine Funktion sich selbst

innerhalb von

aufruft, ist die Funktion rekursiv. Die Vorteile rekursiver Funktionen liegen in der einfachen Definition und klaren 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.

def fact(n):

def fact(n):

    if n==1:

        return 1

    return n * fact(n - 1)

wenn n==1 : return 1 return n * fact(n - 1)

Bei der Verwendung rekursiver Funktionen muss darauf geachtet werden, einen Stapelüberlauf zu verhindern. 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.

Die Bewegung des Turms von Hanoi lässt sich sehr einfach über rekursive Funktionen umsetzen.

8.6 Funktionen höherer Ordnung

8.6.1 Funktionen höherer Ordnung

Da Variablen auf Funktionen zeigen können und die Parameter von Funktionen Variablen empfangen können, kann eine Funktion empfangen Eine andere Funktion Als Parameter wird diese Art von Funktion als Funktion höherer Ordnung bezeichnet.

def add(x, y, f):

    return f(x) + f(y)

def add(x, y, f):

return f(x) + f(y)

8.6.2 Integrierte Funktionen

1. Die Funktion abs(), die den Absolutwert ermittelt, hat nur einen Parameter.

>>> type(123)

>>> type('str')

>>> type(None)

　2. Um den Objekttyp zu bestimmen, verwenden Sie die Funktion type():

>>> type(123)

>>> len('ABC')

3

>>> 'ABC'.__len__()

3

>>> type('str')

< ;class 'str'>

>>> type(None)

　3. Um die Quadratwurzel zu berechnen, können Sie die Funktion math.sqrt() aufrufen.

　4.lower() gibt eine Zeichenfolge in Kleinbuchstaben zurück.

>>> hasattr(obj, 'x') # 有属性'x'吗？

True

>>> obj.x

9

>>> hasattr(obj, 'y') # 有属性'y'吗？

False

>>> setattr(obj, 'y', 19) # 设置一个属性'y'

>>> hasattr(obj, 'y') # 有属性'y'吗？

True

>>> getattr(obj, 'y') # 获取属性'y'

19

>>> obj.y # 获取属性'y'

19

5.__len__-Methode gibt die Länge zurück. Wenn Sie in Python die Funktion len() aufrufen, um zu versuchen, die Länge eines Objekts zu ermitteln, ruft die Funktion tatsächlich innerhalb der Funktion len() automatisch die Methode __len__() des Objekts auf, sodass der folgende Code äquivalent ist:

>>> len('ABC')

>>> def f(x):

...     return x * x

...

>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])

>>> list(r)

[1, 4, 9, 16, 25, 36, 49, 64, 81]

3

>>> 'ABC'.__len__()

>>> from functools import reduce

>>> def fn(x, y):

...     return x * 10 + y

...

>>> reduce(fn, [1, 3, 5, 7, 9])

13579

3

6. Die Max-Funktion max() kann beliebig viele Parameter empfangen und den größten zurückgeben. 7. Wenn Sie alle Eigenschaften und Methoden eines Objekts abrufen möchten, können Sie die Funktion dir() verwenden, die beispielsweise eine Liste mit Zeichenfolgen zurückgibt, um alle Eigenschaften und Methoden eines Objekts abzurufen str-Objekt: 　8. Die in Python integrierte hex()-Funktion wandelt eine Ganzzahl in eine hexadezimal dargestellte Zeichenfolge um. 9. Für Klassenvererbungsbeziehungen ist die Verwendung von type () sehr unpraktisch. Um den Typ der Klasse zu bestimmen, können wir die Funktion isinstance() verwenden. Parametertypen werden überprüft und nur Parameter vom Typ Ganzzahl und Gleitkomma sind zulässig. Die Datentypprüfung kann mit der integrierten Funktion isinstance() implementiert werden. Verwenden Sie die integrierte Funktion isinstance, um zu bestimmen, ob eine Variable eine Zeichenfolge ist. 10. Mit getattr(), setattr() und hasattr() können wir den Zustand eines Objekts direkt manipulieren.

>>> hasattr(obj, 'x') # Hat Attribute 'X'? True>>> obj.x9>>> Gibt es ein Attribut „y“? False>>> setattr(obj, 'y', 19) # Setze ein Attribut 'y'>>> obj, 'y') # Gibt es ein Attribut 'y'? True>>> getattr(obj, 'y') # Attribut 'y' abrufen19>> > obj.y # Attribut 'y' abrufen19

Durch eine Reihe integrierter Funktionen können wir kann jedes Python-Objekt analysieren und seine internen Daten abrufen. Es ist zu beachten, dass wir Objektinformationen nur erhalten, wenn wir die Objektinformationen nicht kennen. 11. Python verfügt über integrierte Map()- und Reduce()-Funktionen. Map wendet die übergebene Funktion der Reihe nach auf jedes Element der Sequenz an und gibt das Ergebnis als neuen Iterator zurück.

>>> >...     return x * x...>>> 8, 9])>>> list(r)[1, 4, 9, 16, 25, 36, 49, 64, 81]

So verwenden Sie Reduzieren. Reduce wendet eine Funktion auf eine Sequenz an [x1, x2, x3, ...]. Diese Funktion muss zwei Parameter erhalten. Reduce setzt das Ergebnis fort und führt eine kumulative Berechnung mit dem nächsten Element der Sequenz durch.

>>> from functools import Reduce> ;>> def fn(x, y):... Rückgabe x * 10 + y>>> (fn, [1, 3, 5, 7, 9])13579

　12.Pythons integrierte Funktion filter() wird zum Filtern von Sequenzen verwendet. filter() akzeptiert auch eine Funktion und eine Sequenz . Im Gegensatz zu map() wendet filter() die übergebene Funktion der Reihe nach auf jedes Element an und entscheidet dann, ob das Element beibehalten oder verworfen wird, je nachdem, ob der Rückgabewert True oder False ist. Der Schlüssel liegt in der korrekten Implementierung einer „Filter“-Funktion. Beachten Sie, dass die Funktion filter() einen Iterator zurückgibt, bei dem es sich um eine Lazy-Sequenz handelt. Um filter() zu zwingen, die Berechnungsergebnisse zu vervollständigen, müssen Sie die Funktion list() verwenden, um alle Ergebnisse abzurufen und die Liste zurückzugeben.

def is_odd(n):

    return n % 2 == 1

 

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))

# 结果: [1, 5, 9, 15]

def is_odd(n):

return n % 2 = = 1

>>> sorted([36, 5, -12, 9, -21])

[-21, -12, 5, 9, 36]

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)

['Zoo', 'Credit', 'bob', 'about']

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))

# Ergebnis: [1 , 5, 9, 15]

13. Die in Python integrierte Funktion sorted() kann die Liste sortieren.

>>> , -21])

[-21, -12, 5, 9, 36]

　14.sorted( )-Funktion ist auch eine Funktion höherer Ordnung. Sie kann auch eine Schlüsselfunktion erhalten, um eine benutzerdefinierte Sortierung zu implementieren, z. B. eine Sortierung nach Absolutwert. Um eine umgekehrte Sortierung durchzuführen, müssen Sie die Schlüsselfunktion nicht ändern. Sie können den dritten Parameter reverse=True übergeben.

>>> def now():

...     print('2015-3-25')

...

>>> f = now

>>> f()

2015-3-25

>>> now.__name__

'now'

>>> f.__name__

'now'

>>> 'Zoo', 'Credit'], key=str.lower, reverse=True)

class Student(object):

 

    @property

    def score(self):

        return self._score

 

    @score.setter

    def score(self, value):

        if not isinstance(value, int):

            raise ValueError('score must be an integer!')

        if value < 0 or value > 100:

            raise ValueError('score must between 0 ~ 100!')

        self._score = value

['Zoo', 'Credit', 'bob', 'about']

　15. Die in Python integrierte Aufzählungsfunktion kann eine Liste in ein Index-Element-Paar umwandeln, sodass der Index und das Element selbst gleichzeitig in a iteriert werden können for-Schleife. 16. Die Funktion „round()“ kann jede Dezimalstelle zurückgeben. 8.6.3 Decorator Die Möglichkeit, Funktionen dynamisch hinzuzufügen, während der Code ausgeführt wird, wird als „Decorator“ bezeichnet. Im Wesentlichen ist ein Dekorator eine Funktion höherer Ordnung, die eine Funktion zurückgibt. Dekorateur: Fügen Sie neue Funktionen hinzu, ohne die Funktion selbst zu ändern. Das Funktionsobjekt verfügt über ein __name__-Attribut. Sie können den Namen der Funktion abrufen: Pythons integrierter @property-Dekorator ist dafür verantwortlich, eine Methode in einen Eigenschaftsaufruf umzuwandeln:

>>> def now():... print('2015-3-25')... >>> f = now>>> f()2015-3-25>>> __name__ 'now'>>> f.__name__'now'

class Student(object): @property def score(self): return self._score @score.setter def score(self, value): if not isinstance(value, int): raise ValueError('score muss eine ganze Zahl sein!') wenn value < 0 oder value > > self._score = value

@property wird häufig in Klassendefinitionen verwendet und ermöglicht es Aufrufern, Funktionscodes zu schreiben und gleichzeitig die notwendigen Überprüfungen der Parameter sicherzustellen, wodurch die Möglichkeit von Fehlern bei der Ausführung des Programms verringert wird.

Der @unique-Dekorator kann uns bei der Überprüfung helfen, um sicherzustellen, dass keine doppelten Werte vorhanden sind.

8.7 Funktionen in Modulen speichern

Um wartbaren Code zu schreiben, können Sie viele Funktionen in verschiedene Dateien gruppieren, sodass der in jeder Datei enthaltene Code relativ kleiner ist. In Python wird eine .py-Datei als Modul (Module) bezeichnet.

Einer der Vorteile von Funktionen besteht darin, dass Sie damit Codeblöcke vom Hauptprogramm trennen können. Indem Sie den Funktionen beschreibende Namen geben, machen Sie das Hauptprogramm viel verständlicher. Sie können noch einen Schritt weiter gehen und die Funktionen in separaten Dateien, sogenannten Modulen, speichern und die Module dann in das Hauptprogramm importieren. Die Importanweisung ermöglicht die Verwendung des Codes im Modul in der aktuell ausgeführten Programmdatei.

Durch das Speichern von Funktionen in separaten Dateien können Sie die Details des Programmcodes verbergen und sich auf die übergeordnete Logik des Programms konzentrieren. Dadurch können Sie Funktionen auch in vielen verschiedenen Programmen wiederverwenden. Durch das Speichern von Funktionen in separaten Dateien können Sie diese Dateien mit anderen Programmierern teilen und nicht das gesamte Programm. Wenn Sie wissen, wie man Funktionen importiert, können Sie auch Funktionsbibliotheken verwenden, die von anderen Programmierern geschrieben wurden.

Um Konflikte bei Modulnamen zu vermeiden, hat Python eine Methode zum Organisieren von Modulen nach Verzeichnis eingeführt, die als Paket bezeichnet wird. Nach der Einführung des Pakets treten keine Konflikte mit anderen Modulen auf, solange der Paketname der obersten Ebene nicht mit anderen in Konflikt steht. Jetzt wird der Modulname von abc.py zu mycompany.abc und entsprechend wird der Modulname von xyz.py zu mycompany.xyz.

Beachten Sie, dass sich unter jedem Paketverzeichnis eine Datei __init__.py befindet. Diese Datei muss vorhanden sein, andernfalls behandelt Python dieses Verzeichnis als normales Verzeichnis und nicht als Paket. __init__.py kann eine leere Datei sein oder Python-Code enthalten, da __init__.py selbst ein Modul ist und sein Modulname mycompany ist.

8.7.1 Gesamtes Modul importieren

Um die Funktion importierbar zu machen, müssen Sie zunächst das Modul erstellen. Module sind Dateien mit der Erweiterung .py, die Code enthalten, der in ein Programm importiert werden soll.

if __name__=='__main__':

if __name__=='__main__':

    test()

test()

Der erste Schritt zur Verwendung eines Moduls besteht darin, das Modul zu importieren. Wenn wir die Hallo-Moduldatei in der Befehlszeile ausführen, wird der Python-Interpreter verwendet Ändert eine spezielle Variable __name__, die auf __main__ gesetzt ist, und wenn das Hallo-Modul an anderer Stelle importiert wird, schlägt die if-Beurteilung fehl. Daher ermöglicht dieser if-Test einem Modul, zusätzlichen Code auszuführen, wenn es über die Befehlszeile ausgeführt wird Test durchführen.

8.7.2 Geltungsbereich

In einem Modul definieren wir möglicherweise viele Funktionen und Variablen, aber einige Funktionen und Variablen hoffen wir, von anderen verwendet zu werden, und einige Funktionen und Variablen hoffen wir nur verwendet innerhalb des Moduls. In Python wird dies durch das Präfix _ erreicht. Normale Funktions- und Variablennamen sind öffentlich und können direkt referenziert werden, z. B. abc, x123, PI usw.; Variablen wie __xxx__ sind spezielle Variablen und können direkt referenziert werden, haben jedoch spezielle Zwecke, wie z. B. die oben genannten __author__ und __name__ Auf die vom Hello-Modul definierten Dokumentkommentare kann auch mit der speziellen Variablen __doc__ zugegriffen werden. Im Allgemeinen sollten wir diesen Variablennamen nicht für unsere eigenen Variablenfunktionen verwenden, da _xxx und __xxx nicht öffentlich sind. sollten nicht direkt in Anführungszeichen gesetzt werden, wie z. B. _abc, __abc usw.;

def _private_1(name):

    return 'Hello, %s' % name

 

def _private_2(name):

    return 'Hi, %s' % name

 

def greeting(name):

    if len(name) > 3:

        return _private_1(name)

    else:

        return _private_2(name)

Private Funktionen oder Variablen sollten nicht von anderen in Anführungszeichen gesetzt werden. Welchen Nutzen haben sie also? Bitte sehen Sie sich das Beispiel an:

def _private_1(name): return 'Hallo, %s' % name def _private_2(name): return 'Hallo, %s' % name def Greeting(name): if len(name) > 3: return _private_1(name) else: return _private_2(name)

Wir legen die Funktion Greeting() im Modul offen und verbergen die interne Logik mit privaten Funktionen. Auf diese Weise müssen wir uns beim Aufruf der Funktion Greeting() nicht um die Details der internen privaten Funktion kümmern. Dies ist auch eine sehr nützliche Code-Kapselungs- und Abstraktionsmethode, das heißt: Alle Funktionen, auf die nicht von außen verwiesen werden muss, werden als privat definiert, und nur Funktionen, auf die von außen verwiesen werden muss, werden als öffentlich definiert.

8.7.3 Bestimmte Module importieren

Speichern Sie mehrere Funktionen in einem Modul, getrennt durch Kommas. Sie können beliebig viele Funktionen aus dem Modul importieren.

8.7.4 Verwenden Sie as, um einen Alias ​​für eine Funktion anzugeben

from pizza import make_pizza as mp

Wenn der Name der zu importierenden Funktion möglicherweise mit einem vorhandenen in Konflikt steht Geben Sie im Programm einen Namen ein. Wenn der Name der Funktion zu lang ist, können Sie einen kurzen und eindeutigen Alias ​​angeben – einen anderen Namen für die Funktion, ähnlich einem Spitznamen. Um einer Funktion diesen speziellen Spitznamen zuzuweisen, müssen Sie dies beim Importieren tun.

8.7.5 Verwenden Sie as, um Aliase für Module anzugeben

Sie können auch Aliase für Module angeben. Indem Sie dem Modul einen kurzen Alias ​​geben (z. B. indem Sie dem Pizza-Modul den Alias ​​p zuweisen), können Sie Funktionen im Modul einfacher aufrufen. Im Vergleich zu pizza.make_pizza() ist p.make_pizza() prägnanter.

8.7.6 Verwenden Sie *, um alle Funktionen im Modul zu importieren

Durch die Verwendung des Sternchenoperators (*) kann Python alle Funktionen im Modul importieren.

Wenn Sie jedoch ein großes Modul verwenden, das Sie nicht selbst geschrieben haben, ist es am besten, diese Importmethode nicht zu verwenden: Wenn es im Modul Funktionen mit denselben Namen gibt wie die in Ihrem Projekt verwendeten, kann dies der Fall sein zu unerwarteten Ergebnissen führen: Python kann auf mehrere Funktionen oder Variablen mit demselben Namen stoßen und die Funktion überschreiben, anstatt alle Funktionen separat zu importieren.

8.8 Leitfaden zum Schreiben von Funktionen

Beim Schreiben von Funktionen müssen Sie mehrere Details im Auge behalten.

1. Funktionen sollten beschreibende Namen erhalten und nur Kleinbuchstaben und Unterstriche verwenden. Beschreibende Namen helfen Ihnen und anderen zu verstehen, was der Code bewirken soll. Die obige Konvention sollte auch bei der Benennung von Modulen befolgt werden.

2. Jede Funktion sollte einen Kommentar enthalten, der ihre Funktion kurz erklärt. Der Kommentar sollte der Funktionsdefinition folgen und das docstring-Format verwenden. Eine gut dokumentierte Funktion ermöglicht es anderen Programmierern, sie einfach durch Lesen der Beschreibung im Dokumentstring zu verwenden: Sie können darauf vertrauen, dass der Code wie beschrieben funktioniert, solange sie den Namen der Funktion, die erforderlichen Argumente und den Typ kennen Den Rückgabewert können Sie in Ihren eigenen Programmen verwenden.

　3.Bei der Angabe eines Standardwerts für einen formalen Parameter dürfen auf beiden Seiten des Gleichheitszeichens keine Leerzeichen stehen.

Das obige ist der detaillierte Inhalt vonEinführung in die Python-Grundlagen – Funktion. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!