Les expressions lambdas (ou expressions anonymes), c'est bon, mangez-en !
en.wikipedia.org/wiki/An…

Mais concrètement, vous les utilisez pour quoi?

Principalement, moi c'est pour les recherches dans les collections, pour écrire des trucs du genres:
animaux.Where(a => a.NombrePattes > 4 && a.EstVivant).Select(a => a.Espece).OrderBy(s => s)

Qui me récupère tous les animaux avec + 4 pattes, sont vivants, sélectionne leur espèce et trie les espèces par ordre alphabétique.

Et vous, ça vous sert à quoi ?

Parce que dans les exemples, faire des expressions lambda pour renvoyer le carré de x ... euh ... comment dire ... Ça sert à rien quoi

Je dois reconnaître que les lambda en Python ne sont pas aussi "sympathiques" à utiliser que dans d'autres langages, essentiellement parce que c'est plutôt verbeux ("lambda x: ..."), que c'est essentiellement limité à un seul paramètre, et qu'on ne peut pas utiliser des constructions "avancées" dedans (mais ce n'est pas anormal vu qu'une lambda doit rester "simple" idéalement).

Personnellement, j'utilise les lambda essentiellement :
- Quand je ne veux pas introduire un nouveau nom de fonction, et qu'il me faut réellement quelque chose d'anonyme du point de vue namespace. Dans ce cas, si la fonction est simple, je passe par une lambda, ou sinon je passe par un "def _(...)" pas très élégant.
- Quand je veux introduire une fonction partielle et que je ne veux pas aller chercher "partial" dans "functools".
- Quand j'ai besoin d'une fonction qui doit accéder à son contexte appelant (la closure) et que, typiquement, ça se fait dans un scope limité (et dans ce cas, si la fonction est simple, ça ne sert à rien de passer par "def _(...)").

Après, cela dépend grandement du contexte. Quand je fais de l'analyse de données, j'utilise énormément de lambda pour spécifier les masques à utiliser pour les données ou pour assigner de nouvelles colonnes sur base de précédentes (e.g. df[lambda d: ~d['machin'] & d['truc']].assign(new=lambda d: d['a'] + d['b']).......).

VIsiblement, on est les deux seuls à en utiliser ici

ça viendra :D

Je les utilise en js, mais plus sous la forme self invoked (? ... ok, j'me suis planté : executing) anonymous function : je pose un bout de code sous forme de fonction, qui se lance automatiquement (notez la parenthèse englobant la fonction qui sert à ça) :
(function () { console.log('Anca est un con'); }) (qui est un exemple à la con, pas besoin d'être dans une fonction pour juste afficher une ligne)

Qui peut aussi avoir des arguments, qui peut aussi être embeddé dans une autre fonction qui est elle nommée, pour faire des fonctions à la volée...

Par contre, j'utilise ça uniquement en js, qui est un langage articulé autour de fonctions. Et j'ai plus eu à toucher à ça depuis un petit moment, mais quand je refais du js, j'utilise pas mal les fonctions anonymes.

GuybrushVIsiblement, on est les deux seuls à en utiliser ici

Ben non ça sert souvent, et pour plein de trucs. Mais une fois qu'on a dit ça on est guère plus avancé, ça valait pas le coup d'ajouter un message au topic

Allez je vous partage un use case qui vient à l'esprit, celui de l'injection de dépendance.

En go on est parfois amené à implémenter une fonction dont la signature est contractualisée dans un autre type:

type AddressValidator func (string) bool

Si je veux faire un AddressValidator qui appelle une BDD, faudrait que je lui laisse le soin de créer lui même son handler de BDD, genre

func BDDAddressValidator(address string) bool {
    db:= sql.Open(...)
}

Booh, pas joli, pas testable. Du coup je peux contourner en écrivant un "générateur" d'AddressValidator qui retourne une Closure et auquel je peux passer mon handler de BDD:

func BDDAddressValidator(db *sql.DB) AddressValidator
        return func (address string) bool {
            // db exists now
        }
}

Charge au code appellant de s'occuper de la connexion BDD, c'est beaucoup mieux
Par contre on est pas trop en mode "expression lambda" qui n'existe pas en go, c'est de la grosse closure poilue.