Le Currying : La Puissance de la Programmation Fonctionnelle en Python
HTML-код
- Опубликовано: 9 июл 2024
- Si tu souhaites devenir un expert de Python et apprendre à créer un code exceptionnel : developerssecrets.com
Si tu veux rejoindre une communauté de développeurs actifs et motivés : / discord 
Наука
Hello, super video ! Ça serait cool de zoomer un peu dans l'ide parce que sur téléphone c'est assez dur de lire le code 😄
Merci beaucoup ! Je ferais en sorte de zoomer encore plus dans les prochaines vidéos que je tourne
Hello, merci pour cette initiative de présenter différents patterns avancés en python, c'est top d'avoir le courage de sa jeter à l'eau et de démarrer une chaîne technique !
Petite suggestion, ce serait cool je pense de réfléchir à démontrer la puissance du pattern dans une petite situation pratique, pour montrer que ce n'est pas juste plus compliqué pour le plaisir de faire plus compliqué. Pour le currying, il s'agirait de montrer clairement à travers un petit exemple pourquoi manipuler f(a, b) peut être moins pratique que manipuler f(a)(b).
Par exemple si l'on souhaite utilise la fonction map() de python pour ajouter une extension (variable) à un ensemble de noms de fichiers, ce sera probablement plus simple et clair avec ce pattern qui permettra de faire map(add_ext(".txt"), names), map(add_ext(".json"), names) etc. plutôt que de passer par des lambda fonctions. Également peut-être de montrer qu'on peut ajouter un peu de logique dans la fonction de retour en fonction de l'agument ?
Juste quelques idées comme ça, en tous cas merci pour le contenu c'est cool !
Merci beaucoup ! Je prends note de tout ça, je pense que je ferais plus tard une vidéo plus avancée sur ce concept qui expliquera plus en détail comment l'utiliser dans un cas concret
Merci
Salut! Merci pr le partage, c'est cool tu abordes des choses méconnus des débutants, mais pr ns permettre de mieux comprendre l'utilité du truc je pense qu'il serait bien d'ajouter un cas pratique plus complexe
Oui c'est vrai tu as raison, dans tous les cas je pense que je ferais une nouvelle version de cette vidéo plus développée et cette fois ci il y aura un exemple plus complexe et concret
Ce qui m'ennuie avec `partial` c'est que l'intellisense perd le docstring et la signature, en tout cas dans VS Code avec Pylance. Si je survole ta fonction ça me dira `partial[int]`, ce qui n'est pas du tout utile.
À ce sujet, je déconseille d'annoter la valeur de retour de `ajouter_currying`. Déjà ça sert à rien, et puis si tu fais ça l'intellisense perd le nom des paramètres de `ajouter_b`
D'un autre côté, j'ai vraiment du mal à utiliser le currying en python à cause du manque de support syntaxique, Si au moins on pouvait écrire `return def`. On a l'impression qu'une fonction currifiée est très compliquée alors que pas du tout, et essayer de l'exprimer avec des lambdas est non-seulement pire syntaxiquement, plus complexe au niveau des type hints, mais aussi très limitant parce que l'implémentation d'une lambda doit se limiter à une seule expression.
Habituellement, j'utilise beaucoup le currying pour passer des dépendances à certaines fonctions avant de les injecter dans mon programme. C'est aussi très pratique lorsque l'on utilise un style tacite pour composer des fonctions ou utiliser des prédicats : on applique tous les paramètres sauf le principal, qui fait partie du pipeline. Mais pour que ce style ait un intérêt au niveau de la lisibilité, il faut que écrire des fonctions currifiées soit simple. Or en Python, j'ai l'impression que ça ne vaut pas le coup.
Oui `partial[int]` ne donne aucune information et j'avoue que c'est peu pratique. J'espère que ça pourra s'améliorer dans le futur
J'ai un exemple concret du currying que j'ai utilisé pour mon grand oral:
def calculer_function_quadratique(A: Point, B: Point, C: Point) -> Callable[[int], int]:
a = A.y / ((A.x - B.x) * (A.x - C.x)) + B.y / ((B.x - A.x) * (B.x - C.x)) + C.y / ((C.x -
A.x) * (C.x - B.x))
b = - (A.y * (B.x + C.x) / ((A.x - B.x) * (A.x - C.x)) + B.y * (A.x + C.x) / ((B.x - A.x)
* (B.x - C.x)) + C.y * (A.x + B.x) / ((C.x - A.x) * (C.x - B.x)))
c = A.y * B.x * C.x / ((A.x - B.x) * (A.x - C.x)) + B.y * A.x * C.x / ((B.x - A.x) * (B.x
- C.x)) + C.y * A.x * B.x / ((C.x - A.x) * (C.x - B.x))
return lambda x: int(a * x**2 + b * x + c)
On a une méthode d'interpolation numérique et ici utiliser le currying permet réellement d'avoir un code plus performant et d'éviter un grand nombre de calcul inutile.(j'appelle cette fonction un peu moins de 2000 fois)
A mon avis si une personne doit utiliser partial pour utiliser à la fois la méthode de manière "normale" et de manière "currying", je pense qu'il y a un problèmes d'architecture du code. Je reste ouvert au critique sur ce point cependant.
Ceci dit très bonne introduction à ce sujet qui fait parfois peur tellement il est peu compris des personnes programmant uniquement en orienté objet. J'aurais cependant choisis un exemple plus parlant puisque celui ci paraît très inutile comme tu l'as dit. Ça ne fait pas bonne pub à un outil si utile😅
Merci beaucoup ! Je vais prendre en compte cet exemple pour une future vidéo sur le sujet