Fonctions Python3
Une fonction est un segment de code organisé et réutilisable utilisé pour implémenter une fonction unique ou associée. Les fonctions
peuvent améliorer la modularité des applications et la réutilisation du code. Vous savez déjà que Python fournit de nombreuses fonctions intégrées, telles que print(). Mais vous pouvez également créer vos propres fonctions, appelées fonctions définies par l'utilisateur.
Définir une fonction
Vous pouvez définir une fonction avec la fonction que vous souhaitez, voici les règles simples :
Code de fonction A Le bloc commence par le mot-clé def, suivi du nom de l'identifiant de la fonction et des parenthèses ().
Tous les paramètres entrants et variables indépendantes doivent être placés entre parenthèses, et les espaces entre parenthèses peuvent être utilisés pour définir les paramètres.
La première ligne d'une fonction peut éventuellement utiliser une docstring - utilisée pour stocker les descriptions de fonctions.
Le contenu de la fonction commence par deux points et est en retrait.
return [expression] Termine la fonction, renvoyant éventuellement une valeur à l'appelant. Renvoyer sans expression équivaut à renvoyer Aucun.
Syntaxe
Python définit les fonctions à l'aide du mot clé def, le format général est le suivant :
def 函数名（参数列表）: 函数体
Par défaut, les valeurs des paramètres et noms de paramètres Ils correspondent dans l'ordre défini dans la déclaration de fonction.
Exemple
Utilisons une fonction pour afficher "Hello World!":
>>> def hello() :
print("Hello World!")
>>> hello()
Hello World!
>>>Pour une application plus complexe, apportez des variables de paramètre dans la fonction:
#!/usr/bin/python3
# 计算面积函数
def area(width, height):
return width * height
def print_welcome(name):
print("Welcome", name)
print_welcome("php")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h)) Résultat de sortie de l'exemple ci-dessus :
Welcome php width = 4 height = 5 area = 20
Appel de fonction
Définir une fonction : donner un nom à la fonction, spécifier les paramètres contenus dans la fonction et le bloc de code structure.
Une fois la structure de base de cette fonction terminée, vous pouvez l'exécuter via un autre appel de fonction ou directement à partir de l'invite de commande Python.
L'exemple suivant appelle la fonction printme() :
#!/usr/bin/python3
# 定义函数
def printme( str ):
"打印任何传入的字符串"
print (str);
return;
# 调用函数
printme("我要调用用户自定义函数!");
printme("再次调用同一函数");Le résultat de sortie de l'exemple ci-dessus :
我要调用用户自定义函数! 再次调用同一函数
Passer des paramètres par valeur et passer des paramètres par référence
En Python, tous les paramètres (variables) sont passés par référence. Si vous modifiez les paramètres dans la fonction, les paramètres d'origine seront également modifiés dans la fonction qui appelle cette fonction. Par exemple :
#!/usr/bin/python3
# 可写函数说明
def changeme( mylist ):
"修改传入的列表"
mylist.append([1,2,3,4]);
print ("函数内取值: ", mylist)
return
# 调用changeme函数
mylist = [10,20,30];
changeme( mylist );
print ("函数外取值: ", mylist)L'objet passé dans la fonction et l'objet pour ajouter du nouveau contenu à la fin utilisent la même référence. Par conséquent, le résultat est le suivant :
函数内取值: [10, 20, 30, [1, 2, 3, 4]] 函数外取值: [10, 20, 30, [1, 2, 3, 4]]
Paramètres
Voici les types de paramètres formels qui peuvent être utilisés lors de l'appel de fonctions :
Paramètres requis
Paramètres des mots clés
Paramètres par défaut
Paramètres de longueur variable
Paramètres requis
Les paramètres requis doivent être transmis à la fonction dans le bon ordre. La quantité au moment de l'appel doit être la même que lors de la déclaration.
Lors de l'appel de la fonction printme(), vous devez passer un paramètre, sinon une erreur de syntaxe se produira :
#!/usr/bin/python3 #可写函数说明 def printme( str ): "打印任何传入的字符串" print (str); return; #调用printme函数 printme();
Le résultat de sortie de l'exemple ci-dessus :
Traceback (most recent call last): File "test.py", line 10, in <module> printme(); TypeError: printme() missing 1 required positional argument: 'str'
Paramètres de mots-clés
Les paramètres de mots-clés sont étroitement liés aux appels de fonction. Les appels de fonction utilisent des paramètres de mots-clés pour déterminer les valeurs des paramètres transmises.
L'utilisation d'arguments de mots clés permet à la fonction d'être appelée dans un ordre différent de celui lors de sa déclaration, car l'interpréteur Python est capable de faire correspondre les noms de paramètres avec les valeurs des paramètres.
Les exemples suivants utilisent des noms de paramètres lors de l'appel de la fonction printme() :
#!/usr/bin/python3 #可写函数说明 def printme( str ): "打印任何传入的字符串" print (str); return; #调用printme函数 printme( str = "php中文网");
Les résultats de sortie des exemples ci-dessus :
php中文网
Les exemples suivants démontrent l'utilisation des paramètres de fonction et n'ont pas besoin d'être utilisés Précisez l'ordre :
#!/usr/bin/python3
#可写函数说明
def printinfo( name, age ):
"打印任何传入的字符串"
print ("名字: ", name);
print ("年龄: ", age);
return;
#调用printinfo函数
printinfo( age=50, name="php" );Résultat de sortie de l'exemple ci-dessus :
名字: php 年龄: 50
Paramètres par défaut
Lors de l'appel de la fonction, si aucun paramètre n'est transmis , les paramètres par défaut seront utilisés. Dans l'exemple suivant, si le paramètre age n'est pas transmis, la valeur par défaut est utilisée :
#!/usr/bin/python3
#可写函数说明
def printinfo( name, age = 35 ):
"打印任何传入的字符串"
print ("名字: ", name);
print ("年龄: ", age);
return;
#调用printinfo函数
printinfo( age=50, name="php" );
print ("------------------------")
printinfo( name="php" );Le résultat de sortie de l'exemple ci-dessus :
名字: php 年龄: 50 ------------------------ 名字: php 年龄: 35
Paramètre de longueur variable
Vous aurez peut-être besoin d'une fonction pour gérer Plus de paramètres que ceux initialement déclarés. Ces paramètres sont appelés paramètres de longueur variable. Contrairement aux deux paramètres ci-dessus, ils ne seront pas nommés lors de leur déclaration. La syntaxe de base est la suivante :
def functionname([formal_args,] *var_args_tuple ): "函数_文档字符串" function_suite return [expression]
Les noms de variables avec un astérisque (*) stockeront tous les paramètres de variables sans nom. Si aucun paramètre n'est spécifié lors de l'appel de la fonction, il s'agit d'un tuple vide. Nous ne pouvons pas non plus transmettre de variables sans nom à la fonction. L'exemple suivant :
#!/usr/bin/python3
# 可写函数说明
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
for var in vartuple:
print (var)
return;
# 调用printinfo 函数
printinfo( 10 );
printinfo( 70, 60, 50 );Le résultat de sortie de l'exemple ci-dessus :
输出: 10 输出: 70 60 50
Fonction anonyme
Python utilise lambda pour créer des fonctions anonymes.
Le soi-disant anonyme signifie que vous n'utilisez plus la forme standard d'instruction def pour définir une fonction.
lambda n'est qu'une expression, et la fonction body est beaucoup plus simple que def.
Le corps de lambda est une expression, pas un bloc de code. Seule une logique limitée peut être encapsulée dans des expressions lambda.
La fonction lambda a son propre espace de noms et ne peut pas accéder aux paramètres en dehors de sa propre liste de paramètres ou dans l'espace de noms global.
Bien que la fonction lambda semble pouvoir écrire une seule ligne, elle n'est pas équivalente à la fonction inline du C ou du C++. Le but de cette dernière est d'appeler une petite fonction. sans occuper la mémoire de la pile et augmenter ainsi l'efficacité du temps d'exécution.
Syntaxe
La syntaxe de la fonction lambda ne contient qu'une seule instruction, comme suit :
lambda [arg1 [,arg2,.....argn]]:expression
L'exemple suivant :
#!/usr/bin/python3
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))L'exemple de résultat ci-dessus Résultat :
相加后的值为 : 30 相加后的值为 : 40
instruction return
return [expression] L'instruction est utilisée pour quitter la fonction, renvoyant éventuellement une expression au demandeur. Une instruction return sans valeurs de paramètres renvoie None. Les exemples précédents n'ont pas montré comment renvoyer une valeur. L'exemple suivant montre l'utilisation de l'instruction return :
#!/usr/bin/python3
# 可写函数说明
def sum( arg1, arg2 ):
# 返回2个参数的和."
total = arg1 + arg2
print ("函数内 : ", total)
return total;
# 调用sum函数
total = sum( 10, 20 );
print ("函数外 : ", total)Le résultat de sortie de l'exemple ci-dessus :
函数内 : 30 函数外 : 30
Portée variable
En Python, les variables du programme ne sont pas accessibles depuis tous les emplacements. Les autorisations d'accès dépendent de l'endroit où la variable reçoit une valeur.
