Kaedah lulus parameter fungsi dalam Python *args, **kwargs, dan lain-lain

Artikel ini akan membincangkan parameter fungsi Python. Kami akan memahami apa itu args dan **kwargs, / dan Walaupun soalan ini adalah soalan ular sawa asas, ia akan sering ditemui apabila kita menulis kod ini cara lulus parameter.

Mentakrifkan dan menghantar parameter

Apakah perbezaan antara parameter dan argumen

Ramai orang menggunakan istilah ini secara bergantian, tetapi mereka Ada? ialah perbezaan:

• Parameter ialah nama yang ditakrifkan dalam definisi fungsi
• Argumen ialah nilai yang dihantar kepada fungsi

Yang merah ialah parameter dan yang hijau ialah hujah.

Dua cara untuk lulus parameter

Kami boleh lulus parameter mengikut kedudukan dan kata kunci. Dalam contoh berikut, kami menghantar nilai hello sebagai parameter kedudukan. Dunia nilai diluluskan menggunakan kata kunci.

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

Perbezaan antara parameter kedudukan dan kwarg (argumen kata kunci) ialah susunan parameter kedudukan diluluskan adalah penting. Jika anda memanggil the_func('world', 'hello') ia akan mencetak world hello. Urutan di mana kwarg diluluskan tidak penting:

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'

Anda boleh mencampur dan memadankan hujah kedudukan dan kata kunci selagi kwarg datang selepas hujah kedudukan, itulah yang kami sering lakukan dalam tutorial python Selepas melihat kandungan, mari teruskan.

Parameter fungsi

Kami akan menunjukkan 6 kaedah menghantar parameter fungsi, yang boleh merangkumi semua masalah.

1. Cara mendapatkan semua parameter kedudukan yang tidak ditangkap

Gunakan *args untuk membiarkannya menerima bilangan parameter formal yang tidak ditentukan.

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

Dalam fungsi ini, kita biasanya mentakrifkan dua parameter pertama (a dan b). Kemudian gunakan args untuk mengemas semua argumen yang tinggal ke dalam tuple. Anda boleh menganggap * sebagai mendapatkan parameter lain yang tidak diproses dan mengumpulnya ke dalam pembolehubah tuple bernama "args":

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

Panggilan terakhir akan Nilai 1 diberikan kepada parameter a, 2 diberikan kepada parameter b, dan pembolehubah arg diisi dengan (3,4). Memandangkan ini adalah tuple, kita boleh menggelungkannya dalam fungsi dan mendarab menggunakan nilai

2. Bagaimana untuk mendapatkan semua hujah kata kunci yang tidak ditangkap

Serupa dengan *args, ini diikuti dengan dua asterisk **kwargs

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

**kata kunci kwargs akan menyimpan semua hujah kata kunci yang tidak dapat dipadankan dalam kamus yang dipanggil kwargs. Kamus ini kemudiannya boleh diakses seperti fungsi di atas.

 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. Jika anda mahu menerima parameter kata kunci sahaja, cara mereka bentuk

untuk memaksa fungsi hanya menerima parameter kata kunci.

 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)

Dalam fungsi di atas, asterisk * mendapat semua parameter kedudukan yang tidak sepadan, tetapi tiada pembolehubah untuk menerimanya, iaitu, ia diabaikan.

4. Cara mereka bentuk fungsi yang hanya menerima parameter kedudukan

Berikut ialah contoh fungsi yang hanya membenarkan parameter kedudukan:

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

The / in definisi fungsi dipaksa sebelum itu Semua parameter adalah parameter kedudukan. Ini tidak bermakna bahawa semua hujah yang mengikuti / mestilah kwarg sahaja; ini boleh menjadi kedudukan dan kata kunci.

Apabila anda melihat ini, anda pasti akan berfikir, mengapa anda mahu ini tidak akan mengurangkan kebolehbacaan kod?, Saya juga fikir anda sangat betul, apabila mentakrifkan fungsi yang sangat jelas, tidak? Argumen kata kunci diperlukan untuk menentukan fungsinya. Contohnya:

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

Dalam contoh ini, ia sedang menyemak sama ada saiz memori 'a' melebihi 100 bait. Kerana nama x ini tidak penting kepada kami, tidak perlu untuk menyatakan x='a' apabila memanggil fungsi tersebut. Sebagai contoh, len kami yang paling biasa digunakan, jika anda memanggil len(__obj=[]), adakah ia kelihatan agak bodoh, kerana len ditakrifkan seperti ini def len(__obj: Saiz) -> int:

5. Mixing and matching

Sebagai contoh, kita akan lihat pada fungsi len yang dibincangkan tadi. Fungsi ini hanya membenarkan hujah kedudukan. Kami akan melanjutkan fungsi ini dengan membenarkan pembangun memilih sama ada untuk mengira pendua, seperti menghantar kata kunci ini dengan kwargs:

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

Ingin mengira len parameter pembolehubah kerana ia mempunyai / dalam hadapannya. Argumen no_duplicate mesti dihantar dengan kata kunci kerana ia mengikuti . Mari lihat bagaimana fungsi ini boleh dipanggil:

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. Akhir sekali letakkan mereka bersama

Fungsi berikut adalah contoh yang sangat melampau tentang cara menggabungkan semua teknik yang dibincangkan sebelum ini: ia memaksa dua hujah pertama diluluskan mengikut kedudukan, dua hujah seterusnya boleh diluluskan mengikut kedudukan, dan dengan kata kunci, dan kemudian dua hujah kata kunci sahaja, yang kemudiannya kami tangkap dengan **kwargs Parameter yang tidak ditangkap yang selebihnya.

 def the_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=}")

Kaedah panggilan adalah seperti berikut:

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

Ringkasan

Nampak kemas, betul? Kerana Python adalah bahasa yang sangat longgar apabila ia direka, tidak begitu banyak spesifikasi Semakin ramai orang menggunakannya, semakin banyak kaedah yang digunakan, dan ia menjadi seperti ini.

Jadi kembali kepada gambar pertama:

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

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

Atas ialah kandungan terperinci Kaedah lulus parameter fungsi dalam Python *args, **kwargs, dan lain-lain. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!