Python : Fonctions

Fonctions lambda

Une fonction lambda fait la même chose qu'une fonction normale, c'est surtout une question de style. Les différences sont :

• Le mot-clef lambda au lieu de def
• Pas de parenthèses
• Pas de mot-clef return

Exemple:

def gratter(sujet):

    grattouille = "Je me gratte de" + str(sujet)
    return grattouille

Est équivalent à:

gratter = lambda sujet: "Je me gratte de " + str(sujet)

Un point sur les retours et les paramètres

Portée des variables

Quand je passe en paramètre (formel) une variable à ma fonction et que je modifie cette variable dans la fonction, cette variable n'est pas modifiée dans le reste du programme (si c'est un int, float ou string): ce changement n'as de portée que dans la fonction (tout comme une variable initialisée dans une fonction n'as que cette fonction comme portée). Pour effectuer ce genre d'opérations, il faut importer la variable dans la fonction en tant que variable globale, avec le mot-clef "global" : la fonction sera alors recherchée dans l'ensemble du code.

variable_globale = 25

def maFonction():

    global variable_globale

    variable_globale += 1

    return True

#variable_globale vaut maintenant 26

En fait, il faut se rappeller que lorsque l'on passe objet non mutable à une fonction, celle-ci agit sur une copie de cet objet (ont dit qu'ils sont passés par valeur); quand on lui passe un objet mutable, elle agit sur l'objet lui-même (on dit qu'ils sont passés par référence).

Appel récursif d'une fonction

Une fonction peut s'appeller elle-même, notemment (seulement?) lors du return :

def fact(n):
   """
   retourne la factorielle de n
   Entrées :
      n : entier dont on veut la factorielle
   Sortie :
      n ! = n * (n-1) ! si n > 0
      et 1 si n = 0 (car 0 ! = 1)
   """
   if n==0 :
      return 1 # car 0 ! = 1
   else :
      return n*fact(n-1) # l'appel récursif est ici

##### programme principal #####
print (fact(5))

 

Paramètres positional-only (démerdez-vous pour la traduction)

Apparu en 3.8. Dans les arguments d'une fonction, on peut préciser si ceux-ci doivent être positionnels (genre je déclare juste une valeur comme ça), ou keyword (du type x=machin):

Dans ma définition de fonction, je vais utiliser / ou *.

• Tous les arguments avant / doivent être positionnels
• Tous les arguments après * doivent être keywords.

Du coup, il faut faire attention en mélangeant les deux. / doit être avant *. Les arguments positonnels doivent de toute façon toujours être avant les keywords !

<source lang="python"> def f(a, b, /, c, d, *, e, f):

   print(a, b, c, d, e, f)

1. Appel valide

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

1. Appel invalide

f(10, b=20, 30, 40, e=50, f=60) Syntax Error: positional argument follows keyword argument (<input>, line 1) </source>

Le fait que / et * soit posés comme ça avec des virgules est étrange; c'est un point à retenir.