Bevor Sie Funktionen gelernt haben, haben Sie immer Folgendes befolgt: prozessorientierte Programmierung, dh: Implementierung von Funktionen von oben nach unten basierend auf der Geschäftslogik. Sie können darüber nachdenken, ob es mehrere Codes gibt Ist es möglich, sie nur einmal zu schreiben, wenn sie an jeder Stelle verwendet wird? Wie soll der Code zu diesem Zeitpunkt definiert werden? Beobachten Sie zunächst den folgenden Fall:
while True:
wenn CPU-Auslastung> 90 %:
#E-Mail-Erinnerung senden
Verbindung zum Postfachserver herstellen
E-Mail senden
Schließen Sie die Verbindung
Speichernutzung> 80 %:
#E-Mail senden.
>
def E-Mail senden (Inhalt)
#E-Mail-Erinnerung senden
Mit E-Mail-Server verbinden
E-Mail senden
Verbindung schließen
während True:
wenn CPU-Auslastung > > 90 %:
E-Mail senden („Speicheralarm“)
Für das oben Genannte Bei zwei Implementierungsmethoden muss das zweite Mal in Bezug auf Wiederverwendbarkeit und Lesbarkeit besser sein. Dies kann den Code und die Entwicklungszeit erheblich verkürzen. Dies ist tatsächlich der Fall Funktionale Programmierung
Das Konzept der funktionalen Programmierung:
Bei der Entwicklung eines Programms muss ein bestimmter Codeabschnitt mehrmals verwendet werden. Um jedoch die Schreibeffizienz und die Wiederverwendung von Code zu verbessern, werden Codeblöcke mit unabhängigen Funktionen verwendet In einem kleinen Modul organisiert. Dies ist die Funktion
Die Definition und der Aufruf der Funktion
<1>Funktion definieren
def printInfo():
print '---------------- -------------- ------------' print 'Das Leben ist kurz, ich benutze Python' print '---------- --------- ---------------'
Die Definition der Funktion hat hauptsächlich die folgenden Punkte:
• def: Schlüsselwort, das eine Funktion darstellt • Funktionsname: Der Name der Funktion. Die Funktion wird beim Aufruf entsprechend dem Funktionsnamen aufgerufen.
• Funktionskörper: Wird in der Funktion A-Reihe ausgeführt logischer Berechnungen oder den funktionalen Inhalt der Funktion.
• Parameter: Stellen Sie Daten für den Funktionskörper bereit
<2> Aufrufen einer Funktion
Nach dem Definieren einer Funktion ist es gleichbedeutend mit einem Code mit bestimmten Funktionen Codes ausführbar sind, müssen Sie sie aufrufen (beachten Sie, dass der darin enthaltene Inhalt beim Definieren der Funktion nicht ausgeführt wird) Der Aufruf der Funktion ist sehr einfach und der Aufruf kann über den Funktionsnamen ()
abgeschlossen werden demo: # Nach der Definition der Funktion wird die Funktion nicht automatisch ausgeführt, Sie müssen sie aufrufen
printInfo()
< 3> FunktionsdokumentbeschreibungBeispiel:
>>> def test(a,b):
... „Wird verwendet, um die Summe von 2 Zahlen zu vervollständigen“
...
>>>>>> test(11,22)
33
>>> help(test)
Sie können die relevanten Anweisungen der Testfunktion sehen===== ===== ==================================
Hilfe zur Funktion test im Modul __main__:
test(a, b)
wird verwendet, um die Summe von 2 Zahlen zu vervollständigen
(END)
===========================================
Funktionsparameter-Rückgabewert
<1> eine Funktion mit Parametern
Das Beispiel sieht wie folgt aus:
def addnum(a, b):
c = a+b
print c
<2> Rufen Sie eine Funktion mit Parametern auf
So rufen Sie die Funktion add2num(a, b) oben auf: Beispiel:
def addnum(a, b):
c = a+b
print c
add2num(11, 22) #Wenn Sie eine Funktion mit Parametern aufrufen, müssen Sie die Daten in Klammern übergeben
Zusammenfassung:
• Die Parameter in Klammern beim Definieren werden zum Empfangen von Parametern verwendet und werden als „formale Parameter“
bezeichnet. • Die Parameter in Klammern beim Aufruf werden zur Übergabe an die Funktion verwendet und als „tatsächliche Parameter“
ps: Es wird später einen separaten Blog geben, in dem Funktionsparameter ausführlich erläutert werden
<3> Beispiel:
def add2num(a, b):
Return c
Ein Beispiel Der Rückgabewert der gespeicherten Funktion lautet wie folgt: #Define function
Return a+ b
#Rufen Sie die Funktion auf und speichern Sie den Rückgabewert der Funktion
result = add2num(100,98)
Ergebnis drucken
Ergebnis: 198
(a, b):... shang = a//b ... yushu = a%b
... return shang, yushu
...
>> sh, yu = divid(5, 2)
> ;>> sh
5
>>> yu
Das Wesentliche ist die Verwendung von Tupeln
Funktionen können miteinander kombiniert werden, je nachdem, ob Parameter vorhanden sind und ob ein Rückgabewert vorhanden ist • Keine Parameter, kein Rückgabewert
• Keine Parameter, kein Rückgabewert • Es gibt Parameter, es gibt keinen Rückgabewert
• Es gibt Parameter, es gibt einen Rückgabewert
<1>Funktion ohne Parameter, kein Rückgabewert
Diese Art von Funktion kann nicht Akzeptieren Sie Parameter und haben Sie keinen Rückgabewert. Verwenden Sie diesen Funktionstyp im Allgemeinen für Funktionen, die dem Drucken von Eingabeaufforderungslichtern ähneln.
Parameter, aber keine Daten zurückgeben, wenn keine Ergebnisse erforderlich sind, verwenden Sie diesen Funktionstyp
<4>Funktion mit Parameter und Rückgabewert
Dieser Funktionstyp kann nicht nur Parameter empfangen, sondern auch bestimmte Daten zurückgeben. Im Allgemeinen verwenden Sie diesen Funktionstyp
Kleine Zusammenfassung
Funktionen können miteinander kombiniert werden, je nachdem, ob sie Parameter und Rückgabewerte haben.
• Bei der Definition einer Funktion wird diese auf der Grundlage tatsächlicher funktionaler Anforderungen, also der Funktionstypen, entworfen Von verschiedenen Entwicklern geschrieben, sind unterschiedlich• Was genau hat eine Funktion? Wenn es keinen Rückgabewert gibt, hängt es davon ab, ob es einen Rückgabewert gibt, denn nur return kann Daten zurückgeben• In der Entwicklung werden Funktionen oft entworfen je nach Bedarf, ob sie einen Wert zurückgeben müssen
• def testB(): print('---- testA start----') testB( ) print('---- testA end----') Aufruf testA() Kleine Zusammenfassung: Fall der Funktionsverschachtelung: 1. Schreiben Sie eine Funktion, um die Summe von drei zu ermitteln Zahlen # Vervollständigen Sie den Durchschnitt von 3 Zahlen # Da die Funktion sum3Number bereits die Summe der drei Zahlen vervollständigt hat, muss sie nur aufgerufen werden # Rufen Sie die Funktion auf, um den Durchschnitt von 3 Zahlen zu vervollständigen result = Average3Number(11,2,55) print("average is %d"%result) Lokale Variablen und globale Variablen der Funktion Lokale Variablen Beispiel: . ..: Drucken ("Text1 ----- %D" %A) a = 400 In [11]: text2() • Verschiedene Funktionen können lokale Variablen mit demselben Namen definieren, aber die Verwendung jeder einzelnen wird dies tun keine Auswirkungen haben Globale Variablen Konzept: Wenn eine Variable in einer Funktion oder in anderen Funktionen verwendet werden kann, ist eine solche Variable eine globale Variable text1(): ...: print("----text1----% d" %a) ...: In [14]: def text2( ): ----text1----250 In [16]: text2() Wenn lokale Variablen und globale Variablen das haben gleicher Name Wenn: In [24]: def text1(): ----text1----666 • Auf globale Variablen kann in all Funktionen • Wenn der Name der globalen Variablen mit dem Namen der lokalen Variablen übereinstimmt, werden lokale Variablen verwendet, ein kleiner Trick, um die lokalen Schlangen in Schach zu halten In [32]: def text1(): . ..: a = 520 ...: print("----text1----%d" %a ) In [33]: ps: Das wird es Ich werde später einen Blog veröffentlichen, in dem die Konzepte von Variablentypen und unveränderlichen Typen im Detail erläutert werden Beispiel: -------> ;Unveränderlicher Typ: In [47]: def demo(): ...: a += 1 ...: print(a) ...: Fehlermeldung: 1 def demo(): UnboundLocalError: Lokale Variable 'a', auf die vor der Zuweisung verwiesen wird -------------------------------------------- -- --------------------------------------------- ------->Variablentyp: In [49]: a = [1,] In [50]: In [50]: def demo(): In [51]: demo() In [52]: a Wenn eine Funktion aufgerufen wird, wird der Wert der Liste innerhalb der Funktion geändert, wenn die Funktion ausgeführt wird – und auch geändert, wenn er extern gedruckt wird. ○ Wenn Sie eine globale Variable in einer Funktion ändern, müssen Sie global für die Deklaration verwenden, sonst tritt ein Fehler auf
Versuchen Sie, die Namen von Funktionen in einem Programm nicht zu wiederholen. Wenn die Funktionsnamen wiederholt werden, überschreiben die späteren die vorherigen (Hinweis: Wiederholen Sie auch den Variablennamen nicht, da er sonst überschrieben wird)
Verschachtelung von Funktionen
print('---- testB start----')
print('Das ist testB Der von der Funktion ausgeführte Code...(weggelassen)...')
print('---- testB end----')
def testA():
Ergebnis:
---- testA start----
---- testB start--- -
Hier ist der von der testB-Funktion ausgeführte Code...(weggelassen)...
---- testB end----
---- testA end----
• Eine Funktion ruft eine andere Funktion auf, Dies ist der sogenannte verschachtelte Funktionsaufruf
• Wenn eine andere Funktion B in Funktion A aufgerufen wird, werden zunächst alle Aufgaben in Funktion B ausgeführt, bevor zur vorherigen Funktion The zurückgekehrt wird Position, an der die Sekundärfunktion A ausgeführt wird
2. Schreiben Sie eine Funktion, um den Durchschnitt von drei Zahlen zu ermitteln
# Finden Sie die Summe von drei Zahlen
def sum3Number(a,b , c):
return a+b+c # return kann von einem numerischen Wert oder einem Ausdruck gefolgt werden
def Average3Number(a,b,c):
# Das heißt, die drei empfangenen Zahlen können als tatsächliche Parameter übergeben werden
sumResult = sum3Number(a,b,c)
aveResult = sumResult/3.0
return aveResult
In [8]: def text1():
...: a = 200
...: Drucken ("Nach der Änderung")
...: A = 300
("text1----%d" %a)
...:
print("text2- ----%d" %a) 🎜> text1----200
Geändert
text1----300
Zusammenfassung
• Die Rolle lokaler Variablen: Um Daten vorübergehend zu speichern, müssen Variablen in der Speicherfunktion definiert werden. Dies ist ihre Rolle
----text2----250
In [23]: a = 250 # Globale Variable
. .: ..: # Lokale Variable
...: ...:
In [25]: def text2(): .. .: print("----text2----%d" %a)
.. .:
In [26]: text1()
In [ 27]: text2()
In [28]:
Zusammenfassung:
Globale Variablen innerhalb der Funktion ändern:
In [31]: a = 250
In [ 33]: def text2():
...:
global
a
...: a = 666
...: Print("----text2-- --%d" %a)
...:
In [34]: # Keine Funktion wird aufgerufen
In [35]: print( a)
250
In [36]: # Call text1
In [37]: text1()
----text1-- --520
In [38]: # Erneut drucken---->
In [39]: print(a)
250
In [40]: # Es wurde festgestellt, dass der Wert nicht geändert wurde
In [41 ]:
# Call text2
In [42]: text2() ----text2----666
In [43]: # Drucken Sie ein
noch einmal aus In [ 44]: print(a)
666
In [45]: # Der Wert wurde geändert
Zusammenfassung:
• Wenn Sie eine globale Variable in einer Funktion ändern, müssen Sie sie mit global deklarieren. Andernfalls entspricht dies einer Neudefinition innerhalb der Funktion (ohne Übergabe von Parametern). Ein Objekt derselben Variablen
Der Unterschied zwischen - globalen Variablen vom Variablentyp - und globalen Variablen vom unveränderlichen Typ - innerhalb der Funktion geändert
In [48]: demo()
------------- --------------- ----------------------------------- ------------
UnboundLocalError Traceback (letzter Aufruf)
a += 1 3 Print (a)
4
Hinweis: Offensichtlich kann es nicht geändert werden
...: a.append(2)
print(a)
..:
[1, 2]
Out[52]: [1, 2]
Zusammenfassung:
○ Verwenden Sie keine globale Deklaration in der Funktion Das Wesentliche, dass globale Variablen nicht geändert werden können ist, dass den Punkt globaler Variablen nicht ändern kann. bedeutet, dass globale Variablen nicht auf neue verweisen kann Daten .
○ Bei globalen Variablen vom unveränderlichen Typ können die Daten, auf die zeigt, nicht geändert werden . Wenn also global nicht verwendet wird, kann die globale Variable nicht ändern .
○ Für globale Variablen vom -Variablentyp können die Daten, auf die zeigt, geändert werden . Wenn also global nicht verwendet wird, kann auch global ändern Variable.
Das obige ist der detaillierte Inhalt vonGrundlegende Punkte in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
