Methoden zur Übergabe von Funktionsparametern in Python *args, **kwargs und anderen

In diesem Artikel werden die Funktionsparameter von Python erläutert. Wir werden verstehen, was args und **kwargs, / und sind. Obwohl es sich bei diesem Problem um ein grundlegendes Python-Problem handelt, werden wir häufig darauf stoßen, wenn wir Code schreiben in timm Diese Parameterübergabemethode wird verwendet.

Parameter definieren und übergeben

Was ist der Unterschied zwischen Parametern und Argumenten?

Viele Menschen verwenden diese Begriffe austauschbar, aber es gibt einen Unterschied:

• Parameter sind die in der Funktionsdefinition definierten Namen.
• Argumente sind die an die übergebenen Werte function# 🎜🎜#

Die roten sind Parameter und die grünen sind Argumente.

Zwei Möglichkeiten, Parameter zu übergeben

Wir können Parameter nach Position und Schlüsselwort übergeben. Im folgenden Beispiel übergeben wir den Wert hello als Positionsparameter. Der Wert world wird mit dem Schlüsselwort übergeben.

 def the_func(greeting, thing):
 print(greeting + ' ' + thing)
 
 the_func('hello', thing='world')

Der Unterschied zwischen Positionsparametern und Kwargs (Schlüsselwortparametern) besteht darin, dass die Reihenfolge, in der Positionsparameter übergeben werden, von Bedeutung ist. Wenn Sie the_func('world', 'hello') aufrufen, wird world hello ausgegeben. Die Reihenfolge, in der Kwargs übergeben werden, spielt keine Rolle:

the_func('hello', 'world')# -> 'hello world'
the_func('world', 'hello')# -> 'world hello'
the_func(greeting='hello', thing='world') # -> 'hello world'
the_func(thing='world', greeting='hello') # -> 'hello world'
the_func('hello', thing='world')# -> 'hello world'

Solange der Kwarg nach dem Positionsargument steht, können Sie Positions- und Schlüsselwortargumente kombinieren und anpassen Das haben wir im Python-Tutorial gemacht. Inhalte, die oft in zu sehen sind, fahren wir weiter unten fort.

Funktionsparameter

Wir zeigen 6 Methoden zur Übergabe von Funktionsparametern, die alle Probleme abdecken können.

1. So erhalten Sie alle nicht erfassten Positionsparameter

Verwenden Sie *args, um eine unbestimmte Anzahl formaler Parameter zu erhalten.

def multiply(a, b, args):
result = a * b
for arg in args:
result = result * arg
return result

In dieser Funktion definieren wir normalerweise die ersten beiden Parameter (a und b). Verwenden Sie dann args, um alle verbleibenden Argumente in ein Tupel zu packen. Sie können sich * so vorstellen, dass andere unverarbeitete Parameter abgerufen und in einer Tupelvariablen namens „args“ gesammelt werden:

multiply(1, 2)# returns 2
multiply(1, 2, 3, 4)# returns 24

Letztes Mal Der Aufruf weist dem Parameter a den Wert 1 zu , 2 zum Parameter b und füllt die arg-Variable mit (3,4). Da es sich um ein Tupel handelt, können wir es in der Funktion durchlaufen und die Werte für die Multiplikation verwenden! 🎜#** Das Schlüsselwort kwargs speichert alle nicht übereinstimmenden Schlüsselwortargumente in einer Datei namens kwargs im Wörterbuch. Auf dieses Wörterbuch kann dann wie oben beschrieben zugegriffen werden.

def introduce(firstname, lastname, **kwargs):
introduction = f"I am {firstname} {lastname}"
for key, value in kwargs.items():
introduction += f" my {key} is {value} "
return introduction

3. Wenn Sie nur Schlüsselwortparameter akzeptieren möchten, wie Sie

entwerfen, um zu erzwingen, dass die Funktion nur Schlüsselwortparameter akzeptiert.

 print(introduce(firstname='mike', lastname='huls'))
 # returns "I am mike huls"
 
 print(introduce(firstname='mike', lastname='huls', age=33, website='mikehuls.com'))
 # I am mike huls my age is 33 my website is overfit.cn

In der obigen Funktion ruft das Sternchen * alle nicht übereinstimmenden Positionsparameter ab, es gibt jedoch keine Variable, die es akzeptiert, das heißt, es wird ignoriert.

4. So entwerfen Sie eine Funktion, die nur Positionsparameter akzeptiert

Das Folgende ist ein Beispiel für eine Funktion, die nur Positionsparameter zulässt:

 def transfer_money(*, from_account:str, to_account:str, amount:int):
 print(f'Transfering ${amount} FORM {from_account} to {to_account}')
 
 transfer_money(from_account='1234', to_account='6578', amount=9999)
 # won't work: TypeError: transfer_money() takes 0 positional arguments but 1 positional argument (and 2 keyword-only arguments) were given
 transfer_money('1234', to_account='6578', amount=9999)
 # won't work: TypeError: transfer_money() takes 0 positional arguments but 3 were given
 transfer_money('1234', '6578', 9999)

#🎜🎜 #/ in der Funktionsdefinition Erzwingt, dass alle Argumente davor Positionsargumente sind. Dies bedeutet nicht, dass alle Argumente, die auf / folgen, nur Kwarg-Argumente sein dürfen. Dies können Positions- und Schlüsselwortargumente sein.

Wenn Sie das sehen, werden Sie sich auf jeden Fall fragen, warum das nicht die Lesbarkeit des Codes beeinträchtigt? klare Funktion, es sind keine Schlüsselwortargumente erforderlich, um ihre Funktionalität anzugeben. Zum Beispiel:

 def the_func(arg1:str, arg2:str, /):
 print(f'provided {arg1=}, {arg2=}')
 
 # These work:
 the_func('num1', 'num2')
 the_func('num2', 'num1')
 
 # won't work: TypeError: the_func() got some positional-only arguments passed as keyword arguments: 'arg1, arg2'
 the_func(arg1='num1', arg2='num2')
 # won't work: TypeError: the_func() got some positional-only arguments passed as keyword arguments: 'arg2'
 the_func('num1', arg2='num2')

In diesem Beispiel wird geprüft, ob die Speichergröße von „a“ 100 Bytes überschreitet. Da der Name dieses x für uns nicht wichtig ist, ist es nicht erforderlich, beim Aufruf der Funktion x='a' anzugeben. Wenn Sie beispielsweise len(__obj=[]) aufrufen, sieht das bei unserem am häufigsten verwendeten len etwas albern aus, da len wie folgt definiert ist: def len(__obj: Sized) -> int:

#🎜 🎜#5, Mischen und Anpassen

Als Beispiel betrachten wir die zuvor besprochene Len-Funktion. Diese Funktion erlaubt nur Positionsargumente. Wir werden diese Funktion erweitern, indem wir Entwicklern die Möglichkeit geben, zu wählen, ob Duplikate gezählt werden sollen, indem wir beispielsweise dieses Schlüsselwort mit kwargs übergeben: Der Parameter des formalen Parameters, da ein / davor steht. Der Parameter no_duplicate muss mit dem Schlüsselwort übergeben werden, das auf

folgt. Sehen wir uns an, wie diese Funktion aufgerufen werden kann:

def exceeds_100_bytes(x, /) -> bool:
 return x.__sizeof__() > 100
 
 exceeds_100_bytes('a')
 exceeds_100_bytes({'a'})

6 Zum Schluss fügen Sie sie zusammen

Die folgende Funktion ist ein sehr extremes Beispiel dafür, wie alle zuvor besprochenen Techniken kombiniert werden können : Es erzwingt, dass die ersten beiden Parameter positionell übergeben werden, die nächsten beiden Parameter können positionell übergeben werden, und mit Schlüsselwörtern, dann die beiden Nur-Schlüsselwort-Parameter, und dann verwenden wir ** kwargs, um die verbleibenden nicht erfassten Argumente zu erfassen.

 def len_new(x, /, *, no_duplicates=False):
 if (no_duplicates):
 return len(list(set([a for a in x])))
 return len(x)

Die Aufrufmethode ist wie folgt:

print(len_new('aabbcc'))# returns 6
 print(len_new('aabbcc', no_duplicates=True))# returns 3
 print(len_new([1, 1, 2, 2, 3, 3], no_duplicates=False)) # returns 6
 print(len_new([1, 1, 2, 2, 3, 3], no_duplicates=True))# returns 3
 
 # Won't work: TypeError: len_() got some positional-only arguments passed as keyword arguments: 'x'
 print(len_new(x=[1, 1, 2, 2, 3, 3]))
 # Won't work: TypeError: len_new() takes 1 positional argument but 2 were given
 print(len_new([1, 1, 2, 2, 3, 3], True))

Zusammenfassung

Es sieht chaotisch aus, oder? Das stimmt. Da Python beim Entwerfen eine sehr lockere Sprache ist, gibt es nicht so viele Spezifikationen. Je mehr Leute es verwenden, desto mehr Methoden werden verwendet, und es wird so.

Also zurück zum ersten Bild:

def func(x,/,y,,z,**k):

(x,/,y,,z,**k):是函数的参数。总共有四个参数:

• x: 是一个常规参数，这意味着它可以按位置传递，也可以按关键字传递。
• /,: 是一个参数分隔符，将仅限位置的参数与其他参数分开。与前面的x结合，意味着x只能按位置传递。
• y: 时另一个常规参数。
• *: 是一个参数分隔符，用于分隔仅限位置参数和仅限关键字参数。它意味着后面的z只能通过关键字传递。
• z: 是一个仅限关键字的参数。
• **k: 这是一个参数，将所有剩余的关键字参数收集到一个名为' k '的字典中。

这样解释是不是就很明白了。

我们今天介绍的这个例子虽然在看源代码时没有遇到这么复杂的情况，但是在 面试 的时候还真有人问（虽然我觉得没啥用），所以最好还是知道一些，以免尴尬。

如果你忘记了，这里可以教你一个变通的办法，可以使用类似的回答：

上面的参数传递在开发时并不常用，因为对于开发规范来说，应该保证代码的可读性，我们这边遵循的开发规范是：

1、尽量不要在函数定义中将可变位置参数 *args 和可变关键字参数 **kwargs 放在一起，因为这样会让函数的调用方式变得不太直观。

2、在使用可变参数时，要保证函数的行为是可预测的。上面函数中的进行了太多的python语法糖，对于理解该函数的参数会造成很大的困惑，也就是可读性太差，我们在进行codereview（如果你了解什么是codereview就说，不了解就说组长检查）/组长merge代码 时会直接要求返工，所以我们在实际开发时是不会用这个的。

对于我阅读的开源代码，也都基本上使用的是 **kwargs这种情况（这里可以举两个例子），还没有看到有人写这么乱的代码，我想要是写这样的代码估计开源的人也会被人吐糟（这里自己可以自行延伸），所以这些参数传递的规则我在学习的时候看到过，但是实际中没见过真正使用，就不太记住了。

回到本文，我们介绍了设计函数参数的所有方法，并了解了如何混合和匹配它们，虽然后面几个内容可能你一辈子也不会用到，但是了解一下也是好的，因为万一呢。

Das obige ist der detaillierte Inhalt vonMethoden zur Übergabe von Funktionsparametern in Python *args, **kwargs und anderen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!