En Python, lorsque l'on définit des fonctions avec des valeurs par défaut pour certains paramètres, on dit que ses arguments sont définis en option pour l'utilisateur. Les utilisateurs peuvent soit transmettre leurs valeurs, soit faire semblant que la fonction utilise leurs valeurs par défaut spécifiées.
De cette façon, l'utilisateur peut appeler la fonction soit en transmettant ces paramètres facultatifs, soit simplement en transmettant les paramètres requis.
Il existe deux manières principales de transmettre des paramètres facultatifs en python
pseudocode java
- Sans utiliser d'arguments de mots clés.
- En utilisant des arguments de mots clés.
Passer sans utiliser d'arguments de mots clés
Un point principal à prendre en compte lors de la transmission sans utiliser d'arguments de mots-clés est :
- L'ordre des paramètres doit être conservé, c'est-à-dire que l'ordre dans lequel les paramètres sont définis dans la fonction doit être conservé lors de l'appel de la fonction.
- Les valeurs des paramètres non facultatifs doivent être transmises, sinon une erreur sera générée.
- La valeur des arguments par défaut peut être transmise ou ignorée.
Vous trouverez ci-dessous quelques codes qui expliquent ce concept.
Exemple 1:
Python3
# Here b is predefined and hence is optional.> def> func(a, b>=>1098>):> >return> a>+>b> print>(func(>2>,>2>))> # this 1 is represented as 'a' in the function and> # function uses the default value of b> print>(func(>1>))> |
>
>
Sortir:
4 1099>
Exemple 2 : on peut aussi passer des chaînes.
Python3
# Here string2 is the default string used> def> fun2(string1, string2>=>'Geeks'>):> >print>(string1>+> string2)> # calling the function using default value> fun2(>'GeeksFor'>)> # calling without default value.> fun2(>'GeeksFor'>,>'Geeks'>)> |
>
>
Sortir:
GeeksForGeeks GeeksForGeeks>
Passer avec des arguments de mots-clés
Lorsque les fonctions sont définies, les paramètres sont écrits sous la forme nom-clé de type de données. Python fournit donc un mécanisme pour appeler la fonction en utilisant le nom du mot-clé pour transmettre les valeurs. Cela aide le programmeur en lui évitant de devoir apprendre la séquence ou l'ordre dans lequel les paramètres doivent être transmis.
Certains points importants dont nous devons nous souvenir sont les suivants :
- Dans ce cas, nous ne sommes pas obligés de maintenir l’ordre de transmission des valeurs.
- Il ne devrait y avoir aucune différence entre les noms de mots clés transmis et déclarés.
Vous trouverez ci-dessous le code pour son implémentation.
Python3
# Here string2 is the default string used> def> fun2(string1, string2>=>'Geeks'>):> >print>(string1>+> string2)> # Thiscan be a way where no order is needed.> fun2(string2>=>'GeeksFor'>, string1>=>'Geeks'>)> # since we are not mentioning the non-default argument> # so it will give error.> fun2(string2>=>'GeeksFor'>)> |
>
>
Sortir:
itération de la carte Java
Comme nous pouvons le voir, nous n’exigeons qu’aucun ordre soit maintenu dans l’exemple ci-dessus. De plus, nous pouvons voir que lorsque nous essayons de transmettre uniquement les paramètres facultatifs, cela génère une erreur. Cela se produit car les paramètres facultatifs peuvent être omis car ils ont une valeur par défaut, mais nous ne pouvons pas omettre les paramètres requis (string1 dans le cas ci-dessus.) Par conséquent, il affiche une erreur avec l'indicateur : il manque 1 argument requis.
Cet exemple donnera une idée plus précise du sujet ci-dessus :
Python3
def> func(a, b, c>=>'geeks'>):> >print>(a,>'type is'>,>type>(a))> >print>(b,>'type is'>,>type>(b))> >print>(c,>'type is'>,>type>(c))> # The optional parameters will not decide> # the type of parameter passed.> # also the order is maintained> print>(>'first call'>)> func(>2>,>'z'>,>2.0>)> # below call uses the default> # mentioned value of c> print>(>'second call'>)> func(>2>,>1>)> # The below call (in comments) will give an error> # since other required parameter is not passed.> # func('a')> print>(>'third call'>)> func(c>=>2>, b>=>3>, a>=>'geeks'>)> |
>
>
Sortir:
first call 2 type is z type is 2.0 type is second call 2 type is 1 type is geeks type is third call geeks type is 3 type is 2 type is>
Donc, fondamentalement, les appels fonctionnels Python vérifient uniquement si le nombre requis de paramètres fonctionnels est transmis ou non.
Ci-dessous montre le cas où un utilisateur tente de transmettre des arguments des deux manières évoquées ci-dessus, ainsi que les précautions données :
Python3
opacité de la transition CSS
def> comp(a, b>=>2>):> >if>(a print('first parameter is smaller') if(a>b): print('le deuxième paramètre est plus petit') if(a == b): print('les deux sont de valeur égale.') print('premier appel') comp(1) print( 'deuxième appel') comp(2, 1) print('troisième appel') comp(b=1, a=-1) print('quatrième appel') comp(-1, b=0 )> |
>
>
Sortir:
first call first parameter is smaller second call second parameter is smaller third call first parameter is smaller fourth call first parameter is smaller>
Donc, une chose dont nous devons nous rappeler est que l'argument mot-clé doit être utilisé une fois que tous les arguments de position sont passés. C'est donc une chose importante que nous devons garder à l'esprit lorsque nous transmettons des paramètres dans les deux sens à la même fonction.