quels outils fonctionnels restent dans Python 3k?

Question

J'ai lu plusieurs articles concernant la suppression de plusieurs fonctions fonctionnelles du futur python, y compris map et reduction.

Quelle est la politique officielle concernant les extensions fonctionnelles?
la fonction lambda va-t-elle rester?

Answer 1

Eh bien, Python 3.0 et 3.1 sont déjà publiés, vous pouvez donc le vérifier vous-même. Le résultat final est que la carte et le filtre ont été conservés en tant que paramètres intégrés et que lambda a également été conservé. Le seul changement est que reduction a été déplacé vers le module functools; il vous suffit de faire

from functools import reduce

l'utiliser.

À cet égard, les versions 3.x futures devraient rester rétrocompatibles avec les versions 3.0 et 3.1.

Answer 2

Dans Python 3.x, Python continue d’avoir un riche ensemble d’outils fonctionnels intégrés: compréhensions de liste, expressions de générateur, itérateurs et générateurs, ainsi que des fonctions telles que any () et tous () qui ont une évaluation de court-circuit chaque fois que possible.

Python's "Dictateur bienveillant pour la vie" a lancé l'idée de supprimer map () car vous pouvez reproduire de manière triviale ses effets avec une liste de compréhension:

lst2 = map(foo, lst)

lst3 = [foo(x) for x in lst]

lst2 == lst3  # evaluates True

La fonctionnalité lambda de Python n'a pas été supprimée ou renommée et ne le sera probablement jamais. Cependant, il ne deviendra probablement jamais plus puissant non plus. Le lambda de Python est limité à une seule expression; il ne peut pas inclure d'instructions et ne peut pas inclure plusieurs lignes de code Python.

Le code standard def de Python définit un objet fonction, qui peut être transmis aussi facilement qu'un objet lambda . Vous pouvez même dissocier le nom de la fonction après l'avoir définie, si vous le souhaitez vraiment.

Exemple:

# NOT LEGAL PYTHON
lst2 = map(lambda x: if foo(x): x**2; else: x, lst)

# perfectly legal Python
def lambda_function(x):
    if foo(x):
        return x**2
    else:
        return x

lst2 = map(lambda_function, lst)

del(lambda_function) # can unbind the name if you wish

Notez que vous pouvez réellement utiliser l’opérateur " opérateur ternaire " dans un lambda afin que l'exemple ci-dessus soit un peu artificiel.

lst2 = map(lambda x: x**2 if foo(x) else x, lst)

Mais certaines fonctions multilignes sont difficiles à forcer dans un lambda et sont mieux traitées comme de simples fonctions multilignes ordinaires.

Python 3.x n’a rien perdu de son pouvoir fonctionnel. Il existe un sentiment général selon lequel la compréhension de liste et les expressions de générateur sont probablement préférables à map () ; en particulier, les expressions du générateur peuvent parfois être utilisées pour faire l'équivalent d'un map () mais sans allouer de liste ni la libérer à nouveau. Par exemple:

total = sum(map(lst, foo))

total2 = sum(foo(x) for x in lst)

assert total == total2  # same result

Dans Python 2.x, le map () alloue une nouvelle liste, qui est résumée et immédiatement libérée. L'expression du générateur obtient les valeurs une à la fois et ne lie jamais la mémoire de toute une liste de valeurs.

Dans Python 3.x, map () est " lazy " donc les deux sont à peu près aussi efficaces. Par conséquent, dans Python 3.x, il faut forcer l’exemple ternaire lambda dans une liste:

lst2 = list(map(lambda x: x**2 if foo(x) else x, lst))

Plus facile d’écrire la compréhension de la liste!

lst2 = [x**2 if foo(x) else x for x in lst]