Funktionsgrundlagen (Python)

Der Inhalt dieses Artikels ist das Grundwissen über Python-Funktionen. Jetzt können Freunde in Not auf den Inhalt des Artikels zurückgreifen

Funktion: Wenn Sie bei der Entwicklung eines Programms einen bestimmten Codeabschnitt mehrmals benötigen, aber um die Schreibeffizienz und die Wiederverwendung von Code zu verbessern, werden Codeblöcke mit unabhängigen Funktionen in einem kleinen Modul organisiert
Dies ist eine Funktion

Funktionsdefinition und -aufruf

<1>Funktion definieren
Das Format der Funktionsdefinition ist wie folgt:

def function name():
Code
< 2>Funktion aufrufen

Nachdem Sie die Funktion definiert haben, entspricht dies einem Code mit bestimmten Funktionen. Wenn Sie möchten, dass diese Codes ausgeführt werden, müssen Sie sie aufrufen

Der Aufruf der Funktion ist sehr einfach. Der Aufruf kann über den Funktionsnamen ()


Funktionsparameter (1)

abgeschlossen werden, um eine Funktion allgemeiner zu gestalten Wenn Sie möchten, dass die Summe zweier Zahlen berechnet wird, können Sie die Funktion beim Definieren von Daten
dieses Problem lösen lassen Funktion

<1> Mit Parametern definieren Funktion

Beispiele sind wie folgt:

def add2num(a, b):
c = a+b
print c

<2> Aufruf mit Parameterfunktionen

Nehmen Sie den Aufruf der Funktion add2num(a, b) oben als Beispiel:


def add2num( a, b):
c = a+b
Print C

add2num (11, 22) #Wenn Sie eine Funktion mit Parametern aufrufen, müssen Sie die Daten übergeben
& lt; 4 & gt; kleine Zusammenfassung Die Parameter in Klammern werden zum Empfangen von Parametern verwendet und werden als „formale Parameter“ bezeichnet

Die Parameter in Klammern werden beim Aufruf zur Übergabe an die Funktion verwendet und als „tatsächliche Parameter“ bezeichnet

Funktionsrückgabewert (1)

<1> Einführung in „Rückgabewert“

Der sogenannte „Rückgabewert“ ist der Endwert, der dem Aufrufer nach der Funktion übergeben wird im Programm vervollständigt eine Sache Ergebnis

<2>Funktion mit Rückgabewert

Wenn Sie das Ergebnis an den Aufrufer in der Funktion zurückgeben möchten, müssen Sie return
in der Funktion wie folgt:

def add2num(a, b):
c = a+b
return c

oder

def add2num (a, b):
Rückgabe von a+b

<3>Speichern Sie den Rückgabewert der Funktion

Im eingangs erwähnten Beispiel „Zigaretten kaufen“. Abschnitt, am Ende gibt dir dein Sohn Zigaretten. Du musst sie deinem Sohn abgenommen haben, oder? Das Gleiche gilt für Programme. Wenn eine Funktion Daten zurückgibt und Sie diese Daten verwenden möchten, müssen Sie
Ein Beispiel für den Rückgabewert der gespeicherten Funktion lautet wie folgt:

                 #Funktion definieren
                                                                                                                                                                                                                                                           100,98)

#Weil das Ergebnis den Rückgabewert von gespeichert hat die Adtenedness, damit Sie
Ergebnis drucken

Ergebnis:

198



Funktionsrückgabewert (2)
Können wir Mehrere Werte in Python zurückgeben? >shang, yushu
...
>>> sh, yu = pid(5, 2)
>>> sh
>> ;> ; yu
1

Das Wesentliche ist die Verwendung des Tupels



4 Arten von Funktionen

Die Funktion hängt davon ab, ob es welche gibt Parameter und ob es einen Rückgabewert gibt, können miteinander kombiniert werden. Es gibt insgesamt 4 Typen

Keine Parameter, kein Rückgabewert
keine Parameter und zurückgebende
Parameter, kein Rückgabewert
Parameter, Rückwert

& lt; 🎜>
Diese Art von Funktion kann keine Parameter akzeptieren und hat keinen Rückgabewert. Um Funktionen ähnlich wie Aufforderungslichter zu drucken, verwenden Sie im Allgemeinen diese Art von Funktion

<2>Keine Parameter, Rückgabewert Wertfunktion

Diese Art von Funktion kann keine Parameter empfangen, aber bestimmte Daten zurückgeben. Im Allgemeinen verwenden Sie zum Sammeln von Daten diese Art von Funktion


# Ermitteln Sie die Temperatur
                def getTemperature ():

                                                                                                                                                                                                                                  🎜>
temperatur = getTemperature()
                                                                                                                                                                                                                                                    Die aktuelle Temperatur beträgt: 24 Funktionen mit Parametern und ohne Rückgabewerte

Dieser Funktionstyp kann Parameter empfangen , kann aber keine Daten zurückgeben. Im Allgemeinen wird diese Art von Funktion verwendet, wenn Daten für bestimmte Variablen festgelegt werden, ohne dass Ergebnisse erforderlich sind                                                                                                                                      Funktionen mit Parametern und Rückgabewerten

                               , Verwenden Sie diese Art von Funktion


# Berechnen Sie die Akkumulation von 1 ~ NUM und
DEF CALCULENUM (NUM):

Ergebnis = 0
i = 1
WHILE i<=num:

Ergebnis = Ergebnis + i

i+=1

Ergebnis zurückgeben

Ergebnis = berechneNum(100)
print( Die kumulative Summe von ' 1~100 ist: %d'%result)

Ergebnis:

Die kumulative Summe von 1~100 ist: 5050

Funktionsparameter (2)<参> 1 . Standardparameter

Wenn beim Aufruf der Funktion der Wert des Standardparameters nicht eingegeben wird, wird er als Standardwert betrachtet. Das folgende Beispiel druckt das Standardalter, wenn das Alter nicht übergeben wird: Name
drucken "Alter", = 9, name = "miki")

Das Ausgabeergebnis des obigen Beispiels:

                                                                                                                                                                                                           

                                                                         Datei "", Zeile 1 . Syntax Fehler: Nicht standardmäßiges ARGUMENT FOLLOWS Standard-ARGUMENT

2. Leistungsparameter

Manchmal kann eine Funktion erforderlich sein um mehr Parameter zu verarbeiten als bei der ursprünglichen Anweisung. Diese Parameter werden als Parameter variabler Länge bezeichnet und bei der Deklaration nicht benannt.

Die grundlegende Syntax lautet wie folgt:

defekt. FunktionName ([formal_args,] *args, ** kwargs):
"function_docstring"
Ausdruck]

Die Variablen mit der Sternnummer (*) ARGS speichern alle unbenannten Variablenparameter, ARGS ist die Metagruppe und die Variable KWARGS fügt Schlüssel=Wert-Parameter hinzu, kwargs ist ein Wörterbuch.

                                                                                    > print "a =", a
... ... print "b =", b
... ... print "args =", args
. .. print „kwargs:“                                                                                                                                         5, m=6, n=7, p=8) # Beachten Sie, dass die übergebenen Parameter kwargs entsprechen:
p = 8
m = 6
n = 7
>>>
                                                                                                       ;> c = (3, 4, 5)
                                                              >>> fun(1, 2, *c, **d) # Achten Sie auf die Parameterübergabemethode von Tupeln und Wörterbüchern
, 5)
kwargs:
p = 8
m = 6
n = 7
                                                                                                ;>
                                                                    , 'm': 6, 'n': 7})
                                                             Typen werden als Funktionsparameter verwendet. Wird das anders sein?
Verfügt Python über eine ähnliche Zeigerparameterübergabe wie in der C-Sprache?

                                                                                                                                    ...
                                                                                                                                                                     1
                                                                                                                                             >>> selfAdd(a_list)
               > Bei unveränderlichen Typen kann die abhängige Variable nicht geändert werden, sodass die Operation keinen Einfluss auf die Variable selbst hat
; und bei Variablentypen kann die Operation im Funktionskörper die eingehende Parametervariable ändern.


Verschachtelte Aufrufe von Funktionen

def testB():
print('---- testB start----')
print('Here It ist der Code, der von der testB-Funktion ausgeführt wird --- testA start----')

testB()

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

testA()

Ergebnis:

--- - testA start----
---- testB start----
                                                                                                                  ''' herauskommen raus'       ' 's ' ' ' zusammen durch 's durch's durch ‐ ‐ ‐‐‐‐ zusammen's zusammen, um zu gehen, um ein Ende zu testen----



Denken und Implementieren 1

Schreiben Sie eine Funktion zum Drucken einer horizontalen Linie
Drucken Sie eine benutzerdefinierte Anzahl von horizontale Linien

Referenzcode 1


# Eine horizontale Linie drucken
DEF PRINTNUMLINE (NUM):
I = 0

# Weil die Die PrintoneERINE-Funktion hat die horizontale Druckfunktion abgeschlossen,
# Rufen Sie diese Funktion einfach mehrmals auf
while                                                                                          ​​​​Schreiben Sie eine Funktion, um drei Zahlen zu finden. Die Summe von drei Zahlen
Schreiben Sie eine Funktion, um den Durchschnitt von drei Zahlen zu ermitteln

Referenzcode 2


# Finden Sie die Summe von drei Zahlen
def sum3Number(a,b, c):
            return a+b+c # return 的后面可以是数值，也可是一个表达式

        # 完成对3个数求平均值
        def Average3Number(a,b, c):

Da die Funktion der Summe 3Number bereits die Summe von 3 Zahlen abgeschlossen hat, nennen Sie sie also 🎜> sumresult = sum3number (a, b, c)
averesult = Sumresult/3.0
return averesult

                                                                  
                                                                                                                                                                                                      Daten müssen Sie Variablen in der Funktion zum Speichern definieren. Dies ist ihre Rolle

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

Die Demo lautet wie folgt:

# Globale Variablen definieren
a = 100

def test1():
print(a)

def test2():
print(a)

             # Funktion anrufen
               test1()
                                                                                                                                                                                    Wenn Sie eine globale Variable in einer Funktion ändern, ändern Sie Sie müssen global verwenden, um es zu deklarieren, sonst tritt ein Fehler auf.
Wenn der Name der globalen Variablen mit dem Namen der lokalen Variablen übereinstimmt, wird die lokale Variable verwendet. Ein kleiner Trick, um den mächtigen Drachen nicht zu machen Überwältige die lokale Schlange


Rekursive Funktion
Wenn eine Funktion intern keine anderen Funktionen aufruft, sondern sich selbst, handelt es sich bei dieser Funktion um eine rekursive Funktion.
Berechnen wir zum Beispiel die Fakultät n! = 1 * 2 * 3 * ... * n
def calNum(num):
i = 1
return = 1

while i<=num:
return *= i
i+=1

return result

ret = calNum(3)
print(ret)


Anonyme Funktion

Verwenden Sie das Schlüsselwort Lambda, um eine kleine anonyme Funktion zu erstellen. Dieser Funktionstyp verdankt seinen Namen der Tatsache, dass der Standardschritt der Deklaration einer Funktion mit def weggelassen wird.

Die Syntax der Lambda-Funktion enthält nur eine Anweisung wie folgt:

lambda [arg1 [,arg2,...argn]]:expression

Das folgende Beispiel :

sum = lambda arg1, arg2: arg1 + arg2

#Summenfunktion aufrufen
print „Value of total:“, sum(10, 20)
print „Value of total : ", sum( 20, 20 )

Das Ausgabeergebnis des obigen Beispiels:

Wert der Summe: 30
Wert der Summe: 40

Die Lambda-Funktion kann beliebig viele Parameter empfangen, aber nur den Wert eines Ausdrucks zurückgeben

Anonyme Funktionen können print nicht direkt aufrufen, da Lambda einen Ausdruck erfordert
Anwendungsanlässe
Funktionen werden als Parameter übergeben

Selbstdefinitionsfunktion.                                         ; > a = 1
b = 2
Ergebnis = 3

Als Parameter der integrierten Funktion

Denken Sie darüber nach, wie geben Sie die folgenden Daten an, die nach Alter oder Name sortiert werden sollen?

stus = [
{"name": "zhangsan", "age":18},
{"name": "lisi", "age":19},
{"name": "wangwu", "age":17}
]

Nach Name sortieren:

>>> x['name'])
>>> stus
[{'age': 19, 'name': 'lisi'}, {'age': 17, 'name': 'wangwu '}, {'age': 18, 'name': 'zhangsan'}]

Sortieren nach Alter:

>>> x['age'])
>>> stus
[{'age': 17, 'name': 'wangwu'}, {'age': 18, 'name': 'zhangsan '}, {'age': 19, 'name': 'lisi'}]

Hinweise zur Verwendung von Funktionen

1. Benutzerdefinierte Funktion

<1> Parameter, kein Rückgabewert

                                                                                                                                                             . :
                                                                                                                                                                                                        🎜>In der Entwicklung werden Funktionen häufig entsprechend den Anforderungen entworfen, ob sie einen Wert zurückgeben müssen
In einer Funktion können mehrere Rückgabeanweisungen vorhanden sein. Solange jedoch eine Rückgabeanweisung ausgeführt wird, bedeutet dies, dass der Aufruf dieser Funktion erfolgt abgeschlossen

& lt; 3 & gt; es gibt Parameter, kein Rückgabewert

DEF-Funktionsname (formale Parameterliste):
Anweisung

Hinweis:

Wenn Sie die Funktion aufrufen, müssen Sie bei Bedarf einige Daten zusammen übergeben, und die aufgerufene Funktion muss Parameter verwenden, um sie zu empfangen.
Die Anzahl der Variablen in der Parameterliste wird anhand der tatsächlich übergebenen Datenmenge ermittelt

Wert

def Funktionsname (Parameterliste):

2. Aufrufende Funktion

                                                                                                                                                                                                                                                               

Wenn die aufgerufene Funktion bei der Definition über formale Parameter verfügt, sollten die Parameter beim Aufruf übergeben werden

Im Einklang mit den Anforderungen
                                                                                                                        ;1> Funktion (lokale Variablen)

         <2> Außerhalb der Funktion definierte Variablen können in allen Funktionen (globale Variablen) verwendet werden.
Verwandte Empfehlungen:


Einführung in Python-Grundfunktionen

Das obige ist der detaillierte Inhalt vonFunktionsgrundlagen (Python). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!