Méthodes de transmission des paramètres de fonction en Python *args, **kwargs et autres

Cet article discutera des paramètres de fonction de Python. Nous découvrirons args et **kwargs, ce que sont / et Bien que ce problème soit un problème de base de Python, nous le rencontrons souvent lorsque nous écrivons du code. Par exemple, timm utilise un grand nombre de tels transferts de paramètres.

Définir et transmettre des paramètres

Quelle est la différence entre les paramètres et les arguments ?

Beaucoup de personnes utilisent ces termes de manière interchangeable, mais il y a une différence :

• Les paramètres sont les noms définis dans la définition de la fonction
• Arguments sont les valeurs transmises à la fonction

Les rouges sont des paramètres et les verts sont des arguments.

Deux façons de transmettre les paramètres

Nous pouvons transmettre les paramètres par position et par mot-clé. Dans l'exemple suivant, nous passons la valeur hello comme paramètre de position. Le monde de valeurs est transmis à l'aide du mot-clé.

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

La différence entre les paramètres de position et les kwargs (arguments de mots clés) est que l'ordre dans lequel les paramètres de position sont transmis est important. Si vous appelez the_func('world', 'hello') il affichera world hello. L'ordre dans lequel les kwargs sont transmis n'a pas d'importance :

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'

Tant que le kwarg vient après les paramètres de position, vous pouvez mélanger et faire correspondre les arguments de position et de mot-clé. Ce qui précède est ce que nous voyons souvent dans les tutoriels Python, continuons. ci-dessous.

Paramètres de fonction

Nous démontrerons 6 méthodes de transmission des paramètres de fonction, qui peuvent couvrir tous les problèmes.

1. Comment obtenir tous les paramètres de position non capturés

Utilisez *args et laissez-le recevoir un nombre indéterminé de paramètres formels.

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

Dans cette fonction, nous définissons généralement les deux premiers paramètres (a et b). Utilisez ensuite args pour regrouper tous les arguments restants dans un tuple. Vous pouvez considérer * comme récupérant d'autres paramètres non traités et les rassemblant dans une variable tuple appelée "args":

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

Le dernier appel attribue la valeur 1 au paramètre a et 2 à Give paramètre b et remplissez la variable arg avec ( 3,4). Puisqu'il s'agit d'un tuple, nous pouvons le parcourir dans la fonction et multiplier en utilisant les valeurs !

** Le mot-clé kwargs stockera tous les arguments de mots-clés sans correspondance dans un dictionnaire appelé kwargs. Ce dictionnaire est alors accessible comme la fonction ci-dessus.

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. Si vous souhaitez n'accepter que les paramètres de mots-clés, comment pouvez-vous concevoir

pour forcer la fonction à n'accepter que les paramètres de mots-clés.

 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

Dans la fonction ci-dessus, l'astérisque * obtient tous les paramètres de position sans correspondance, mais il n'y a aucune variable pour l'accepter, ce qui est ignoré.

4. Comment concevoir une fonction qui n'accepte que les paramètres de position

Ce qui suit est un exemple de fonction qui autorise uniquement les paramètres de position :

 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)

/Force tous les paramètres qui la précèdent dans la définition de la fonction à être des paramètres de position. Cela ne signifie pas que tous les arguments qui suivent / doivent être uniquement des kwarg ; ils peuvent être positionnels ou des mots-clés.

Vous devez vous demander après avoir vu cela, pourquoi voulez-vous cela ? Cela ne réduira-t-il pas la lisibilité du code ?, je pense aussi que vous avez tout à fait raison, lors de la définition d'une fonction très claire, aucun paramètre de mot-clé n'est requis pour spécifier sa fonctionnalité. Par exemple :

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

Dans cet exemple, il vérifie si la taille de la mémoire de « a » dépasse 100 octets. Comme le nom de ce x n'est pas important pour nous, il n'est pas nécessaire de spécifier x='a' lors de l'appel de la fonction. Par exemple, notre len le plus couramment utilisé, si vous appelez len(__obj=[]), cela a l'air un peu idiot, car len est défini comme ceci def len(__obj: Sized) -> int:

5, mixé et Correspondance

À titre d'exemple, nous examinerons la fonction len discutée plus tôt. Cette fonction autorise uniquement les arguments de position. Nous allons étendre cette fonction en permettant aux développeurs de choisir de compter ou non les doublons, par exemple en passant ce mot-clé avec kwargs :

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

Vous souhaitez calculer la longueur de la variable x, vous ne pouvez passer le paramètre du paramètre formel x que de manière positionnelle, car il est précédé d'un/. L'argument no_duplicate doit être passé avec le mot-clé puisqu'il suit

. Voyons comment cette fonction peut être appelée :

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

6. Enfin, rassemblez le tout

La fonction ci-dessous est un exemple très extrême de la façon de combiner toutes les techniques évoquées précédemment : elle force les deux premiers paramètres passés positionnellement, le suivant deux arguments peuvent être transmis positionnellement et avec des mots-clés, puis deux arguments avec uniquement des mots-clés, puis nous capturons les arguments non capturés restants avec **kwargs.

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

La méthode d'appel est la suivante :

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

Résumé

Ça a l'air compliqué, n'est-ce pas ? Parce que Python est un langage très lâche lors de sa conception, il n'y a pas tellement de spécifications. Plus les gens l'utilisent, plus il utilise de méthodes, et cela devient comme ça.

Alors revenons à la première photo :

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

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!