Cet article vous apporte une introduction détaillée aux paramètres de fonction en Python (avec des exemples). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.
La définition de la fonction Python est relativement simple, implémentée à l'aide du mot-clé def, mais les paramètres sont très flexibles. En plus des paramètres requis normalement définis, vous pouvez également utiliser des paramètres par défaut, des paramètres variables, des paramètres de mot-clé, des paramètres de mot-clé nommé et des combinaisons de paramètres. Cela permet à l'interface définie par la fonction non seulement de gérer des paramètres complexes, mais également de simplifier les appels. Le code de l'opérateur
Lorsque la fonction est définie, précisez l'ordre de position des paramètres. Les paramètres de position doivent être transmis dans l'ordre exact dans la définition de la fonction appelée.
Par exemple : Calculez la nième puissance de x
def powern(x,n): s = 1 while n >0: s = s * x n = n -1 return s
Les deux paramètres x et n sont des paramètres de position. Lors de l'appel d'une fonction, les deux valeurs doivent être transmises et affectées aux paramètres x et n par ordre de position. Si elles sont omises par défaut, une erreur sera signalée. Par exemple :
>>> powern(5) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: powern() missing 1 required positional argument: 'n'
Dans la définition de la fonction, des valeurs par défaut sont prédéfinies pour les paramètres. Lorsqu'une fonction est appelée, si aucune valeur spécifiée n'est fournie pour un paramètre, la valeur par défaut est utilisée.
Par exemple : il trouve toujours x élevé à la nième puissance, mais la valeur par défaut est x élevé à la troisième puissance.
def powern( x,n = 3): s = 1 while n >0: s = s * x n = n -1 return s
Exécuter : powern(2), ce qui équivaut à appeler powern(2,3)
Si vous avez besoin de la quatrième puissance de 2, vous devez exécuter : powern(2,4)
Quels sont les avantages de définir des paramètres par défaut ?
Les paramètres par défaut peuvent simplifier les appels de fonctions et réduire la difficulté d'appeler des fonctions. Qu'il s'agisse d'un appel simple ou d'un appel complexe, une seule fonction doit être définie.
Par exemple, dans l'exemple ci-dessus de powern(), lorsque d'autres valeurs de n sont transmises, d'autres nièmes puissances de x peuvent être réalisées.
Mais lors de l'utilisation des paramètres par défaut, il y aura des pièges s'ils sont mal utilisés. Comprenons d'abord la différence entre les paramètres variables et les paramètres immuables en tant que paramètres de fonction :
Paramètres immuables en tant que paramètres de fonction
>>> a = 1
>>> def func(a):
... print('func_id:',id(a))
... a = 2
... print('after_func_id:',id(a),'id(2):',id(2))
...
>>> print('out_of_func_id:',id(a),'id(1):',id(1))
out_of_func_id: 501962480 id(1): 501962480 # 全局变量a的id
>>> func(a) # 将全局参数a传入函数
func_id: 501962480 # a=1 的id
after_func_id: 501962496 id(2): 501962496
>>> print(a) # 退出函数，a的值仍为1
1Lors du passage du a global Après l'avoir donné à la fonction, la fonction copie automatiquement une référence. Après avoir exécuté a=2, l'adresse mémoire de id(a) change. Mais cela n'a rien à voir avec le a extérieur.
Objets variables comme paramètres de fonction
>>> a = []
>>> def func2(a):
... print('func2_id:',id(a))
... a.append(1)
...
>>> print('out_of_func2_id',id(a))
out_of_func2_id 59694296
>>> func2(a)
func2_id: 59694296
>>> print(a)
[1]Le type de variable a est une liste, qui est un objet variable. La référence de la fonction pointe vers un objet mutable, et l'adresse ne change pas, donc le contenu de a change après l'opération de la fonction.
Ainsi, lorsque la fonction func2(a) est à nouveau utilisée, un résultat différent de celui attendu est produit :
>>> func2(a) func2_id: 59694296 # a地址不变 >>> print(a) [1, 1] # 因为第一次执行func2(a)时，已经修改了a=[1]，再次调用时，在[1]里新增
Par exemple :
def add_end( L=[] ): # 设置为一个list变量L（对象可变）
L.append('end')
return L
>>> add_end( )
['end']
>>> add_end()
['end', 'end']Lorsqu'il est appelé à plusieurs reprises avec les paramètres par défaut , le résultat est une erreur.
Lorsque la fonction Python est définie, la valeur du paramètre par défaut L est calculée, qui est []. L est aussi une variable, qui pointe vers l'objet []. Chaque fois que la fonction est appelée, si le contenu de L est modifié, le contenu du paramètre par défaut changera au prochain appel, et il ne le sera plus. le [] lorsque la fonction a été définie.
peut être modifié en :
def add_end( L=None ): # L为不变对象
if L is None:
L = []
L.append('end')
return L Ensuite, peu importe le nombre de fois où il sera appelé, il n'y aura aucun problème.
Il y a donc une chose à garder à l'esprit lors de la définition des paramètres par défaut : Les paramètres par défaut doivent pointer vers des objets immuables ! Car une fois qu'un objet immuable est créé, les données à l'intérieur de l'objet ne peuvent pas être modifiées, ce qui réduit les erreurs causées par la modification des données. De plus, l'objet restant inchangé, la lecture simultanée d'objets dans un environnement multitâche ne nécessite pas de verrouillage.
Lors de la définition des paramètres par défaut, il y a quelques points à noter
1. Les paramètres obligatoires viennent en premier et les paramètres par défaut en dernier, sinon l'interpréteur Python signalera une erreur.
2. Comment définir les paramètres par défaut ? Lorsqu'une fonction a plusieurs paramètres, placez les paramètres avec les changements les plus importants au début et les paramètres avec les changements les plus mineurs à la fin. Les paramètres avec de légères modifications peuvent être utilisés comme paramètres par défaut.
3. N'utilisez pas d'objets mutables comme paramètres par défaut.
Paramètres variables, c'est-à-dire que le nombre de paramètres transmis est variable, de 0 à n'importe quel nombre.
Le nombre de paramètres étant incertain, vous pouvez utiliser une liste ou un tuple pour les transmettre. Il sera ensuite automatiquement assemblé en tuple lorsque la fonction sera appelée.
Par exemple :
def calc(numbers): # 变量 sum = 0 for n in numbers: sum = sum + n * n return sum >>> calc( [1,2,3] ) # 传入的是一个list 14
Utilisation de paramètres variables *args :
def calc( *numbers ): sum = 0 for n in numbers: # 在函数内部，numbers组装成一个tuple sum = sum + n * n return sum >>> calc( ) # 0个参数 0 >>> calc( 1,3,5,7 ) # 多个参数 84 >>> num = [1,2,3] # list >>> calc( *num ) # *list –> tuple 14 >>> t = (1,3,5) >>> calc( t ) # tuple(错误) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "<stdin>", line 4, in calc TypeError: can't multiply sequence by non-int of type 'tuple' >>> calc( *t ) 35
Le code de la fonction reste complètement inchangé. Cependant, lors de l'appel de cette fonction, n'importe quel nombre de paramètres peut être transmis, y compris 0 paramètre.
Paramètre de mot-clé **kw permet de transmettre 0 à n'importe quel nombre de paramètres contenant des noms de paramètres. Ces paramètres de mots-clés sont automatiquement assemblés en un. dict à l’intérieur de la fonction. Par exemple :
def person(name , age , **kw ):
print('name:',name,'age:',age,'other:',kw)
>>> person('xiong',18)
name: xiong age: 18 other: {}
>>> person('xiong',18,city = 'SH') # city是原本没有的参数，但是因为有**kw
name: xiong age: 18 other: {'city': 'SH'}A quoi servent les paramètres clés ? La fonctionnalité de la fonction peut être étendue. Par exemple, dans la fonction person(), il est garanti de recevoir les deux paramètres name et age. Mais si davantage de paramètres sont fournis, ils peuvent également être reçus. Bien sûr, vous pouvez également assembler un dict d'abord, puis convertir le dict en paramètres de mots-clés et le transmettre :
>>> extra ={'city':'shanghai','job':'SET'} # dict的定义
>>> person('xiong',18,city = extra['city'],job=extra['job']) # dict的使用
name: xiong age: 18 other: {'city': 'shanghai', 'job': 'SET'} # dict的内容
>>> person('xiong',18,**extra)
name: xiong age: 18 other: {'city': 'shanghai', 'job': 'SET'}[Résumé] **extra signifie transmettre toutes les valeurs-clés du extra dict comme paramètres de mot-clé. Entrez le paramètre **kw de la fonction, et kw obtiendra un dict. Notez que le dict obtenu par kw est une copie de extra. Les modifications apportées à kw n'affecteront pas l'extra en dehors de la fonction.
如果要限制关键字参数的名字，就可以用命名关键字参数。需要一个特殊分隔符“”，“”后面的参数被视为命名关键字参数。如果缺少“*”，Python解释器则无法识别位置参数和命名关键字参数。在调用时，必须指定参数名字与参数值。
例如，只接收city和job作为关键字参数，可以使用如下定义：
def person( name ,age,*,city,job):
print(name , age , city , job )
>>> person('xiong', 18, city='shanghai', job='tester')
xiong 18 shanghai tester如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：
>>> def person( name,age,*args,city,job ): # 此处city和job也是命名关键字参数 ... print(name, age, city, job)
命名关键字参数必须传入参数名，如果没有传入参数名，调用将会报错：
>>> person('xlp',18,'shanghai','tester') # 错误调用
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: person() missing 2 required keyword-only arguments: 'city' and 'job'
>>> person('xlp',18,city='shanghai',job='tester') # 正确调用
xlp 18 shanghai tester命名关键字参数可以有缺省值，从而简化调用：
>>> def person1(name,age,*,city='shanghai',job):
... print(name,age,city,job)
...
>>> person1('xlp',18,job='engineer')
xlp 18 shanghai engineer在Python中定义函数，可以用位置参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。
但是要注意，参数定义的顺序必须是：位置参数、默认参数、可变参数、命名关键字参数和关键字参数。
（1）定义可变参数和关键字参数的语法：
*args是可变参数，args接收的是一个list、tuple;
**kw是关键字参数，kw接收的是一个dict；
（2）调用函数时如何传入可变参数和关键字参数的语法：
可变参数直接传入：func(1,2,3)
可变参数间接传入：先组装成list或tuple，l=(1,2,3)，再通过args传入，func(l)
关键字参数直接传入：func(a=1,b=2)
关键字参数间接传入：先组装成dict，d={‘a’:1,’b’:2}，再通过kw传入，func(d)
（3）命名关键字参数 是为了限制调用者可以传入的参数名，同时可以提供默认值。
（4）定义命名的关键字参数在没有可变参数的情况下，不要忘记写分隔符*，否则定义的将是位置参数
相关推荐：
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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
