Positionsargument gegen Schlüsselwortargument

Basierend darauf

Ein Positionsargument ist ein Name, auf den kein Gleichheitszeichen (=) und kein Standardwert folgen.

Auf ein Schlüsselwortargument folgen ein Gleichheitszeichen und ein Ausdruck, der den Standardwert angibt.

def rectangleArea(width, height):
    return width * height

print rectangleArea(width=1, height=2)

Frage > Ich gehe davon aus, dass beide widthund heightPositionsargumente sind. Warum können wir es dann auch mit der Syntax des Schlüsselwortarguments aufrufen?

Der von Ihnen zitierte Text dient der Definition der Funktion und hat nichts mit Aufrufen der Funktion zu tun. Beim Aufruf dieser Funktion verwenden Sie die Funktion "benanntes Argument". Dieser Link, den Sie bereitstellen, ist nicht von sehr guter Qualität. Die Autoren scheinen zwischen zwei verschiedenen Dingen verwechselt zu sein.

Die Python-Referenz bezieht sich nur auf Positions- und Schlüsselwortargumente in Bezug auf einen Aufruf einer Funktion (siehe Abschnitt5.3.4 Calls ).

Wenn sie über die Definition einer Funktion im Abschnitt7.6 Function definitions sprechen , ist dies ein völlig anderer Begriff "Standardparameterwerte".

Ich vermute, die Leute, die diese Kursware zusammengestellt haben, waren mit Python nicht ganz vertraut :-)

Beziehen Sie sich beispielsweise auf die folgende Definition und Aufrufe:

def fn (a, b, c = 1):          # a/b required, c optional.
    return a * b + c

print fn (1, 2)                # returns 3, positional and default.
print fn (1, 2, 3)             # returns 5, positional.
print fn (c = 5, b = 2, a = 2) # returns 9, named.
print fn (b = 2, a = 2)        # returns 5, named and default.
print fn (5, c = 2, b = 1)     # returns 7, positional and named.
print fn (8, b = 0)            # returns 1, positional, named and default.

Die Bedeutung der =Änderungen hängt davon ab, ob sie in der Definition oder im Aufruf enthalten sind.

In der Definition wird das Argument optional markiert und ein Standardwert festgelegt.

Im Aufruf können Sie einfach angeben, welche Argumente welche Werte sein sollen, in welcher Reihenfolge Sie möchten.

Da in Python 3.8 nur Positionsargumente eingeführt wurden, muss dieser Beitrag aktualisiert werden.

Positionsargumente, Schlüsselwortargumente, erforderliche Argumente und optionale Argumente werden häufig verwechselt. Positionsargumente sind nicht die gleichen wie die erforderlichen Argumente. und Schlüsselwörter Argumente sind nicht die gleichen wie optionale Argumente.

Positionsargumente sind Argumente, die über ihre Position in der Funktionsdefinition aufgerufen werden können.

Schlüsselwortargumente sind Argumente, die mit ihrem Namen aufgerufen werden können.

Erforderliche Argumente sind Argumente, die an die Funktion übergeben werden müssen.

Optionale Argumente sind Argumente, die nicht an die Funktion übergeben werden können. In Python sind optionale Argumente Argumente mit einem Standardwert .

Positionsargument, das optional ist (Python 3.8)

def f(a=2, /):
    pass


f()  # Allowed, argument is optional
f(1)  # Allowed, it's a positional argument
f(a=1)  # Error, positional only argument

Erforderliches Positionsargument (Python 3.8)

def f(a, /):
    pass


f()  # Error, argument required
f(1)  # Allowed, it's a positional argument
f(a=1)  # Error, positional only argument

Schlüsselwortargument, das optional ist

def f(*, a=1):
    pass


f()  # Allowed
f(1)  # Error, keyword only arguments
f(a=1)  # Allowed, it's a keyword argument

Schlüsselwortargument, das erforderlich ist

def f(*, a)
    pass


f()  # Error, argument required
f(1)  # Error, keyword only arguments
f(a=1)  # Allowed, it's a keyword argument

Positions- und Schlüsselwortargument, das optional ist

def f(a=1)
    pass


f()  # Allowed, argument is optional
f(1)  # Allowed, it's a positional argument
f(a=1)  # Allowed, it's a keyword argument

# In fact this function is the same as
def f(*, a=1, /):
    pass

Erforderliches Positions- und Schlüsselwortargument

def f(a):
    pass


f()  # Error, argument required
f(1)  # Allowed, it's a positional argument
f(a=1)  # Allowed, it's a keyword argument

# In fact this function is the same as
def f(*, a, /):
    pass

Schlussfolgerung: Ein Argument kann optional sein oder nicht beide gleichzeitig erfordern . Es kann auch Position, Schlüsselwort oder beides gleichzeitig sein .

In Python 3.8 wurden nur Positionsparameter eingeführt .

def f(positional_argument, /, positional_or_keyword_argument, *, keyword_argument):
    pass

Ein Schlüsselwortargument ist nur ein Positionsargument mit einem Standardwert. Sie müssen alle Argumente angeben, die keinen Standardwert haben. Mit anderen Worten, Schlüsselwortargumente sind nur "optional", da sie auf ihren Standardwert gesetzt werden, wenn sie nicht speziell angegeben werden.

Positionsargumente können entweder mithilfe von Werten in der angegebenen Reihenfolge oder durch Benennung aufgerufen werden. Zum Beispiel würden alle drei der folgenden Methoden auf die gleiche Weise funktionieren:

def rectangleArea(width, height):
    return width * height

print(rectangleArea(1, 2))
print(rectangleArea(width=1, height=2))
print(rectangleArea(height=2, width=1))

Positionsargumente: Argumente, die in der richtigen Positionsreihenfolge an eine Funktion übergeben werden. Das folgende Programm versteht die Positionsargumente einer Funktion

#positional arguments example
def combine(str1, str2):
#To join str1 and str2 with str3
    str3 = str1 + str2
    print(str3)

#call combine() and pass 2 strings
combine("Well", "come")   #positional arguments 

Nehmen wir an, wir haben zuerst "kommen", dann "gut" bestanden, dann ist das Ergebnis gut. Rufen Sie auch die Funktion 3 Zeichenfolgen werden Fehler.

Verstehen Sie die Schlüsselwortargumente einer Funktion.

Schlüsselwortargumente sind Argumente, die die Parameter anhand ihrer Namen identifizieren.

#keyword arguments example: 
def employee(name, Id):
    print("Employee Name: ", name)
    print("Employee Id  : ", Id)
#call employee() and pass 2 arguments
employee(name = "inban", Id = "pay001")
employee(Id = "pay002", name = "karthik") #we can change the order args.

Das Definieren von Parametern und Argumenten hier könnte helfen.

1. Parameter: Eine benannte Entität in der Funktions- / Methodendefinition, die ein Argument angibt.
2. Argument: Ein Wert, der an eine Funktion übergeben wird.

Zum Beispiel,

def my_function(parameter_1, parameter_2):
    pass

my_function(argument_1, argument_2)

Wenn Sie nun Positionsargumente sagen, sprechen Sie von Argumenten , haben also nichts mit der Funktionsdefinition zu tun. widthund heightin Ihrem Beispiel sind Positionsparameter oder Schlüsselwortparameter (sogenannte Positions- oder Schlüsselwortparameter).

Wie Sie anrufen / auf die Funktion den Wert vorbei bestimmt , ob sie Positions sind Argumente oder Keyword - Argumente .

rectangleArea(1, 2) # positional arguments
rectangleArea(width=1, height=2) # keyword arguments

Nicht viele Leute wissen, dass Sie einen Nur-Positions-Parameter mithilfe /des Parameters in der Parameterliste angeben können (Beispiel von hier ).

def func(positional_only1, positional_only2, /, positional_or_keyword): ...

In ähnlicher Weise können Sie mithilfe des *Zeichens auch nur Schlüsselwortparameter verwenden .

def func(positional_or_keyword, *, keyword_only1, keyword_only2): ...

Schließlich haben wir auch var-positional und var-keyword (auch bekannt als * args bzw. ** kwargs). Das heißt, Sie können eine beliebige Folge von Positionsargumenten oder Schlüsselwortargumenten an die Funktion übergeben lassen.