fonction python3

La fonction est une bonne organisation, réutilisable, utilisé pour obtenir un segment de code unique, ou des fonctions associées.

La fonction peut être appliquée pour améliorer la modularité et la réutilisation du code. Vous savez déjà que Python offre de nombreuses fonctions intégrées, telles que print (). Mais vous pouvez aussi créer votre propre fonction, qui est appelé une fonction définie par l'utilisateur.

Définir une fonction

Vous pouvez définir une fonction à partir de la fonction que vous voulez, les règles simples suivantes:

• Bloc de fonctiondef mot - clé au début, suivi du nom et des identifiants fonction entre parenthèses ().
• Tous les paramètres et les arguments entrants doivent être placés entre parenthèses dans le milieu, il peut être utilisé pour définir les paramètres entre parenthèses.
• La première ligne de la déclaration de fonction peut éventuellement utiliser un document de chaîne - sont utilisés pour la description de la fonction.
• le contenu de la fonction à partir de deux points et l'indentation.
• return [expression] fin de la fonction, le cas échéant retourner une valeur à l'appelant. revenir sans une expression équivalente à retourner Aucun.

grammaire

Les fonctions Python définies en utilisant def mot-clé, le format général est le suivant:

def 函数名（参数列表）:
    函数体

Par défaut, le nom du paramètre et le paramètre valeur est dans l'ordre défini dans la déclaration de fonction correspond jusqu'à.

Exemples

Nous allons utiliser la fonction de sortie "Bonjour tout le monde!":

>>> def hello() :
   print("Hello World!")

   
>>> hello()
Hello World!
>>> 

Application de point de plus complexe, pour amener les variables de paramètres de fonction:

#!/usr/bin/python3

# 计算面积函数
def area(width, height):
    return width * height
 
def print_welcome(name):
    print("Welcome", name)

print_welcome("w3big")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h))

Des exemples de sortie ci-dessus:

Welcome w3big
width = 4  height = 5  area = 20

appel de fonction

Définir une fonction: donner la fonction d'un nom, spécifiez les paramètres de la fonction contient, et la structure du bloc de code.

Après l'achèvement de la structure de base de cette fonction, vous pouvez effectuer une autre fonction appel à être exécuté directement à partir de l'invite de commande Python.

Les exemples suivants sont appelés fonction PrintMe ():

#!/usr/bin/python3
 
# 定义函数
def printme( str ):
   "打印任何传入的字符串"
   print (str);
   return;
 
# 调用函数
printme("我要调用用户自定义函数!");
printme("再次调用同一函数");

Des exemples de sortie ci-dessus:

我要调用用户自定义函数!
再次调用同一函数

Les paramètres passés par des paramètres de valeur et passe par référence

En Python, tous les paramètres (variables) sont passés par référence. Si vous modifiez un paramètre dans une fonction, cette fonction est appelée fonction, les paramètres d'origine sont également changé. 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)

Et passé dans la fonction de l'objet à la fin pour ajouter du nouveau contenu en utilisant la même référence. Par conséquent, les résultats de sortie sont les suivantes:

函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

Paramètres

Ce qui suit est le type de paramètre formel peut être utilisé lors de l'appel de la fonction:

• Les paramètres requis
• arguments de mots-clés
• Les paramètres par défaut
• paramètres de longueur variable

Les paramètres requis

Les paramètres requis dans le bon ordre pour être transmis à la fonction. Lorsque le nombre d'appels et doit être la même déclaration.

PrintMe Call () de fonction, vous devez passer dans un paramètre, ou d'une erreur de syntaxe se produit:

#!/usr/bin/python3
 
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str);
   return;
 
#调用printme函数
printme();

Des exemples de sortie ci-dessus:

Traceback (most recent call last):
  File "test.py", line 10, in <module>
    printme();
TypeError: printme() missing 1 required positional argument: 'str'

arguments de mots-clés

arguments et la fonction de mots-clés appelle un gros appel de fonction de la relation en utilisant des arguments de mots clés pour déterminer la valeur du paramètre passé.

Lorsque vous utilisez le paramètre mot-clé permet le paramètre appel de fonction de commande est incompatible avec la déclaration, parce interpréteur Python capable de faire correspondre les valeurs des paramètres en utilisant le nom du paramètre.

La fonction exemple suivant PrintMe () est appelée avec le nom du paramètre:

#!/usr/bin/python3
 
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str);
   return;
 
#调用printme函数
printme( str = "本教程");

Des exemples de sortie ci-dessus:

本教程

L'exemple suivant illustre l'utilisation de paramètres de la fonction n'a pas besoin d'utiliser l'ordre indiqué:

#!/usr/bin/python3
 
#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print ("名字: ", name);
   print ("年龄: ", age);
   return;
 
#调用printinfo函数
printinfo( age=50, name="w3big" );

Des exemples de sortie ci-dessus:

名字:  w3big
年龄:  50

Les paramètres par défaut

Lorsque la fonction est appelée, si le paramètre est pas passé, il utilisera les paramètres par défaut. L'exemple suivant, si aucun paramètre d'âge entrant, la valeur par défaut:

#!/usr/bin/python3
 
#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name);
   print ("年龄: ", age);
   return;
 
#调用printinfo函数
printinfo( age=50, name="w3big" );
print ("------------------------")
printinfo( name="w3big" );

Des exemples de sortie ci-dessus:

名字:  w3big
年龄:  50
------------------------
名字:  w3big
年龄:  35

paramètres de longueur variable

Vous devrez peut-être une fonction qui peut gérer plus de la déclaration d'origine des paramètres. Ces paramètres sont appelés paramètres de longueur variable, et les deux types de paramètres sont différents, ne nommant déclaration. La syntaxe de base est la suivante:

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]

Avec un astérisque (*) seront stockées dans les noms de variables, tous les paramètres variables sans nom. Si aucun argument lorsque la fonction est appelée, elle est un tuple vide. Nous ne pouvons pas passer la variable sans nom à une fonction. Les exemples qui suivent:

#!/usr/bin/python3
 
# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   for var in vartuple:
      print (var)
   return;
 
# 调用printinfo 函数
printinfo( 10 );
printinfo( 70, 60, 50 );

Des exemples de sortie ci-dessus:

输出:
10
输出:
70
60
50

Anonyme fonction

python utilisant lambda pour créer une fonction anonyme.

Le soi-disant anonyme, ce qui signifie ne plus utiliser cette déclaration sous forme de définition standard pour définir une fonction.

• Juste une expression lambda, le corps de la fonction est beaucoup plus simple que def.
• Le corps est une expression lambda, plutôt que d'un bloc de code. Nous ne pouvons emballer une logique limitée dans l'expression lambda.
• fonction lambda a son propre espace de noms, et ne peut être consulté à l'extérieur de sa propre liste d'arguments ou les paramètres globaux d'espace de noms.
• Bien que la fonction lambda semble n'écrire une seule ligne, mais pas les mêmes que les fonctions inline en C ou C ++, ce dernier objectif n'est pas occupé lors de l'appel de la fonction de mémoire de pile faible pour augmenter l'efficacité de fonctionnement.

grammaire

syntaxe de la fonction Lambda ne contient qu'une seule déclaration, comme suit:

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

Les exemples qui suivent:

#!/usr/bin/python3
 
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

Des exemples de sortie ci-dessus:

相加后的值为 :  30
相加后的值为 :  40

instruction de retour

return [expression] instruction est utilisée pour quitter la fonction, de manière sélective à l'appelant renvoie une expression.instruction de retour sans paramètres retourne None. Aucun exemples précédents démontrent comment retourner une valeur, l'exemple suivant illustre l'utilisation de la déclaration de retour:

#!/usr/bin/python3

# 可写函数说明
def sum( arg1, arg2 ):
   # 返回2个参数的和."
   total = arg1 + arg2
   print ("函数内 : ", total)
   return total;

# 调用sum函数
total = sum( 10, 20 );
print ("函数外 : ", total)

Des exemples de sortie ci-dessus:

函数内 :  30
函数外 :  30

Portée variable

Pyhton, la variable ne soit pas la position dans laquelle le programme peut avoir accès, l'accès dépend de l'endroit où la variable est affectée.

#!/usr/bin/python3

total = 0; # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
    #返回2个参数的和."
    total = arg1 + arg2; # total在这里是局部变量.
    print ("函数内是局部变量 : ", total)
    return total;

#调用sum函数
sum( 10, 20 );
print ("函数外是全局变量 : ", total)

函数内是局部变量 :  30
函数外是全局变量 :  0