关于机器学习:Python中函数参数传递方法args-kwargs还有其他

本文将探讨 Python 的函数参数。咱们将理解 args 和kwargs，/ 和 的都是什么，尽管这个问题是一个根本的 python 问题，然而在咱们写代码时会常常遇到，比方 timm 中就大量应用了这样的参数传递形式。

parameters 和 arguments 之间的区别是什么?

许多人交替应用这些术语，但它们是有区别的：

Parameters 是函数定义中定义的名称
Arguments 是传递给函数的值

红色的是 parameters , 绿色的是 arguments

传递参数的两种形式

咱们能够按地位和关键字传递参数。在上面的例子中，咱们将值 hello 作为地位参数传递。值 world 用关键字传递的

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

地位参数和 kwargs(关键字参数)之间的区别在于传递地位参数的程序很重要。如果调用 the_func(‘world’，‘hello’)它会打印 world hello。传递 kwargs 的程序并不重要:

 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'

只有 kwarg 在地位参数之后，就能够混合和匹配地位参数和关键字参数，以上就是咱们在 python 教程中常常看到的内容，上面咱们持续

咱们将演示 6 个函数参数传递的办法，这些办法可能笼罩到所有的问题。

1、如何取得所有未捕捉的地位参数

应用 *args，让它接管一个不指定数量的形参。

 defmultiply(a, b, *args):
   result=a*b
   forarginargs:
     result=result*arg
   returnresult

在这个函数中，咱们通常定义前两个参数 (a 和 b)。而后应用args 将所有残余参数打包到一个元组中。能够把 看作是获取到了其余没有解决的参数，并将它们收集到一个名为“args”的元组变量中:

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

最初一次调用将值 1 赋给参数 a，将 2 赋给参数 b，并将 arg 变量填充为(3,4)。因为这是一个元组，咱们能够在函数中循环它并应用这些值进行乘法!

2、如何取得所有未捕捉的关键字参数

与args 相似，这次是两个星号*kwargs

 defintroduce(firstname, lastname, **kwargs):
   introduction=f"I am {firstname}{lastname}"
   forkey, valueinkwargs.items():
     introduction+=f"my {key} is {value}"
   returnintroduction

**kwargs 关键字会将所有不匹配的关键字参数存储在一个名为 kwargs 的字典中。而后能够像下面的函数一样拜访这个字典。

 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

3、如果想只承受关键字参数，那怎么设计

能够强制函数只承受关键字参数。

 deftransfer_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)

在下面的函数中，* 星号取得了了所有不匹配的地位参数，然而并没有一个变量来承受它，也就是被忽略了。

4、如何设计函数只承受地位参数

上面是一个只容许地位参数的函数示例:

 defthe_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')

函数定义中的 / 强制在它之前的所有参数都是地位参数。这并不意味着 / 前面的所有参数都必须是 kwarg-only; 这些能够是地位和关键字。

看到这个你必定会想，为什么想要这个? 这不会升高代码的可读性吗?，我也感觉你说的十分正确，当定义一个十分明确的函数时，不须要关键字参数来指定它的性能。例如:

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

在这个例子中，正在查看 ’a’ 的内存大小是否超过 100 字节。因为这个 x 对于咱们来说他的名字不重要，在调用函数的时候不须要指定 x = ‘ a ‘。比如说咱们最罕用的 len，如果你调用 len(__obj=[]) 这样看起来是不是有点呆萌，因为 len 是这么定义的

def len(__obj: Sized) -> int:

5、混合和匹配

作为一个例子，咱们将看看后面探讨过的 len 函数。这个函数只容许地位参数。咱们将通过容许开发人员抉择是否计算反复项来扩大此函数，比方用 kwargs 传递这个关键字:

 deflen_new(x, /, *, no_duplicates=False):
   if (no_duplicates):
     returnlen(list(set([aforainx])))
   returnlen(x)

想计算变量 x 的 len，只能按地位传递 x 形参的参数，因为它后面有一个 /。no_duplicate 参数必须与关键字一起传递，因为它跟在 * 前面。让咱们看看这个函数都能够怎么调用:

 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))

6、最初把它们合在一起

上面的函数是一个十分极其的例子，阐明了如何组合后面探讨的所有技术：它强制前两个参数以地位形式传递，接下来的两个参数能够以地位形式传递，并且带有关键字，而后是两个只有关键字的参数，而后咱们用 **kwargs 捕捉剩下的未捕捉的参数。

 defthe_func(pos_only1, pos_only2, /, pos_or_kw1, pos_or_kw2, *, kw1, kw2, **extra_kw):
   # cannot be passed kwarg   <--   | --> can be passed 2 ways | --> can only be passed by kwarg
   print(f"{pos_only1=}, {pos_only2=}, {pos_or_kw1=}, {pos_or_kw2=}, {kw1=}, {kw2=}, {extra_kw=}")

调用形式如下：

 # works (pos_or_kw1 & pow_or_k2 can be passed positionally and by kwarg)
 pos_only1='pos1', pos_only2='pos2', pos_or_kw1='pk1', pos_or_kw2='pk2', kw1='kw1', kw2='kw2', extra_kw={}
 pos_only1='pos1', pos_only2='pos2', pos_or_kw1='pk1', pos_or_kw2='pk2', kw1='kw1', kw2='kw2', extra_kw={}
 pos_only1='pos1', pos_only2='pos2', pos_or_kw1='pk1', pos_or_kw2='pk2', kw1='kw1', kw2='kw2', extra_kw={'kw_extra1': 'extra_kw1'}
 
 # doesnt work, (pos1 and pos2 cannot be passed with kwarg)
 # the_func(pos_only1='pos1', pos_only2='pos2', pos_or_kw1='pk1', pos_or_kw2='pk2', kw1='kw1', kw2='kw2')
 
 # doesnt work, (kw1 and kw2 cannot be passed positionally)
 # the_func('pos1', 'pos2', 'pk1', 'pk2', 'kw1', 'kw2')

看着很乱是吧，这就对了。因为 python 在设计时是一个很宽松的语言，并没有那么多的标准，用的人越多应用办法就越多，就变成了这样。

那么回到第一张图：

 deffunc(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 这种状况（这里能够举两个例子），还没有看到有人写这么乱的代码，我想要是写这样的代码预计开源的人也会被人吐糟（这里本人能够自行延长），所以这些参数传递的规定我在学习的时候看到过，然而理论中没见过真正应用，就不太记住了。

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

https://avoid.overfit.cn/post/c2555b2ad4da4255814c94cfc3809efd

作者：Mike Huls

关于机器学习:Python中函数参数传递方法args-kwargs还有其他

定义和传递参数

函数参数

总结

Just My Socks（注册教程内含优惠码）

关于机器学习:Python中函数参数传递方法args-kwargs还有其他

定义和传递参数

函数参数

总结

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）