Vous serez ingénieur dans 100 jours --Jour 32 --Python --Basiques du langage Python 7
Cette fois est une continuation des bases de Python.
Cliquez ici pour la dernière fois [Vous deviendrez ingénieur dans 100 jours - Jour 31 - Python - Exercice Python 2] (https://qiita.com/otupy/items/8b7436e4df68c6c94fb1)
une fonction
J'ai parlé des fonctions intégrées il y a quelque temps, mais cette fois, il s'agit de fonctions.
La fonction intégrée est une fonction intégrée du langage Python,
Vous pouvez définir vous-même la fonction.
** Comment définir une fonction **
nom de la fonction def(argument):
return Valeur de retour
Le terme est lié aux fonctions, mais il y a d'abord un «argument».
Vous pouvez l'écrire à l'intérieur de la parenthèse () de la fonction.
Les arguments sont utilisés lors du passage de données qui peuvent être utilisées dans une fonction.
Vient ensuite la valeur de retour, mais le résultat calculé dans la fonction
Il est utilisé lors du retour vers l'extérieur de la fonction.
Définissons une fonction immédiatement.
#Définition des fonctions
def abc(aaa=0):
print(aaa)
return 1
#Exécution de la fonction
print(abc())
print(abc(2))
0 1 2 1
Si vous attribuez une valeur en ajoutant = égal après le nom de variable de ʻargument`,
Si l '«argument» n'est pas spécifié, ce sera la valeur utilisée comme «valeur initiale».
Puisque la valeur de retour est le résultat de l'exécution de la fonction
Il peut également être stocké dans une variable.
#Le résultat de l'exécution de la fonction est stocké dans une variable
a = abc(3)
print(a)
3 1
La valeur de retour et l'argument peuvent être définis comme une fonction sans réglage
def defg():
print('dd')
defg()
dd
Sauf si vous devez renvoyer la valeur Il est normal d'éliminer la «valeur de retour» sans le «retour».
Si vous souhaitez utiliser le résultat de la fonction pour le traitement suivant
Ajoutez return pour renvoyer la valeur.
Vous pouvez avoir autant d’arguments que vous le souhaitez, Si c'est trop, ce sera un problème lors de son utilisation.
Je pense donc qu'il vaut mieux le mettre en 5-6 morceaux. Si cela devient plus que cela, il vaut mieux réviser le processus.
Après avoir défini l'argument lors de la définition de la fonction, Lors de son utilisation, il est nécessaire de spécifier uniquement l '«argument», En fonction de la fonction, il est également nécessaire de modifier le traitement avec l '«argument».
Dans un tel cas, ajoutez «**» à «l'argument» Vous pouvez recevoir l '«argument» comme un «type tapple» ou un «type de dictionnaire».
def aaa1(**karg):
print(karg)
#Passer le type de dictionnaire comme argument de fonction
aaa1(aws=[1,2])
{'aws': [1, 2]}
Vous pouvez transmettre des données à plusieurs arguments à la fois.
def aaa2(arg1, arg2, arg3):
print(arg1)
print(arg2)
print(arg3)
lis = ['one', 'two', 'three']
#Passez la liste sous forme de tapot pour exécuter la fonction.
aaa2(*lis)
one two three
Cependant, dans ce cas, il doit correspondre au nombre d'arguments. Si les nombres ne correspondent pas, une erreur se produira.
lis2 = ['one', 'two', 'three','four']
#Une erreur se produira si le nombre d'arguments et le nombre transmis ne correspondent pas.
aaa2(*lis2)
TypeError: aaa2() takes 3 positional arguments but 4 were given
Quant à l'utilisation de la fonction, un traitement qui s'étend sur plusieurs lignes
Si cela est fait plus de «2» fois, il vaut mieux en faire une fonction
Le code est net et facile à voir, et il est facile à maintenir.
Si vous écrivez deux fois le même processus, révisez le tout Avec le sentiment de réécrire les pièces qui peuvent être «simplifiées» et «économie de travail» Je pense qu'il vaut mieux créer une "fonction".
La «fonction spécifique» est également lue comme «méthode» par un autre nom. Assurez-vous de garder cela à l'esprit car c'est un concept essentiel dans la programmation.
variables globales et portée
Le concept de «scope» est toujours associé lors de l'utilisation de «fonctions». C'est un concept qui indique la «plage utilisable» de la variable déclarée.
Il existe deux types de «scope», «global» et «local».
En gros, le plus extérieur est «global» L'intérieur du bloc fonction est «local».
Voyons la différence.
Tout d'abord, préparez les variables qui peuvent être utilisées dans global.
global_var = 'global'
Ensuite, définissez une fonction et préparez les variables qui peuvent y être utilisées.
def local_def():
#Variables pour local
local_var = 'local'
return local_var
Appelons les deux variables.
Appel de variable globale
print(global_var)
global
Appel de variable locale
print(local_var)
NameError Traceback (most recent call last)
Si la variable n'est pas définie, vous obtiendrez une erreur.
Ce qui est défini dans «local» est C'est parce qu'il ne peut être utilisé qu'à l'intérieur du "bloc" du "local".
Donc, cette variable locale peut être utilisée
Uniquement dans la fonction définie.
Ensuite, jouons avec la fonction et lisons la variable globale dans la fonction.
def local_def():
#Référence de variable globale
print(global_var)
local_def()
global
La variable déclarée dans global peut être utilisée n'importe où.
Ce qui a été déclaré en local
Comment puis-je l'utiliser dans global?
S'il s'agit d'une fonction, comme valeur de retour
Vous pouvez le réutiliser en retournant au côté «global».
def local_def():
local_var = 'local'
#Renvoie des variables définies localement
return local_var
g2 = local_def()
print(g2)
local
Regardons également l'instruction for.
global_var = 'g'
for i in range(5):
j = global_var*i
#Imprimer les variables locales telles quelles
print(i,j)```
4 gggg
Le résultat ne reflétera que le résultat final attribué.
La `variable` etc. utilisée dans le bloc de l'instruction` for`
Je pense qu'il peut y avoir des cas où il est réutilisé sans s'en apercevoir.
En fonction de la valeur stockée dans la «variable», le résultat du programme sera grandement affecté.
Enfin, que se passe-t-il si les noms des variables se chevauchent dans «global» et «local»?
```python
sp = 'global'
def local_def():
sp = 'local'
print(sp)
local_def()
print(sp)
local global
Une fois défini dans local avec le même nom de variable
Lorsque vous appelez une fonction, utilisez le nom de variable défini dans cette fonction.
Puisqu'elle sera écrasée, la valeur assignée par local sera affichée.
Puis lors de l'appel de la variable global
Le mécanisme est que la valeur d'origine est affichée.
Si vous utilisez le «mot réservé» appelé «global», Vous pouvez manipuler cette «variable globale» du côté «local».
sp = 'global'
def local_def():
#Défini localement comme une variable globale
global sp
sp= 'local'
print(sp)
local_def()
print(sp)
local local
Déclarez la variable avec «global» devant elle dans «local».
Vous pouvez ensuite l'assigner à une variable pour manipuler la variable globale.
Si vous utilisez la même variable pour global et local,
Il est facile de provoquer des bogues accidentels.
Donc, jusqu'à ce que vous vous y habituiez, vous ne devriez pas couvrir autant que possible le nom de la variable. Nous vous recommandons d'utiliser un nom.
Fonction anonyme
Jusqu'à présent, j'ai enseigné les «fonctions», Cette fois, nous parlons d'une «fonction anonyme».
J'ai abordé un peu les temps de tri
lambda À propos de lambda.
Aussi appelée «expression lambda», vous pouvez créer une «fonction sans nom».
** Comment écrire un style lambda **
argument lambda: traitement
Si vous écrivez une fonction normale
def add (a,b):
return a+b
print(add(2,3))
5
Ça ressemble à ça S'il s'agit d'une «fonction anonyme» utilisant «lambda»
add = lambda a,b : a+b
print(add(2,3))
5
La variable écrite après "lambda" est reçue et le traitement après ":" est exécuté.
Assignez une fonction à la variable ʻadd avec lexpression lambda`
C'est un mécanisme que la fonction est exécutée lorsque la variable est utilisée
Il n'y a pratiquement aucune différence par rapport à une fonction normale et il est plus sûr de définir la fonction.
L'expression «lambda» est efficace à des moments tels que «sort».
Cette «expression lambda» est sortie lors du «tri» avec une «valeur de type dictionnaire».
dct ={ 3:7 , 5:6 ,1:3 }
#Triez le type de dictionnaire par valeur dans l'ordre croissant.
print(sorted(dct.items(), key=lambda x:x[1]))
[(1, 3), (5, 6), (3, 7)]
Après «key =» se trouve «expression lambda».
La clé de l'argument de fonction triée peut recevoir la fonction.
L'expression lambda est utile pour le tri complexe.
lis1 = [2,3,4,5,7]
#Lors du tri des éléments par le reste divisé par 3
print(sorted(lis1 , key=lambda x:x%3))
[3, 4, 7, 2, 5]
Dans le cas du type dictionnaire, «key» et «value» sont renvoyés comme «type tupple».
dct ={ 3:7 , 5:6 ,1:3 }
print(sorted(dct.items(), key=lambda x:x[1]))
[(1, 3), (5, 6), (3, 7)]
Dans la partie index de key = lambda x: x [1]
«[0]» est la clé et «[1]» est la valeur.
Si vous voulez «trier» par «valeur»,
Dans l'expression «lambda», il s'agit du deuxième index, c'est-à-dire «1».
Vous devez spécifier key = lambda x: x [1].
Ceci est utile pour trier des données complexes, etc.
#Définir plusieurs listes
complex_list = [[1,2,3],[3,5,2],[2,6,8]]
print(complex_list)
[[1, 2, 3], [3, 5, 2], [2, 6, 8]]
#Trier par la première valeur de la liste
print(sorted(complex_list,key=lambda x : x[0]))
#Trier par la deuxième valeur de la liste
print(sorted(complex_list,key=lambda x : x[1]))
#Trier par la troisième valeur de la liste
print(sorted(complex_list,key=lambda x : x[2]))
[[1, 2, 3], [2, 6, 8], [3, 5, 2]] [[1, 2, 3], [3, 5, 2], [2, 6, 8]] [[3, 5, 2], [1, 2, 3], [2, 6, 8]]
La clé pour trier la liste qui existe en tant qu'élément de la grande liste
Il peut être défini pour chaque élément de la liste.
En faisant cela, il sera possible de traiter toute forme de données. L'expression lambda est très utile.
Il convient aux petits traitements qui ne nécessitent pas la définition d'une fonction. N'oubliez pas comment l'utiliser dans les fonctions et les tris.
Résumé
Les fonctions sont une fonctionnalité très utile pour simplifier et organiser votre travail.
Comment définir des fonctions et comment gérer les variables dans la portée Gardez une trace de son fonctionnement et essayez d'éviter les bogues.
68 jours avant de devenir ingénieur
Informations sur l'auteur
HP d'Otsu py: http://www.otupy.net/
Youtube： https://www.youtube.com/channel/UCaT7xpeq8n1G_HcJKKSOXMw
Twitter： https://twitter.com/otupython
Recommended Posts