fonctions lambda

lambda est une expression, pas une instruction
qui permet de créer un objet fonction anonyme et à la volée

# un objet fonction 
# qui n'a pas de nom
lambda x: x**2

# mais que je peux appeler
(lambda x: x**2)(10)

# comme si j'avait fait
def anonymous(x):
    return x**2

anonymous(10)

lambda : une expression¶

• elle peut donc apparaître
  là où une fonction classique ne peut pas

• typiquement à l’intérieur d’une expression

• par contre pas trop adapté pour du code compliqué

  • doit pouvoir être écrit sous forme d’une seule expression

lambda vs def¶

• les deux formes suivantes sont donc équivalentes

def foo(x):
    return x*x
foo

foo = lambda x: x*x
foo

limitation de lambda¶

• le corps d’une fonction lambda
  doit tenir sur une seule expression

  • uniquement applicable à des fonctions simples

  • pas de déclaration de variable locale

  • pas d’impact sur la portée des variables

• forme générale

lambda arg1, arg2, … argN : expression using args

f = lambda x: x+1
f(1)

(lambda x: x+1)(12)

exemples d’utilisation¶

# pour appeler un objet fonction
# c'est la syntaxe habituelle
def call(func, a, b):
    return(func(a, b))

# j'appelle l'addition sur ces deux nombres
call(lambda a, b: a + b, 3, 5)

# pareil avec la multiplication
call(lambda a, b: a * b, 3, 5)

application au tri¶

Rappel :

• sort() est une méthode qui trie les listes en place

• sorted() est une fonction built-in qui trie n’importe quel itérable et retourne un nouvel itérateur

• argument key:
  une fonction pour spécifier le critère de tri
  typiquement une fonction lambda

• argument reverse:
  booléen qui définit l’ordre de tri
  par défaut reverse=False: tri ascendant

sample = "This is a test string from Andrew".split()
sample

# une copie triée de sample
sorted(sample)

# avec un autre critère
sorted(sample, key=str.lower)

# pareil que
sorted(sample, key=lambda s: str.lower(s))

ou encore avec une autree donnée

student_marks = [('marc', 12), ('eric', 15), ('jean', 12), ('gabriel', 18)]

# on n'indique pas comment trier : c'est l'ordre "naturel" des tuples
sorted(student_marks)

# pour trier sur la note cette fois
sorted(student_marks, key=lambda student_tuple: student_tuple[1])

# remarque:
# des utilitaires sont disponibles aussi
# dans le module standard `operator` 
import operator
sorted(student_marks, key=operator.itemgetter(1))

reverse() et reversed()¶

• un schéma analogue existe
  pour renverser / retourner une liste

• list.reverse() comme méthode
  sur les listes qui retourne en place

• reversed() comme fonction builtin qui renvoie
  un itérateur pour parcourir à l’envers

source = [1, 10, 100, 1000]

source.reverse()
source

reversed(source)

list(reversed(source))

map() et filter()¶

rappel : appliquent une fonction à un itérable

• map(func, iter)

  • applique la fonction func à chaque élément de iter

  • retourne (un itérateur sur) les valeurs retournées par func

• filter(func, iter)

  • similaire à map, mais retourne seulement les valeurs
    qui sont vraies (techniquement, telles que bool(val) == True)

L = [1, 2, 3, 4]
m = map(lambda x: x**2, L)
# le résultat est un itérateur
m

# pour voir le résultat la liste on
# peut par exemple transformer
# explicitement en list()
list(m)

# si on essaie une deuxième fois
# il ne se passe plus rien car on a déjà itéré sur m
list(m)

m = map(lambda x: x**2, L)

for i in m: 
    print(i, end=' ')

1 4 9 16 

source = range(1, 5)
f = filter(lambda x: x%2 == 0, 
           map(lambda x:x**2, source))

# f est bien un itérateur
f is iter(f)

list(f)

cette forme est toutefois passée de mode au profit des expressions génératrices

# ceci est vraiment équivalent 
g = (x**2 for x in source
     if x%2 == 0)

g is iter(g)

list(g)

introspection (avancé)¶

• en Python tout est un objet
  on peut accéder à tous les attributs d’un objet

• en particulier donc pour les objets de type fonction

• modifier directement les attributs n’est pas recommandé,
  sauf si on comprend vraiment ce que l’on fait

• par contre c’est intéressant en lecture
  pour comprendre les détails d’implémentation

lecture d’attributs¶

def f(name="jean"):
    """le docstring"""
    pass
f.__name__

f.__doc__

f.__code__

f.__module__

f.__defaults__

aller plus loin¶

• si le sujet vous intéresse
  voyez le module inspect dans la librairie standard