Discussion :

[Yuseph]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
def f(a,b):
    return b(a)
 
def b(x):
    return x(0)
 
print(f(lambda x: x + 1, b))

C'est trop contre-intruitif pour que j'y pige qqch. J'espère que je n'aurai pas à tomber sur des aberrations pareilles dans des codes de vrai programme.
Même avec les explications de chatGPT j'y pige rien.

[josmiley]

f prend 2 fonctions en argument, a et b, et retourne le résultat de b(a)
b prend une fonction en argument ,x , et retourne le résultat de x(0) ce qui laisse supposé que x est une fonction qui prend au moins 1 argument, 0 ici.
donc la fonction argument de a de f prend au moins 1 argument. D'ailleurs c'est lambda x: x + 1.

ouais c'est tordu.

[Sve@r]

Bonjour

C'est trop contre-intruitif pour que j'y pige qqch.

Je suis d'accord. C'est pas évident. C'est à mon avis un exemple permettant d'illustrer le fait qu'une fonction est elle-aussi un objet manipulable, donc qu'on peut passer à une autre fonction pour qu'elle s'en serve à son profit.
Un exemple plus simple pourrait être le suivant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
def carre(c):
	return c*4
 
def cercle(r):
	return r * 3.14 * 2
 
def perimetre(f, v):
	print(f, type(f))
	return f(v)
 
print("carré(5)=%f" % perimetre(carre, 5))
print("cercle(6)=%f" % perimetre(cercle, 6))

Je ne dis pas que c'est utile, mais ça illustre le fait qu'on peut traiter des fonctions comme des objets (d'ailleurs ce sont des objets). Et le print() dans la fonction "perimetre()" te le montre bien.

J'espère que je n'aurai pas à tomber sur des aberrations pareilles dans des codes de vrai programme.

Des trucs aussi tordus non. Mais tu pourras tomber sur des trucs style sort(tableau, key=lambda ...) permettant de faire traiter chaque élément du tableau par la fonction "lambda" afin que sort() sache comment comparer deux éléments.
Et c'est aussi un point de départ permettant de comprendre les décorateurs...

Même avec les explications de chatGPT j'y pige rien.

Hé oui. chatGPT ne remplace pas des humains capables d'analyser un texte, mettre en corrélation leurs souvenirs et leurs connaissances grammaticales pour arriver ensuite à expliquer la solution. The Imitation Game n'est pas encode gagné.

[Yuseph]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
def f(a,b):
    return b(a)
 
def b(x):
    return x(0)
 
print(f(lambda x: x + 1, b))

Ok alors je reprends étape par étape.

1. print() veut afficher la fonction f(lambda x: x + 1, b)
2. Python execute f(lambda x: x + 1, b), car f(a,b) est déjà défini.
3. f(a,b) doit retourner b(a), du coup c'est b(lambda x: x + 1) qui est retourné. ce qui au passage crée un étrange lambda sans 2e argument.
4. Comme b(lambda x: x + 1) est retourné, Python execute alors la fonction b(x), c'est à dire toujours b(lambda x: x + 1)
5. b(x) retourne la fonction x(0), c'est à dire lambda x: x + 1, 0 (à moins que ce soit (lambda x: x +1)(0), pas encore bien pigé la différence)
6. Cette fois lambda a de quoi manger, du coup le "0" qui sert de 2e argument devient b de lambda. lambda traite x + 1 comme 0 + 1.
7. print() imprime 1.

[wiztricks]

Ok alors je reprends étape par étape.

Vous trainez le lambda comme un boulet.
Remplacez le par une vraie fonction:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
def g(x):
     return x + 1

ce qui revient à print(f(g, b))
Et comme on a que des "return", ça équivaut a des remplacements: f(g, b) devient b(g) qui devient g(0) qui devient 1.

- W

[papajoker]

bonjour,

En effet, lambda n'apporte rien de particulier ici.
Si tu ne comprends pas le cheminement, alors pourquoi tu n'inclus pas des print() ??? c'est la première chose

- print()
- commentaires
- renommer les fonctions (si plus compréhensible ?)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
def total(fonction_a, fonction_b):
    print("  # total...")
    # return appel_fontion(increment)
    return fonction_b(fonction_a)
 
def appel_fonction(fonction_x):
    """ lire dans une BD/variable est plus logique comme mécanisme"""
    print("  # appel_fonction... set 100 et lui applique une fonction")
    # return increment(100)
    return fonction_x(100)
 
def increment(x):
    print("  # increment...")
    return x + 1
 
print(total(increment, appel_fonction))

- lambda : n'est qu'une fonction
- si on passe une fonction en paramètre, elle n'est pas exécutée lors du passage, mais dans le corps de la fonction f().

Note: ton code n'a rien d'un snippet

[Sve@r]

1. print() veut afficher la fonction f(lambda x: x + 1, b)

Plus précisément ça veut afficher ce que retourne "f". Si j'écris def f(): return 123 et que j'appelle print(f()) ça affiche 123.

ce qui au passage crée un étrange lambda sans 2e argument.

Pourquoi "étrange"? Une lambda peut avoir 0, 1 ou 500 arguments sans que ce soit étrange.
J'en déduis que dans l'écriture f(lambda x: x + 1, b) tu assimiles "b" comme 2° argument de la lambda. Ce qui n'est absolument pas le cas. La lambda reçoit un argument "x", retourne "x+1". Et c'est "f" qui reçoit deux arguments 1) la lambda 2) "b".

5. b(x) retourne la fonction x(0), c'est à dire lambda x: x + 1, 0 (à moins que ce soit (lambda x: x +1)(0), pas encore bien pigé la différence)

"f" désigne l'objet fonction, un peu l'étiquette de son code. Evidemment ce serait plus parlant si cette fonction avait un nom un peu plus développé. f() avec parenthèses désigne l'appel de la fonction, c'est à dire lui demander d'effectuer le travail pour laquelle elle a été codée et retourner le résultat calculé.

[binarygirl]

[J'espère que je n'aurai pas à tomber sur des aberrations pareilles dans des codes de vrai programme.

J'en déduis que vous n'êtes pas encore programmeur de métier. Le jour où vous rentrerez sur le marché de l'emploi et que vous aurez à reprendre des développement faits par d'autres, vous verrez des choses bien plus tordues
Et encore, à l'avenir on va devoir se taper la reprise de code générée par GPT... la joie Je sens qu'il y a encore de l'avenir pour l'humain en programmation

[papajoker]

Ici, la particularité est d'intégrer la constante 0 dans la fonction b()
Je suis un CodeurGPT addict et je vais créer un code super pro ! pourquoi ? parce que c'est le but de ce mécanisme : changer les fonctions plutôt que des paramètres.
Note :
code bien sûr très utile (dans ma tête), mais puisque "ça marche", ce n'est pas le principal ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
def get_clean_champ(dico: dict, get_data, propre, convertir) -> str:
    return get_data(dico, propre, convertir)
 
 
def get_champ(dico, nom_champ, autre, convertir) -> str:
    valeur = dico[nom_champ]
    return autre(convertir(str(valeur)))
 
def get_nom(dico, convertir, autre) -> str:
    return get_champ(dico, "nom", autre, convertir)
 
def get_prenom(dico, convertir, autre) -> str:
    return get_champ(dico, "prenom", autre, convertir)
 
 
dico = {"nom": " LeFrank", "prenom": " alice"}
 
print(get_clean_champ(dico, get_nom, str.strip, str.upper))
print(get_clean_champ(dico, get_prenom, str.upper, str.strip))
print(get_clean_champ(dico, get_prenom, str.lower, str.strip))
print(get_clean_champ(dico, get_nom, str.strip, str.split))

Un exemple plus réaliste, serait :

get_entree( read_from_clavier, str.lower )
get_entree( read_from_clavier, convertir_en_breton )
get_entree( read_from_fichier, convertir_en_python )

def get_entree( read_from, convertir ):
return {"entree": convertir(read_from)}

[CosmoKnacki]

... ça illustre le fait qu'on peut traiter des fonctions comme des objets (d'ailleurs ce sont des objets)...

Et encore aujourd'hui en 2023. Quelle époque.

[Yuseph]

Ok merci des tuyaux. j'ai bien tenu compte de toutes vos remarques.
Pour info, le code vient de chatGPT. Je lui avais demandé un exemple emblématique. Car de toutes les questions de l'exam PCAP, les lambdas chelous étaient mon seul point faible.

[Yuseph]

J'en déduis que vous n'êtes pas encore programmeur de métier. Le jour où vous rentrerez sur le marché de l'emploi et que vous aurez à reprendre des développement faits par d'autres, vous verrez des choses bien plus tordues
Et encore, à l'avenir on va devoir se taper la reprise de code générée par GPT... la joie Je sens qu'il y a encore de l'avenir pour l'humain en programmation

Non, c'est pour la robotique et l'IoT.
Développeur, c'est un boulot qui donne des acouphènes et des symptômes d'anxiété.