Dans ce chapitre, vous découvrirez les fonctions Python. Qu'est-ce qu'une fonction en premier lieu? Cela ressemble à cela, mais je vais l'expliquer, y compris l'explication à ce sujet.
Il y a de nombreux avantages à bien utiliser les fonctions, comme réduire la quantité de code à écrire, éviter d'écrire le même code encore et encore et rendre le code plus facile à lire.
Commençons par l'explication de la fonction elle-même.
La fonction est fonction en anglais. En mathématiques, il existe quelque chose qui s'appelle une fonction, qui est également appelée fonction en anglais, mais le contenu de la fonction est différent entre les mathématiques et les programmes. Veuillez noter que c'est différent.
Les fonctions des programmes Python ont les principales caractéristiques suivantes.
Seki ** Number **, quelque chose lié aux nombres parce qu'il est attaché aux nombres? Vous pourriez penser, mais la fonction accepte diverses choses autres que des nombres, comme des chaînes et des listes. C'est un peu déroutant en japonais, mais en anglais pour les fonctions, il n'y a pas de mots liés aux nombres, et il faut garder à l'esprit que c'est simplement une fonction.
En plus du sens de fonction, fonction a également le sens de «fonction» et de «travail». Il peut être bon de considérer les fonctions d'un programme comme «un programme avec une certaine fonction est exécuté» lorsqu'il est exécuté.
Pour créer une fonction Python, utilisez le mot-clé def. Mettez un espace demi-largeur après def, écrivez le nom de la fonction après elle, écrivez les parenthèses demi-largeur ( et) , et ajoutez les deux points demi-largeur`: ʻà la fin de la ligne. Vous pouvez créer une fonction.
Par exemple, def function name ():. Fondamentalement, des caractères alphanumériques demi-largeur sont utilisés pour le nom de la fonction.
Le contenu du programme de fonction y sera écrit en ajoutant un retrait (quatre espaces demi-largeur) à partir de la ligne suivante de la fonction définie par def.
À titre d'exemple, si vous souhaitez afficher le contenu de 1 + 1 avec print et que le nom de la fonction est print_one_plus_one, le code est le suivant.
def print_one_plus_one():
print(1 + 1)
Dans la section sur l'indentation du chapitre précédent, j'ai expliqué que «l'indentation représente la structure hiérarchique du programme» et «plus la hiérarchie du programme est profonde».
Même dans les programmes de fonction, cette règle selon laquelle «la hiérarchie du programme est plus profonde lorsqu'elle va vers la droite» est bien vivante.
Faisons attention à la partie appelée print (1 + 1) où un retrait (4 espaces demi-largeur) est défini dans le code ci-dessus.
Cette partie correspond au "programme en fonction". En d'autres termes, la hiérarchie du programme est devenue plus profonde en raison de l'augmentation de l'indentation, comme "programme appelé` print (1 + 1)" "dans" fonction appelée print_one_plus_one "(le programme est inclus par le montant de l'indentation). Masu).
De plus, dans la section sur l'indentation dans les listes et les dictionnaires, j'ai expliqué que même le code qui omet l'indentation comme suit fonctionnera (cela ne provoquera pas d'erreur de programme).
int_list = [
1,
2,
3,
4,
]
D'autre part, les indentations ont ** signification ** dans les fonctions. «Position de départ du programme avec retrait» signifie «position de départ du programme en fonction», et «position immédiatement avant le programme sans retrait» signifie «position finale du programme en fonction». Je pense que ce domaine est un peu difficile à comprendre, donc je vais regarder de plus près en fonction du programme.
Gardez à l'esprit que le programme de fonction ne fonctionnera que si vous définissez le retrait correct pour le moment.
En guise de test, écrivons et exécutons du code qui n'inclut pas de retrait après la fonction.
def print_one_plus_one():
print(1 + 1)
File "<ipython-input-12-a31292ca450b>", line 2
print(1 + 1)
^
IndentationError: expected an indented block
Comme mentionné ci-dessus, s'il n'y a pas de retrait après la fonction, une erreur se produit. IndentationError est une erreur causée par une indentation incorrecte, un bloc indenté signifie un bloc de code indenté, attendu signifie "attendu", donc "en supposant que la partie de code avec une indentation ajoutée arrive" J'obtiens un message d'erreur du type "C'est fait, mais ce n'est pas le cas (pas d'indentation)".
S'il s'agit d'une ligne qui n'est pas du code, par exemple une ligne qui est juste vide (une ligne où aucun programme n'est écrit), il n'y a pas de problème même s'il n'y a pas d'indentation. Par exemple, peu importe s'il y a une ligne vide et non indentée entre la ligne digit_value = 1 + 1 et la ligne` print (digit_value) ʻ comme indiqué ci-dessous.
def print_one_plus_one():
digit_value = 1 + 1
print(digit_value)
Pour terminer la fonction, écrivez le code sans indentation. Par exemple, le contenu d'une fonction ne sera pas exécuté à moins que la fonction ne soit exécutée (décrite dans la section suivante), mais dans le code suivant, la partie print (3 + 5) n'a pas de retrait (= fonction). Puisque le contenu de) est terminé), il est exécuté immédiatement sans appeler la fonction, et le résultat de 8 est affiché.
def print_one_plus_one():
digit_value = 1 + 1
print(digit_value)
print(3 + 5)
Contenu de sortie du résultat de l'exécution du code:
8
Pour appeler (exécuter) la fonction créée, utilisez des parenthèses mi-largeur ( et ) après le nom de la fonction, comme function name ().
Si vous voulez exécuter la fonction print_one_plus_one que vous avez créée il y a quelque temps, écrivez quelque chose comme print_one_plus_one (). Lorsque vous exécutez le code, vous pouvez voir que le programme à l'intérieur de la fonction (print (1 + 1)) est exécuté et 2 est sorti.
def print_one_plus_one():
print(1 + 1)
print_one_plus_one()
Contenu de sortie du résultat de l'exécution du code:
2
Les variables créées dans une fonction se comportent spécialement.
Par souci d'explication, écrivez et exécutez d'abord le code suivant.
def print_one_plus_one():
digit_value = 1 + 1
print(digit_value)
print_one_plus_one()
digit_value += 1
2
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-21-50561b28b02f> in <module>
5
6 print_one_plus_one()
----> 7 digit_value += 1
NameError: name 'digit_value' is not defined
La fonction print_one_plus_one est exécutée en premier (print_one_plus_one ()), où une variable appelée digit_value est créée ( digit_value = 1 + 1), puis 1 est ajouté à la variable digit_value en dehors de la fonction. Le code est (digit_value + = 1).
Cependant, quand je l'ai exécuté, j'ai reçu un message d'erreur (name'digit_value 'is not defined) disant" La variable digit_value n'est pas définie ".
Pourquoi créez-vous des variables dans le code à l'intérieur de la fonction?
En fait, les variables créées dans la fonction disparaissent fondamentalement lorsque la fonction termine son exécution. Par conséquent, si les variables créées dans la fonction sont laissées telles quelles, elles ne peuvent pas être utilisées (souvent désignées) à partir du code en dehors de la fonction (la partie sans indentation) ou à partir d'autres fonctions.
Imaginez qu'il existe différentes variables dans une boîte appelée une fonction. Une autre fonction sera une autre boîte. Les uns et les autres ne peuvent utiliser que les variables qui se trouvent dans la boîte.
La plage de variables qui peuvent être référencées, comme cette boîte, est appelée ** scope **. En anglais, c'est la portée. C'est un mot qui a le sens de "plage" ou "vue". En programmation, cela signifie "plage de variables accessible, etc."
Regardons de plus près la portée.
Auparavant, lorsque j'essayais d'accéder à une variable dans une fonction en dehors de la fonction, j'avais une erreur. Que se passe-t-il si vous accédez à une variable créée en dehors de la fonction depuis l'intérieur de la fonction?
Les références dans une fonction d'une variable créée en dehors de la fonction se comportent différemment selon le type de la variable.
Tout d'abord, essayons une variable entière (int) comme exemple.
int_variable = 100
def add_one():
int_variable += 1
add_one()
UnboundLocalError Traceback (most recent call last)
<ipython-input-4-e73c01cb25ac> in <module>
6
7
----> 8 add_one()
<ipython-input-4-e73c01cb25ac> in add_one()
3
4 def add_one():
----> 5 int_variable += 1
6
7
UnboundLocalError: local variable 'int_variable' referenced before assignment
Lorsque j'essaye de l'exécuter, j'obtiens l'erreur ci-dessus. Non consolidé a le sens de "non consolidé" ou "non attribué" en plus du sens de "non consolidé".
De plus, les variables de la fonction sont appelées variables locales (variables locales en anglais). Une règle uniquement pour une région spécifique est appelée règle locale, mais une variable locale a un sentiment similaire et signifie "une variable uniquement dans une fonction spécifique".
La référence signifie qu'elle est référencée et l'affectation signifie quelque chose comme l'allocation. Ici, il n'y a pas de problème si vous le lisez comme si la variable n'avait pas été créée.
Par conséquent, le message d'erreur "variable locale" variable_int "référencée avant l'affectation" devient le message "La variable locale" variable_int "est référencée avant la création."
Il existe une variable globale associée à une variable locale. Les variables locales ne peuvent être référencées que par des fonctions spécifiques, tandis que les variables globales peuvent être référencées à divers endroits en fonction des paramètres.
Si vous créez une variable en dehors de la fonction, elle devient une variable globale. En fait, les variables que nous avons créées avant le chapitre fonction correspondent à des variables globales.
Dans le code qui a abouti à UnboundLocalError mentionné ci-dessus, la variable globale est créée en premier avec le code ʻint_variable = 100`. Il a également expliqué que les variables globales peuvent être référencées à divers endroits.
Dans ce cas, n'est-il pas étrange qu'une erreur se produise lors du référencement de ʻint_variable dans la fonction ʻadd_one? N'est-il pas étrange que des variables locales soient affichées dans le message d'erreur même s'il s'agit de variables globales? Vous pouvez ressentir cela.
La raison de ce comportement est que le programme Python ne sait pas "est-ce une variable locale?" Ou "est-ce une variable globale?".
Vous pouvez utiliser le même nom pour les variables globales et locales. Par conséquent, si cela est laissé tel quel, le programme ne peut pas déterminer lequel gérer et la variable locale gère les entiers. Si vous souhaitez gérer des variables globales telles que des entiers, vous devez indiquer explicitement au programme: "Ceci est une variable globale".
Pour indiquer au programme qu'une variable particulière est une variable globale, écrivez «nom de la variable globale» dans la fonction. Lorsque vous traitez la variable ʻint_variabledans le code ci-dessus comme une variable globale, elle sera sous la forme deglobal int_variable`.
Si vous le réécrivez pour que l'erreur ne se produise pas, ce sera comme suit. Vous pouvez confirmer que 101 est généré en ajoutant 1 à la valeur de la variable globale «100».
int_variable = 100
def add_one():
global int_variable
int_variable += 1
print(int_variable)
add_one()
Contenu de sortie du résultat de l'exécution du code:
101
Que se passe-t-il si vous utilisez global dans une fonction, puis créez une variable avant de créer une variable en dehors de la fonction (variable globale) à l'avance, puis faites référence à cette variable en dehors de la fonction après avoir exécuté la fonction?
Écrivons le code et exécutons-le.
def define_global_variable():
global int_variable_2
int_variable_2 = 200
define_global_variable()
print(int_variable_2)
Contenu de sortie du résultat de l'exécution du code:
200
Cette fois, le nouveau nom de variable est ʻint_variable_2. La fonction est exécutée dans la partie define_global_variable (), les variables sont créées en tant que variables globales à l'intérieur de la fonction (global int_variable_2 et ʻint_variable_2 = 200), puis la variable est référencée (sortie) en dehors de la fonction. (Imprimer (variable_int_2)).
Vous pouvez voir que ce qui était une erreur quand il n'y avait pas de description de global peut afficher le contenu de la variable 200 sans erreur.
Dans la section précédente, nous avons confirmé qu'essayer d'accéder à une variable globale telle qu'un entier tel quel dans une fonction entraînerait une erreur.
Ce comportement est le même pour les chaînes non entières (str), les nombres à virgule flottante (float), les valeurs booléennes (bool) et d'autres types de valeurs.
En revanche, le comportement change pour les valeurs telles que les listes et les dictionnaires. Voyons comment ils diffèrent un par un.
Tout d'abord, créez une variable globale en dehors de la fonction et faites référence à cette variable à l'intérieur de la fonction (sans la description de global).
dict_variable = {'name': 'orange'}
def print_dict_variable():
print(dict_variable)
print_dict_variable()
Contenu de sortie du résultat de l'exécution du code:
{'name': 'orange'}
Je crée une variable globale dans le dictionnaire en dehors de la fonction (dict_variable = {'name': 'orange'}) et j'exécute la fonction (print_dict_variable ()). A l'intérieur de la fonction, le contenu de la variable globale du dictionnaire est affiché (print (dict_variable)).
Quand j'ai essayé avec des variables entières dans la section précédente, j'ai eu une erreur si je ne spécifiais pas la variable avec global (il a été jugé que la variable locale n'était pas générée) de cette manière d'écrire, mais dans le dictionnaire Dans le cas d'une variable globale, vous pouvez voir qu'aucune erreur ne se produit même si vous ne la spécifiez pas avec global, et la valeur peut être sortie correctement.
De cette manière, les variables globales peuvent être référencées dans des fonctions même dans des dictionnaires et d'autres listes. Veuillez noter que le comportement de la portée est différent de celui des entiers.
Ensuite, vérifions le comportement lorsqu'une variable locale est créée dans la fonction avec le même nom de variable que la variable globale (la spécification de «global» est omise).
dict_variable = {'name': 'orange'}
def change_dict_variable():
dict_variable = {'name': 'apple'}
change_dict_variable()
print(dict_variable)
Contenu de sortie du résultat de l'exécution du code:
{'name': 'orange'}
Commencez par créer une variable globale pour le dictionnaire (dict_variable = {'name': 'orange'}), puis exécutez la fonction (change_dict_variable ()). Dans la fonction, nous créons une nouvelle variable de dictionnaire avec le même nom que la variable globale (dict_variable = {'name': 'apple'}). Enfin, le contenu de la variable globale est imprimé en dehors de la fonction (print (dict_variable)).
Comme vous pouvez le voir à partir du résultat de sortie ({'name': 'orange'}), la valeur définie dans la fonction ({'name': 'apple'}) n'est pas reflétée et c'est une variable globale. La valeur au moment de la fabrication est la même.
Cela signifie que lorsque vous créez une nouvelle liste ou un nouveau dictionnaire dans une fonction, même s'il existe une variable globale portant le même nom, elle sera traitée comme une variable locale. En d'autres termes, lorsque le contenu de la fonction est terminé, le contenu de la variable locale sera perdu et, par conséquent, la valeur de la variable globale restera telle quelle.
C'est un peu compliqué. Même si vous ne vous souvenez pas de tout, ce n'est pas grave si vous pouvez vous en souvenir chaque fois que vous en avez besoin en exécutant le code et en l'essayant. Gardez simplement à l'esprit que le comportement de l'oscilloscope change en fonction des conditions.
Enfin, essayons le comportement dans le cas de la définition d'un nouveau dictionnaire en créant au préalable la variable globale du dictionnaire et en spécifiant la variable du même nom en utilisant global dans la fonction.
dict_variable = {'name': 'orange'}
def change_dict_variable():
global dict_variable
dict_variable = {'name': 'apple'}
change_dict_variable()
print(dict_variable)
Contenu de sortie du résultat de l'exécution du code:
{'name': 'apple'}
Seule la partie global dict_variable de la fonction a été ajoutée par rapport au code précédent. Cependant, cette description fait que la variable dict_variable est traitée comme une variable globale au lieu d'une variable locale, donc le résultat du traitement de sortie (print (dict_variable)) après l'exécution de la fonction est{'name': 'orange'}. Il a changé en{'name': 'apple'}(valeur définie dans la fonction) au lieu de(valeur lorsque la variable globale est définie).
De cette manière, le comportement change en fonction du type de valeur et si global est spécifié ou non. C'est compliqué, donc les idées suivantes peuvent vous aider à rester simple.
--Ne pas utiliser de variables globales, ni les minimiser même si elles sont utilisées (les arguments sont principalement utilisés car il existe de nombreux cas où ils peuvent être remplacés par la fonction appelée ** argument **, qui sera mentionnée plus loin). --Si vous souhaitez la traiter comme une variable globale, spécifiez-la globalement quelle que soit la valeur numérique ou le dictionnaire (ne l'omettez pas dans le dictionnaire, etc.).
En outre, déterminer si global est requis pour référencer des variables globales dans une fonction pour chaque type n'est pas une définition stricte, mais comme un index.
--Global doit être spécifié pour une seule valeur (entier, chaîne, etc.) --Global peut être omis pour les grandes valeurs (listes, dictionnaires, etc.) qui stockent plusieurs valeurs uniques.
Cela peut être plus facile à comprendre si vous vous en souvenez.
Bien sûr, vous pouvez réaliser un programme qui fonctionne même si vous écrivez le code tel quel sans fournir de fonction. Alors pourquoi utiliser des fonctions?
Il y a plusieurs raisons, mais les deux principales sont "réduire la duplication du code" et "rendre le code plus facile à lire".
Les exemples de code jusqu'à présent sont tous des codes courts, il peut donc être difficile de comprendre les avantages.
Cependant, dans le travail réel, nous avons souvent affaire à des programmes longs et des programmes contenant de nombreux fichiers. Les avantages des fonctions prennent vie dans des environnements aussi complexes.
Par exemple, supposons que vous écriviez environ 20 lignes de code au travail. À ce niveau, rien ne compte.
Cependant, un traitement similaire sera nécessaire à l'avenir, et 40 lignes seront doublées, et cela passera à 60 lignes ... En répétant, des centaines, des milliers, des dizaines de milliers de lignes. Cela deviendra .. Cela est particulièrement vrai pour des années de travail sur des projets.
Si vous écrivez le même code à chaque fois, il sera difficile de saisir le code. Puisque le nombre de variables sera énorme, il sera difficile de suivre le code tel que "Comment cette variable est-elle utilisée?", Et il sera difficile d'utiliser des variables indépendantes. De nombreuses erreurs se produiront.
Supposons également que le traitement requis dans le futur change et que vous deviez modifier le code. S'il existe des dizaines de codes similaires, il sera très difficile de changer le code sans se tromper. Si l'une des modifications est manquante, cela entraînera un bogue (également appelé bogue) ou une erreur.
Le travail d'écriture d'un programme nécessite des mises à jour fréquentes et des ajouts de fonctionnalités, ce qui peut être assez pénible.
D'autre part, que se passe-t-il si le traitement exécute la fonction et que le code de traitement réel est écrit à l'intérieur de la fonction?
Il vous suffit de modifier le code dans la fonction pour éviter toute omission de modifications. Les modifications nécessitent également très peu de travail.
En faisant bon usage des fonctions de cette manière, vous pouvez réduire le temps et le risque requis pour les modifications en transformant la partie de traitement dupliquée du code en fonction.
Un autre gros avantage est que le code est plus facile à lire, selon la façon dont vous utilisez la fonction.
Lors de la lecture d'un programme, moins il y a d'éléments, plus il est facile à lire. Par exemple, si le code contient environ 300 variables et qu'il existe de nombreuses branches conditionnelles qui apparaîtront dans les chapitres suivants, il sera très difficile de saisir le contenu avec précision et il est facile de faire des erreurs.
D'un autre côté, comme mentionné dans la portée de la section précédente, les fonctions ont la propriété que les variables locales sont "utilisées uniquement dans la fonction" et "les variables locales disparaissent lorsque la fonction se termine".
En raison de cette propriété, par exemple, si vous divisez un processus qui nécessite 300 variables en plusieurs fonctions et que vous le divisez en 5 ou plus pour chaque fonction, le code sera très facile à lire.
J'entends souvent des histoires comme «les humains peuvent se souvenir d'environ 3 à 9 éléments à la fois», mais il en va de même pour les programmes, et s'il y a plusieurs éléments à la fois, cela devient difficile à saisir et à retenir pendant une courte période. ..
Cela peut être similaire à mettre un trait d'union dans 3 ou 4 chiffres dans un numéro de téléphone, etc. et à le diviser pour le rendre plus facile à comprendre. En divisant par fonction et en réduisant le nombre de variables et de processus par fonction, vous pouvez rendre le code plus facile à comprendre et moins susceptible de commettre des erreurs comme le fractionnement d'un numéro de téléphone.
Un autre avantage est qu'il facilite l'écriture de tests en divisant beaucoup en fonctions qui nécessitent moins de traitement. Le contenu du test etc. sera assez avancé, donc je l'expliquerai en détail dans un chapitre ultérieur.
La création d'une fonction à l'aide de valeurs variables telles que des variables est plus polyvalente et plus facile à utiliser que le traitement d'une fonction utilisant uniquement des valeurs fixes.
Par exemple, il y a plus de cas où la fonction correspondante peut être utilisée en "calculant x par 3" avec une valeur arbitraire de x qu'en "calculant 5 x 3".
Vous pouvez utiliser n'importe quelle variable en utilisant les variables globales mentionnées dans la section précédente, mais dans de tels cas, il est courant d'utiliser une fonction appelée «argument» de la fonction. L'argument est appelé argument en anglais.
Bien qu'il soit nommé soustraction ** en japonais, il accepte les arguments non numériques dans le programme. Vous pouvez spécifier divers arguments tels que des chaînes de caractères, des valeurs booléennes et des listes.
En plus du sens d'un argument, l'argument anglais a également le sens de "discussion" et "argument", comme on peut s'y attendre d'après les mots anglais d'argue, qui signifie "discuter" et "argumenter".
À première vue, les arguments et l'argument semblent n'avoir rien à voir les uns avec les autres, mais dans le sens original, ils découlent de «la justification (raisons et preuves à l'appui de l'argument)» et «de rechercher d'autres quantités». Il semble que cela vienne du fait qu'il a changé comme "le montant initial utilisé pour".
Étant donné la propriété que le résultat du traitement de la fonction fluctue en fonction de la valeur de l'argument, le mot argument est un peu plus agréable.
Le mot argument en japonais peut avoir une signification similaire à quelque chose comme "valeur à transmettre à une fonction".
Vous pouvez transmettre n'importe quelle valeur à la fonction en utilisant un argument.
L'argument passé est traité comme une variable locale pour cette fonction. Puisque la section précédente a la propriété que «les variables locales ne sont utilisées que dans la fonction» et «les variables locales disparaissent lorsque la fonction se termine», le code est plus facile à lire et moins susceptible de faire des erreurs que l'écriture de code à l'aide de nombreuses variables globales. Je peux écrire.
Jusqu'à présent, dans l'exemple de code, nous avons créé des fonctions qui n'utilisent aucun argument.
Pour créer une fonction qui accepte des arguments, spécifiez le nom de l'argument entre les parenthèses ( et ) après le nom de la fonction.
Par exemple, dans le processus mentionné ci-dessus de "calcul de x à tripler avec une valeur arbitraire de x", écrivez def multiply_three (x): pour créer une fonction nommée multiply_three qui accepte x comme argument. Je vais.
Pour spécifier la valeur de l'argument lors de l'exécution de la fonction, définissez la valeur que vous souhaitez spécifier pour l'argument entre parenthèses de ( et ) au lieu d'écrire multiply_three (). Par exemple, si vous voulez spécifier 10 comme argument, écrivez multiplier_trois (10).
Écrivons le code, exécutons la fonction et vérifions le résultat.
def multiply_three(x):
multiplied_value = x * 3
print(multiplied_value)
multiply_three(10)
Contenu de sortie du résultat de l'exécution du code:
30
La fonction est exécutée dans la partie multiply_three (10), et 10 est spécifié comme argument. Dans la fonction (def multiply_three (x):), la valeur de x donnée à l'argument (x vaut 10 cette fois car c'est la valeur spécifiée à l'exécution) est triplée ( multiplied_value = x * 3).
Enfin, la valeur triplée est sortie par impression. Le résultat de sortie est 30, soit 3 fois 10.
Plus tôt, j'ai créé une fonction qui triple la valeur de x avec l'argument x. Modifions maintenant la valeur de "multiplier" par l'argument à l'exécution. Acceptez l'argument y au lieu de la triple partie.
Pour spécifier le deuxième argument et les suivants, ajoutez une virgule demi-largeur entre les arguments. Cela ne cause pas d'erreur même si vous ne mettez pas d'espace, mais comme il est stipulé dans la norme de codage Python de mettre un espace demi-largeur après la virgule, écrivez-le comme ça.
La partie argument de la fonction dans ce cas est un code tel que (x, y).
def multiply_x_by_y(x, y):
multiplied_value = x * y
print(multiplied_value)
multiply_x_by_y(10, 5)
Contenu de sortie du résultat de l'exécution du code:
50
Lors de l'exécution d'une fonction avec plusieurs arguments, définissez les valeurs séparées par des virgules demi-largeur. Si vous voulez mettre x à 10 et y à 5, écrivez la partie d'exécution de la fonction telle que multiplier_x_by_y (10, 5).
Dans le traitement à l'intérieur de la fonction, le code est multiplié par y au lieu du code triplé comme * 3 ( multiplied_value = x * y).
En conséquence, la valeur sortie par impression en multipliant 10 de x et 5 de y est 50.
Si vous souhaitez utiliser 3 arguments ou plus, vous pouvez définir n'importe quel nombre d'arguments en ajoutant des virgules. Par exemple, si vous souhaitez créer une fonction qui prend trois arguments, x, y et z, écrivez comme suit.
def multiply_x_y_z(x, y, z):
multiplied_value = x * y * z
print(multiplied_value)
multiply_x_y_z(10, 5, 3)
Contenu de sortie du résultat de l'exécution du code:
150
La partie argument a trois valeurs, (x, y, z), et même lors de l'exécution de la fonction, trois valeurs telles que multiply_x_by_y (10, 5, 3) sont spécifiées séparées par des virgules demi-largeur. Je vais.
Le résultat de sortie par impression est de 150 avec 10 x 5 x 3 des trois arguments de xyz.
De cette manière, plusieurs valeurs peuvent être définies pour l'argument, mais elles sont appelées dans l'ordre en tant que premier argument, deuxième argument, troisième argument, etc. Dans cette fonction, le premier argument de la fonction multiply_x_y_z est x, le deuxième argument est y et le troisième argument est z.
Par exemple, que se passe-t-il si une fonction qui accepte trois arguments spécifie seulement deux valeurs à l'exécution? Écrivons le code et essayons-le.
def multiply_x_y_z(x, y, z):
multiplied_value = x * y * z
print(multiplied_value)
multiply_x_y_z(10, 5)
Le contenu du code est une fonction qui accepte trois arguments, x, y, z, et ne transmet que deux valeurs aux arguments, comme` multiplier_x_y_z (10, 5) ʻà l'exécution (valeur de l'argument de z). N'est pas spécifié).
TypeError Traceback (most recent call last)
<ipython-input-27-8cab8c50c583> in <module>
4
5
----> 6 multiply_x_y_z(10, 5)
TypeError: multiply_x_y_z() missing 1 required positional argument: 'z'
Quand je l'ai essayé, une erreur s'est produite. Lisons le message d'erreur.
Manquant signifie «pas assez» et requis signifie «requis». argument était un mot anglais pour l'argument.
À peu près traduit, le message d'erreur est "Il n'y a pas assez d'arguments de position requis (non manquables) nommés" z "".
Une erreur se produira si les arguments requis ne sont pas spécifiés lorsque la fonction est exécutée de cette manière. Si vous obtenez cette erreur, vérifiez "Quels arguments manquent?" Et vérifiez le code que vous exécutez pour voir si le nombre d'arguments est correct.
Comme vous pouvez le voir dans le message d'erreur de la section précédente qui dit «argument positionnel requis» et que le message d'erreur est requis, vous pouvez également définir l'argument «non requis (facultatif)».
Ces arguments optionnels sont appelés "arguments optionnels" (arguments optionnels en anglais).
De plus, s'il est omis, «la valeur de l'argument» est spécifiée par ce qu'on appelle une «valeur par défaut». Pour définir la valeur par défaut de l'argument, définissez le symbole demi-largeur égal à = immédiatement après le nom de l'argument et la valeur par défaut que vous souhaitez définir. Par exemple, si vous souhaitez définir la valeur par défaut de 10 pour l'argument x, écrivez «x = 10».
Lors de la création de paramètres de variable, des espaces demi-largeur ont été insérés avant et après l'égal, mais la convention de codage Python correcte n'est pas d'insérer des espaces avant et après l'égal dans l'argument par défaut. Veuillez noter qu'il est différent des paramètres variables.
Même si vous insérez un espace, aucune erreur ne se produira, mais le code ne sera pas conforme aux normes de codage.
Écrivons le code et essayons-le.
def print_x(x=10):
print(x)
Le contenu est une fonction simple qui imprime simplement la valeur spécifiée dans l'argument avec print. Il n'y a qu'un seul argument nommé x.
Assurez-vous que la partie argument est «x = 10». Il s'agit de la description que «si la spécification d'argument de x est omise, la valeur par défaut de 10 est définie».
Exécutons la fonction. Tout d'abord, exécutons-le sans omettre l'argument de x. Spécifiez 30 pour l'argument x.
print_x(30)
Contenu de sortie du résultat de l'exécution du code:
30
La valeur 30 spécifiée dans l'argument a été sortie.
De cette façon, si vous spécifiez la valeur sans omettre l'argument pour lequel la valeur par défaut est définie, vous pouvez voir que la valeur spécifiée a la priorité (30 cette fois) et la valeur par défaut de 10 est ignorée.
Cette fois, je vais omettre l'argument et l'exécuter. Notez qu'il n'y a rien entre les parenthèses de ( et ) (la valeur de l'argument n'est pas spécifiée).
print_x()
Contenu de sortie du résultat de l'exécution du code:
10
Par conséquent, 10, qui est défini comme valeur par défaut de l'argument, est affiché.
De cette façon, lorsque la valeur par défaut est définie comme argument,
--Lorsqu'une valeur est spécifiée pour l'argument -> La valeur spécifiée est définie. --Si l'argument est omis -> La valeur par défaut de l'argument est définie.
Cela devient le comportement.
La valeur par défaut est utilisée principalement dans des cas tels que «généralement, cette valeur par défaut est correcte, mais vous voulez changer la valeur de temps en temps».
Inversement, vous ne devez pas définir de valeur par défaut dans les cas où la valeur spécifiée pour l'argument est fondamentalement différente à chaque fois.
Dans de tels cas, la fonction doit être créée de telle manière que des arguments normaux soient requis. Si vous devez spécifier un argument à chaque fois, mais si vous oubliez accidentellement de le spécifier et que la valeur par défaut est définie (même si vous oubliez de spécifier l'argument), une erreur ne se produira pas et vous ne remarquerez peut-être pas l'erreur. Parce que cela peut être fait.
En outre, lors de la définition d'un argument avec une valeur par défaut, il existe une règle selon laquelle "l'argument pour lequel la valeur par défaut est définie doit venir après l'argument requis".
Par exemple, si vous définissez un argument (x = 10) qui a une valeur par défaut suivie d'un argument obligatoire ( y) qui n'a pas de valeur par défaut dans la fonction comme indiqué ci-dessous, une erreur se produira.
def multiply_x_by_y(x=10, y):
multiplied_value = x * y
print(multiplied_value)
File "<ipython-input-34-13a53a0612f1>", line 1
def multiply_x_by_y(x=10, y):
^
SyntaxError: non-default argument follows default argument
Lorsque le message d'erreur est traduit, ce sera quelque chose comme "Un argument qui n'a pas de valeur par défaut vient après un argument qui a une valeur par défaut."
En effet, lorsque vous exécutez une fonction telle que multiply_x_by_y (10), le premier argument peut être omis tandis que le deuxième argument ne peut pas être omis (il n'y a pas de valeur par défaut), donc `(10) C'est parce que le programme ne peut pas déterminer si la valeur de) ʻest la valeur de x dans le premier argument ou la valeur de y dans le deuxième argument.
Par conséquent, l'argument avec la valeur par défaut doit être placé après l'argument requis. Comme indiqué ci-dessous, dans le cas de la définition d'un argument optionnel avec deux arguments x et y, le côté x est l'argument requis et le côté y a la valeur par défaut, cela fonctionne sans erreur.
def multiply_x_by_y(x, y=10):
multiplied_value = x * y
print(multiplied_value)
Dans le cas où cette erreur ne se produit pas, si vous spécifiez un seul argument tel que multiply_x_by_y (30) et que vous l'exécutez, vous pouvez voir que c'est la valeur pour x du premier argument requis, et `multiply_x_by_y (30, 20) Même si vous spécifiez les deux valeurs sans omettre ʻet l'argument, le code peut être interprété côté programme sans aucun problème, tel que la valeur de x est 30 et la valeur de y est 20.
Même s'il y a plusieurs arguments requis, l'argument avec la valeur par défaut doit les suivre.
Par exemple, comme indiqué ci-dessous, il n'est pas possible de définir l'argument requis z après l'argument requis x suivi de l'argument y avec la valeur par défaut (une erreur se produira).
def multiply_x_y_z(x, y=20, z):
multiplied_value = x * y * z
print(multiplied_value)
File "<ipython-input-39-81a253f339fe>", line 1
def multiply_x_y_z(x, y=20, z):
^
SyntaxError: non-default argument follows default argument
Même s'il y a plusieurs arguments requis comme celui-ci, l'argument avec la valeur par défaut (z = 20) doit être amené après l'argument requis sans la valeur par défaut comme indiqué ci-dessous.
def multiply_x_y_z(x, y, z=20):
multiplied_value = x * y * z
print(multiplied_value)
Même si vous souhaitez définir plusieurs arguments avec des valeurs par défaut, aucune erreur ne se produira s'ils viennent après les arguments requis. Par exemple, si vous voulez que les arguments y et z aient des valeurs par défaut, aucune erreur ne se produira si chacun d'eux suit l'argument requis x qui n'a pas de valeur par défaut, comme indiqué ci-dessous.
def multiply_x_y_z(x, y=20, z=30):
multiplied_value = x * y * z
print(multiplied_value)
Par exemple, supposons que vous ayez une fonction avec de nombreux arguments comme celui-ci:
def calculate_cost(manufacturing_cost, labor_cost, delivery_cost, tax):
sum_value = manufacturing_cost + labor_cost + delivery_cost + tax
return sum_value
Lorsque j'essaye d'exécuter la fonction, cela ressemble à ceci:
calculate_cost(1000, 400, 150, 50)
Avec ce nombre, vous pouvez comprendre à quel argument correspond chaque valeur. Cependant, cela semble difficile à comprendre et il est probable que vous fassiez par inadvertance une erreur dans la commande.
Et si le nombre d'arguments augmentait encore? Par exemple, imaginez une fonction qui nécessite 10 arguments, ou une fonction qui nécessite 15 arguments.
Il semble très difficile de spécifier les valeurs des arguments dans l'ordre sans se tromper. Imaginez également le cas où la fonction change fréquemment le nombre d'arguments avec des mises à jour. S'il n'y a pas d'arguments au milieu, l'ordre des arguments suivants sera dans le désordre, ce qui est très déroutant.
En guise de contre-mesure pour de tels cas, il existe une fonction appelée «arguments de mots clés» en Python.
En utilisant des arguments de mot-clé, vous pouvez écrire du code facile à lire même pour les fonctions avec de nombreux arguments.
Écrivons en fait le code de la partie exécution de la fonction. Pour utiliser des arguments de mots-clés, vous pouvez les utiliser en les écrivant sous la forme ʻargument name = valeur spécifiée dans l'argumentà l'emplacement d'exécution de la fonction. Par exemple, dans l'exemple de fonction de code ci-dessus, pour utiliser l'argument de mot-clé avec l'argumentManufacturing_cost, écrivez Manufacturing_cost = 1000`.
Lorsque vous spécifiez plusieurs autres fonctions, la règle de les séparer par une virgule demi-largeur est généralement la même que celle de l'argument.
calculate_cost(
manufacturing_cost=1000,
labor_cost=400,
delivery_cost=150,
tax=50)
En utilisant des arguments de mots-clés, il est maintenant possible de voir rapidement de quel argument la valeur de chaque argument est. Par exemple, delivery_cost vaut 150.
De plus, si vous utilisez des arguments de mot-clé, le code du nom de l'argument devient long horizontalement et il devient difficile à lire, donc dans le code ci-dessus, un saut de ligne est inséré pour chaque argument.
Comme mentionné ci-dessus, les arguments de mots-clés ont plusieurs mérites en plus des mérites de "une fonction avec de nombreux arguments facilite la compréhension du contenu et rend les erreurs moins susceptibles de se produire".
Par exemple, il est utile dans le cas d'une fonction qui a de nombreux arguments avec des valeurs par défaut, comme "Je veux définir une valeur spécifique pour certains de ces derniers arguments seulement".
Supposons que vous ayez une fonction comme celle-ci:
def multiply_x_y_z(x=10, y=20, z=30):
multiplied_value = x * y * z
print(multiplied_value)
Cette fonction a des valeurs par défaut pour tous les arguments x, y et z (les arguments peuvent être omis).
Imaginez un cas où vous devez changer uniquement l'argument z à une valeur de 100 avec cette fonction. Si vous spécifiez un argument normal, vous devez spécifier les valeurs dans l'ordre, donc si vous essayez de spécifier la valeur de z, vous devez spécifier la même valeur pour x et y comme valeur par défaut (`multiply_x_y_z (10, 20, 100) ) »).
S'il y a environ 3 arguments, cela deviendra douloureux à mesure que le nombre d'arguments augmente. Surtout dans les cas où ce dernier argument est utilisé plus fréquemment, cela devient plus douloureux (même si les arguments sont définis par ordre de priorité au moment de l'écriture du code, il sera en retard en raison du passage du temps ou des mises à jour, etc. Il est possible que l'argument de soit plus important).
Et si le code est mis à jour et que les valeurs par défaut des fonctions changent? Par exemple, supposons que la valeur par défaut d'une fonction soit mise à jour en def multiply_x_y_z (x = 100, y = 200, z = 300):.
Dans un tel cas, si le côté exécution de la fonction (code tel que multiply_x_y_z (10, 20, 100)) n'est pas mis à jour sans omission, on dit que "la même valeur que la valeur par défaut a été assumée et spécifiée". Dans certains cas, il peut se comporter de manière inattendue (s'il y a de nombreux endroits où la fonction est exécutée, il sera difficile de la corriger sans erreur).
D'autre part, les arguments de mot-clé vous permettent d'exécuter une fonction en spécifiant directement une valeur uniquement pour l'argument avec un nom d'argument spécifique.
Par exemple, si vous souhaitez spécifier la valeur uniquement pour l'argument de z et définir les autres valeurs comme valeurs par défaut, vous pouvez écrire comme suit.
multiply_x_y_z(100)
En écrivant de cette manière, vous pouvez réduire la description supplémentaire et vous pouvez réduire l'effet lorsque la valeur par défaut est modifiée dans la fonction.
Un autre point à considérer avec les arguments de mot-clé est que «les arguments qui prennent des valeurs par défaut doivent être spécifiés comme arguments de mot-clé».
En ce qui concerne l'argument qui prend la valeur par défaut, en raison de la propriété que le paramètre est arbitraire (ce n'est pas nécessaire), il peut être ajouté ou supprimé en raison de mises à jour quotidiennes, ou l'ordre des arguments peut être modifié. Il y a des cas à faire.
Par conséquent, fondamentalement, si vous spécifiez l'argument avec la valeur par défaut comme argument de mot-clé à chaque fois, il sera difficile d'être affecté et le code sera robuste de sorte que ce n'est pas grave si l'ordre des arguments avec la valeur par défaut est modifié.
Ne devrait-on pas changer la fonction référencée? Vous pouvez penser que, au travail, j'utilise souvent des bibliothèques créées par d'autres personnes (comme une collection de code pratique et à usage général), mais ces bibliothèques sont anciennes pour des raisons de sécurité. Dans certains cas, vous devrez mettre à jour car le support a expiré dans la version.
Dans de tels cas, utilisez les arguments de mots clés de manière appropriée pour réduire le nombre de choses bloquées dans la mise à jour ou provoquant des bogues.
C'est un peu comme la différence de comportement entre les variables globales et locales pour chaque type mentionné dans la section précédente, mais les arguments ont aussi les concepts de "passage par valeur" et "passage par référence".
Bien qu'il soit un peu difficile de comprendre la signification du japonais, chacun présente les caractéristiques suivantes.
Selon le type de valeur, le comportement est divisé en passant par valeur et en passant par référence.
--Integer (int), nombre à virgule flottante (float), string (str), valeur booléenne, etc.-> Passer par valeur --Dictionnaires, listes, etc.-> Passage par référence
Ce sera.
C'est difficile à comprendre, alors écrivons un code et essayons-le.
Tout d'abord, essayons le cas de la spécification d'un entier comme argument, qui est passé par valeur.
def add_one_to_x(x):
x += 1
cat_age = 10
add_one_to_x(x=cat_age)
print(cat_age)
Contenu de sortie du résultat de l'exécution du code:
10
Tout d'abord, nous créons une variable nommée cat_age en dehors de la fonction. La valeur est définie sur 10.
Après cela, la fonction est exécutée dans la partie ʻadd_one_to_x (x = cat_age) , et la variable cat_age` est spécifiée comme valeur d'argument.
Dans la fonction, 1 est ajouté à la valeur de l'argument, et enfin la valeur de la variable est sortie par print (cat_age).
Le résultat de sortie est 10 (et non 11) même si 1 est ajouté dans la fonction.
La variable cat_age spécifiée dans l'argument cette fois est une valeur entière. Par conséquent, il est passé par valeur, et en passant par valeur, la valeur est copiée et transmise à la fonction (passée comme quelque chose de différent de la variable d'origine), donc même si la valeur est mise à jour dans la fonction, la variable d'origine sera affectée. Il reste à 10 sans.
Essayons maintenant d'écrire du code pour un cas où la référence est passée par valeur. Auparavant, j'ai spécifié une valeur entière comme argument, mais cette fois je vais spécifier un dictionnaire comme argument.
my_age = 25
my_age += 2
print(my_age)
Contenu de sortie du résultat de l'exécution du code:
27
Tout d'abord, la variable cat_info_dict est définie sur un dictionnaire avec la clé ʻage`.
Après cela, la fonction est exécutée et la variable cat_info_dict est spécifiée comme argument.
Dans la fonction, 1 est ajouté à la valeur de la clé de ʻage` du dictionnaire spécifié dans l'argument.
Enfin, print imprime le contenu de la variable cat_info_dict.
Comme vous pouvez le voir à partir du résultat de sortie, la mise à jour de la valeur du dictionnaire exécuté dans la fonction est reflétée dans la variable d'origine, et le résultat de la clé de ʻage` du dictionnaire est 11. Je vais.
Lorsqu'un dictionnaire ou une liste est spécifié de cette manière, la référence est passée par valeur et la variable d'origine est également modifiée.
Étant donné que le comportement change en fonction du type, il existe deux cas où la variable est censée être mise à jour mais est «mise à jour» et où la variable est censée être mise à jour mais pas mise à jour. Soyez prudent car il est facile de faire des erreurs par inadvertance.
Au fait, pourquoi le comportement change-t-il en fonction du type comme celui-ci? Il y a deux raisons principales, et la première est que «fondamentalement, comme les variables locales, les erreurs peuvent être réduites s'il n'y a aucun effet en dehors de la fonction».
Comme mentionné dans la section sur les variables locales et les variables globales, les variables locales disparaissent après la fin de l'exécution de la fonction. Par conséquent, il est plus sûr de gérer le code en termes de moins de probabilités d'erreurs, telles qu'un grand nombre de variables créées dans la zone en dehors de la fonction et ne pouvant pas être référencées par d'autres fonctions.
Lorsqu'un entier ou une chaîne de caractères est passé par valeur, il est traité de la même manière qu'une variable locale. En d'autres termes, lorsque la fonction termine son exécution, la valeur spécifiée dans l'argument (la valeur copiée à partir de la variable d'origine, etc.) est ignorée.
Cela permet une implémentation sécurisée similaire à l'utilisation de variables locales.
Alors pourquoi les listes et les dictionnaires sont-ils passés par référence, non copiés, mais comme arguments? Pourquoi est-il plus sûr de le copier et de le traiter comme une variable locale?
La raison en est que les listes et les dictionnaires peuvent stocker beaucoup de nombres et de chaînes de caractères, donc si vous les copiez, la charge de traitement augmentera.
Par exemple, que faire si la liste contient des millions de nombres? Si la liste est copiée à chaque fois que la fonction est exécutée, le temps de traitement sera long, et si de nombreuses listes aussi volumineuses sont copiées, une grande quantité de mémoire de l'ordinateur personnel sera nécessaire (spécification). Il sera difficile d'exécuter le code sur un ordinateur bas).
Par conséquent, afin de réduire la charge lors de l'exécution des fonctions, dans le cas des listes et des dictionnaires, la valeur de la variable est transmise telle quelle sans être copiée par valeur. Le fait que la valeur soit passée à l'argument sans être copiée de cette manière est le deuxième avantage que la fonction peut être exécutée avec moins de charge.
Dans cet esprit, n'est-il pas préférable de transmettre les nombres et les chaînes de caractères sans les copier? Cependant, même si la valeur numérique ou la valeur d'une seule chaîne de caractères est copiée, il s'agit d'un chargement qui peut être considéré comme presque une "erreur" s'il s'agit d'un ordinateur personnel récent (sauf lorsqu'une chaîne de caractères trop longue est spécifiée). ).
Si la charge est telle que la valeur est copiée et traitée comme une variable locale, il y a un grand avantage en termes de sécurité, donc la valeur est copiée comme passant par valeur.
Pour cette raison, le comportement de passage par valeur et de passage par référence diffère selon le type en fonction des avantages et des inconvénients.
Soyez prudent, car cela peut conduire à des erreurs en cas de confusion.
Cependant, c'est un concept difficile à comprendre tant que vous ne vous y êtes pas habitué, il n'y a donc pas de problème si vous les apprenez en vous habituant à la programmation petit à petit. Tant que vous continuez à écrire le code, vous rencontrerez probablement "ne pas se comporter comme prévu" en passant par valeur dans le futur ou par référence.
En acquérant une telle expérience, vous vous en souviendrez progressivement et naturellement. Donnez la priorité à l'écriture de code sans vous précipiter.
Dans la section précédente pass-by-value, j'ai écrit que les valeurs telles que les entiers et les chaînes d'arguments sont copiées et transmises, et que les modifications de ces valeurs à l'intérieur de la fonction ne sont pas reflétées en dehors de la fonction.
Cependant, il existe de nombreux cas où vous souhaitez recevoir le résultat d'une fonction et le définir dans une variable en dehors de la fonction.
Dans un tel cas, il peut être réalisé en utilisant la fonction appelée valeur de retour (également appelée valeur de retour ou valeur de retour) de la fonction. La valeur de retour est la valeur de retour en anglais.
Lors de la définition de la valeur de retour dans la fonction, écrivez-la comme return return value dans la fonction.
Écrivons le code et déplaçons-le. Dans le code ci-dessous, la partie return added_value de la fonction est la description de la relation de valeur de retour.
def add_one(x):
added_value = x + 1
return added_value
returned_value = add_one(x=10)
print(returned_value)
Contenu de sortie du résultat de l'exécution du code:
11
Lorsque vous exécutez une fonction dont la valeur de retour est définie, la valeur est renvoyée. Vous pouvez obtenir le contenu de la valeur renvoyée en définissant la valeur dans une variable ou autre.
Dans le code ci-dessus, la partie de valeur_retournée = add_one (x = 10) est applicable. ʻAdd_one (x = 10) La fonction est exécutée dans la pièce, et la valeur est retournée, il est donc possible d'obtenir la valeur de la valeur de retour définie dans la fonction par la description qui définit la valeur sur la variable Valeur_retournée =`. Je peux le faire.
Le contenu de la fonction consiste simplement à ajouter 1 à la valeur spécifiée dans l'argument x et à renvoyer cette valeur (return added_value).
Si vous essayez de sortir la valeur de la valeur de retour (print (returned_value)), vous pouvez voir que 11 est généré suite à l'ajout de 1 dans la fonction.
La description de «return» a le sens de «arrêter le traitement de la fonction» en plus de définir la valeur de retour. Si la partie «return» est rencontrée dans la fonction, le traitement de la fonction y est arrêté et le traitement suivant n'est pas exécuté.
Si vous souhaitez seulement arrêter le processus, vous pouvez écrire uniquement return sans définir la valeur de retour.
Par exemple, s'il y a une description de «return» juste en dessous de la fonction comme indiqué ci-dessous, le traitement suivant ne sera pas exécuté.
def add_one(x):
return
added_value = x + 1
return added_value
returned_value = add_one(x=20)
print(returned_value)
Contenu de sortie du résultat de l'exécution du code:
None
Puisqu'il existe une description de «return» au début de la fonction, le traitement suivant n'est pas exécuté. Le traitement s'arrêtera à ce point de «retour».
En d'autres termes, le traitement suivant de ʻadded_value = x + 1 et return added_value` ne sera pas exécuté.
Même si vous exécutez réellement la fonction (valeur_retournée = add_one (x = 20)) et affichez le résultat (print (valeur_retournée)), le résultat de plus 1 n'est pas affiché et le contenu est Aucun. Ce sera une sortie. None est une valeur comme "rien", dont nous parlerons plus en détail dans un chapitre ultérieur. Puisque le traitement est arrêté sans définir la valeur de retour uniquement avec return, la valeur de retour est None.
Le résultat du calcul, etc. n'est pas retourné, et vous pouvez voir que la partie telle que return added_value n'est pas exécutée.
Dans la situation actuelle, quel est le contrôle pour arrêter le traitement d'une telle fonction au milieu? Bien que cela semble être le cas, c'est utile pour le branchement conditionnel qui sera appris dans les chapitres suivants. Par exemple, vous pourrez contrôler des éléments tels que "arrêter le traitement dans des conditions XX".
Vous pouvez définir plusieurs valeurs pour la valeur de retour. Dans ce cas, définissez plusieurs valeurs séparées par des virgules demi-largeur.
Par exemple, dans le code ci-dessous, plusieurs valeurs de retour sont définies séparées par des virgules dans la partie return added_x, added_y.
def add_one(x, y):
added_x = x + 1
added_y = y + 1
return added_x, added_y
returned_x, returned_y = add_one(x=100, y=200)
print('returned_x:', returned_x, 'returned_y:', returned_y)
Contenu de sortie du résultat de l'exécution du code:
returned_x: 101 returned_y: 201
Le contenu de la fonction est qu'elle reçoit deux arguments, x et y, plus 1 pour chacun, et renvoie les deux comme valeurs de retour.
Comme vous pouvez le voir dans la partie return_x, returned_y = add_one (x = 100, y = 200), la partie de la valeur à définir dans la variable après l'exécution de la fonction doit également être définie séparée par des virgules.
Enfin, le contenu de la valeur de retour est imprimé par print (print ('returned_x:', returned_x, 'returned_y:', returned_y)).
Comme nous le verrons plus en détail dans un chapitre ultérieur, print peut également imprimer plusieurs valeurs en même temps, séparées par des virgules (imprimer un total de quatre valeurs pour imprimer deux chaînes comme étiquettes et les valeurs de deux variables). Spécifié).
Si vous vérifiez le contenu de la sortie, vous pouvez vérifier la valeur obtenue en ajoutant la valeur spécifiée pour x et y de l'argument plus 1 dans chaque variable de valeur de retour.
La définition de la valeur de retour de plusieurs valeurs est pratique, mais tout comme il est facile de faire des erreurs si vous essayez d'utiliser de nombreux arguments avec des arguments normaux au lieu d'arguments de mots clés, il est facile d'induire des erreurs avec de nombreuses valeurs de retour. Contrairement au côté argument, il n'y a pas de fonction telle que la valeur de retour du mot-clé, alors utilisons-la modérément pour qu'elle n'augmente pas trop.
Importance: ★★ ☆☆☆ (Vous n'avez pas à savoir au début)
Supposons que vous ayez une fonction (ʻadd_three_value) qui prend trois arguments, x, y et z, comme dans le code ci-dessous. J'ai également une variable de liste (ʻargument_list) qui stocke trois valeurs, et je veux les spécifier dans l'ordre.
def add_three_value(x, y, z):
total = x + y + z
return total
argument_list = [10, 20, 30]
Étant donné que chacune des trois valeurs de l'argument doit être spécifiée sous la forme d'un entier, le nombre d'arguments ne correspond pas simplement en spécifiant la liste telle quelle (un seul argument est spécifié et les deux arguments restants ne sont pas suffisants. ) Entraînera l'erreur.
add_three_value(argument_list)
TypeError: add_three_value() missing 2 required positional arguments: 'y' and 'z'
Dans le cas où vous souhaitez spécifier la valeur dans la liste pour chaque argument comme celui-ci, comme moyen spécial d'écrire en Python, définissez l'astérisque demi-largeur * immédiatement avant la variable de liste dans la spécification de valeur au moment de l'exécution de la fonction. Ensuite, le contenu de la liste sera assigné aux arguments dans l'ordre.
Dans l'exemple de code ci-dessous, la partie de code * argument_list est applicable.
returned_value = add_three_value(*argument_list)
print(returned_value)
Contenu de sortie du résultat de l'exécution du code:
60
Cette fois, cela fonctionne sans erreur. Vous pouvez également voir à partir de la sortie que x, y et z reçoivent respectivement 10, 20 et 30 du contenu de la liste et qu'un total de 60 valeurs est renvoyé.
Cette méthode d'écriture utilisant un astérisque développe le contenu de la liste et l'alloue aux arguments, donc si le nombre d'arguments et le nombre de valeurs de la liste ne correspondent pas, une erreur se produira.
Par exemple, si vous spécifiez une liste contenant 4 valeurs pour une fonction qui reçoit 3 arguments comme indiqué ci-dessous, une erreur se produira.
def add_three_value(x, y, z):
total = x + y + z
return total
argument_list = [100, 200, 300, 400]
add_three_value(*argument_list)
TypeError: add_three_value() takes 3 positional arguments but 4 were given
En regardant le message d'erreur, il dit quelque chose comme "La fonction add_three_value () nécessite 3 arguments, mais 4 valeurs sont spécifiées", et le nombre d'arguments de la fonction et le réel Vous pouvez voir qu'une erreur s'est produite en raison d'une non-concordance dans le nombre de valeurs spécifiées dans.
Cependant, si les valeurs par défaut mentionnées dans la section précédente sont définies et incluent des arguments facultatifs, peu importe si le nombre d'arguments et le nombre de valeurs de la liste ne correspondent pas. Comme indiqué ci-dessous, dans une fonction qui a trois arguments x, y et z, si la valeur par défaut est définie pour z (z peut être omis), le nombre d'éléments dans la liste peut être de 2 ou 3, et une erreur se produira. (Puisque 2 éléments ne peuvent pas être omis, une erreur se produira si une liste avec 1 valeur est spécifiée).
La liste peut être gérée en spécifiant un astérisque. Mais qu'en est-il des arguments de mots clés? Par exemple, dans le cas suivant, vous souhaitez spécifier un dictionnaire avec des noms d'argument définis dans les clés pour une fonction qui a trois arguments x, y et z comme précédemment.
def add_three_value(x, y, z):
total = x + y + z
return total
argument_dict = {
'x': 10,
'y': 20,
'z': 30,
}
Si vous souhaitez spécifier une valeur en Python en tant qu'argument de mot-clé à l'aide d'un tel dictionnaire, vous pouvez le gérer en définissant deux symboles astérisque demi-largeur immédiatement avant la valeur de l'argument lors de l'exécution de la fonction. Mettez deux astérisques devant le dictionnaire, par exemple «** argument_dict».
total = add_three_value(**argument_dict)
print(total)
Contenu de sortie du résultat de l'exécution du code:
60
Même avec la méthode de spécification des arguments de mot-clé à l'aide de ce dictionnaire, une erreur se produira si les arguments de mot-clé ne sont pas suffisamment spécifiés, à l'exception des arguments pour lesquels des valeurs par défaut sont définies, comme dans le cas de la liste. Par exemple, si vous essayez d'exécuter le code dans la fonction ci-dessus sans l'argument mot-clé de y inclus dans le dictionnaire, l'erreur suivante se produit.
def add_three_value(x, y, z):
total = x + y + z
return total
argument_dict = {
'x': 10,
'z': 30,
}
add_three_value(**argument_dict)
TypeError: add_three_value() missing 1 required positional argument: 'y'
Normalement, une erreur se produit si vous spécifiez plus de valeurs que le nombre défini dans la fonction comme arguments, comme dans le cas où 3 arguments sont spécifiés pour une fonction qui accepte 2 arguments dans le code suivant.
def add_two_value(x, y):
total = x + y
return total
add_two_value(100, 200, 300)
TypeError: add_two_value() takes 2 positional arguments but 3 were given
Quand je lis le message d'erreur, il dit quelque chose comme "La fonction add_two_value prend deux arguments, mais trois arguments sont spécifiés." De cette manière, le nombre d'arguments qu'une fonction peut accepter est fondamentalement limité.
D'autre part, si vous acceptez un nombre quelconque d'arguments, vous pouvez implémenter un comportement flexible avec une fonction, comme "calculer avec la valeur de 3 arguments" ou "calculer avec la valeur de 5 arguments". ..
Pour créer une telle fonction, utilisez un astérisque demi-largeur dans la partie argument de la fonction de la même manière que lors de l'exécution de la fonction. Quant au nom de l'argument, le nom «args» est souvent utilisé comme "groupe d'arguments de fonctions arbitraires" par convention. Souvent utilisé sous la forme «* args» avec un astérisque.
L'argument * args est défini dans un taple (il ressemble à la liste mentionnée dans le chapitre précédent où les changements de valeur ne fonctionnent pas).
def print_args(*args):
print(args)
Le contenu de la fonction affiche simplement le contenu de l'argument «* args» passé.
Essayons-le avec 3 arguments.
print_args(100, 200, 300)
Contenu de sortie du résultat de l'exécution du code:
(100, 200, 300)
Si vous regardez le contenu de sortie de * args, vous pouvez voir que celui qui stocke les trois valeurs est correctement sorti. De plus, vous pouvez voir que même si la fonction n'a que «* args» comme argument, aucune erreur ne se produit même si trois arguments sont spécifiés.
Maintenant, exécutons la fonction avec 5 arguments.
print_args(100, 200, 300, 400, 500)
Contenu de sortie du résultat de l'exécution du code:
(100, 200, 300, 400, 500)
Il peut être confirmé que le contenu des arguments spécifiés et 5 est affiché dans la fonction sans aucune erreur.
De plus, l'argument ʻargs défini par la description comme * argspeut également faire référence à la valeur par index comme une liste. Par exemple, si vous voulez faire référence à la première valeur (index de 0), vous pouvez accéder à la première valeur de l'argument en écrivant ʻargs [0].
Dans le code ci-dessous, le premier argument est imprimé dans la fonction, et par conséquent, les 100 premiers sont affichés (print (args [0])).
def print_args(*args):
print(args[0])
print_args(100, 200, 300)
Contenu de sortie du résultat de l'exécution du code:
100
Auparavant, j'ai créé une fonction qui accepte n'importe quel nombre d'arguments. Ensuite, j'expliquerai la fonction qui accepte les arguments de mots-clés avec des noms d'arguments arbitraires.
Comme avec les arguments normaux, si vous spécifiez un argument qui n'est pas défini dans la fonction tel qu'il est avec un argument de mot-clé, une erreur se produira comme indiqué dans le code ci-dessous (l'argument de mot-clé x qui n'existe pas dans l'argument de fonction est spécifié).
def multiply_two():
return x * 2
multiply_two(x=100)
TypeError: multiply_two() got an unexpected keyword argument 'x'
Quand je lis le message d'erreur, il dit quelque chose comme "La fonction multiply_two a reçu un argument mot-clé inattendu de x". Ce message d'erreur se produit car l'argument x est spécifié même si l'argument x n'est pas défini.
Pour que la fonction accepte des arguments de mot-clé arbitraires, définissez deux astérisques à un octet dans une ligne immédiatement avant le nom de l'argument dans l'argument de la fonction. Le nom d'argument «kwargs» est souvent utilisé pour cet argument. Le nom de l'argument est une version abrégée de l'argument de mot clé anglais ** k ** ey ** w ** ou ** ar ** guidance ** s . Il s'écrit « kwargs» avec deux astérisques.
Écrivez le code et essayez-le.
def print_kwargs(**kwargs):
print(kwargs)
print_kwargs(x=100, y=200)
Contenu de sortie du résultat de l'exécution du code:
{'x': 100, 'y': 200}
Chaque argument de mot-clé spécifié est stocké dans kwargs. kwargs est un dictionnaire, et les noms d'argument (x et y dans cet exemple) sont définis dans la clé et chaque valeur (100 et 200 dans cet exemple) est stockée.
[1] Créons une fonction qui prend un argument entier, double la valeur de cet argument et le renvoie. Exécutons également la fonction et sortons la valeur de retour reçue avec print. Le nom de l'argument peut être n'importe quoi.
[2]. Le code suivant a généré une erreur. Corrigeons-le pour qu'il ne provoque pas d'erreur.
def print_value(value):
print(value)
File "<ipython-input-21-def08fe6f21b>", line 2
print(value)
^
IndentationError: expected an indented block
[1]. Pour créer une fonction, écrivez def function name ():. De plus, puisque la question dit "recevoir un argument entier", l'exemple de réponse définit l'argument x (un autre nom est acceptable).
def multiply_two(x):
x *= 2
return x
multiplied_x = multiply_two(100)
print(multiplied_x)
Contenu de sortie du résultat de l'exécution du code:
200
De plus, pour définir la valeur de retour, écrivez return return value dans la fonction. Dans le code ci-dessus, la partie «return x» est applicable.
[2]. Un retrait est requis dans la fonction. Le retrait est défini avec 4 espaces demi-largeur. Même si le nombre d'espaces est différent de 4 (2 etc.), aucune erreur ne se produira, mais comme la norme de codage Python stipule 4 espaces, définissez 4 espaces sauf s'il y a une raison particulière. Je vais.
Si le code est indenté avant la partie print (value) comme indiqué ci-dessous, aucune erreur ne se produira.
def print_value(value):
print(value)
[1]. Lorsque j'ai créé et exécuté une fonction de traitement qui ajoute 1 à une variable appelée dog_age comme indiqué ci-dessous, une erreur s'est produite. Modifions le code pour qu'il n'y ait aucune erreur.
dog_age = 10
def increment_dog_age():
dog_age += 1
increment_dog_age()
UnboundLocalError Traceback (most recent call last)
<ipython-input-23-37cd012f49bf> in <module>
6
7
----> 8 increment_dog_age()
<ipython-input-23-37cd012f49bf> in increment_dog_age()
3
4 def increment_dog_age():
----> 5 dog_age += 1
6
7
UnboundLocalError: local variable 'dog_age' referenced before assignment
[2] Créons une fonction qui accepte trois arguments x, y et z et renvoie la somme de chaque argument. Essayez également d'exécuter cette fonction et imprimez le résultat.
[1]. La variable «dog_age» est un entier. Les variables globales entières ne peuvent pas être référencées directement dans une fonction. Pour faire référence à une variable globale entière dans une fonction, vous devez spécifier «global» et la variable, ou la traiter comme une variable locale en utilisant des arguments et des valeurs de retour.
Dans le cas où vous spécifiez «global» dans la fonction, écrivez comme suit. Vous pouvez voir qu'il s'exécute sans erreur et que la valeur résultante dog_age est incrémentée de 1 à 11.
dog_age = 10
def increment_dog_age():
global dog_age
dog_age += 1
increment_dog_age()
print(dog_age)
Contenu de sortie du résultat de l'exécution du code:
11
Vous pouvez également écrire ce qui suit en utilisant l'argument et la valeur de retour. Quelle que soit votre utilisation, vous obtiendrez le même résultat, mais il est préférable de réduire le nombre de variables globales utilisées dans la fonction si possible, c'est donc fondamentalement recommandé.
dog_age = 10
def increment_dog_age(dog_age):
dog_age += 1
return dog_age
dog_age = increment_dog_age(dog_age)
print(dog_age)
Contenu de sortie du résultat de l'exécution du code:
11
[2]. Si vous souhaitez définir plusieurs arguments, placez une virgule demi-largeur entre chaque argument. Insérez un espace demi-largeur après la virgule.
def calculate_total(x, y, z):
return x + y + z
total = calculate_total(100, 200, 300)
print(total)
Contenu de sortie du résultat de l'exécution du code:
600
[1]. L'exécution du code suivant entraînera une erreur. Régulons pour qu'aucune erreur ne se produise.
def calculate_x_plus_y(x, y):
total = x + y
return total
calculate_x_plus_y(100)
4
5
----> 6 calculate_x_plus_y(100)
TypeError: calculate_x_plus_y() missing 1 required positional argument: 'y'
[2] Créons une fonction avec un argument nommé x qui peut être omis et un argument qui définit une valeur de 100 si la spécification est omise. Peu importe ce que fait la fonction.
[3]. Exécutez la fonction en spécifiant uniquement l'argument y dans la fonction suivante.
def calculate_total(x=100, y=200, z=300):
total = x + y + z
return total
[1]. Bien que la fonction nécessite deux arguments, x et y, un seul argument est spécifié là où la fonction est exécutée. Si vous définissez deux arguments à l'emplacement d'exécution de la fonction, l'erreur disparaîtra.
def calculate_x_plus_y(x, y):
total = x + y
return total
total = calculate_x_plus_y(100, 200)
print(total)
Contenu de sortie du résultat de l'exécution du code:
300
[2]. Pour spécifier un argument facultatif, définissez la valeur par défaut de l'argument. Pour définir la valeur par défaut, définissez un symbole égal à demi-largeur sous la forme «argument = valeur par défaut». Écrivez sans espaces avant et après l'égalité. Dans ce problème, écrivez comme «x = 100».
def print_x(x=100):
print(x)
print_x()
Contenu de sortie du résultat de l'exécution du code:
100
[3]. Si vous souhaitez spécifier uniquement le y du milieu des trois arguments, utilisez l'argument mot-clé. Pour utiliser des arguments de mot-clé, spécifiez-les sous la forme ʻargument name = value` lors de l'exécution de la fonction. Dans ce problème, spécifiez au format «y = 500».
total = calculate_total(y=500)
print(total)
Contenu de sortie du résultat de l'exécution du code:
900
[1]. Essayez d'exécuter la fonction en spécifiant les variables dans la liste de ʻarg_value_listdans le code suivant comme ** list ** dans l'argument de la fonctionCalculate_total`.
arg_value_list = [100, 200, 300]
def calculate_total(x, y, z):
total = x + y + z
return total
calculate_total(
arg_value_list[0],
arg_value_list[1],
arg_value_list[2],
)
[2] Essayez de créer une fonction qui accepte n'importe quel nombre d'arguments (3 ou 5). Le contenu de traitement de la fonction n'a pas d'importance.
[1]. Pour affecter chaque valeur de la liste à un argument, spécifiez un astérisque demi-largeur juste avant la liste. Dans ce problème, nous écrirons * arg_value_list.
total = calculate_total(*arg_value_list)
print(total)
Contenu de sortie du résultat de l'exécution du code:
600
[2]. Pour créer une fonction qui accepte n'importe quel nombre d'arguments, placez un astérisque demi-largeur avant le nom de l'argument, tel que «* args», dans la partie paramètre d'argument de la fonction.
def print_args(*args):
print(args)
print_args(100, 200, 300)
Contenu de sortie du résultat de l'exécution du code:
(100, 200, 300)
Une fonction est un ensemble de programmes qui peuvent être exécutés à partir de divers emplacements et peuvent implémenter divers comportements à l'aide d'arguments et de valeurs de retour.
def pour créer une fonction.
--Indentation de 4 espaces demi-largeur est requise dans la fonction. Si vous n'ajoutez pas de retrait, une erreur se produira.
--Pour exécuter une fonction, écrivez quelque chose comme function () (par exemple, Calculate_total ()).global pour spécifier que la variable cible est une variable globale.De plus, j'écris divers articles principalement sur Python. Faites-le aussi! Principaux articles publiés jusqu'à présent
Recommended Posts