Sie werden in 100 Tagen Ingenieur - Tag 32 - Python - Grundlagen der Python-Sprache 7
Diese Zeit ist eine Fortsetzung der Grundlagen von Python.
Klicken Sie hier zum letzten Mal [Sie werden in 100 Tagen Ingenieur - Tag 31 - Python - Python-Übung 2] (https://qiita.com/otupy/items/8b7436e4df68c6c94fb1)
Funktion
Ich habe vor einiger Zeit über eingebaute Funktionen gesprochen, aber diesmal geht es um "Funktionen".
Die "eingebaute Funktion" ist eine eingebaute Funktion der Python-Sprache. Sie können die Funktion selbst definieren.
** So definieren Sie eine Funktion **
def Funktionsname(Streit):
return Rückgabewert
Der Begriff bezieht sich auf Funktionen, aber zuerst gibt es ein "Argument".
Sie können es in die Klammer () der Funktion schreiben.
Argumente werden verwendet, wenn Daten übergeben werden, die in einer Funktion verwendet werden können.
Als nächstes kommt der Rückgabewert, aber das in der Funktion berechnete Ergebnis Es wird verwendet, wenn Sie zur Außenseite der Funktion zurückkehren.
Definieren wir sofort eine Funktion.
#Funktionsdefinition
def abc(aaa=0):
print(aaa)
return 1
#Funktionsausführung
print(abc())
print(abc(2))
0 1 2 1
Wenn Sie einen Wert zuweisen, indem Sie nach dem Variablennamen "argument" "=" gleich hinzufügen, Wenn das "Argument" nicht angegeben ist, ist es der Wert, der als "Anfangswert" verwendet wird.
Da der Rückgabewert das Ergebnis der Ausführung der Funktion ist Es kann auch in einer Variablen gespeichert werden.
#Das Ausführungsergebnis der Funktion wird in einer Variablen gespeichert
a = abc(3)
print(a)
3 1
Rückgabewert und Argument können als Funktion ohne Einstellung definiert werden
def defg():
print('dd')
defg()
dd
Es sei denn, Sie müssen den Wert zurückgeben Es ist in Ordnung, den "Rückgabewert" ohne den "Rückgabewert" zu entfernen.
Wenn Sie das Ergebnis der Funktion für die nächste Verarbeitung verwenden möchten
Fügen Sie return hinzu, um den Wert zurückzugeben.
Sie können so viele Argumente haben, wie Sie möchten. Wenn es zu viel ist, ist es ein Problem bei der Verwendung.
Ich denke, es ist besser, es in ungefähr 5-6 Teile zu legen. Wenn es mehr wird, ist es besser, den Prozess zu überarbeiten.
Nachdem Sie das Argument beim Definieren der Funktion definiert haben, Bei der Verwendung muss nur das Argument angegeben werden. Abhängig von der Funktion besteht auch die Notwendigkeit, die Verarbeitung mit dem Argument zu ändern.
In diesem Fall fügen Sie dem Argument "**" hinzu Sie können das "Argument" als "Tapple-Typ" oder "Wörterbuch-Typ" erhalten.
def aaa1(**karg):
print(karg)
#Übergeben Sie den Wörterbuchtyp als Funktionsargument
aaa1(aws=[1,2])
{'aws': [1, 2]}
Sie können Daten gleichzeitig an mehrere Argumente übergeben.
def aaa2(arg1, arg2, arg3):
print(arg1)
print(arg2)
print(arg3)
lis = ['one', 'two', 'three']
#Übergeben Sie die Liste als Taple, um die Funktion auszuführen.
aaa2(*lis)
one two three
In diesem Fall muss es jedoch mit der Anzahl der Argumente übereinstimmen. Wenn die Zahlen nicht übereinstimmen, tritt ein Fehler auf.
lis2 = ['one', 'two', 'three','four']
#Ein Fehler tritt auf, wenn die Anzahl der Argumente und die Anzahl der übergebenen Argumente nicht übereinstimmen.
aaa2(*lis2)
TypeError: aaa2() takes 3 positional arguments but 4 were given
Informationen zur Verwendung der Funktion, die mehrere Zeilen umfasst Wenn es mehr als 2 Mal gemacht wird, ist es besser, es zu einer Funktion zu machen Der Code ist ordentlich und leicht zu sehen und leicht zu pflegen.
Wenn Sie denselben Prozess zweimal schreiben, überprüfen Sie das Ganze Mit dem Gefühl, die Teile neu zu schreiben, die "vereinfacht" und "arbeitssparend" sind Ich denke, es ist besser, eine "Funktion" zu erstellen.
Die "spezifische Funktion" wird auch als "Methode" unter einem anderen Namen gelesen. Denken Sie daran, da dies ein wesentliches Konzept für die Programmierung ist.
globale Variablen und Umfang
Das Konzept des "Geltungsbereichs" wird bei der Verwendung von "Funktionen" immer angehängt. Dies ist ein Konzept, das den "nutzbaren Bereich" der deklarierten Variablen angibt.
Es gibt zwei Arten von "Gültigkeitsbereich", "global" und "lokal".
Grob gesagt ist das äußerste "global" Das Innere des Funktionsblocks ist "lokal".
Mal sehen, den Unterschied. Bereiten Sie zunächst Variablen vor, die in "global" verwendet werden können.
global_var = 'global'
Definieren Sie als Nächstes eine Funktion und bereiten Sie Variablen vor, die darin verwendet werden können.
def local_def():
#Variablen für local
local_var = 'local'
return local_var
Nennen wir beide Variablen. Aufruf von "globaler Variable"
print(global_var)
global
Aufruf der lokalen Variablen
print(local_var)
NameError Traceback (most recent call last)
Wenn die Variable nicht definiert ist, wird eine Fehlermeldung angezeigt.
Was in "lokal" definiert ist, ist Dies liegt daran, dass es nur innerhalb des "Blocks" des "lokalen" verwendet werden kann.
Diese "lokale" Variable kann also verwendet werden Nur in der definierten Funktion.
Als nächstes spielen wir mit der Funktion und lesen die "globale Variable" in der Funktion.
def local_def():
#Globale Variablenreferenz
print(global_var)
local_def()
global
Die in "global" deklarierte "Variable" kann überall verwendet werden.
Was wurde in "lokal" deklariert Wie kann ich es in "global" verwenden?
Wenn es sich um eine Funktion handelt, als Rückgabewert Sie können es wiederverwenden, indem Sie zur "globalen" Seite zurückkehren.
def local_def():
local_var = 'local'
#Gibt lokal definierte Variablen zurück
return local_var
g2 = local_def()
print(g2)
local
Schauen wir uns auch die for-Anweisung an.
global_var = 'g'
for i in range(5):
j = global_var*i
#Lokale Variablen so wie sie sind drucken
print(i,j)```
4 gggg
Das Ergebnis gibt nur das endgültig zugewiesene Ergebnis wieder.
Die im Anweisungsblock "for" verwendete Variable usw.
Ich denke, es kann Fälle geben, in denen es wiederverwendet wird, ohne es zu bemerken.
Abhängig von dem in der "Variablen" gespeicherten Wert wird das Ergebnis des Programms stark beeinflusst.
Was ist schließlich, wenn sich die Variablennamen in "global" und "lokal" überschneiden?
```python
sp = 'global'
def local_def():
sp = 'local'
print(sp)
local_def()
print(sp)
local global
Einmal in local mit demselben Variablennamen definiert
Verwenden Sie beim Aufrufen einer Funktion den in dieser Funktion definierten Variablennamen.
Da es überschrieben wird, wird der von local zugewiesene Wert angezeigt.
Dann beim Aufruf der "globalen" Variablen Der Mechanismus besteht darin, dass der ursprüngliche Wert angezeigt wird.
Wenn Sie das "reservierte Wort" "global" verwenden, Sie können diese "globale Variable" auf der "lokalen" Seite bearbeiten.
sp = 'global'
def local_def():
#Lokal als globale Variable definiert
global sp
sp= 'local'
print(sp)
local_def()
print(sp)
local local
Deklarieren Sie die Variable mit "global" davor in "local". Sie können es dann einer Variablen zuweisen, um die globale Variable zu bearbeiten.
Wenn Sie dieselbe "Variable" für "global" und "lokal" verwenden, Es ist leicht, versehentliche Fehler zu verursachen.
Bis Sie sich daran gewöhnt haben, sollten Sie den Variablennamen nicht so weit wie möglich behandeln. Wir empfehlen Ihnen, einen Namen zu verwenden.
Anonyme Funktion
Bisher habe ich über "Funktionen" unterrichtet, Diesmal geht es um eine "anonyme Funktion".
Ich habe die Sortierzeiten ein wenig berührt
Lambda Über Lambda.
Auch als "Lambda-Ausdruck" bezeichnet, können Sie eine "unbenannte Funktion" erstellen.
** Wie schreibe ich Lambda-Stil **
Lambda-Argument: Verarbeitung
Wenn Sie eine normale Funktion schreiben
def add (a,b):
return a+b
print(add(2,3))
5
Es sieht aus wie das Wenn es sich um eine anonyme Funktion handelt, die Lambda verwendet
add = lambda a,b : a+b
print(add(2,3))
5
Die nach "Lambda" geschriebene Variable wird empfangen und die Verarbeitung nach ":" wird ausgeführt.
Weisen Sie der Variablen add mit Lambda-Ausdruck eine Funktion zu
Es ist ein Mechanismus, mit dem die Funktion ausgeführt wird, wenn die Variable verwendet wird
Es gibt fast keinen Unterschied zu einer normalen Funktion, und es ist sicherer, die Funktion zu definieren.
Der "Lambda-Ausdruck" ist zu Zeiten wie "Sortieren" wirksam.
Dieser "Lambda-Ausdruck" kam beim "Sortieren" mit einem "Wörterbuchtypwert" heraus.
dct ={ 3:7 , 5:6 ,1:3 }
#Sortieren Sie den Wörterbuchtyp nach Wert in aufsteigender Reihenfolge.
print(sorted(dct.items(), key=lambda x:x[1]))
[(1, 3), (5, 6), (3, 7)]
Nach key = steht Lambda-Ausdruck.
Das "sortierte" Funktionsargument "key" kann die Funktion empfangen.
Der "Lambda-Ausdruck" ist nützlich für die komplexe Sortierung.
lis1 = [2,3,4,5,7]
#Beim Sortieren von Elementen nach dem Rest geteilt durch 3
print(sorted(lis1 , key=lambda x:x%3))
[3, 4, 7, 2, 5]
Im Fall eines Wörterbuchtyps werden "Schlüssel" und "Wert" als "Tuppeltyp" zurückgegeben.
dct ={ 3:7 , 5:6 ,1:3 }
print(sorted(dct.items(), key=lambda x:x[1]))
[(1, 3), (5, 6), (3, 7)]
Im Indexteil von key = lambda x: x [1]
[0] ist der Schlüssel und [1] ist der Wert.
Wenn Sie nach Wert sortieren möchten,
Im "Lambda-Ausdruck" ist es der zweite Index, dh "1".
Sie würden key = lambda x: x [1] angeben.
Dies ist nützlich zum Sortieren komplexer Daten usw.
#Definieren Sie mehrere Listen
complex_list = [[1,2,3],[3,5,2],[2,6,8]]
print(complex_list)
[[1, 2, 3], [3, 5, 2], [2, 6, 8]]
#Sortieren Sie nach dem ersten Wert in der Liste
print(sorted(complex_list,key=lambda x : x[0]))
#Sortieren Sie nach dem zweiten Wert in der Liste
print(sorted(complex_list,key=lambda x : x[1]))
#Sortieren Sie nach dem dritten Wert in der 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]]
Der Schlüssel zum Sortieren der Liste, die als Element der großen "Liste" vorhanden ist Sie kann für jedes Element in der Liste definiert werden.
Auf diese Weise können alle Arten von Daten verarbeitet werden. Der "Lambda-Ausdruck" ist sehr nützlich.
Es eignet sich für kleine Verarbeitungen, bei denen keine Funktion definiert werden muss. Denken Sie daran, wie Sie es in Funktionen und Sortierungen verwenden.
Zusammenfassung
Funktionen sind eine sehr nützliche Funktion zur Vereinfachung und Organisation Ihrer Arbeit.
Definieren von Funktionen und Behandeln von Variablen im Gültigkeitsbereich Behalten Sie den Überblick und versuchen Sie, Fehler zu vermeiden.
68 Tage, bis Sie Ingenieur werden
Informationen zum Autor
HP von Otsu py: http://www.otupy.net/
Youtube： https://www.youtube.com/channel/UCaT7xpeq8n1G_HcJKKSOXMw
Twitter： https://twitter.com/otupython
Recommended Posts