introduction

Cet article est à moitié créé pour mes propres notes. Cependant, pour faire un mémo facile à comprendre quand je regarde en arrière J'ai essayé de rendre l'article facile à voir pour tout le monde. (Il semble qu'il sera signalé quand il fait une erreur ... (intention réelle))

ÉTAPE 1: À propos des arguments réels et formels

Les arguments sont grossièrement classés en deux types: les arguments formels et les arguments réels. Argument formel: utilisé dans la fonction ** définition **. Un argument formel car il donne un nom formel à l'objet réel. (argument) Argument réel: utilisé dans la fonction ** call **. Puisqu'il s'agit d'un objet réel, c'est un argument réel. (paramètre)


def foo(a):  #Argument formel
  a+=1
  return a

print(foo(1)) #Argument réel
 >>>2

ÉTAPE 2: Propriétés des arguments formels

Une propriété importante des arguments formels est qu'ils sont ** définis pour chaque appel de fonction **. Regardons un exemple concret.


def remove_first(lst):
    lst = lst[1:]
    print(lst)


lst = [1, 2, 3, 4]
print(lst)
remove_first(lst)
 >>> [2, 3, 4]
remove_first(lst)
 >>> [2, 3, 4]

Ce que je veux dire ici, c'est que les résultats du premier et du second remove_first (lst) sont les mêmes. En d'autres termes, "l'argument formel lorsqu'il est appelé pour la première fois" et "l'argument formel lorsqu'il est appelé pour la deuxième fois" sont Cela signifie que même la même variable est traitée comme une variable différente.

ÉTAPE 3: Type d'argument formel

Il existe cinq modèles pour les arguments formels mentionnés ci-dessus.

--Position ou mot-clé: définition de fonction dite ordinaire --Position uniquement: voir ci-dessous

Mots clés uniquement: voir ci-dessous
Position de longueur variable: décrite plus loin
Mot clé de longueur variable: décrit plus loin

Pour le moment, voici les positions ou mots-clés habituels.


def foo2(a, b=3):  #a est un argument positionnel et b est un argument mot-clé
  return a + b
def foo3(a=1, b):  #Erreur (l'argument mot-clé ne peut pas être défini avant l'argument positionnel)
  return a + b

print(foo2(1)) #Argument positionnel (la valeur de b est la valeur par défaut lorsque la fonction est définie)
 >>>4
print(foo2(1,5)) #Argument de position (un=1,b=5）
 >>>6
print(foo2(1,b=5)) #Arguments positionnels et mots-clés
 >>>6
print(foo2(a=1,b=5)) #Argument de mot-clé
 >>>6
print(foo2(b=2)) #Erreur
 >>>TypeError
print(foo2(b=3,a=1)) #Changer l'ordre des arguments de mots clés

En tant que propriété importante qui peut être vue de ce qui précède

Pour les arguments formels, les arguments de mot-clé ne peuvent pas être définis avant les arguments de position. --Si l'argument mot-clé n'est pas défini comme argument réel, la valeur par défaut de l'argument formel est appliquée. --Dans l'argument réel, l'argument mot-clé peut être défini en modifiant l'ordre.
** Peut être appelé comme argument de position ou comme argument de mot-clé avec un argument réel **

ÉTAPE 4: Position uniquement, mot-clé uniquement

Ensuite, je présenterai uniquement les mots-clés mentionnés ci-dessus. Tout d'abord, seule la position, ** Lors de la définition d'une fonction, l'argument avant / ne peut être appelé que comme argument positionnel ** En revanche, seuls les mots clés ** Lors de la définition d'une fonction, les arguments après * ne peuvent être appelés qu'avec des arguments de mot-clé **


def func(a,*,b,c):
    return a + b + c

def func2(a, /):
    return a 

print(func(1,b=2,c=3)) #b entraînera une erreur s'il n'est pas appelé avec un argument mot-clé
print(func2(1)) #a entraînera une erreur s'il n'est pas appelé avec un argument de position

ÉTAPE 5: Position de longueur variable, mot-clé de longueur variable

Tout d'abord, la position de longueur variable est ** un argument qui peut recevoir n'importe quel nombre d'arguments de position **. ** Lors de la définition d'une fonction, ajoutez * avant l'argument pour en faire un argument positionnel (jusqu'à une fois par fonction) ** Les mots-clés de longueur variable sont des ** arguments qui peuvent accepter n'importe quel nombre d'arguments de mots-clés **. ** Lors de la définition d'une fonction, ajoutez \ ** avant l'argument pour en faire un argument positionnel (jusqu'à une fois par fonction) **


def func(*a, **b):
    print(a)
    print(b)

func(1,2,3,b=4,c=5)
 >>> (1, 2, 3)
     {'b': 4, 'c': 5}