fonction Python

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 fonction def 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

def functionname( parameters ):
   "函数_文档字符串"
   function_suite
   return [expression]

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

Ce qui suit est une simple fonction Python, en passant une chaîne comme paramètre, puis imprimer sur le dispositif d'affichage standard.

def printme( str ):
   "打印传入的字符串到标准显示设备上"
   print str
   return

appel de fonction

Définir une fonction uniquement à un nom de fonction, spécifiez les paramètres et la structure du bloc de code contient la fonction.

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 Python.

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

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 定义函数
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

Tous les paramètres (arguments) en Python 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/python
# -*- coding: UTF-8 -*-
 
# 可写函数说明
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:

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

paramètre obligatoire

Paramètre obligatoire à passer à la fonction dans l'ordre correct. 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/python
# -*- coding: UTF-8 -*-
 
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print str;
   return;
 
#调用printme函数
printme();

Des exemples de sortie ci-dessus:

Traceback (most recent call last):
  File "test.py", line 11, in <module>
    printme();
TypeError: printme() takes exactly 1 argument (0 given)

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/python
# -*- coding: UTF-8 -*-
 
#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print str;
   return;
 
#调用printme函数
printme( str = "My string");

Des exemples de sortie ci-dessus:

My string

L'exemple suivant peut commander l'argument mot-clé est pas importante exposition plus clairement:

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print "Name: ", name;
   print "Age ", age;
   return;
 
#调用printinfo函数
printinfo( age=50, name="miki" );

Des exemples de sortie ci-dessus:

Name:  miki
Age  50

Les paramètres par défaut

Lorsque la fonction est appelée, la valeur par défaut si le paramètre est pas passé, la valeur par défaut est considéré. Par défaut imprimer réunion ordinaire de l'âge, si l'âge ne sont pas transmises:

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print "Name: ", name;
   print "Age ", age;
   return;
 
#调用printinfo函数
printinfo( age=50, name="miki" );
printinfo( name="miki" );

Des exemples de sortie ci-dessus:

Name:  miki
Age  50
Name:  miki
Age  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. paramètres Pass peuvent être peu de choix. Les exemples qui suivent:

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 可写函数说明
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.

• 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/python
# -*- coding: UTF-8 -*-
 
# 可写函数说明
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

Déclaration retour [expression] pour quitter la fonction 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 va vous montrer comment le faire:

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
# 可写函数说明
def sum( arg1, arg2 ):
   # 返回2个参数的和."
   total = arg1 + arg2
   print "函数内 : ", total
   return total;
 
# 调用sum函数
total = sum( 10, 20 );

Des exemples de sortie ci-dessus:

函数内 :  30

Portée variable

Toutes les variables dans un programme qui ne soit pas une position qui peut être consulté. L'accès dépend de l'endroit où la variable est affectée.

#!/usr/bin/python
# -*- coding: UTF-8 -*-

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

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