In diesem Kapitel lernen Sie die Python-Funktionen kennen. Was ist überhaupt eine Funktion? Es scheint so, aber ich werde es erklären, einschließlich der Erklärung dazu.
Die gute Verwendung der Funktion bietet viele Vorteile, z. B. die Reduzierung der zu schreibenden Codemenge, die Vermeidung des wiederholten Schreibens desselben Codes und die Vereinfachung des Lesens des Codes.
Beginnen wir mit der Erklärung der Funktion selbst.
Die Funktion ist Funktion in Englisch. In der Mathematik gibt es eine sogenannte Funktion, die auf Englisch auch als Funktion bezeichnet wird, aber der Inhalt der Funktion unterscheidet sich zwischen Mathematik und Programm. Bitte beachten Sie, dass es anders ist.
Funktionen in Python-Programmen weisen die folgenden Hauptmerkmale auf.
Seki ** Nummer **, etwas, das mit Zahlen zusammenhängt, weil es mit Zahlen verbunden ist? Sie mögen denken, aber die Funktion akzeptiert verschiedene andere Dinge als Zahlen, wie z. B. Zeichenfolgen und Listen. Auf Japanisch ist es etwas verwirrend, aber auf Englisch gibt es für Funktionen keine Wörter, die sich auf Zahlen beziehen. Denken Sie also daran, dass es sich lediglich um eine Funktion handelt.
Neben der Bedeutung von Funktion hat Funktion auch die Bedeutung von "Funktion" und "Arbeit". Es kann gut sein, sich die Funktionen eines Programms als "ein Programm mit einer Funktion wird ausgeführt" vorzustellen, wenn es ausgeführt wird.
Verwenden Sie zum Erstellen einer Python-Funktion das Schlüsselwort def. Setzen Sie nach def ein Leerzeichen mit halber Breite, schreiben Sie den Namen der Funktion danach, schreiben Sie die Klammern mit halber Breite ( und) und fügen Sie den Doppelpunkt mit halber Breite: am Ende der Zeile hinzu. Sie können eine Funktion erstellen.
Zum Beispiel def function name ():. Grundsätzlich werden für den Funktionsnamen alphanumerische Zeichen halber Breite verwendet.
Der Inhalt des Funktionsprogramms wird dort geschrieben, indem ein Einzug (vier Leerzeichen halber Breite) aus der nächsten Zeile der durch "def" definierten Funktion hinzugefügt wird.
Wenn Sie beispielsweise den Inhalt von 1 + 1 mit print drucken möchten und der Funktionsname "print_one_plus_one" lautet, lautet der Code wie folgt.
def print_one_plus_one():
print(1 + 1)
Im Abschnitt Einrückung des vorherigen Kapitels habe ich erklärt, dass "Einrückung die hierarchische Struktur des Programms darstellt" und "je weiter rechts, desto tiefer die Hierarchie des Programms".
Selbst in Funktionsprogrammen ist diese Regel, dass "die Hierarchie des Programms tiefer nach rechts ist", noch gültig.
Achten wir auf den Teil namens "print (1 + 1)", in dem im obigen Code ein Einzug (4 Leerzeichen halber Breite) gesetzt ist.
Dieser Teil entspricht "Programm in Funktion". Mit anderen Worten, die Hierarchie des Programms ist aufgrund der Zunahme der Einrückung tiefer geworden, wie z. B. "Programm mit dem Namen" print (1 + 1) "in" Funktion mit dem Namen "print_one_plus_one" (das Programm wird durch den Einrückungsbetrag eingeschlossen). Masu).
Außerdem habe ich im Abschnitt zum Einrücken in Listen und Wörterbüchern erklärt, dass selbst Code, bei dem der Einzug wie folgt weggelassen wird, funktioniert (er verursacht keinen Programmfehler).
int_list = [
1,
2,
3,
4,
]
Andererseits haben Einrückungen in Funktionen eine ** Bedeutung **. "Startposition des Programms mit Einzug" bedeutet "Startposition des Programms in Funktion" und "Position unmittelbar vor dem Programm ohne Einzug" bedeutet "Endposition des Programms in Funktion". Ich bin der Meinung, dass dieser Bereich etwas schwer zu verstehen ist, daher werde ich ihn anhand des Programms genauer betrachten.
Beachten Sie, dass das Funktionsprogramm nur funktioniert, wenn Sie vorerst den richtigen Einzug eingestellt haben.
Lassen Sie uns als Test Code schreiben und ausführen, der nach der Funktion keinen Einzug enthält.
def print_one_plus_one():
print(1 + 1)
File "<ipython-input-12-a31292ca450b>", line 2
print(1 + 1)
^
IndentationError: expected an indented block
Wie oben erwähnt, tritt ein Fehler auf, wenn nach der Funktion kein Einzug vorhanden ist. IndentationError ist ein Fehler, der durch einen falschen Einzug verursacht wird. Einrückungsblock bedeutet einen Block mit eingerücktem Code, erwartet bedeutet "erwartet", also "vorausgesetzt, der Codeteil mit hinzugefügtem Einzug kommt". Ich erhalte eine Fehlermeldung wie "Es ist fertig, aber es ist nicht (keine Einrückung)".
Beachten Sie, dass es kein Problem gibt, wenn es sich um eine Nicht-Code-Zeile handelt, z. B. eine Zeile, die nur leer ist (eine Zeile, in der kein Programm geschrieben ist), auch wenn keine Einrückung vorhanden ist. Zum Beispiel spielt es keine Rolle, ob zwischen der Zeile "digit_value = 1 + 1" und der Zeile "print (digit_value)" eine leere und nicht eingerückte Zeile steht, wie unten gezeigt.
def print_one_plus_one():
digit_value = 1 + 1
print(digit_value)
Um die Funktion zu beenden, schreiben Sie den Code ohne Einrückung. Beispielsweise wird der Inhalt einer Funktion nur ausgeführt, wenn die Funktion ausgeführt wird (im nächsten Abschnitt beschrieben), aber im folgenden Code hat der Teil "print (3 + 5)" keinen Einzug (= Funktion). Da der Inhalt von) fertig ist), wird er sofort ausgeführt, ohne die Funktion aufzurufen, und das Ergebnis von 8 wird angezeigt.
def print_one_plus_one():
digit_value = 1 + 1
print(digit_value)
print(3 + 5)
Ausgabeinhalt des Ergebnisses der Codeausführung:
8
Verwenden Sie zum Aufrufen (Ausführen) der erstellten Funktion Klammern in halber Breite ((und)) nach dem Funktionsnamen, z. B. "Funktionsname ()".
Wenn Sie die Funktion "print_one_plus_one" ausführen möchten, die Sie vor einiger Zeit erstellt haben, schreiben Sie etwas wie "print_one_plus_one ()". Wenn Sie den Code ausführen, können Sie sehen, dass das Programm innerhalb der Funktion (print (1 + 1)) ausgeführt und 2 ausgegeben wird.
def print_one_plus_one():
print(1 + 1)
print_one_plus_one()
Ausgabeinhalt des Ergebnisses der Codeausführung:
2
In einer Funktion erstellte Variablen verhalten sich besonders.
Schreiben Sie zur Erklärung zunächst den folgenden Code und führen Sie ihn aus.
def print_one_plus_one():
digit_value = 1 + 1
print(digit_value)
print_one_plus_one()
digit_value += 1
2
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-21-50561b28b02f> in <module>
5
6 print_one_plus_one()
----> 7 digit_value += 1
NameError: name 'digit_value' is not defined
Die Funktion print_one_plus_one wird zuerst ausgeführt (print_one_plus_one ()), wobei eine Variable mit dem Namen digit_value erstellt wird ( digit_value = 1 + 1) und dann 1 zur Variablen digit_value außerhalb der Funktion hinzugefügt wird. Der Code lautet (digit_value + = 1).
Als ich es versuchte, erhielt ich jedoch eine Fehlermeldung (name'digit_value 'ist nicht definiert) mit der Aufschrift" Die Variable digit_value ist nicht definiert ".
Warum erstellen Sie Variablen im Code innerhalb der Funktion?
Tatsächlich verschwinden die in der Funktion erstellten Variablen im Wesentlichen, wenn die Ausführung der Funktion abgeschlossen ist. Wenn die in der Funktion erstellten Variablen unverändert bleiben, können sie daher nicht aus dem Code außerhalb der Funktion (dem Teil ohne Einzug) oder aus anderen Funktionen verwendet (häufig bezeichnet) werden.
Stellen Sie sich vor, dass sich in einem Feld, das als Funktion bezeichnet wird, verschiedene Variablen befinden. Eine andere Funktion wird eine andere Box sein. Jeder kann nur die Variablen verwenden, die in der Box sind.
Der Bereich von Variablen, auf die verwiesen werden kann, wie z. B. dieses Feld, wird als ** Bereich ** bezeichnet. Auf Englisch ist es Umfang. Es ist ein Wort, das die Bedeutung von "Reichweite" oder "Ansicht" hat. In der Programmierung bedeutet dies "zugänglicher Bereich von Variablen usw."
Schauen wir uns den Umfang genauer an.
Als ich zuvor versuchte, auf eine Variable innerhalb einer Funktion außerhalb der Funktion zuzugreifen, wurde eine Fehlermeldung angezeigt. Was passiert, wenn Sie von innerhalb der Funktion auf eine außerhalb der Funktion erstellte Variable zugreifen?
Verweise innerhalb einer Funktion einer Variablen, die außerhalb der Funktion erstellt wurde, verhalten sich je nach Typ der Variablen unterschiedlich.
Versuchen wir zunächst eine Ganzzahlvariable (int) als Beispiel.
int_variable = 100
def add_one():
int_variable += 1
add_one()
UnboundLocalError Traceback (most recent call last)
<ipython-input-4-e73c01cb25ac> in <module>
6
7
----> 8 add_one()
<ipython-input-4-e73c01cb25ac> in add_one()
3
4 def add_one():
----> 5 int_variable += 1
6
7
UnboundLocalError: local variable 'int_variable' referenced before assignment
Wenn ich versuche, es auszuführen, erhalte ich den obigen Fehler. Ungebunden hat die Bedeutung von "ungebunden" und "nicht zugewiesen" zusätzlich zur Bedeutung von "ungebunden".
Außerdem werden die Variablen in der Funktion als lokale Variablen bezeichnet (lokale Variablen in Englisch). Eine Regel nur für eine bestimmte Region wird als lokale Regel bezeichnet, aber eine lokale Variable hat ein ähnliches Gefühl und bedeutet "eine Variable nur in einer bestimmten Funktion".
Referenz bedeutet referenziert und Zuweisung bedeutet so etwas wie Zuordnung. Hier gibt es kein Problem, wenn Sie es so lesen, als ob die Variable nicht erstellt wurde.
Daher wird die Fehlermeldung "lokale Variable" int_variable ", auf die vor der Zuweisung verwiesen wird, zur Meldung" Die lokale Variable "int_variable" wird vor der Erstellung referenziert ".
Es gibt eine globale Variable, die mit einer lokalen Variablen gepaart ist. Lokale Variablen können nur von bestimmten Funktionen referenziert werden, während globale Variablen abhängig von den Einstellungen an verschiedenen Stellen referenziert werden können.
Wenn Sie eine Variable außerhalb der Funktion erstellen, wird sie zu einer globalen Variablen. Tatsächlich entsprechen die Variablen, die wir vor dem Funktionskapitel erstellt haben, globalen Variablen.
In dem obigen Code, der zu UnboundLocalError geführt hat, wird die globale Variable zuerst mit dem Code "int_variable = 100" erstellt. Er erklärte auch, dass globale Variablen an verschiedenen Stellen referenziert werden können.
Ist es in diesem Fall nicht seltsam, dass beim Verweisen auf "int_variable" in der Funktion "add_one" ein Fehler auftritt? Ist es nicht seltsam, dass lokale Variablen in der Fehlermeldung angezeigt werden, obwohl es sich um globale Variablen handelt? Sie können das fühlen.
Der Grund für dieses Verhalten ist, dass das Python-Programm nicht weiß, ob es sich um eine lokale Variable handelt oder ob es sich um eine globale Variable handelt.
Sie können denselben Namen für globale und lokale Variablen verwenden. Wenn dies unverändert bleibt, kann das Programm daher nicht bestimmen, welche behandelt werden soll, und die lokale Variable verarbeitet Ganzzahlen. Wenn Sie globale Variablen wie Ganzzahlen verarbeiten möchten, müssen Sie dem Programm explizit mitteilen: "Dies ist eine globale Variable."
Um dem Programm mitzuteilen, dass eine bestimmte Variable eine globale Variable ist, schreiben Sie "globaler Variablenname" in die Funktion. Wenn die Variable "int_variable" im obigen Code als globale Variable behandelt wird, hat sie die Form "global int_variable".
Wenn Sie es so umschreiben, dass der Fehler nicht auftritt, sieht es wie folgt aus. Sie können bestätigen, dass 101 ausgegeben wird, indem Sie 1 zum Wert der globalen Variablen "100" hinzufügen.
int_variable = 100
def add_one():
global int_variable
int_variable += 1
print(int_variable)
add_one()
Ausgabeinhalt des Ergebnisses der Codeausführung:
101
Was passiert, wenn Sie "global" innerhalb einer Funktion verwenden und dann eine Variable erstellen, bevor Sie im Voraus eine Variable außerhalb der Funktion (globale Variable) erstellen, und dann nach Ausführung der Funktion auf diese Variable außerhalb der Funktion verweisen?
Schreiben wir den Code und führen ihn aus.
def define_global_variable():
global int_variable_2
int_variable_2 = 200
define_global_variable()
print(int_variable_2)
Ausgabeinhalt des Ergebnisses der Codeausführung:
200
Diesmal lautet der neue Variablenname "int_variable_2". Die Funktion wird im Teil define_global_variable () ausgeführt, Variablen werden als globale Variablen innerhalb der Funktion erstellt (global int_variable_2 und int_variable_2 = 200), und dann wird die Variable außerhalb der Funktion referenziert (ausgegeben). (Print (int_variable_2)).
Sie können sehen, dass ein Fehler, wenn keine Beschreibung von "global" vorhanden war, den Inhalt der Variablen 200 fehlerfrei ausgeben kann.
Im vorherigen Abschnitt haben wir bestätigt, dass der Versuch, auf eine globale Variable wie eine Ganzzahl wie in einer Funktion zuzugreifen, zu einem Fehler führen würde.
Dieses Verhalten ist für nicht ganzzahlige Zeichenfolgen (str), Gleitkommazahlen (float), boolesche Werte (bool) und andere Werttypen gleich.
Andererseits ändert sich das Verhalten für Werte wie Listen und Wörterbücher. Mal sehen, wie sie sich nacheinander unterscheiden.
Erstellen Sie zunächst eine globale Variable außerhalb der Funktion und verweisen Sie auf diese Variable innerhalb der Funktion (ohne die Beschreibung von global).
dict_variable = {'name': 'orange'}
def print_dict_variable():
print(dict_variable)
print_dict_variable()
Ausgabeinhalt des Ergebnisses der Codeausführung:
{'name': 'orange'}
Erstellen einer globalen Variablen im Wörterbuch außerhalb der Funktion (dict_variable = {'name': 'orange'}) und Ausführen der Funktion (print_dict_variable ()). Innerhalb der Funktion wird der Inhalt der globalen Variablen des Wörterbuchs ausgegeben (print (dict_variable)).
Als ich im vorherigen Abschnitt mit ganzzahligen Variablen versuchte, wurde eine Fehlermeldung angezeigt, wenn ich die Variable nicht mit "global" (es wurde beurteilt, dass die lokale Variable nicht generiert wurde) in dieser Schreibweise, sondern im Wörterbuch angegeben habe Im Fall einer globalen Variablen können Sie sehen, dass kein Fehler auftritt, auch wenn Sie ihn nicht mit "global" angeben, und der Wert kann ordnungsgemäß ausgegeben werden.
Auf diese Weise können globale Variablen in Funktionen auch in Wörterbüchern und anderen Listen referenziert werden. Bitte beachten Sie, dass sich das Verhalten des Bereichs von dem von ganzen Zahlen unterscheidet.
Als nächstes überprüfen wir das Verhalten, wenn eine lokale Variable in der Funktion mit demselben Variablennamen wie die globale Variable erstellt wird (die Angabe von "global" wird weggelassen).
dict_variable = {'name': 'orange'}
def change_dict_variable():
dict_variable = {'name': 'apple'}
change_dict_variable()
print(dict_variable)
Ausgabeinhalt des Ergebnisses der Codeausführung:
{'name': 'orange'}
Erstellen Sie zuerst eine globale Variable für das Wörterbuch (dict_variable = {'name': 'orange'}) und führen Sie dann die Funktion (change_dict_variable ()) aus. Innerhalb der Funktion erstellen wir eine neue Wörterbuchvariable mit demselben Namen wie die globale Variable (dict_variable = {'name': 'apple'}). Schließlich wird der Inhalt der globalen Variablen außerhalb der Funktion gedruckt (print (dict_variable)).
Wie Sie dem Ausgabeergebnis ({'name': 'orange'}) entnehmen können, wird der in der Funktion festgelegte Wert ({'name': 'apple'}) nicht wiedergegeben und ist eine globale Variable. Der Wert zum Zeitpunkt der Erstellung ist der gleiche.
Dies bedeutet, dass beim Erstellen einer neuen Liste oder eines neuen Wörterbuchs in einer Funktion eine globale Variable mit demselben Namen als lokale Variable behandelt wird. Mit anderen Worten, wenn der Inhalt der Funktion abgeschlossen ist, geht der Inhalt der lokalen Variablen verloren, und infolgedessen bleibt der Wert der globalen Variablen unverändert.
Es ist ein bisschen kompliziert. Auch wenn Sie sich nicht an alles erinnern können, ist es in Ordnung, wenn Sie sich jedes Mal daran erinnern können, wenn Sie den Code ausführen und ausprobieren. Denken Sie daran, dass sich das Verhalten des Bereichs abhängig von den Bedingungen ändert.
Lassen Sie uns abschließend das Verhalten beim Festlegen eines neuen Wörterbuchs ausprobieren, indem Sie die globale Variable des Wörterbuchs im Voraus erstellen und die gleichnamige Variable mit global in der Funktion angeben.
dict_variable = {'name': 'orange'}
def change_dict_variable():
global dict_variable
dict_variable = {'name': 'apple'}
change_dict_variable()
print(dict_variable)
Ausgabeinhalt des Ergebnisses der Codeausführung:
{'name': 'apple'}
Im Vergleich zum vorherigen Code wurde nur der Teil "global dict_variable" in der Funktion hinzugefügt. Aufgrund dieser Beschreibung wird die Variable von "dict_variable" jedoch als globale Variable behandelt, anstatt als lokale Variable behandelt zu werden. Das Ergebnis der Ausgabeverarbeitung ("print (dict_variable)") nach Ausführung der Funktion lautet "{'name': 'orange'}. Es wurde in {'name': 'apple'} (in der Funktion festgelegter Wert) anstelle von `(Wert, wenn die globale Variable festgelegt ist) geändert.
Auf diese Weise ändert sich das Verhalten abhängig vom Wertetyp und davon, ob global angegeben ist oder nicht. Es ist kompliziert, daher können die folgenden Ideen helfen, es einfach zu halten.
Die Bestimmung, ob global für die Referenzierung globaler Variablen in einer Funktion für jeden Typ erforderlich ist, ist keine strenge Definition, sondern ein Index.
--Global muss für einen einzelnen Wert (Ganzzahl, Zeichenfolge usw.) angegeben werden. --Global kann für große Werte (Listen, Wörterbücher usw.) weggelassen werden, in denen viele Einzelwerte gespeichert sind.
Es ist möglicherweise einfacher zu verstehen, wenn Sie sich daran erinnern.
Natürlich können Sie ein Programm realisieren, das auch dann funktioniert, wenn Sie den Code so schreiben, wie er ist, ohne eine Funktion bereitzustellen. Warum also Funktionen nutzen?
Es gibt verschiedene Gründe, aber die beiden Hauptgründe sind "Reduzierung der Codeduplizierung" und "Erleichterung der Lesbarkeit des Codes".
Die Codebeispiele bis zu diesem Punkt sind alle Kurzcodes, daher kann es schwierig sein, die Vorteile zu verstehen.
In der realen Arbeit beschäftigen wir uns jedoch häufig mit langen Programmen und Programmen mit vielen Dateien. Die Vorteile von Funktionen werden in solch komplexen Umgebungen zum Leben erweckt.
Angenommen, Sie schreiben bei der Arbeit etwa 20 Codezeilen. Auf dieser Ebene ist nichts wichtig.
Eine ähnliche Verarbeitung wird jedoch in Zukunft erforderlich sein, und 40 Zeilen werden verdoppelt und auf 60 Zeilen erhöht ... Während der Wiederholung werden Hunderte, Tausende, Zehntausende von Zeilen wiederholt. Es wird werden .. Dies gilt insbesondere für jahrelange Projektarbeit.
Wenn Sie jedes Mal denselben Code schreiben, ist es schwierig, den Code zu erfassen. Da die Anzahl der Variablen sehr groß sein wird, wird es schwierig sein, dem Code wie "Wie wird diese Variable verwendet?" Zu folgen, und es wird schwierig sein, nicht verwandte Variablen zu betreiben. Viele Fehler werden auftreten.
Angenommen, die in der Zukunft erforderliche Verarbeitung ändert sich und Sie müssen den Code bearbeiten. Wenn es Dutzende ähnlicher Codes gibt, ist es sehr schwierig, den Code ohne Fehler zu ändern. Wenn eine der Änderungen fehlt, führt dies zu einem Fehler (auch als Fehler bezeichnet) oder einem Fehler.
Das Schreiben eines Programms erfordert häufige Aktualisierungen und Ergänzungen von Funktionen, was sehr schmerzhaft sein kann.
Was ist andererseits, wenn die Verarbeitung die Funktion ausführt und der Code der tatsächlichen Verarbeitung in die Funktion geschrieben wird?
Sie müssen nur den Code in der Funktion ändern, um das Auslassen von Änderungen zu verhindern. Es erfordert auch sehr wenig Arbeit, um Änderungen vorzunehmen.
Indem Sie Funktionen auf diese Weise gut nutzen, können Sie die Zeit und das Risiko für Änderungen reduzieren, indem Sie die doppelte Verarbeitung des Codes zu einer Funktion machen.
Ein weiterer großer Vorteil ist, dass der Code je nach Verwendung der Funktion leichter zu lesen ist.
Je weniger Elemente ein Programm liest, desto einfacher ist es zu lesen. Wenn der Code beispielsweise ungefähr 300 Variablen enthält und viele bedingte Verzweigungen in späteren Kapiteln erscheinen, ist es sehr schwierig, den Inhalt genau zu erfassen, und es ist leicht, Fehler zu machen.
Andererseits haben Funktionen, wie im vorherigen Abschnitt erwähnt, die Eigenschaft, dass lokale Variablen "nur innerhalb der Funktion verwendet werden" und "die lokalen Variablen verschwinden, wenn die Funktion endet".
Aufgrund dieser Eigenschaft ist der Code beispielsweise sehr einfach zu lesen, wenn Sie einen Prozess, für den 300 Variablen erforderlich sind, in viele Funktionen aufteilen und für jede Funktion in etwa 5 Variablen aufteilen.
Ich höre oft Geschichten wie "Menschen können sich an 3 bis 9 Elemente gleichzeitig erinnern", aber das Gleiche gilt für Programme, und wenn es viele Elemente gleichzeitig gibt, wird es schwierig, sie für einen kurzen Zeitraum zu erfassen und sich zu erinnern. ..
Es kann ähnlich sein, einen Bindestrich in 3 oder 4 Zahlen in eine Telefonnummer usw. einzufügen und ihn zu teilen, um das Verständnis zu erleichtern. Durch Aufteilen nach Funktionen und Reduzieren der Anzahl von Variablen und Prozessen pro Funktion können Sie den Code verständlicher machen und Fehler wie das Aufteilen einer Telefonnummer weniger wahrscheinlich machen.
Darüber hinaus besteht der Vorteil, dass es einfacher wird, einen Test zu schreiben, indem er in viele Funktionen mit weniger Verarbeitung unterteilt wird. Der Inhalt des Tests usw. wird ziemlich weit fortgeschritten sein, daher werde ich ihn in einem späteren Kapitel ausführlich erläutern.
Das Erstellen einer Funktion mit Variablenwerten wie Variablen ist vielseitiger und einfacher zu verwenden als das Verarbeiten einer Funktion mit nur festen Werten.
Zum Beispiel gibt es mehr Fälle, in denen die entsprechende Funktion durch "Berechnen von x um 3" mit einem beliebigen Wert von x verwendet werden kann als durch "Berechnen von 5 x 3".
Sie können jede Variable mit den im vorherigen Abschnitt genannten globalen Variablen verwenden. In solchen Fällen wird jedoch häufig eine Funktion verwendet, die als "Argument" der Funktion bezeichnet wird. Das Argument heißt auf Englisch Argument.
Obwohl es auf Japanisch Subtraktion ** heißt, akzeptiert es nicht numerische Argumente im Programm. Sie können verschiedene Argumente wie Zeichenfolgen, Boolesche Werte und Listen angeben.
Zusätzlich zur Bedeutung eines Arguments hat das englische Argument auch die Bedeutung von "Diskussion" und "Argument", wie aus den englischen Argumentationswörtern zu erwarten ist, was "diskutieren" und "argumentieren" bedeutet.
Auf den ersten Blick scheinen Argumente und Diskussionen nichts miteinander zu tun zu haben, aber im ursprünglichen Sinne leiten sie sich aus "Begründungen (Gründe und Beweise zur Unterstützung der Diskussion)" und "nach anderen Größen suchen" ab. Es scheint, dass es von der Tatsache herrührt, dass es sich so geändert hat wie "der ursprüngliche Betrag, für den es verwendet wurde".
Angesichts der Eigenschaft, dass das Ergebnis der Funktionsverarbeitung abhängig vom Wert des Arguments schwankt, ist das Wortargument etwas schöner.
Das japanische Wortargument hat möglicherweise eine ähnliche Bedeutung wie "Wert, der an eine Funktion übergeben werden soll".
Sie können einen beliebigen Wert mithilfe eines Arguments an die Funktion übergeben.
Das übergebene Argument wird als lokale Variable für diese Funktion behandelt. Da der vorherige Abschnitt die Eigenschaft hat, dass "lokale Variablen nur innerhalb der Funktion verwendet werden" und "die lokalen Variablen verschwinden, wenn die Funktion endet", ist der Code leichter zu lesen und macht weniger Fehler als das Schreiben von Code mit vielen globalen Variablen. Ich kann schreiben.
Im bisherigen Beispielcode haben wir Funktionen erstellt, die keine Argumente verwenden.
Um eine Funktion zu erstellen, die Argumente akzeptiert, geben Sie den Argumentnamen in den Klammern ( und ) nach dem Funktionsnamen an.
Schreiben Sie beispielsweise in dem oben erwähnten Prozess "Berechnen von x, das mit einem beliebigen Wert von x verdreifacht werden soll" "def multiply_three (x):", um eine Funktion mit dem Namen multiply_three zu erstellen, die x als Argument akzeptiert. Ich werde.
Um den Wert des Arguments bei der Ausführung der Funktion anzugeben, legen Sie den Wert, den Sie für das Argument angeben möchten, in den Klammern von "(" und ")" fest, anstatt "multiply_three ()" zu schreiben. Wenn Sie beispielsweise 10 als Argument angeben möchten, schreiben Sie "multiply_three (10)".
Schreiben wir den Code, führen die Funktion aus und überprüfen das Ergebnis.
def multiply_three(x):
multiplied_value = x * 3
print(multiplied_value)
multiply_three(10)
Ausgabeinhalt des Ergebnisses der Codeausführung:
30
Die Funktion wird im Teil multiply_three (10) ausgeführt, und 10 wird als Argument angegeben. In der Funktion (def multiply_three (x):) wird der Wert von x, der dem Argument gegeben wird (da es der zur Laufzeit angegebene Wert ist, ist x diesmal 10), verdreifacht ( multiplizierter_Wert = x * 3).
Schließlich wird der verdreifachte Wert per Druck ausgegeben. Das Ausgabeergebnis ist 30, was 3 mal 10 ist.
Zuvor habe ich eine Funktion erstellt, die den Wert von x mit dem Argument x verdreifacht. Ändern wir nun zur Laufzeit den Wert von "multiplizieren" mit dem Argument. Akzeptieren Sie das Argument y anstelle des dreifachen Teils.
Fügen Sie zwischen den Argumenten ein Komma mit halber Breite hinzu, um das zweite und die nachfolgenden Argumente anzugeben. Es verursacht keinen Fehler, selbst wenn Sie kein Leerzeichen einfügen. Da es jedoch im Python-Codierungsstandard festgelegt ist, ein Leerzeichen mit halber Breite nach dem Komma einzufügen, schreiben Sie es so.
Der Argumentteil der Funktion ist in diesem Fall Code wie "(x, y)".
def multiply_x_by_y(x, y):
multiplied_value = x * y
print(multiplied_value)
multiply_x_by_y(10, 5)
Ausgabeinhalt des Ergebnisses der Codeausführung:
50
Wenn Sie eine Funktion mit mehreren Argumenten ausführen, legen Sie die durch Kommas halber Breite getrennten Werte fest. Wenn Sie x auf 10 und y auf 5 setzen möchten, schreiben Sie den Funktionsausführungsteil wie "multiply_x_by_y (10, 5)".
Bei der Verarbeitung innerhalb der Funktion wird der Code mit y multipliziert, anstatt mit dem Code, der wie "* 3" ("multiplizierter_Wert = x * y") verdreifacht wird.
Infolgedessen beträgt der Wert, der durch Drucken durch Multiplizieren von 10 von x und 5 von y ausgegeben wird, 50.
Wenn Sie 3 oder mehr Argumente verwenden möchten, können Sie eine beliebige Anzahl von Argumenten festlegen, indem Sie Kommas hinzufügen. Wenn Sie beispielsweise eine Funktion erstellen möchten, die die drei Argumente x, y und z akzeptiert, schreiben Sie wie folgt.
def multiply_x_y_z(x, y, z):
multiplied_value = x * y * z
print(multiplied_value)
multiply_x_y_z(10, 5, 3)
Ausgabeinhalt des Ergebnisses der Codeausführung:
150
Der Argumentteil hat drei Werte, "(x, y, z)", und selbst wenn die Funktion ausgeführt wird, werden drei Werte wie "multiply_x_by_y (10, 5, 3)" durch Kommas halber Breite getrennt angegeben. Ich werde.
Das Ausgabeergebnis per Druck ist 150 mit 10 x 5 x 3 der drei Argumente von xyz.
Auf diese Weise können mehrere Werte für das Argument festgelegt werden, die jedoch in der Reihenfolge des ersten Arguments, des zweiten Arguments, des dritten Arguments usw. aufgerufen werden. In dieser Funktion ist das erste Argument der Funktion "multiply_x_y_z" "x", das zweite Argument "y" und das dritte Argument "z".
Was passiert beispielsweise, wenn eine Funktion, die drei Argumente akzeptiert, zur Laufzeit nur zwei Werte angibt? Schreiben wir den Code und probieren ihn aus.
def multiply_x_y_z(x, y, z):
multiplied_value = x * y * z
print(multiplied_value)
multiply_x_y_z(10, 5)
Der Inhalt des Codes ist eine Funktion, die drei Argumente akzeptiert, "x, y, z", und nur zwei Werte an die Argumente übergibt, z. B. "multiply_x_y_z (10, 5)" zur Laufzeit (Wert des Arguments von z). Ist nicht angegeben).
TypeError Traceback (most recent call last)
<ipython-input-27-8cab8c50c583> in <module>
4
5
----> 6 multiply_x_y_z(10, 5)
TypeError: multiply_x_y_z() missing 1 required positional argument: 'z'
Als ich es versuchte, trat ein Fehler auf. Lesen wir die Fehlermeldung.
Fehlend bedeutet "nicht genug" und erforderlich bedeutet "erforderlich". Argument war ein englisches Wort für das Argument.
Grob übersetzt lautet die Fehlermeldung "Es sind nicht genügend erforderliche (nicht verfehlbare) Positionsargumente mit dem Namen" z "vorhanden".
Ein Fehler tritt auf, wenn die erforderlichen Argumente nicht angegeben werden, wenn die Funktion auf diese Weise ausgeführt wird. Wenn Sie diesen Fehler erhalten, überprüfen Sie "Welche Argumente fehlen?" Und überprüfen Sie den Code, den Sie ausführen, um festzustellen, ob die Anzahl der Argumente korrekt ist.
Wie Sie der Fehlermeldung im vorherigen Abschnitt entnehmen können, in der "Erforderliches Positionsargument" steht und die Fehlermeldung erforderlich ist, können Sie auch das Argument "Nicht erforderlich (optional)" festlegen.
Diese optionalen Argumente werden als "optionale Argumente" bezeichnet (optionale Argumente in Englisch).
Wenn dies weggelassen wird, wird "welcher Wert das Argument sein wird" durch einen sogenannten "Standardwert" angegeben. Um den Standardwert für das Argument festzulegen, setzen Sie unmittelbar nach dem Argumentnamen das Symbol halber Breite gleich = und den Standardwert, den Sie festlegen möchten. Wenn Sie beispielsweise den Standardwert 10 für das Argument x festlegen möchten, schreiben Sie "x = 10".
Beim Erstellen von Variableneinstellungen wurden Leerzeichen mit halber Breite vor und nach dem Gleichheitszeichen eingefügt. Die korrekte Python-Codierungskonvention besteht jedoch nicht darin, Leerzeichen vor und nach dem Gleichheitszeichen in das Standardargument einzufügen. Bitte beachten Sie, dass es sich von den variablen Einstellungen unterscheidet.
Selbst wenn Sie ein Leerzeichen einfügen, tritt kein Fehler auf, aber der Code entspricht nicht den Codierungsstandards.
Schreiben wir den Code und probieren ihn aus.
def print_x(x=10):
print(x)
Der Inhalt ist eine einfache Funktion, die nur den im Argument angegebenen Wert mit print druckt. Es gibt nur ein Argument mit dem Namen x.
Stellen Sie sicher, dass der Argumentteil "x = 10" ist. Dies ist die Beschreibung, dass "wenn die Argumentspezifikation von x weggelassen wird, der Standardwert von 10 gesetzt wird".
Lassen Sie uns die Funktion ausführen. Lassen Sie es uns zuerst ausführen, ohne das Argument von x wegzulassen. Geben Sie 30 für das x-Argument an.
print_x(30)
Ausgabeinhalt des Ergebnisses der Codeausführung:
30
Der im Argument angegebene Wert 30 wurde ausgegeben.
Auf diese Weise können Sie sehen, dass der angegebene Wert Priorität hat (diesmal 30) und der Standardwert 10 ignoriert wird, wenn Sie den Wert angeben, ohne das Argument wegzulassen, für das der Standardwert festgelegt ist.
Dieses Mal werde ich das Argument weglassen und es ausführen. Beachten Sie, dass zwischen den Klammern von "(" und ")" nichts steht (der Wert des Arguments ist nicht angegeben).
print_x()
Ausgabeinhalt des Ergebnisses der Codeausführung:
10
Als Ergebnis wird 10 ausgegeben, die als Standardwert des Arguments festgelegt ist.
Auf diese Weise wird, wenn der Standardwert als Argument festgelegt wird,
--Wenn für das Argument ein Wert angegeben wird-> Der angegebene Wert wird gesetzt. --Wenn das Argument weggelassen wird-> Der Standardwert des Arguments wird festgelegt.
Es wird das Verhalten.
Der Standardwert wird hauptsächlich in Fällen wie "Normalerweise ist dieser Standardwert in Ordnung, aber Sie möchten den Wert gelegentlich ändern" verwendet.
Umgekehrt sollten Sie keinen Standardwert festlegen, wenn der für das Argument angegebene Wert jedes Mal grundsätzlich unterschiedlich ist.
In solchen Fällen sollte die Funktion so erstellt werden, dass normale Argumente erforderlich sind. Wenn Sie jedes Mal ein Argument angeben müssen, aber versehentlich vergessen haben, es anzugeben, und der Standardwert festgelegt ist (auch wenn Sie vergessen haben, das Argument anzugeben), tritt kein Fehler auf und Sie bemerken den Fehler möglicherweise nicht. Weil es möglich ist.
Wenn Sie ein Argument mit einem Standardwert festlegen, gilt die Regel, dass "das Argument, für das der Standardwert festgelegt wird, nach dem erforderlichen Argument stehen muss".
Wenn Sie beispielsweise ein Argument mit einem Standardwert (x = 10) gefolgt von einem erforderlichen Argument ohne Standardwert ( y) in der unten gezeigten Funktion festlegen, tritt ein Fehler auf.
def multiply_x_by_y(x=10, y):
multiplied_value = x * y
print(multiplied_value)
File "<ipython-input-34-13a53a0612f1>", line 1
def multiply_x_by_y(x=10, y):
^
SyntaxError: non-default argument follows default argument
Die Übersetzung der Fehlermeldung lautet etwa "Ein Argument ohne Standardwert folgt auf ein Argument mit einem Standardwert."
Dies liegt daran, dass beim Ausführen einer Funktion wie "multiply_x_by_y (10)" das erste Argument weggelassen werden kann, während das zweite Argument nicht weggelassen werden kann (es gibt keinen Standardwert), also "(10) Dies liegt daran, dass das Programm nicht bestimmen kann, ob der Wert von) `der Wert für x im ersten Argument oder der Wert für y im zweiten Argument ist.
Daher muss das Argument mit dem Standardwert nach dem erforderlichen Argument platziert werden. Wie unten gezeigt, ist beim Festlegen eines optionalen Arguments mit zwei Argumenten x und y die x-Seite das erforderliche Argument und die y-Seite hat den Standardwert. Sie funktioniert fehlerfrei.
def multiply_x_by_y(x, y=10):
multiplied_value = x * y
print(multiplied_value)
Wenn dieser Fehler nicht auftritt und Sie nur ein Argument wie "multiply_x_by_y (30)" angeben und ausführen, können Sie sehen, dass es sich um den Wert für x des erforderlichen ersten Arguments handelt, und "multiply_x_by_y" (30, 20). Selbst wenn Sie beide Werte angeben, ohne `und das Argument wegzulassen, kann der Code vom Programm problemlos interpretiert werden, z. B. der Wert von x ist 30 und der Wert von y ist 20.
Selbst wenn mehrere Argumente erforderlich sind, muss das Argument mit dem Standardwert darauf folgen.
Wie unten gezeigt, ist es beispielsweise nicht möglich, das erforderliche Argument z nach dem erforderlichen Argument x gefolgt vom Argument y mit dem Standardwert festzulegen (ein Fehler tritt auf).
def multiply_x_y_z(x, y=20, z):
multiplied_value = x * y * z
print(multiplied_value)
File "<ipython-input-39-81a253f339fe>", line 1
def multiply_x_y_z(x, y=20, z):
^
SyntaxError: non-default argument follows default argument
Selbst wenn mehrere erforderliche Argumente wie dieses vorhanden sind, muss das Argument mit dem Standardwert (z = 20) nach dem erforderlichen Argument ohne den unten gezeigten Standardwert gebracht werden.
def multiply_x_y_z(x, y, z=20):
multiplied_value = x * y * z
print(multiplied_value)
Selbst wenn Sie mehrere Argumente mit Standardwerten festlegen möchten, tritt kein Fehler auf, wenn sie nach den erforderlichen Argumenten stehen. Wenn Sie beispielsweise festlegen möchten, dass die Argumente y und z Standardwerte haben, tritt kein Fehler auf, wenn jedes der Argumente dem erforderlichen Argument x folgt, das keinen Standardwert hat, wie unten gezeigt.
def multiply_x_y_z(x, y=20, z=30):
multiplied_value = x * y * z
print(multiplied_value)
Angenommen, Sie haben eine Funktion mit vielen Argumenten wie diesem:
def calculate_cost(manufacturing_cost, labor_cost, delivery_cost, tax):
sum_value = manufacturing_cost + labor_cost + delivery_cost + tax
return sum_value
Wenn ich versuche, die Funktion auszuführen, sieht es so aus:
calculate_cost(1000, 400, 150, 50)
Mit dieser Zahl ist es vorerst möglich zu erfassen, welchem Argument jeder Wert entspricht. Es ist jedoch schwer zu verstehen, und es ist wahrscheinlich, dass Sie versehentlich einen Fehler in der Reihenfolge machen.
Was ist, wenn die Anzahl der Argumente weiter zunimmt? Stellen Sie sich beispielsweise eine Funktion vor, für die 10 Argumente erforderlich sind, oder eine Funktion, für die 15 Argumente erforderlich sind.
Es scheint sehr schwierig zu sein, die Argumentwerte der Reihe nach anzugeben, ohne einen Fehler zu machen. Stellen Sie sich auch den Fall vor, in dem die Funktion die Anzahl der Argumente bei Aktualisierungen häufig ändert. Wenn sich in der Mitte keine Argumente befinden, ist die Reihenfolge der nachfolgenden Argumente nicht in der richtigen Reihenfolge, was sehr verwirrend ist.
Als Gegenmaßnahme für solche Fälle gibt es in Python eine Funktion namens "Schlüsselwortargumente".
Mithilfe von Schlüsselwortargumenten können Sie auch für Funktionen mit vielen Argumenten einfach zu lesenden Code schreiben.
Lassen Sie uns tatsächlich den Code für den Funktionsausführungsteil schreiben. Um Schlüsselwortargumente zu verwenden, können Sie sie verwenden, indem Sie sie in der Form "Argumentname = im Argument angegebener Wert" am Ausführungsort der Funktion schreiben. Um beispielsweise in der Funktion des obigen Beispielcodes das Schlüsselwortargument mit dem Argument "Fertigungskosten" zu verwenden, schreiben Sie als "Fertigungskosten = 1000".
Wenn Sie mehrere andere Funktionen angeben, entspricht die Regel, sie durch ein Komma halber Breite zu trennen, normalerweise der Argumentspezifikation.
calculate_cost(
manufacturing_cost=1000,
labor_cost=400,
delivery_cost=150,
tax=50)
Mithilfe von Schlüsselwortargumenten können Sie jetzt schnell herausfinden, welches Argument der Wert jedes Arguments ist. Zum Beispiel ist "Delivery_cost" 150.
Wenn Sie Schlüsselwortargumente verwenden, wird der Code für den Argumentnamen horizontal lang und schwer lesbar. Daher wird im obigen Code für jedes Argument ein Zeilenumbruch eingefügt.
Wie oben erwähnt, haben Schlüsselwortargumente zusätzlich zu den Vorzügen "Eine Funktion mit vielen Argumenten erleichtert das Verständnis des Inhalts und verringert das Auftreten von Fehlern" mehrere Vorteile.
Dies ist beispielsweise bei einer Funktion hilfreich, die viele Argumente mit Standardwerten enthält, z. B. "Ich möchte nur für einige der letzteren Argumente einen bestimmten Wert festlegen".
Angenommen, Sie haben eine Funktion wie diese:
def multiply_x_y_z(x=10, y=20, z=30):
multiplied_value = x * y * z
print(multiplied_value)
Diese Funktion hat Standardwerte für alle x-, y- und z-Argumente (Argumente können weggelassen werden).
Stellen Sie sich einen Fall vor, in dem Sie mit dieser Funktion nur das Argument z auf den Wert 100 ändern müssen. Wenn Sie ein normales Argument angeben, müssen Sie die Werte in der angegebenen Reihenfolge angeben. Wenn Sie also versuchen, den Wert von z anzugeben, müssen Sie denselben Wert wie den Standardwert für x und y angeben (multiply_x_y_z (10, 20, 100)). ) ).
Wenn es ungefähr 3 Argumente gibt, wird es schmerzhaft, wenn die Anzahl der Argumente zunimmt. Insbesondere in Fällen, in denen das letztere Argument häufiger verwendet wird, wird es schmerzhafter (selbst wenn die Argumente zum Zeitpunkt des Schreibens des Codes in der Reihenfolge ihrer Priorität festgelegt werden, bleibt es aufgrund des Zeitablaufs oder von Aktualisierungen usw. zurück. Es ist möglich, dass das Argument von wichtiger ist).
Und was ist, wenn der Code aktualisiert wird und sich die Standardwerte für die Funktionen ändern? Angenommen, der Standardwert einer Funktion wird auf "def multiply_x_y_z (x = 100, y = 200, z = 300)" aktualisiert.
Wenn in einem solchen Fall die Ausführungsseite der Funktion (Code wie "multiply_x_y_z (10, 20, 100)") nicht ohne Auslassung aktualisiert wird, heißt es, dass "derselbe Wert wie der Standardwert angenommen und angegeben wurde". In einigen Fällen kann es sich unerwartet verhalten (wenn es viele Stellen gibt, an denen die Funktion ausgeführt wird, ist es schwierig, sie fehlerfrei zu korrigieren).
Auf der anderen Seite können Sie mit Schlüsselwortargumenten eine Funktion ausführen, indem Sie direkt nur einen Wert für das Argument mit einem bestimmten Argumentnamen angeben.
Wenn Sie beispielsweise den Wert nur für das Argument von z angeben und die anderen Werte als Standardwerte festlegen möchten, können Sie wie folgt schreiben.
multiply_x_y_z(100)
Wenn Sie auf diese Weise schreiben, können Sie die zusätzliche Beschreibung reduzieren und den Effekt reduzieren, wenn der Standardwert in der Funktion geändert wird.
Ein weiterer Punkt, der bei Schlüsselwortargumenten berücksichtigt werden muss, ist, dass "Argumente, die Standardwerte annehmen, grundsätzlich als Schlüsselwortargumente angegeben werden sollten".
In Bezug auf das Argument, das den Standardwert annimmt, kann es aufgrund der Eigenschaft, dass die Einstellung willkürlich ist (es muss nicht sein), aufgrund täglicher Aktualisierungen hinzugefügt oder gelöscht werden, oder die Reihenfolge der Argumente kann geändert werden. Es gibt Fälle zu tun.
Wenn Sie also jedes Mal das Argument mit dem Standardwert als Schlüsselwortargument angeben, ist es im Grunde schwer zu beeinflussen, und der Code ist robust, sodass es in Ordnung ist, wenn die Reihenfolge der Argumente mit dem Standardwert geändert wird.
Sollten wir die referenzierte Funktion nicht ändern? Sie mögen denken, dass ich bei der Arbeit häufig Bibliotheken verwende, die von anderen Personen erstellt wurden (z. B. eine praktische und universelle Codesammlung), aber solche Bibliotheken sind aus Sicherheitsgründen alt. In einigen Fällen müssen Sie ein Update durchführen, da die Unterstützung in der Version abgelaufen ist.
Verwenden Sie in solchen Fällen Schlüsselwortargumente entsprechend, um die Anzahl der Dinge zu verringern, die im Update stecken bleiben oder Fehler verursachen.
Es ist ein bisschen wie der Unterschied im Verhalten zwischen globalen und lokalen Variablen für jeden im vorherigen Abschnitt erwähnten Typ, aber die Argumente haben auch die Konzepte "Übergeben von Werten" und "Übergeben von Referenzen".
Obwohl es ein wenig schwierig ist, die Bedeutung des Japanischen zu verstehen, weist jedes die folgenden Merkmale auf.
Je nach Wertetyp wird das Verhalten in Wertübergabe und Referenzübergabe unterteilt.
Es wird sein.
Es ist schwer zu verstehen, also schreiben wir einen Code und probieren ihn aus.
Versuchen wir zunächst, eine Ganzzahl als Argument anzugeben, das als Wert übergeben wird.
def add_one_to_x(x):
x += 1
cat_age = 10
add_one_to_x(x=cat_age)
print(cat_age)
Ausgabeinhalt des Ergebnisses der Codeausführung:
10
Zuerst erstellen wir eine Variable mit dem Namen "cat_age" außerhalb der Funktion. Der Wert wird auf 10 gesetzt.
Danach wird die Funktion im Teil add_one_to_x (x = cat_age) ausgeführt und die Variable cat_age als Argumentwert angegeben.
In der Funktion wird 1 zum Argumentwert hinzugefügt, und schließlich wird der Wert der Variablen von "print (cat_age)" ausgegeben.
Das Ausgabeergebnis ist 10 (nicht 11), obwohl 1 in der Funktion hinzugefügt wird.
Die diesmal im Argument angegebene Variable cat_age ist ein ganzzahliger Wert. Daher wird es als Wert übergeben, und beim Übergeben als Wert wird der Wert kopiert und an die Funktion übergeben (als etwas anderes als die ursprüngliche Variable übergeben). Selbst wenn der Wert in der Funktion aktualisiert wird, ist die ursprüngliche Variable betroffen. Es bleibt bei 10 ohne.
Versuchen wir nun, Code für einen Fall zu schreiben, in dem die Referenz als Wert übergeben wird. Früher habe ich einen ganzzahligen Wert als Argument angegeben, aber dieses Mal werde ich ein Wörterbuch als Argument angeben.
my_age = 25
my_age += 2
print(my_age)
Ausgabeinhalt des Ergebnisses der Codeausführung:
27
Zuerst setze ich ein Wörterbuch mit dem Schlüssel age in der Variablen cat_info_dict.
Danach wird die Funktion ausgeführt und die Variable cat_info_dict als Argument angegeben.
In der Funktion wird 1 zum Wert des Schlüssels "age" des im Argument angegebenen Wörterbuchs hinzugefügt.
Schließlich druckt print den Inhalt der Variablen cat_info_dict.
Wie Sie dem Ausgabeergebnis entnehmen können, spiegelt sich die Aktualisierung des Werts des in der Funktion ausgeführten Wörterbuchs in der ursprünglichen Variablen wider, und das Ergebnis des Schlüssels "age" des Wörterbuchs ist 11. Ich werde.
Wenn ein Wörterbuch oder eine Liste auf diese Weise angegeben wird, wird die Referenz als Wert übergeben und die ursprüngliche Variable wird ebenfalls geändert.
Da sich das Verhalten je nach Typ ändert, gibt es beide Fälle, in denen erwartet wird, dass die Variable aktualisiert, aber "aktualisiert" wird, und in denen erwartet wird, dass die Variable aktualisiert, aber nicht aktualisiert wird. Seien Sie vorsichtig, da es leicht ist, versehentlich Fehler zu machen.
Warum ändert sich das Verhalten übrigens je nach Typ? Es gibt zwei Hauptgründe, und der erste ist, dass "wie bei lokalen Variablen Fehler reduziert werden können, wenn außerhalb der Funktion keine Auswirkungen auftreten".
Wie im Abschnitt über lokale und globale Variablen erwähnt, verschwinden lokale Variablen, nachdem die Funktion ausgeführt wurde. Daher ist es sicherer, mit dem Code umzugehen, um Fehler weniger wahrscheinlich zu machen, z. B. dass viele Variablen in einem Bereich außerhalb der Funktion erstellt werden und von anderen Funktionen nicht referenziert werden können.
Wenn eine Ganzzahl oder Zeichenfolge als Wert übergeben wird, wird sie wie eine lokale Variable behandelt. Mit anderen Worten, wenn die Ausführung der Funktion abgeschlossen ist, wird der im Argument angegebene Wert (der von der ursprünglichen Variablen kopierte Wert usw.) verworfen.
Dies ermöglicht eine sichere Implementierung ähnlich der Arbeit mit lokalen Variablen.
Warum werden Listen und Wörterbücher als Referenz übergeben, nicht kopiert, sondern als Argumente? Warum ist es sicherer, es als lokale Variable zu kopieren und zu behandeln?
Der Grund dafür ist, dass Listen und Wörterbücher viele Zahlen und Zeichenfolgen speichern können, sodass das Kopieren die Verarbeitungslast erhöhen kann.
Was ist zum Beispiel, wenn die Liste Millionen von Zahlen enthält? Wenn die Liste jedes Mal kopiert wird, wenn die Funktion ausgeführt wird, ist die Verarbeitungszeit lang, und wenn viele derart große Listen kopiert werden, wird viel Speicher des Personal Computers benötigt (Spezifikation). Es wird schwierig sein, den Code auf einem niedrigen Computer auszuführen.
Um die Belastung bei der Ausführung von Funktionen zu verringern, wird bei Listen und Wörterbüchern der Wert der Variablen unverändert übergeben, ohne dass er durch den Wert kopiert wird. Die Tatsache, dass der Wert an das Argument übergeben wird, ohne auf diese Weise kopiert zu werden, ist der zweite Vorteil, dass die Funktion mit weniger Last ausgeführt werden kann.
Ist es in diesem Sinne nicht besser, die Zahlen und Zeichenketten zu übergeben, ohne sie zu kopieren? Selbst wenn der numerische Wert oder der Wert einer einzelnen Zeichenfolge kopiert wird, handelt es sich um eine Last, die fast als "Fehler" bezeichnet werden kann, wenn es sich um einen neueren Personal Computer handelt (außer wenn eine zu lange Zeichenfolge angegeben wird). ).
Wenn die Last so ist, dass der Wert kopiert und wie eine lokale Variable behandelt wird, besteht ein großer Sicherheitsvorteil, sodass der Wert als Wertübergabe kopiert wird.
Aus diesem Grund unterscheidet sich das Verhalten der Wertübergabe und der Referenzübergabe je nach Typ aufgrund der Vor- und Nachteile.
Seien Sie vorsichtig, da dies bei Verwirrung zu Fehlern führen kann.
Es ist jedoch ein Konzept, das schwer zu verstehen ist, bis Sie sich daran gewöhnt haben. Es ist also kein Problem, wenn Sie diese lernen, wenn Sie sich nach und nach an das Programmieren gewöhnen. Solange Sie den Code weiter schreiben, werden Sie wahrscheinlich feststellen, dass Sie sich nicht wie erwartet verhalten, wenn Sie in Zukunft einen Wert oder eine Referenz übergeben.
Wenn Sie solche Erfahrungen sammeln, werden Sie sich allmählich und natürlich daran erinnern. Priorisieren Sie das Schreiben von Code ohne Eile.
Im vorherigen Abschnitt zum Übergeben von Werten habe ich geschrieben, dass Werte wie Ganzzahlen und Zeichenfolgen von Argumenten kopiert und übergeben werden und Änderungen dieser Werte innerhalb der Funktion nicht außerhalb der Funktion wiedergegeben werden.
Es gibt jedoch viele Fälle, in denen Sie das Ergebnis einer Funktion empfangen und in einer Variablen außerhalb der Funktion festlegen möchten.
In einem solchen Fall kann dies unter Verwendung der Funktion realisiert werden, die als Rückgabewert (auch als Rückgabewert oder Rückgabewert bezeichnet) der Funktion bezeichnet wird. Der Rückgabewert ist der Rückgabewert in Englisch.
Wenn Sie den Rückgabewert in der Funktion einstellen, schreiben Sie ihn als Rückgabewert in die Funktion.
Lassen Sie uns den Code tatsächlich schreiben und verschieben. Im folgenden Code ist der Teil "return added_value" in der Funktion die Beschreibung der Rückgabewertbeziehung.
def add_one(x):
added_value = x + 1
return added_value
returned_value = add_one(x=10)
print(returned_value)
Ausgabeinhalt des Ergebnisses der Codeausführung:
11
Wenn Sie eine Funktion ausführen, für die ein Rückgabewert festgelegt ist, wird der Wert zurückgegeben. Sie können den Inhalt des zurückgegebenen Werts abrufen, indem Sie den Wert in einer Variablen oder dergleichen festlegen.
Im obigen Code gilt der Teil von "return_value = add_one (x = 10)". Die Funktion wird im Teil add_one (x = 10) ausgeführt, und der Wert wird zurückgegeben, sodass es möglich ist, den Wert des in der Funktion festgelegten Rückgabewerts anhand der Beschreibung abzurufen, die den Wert auf die Variable return_value = setzt. Ich kann es schaffen
Der Inhalt der Funktion besteht lediglich darin, 1 zu dem im Argument x angegebenen Wert hinzuzufügen und diesen Wert zurückzugeben (return added_value).
Wenn Sie versuchen, den Wert des Rückgabewerts (print (return_value)) auszugeben, können Sie sehen, dass 11 als Ergebnis der Addition von 1 in der Funktion ausgegeben wird.
Die Beschreibung von "return" hat die Bedeutung "die Verarbeitung der Funktion stoppen" zusätzlich zum Festlegen des Rückgabewerts. Wenn der Teil "return" in der Funktion angetroffen wird, wird die Verarbeitung der Funktion dort gestoppt und die nachfolgende Verarbeitung wird nicht ausgeführt.
Wenn Sie den Prozess nur stoppen möchten, können Sie nur "return" schreiben, ohne den Rückgabewert festzulegen.
Wenn sich beispielsweise eine Beschreibung von "return" direkt unter der unten gezeigten Funktion befindet, wird die nachfolgende Verarbeitung nicht ausgeführt.
def add_one(x):
return
added_value = x + 1
return added_value
returned_value = add_one(x=20)
print(returned_value)
Ausgabeinhalt des Ergebnisses der Codeausführung:
None
Da zu Beginn der Funktion eine Beschreibung von "return" steht, wird die nachfolgende Verarbeitung nicht ausgeführt. Die Verarbeitung wird an diesem Rückgabepunkt gestoppt.
Mit anderen Worten, die nachfolgende Verarbeitung von "addierter Wert = x + 1" und "Rückgabe addierten Wert" wird nicht ausgeführt.
Selbst wenn Sie die Funktion (return_value = add_one (x = 20)) tatsächlich ausführen und das Ergebnis ausgeben (print (return_value)), wird das Ergebnis von plus 1 nicht ausgegeben und der Inhalt ist None. Es wird ausgegeben. Keiner ist ein Wert wie "nichts", auf den wir in einem späteren Kapitel näher eingehen werden. Da die Verarbeitung gestoppt wird, ohne den Rückgabewert nur mit "return" zu setzen, ist der Rückgabewert None.
Das Berechnungsergebnis usw. wird nicht zurückgegeben, und Sie können sehen, dass der Teil wie "return added_value" nicht ausgeführt wird.
Was ist in der aktuellen Situation die Steuerung, um die Verarbeitung einer solchen Funktion in der Mitte zu stoppen? Obwohl es so scheint, ist es nützlich für bedingte Verzweigungen, die in späteren Kapiteln gelernt werden. Zum Beispiel können Sie Dinge wie "Verarbeitung unter XX-Bedingungen beenden" steuern.
Sie können mehrere Werte für den Rückgabewert festlegen. Stellen Sie in diesem Fall mehrere Werte ein, die durch Kommas mit halber Breite getrennt sind.
Im folgenden Code werden beispielsweise mehrere Rückgabewerte im Teil "return added_x, added_y" durch Kommas getrennt festgelegt.
def add_one(x, y):
added_x = x + 1
added_y = y + 1
return added_x, added_y
returned_x, returned_y = add_one(x=100, y=200)
print('returned_x:', returned_x, 'returned_y:', returned_y)
Ausgabeinhalt des Ergebnisses der Codeausführung:
returned_x: 101 returned_y: 201
Der Inhalt der Funktion besteht darin, dass sie zwei Argumente empfängt, x und y plus jeweils 1, und beide als Rückgabewerte zurückgibt.
Wie Sie dem Teil "return_x, return_y = add_one (x = 100, y = 200)" entnehmen können, muss der Teil des Werts, der nach Ausführung der Funktion in der Variablen festgelegt werden soll, auch durch Kommas getrennt gesetzt werden.
Schließlich wird der Inhalt des Rückgabewerts durch print gedruckt (print ('return_x:', return_x, 'return_y:', return_y)).
Wie wir in einem späteren Kapitel genauer sehen werden, kann print auch mehrere Werte gleichzeitig drucken, die durch Kommas getrennt sind (drucken Sie insgesamt vier Werte, um zwei Zeichenfolgen als Beschriftungen und die Werte zweier Variablen zu drucken). Spezifizierten).
Wenn Sie den Ausgabeinhalt überprüfen, können Sie den erhaltenen Wert überprüfen, indem Sie den für x und y des Arguments angegebenen Wert plus 1 in jede Rückgabewertvariable einfügen.
Das Festlegen des Rückgabewerts mehrerer Werte ist praktisch, aber genauso wie es leicht ist, Fehler zu machen, wenn Sie versuchen, viele Argumente mit normalen Argumenten anstelle von Schlüsselwortargumenten zu verwenden, ist es leicht, Fehler mit vielen Rückgabewerten zu induzieren. Im Gegensatz zur Argumentationsseite gibt es keine Funktion wie den Schlüsselwortrückgabewert. Verwenden Sie sie daher moderat, damit sie nicht zu stark zunimmt.
Wichtigkeit: ★★ ☆☆☆ (Sie müssen es zuerst nicht wissen)
Angenommen, Sie haben eine Funktion (add_three_value), die drei Argumente akzeptiert, x, y und z, wie im folgenden Code. Ich habe auch eine Listenvariable (argument_list), die drei Werte speichert, und ich möchte diese in der angegebenen Reihenfolge angeben.
def add_three_value(x, y, z):
total = x + y + z
return total
argument_list = [10, 20, 30]
Da jeder der drei Werte des Arguments als Ganzzahl angegeben werden muss, stimmt die Anzahl der Argumente nicht nur durch Angabe der Liste überein (es wird nur ein Argument angegeben, und die verbleibenden zwei Argumente reichen nicht aus. ) Wird zum Fehler führen.
add_three_value(argument_list)
TypeError: add_three_value() missing 2 required positional arguments: 'y' and 'z'
Wenn Sie den Wert in der Liste für jedes Argument wie dieses angeben möchten, setzen Sie als spezielle Schreibweise für Python das Sternsymbol * mit halber Breite unmittelbar vor der Listenvariablen in der Wertespezifikation zum Zeitpunkt der Funktionsausführung. Anschließend wird der Inhalt der Liste den Argumenten der Reihe nach zugewiesen.
Im folgenden Codebeispiel gilt der Codeteil "* argument_list".
returned_value = add_three_value(*argument_list)
print(returned_value)
Ausgabeinhalt des Ergebnisses der Codeausführung:
60
Diesmal funktioniert es ohne Fehler. Sie können der Ausgabe auch entnehmen, dass x, y und z den Inhalt der Liste 10, 20 bzw. 30 übergeben und insgesamt 60 Werte zurückgegeben werden.
Diese Schreibmethode mit einem Sternchen erweitert den Inhalt der Liste und ordnet ihn den Argumenten zu. Wenn also die Anzahl der Argumente und die Anzahl der Werte in der Liste nicht übereinstimmen, tritt ein Fehler auf.
Wenn Sie beispielsweise eine Liste mit 4 Werten für eine Funktion angeben, die 3 Argumente empfängt, wie unten gezeigt, tritt ein Fehler auf.
def add_three_value(x, y, z):
total = x + y + z
return total
argument_list = [100, 200, 300, 400]
add_three_value(*argument_list)
TypeError: add_three_value() takes 3 positional arguments but 4 were given
In der Fehlermeldung heißt es etwa "Die Funktion add_three_value () erfordert 3 Argumente, aber 4 Werte sind angegeben" und die Anzahl der Argumente der Funktion und die tatsächliche Sie können sehen, dass ein Fehler aufgrund einer Nichtübereinstimmung der in angegebenen Werte aufgetreten ist.
Wenn jedoch die im vorherigen Abschnitt genannten Standardwerte festgelegt sind und optionale Argumente enthalten, spielt es keine Rolle, ob die Anzahl der Argumente und die Anzahl der Werte in der Liste nicht übereinstimmen. Wie unten gezeigt, kann in einer Funktion mit drei Argumenten x, y und z die Anzahl der Elemente in der Liste 2 oder 3 betragen, wenn der Standardwert für z festgelegt ist (z kann weggelassen werden), und es tritt ein Fehler auf. (Da 2 Elemente nicht weggelassen werden können, tritt ein Fehler auf, wenn eine Liste mit 1 Wert angegeben wird.)
Die Liste kann durch Angabe eines Sternchens bearbeitet werden. Aber was ist mit Keyword-Argumenten? Im folgenden Fall möchten Sie beispielsweise ein Wörterbuch mit in den Schlüsseln festgelegten Argumentnamen für eine Funktion angeben, die wie zuvor drei Argumente x, y und z enthält.
def add_three_value(x, y, z):
total = x + y + z
return total
argument_dict = {
'x': 10,
'y': 20,
'z': 30,
}
Wenn Sie mit einem solchen Wörterbuch einen Wert in Python als Schlüsselwortargument angeben möchten, können Sie dies tun, indem Sie beim Ausführen der Funktion zwei Sternsymbole mit halber Breite unmittelbar vor dem Argumentwert festlegen. Stellen Sie zwei Sternchen vor das Wörterbuch, zum Beispiel "** argument_dict".
total = add_three_value(**argument_dict)
print(total)
Ausgabeinhalt des Ergebnisses der Codeausführung:
60
Selbst bei der Methode zum Angeben von Schlüsselwortargumenten mithilfe dieses Wörterbuchs tritt ein Fehler auf, wenn die Schlüsselwortargumente nicht ausreichend angegeben werden, mit Ausnahme der Argumente, für die Standardwerte festgelegt sind, wie im Fall der Liste. Wenn Sie beispielsweise versuchen, den Code in der obigen Funktion ohne das im Wörterbuch enthaltene Schlüsselwortargument y auszuführen, tritt der folgende Fehler auf.
def add_three_value(x, y, z):
total = x + y + z
return total
argument_dict = {
'x': 10,
'z': 30,
}
add_three_value(**argument_dict)
TypeError: add_three_value() missing 1 required positional argument: 'y'
Normalerweise tritt ein Fehler auf, wenn Sie mehr Werte als die in der Funktion festgelegte Zahl als Argumente angeben, wie in dem Fall, in dem 3 Argumente für eine Funktion angegeben werden, die im folgenden Code 2 Argumente akzeptiert.
def add_two_value(x, y):
total = x + y
return total
add_two_value(100, 200, 300)
TypeError: add_two_value() takes 2 positional arguments but 3 were given
Wenn ich die Fehlermeldung lese, heißt es so etwas wie "Die Funktion add_two_value akzeptiert zwei Argumente, aber drei Argumente sind angegeben." Auf diese Weise ist die Anzahl der Argumente, die eine Funktion akzeptieren kann, grundsätzlich begrenzt.
Wenn Sie jedoch eine beliebige Anzahl von Argumenten akzeptieren, können Sie ein flexibles Verhalten mit einer Funktion implementieren, z. B. "Berechnen mit dem Wert von 3 Argumenten" oder "Berechnen mit dem Wert von 5 Argumenten". ..
Verwenden Sie zum Erstellen einer solchen Funktion ein Sternchen mit halber Breite im Argumentteil der Funktion auf dieselbe Weise wie beim Ausführen der Funktion. Was den Argumentnamen betrifft, wird der Name "args" häufig als "Argumentgruppe beliebiger Funktionen" verwendet. Wird oft in der Form "* args" mit einem Sternchen verwendet.
Das Argument * args wird mit einem Taple gesetzt (es sieht aus wie die im vorherigen Kapitel erwähnte Liste, in der die Wertänderungen nicht funktionieren).
def print_args(*args):
print(args)
Der Inhalt der Funktion druckt einfach den Inhalt des übergebenen Arguments * args aus.
Versuchen wir es mit 3 Argumenten.
print_args(100, 200, 300)
Ausgabeinhalt des Ergebnisses der Codeausführung:
(100, 200, 300)
Wenn Sie sich den Ausgabeinhalt von * args ansehen, können Sie sehen, dass derjenige, in dem die drei Werte gespeichert sind, ordnungsgemäß ausgegeben wird. Sie können auch sehen, dass, obwohl die Funktion nur "* args" als Argument hat, kein Fehler auftritt, selbst wenn drei Argumente angegeben sind.
Führen wir nun die Funktion mit 5 Argumenten aus.
print_args(100, 200, 300, 400, 500)
Ausgabeinhalt des Ergebnisses der Codeausführung:
(100, 200, 300, 400, 500)
Es kann bestätigt werden, dass der Inhalt der angegebenen und 5 Argumente fehlerfrei in der Funktion ausgegeben wird.
Das in der Beschreibung festgelegte Argument "args" wie "* args" kann sich auch wie eine Liste auf den Wert nach Index beziehen. Wenn Sie beispielsweise auf den ersten Wert (Index 0) verweisen möchten, können Sie auf den ersten Wert des Arguments zugreifen, indem Sie "args [0]" schreiben.
Im folgenden Code wird das erste Argument in der Funktion gedruckt, und als Ergebnis werden die ersten 100 angezeigt (print (args [0])).
def print_args(*args):
print(args[0])
print_args(100, 200, 300)
Ausgabeinhalt des Ergebnisses der Codeausführung:
100
Zuvor habe ich eine Funktion erstellt, die eine beliebige Anzahl von Argumenten akzeptiert. Als nächstes werde ich die Funktion erklären, die Schlüsselwortargumente mit beliebigen Argumentnamen akzeptiert.
Wenn Sie wie bei normalen Argumenten ein Argument angeben, das nicht wie bei einem Schlüsselwortargument in der Funktion festgelegt ist, tritt ein Fehler auf, wie im folgenden Code gezeigt (das Schlüsselwortargument x, das im Funktionsargument nicht vorhanden ist, wird angegeben).
def multiply_two():
return x * 2
multiply_two(x=100)
TypeError: multiply_two() got an unexpected keyword argument 'x'
Wenn ich die Fehlermeldung lese, heißt es so etwas wie "Die Funktion multiply_two hat ein unerwartetes Schlüsselwortargument von x erhalten". Diese Fehlermeldung tritt auf, weil das Argument x angegeben wird, obwohl das Argument x nicht definiert ist.
Um die Funktion so einzustellen, dass beliebige Schlüsselwortargumente akzeptiert werden, setzen Sie zwei Einzelbyte-Sternchen in einer Reihe unmittelbar vor dem Argumentnamen im Funktionsargument. Der Argumentname "kwargs" wird häufig für dieses Argument verwendet. Der Argumentname ist eine verkürzte Version des Schlüsselwortarguments Englisch ** k ** ey ** w ** oder ** ar ** guest ** s . Es ist als " kwargs" mit zwei Sternchen geschrieben.
Schreiben Sie den Code und probieren Sie es aus.
def print_kwargs(**kwargs):
print(kwargs)
print_kwargs(x=100, y=200)
Ausgabeinhalt des Ergebnisses der Codeausführung:
{'x': 100, 'y': 200}
Jedes angegebene Schlüsselwortargument wird in kwargs gespeichert. kwargs ist ein Wörterbuch, und Argumentnamen (x und y in diesem Beispiel) werden im Schlüssel festgelegt, und jeder Wert (100 und 200 in diesem Beispiel) wird gespeichert.
[1] Erstellen wir eine Funktion, die ein ganzzahliges Argument verwendet, den Wert dieses Arguments verdoppelt und zurückgibt. Lassen Sie uns auch die Funktion ausführen und den empfangenen Rückgabewert mit print ausgeben. Der Argumentname kann alles sein.
[2] Der folgende Code führte zu einem Fehler. Beheben wir das Problem, damit es keinen Fehler verursacht.
def print_value(value):
print(value)
File "<ipython-input-21-def08fe6f21b>", line 2
print(value)
^
IndentationError: expected an indented block
[1] Um eine Funktion zu erstellen, schreiben Sie def function name ():. Da die Frage "ein ganzzahliges Argument empfangen" lautet, setzt das Antwortbeispiel das Argument x (ein anderer Name ist akzeptabel).
def multiply_two(x):
x *= 2
return x
multiplied_x = multiply_two(100)
print(multiplied_x)
Ausgabeinhalt des Ergebnisses der Codeausführung:
200
Um den Rückgabewert festzulegen, schreiben Sie außerdem "Rückgabewert" in die Funktion. Im obigen Code gilt der Teil "return x".
[2] In der Funktion ist ein Einzug erforderlich. Der Einzug wird mit 4 Feldern halber Breite gesetzt. Selbst wenn die Anzahl der Leerzeichen nicht 4 (2 usw.) ist, tritt kein Fehler auf. Da der Python-Codierungsstandard jedoch 4 Leerzeichen vorschreibt, setzen Sie 4 Leerzeichen, es sei denn, es gibt einen besonderen Grund. Ich werde.
Wenn der Code wie unten gezeigt vor dem Teil "print (value)" eingerückt wird, tritt kein Fehler auf.
def print_value(value):
print(value)
[1] Als ich eine Funktion zur Verarbeitung erstellt und ausgeführt habe, die einer Variablen namens "dog_age" 1 hinzufügt, wie unten gezeigt, ist ein Fehler aufgetreten. Lassen Sie uns den Code so bearbeiten, dass keine Fehler auftreten.
dog_age = 10
def increment_dog_age():
dog_age += 1
increment_dog_age()
UnboundLocalError Traceback (most recent call last)
<ipython-input-23-37cd012f49bf> in <module>
6
7
----> 8 increment_dog_age()
<ipython-input-23-37cd012f49bf> in increment_dog_age()
3
4 def increment_dog_age():
----> 5 dog_age += 1
6
7
UnboundLocalError: local variable 'dog_age' referenced before assignment
[2] Erstellen wir eine Funktion, die drei Argumente x, y und z akzeptiert und die Summe jedes Arguments zurückgibt. Versuchen Sie auch, diese Funktion auszuführen, und drucken Sie das Ergebnis aus.
[1] Die Variable "dog_age" ist eine ganze Zahl. Ganzzahlige globale Variablen können nicht direkt innerhalb einer Funktion referenziert werden. Um auf eine ganzzahlige globale Variable in einer Funktion zu verweisen, müssen Sie "global" und die Variable angeben oder sie mit Argumenten und Rückgabewerten als lokale Variable behandeln.
Wenn Sie in der Funktion "global" angeben, schreiben Sie wie folgt. Sie können sehen, dass es fehlerfrei ausgeführt wird und der resultierende Wert für "dog_age" um 1 bis 11 erhöht wird.
dog_age = 10
def increment_dog_age():
global dog_age
dog_age += 1
increment_dog_age()
print(dog_age)
Ausgabeinhalt des Ergebnisses der Codeausführung:
11
Alternativ können Sie Folgendes mit dem Argument und dem Rückgabewert schreiben. Unabhängig davon, was Sie verwenden, erhalten Sie das gleiche Ergebnis. Es ist jedoch vorzuziehen, die Anzahl der in der Funktion verwendeten globalen Variablen nach Möglichkeit zu reduzieren. Daher wird dies grundsätzlich empfohlen.
dog_age = 10
def increment_dog_age(dog_age):
dog_age += 1
return dog_age
dog_age = increment_dog_age(dog_age)
print(dog_age)
Ausgabeinhalt des Ergebnisses der Codeausführung:
11
[2] Wenn Sie mehrere Argumente festlegen möchten, setzen Sie zwischen jedem Argument ein Komma mit halber Breite. Fügen Sie nach dem Komma ein Feld mit halber Breite ein.
def calculate_total(x, y, z):
return x + y + z
total = calculate_total(100, 200, 300)
print(total)
Ausgabeinhalt des Ergebnisses der Codeausführung:
600
[1] Die Ausführung des folgenden Codes führt zu einem Fehler. Passen wir an, dass kein Fehler auftritt.
def calculate_x_plus_y(x, y):
total = x + y
return total
calculate_x_plus_y(100)
4
5
----> 6 calculate_x_plus_y(100)
TypeError: calculate_x_plus_y() missing 1 required positional argument: 'y'
[2] Erstellen wir eine Funktion mit einem Argument namens x, das weggelassen werden kann und ein Argument hat, das den Wert 100 festlegt, wenn die Spezifikation weggelassen wird. Es spielt keine Rolle, was die Funktion tut.
[3] Führen Sie die Funktion aus, indem Sie in der folgenden Funktion nur das Argument y angeben.
def calculate_total(x=100, y=200, z=300):
total = x + y + z
return total
[1] Während die Funktion zwei Argumente benötigt, x und y, wird nur ein Argument angegeben, in dem die Funktion ausgeführt wird. Wenn Sie am Ausführungsort der Funktion zwei Argumente festlegen, verschwindet der Fehler.
def calculate_x_plus_y(x, y):
total = x + y
return total
total = calculate_x_plus_y(100, 200)
print(total)
Ausgabeinhalt des Ergebnisses der Codeausführung:
300
[2] Um ein optionales Argument anzugeben, legen Sie den Standardwert für das Argument fest. Um den Standardwert festzulegen, setzen Sie ein gleiches Symbol mit halber Breite in Form von "argument = Standardwert". Schreiben Sie ohne Leerzeichen vor und nach dem Gleichen. Schreiben Sie in diesem Problem als "x = 100".
def print_x(x=100):
print(x)
print_x()
Ausgabeinhalt des Ergebnisses der Codeausführung:
100
[3] Wenn Sie nur das mittlere y der drei Argumente angeben möchten, verwenden Sie das Schlüsselwortargument. Um Schlüsselwortargumente zu verwenden, geben Sie diese bei der Ausführung der Funktion in Form von "Argumentname = Wert" an. Geben Sie in diesem Problem das Format "y = 500" an.
total = calculate_total(y=500)
print(total)
Ausgabeinhalt des Ergebnisses der Codeausführung:
900
[1] Versuchen Sie, die Funktion auszuführen, indem Sie die Variablen in der Liste von arg_value_list im folgenden Code als ** list ** im Argument der Funktion berechne_summe angeben.
arg_value_list = [100, 200, 300]
def calculate_total(x, y, z):
total = x + y + z
return total
calculate_total(
arg_value_list[0],
arg_value_list[1],
arg_value_list[2],
)
[2] Versuchen Sie, eine Funktion zu erstellen, die eine beliebige Anzahl von Argumenten akzeptiert (3 oder 5). Der Verarbeitungsinhalt der Funktion spielt keine Rolle.
[1] Um jeden Wert in der Liste einem Argument zuzuweisen, geben Sie unmittelbar vor der Liste ein Sternchen mit halber Breite an. In diesem Problem schreiben wir * arg_value_list.
total = calculate_total(*arg_value_list)
print(total)
Ausgabeinhalt des Ergebnisses der Codeausführung:
600
[2] Um eine Funktion zu erstellen, die eine beliebige Anzahl von Argumenten akzeptiert, setzen Sie im Argumenteinstellungsteil der Funktion ein Sternchen mit halber Breite vor den Argumentnamen, z. B. "* args".
def print_args(*args):
print(args)
print_args(100, 200, 300)
Ausgabeinhalt des Ergebnisses der Codeausführung:
(100, 200, 300)
def, um eine Funktion zu erstellen.function () (zB berechne_summe ()).Außerdem schreibe ich verschiedene Artikel hauptsächlich über Python. Bitte mach das auch! Bisher veröffentlichte Hauptartikel
Recommended Posts