Fonctions Python

Une fonction est un bloc de code organisé et réutilisable utilisé pour effectuer une action unique ou une action connexe.

Les fonctions aident à 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(). 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 fonctionnalité souhaitée. Voici les règles simples :

  • Les blocs de code de fonction commencent pardefle mot-clé, suivi du nom d'identifiant de fonction et de parenthèses.()。
  • Tous les paramètres et arguments entrants doivent être placés entre les parenthèses. Les parenthèses peuvent être utilisées pour définir des paramètres.
  • La première instruction d'une fonction peut éventuellement être une docstring — utilisée pour stocker une description de fonction.
  • Le corps de la fonction commence par un deux-points et est indenté.
  • return [expression]Termine la fonction, en renvoyant éventuellement une valeur à l'appelant. Un return sans expression équivaut à renvoyer None.

Syntaxe

def functionname( parameters ): "function_docstring" function_suite return [expression]

Par défaut, les valeurs des paramètres et les noms des paramètres sont mis en correspondance dans l'ordre défini dans la déclaration de la fonction.

Exemple

Ce qui suit est une simple fonction Python qui prend une chaîne comme paramètre entrant et l'affiche sur le périphérique d'affichage standard.

Exemple (Python 2.0+)

def printme( str ): "Affiche la chaîne transmise sur le périphérique d'affichage standard." print str return

Appel d'une fonction

Définir une fonction ne fait que donner un nom à la fonction, spécifier les paramètres qu'elle contient et la structure du bloc de code.

Une fois la structure de base de cette fonction terminée, vous pouvez l'appeler et l'exécuter à partir d'une autre fonction, ou directement depuis l'invite Python.

L'exemple suivant appelle la fonction printme() :

Exemple (Python 2.0+)

#!/usr/bin/python # -*- coding: UTF-8 -*- # Définir la fonction def printme( str ): "Afficher toute chaîne transmise" print str return # Appeler la fonction printme("J'appelle une fonction définie par l'utilisateur !") printme("Appeler à nouveau la même fonction")

La sortie de l'exemple ci-dessus est :

I want to call a user-defined function!
Call the same function again

Passage de paramètres

En Python, les types appartiennent aux objets, et les variables ne sont pas typées :

a=[1,2,3] a="Exemple"

Dans le code ci-dessus,[1,2,3]est de type List,"Example"est de type String, tandis que la variable a n'a pas de type. Elle n'est qu'une référence (un pointeur) vers un objet. Elle peut être un objet de type List, ou elle peut pointer vers un objet de type String.

Objets mutables et immuables

En Python, les chaînes, les tuples et les nombres sont des objets immuables, tandis que list, dict, etc. sont des objets mutables.

  • Types immuables :Affectation de variablea=5puis affecter à nouveaua=10Ici, un nouvel objet de valeur int 10 est réellement généré, puis a est amené à pointer vers lui, tandis que 5 est abandonné. Cela ne change pas la valeur de a ; cela équivaut à créer un nouveau a.

  • Types mutables :Affectation de variablela=[1,2,3,4]puis affecter à nouveaula[2]=5Cela change la valeur du troisième élément de la liste la. La variable la elle-même n'est pas déplacée ; seules certaines de ses valeurs internes sont modifiées.

Passage de paramètres dans les fonctions Python :

  • Types immuables :Similaire au passage par valeur en C++, comme les entiers, les chaînes, les tuples. Par exemple, fun(a) transmet uniquement la valeur de a, sans affecter l'objet a lui-même. Par exemple, modifier la valeur de a à l'intérieur de fun(a) ne modifie qu'un autre objet copié, pas a lui-même.

  • Types mutables :Similaire au passage par référence en C++, comme les listes et les dictionnaires. Par exemple, fun(la) transmet en réalité la variable la elle-même ; après modification, la variable la en dehors de fun est également affectée.

En Python, tout est un objet. À proprement parler, on ne peut pas dire passage par valeur ou passage par référence ; on devrait dire passage d'objets immuables et passage d'objets mutables.

Exemple de passage d'objet immuable en Python

Exemple (Python 2.0+)

#!/usr/bin/python # -*- coding: UTF-8 -*- def ChangeInt( a ): a = 10 b = 2 ChangeInt(b) print b # Le résultat est 2

Dans l'exemple, il y a un objet int 2, et la variable qui pointe vers lui est b. Lorsqu'elle est passée à la fonction ChangeInt, la variable b est copiée selon un passage par valeur, donc a et b pointent tous deux vers le même objet int. Lorsque a=10, un nouvel objet de valeur int 10 est généré, et on fait pointer a vers lui.

Exemple de passage d'objet mutable

Exemple (Python 2.0+)

#!/usr/bin/python # -*- coding: UTF-8 -*- # Définition de fonction def changeme( mylist ): "Modifier la liste passée" mylist.append([1,2,3,4]) print "Valeur à l'intérieur de la fonction :", mylist return # Appeler la fonction changeme mylist = [10,20,30] changeme( mylist ) print "Valeur en dehors de la fonction :", mylist

Dans l'exemple, l'objet transmis à la fonction et l'objet auquel un nouveau contenu est ajouté à la fin utilisent la même référence, donc la sortie est la suivante :

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

Parameters

Voici les types de paramètres formels qui peuvent être utilisés lors de l'appel d'une fonction :

  • Paramètres obligatoires
  • Arguments par mot-clé
  • Arguments par défaut
  • Paramètres de longueur variable

Paramètres obligatoires

Les paramètres obligatoires doivent être passés à la fonction dans le bon ordre. Le nombre d'arguments au moment de l'appel doit être identique au nombre au moment de la déclaration.

Pour appeler la fonction printme(), vous devez passer un paramètre ; sinon, une erreur de syntaxe se produira :

Exemple (Python 2.0+)

#!/usr/bin/python # -*- coding: UTF-8 -*- # Définition de fonction def printme( str ): "Afficher toute chaîne transmise" print str return # Appeler la fonction printme printme()

La sortie de l'exemple ci-dessus est :

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

Arguments par mot-clé

Les arguments nommés sont étroitement liés aux appels de fonction. Les appels de fonction utilisent des arguments nommés pour déterminer les valeurs des paramètres transmis.

L'utilisation d'arguments nommés permet que l'ordre des paramètres dans un appel de fonction ne soit pas le même que l'ordre dans la déclaration, car l'interpréteur Python peut faire correspondre les valeurs des paramètres en utilisant les noms des paramètres.

L'exemple suivant utilise les noms des paramètres lors de l'appel de la fonction printme() :

Exemple (Python 2.0+)

#!/usr/bin/python # -*- coding: UTF-8 -*- # Définition de fonction def printme( str ): "Afficher toute chaîne transmise" print str return # Appeler la fonction printme printme( str = "My string")

La sortie de l'exemple ci-dessus est :

My string

L'exemple suivant démontre plus clairement que l'ordre des arguments nommés n'a pas d'importance :

Exemple (Python 2.0+)

#!/usr/bin/python # -*- coding: UTF-8 -*- # Définition de fonction def printinfo( name, age ): "Affiche toute chaîne transmise" print "Name: ", name print "Age ", age return # Appeler la fonction printinfo printinfo( age=50, name="miki" )

La sortie de l'exemple ci-dessus est :

Name:  miki
Age  50

Arguments par défaut

Lors de l'appel d'une fonction, si la valeur d'un paramètre par défaut n'est pas transmise, elle est considérée comme la valeur par défaut. L'exemple suivant affichera l'âge par défaut si age n'est pas transmis :

Exemple (Python 2.0+)

#!/usr/bin/python # -*- coding: UTF-8 -*- # Définition de fonction def printinfo( name, age = 35 ): "Affiche toute chaîne transmise" print "Name: ", name print "Age ", age return # Appeler la fonction printinfo printinfo( age=50, name="miki" ) printinfo( name="miki" )

La sortie de l'exemple ci-dessus est :

Name:  miki
Age  50
Name:  miki
Age  35

Paramètres de longueur variable

Vous pouvez avoir besoin d'une fonction pouvant gérer plus de paramètres que ceux spécifiés dans la déclaration d'origine. Ces paramètres sont appelés paramètres de longueur variable. Contrairement aux deux types ci-dessus, ils ne sont pas nommés dans la déclaration. La syntaxe de base est la suivante :

def functionname([formal_args,] *var_args_tuple ): "function_docstring" function_suite return [expression]

Les noms de variables préfixés par un astérisque (*) stockeront tous les paramètres variables non nommés. Un exemple de paramètres de longueur variable est le suivant :

Exemple (Python 2.0+)

#!/usr/bin/python # -*- coding: UTF-8 -*- # Définition de fonction def printinfo( arg1, *vartuple ): "Afficher tous les paramètres transmis" print "Sortie :" print arg1 for var in vartuple: print var return # Appeler la fonction printinfo printinfo( 10 ) printinfo( 70, 60, 50 )

La sortie de l'exemple ci-dessus est :

输出:
10
输出:
70
60
50

Fonctions anonymes

Python utilise lambda pour créer des fonctions anonymes.

  • Lambda n'est qu'une expression ; le corps de la fonction est bien plus simple que def.
  • Le corps d'une lambda est une expression, et non un bloc de code. Seule une logique limitée peut être encapsulée dans une expression lambda.
  • Les fonctions lambda ont leur propre espace de noms et ne peuvent pas accéder aux paramètres en dehors de leur propre liste de paramètres ou dans l'espace de noms global.
  • Bien que les fonctions lambda semblent être écrites sur une seule ligne, elles ne sont pas équivalentes aux fonctions inline en C ou C++, dont le but est d'éviter d'occuper la mémoire de pile lors de l'appel de petites fonctions afin d'augmenter l'efficacité opérationnelle.

Syntaxe

La syntaxe d'une fonction lambda ne contient qu'une seule instruction, comme suit :

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

L'exemple suivant :

Exemple (Python 2.0+)

#!/usr/bin/python # -*- coding: UTF-8 -*- # Description de la fonction sum = lambda arg1, arg2: arg1 + arg2 # Appeler la fonction sum print "La valeur après addition est :", sum( 10, 20 ) print "La valeur après addition est :", sum( 20, 20 )

La sortie de l'exemple ci-dessus est :

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

Instruction return

L'instruction return [expression] quitte la fonction et renvoie éventuellement une expression à l'appelant. Une instruction return sans valeur de paramètre renvoie None. Les exemples précédents ne montraient pas comment renvoyer une valeur ; l'exemple suivant vous montre comment :

Exemple (Python 2.0+)

#!/usr/bin/python # -*- coding: UTF-8 -*- # Description de la fonction def sum( arg1, arg2 ): # Renvoie la somme de 2 paramètres." total = arg1 + arg2 print "À l'intérieur de la fonction :", total return total # Appeler la fonction sum total = sum( 10, 20 )

La sortie de l'exemple ci-dessus est :

函数内 :  30

Portée des variables

Les variables d'un programme ne sont pas toutes accessibles depuis n'importe quel endroit. Les droits d'accès dépendent de l'endroit où la variable est affectée.

La portée d'une variable détermine dans quelle partie du programme vous pouvez accéder à un nom de variable particulier. Les deux portées de variables les plus fondamentales sont les suivantes :
  • Variables globales
  • Variables locales

Variables globales et locales

Les variables définies à l'intérieur d'une fonction ont une portée locale, tandis que celles définies à l'extérieur d'une fonction ont une portée globale.

Les variables locales ne sont accessibles qu'à l'intérieur de la fonction dans laquelle elles sont déclarées, tandis que les variables globales sont accessibles dans tout le programme. Lorsqu'une fonction est appelée, tous les noms de variables déclarés dans la fonction sont ajoutés à la portée. Comme dans l'exemple suivant :

Exemple (Python 2.0+)

#!/usr/bin/python # -*- coding: UTF-8 -*- total = 0 # Ceci est une variable globale # Description de la fonction def sum( arg1, arg2 ): # Renvoie la somme de 2 paramètres." total = arg1 + arg2 # total est une variable locale ici. print "À l'intérieur de la fonction, c'est une variable locale :", total return total # Appeler la fonction sum sum( 10, 20 ) print "En dehors de la fonction, c'est une variable globale :", total

La sortie de l'exemple ci-dessus est :

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