Cette fois, c'est une petite histoire. Encore une fois, beaucoup de gens ne savent pas comment l'utiliser au travail, alors j'ai pensé l'écrire. Surtout les arguments de longueur variable et les arguments de mots clés. Probablement parce que ce n'est pas dans d'autres langues principales ... Eh bien, si vous recherchez, vous pouvez en trouver autant que vous le souhaitez ...
Je vais le faire avec le système Python 3.X. C'est la base.
##Définition de la fonction *'argument'Est le nom de la variable
def func('argument'):
# process
return ret
if __name__ == '__main__':
#Appel de fonction *'argument'Est en fait une variable ou une valeur
x = func('argument')
Cette fois, comment passer ou recevoir l'argument ici. On dit que Python peut être reçu de cette manière.
Une méthode de réception des arguments de position tels quels, dans l'ordre. Cela ne change pas dans les autres langages de programmation.
code
def func(arg1, arg2, arg3):
return (arg1 * 3.0) + (arg2 * 2.0) + (arg3 * 1.0)
if __name__ == '__main__':
y = func(4, 5, 6)
print(y)
output
28.0
L'appelant passe respectivement 4,5,6 dans l'ordre. Par conséquent, du côté de la réception, il est passé en fonction de la position (ordre). arg1 = 4、arg2 = 5、arg3 = 6 Par conséquent, le contenu de traitement de cette fonction est 4 * 3 + 5 * 2 + 6 * 1 = 28.
Rien ne se passe, définissez des arguments qui n'ont pas besoin d'être spécifiés au moment de l'appel.
code
def func(arg=1):
print(arg)
if __name__ == '__main__':
func()
func(99)
output
1
99
Lorsque l'argument arg est omis au moment de la définition et est appelé, la valeur par défaut est déterminée quant à la manière de le gérer. En définissant "arg = 1", lorsqu'il est omis, le traitement dans la fonction commence par 1 dans arg.
Étant donné que l'argument est omis lors du premier appel, la valeur par défaut de 1 est sortie. Puisque la deuxième fois n'est pas omise, le 99 passé est sorti.
Comme son nom l'indique, les arguments de longueur variable sont une méthode permettant de recevoir un nombre non spécifié de n arguments. Ajoutez un * (astérisque) au nom de l'argument. Cet astérisque n'est pas nécessaire lors de la manipulation dans une fonction. Je ne l'ai jamais vu dans d'autres langues.
code
def func(*args):
for i, v in enumerate(args):
print('args[%d] = %s' % (i, v))
if __name__ == '__main__':
func((1, 2), 3, 4, (5, 6), 7, 8)
output
args[0] = (1, 2)
args[1] = 3
args[2] = 4
args[3] = (5, 6)
args[4] = 7
args[5] = 8
La définition de fonction ne fournit qu'un seul argument, mais l'appelant transmet quatre arguments. La façon dont l'appelant le passe est également un peu délicate. Le premier (1, 2) est maintenant un Tuple et (5, 6) est le même. En dehors de cela, une valeur numérique a un argument, donc comme vous pouvez le voir dans la sortie, il y a six arguments.
Du côté de la réception, plusieurs arguments sont passés aux args comme un seul Tuple. Puisque Tuple est itérable, il s'agit d'une sortie standard décalée de un dans une boucle for. Puisqu'il s'agit de Tuple, vous pouvez faire référence à la valeur de l'argument à n'importe quelle position avec args [i] dans la fonction.
Bien sûr, vous ne pouvez pas en créer deux comme indiqué ci-dessous. Je ne sais pas où se trouve la première longueur variable et où se trouve la deuxième longueur variable.
def func(*args1, *args2):
print(args1, args2)
Les arguments de mots-clés sont également des arguments de longueur variable, et la différence avec les arguments de longueur variable est qu'ils ont des mots-clés. ・ ・ ・ ・ ・ ・ ・ Difficile à expliquer avec des mots. L'argument de longueur variable est Tuple, tandis que l'argument mot-clé est Dictionary.
code
def func(**kwargs):
print(kwargs['arg1'], kwargs['args'])
# print(kwargs)
if __name__ == '__main__':
func(arg1=1, args=(2, 3, 4), arg2=5)
output
1 (2, 3, 4)
Dans l'argument mot-clé, l'appelant le transmet sous la forme "mot-clé = valeur". Dans cette fonction, kwargs est un argument mot-clé et "arg1" et "args" sont affichés en standard dans la fonction. L'appelant spécifie également arg2, mais rien n'est fait car il n'est pas géré dans la fonction.
Depuis qu'il a été adopté, l'impression commentée (kwargs) produit le dictionnaire comme indiqué ci-dessous.
python
{'arg1': 1, 'args': (2, 3, 4), 'arg2': 5}
J'ai bien reçu arg2 = 5.
À propos, comme les arguments de longueur variable, vous ne pouvez pas en créer deux. Je ne sais pas quel argument de mot-clé.
Notez que lorsque vous les utilisez en combinaison, la position est importante sauf pour l'argument mot-clé.
code
def func(*args, **kwargs):
print('args = ', args)
print('kwargs = ', kwargs)
if __name__ == '__main__':
func(1, 2, 3, 4, arg1=5, arg2=6)
Quatre valeurs non-mot-clé dans la première moitié de l'appel sont transmises à l'argument de longueur variable args. Les arguments avec des mots-clés sont transmis aux arguments dans la seconde moitié. Lorsque vous utilisez cette combinaison comme contrainte, il doit s'agir d'abord d'un argument de longueur variable, puis d'un argument mot-clé.
code
def func(**kwargs, *args):
~~~~~
C'est une syntaxe invalide.
<détails> Ce n'est pas trop difficile.
Les deux premiers sont des arguments positionnels, donc 1 et 2 sont respectivement arg1 et arg2.
Le reste est résumé dans Tuple comme un argument de longueur variable, Lors de l'appel, cela ressemble à la combinaison d'arguments de position et d'arguments de mots-clés.
Cependant, la partie d'argument positionnel peut être omise.
Bien sûr, si omis, la valeur par défaut. <détails> De plus, lors de l'appel, le nom de l'argument doit être spécifié comme un argument optionnel comme un argument de mot-clé.
Si omis au moment de l'appel, la valeur par défaut est 1. Si vous avez de l'expérience avec d'autres langues, vous vous êtes peut-être demandé: "Hmm? Surcharge de fonctions?"
En Python, vous pouvez passer un nombre non spécifié d'arguments de cette manière.
De plus, les types de données des variables sont également typés dynamiquement, ce qui se trouve dans d'autres langages de programmation orientés objet.
** Il n'y a pas de surcharge (définition multiple) en Python. ** ** Vous pouvez faire quelque chose comme une surcharge en modifiant le contenu du traitement dans une fonction en utilisant pleinement la méthode de transmission de l'argument cette fois.
Cependant, le nom de la fonction est le même et la surcharge réelle créée par le nombre d'arguments et de types différents ne peut pas être effectuée. Surcharges avec différents nombres d'arguments dans d'autres langues, mais en Python, c'est une erreur.
Cependant, en Python, qui est un interpréteur, la func écrite dans le second écrase la première, donc
** Le contenu de l'erreur est "arg2 n'est pas spécifié". Mise en garde. ** **
Recommended Posts
code
def func(arg1, arg2, *args):
print('arg1 = ', arg1)
print('arg2 = ', arg2)
print('args = ', args)
if __name__ == '__main__':
func(1, 2, 3, 4, 5)
output
arg1 = 1
arg2 = 2
args = (3, 4, 5)
Combinaison d'arguments positionnels et de mots-clés
code
def func(arg1, arg2, **kwargs):
print('arg1 = ', arg1)
print('arg2 = ', arg2)
print('kargs = ', kwargs)
if __name__ == '__main__':
func(1, 2, kwarg1=2, kwarg2=3)
output
arg1 = 1
arg2 = 2
kargs = {'kwarg1': 2, 'kwarg2': 3}
Combinaison d'arguments optionnels et de mots-clés
code
def func(arg=1, **kwargs):
print('arg = ', arg)
print('kargs = ', kwargs)
if __name__ == '__main__':
func(kwarg1=2, kwarg2=3)
func(99, kwarg1=100, kwarg2=101)
output
arg = 1
kargs = {'kwarg1': 2, 'kwarg2': 3}
arg = 99
kargs = {'kwarg1': 100, 'kwarg2': 101}
code
def func(*args, arg=1):
print('arg = ', arg)
print('args = ', args)
if __name__ == '__main__':
func(1, 2, 3, 4, arg=5)
func(5, 6, 7, 8)
output
arg = 5
args = (1, 2, 3, 4)
arg = 1
args = (5, 6, 7, 8)
Points liés à l'orientation de l'objet
Si vous essayez de le forcer d'une manière à laquelle vous êtes habitué dans d'autres langues ...
overload
def func(arg):
return arg
def func(arg1, arg2):
return arg1, arg2
if __name__ == '__main__':
ret = func(1)
output
TypeError: func() missing 1 required positional argument: 'arg2'