Fonctions en Python3

Une fonction est un bloc de code organisé et réutilisable servant à implémenter une fonctionnalité unique ou connexe.

Les fonctions améliorent la modularité des applications et le taux de réutilisation du code. Vous savez déjà que Python fournit de nombreuses fonctions intégrées, telles que print(). Mais vous pouvez aussi 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 :

  • Le bloc de code de la fonction commence par le mot-clédef, suivi du nom d'identifiant de la fonction et de parenthèses.()。
  • Tous les paramètres d'entrée et arguments doivent être placés à l'intérieur des parenthèses ; les parenthèses peuvent servir à définir des paramètres.
  • La première instruction d'une fonction peut facultativement être une docstring — utilisée pour stocker la description de la 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

Python définit des fonctions à l'aide du mot-clé def, avec le format général suivant :

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

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

Utilisons une fonction pour afficher "Hello World!" :

#!/usr/bin/python3

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

bonjour()

Une application plus complexe : ajout de variables de paramètre à la fonction :

Exemple (Python 3.0+)

Comparer deux nombres et renvoyer le plus grand :

#!/usr/bin/python3 def max(a, b): if a > b: return a else: return b a = 4 b = 5 print(max(a, b))

La sortie de l'exemple ci-dessus est :

5

Exemple (Python 3.0+)

Fonction pour calculer l'aire :

#!/usr/bin/python3 # Fonction pour calculer l'aire def area(width, height): return width * height def print_welcome(name): print("Bienvenue", name) print_welcome("Exemple") w = 4 h = 5 print("width =", w, " height =", h, " area =", area(w, h))

La sortie de l'exemple ci-dessus est :

Welcome Example
width = 4  height = 5  area = 20

Appel de fonction

Définir une fonction : donne un nom à la fonction, spécifie les paramètres inclus dans la fonction, ainsi que la structure du bloc de code.

Une fois la structure de base de cette fonction terminée, vous pouvez l'exécuter en l'appelant depuis une autre fonction, ou directement depuis l'invite de commande Python.

L'exemple suivant appelle la fonctionprintme():

Exemple (Python 3.0+)

#!/usr/bin/python3 # Définir la fonction def printme( str ): # Afficher toute chaîne passée print (str) return # Appeler la fonction printme("Je veux appeler la 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 ; les objets ont différents types, et les variables n'ont pas de type :

a=[1,2,3]

a="Example"

Dans le code ci-dessus,[1,2,3]est de type List,"Exemple"est de type String, tandis que la variable a n'a pas de type. Ce n'est qu'une référence à un objet (un pointeur), et elle peut pointer vers un objet de type List ou 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, et 5 est abandonné. Cela ne change pas la valeur de a ; c'est équivalent à créer à nouveau a.

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

Passage de paramètres des fonctions Python :

  • Types immuables :Semblable au passage par valeur en C++, comme les entiers, les chaînes de caractères, les tuples. Par exemple, fun(a) transmet uniquement la valeur de a, sans affecter l'objet a lui-même. Si la valeur de a est modifiée à l'intérieur de fun(a), un nouvel objet pour a est généré.

  • Types mutables :Semblable au passage par référence en C++, comme les listes, les dictionnaires. Par exemple, fun(la) transmet réellement la ; après modification, 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 Python de passage d'objets immuables

En utilisant la fonctionid()pour vérifier les changements d'adresse mémoire :

Exemple (Python 3.0+)

def change(a): print(id(a)) # Pointe vers le même objet a=10 print(id(a)) # Un nouvel objet a=1 print(id(a)) change(a)

La sortie de l'exemple ci-dessus est :

4379369136
4379369136
4379369424

On peut voir qu'avant et après l'appel de fonction, le paramètre formel et le paramètre effectif pointent vers le même objet (l'id de l'objet est le même). Après modification du paramètre formel à l'intérieur de la fonction, le paramètre formel pointe vers un id différent.

Exemple de passage d'un objet mutable

Si le paramètre d'un objet mutable est modifié à l'intérieur d'une fonction, alors dans la fonction qui a appelé cette fonction, le paramètre d'origine est également modifié. Par exemple :

Exemple (Python 3.0+)

#!/usr/bin/python3 # Description de fonction mutable def changeme( mylist ): "Modifie 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 à l'extérieur de la fonction :", mylist)

L'objet passé à la fonction et l'objet auquel du nouveau contenu est ajouté à la fin utilisent la même référence. Par conséquent, 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é
  • Paramètres par défaut
  • Paramètres de longueur variable

Paramètres obligatoires

Les paramètres requis doivent être passés à la fonction dans le bon ordre. Le nombre au moment de l'appel doit être le même qu'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 3.0+)

#!/usr/bin/python3 # Description de fonction mutable def printme( str ): "Affiche toute chaîne passée." print (str) return # Appeler la fonction printme ; l'omission du paramètre provoquera une erreur printme()

La sortie de l'exemple ci-dessus est :

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

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 passés.

L'utilisation d'arguments nommés permet que l'ordre des paramètres dans un appel de fonction ne corresponde pas à celui de la déclaration, car l'interpréteur Python peut associer les valeurs des paramètres par nom de paramètre.

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

Exemple (Python 3.0+)

#!/usr/bin/python3 # Description de fonction mutable def printme( str ): "Affiche toute chaîne passée." print (str) return # Appeler la fonction printme printme( str = "Tutoriel d'exemple")

La sortie de l'exemple ci-dessus est :

Example

L'exemple suivant montre que l'utilisation des paramètres de fonction ne nécessite pas d'ordre spécifié :

Exemple (Python 3.0+)

#!/usr/bin/python3 # Description de la fonction mutable def printinfo( name, age ): "Affiche toute chaîne passée." print ("Name:", name) print ("Âge :", age) return # Appeler la fonction printinfo printinfo( age=50, name="exemple" )

La sortie de l'exemple ci-dessus est :

名字:  example
年龄:  50

Paramètres par défaut

Lors de l'appel d'une fonction, si aucun argument n'est passé, le paramètre par défaut est utilisé. Dans l'exemple suivant, si aucun argument age n'est passé, la valeur par défaut est utilisée :

Exemple (Python 3.0+)

#!/usr/bin/python3 # Description de la fonction def printinfo( name, age = 35 ): "Affiche toute chaîne passée" print ("Name:", name) print ("Âge :", age) return # Appeler la fonction printinfo printinfo( age=50, name="example" ) print ("------------------------") printinfo( name="example" )

Sortie de l'exemple ci-dessus :

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

Paramètres de longueur variable

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

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

Avec un astérisque ajouté*les paramètres sont importés sous forme de tuple, stockant tous les paramètres variables non nommés.

Exemple (Python 3.0+)

#!/usr/bin/python3 # Description de la fonction def printinfo( arg1, *vartuple ): "Afficher tous les arguments passés" print ("Sortie :") print (arg1) print (vartuple) # Appeler la fonction printinfo printinfo( 70, 60, 50 )

Sortie de l'exemple ci-dessus :

输出: 
70
(60, 50)
Si aucun argument n'est spécifié lors de l'appel de la fonction, il s'agit d'un tuple vide. Nous pouvons également ne passer aucune variable non nommée à la fonction. Comme dans l'exemple suivant :

Exemple (Python 3.0+)

#!/usr/bin/python3 # Description de la fonction def printinfo( arg1, *vartuple ): "Afficher tous les arguments passés" print ("Sortie :") print (arg1) for var in vartuple: print (var) return # Appeler la fonction printinfo printinfo( 10 ) printinfo( 70, 60, 50 )

Sortie de l'exemple ci-dessus :

输出:
10
输出:
70
60
50

Il y a aussi le cas où les paramètres ont deux astérisques**La syntaxe de base est la suivante :

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

Avec deux astérisques ajoutés**les paramètres sont importés sous forme de dictionnaire.

Exemple (Python 3.0+)

#!/usr/bin/python3 # Description de la fonction def printinfo( arg1, **vardict ): "Afficher tous les arguments passés" print ("Sortie :") print (arg1) print (vardict) # Appeler la fonction printinfo printinfo(1, a=2,b=3)

Sortie de l'exemple ci-dessus :

输出: 
1
{'a': 2, 'b': 3}

Lors de la déclaration d'une fonction, un astérisque dans les paramètres*peut apparaître seul, par exemple :

def f(a,b,*,c):
    return a+b+c

Si l'astérisque apparaît seul*, alors, après l'astérisque,*les paramètres doivent être passés par mot-clé :

>>> def f(a,b,*,c):
...     return a+b+c
... 
>>> f(1,2,3)   # 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() takes 2 positional arguments but 3 were given
>>> f(1,2,c=3) # 正常
6
>>>

Fonctions anonymes

Python utiliselambdapour créer des fonctions anonymes.

Ce que l'on appelle anonyme signifie ne plus utiliserdefla forme standard d'une instruction def pour définir une fonction.

  • lambdan'est qu'une expression, et le corps de la fonction estdefbeaucoup plus simple que def.
  • Le corps d'une lambda est une expression, pas 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 d'arguments ou dans l'espace de noms global.
  • Bien qu'une fonction lambda semble ne pouvoir être écrite que sur une seule ligne, elle n'est pas équivalente à une fonction inline en C ou C++. Le but des fonctions inline est d'éviter d'occuper de la mémoire de pile lors de l'appel de petites fonctions, réduisant ainsi la surcharge des appels de fonction et améliorant la vitesse d'exécution du code.

Syntaxe

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

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

Définir le paramètre a plus 10 :

Exemple

x = lambda a : a + 10 print(x(5))

Sortie de l'exemple ci-dessus :

15

L'exemple suivant définit une fonction anonyme avec deux paramètres :

Exemple (Python 3.0+)

#!/usr/bin/python3 # 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 ))

Sortie de l'exemple ci-dessus :

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

Nous pouvons encapsuler une fonction anonyme à l'intérieur d'une fonction, afin que le même code puisse être utilisé pour créer plusieurs fonctions anonymes.

L'exemple suivant encapsule une fonction anonyme dans la fonction myfunc, créant différentes fonctions anonymes en passant différents paramètres :

Exemple

def myfunc(n): return lambda a : a * n mydoubler = myfunc(2) mytripler = myfunc(3) print(mydoubler(11)) print(mytripler(11))

Sortie de l'exemple ci-dessus :

22
33

Pour plus de fonctions anonymes, vous pouvez également vous référer à :Python lambda (fonctions anonymes)

Instruction return

return [expression]Cette instruction est utilisée pour quitter une fonction et renvoyer sélectivement une expression à l'appelant. Une instruction return sans argument renvoie None. Les exemples précédents ne montraient pas comment renvoyer une valeur ; l'exemple suivant montre l'utilisation de l'instruction return :

Exemple (Python 3.0+)

#!/usr/bin/python3 # Description de la fonction def sum( arg1, arg2 ): # Renvoie la somme des deux paramètres. total = arg1 + arg2 print ("À l'intérieur de la fonction :", total) return total # Appeler la fonction sum total = sum( 10, 20 ) print ("En dehors de la fonction :", total)

Sortie de l'exemple ci-dessus :

函数内 :  30
函数外 :  30

Paramètres positionnels uniquement

Python 3.8 ajoute une syntaxe de paramètre de fonction / pour indiquer que les paramètres de fonction doivent utiliser les paramètres positionnels spécifiés et ne peuvent pas utiliser d'arguments par mot-clé.

Dans l'exemple suivant, les paramètres a et b doivent être spécifiés comme arguments positionnels, c ou d peuvent être des paramètres positionnels ou nommés, et e et f doivent être des paramètres nommés :
def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)

L'utilisation suivante est correcte :

f(10, 20, 30, d=40, e=50, f=60)

L'utilisation suivante provoquera une erreur :

f(10, b=20, c=30, d=40, e=50, f=60)   # b 不能使用关键字参数的形式
f(10, 20, 30, 40, 50, f=60)           # e 必须使用关键字参数的形式
Autres extensions