Programmation Python : maîtrisez facilement les définitions de fonctions, les types et la transmission des paramètres

Avant-propos

Cet article vous aide à comprendre et à maîtriser facilement la fonctionnalité principale du langage Python - les fonctions : définir la syntaxe et la forme de la fonction, et présenter deux façons de transmettre les paramètres de la fonction.

Signification de la fonction

Une fonction est un bloc d'instructions qui effectue une tâche spécifique. C'est une partie du code qui permet aux programmeurs de la réutiliser, ce qui favorise le concept modulaire des logiciels. L’idée principale derrière cette approche est de diviser un gros bloc de code en parties indépendantes plus petites et donc en sous-blocs plus gérables. Il existe deux types de fonctions en Python :

Fonctions intégrées (Build-in) : Vous pouvez utiliser ces fonctions directement dans le programme sans les définir lors de la programmation. Ce type de fonction est souvent utilisé lors de l'apprentissage initial (par exemple, print(), input(), sum(), etc.).

Fonctions définies par l'utilisateur : Python permet aux programmeurs de créer leurs propres fonctions. Ce type de fonction spécifique sera mis en évidence ensuite.

En bref, une fonction est un bloc structuré d'instructions qui est défini et peut être appelé à plusieurs reprises. La fonction a un nom unique, peut recevoir des paramètres et renvoie le résultat correspondant (valeur) à l'appelant selon les besoins, ou ne renvoie pas de valeur.

Définition des fonctions

Les principales règles de définition des fonctions en Python sont les suivantes :

• Un bloc fonction commence par le mot-clé def, suivi du nom de la fonction et des parenthèses. Notez que Python étant sensible à la casse, def doit être utilisé à la place de Def.
• Semblables aux noms de variables, les noms de fonctions peuvent contenir des lettres ou des chiffres, mais ne contiennent pas d'espaces ni de caractères spéciaux et ne peuvent pas commencer par un chiffre.
• Les paramètres d'entrée facultatifs (appelés arguments) doivent être placés entre parenthèses - le nombre et le type de paramètres dépendent des besoins.
• Le nom de la fonction est suivi de deux points. Habituellement, le bloc d'instructions de la fonction commence par une nouvelle ligne après les deux points et est en retrait.
• Les fonctions qui renvoient des données doivent contenir le mot-clé return dans leur bloc de code.

En résumé, il existe quatre types de fonctions :

• fonctions sans paramètres ni valeurs de retour ;
• fonctions avec paramètres et valeurs de retour ;
• fonctions sans paramètres ni valeurs de retour ; fonction.
• Le format syntaxique de la définition de la fonction est le suivant :

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

Selon la présence ou l'absence de paramètres réels et la présence de valeurs d'entrée et/ou de retour, les fonctions peuvent être divisées en quatre types possibles ci-dessus. Ils seront présentés séparément ci-dessous.

Fonction sans paramètres ni valeur de retour

Dans ce type, la fonction n'accepte pas de variables comme paramètres et ne renvoie aucune donnée. Par exemple, la démonstration de script suivante est une telle fonction, qui imprime uniquement une chaîne prédéfinie à l'écran.

Le code est évident. Il y a des paramètres formels dans la définition, aucun paramètre réel lors de l'appel et aucune instruction return dans le bloc d'instructions. La structure appelle simplement la fonction print() pour afficher le message souhaité. L'appel d'une telle fonction dans le programme principal est assez simple et direct, comme indiqué ci-dessous :

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

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

La sortie après l'exécution du programme est :

Hello world

Fonction avec paramètres et aucune valeur de retour

Un autre type de fonction accepte des variables comme paramètres , mais ne renvoie aucune donnée. Dans l'exemple suivant, une fonction est appelée par son nom déclaré tout en incluant une valeur entre parenthèses de la fonction appelée. Ces valeurs sont transmises au corps de la fonction et peuvent être traitées comme des variables ordinaires :

# 定义接收参数但无返回值的函数
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)

Exécutez le programme, les résultats sont similaires aux suivants :

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

Fonction sans paramètres et valeur de retour

Le troisième type n'accepte pas les paramètres mais renvoie la fonction des données. Il est important de rappeler que puisque ce type de fonction renvoie une valeur au code appelant, cette valeur doit être affectée à une variable avant de pouvoir être utilisée ou traitée. Un exemple est le suivant :

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

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

Le résultat de l'exécution du programme est similaire au suivant :

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

Fonction avec paramètres et valeur de retour

Ce type de fonction accepte les paramètres et renvoie la valeur au code appelant. Exemple de situation ci-dessous. Dans ce cas, l'appel de fonction doit contenir une liste de paramètres et attribuer la valeur de retour à une variable spécifique pour une utilisation ultérieure :

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

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

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

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

Le résultat de l'exécution du programme est similaire au suivant :

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

Il existe deux façons de transmettre la fonction paramètres

Il existe différentes manières de transmettre des paramètres aux fonctions. Déterminer laquelle des deux méthodes choisir doit dépendre de la possibilité ou non de modifier la valeur de la variable d'origine dans la fonction. Il existe deux manières de transmettre des valeurs de paramètres à une fonction, généralement appelées appel/passage par valeur et appel/passage par référence.

En résumé, la fonction transfert de paramètres :

D'abord, par valeur : le paramètre est une copie de la variable d'origine, en conservant la copie sans changer la valeur d'origine ;

Deuxièmement, par référence : le changement agit directement sur la variable d'origine ; , Par conséquent, la valeur d'origine est modifiée.

Appel/passage par valeur

Dans ce cas, la valeur du paramètre réel (paramètre formel) est traitée comme une copie de la variable d'origine. Par conséquent, lorsque le contrôle du programme revient à l'appelant, les variables d'origine dans la portée de l'appelant restent inchangées.

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

本文小结

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!