Heim > Backend-Entwicklung > Python-Tutorial > Grundlegende Punkte in Python

Grundlegende Punkte in Python

巴扎黑
Freigeben: 2017-07-18 13:32:17
Original
1256 Leute haben es durchsucht

Grundlegende Übersicht über Funktionen

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 („Festplattenalarm“)

wenn Speichernutzung> 80 %:

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

Das Format zum Definieren einer Funktion ist wie folgt:

def function name():

Code

 demo:

 # Definieren Sie eine Funktion, die kann die Funktion zum Drucken von Informationen abschließen

  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

 • Rückgabewert: Wenn die Funktion ausgeführt wird, können Daten an den Aufrufer zurückgegeben werden.

<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“

... print("%d"%(a+b))

...

>>>

>>> test(11,22)
33

Führen Sie den folgenden Code aus

>>> 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


def add2num(a, b):


Return a+ b
#Rufen Sie die Funktion auf und speichern Sie den Rückgabewert der Funktion

result = add2num(100,98)
 

#Da das Ergebnis den Rückgabewert von add2num gespeichert hat, kann es als nächstes verwendet werden

Ergebnis drucken
Ergebnis: 198

In Python können wir mehrere Werte zurückgeben


(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.

Klassenfunktionen können keine Parameter empfangen, können aber bestimmte Daten zurückgeben. Im Allgemeinen werden solche Funktionen zum Sammeln von Daten verwendet <3> Funktionen mit Parametern und ohne Rückgabewerte

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

• Eine Funktion kann mehrere Return-Anweisungen enthalten, aber solange eine Return-Anweisung ausgeführt wird, bedeutet dies, dass der Aufruf dieser Funktion abgeschlossen ist


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

def testB():
print('---- testB start----')
print('Das ist testB Der von der Funktion ausgeführte Code...(weggelassen)...')
 print('---- testB end----')


def testA():

print('---- testA start----')

testB( )

print('---- testA end----')

Aufruf

testA()


Ergebnis:
---- testA start----
---- testB start--- -
Hier ist der von der testB-Funktion ausgeführte Code...(weggelassen)...
---- testB end----
---- testA end----

Kleine Zusammenfassung:
  • 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

Fall der Funktionsverschachtelung:

 1. Schreiben Sie eine Funktion, um die Summe von drei zu ermitteln Zahlen
 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

 # Vervollständigen Sie den Durchschnitt von 3 Zahlen
 def Average3Number(a,b,c):

 # Da die Funktion sum3Number bereits die Summe der drei Zahlen vervollständigt hat, muss sie nur aufgerufen werden
  # 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

 # 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:
In [8]: def text1():
...: a = 200

. ..: Drucken ("Text1 ----- %D" %A)
...: Drucken ("Nach der Änderung")
...: A = 300
("text1----%d" %a)
...:

In [9]: def text2():

a = 400
                                                                                                                                                             print("text2- ----%d" %a) 🎜> text1----200
 Geändert
 text1----300

 In [11]: text2()

 text2- ----400



Zusammenfassung

  • Lokale Variablen sind Variablen, die innerhalb einer Funktion definiert sind

  • Verschiedene Funktionen können lokale Variablen mit demselben Namen definieren, aber die Verwendung jeder einzelnen wird dies tun keine Auswirkungen haben
 • Die Rolle lokaler Variablen: Um Daten vorübergehend zu speichern, müssen Variablen in der Speicherfunktion definiert werden. Dies ist ihre Rolle

Globale Variablen


Konzept: Wenn eine Variable in einer Funktion oder in anderen Funktionen verwendet werden kann, ist eine solche Variable eine globale Variable

 

Beispiel:

text1(): ...: print("----text1----% d" %a) ...: In [14]: def text2( ):

                                                                                                                                                                                                                                    )

 ----text1----250

 In [16]: text2()
 ----text2----250

 

 Wenn lokale Variablen und globale Variablen das haben gleicher Name Wenn:
In [23]: a = 250 # Globale Variable

In [24]: def text1():
. .:             ..:      # Lokale Variable

      ...:            ...:
  In [25]: def text2():    .. .:    print("----text2----%d" %a)
   .. .:

 In [26]: text1()

 ----text1- ---521

  ----text1----666

 In [ 27]: text2()

   ----text2----250


In [28]:

 


  Zusammenfassung:

  • Außerhalb einer Funktion definierte Variablen werden globale Variablen genannt

  • 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

Globale Variablen innerhalb der Funktion ändern:
In [31]: a = 250

In [32]: def text1(): . ..: a = 520 ...: print("----text1----%d" %a ) In [33]:

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

 

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 [46]: a = 6

In [47]: def demo(): ...: a += 1 ...: print(a) ...:

In [48]: demo()

Fehlermeldung:
------------- --------------- ----------------------------------- ------------
UnboundLocalError          Traceback (letzter Aufruf)
    in ()

    ---- > ()

    in demo()

          1 def demo():
             a += 1 3 Print (a)
4

   UnboundLocalError: Lokale Variable 'a', auf die vor der Zuweisung verwiesen wird

   -------------------------------------------- -- ---------------------------------------------
 Hinweis: Offensichtlich kann es nicht geändert werden

------->Variablentyp:

In [49]: a = [1,]

In [50]:

In [50]: def demo():
...: a.append(2)
print(a)
..:

In [51]: demo()
[1, 2]

In [52]: a
Out[52]: [1, 2]

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.
Zusammenfassung:

○ Wenn Sie eine globale Variable in einer Funktion ändern, müssen Sie global für die Deklaration verwenden, sonst tritt ein Fehler auf
○ 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!

Verwandte Etiketten:
Quelle:php.cn
Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Beliebte Tutorials
Mehr>
Neueste Downloads
Mehr>
Web-Effekte
Quellcode der Website
Website-Materialien
Frontend-Vorlage