Python-Programmierung: Beherrschen Sie ganz einfach Funktionsdefinitionen, Typen und die Übergabe von Parametern

Vorwort

Dieser Artikel hilft Ihnen, die Kernfunktion der Python-Sprache – Funktionen – leicht zu verstehen und zu beherrschen: Definieren der Syntax und Funktionsform und Einführung von zwei Möglichkeiten zur Übergabe von Funktionsparametern.

Funktionsbedeutung

Eine Funktion ist ein Block von Anweisungen, der eine bestimmte Aufgabe ausführt. Sie ist ein Teil des Codes, der Programmierern die Wiederverwendung ermöglicht, was das modulare Konzept von Softwareprogrammen fördert. Die Hauptidee dieses Ansatzes besteht darin, einen großen Codeblock in kleinere unabhängige Teile und damit besser verwaltbare Unterblöcke zu unterteilen. In Python gibt es zwei Arten von Funktionen:

Eingebaute Funktionen (Build-in): Sie können diese Funktionen direkt im Programm verwenden, ohne sie beim Programmieren zu definieren. Diese Art von Funktion wird häufig beim anfänglichen Lernen verwendet (z. B. print(), input(), sum() usw.).

Benutzerdefinierte Funktionen: Mit Python können Programmierer ihre eigenen Funktionen erstellen. Dieser spezielle Funktionstyp wird als nächstes hervorgehoben.

Kurz gesagt ist eine Funktion ein strukturierter Block von Anweisungen, der definiert ist und wiederholt aufgerufen werden kann. Die Funktion hat einen eindeutigen Namen, kann Parameter empfangen und gibt bei Bedarf das entsprechende Ergebnis (Wert) an den Aufrufer zurück oder gibt keinen Wert zurück.

Funktionsdefinition

Die Hauptregeln für die Definition von Funktionen in Python lauten wie folgt:

• Ein Funktionsblock beginnt mit dem Schlüsselwort def, gefolgt vom Funktionsnamen und Klammern. Beachten Sie, dass in Python die Groß-/Kleinschreibung beachtet werden muss und daher def anstelle von Def verwendet werden muss.
• Ähnlich wie Variablennamen können Funktionsnamen Buchstaben oder Zahlen enthalten, jedoch keine Leer- oder Sonderzeichen und dürfen nicht mit einer Zahl beginnen.
• Optionale Eingabeparameter (Argumente genannt) sollten in Klammern gesetzt werden – Anzahl und Typ der Parameter richten sich nach Bedarf.
• Dem Funktionsnamen folgt ein Doppelpunkt. Normalerweise beginnt der Anweisungsblock in der Funktion mit einer neuen Zeile nach dem Doppelpunkt und ist eingerückt.
• Funktionen, die Daten zurückgeben, müssen das Schlüsselwort return in ihrem Codeblock enthalten.

Zusammenfassend gibt es vier Arten von Funktionen:

• Funktionen ohne Parameter und Rückgabewerte;
• Funktionen ohne Parameter und Rückgabewerte;
• Funktionen mit Parametern und Rückgabewerten Funktion.
• Das Syntaxformat der Funktionsdefinition lautet wie folgt:

def functionName (var1, var2, … etc.):
 Statements

Je nach Vorhandensein oder Fehlen tatsächlicher Parameter und dem Vorhandensein von Eingabe- und/oder Rückgabewerten können Funktionen in die vier oben genannten möglichen Typen unterteilt werden. Sie werden im Folgenden gesondert vorgestellt.

Funktion ohne Parameter und Rückgabewert

Bei diesem Typ akzeptiert die Funktion keine Variablen als Parameter und gibt keine Daten zurück. Die folgende Skriptdemonstration ist beispielsweise eine solche Funktion, die nur eine vordefinierte Zeichenfolge auf dem Bildschirm ausgibt.

Der Code ist offensichtlich. Es gibt formale Parameter in der Definition, keine tatsächlichen Parameter beim Aufruf und keine Return-Anweisung im Anweisungsblock. Die Struktur ruft einfach die Funktion print() auf, um die gewünschte Nachricht anzuzeigen. Der Aufruf einer solchen Funktion im Hauptprogramm ist ganz einfach und unkompliziert, wie unten gezeigt:

# 定义一个既无参数也无返回值的函数
def printSomething():
print('Hello world')

# 在主程序中直接调用
printSomething()

Die Ausgabe nach dem Ausführen des Programms ist:

Hello world

Funktion mit Parametern und ohne Rückgabewert

Eine andere Art von Funktion akzeptiert Variablen als Parameter. gibt aber keine Daten zurück. Im folgenden Beispiel wird eine Funktion mit ihrem deklarierten Namen aufgerufen, während in den Klammern der aufgerufenen Funktion ein Wert enthalten ist. Diese Werte werden an den Funktionskörper übergeben und können als gewöhnliche Variablen behandelt werden:

# 定义接收参数但无返回值的函数
def printMyName(fName, lName):
print('Your name is:', fName, lName)

# 提示用户输入姓名
firstName = input('Enter your first name: ')
lastName = input('Enter your last name: ')

# 在主程序中调用所定义的函数
printMyName(firstName, lastName)

Führen Sie das Programm aus. Die Ergebnisse ähneln den folgenden:

Enter your first name:Solo
Enter your last name: Cui
Your name is: Solo Cui

Funktion ohne Parameter und Rückgabewert

Der dritte Typ akzeptiert keine Parameter, gibt aber die Funktion der Daten zurück. Da diese Art von Funktion einen Wert an den aufrufenden Code zurückgibt, ist es wichtig zu bedenken, dass dieser Wert einer Variablen zugewiesen werden muss, bevor er verwendet oder verarbeitet werden kann. Ein Beispiel ist wie folgt:

# 定义无参数但有返回值的函数
def returnFloatNumber():
inputFloat = float(input('输入一个数字，其将返回给主程序：'))
return inputFloat

# 主程序调用函数并显示输入结果
x = returnFloatNumber()
print('输入的数字为:', x)

Das Ergebnis der Ausführung des Programms sieht in etwa wie folgt aus:

输入一个数字，其将返回给主程序: 5.7
输入的数字为:: 5.7

Funktion mit Parametern und Rückgabewert

Diese Art von Funktion akzeptiert Parameter und gibt Werte an den aufrufenden Code zurück. Situationsbeispiel unten. In diesem Fall muss der Funktionsaufruf eine Parameterliste enthalten und den Rückgabewert einer bestimmten Variablen zur späteren Verwendung zuweisen:

# 有参有返回值函数
def calculateSum(number1, number2):
print('计算两个数字和.')
return(number1 + number2)

# 接受用户输入的两个数字
num1 = float(input('输入第一个数字: '))
num2 = float(input('输入第二个数字: '))

# 调用函数计算俩个数字和
addNumbers = calculateSum(num1, num2)

# 输出两个数字和
print('两个数字和为:', addNumbers)

Das Ergebnis der Programmausführung sieht in etwa wie folgt aus:

输入第一个数字: 3
输入第二个数字: 5
计算两个数字和...
两个数字和为:: 8.0

Es ​​gibt zwei Möglichkeiten, eine Funktion zu übergeben Parameter

Es gibt verschiedene Möglichkeiten, Parameter an Funktionen zu übergeben. Die Wahl der beiden Methoden sollte davon abhängen, ob der Wert der ursprünglichen Variablen innerhalb der Funktion geändert werden kann. Es gibt zwei Möglichkeiten, Parameterwerte an eine Funktion zu übergeben, die normalerweise als Aufruf/Übergabe durch Wert und Aufruf/Übergabe durch Referenz bezeichnet werden.

Zusammengefasst: Funktionsparameterübertragung:

Erstens nach Wert: Der Parameter ist eine Kopie der Originalvariablen und behält die Kopie bei, ohne den Originalwert zu ändern.

Zweitens nach Referenz: Die Änderung wirkt sich direkt auf die Originalvariable aus Daher wird der ursprüngliche Wert geändert.

Aufrufen/Übergeben von Werten

In diesem Fall wird der Wert des tatsächlichen Parameters (formalen Parameters) als Kopie der Originalvariablen behandelt. Wenn daher die Programmkontrolle an den Aufrufer zurückgegeben wird, bleiben die ursprünglichen Variablen im Bereich des Aufrufers unverändert.

在Python中，如果将不可变参数(例如，整数和字符串)传递给函数，通常的做法是按值调用/传递参数。下面的示例通过介绍id()函数说明了这种情况。它接受一个对象作为参数(即id(object))，并返回这个特定对象的标识。Id()返回值是一个整数，它在对象的生命周期内是惟一的和永久的。如示例所示，在调用checkParamemterID函数之前，变量x的id为4564813232。需要注意的是，只要x的值没有更新，x的id在函数中就不会改变。但是，一旦该值更新为20，其对应的id将更改为4564813552。需要注意的最重要的一点是，x的id在调用函数后不会改变，它的原始值保持不变(4564813232)。这意味着对x值的更改应用于变量的副本，而不是调用者作用域内的原始变量。

示例代码如下：

#按值传递参数
# 定义函数'checkParameterID'，带参且按值传递
def checkParameterID(x):
print('在checkParameterID函数内x值改变之前其值为 ', x, 'n其id 为', id(x))
# 在函数范围内改变参数x的值
x = 20
print('checkParameterID中x的值改变后为', x, 'n 其id为', id(x))

# 在主程序声明变量x并赋予初始值
x = 10

print('调用checkParameterID函数之前x的值是', x, 'n 其id为', id(x))

# 调用'checkParameterID'函数
checkParameterID(x)

# 函数调用后在主程序中显示关于'x'的信息
print('调用checkParameterID函数后x的值为', x, 'n 其id为', id(x))

运行输出结果类似如下：

调用checkParameterID函数之前x的值是 10
其id为 2570870194704
在checkParameterID函数内x值改变之前其值为 10
其id 为 2570870194704
checkParameterID中x的值改变后为 20
其id为 2570870195024
调用checkParameterID函数后x的值为 10
其id为 2570870194704

按引用调用/传递

在这种情况下，函数获取实参(即原始变量)的引用，而不是它的副本。如果函数内发生更改，则调用者作用域中原始变量的值也将被修改。在Python中，如果可变参数(如列表)传递给函数，则调用/传递是通过引用进行的。如下所示，updateList将值5追加到名为y的列表中。即原始可变变量x的值发生了变化，这证明函数按引用调用/传递参数的特征。示例代码如下：

# 定义函数'upDateList' 其改变列表内的值
def updateList(y):
y = y.append(5)
return y

# 声明列表'x' 有四个元素值
x = [1, 2, 3, 4]
print('在调用updateList函数之前，x的内容是:', x)

# 调用函数'updateList'
print('调用函数updateList')
updateList(x)
print('调用updateList函数后x的内容为:', x)

运行程序输出结果类似如下：

在调用updateList函数之前，x的内容是: [1, 2, 3, 4]
调用函数updateList
调用updateList函数后x的内容为: [1, 2, 3, 4, 5]

本文小结

本期内容介绍了函数的基本内容和实现语法，以及参数传递、有无参数和返回值的函数形式以及函数调用/传递的实现。

Das obige ist der detaillierte Inhalt vonPython-Programmierung: Beherrschen Sie ganz einfach Funktionsdefinitionen, Typen und die Übergabe von Parametern. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!