Einführung

Dieser Artikel wurde zur Hälfte für meine eigenen Notizen erstellt. Um jedoch ein Memo zu erstellen, das im Rückblick leicht zu verstehen ist Ich habe versucht, den Artikel für jedermann sichtbar zu machen. (Es scheint, dass er darauf hingewiesen wird, wenn er einen Fehler macht ... (echte Absicht))

SCHRITT 1: Über tatsächliche und formale Argumente

Argumente werden grob in zwei Typen eingeteilt: formale Argumente und tatsächliche Argumente. Formales Argument: Wird in der Funktion ** Definition ** verwendet. Ein formales Argument, weil es dem tatsächlichen Objekt einen formalen Namen gibt. (Streit) Tatsächliches Argument: Wird in Funktion ** Aufruf ** verwendet. Da es sich um ein tatsächliches Objekt handelt, handelt es sich um ein tatsächliches Argument. (Parameter)


def foo(a):  #Formelles Argument
  a+=1
  return a

print(foo(1)) #Tatsächliches Argument
 >>>2

SCHRITT 2: Eigenschaften formaler Argumente

Eine wichtige Eigenschaft formaler Argumente ist, dass sie für jeden Funktionsaufruf festgelegt werden. Schauen wir uns ein konkretes Beispiel an.


def remove_first(lst):
    lst = lst[1:]
    print(lst)


lst = [1, 2, 3, 4]
print(lst)
remove_first(lst)
 >>> [2, 3, 4]
remove_first(lst)
 >>> [2, 3, 4]

Was ich hier sagen möchte ist, dass die Ergebnisse des ersten und zweiten remove_first (lst) gleich sind. Mit anderen Worten, "das formale Argument beim ersten Aufruf" und "das formale Argument beim zweiten Aufruf" sind Dies bedeutet, dass sogar dieselbe Variable als unterschiedliche Variable behandelt wird.

SCHRITT 3: Art des formalen Arguments

Es gibt fünf Muster für die oben genannten formalen Argumente.

--Position oder Schlüsselwort: sogenannte gewöhnliche Funktionsdefinition

Nur Position: Siehe unten
Nur Schlüsselwörter: Siehe unten --Variable Längenposition: später beschrieben --Variables Längenschlüsselwort: wird später beschrieben

Hier sind vorerst die üblichen Positionen oder Stichwörter.


def foo2(a, b=3):  #a ist ein Positionsargument und b ist ein Schlüsselwortargument
  return a + b
def foo3(a=1, b):  #Fehler (Schlüsselwortargument kann nicht vor Positionsargument gesetzt werden)
  return a + b

print(foo2(1)) #Positionsargument (der Wert von b ist der Standardwert, wenn die Funktion definiert ist)
 >>>4
print(foo2(1,5)) #Positionsargument (a=1,b=5）
 >>>6
print(foo2(1,b=5)) #Positions- und Schlüsselwortargumente
 >>>6
print(foo2(a=1,b=5)) #Schlüsselwortargument
 >>>6
print(foo2(b=2)) #Error
 >>>TypeError
print(foo2(b=3,a=1)) #Ändern Sie die Reihenfolge der Schlüsselwortargumente

Als wichtige Eigenschaft, die von oben gesehen werden kann

Für formale Argumente können Schlüsselwortargumente nicht vor Positionsargumenten gesetzt werden.
Wenn das Schlüsselwortargument nicht als tatsächliches Argument festgelegt ist, wird der Standardwert des formalen Arguments angewendet.
Im eigentlichen Argument kann das Schlüsselwortargument durch Ändern der Reihenfolge festgelegt werden.
** Kann als Positionsargument oder als Schlüsselwortargument mit einem tatsächlichen Argument aufgerufen werden **

SCHRITT 4: Nur Position, nur Schlüsselwort

Als nächstes werde ich nur die oben genannten Schlüsselwörter vorstellen. Erstens nur die Position, ** Beim Definieren einer Funktion kann das Argument vor / nur als Positionsargument aufgerufen werden ** Auf der anderen Seite nur Schlüsselwörter ** Beim Definieren einer Funktion können die Argumente nach * nur mit Schlüsselwortargumenten aufgerufen werden **


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

def func2(a, /):
    return a 

print(func(1,b=2,c=3)) #b führt zu einem Fehler, wenn es nicht mit einem Schlüsselwortargument aufgerufen wird
print(func2(1)) #a führt zu einem Fehler, wenn es nicht mit einem Positionsargument aufgerufen wird

SCHRITT 5: Position mit variabler Länge, Schlüsselwort mit variabler Länge

Erstens ist die Position mit variabler Länge ** ein Argument, das eine beliebige Anzahl von Positionsargumenten empfangen kann **. ** Wenn Sie eine Funktion definieren, fügen Sie * vor dem Argument hinzu, um daraus ein Positionsargument zu machen (bis zu einmal pro Funktion) ** Schlüsselwörter mit variabler Länge sind ** Argumente, die eine beliebige Anzahl von Schlüsselwortargumenten akzeptieren können **. ** Wenn Sie eine Funktion definieren, fügen Sie vor dem Argument \ ** hinzu, um daraus ein Positionsargument zu machen (bis zu einmal pro Funktion) **


def func(*a, **b):
    print(a)
    print(b)

func(1,2,3,b=4,c=5)
 >>> (1, 2, 3)
     {'b': 4, 'c': 5}