1.6 Funktionsgestaltung
Funktionskonzept
Funktionen können verwendet werden, um wiederverwendbaren Code zu definieren, Code zu organisieren und zu vereinfachen
# 计算1~10的和
sum = 0
for i in range(1, 11):
sum += i
print(sum)
# 计算2~22的和
sum = 0
for i in range(2, 23):
sum += i
print(sum)
# 计算9~101的和
sum = 0
for i in range(9, 102):
sum += i
print(sum)
# 封装
def getSum(a, b):
result = 0
for i in range(a, b + 1):
result += i
return result
sum = getSum(1,10)
print(sum)
sum = getSum(2,22)
print(sum)
sum = getSum(9,101)
print(sum)Eine Funktion ist eine Reihe von Anweisungen, die zur Implementierung einer Operation zusammengestellt wurden
Was sind die Vorteile von Funktionen:
-
Durch die Verwendung von Funktionen kann Code wiederverwendet werden, wodurch das wiederholte Schreiben von Code überflüssig wird und die Wiederverwendung von Code verbessert wird
-
Die Funktion kann die interne Implementierung kapseln, interne Daten schützen und Transparenz für Benutzer erreichen
-
Funktionen machen das Programm modular, mit einer klaren Arbeitsteilung, die zum Lesen, Debuggen und Ändern beiträgt.
Funktionsdefinition
Die Hauptkomponenten der Funktion sind: Funktionsname, Parameter, Funktionskörper und Rückgabewert
def 函数名称(参数):
函数体
return 返回值Parameter werden als formale Parameter oder formale Parameter bezeichnet . Wenn die Funktion von außen aufgerufen wird, werden einige Daten übergeben, und diese Daten werden von den formalen Parametern empfangen. Die übergebenen Daten werden als Aktualparameter oder Istparameter bezeichnet . Der Parameter ist optional.
num1 = 30;
num2 = 40;
sum = getSum(num1,num2)
print(sum)Einige Funktionen haben Rückgabewerte , andere nicht. Gibt es keine Rückgabe ohne Rückgabewert? Wenn es keinen Rückgabewert gibt, wird die Rückgabe ausgeblendet.
def getSumPrint(a,b):
result = 0
for i in range(a, b + 1):
result += i
print(result)
# return
getSumPrint(10,20)Der Funktionskörper enthält eine Reihe von Anweisungen, die definieren, was die Funktion tut.
Rückgabe bedeutet nur das Ende der Funktionsoperation. Sobald der Funktionsausführungsprozess auf die Rückgabeanweisung stößt, wird der gesamte Code nach der Funktion ignoriert, und der Funktionskörper wird direkt herausgesprungen, und die Funktion endet sofort, selbst in einer Schleife. Und wenn die Funktion keinen Rückgabewert hat, gibt sie standardmäßig None zurück. Wenn es einen Rückgabewert gibt, schreiben Sie ihn einfach nach der Rückgabe, beenden Sie die Funktion und geben Sie das Ergebnis an den Aufrufer zurück.
def func01(a):
if a == 10:
print("哈哈")
return
print("嘻嘻")
return
func01(11)
res = func01(10)
print(type(res))
def func02(a):
for i in range(1,11):
if i == a:
print(i)
# break 跳出循环 接着向下运行
return # 直接结束函数
print(i)
print("啦啦")
return
func02(11)
func02(4)Was kann bei Rückgabe zurückgegeben werden?
-
Nichts zurückgeben:
return -
Beliebiger Datentyp:
return 'hello' -
Ein Ausdruck:
return 1 + 2 -
Eine Urteilserklärung:
return 3 > 2 -
Eine Variable:
return a -
Ein Funktionsaufruf:
return func() -
Mehrere Rückgabewerte, durch Kommas getrennt:
return a,1+2,'hello' -
Kehre sogar zu dir zurück:
return self
Funktionen können fast alle Python-Datenobjekte zurückgeben.
Übergabe von Parametern
Funktionen haben normalerweise Parameter, mit denen tatsächliche externe Daten zur Verarbeitung an die Funktion übergeben werden. Bei der Verarbeitung von Parametern unterschiedlicher Datentypen treten jedoch die folgenden zwei Dinge auf:
-
Wenn eine Python-Funktion Parameter übergibt, übergibt sie die Speicheradresse des tatsächlichen Objekts
-
Python-Datentypen werden hauptsächlich in veränderbare Objekte und unveränderliche Objekte unterteilt
def func(a): # 局部变量
print("函数内部没有修改前",id(a)) # 520
a = 2
print("函数内部修改后",id(a)) # 536
print("函数内部修改后a=",a) # 2
return
a = 1 # 全局变量
print("调用函数之前",id(a)) # 520
func(a)
print("调用函数之后",id(a)) # 520
print(a)
def test(lst) :
lst.append(4)
print(id(lst))
print(lst)
lst = [1,2,3] # 列表
print(id(lst))
test(lst)
print(id(lst))
print(lst)In Bezug auf die Übertragung von Parametern gibt es, da Python eine dynamische Sprache ist, keine Datentypunterscheidung für Variablen, sodass die Funktion nicht den Datentyp des tatsächlichen Parameters erkennt, sondern die Nummer. Die Erkennung des Datentyps wird nur erkannt, wenn die Funktion ausgeführt wird. herauskommen.
def add(a, b):
return a + b
add(1, 2)
add(1, 2, 3)
Traceback (most recent call last):
File "C:/Users/HENG/Desktop/PythonCode/Day04/FunctionTest05.py", line 5, in <module>
add(1, 2, 3)
TypeError: add() takes 2 positional arguments but 3 were given
add(1, "hello")
Traceback (most recent call last):
File "C:/Users/HENG/Desktop/PythonCode/Day04/FunctionTest05.py", line 6, in <module>
add(1, "hello")
File "C:/Users/HENG/Desktop/PythonCode/Day04/FunctionTest05.py", line 2, in add
return a + b
TypeError: unsupported operand type(s) for +: 'int' and 'str'
Funktionsbetriebsmechanismus
Ein Stapel ist ein First-In-Last-Out-Container.
Funktionen werden basierend auf dem Stapel ausgeführt. Jedes Mal, wenn eine Funktion aufgerufen wird, erstellt das System automatisch einen Speicherplatz für die Funktion, der auch als Stapelrahmen bezeichnet wird, speichert seine Parameter, Variablen und Ausführungsanweisungen und schiebt den Stapelrahmen dann auf den Stapel, um die Ausführung zu starten. Wenn eine Funktion eine andere neue Funktion aufruft, erstellt das System einen neuen Stapelrahmen, schiebt den Stapelrahmen auf den Stapel und beginnt zu laufen. Die erste Funktion wird angehalten, bis alle Funktionen ausgeführt sind, die erste Die Funktion wird weiterhin ausgeführt.
def multi(a, b, c):
return a ** 2, b ** 2, c ** 2
def add(a, b, c):
return a + b + c
def out(s):
print(s)
def test(a, b):
num1, num2, num3 = multi(a, b, a + b)
out('hello')
return add(num1, num2, num3)
num = test(2, 3)
print(num)Variabler Umfang
Die in der Funktion definierten Variablen werden als lokale Variablen bezeichnet . Auf lokale Variablen kann nur innerhalb der Funktion zugegriffen werden. Die Funktion, in der sich der Bereich der lokalen Variablen befindet, wird in den Stapel verschoben und ausgeführt, bis die Funktion endet und aus dem Stapel herausspringt.
Es ist auch möglich, globale Variablen zu definieren , die außerhalb aller Funktionen definiert sind und auf die alle Funktionen zugreifen können.
Beispiel 1:
globalVar = 1
num1 = 3
num2 = 10
def f1():
localVar = 2 # 局部变量 在该函数内创建
print(globalVar) # 全局变量
print(localVar) # 局部变量
print(num1 + 3) # num1 全局变量
num2 = 20 # 局部变量 在该函数内创建
print(num2)
# 如果直接将全局变量，参与运算，直接打印 调用的就是全局变量
# 如果是对全局变量进行修改，则为创建一个同名的局部变量
f1()
print(globalVar)
print(num2)
# NameError: name 'localVar' is not defined
# print(localVar)Beispiel 2:
x = 1
def f2():
global x # 在函数内部将x标记为全局变量，如果存在则复用，不存在则创建全局变量
x = 2
print(x)
f2()
print(x)
==========================================
def f2():
global x # 在函数内部将x标记为全局变量，如果存在则复用，不存在则创建全局变量
x = 2
print(x)
f2()
print(x)Beispiel 3:
x = int(input("Enter a number:"))
if x > 0:
y = 4 # 全局变量 只有在x>0的条件下创建
print(y)
Enter a number:-10
Traceback (most recent call last):
File "C:/Users/HENG/Desktop/PythonCode/Day04/FunctionTest05.py", line 52, in <module>
print(y)
NameError: name 'y' is not definedBeispiel 4:
sum = 0
for i in range(5): # i 全局变量
sum += i
print(i) # --> 4