Comment utiliser le filtre, la carte et la réduction dans Python 3

filter,, mapet reducefonctionne parfaitement en Python 2. Voici un exemple:

>>> def f(x):
        return x % 2 != 0 and x % 3 != 0
>>> filter(f, range(2, 25))
[5, 7, 11, 13, 17, 19, 23]

>>> def cube(x):
        return x*x*x
>>> map(cube, range(1, 11))
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

>>> def add(x,y):
        return x+y
>>> reduce(add, range(1, 11))
55

Mais en Python 3, je reçois les sorties suivantes:

>>> filter(f, range(2, 25))
<filter object at 0x0000000002C14908>

>>> map(cube, range(1, 11))
<map object at 0x0000000002C82B70>

>>> reduce(add, range(1, 11))
Traceback (most recent call last):
  File "<pyshell#8>", line 1, in <module>
    reduce(add, range(1, 11))
NameError: name 'reduce' is not defined

J'apprécierais que quelqu'un m'explique pourquoi.

Capture d'écran du code pour plus de clarté:

Vous pouvez en savoir plus sur les modifications dans Quoi de neuf dans Python 3.0 . Vous devriez le lire attentivement lorsque vous passez de 2.x à 3.x car beaucoup de choses ont été modifiées.

La réponse entière ici sont des citations de la documentation.

Vues et itérateurs au lieu de listes

Certaines API bien connues ne renvoient plus de listes:

• [...]
• map()et filter()renvoyer les itérateurs. Si vous avez vraiment besoin d'une liste, une solution rapide est par exemple list(map(...)), mais une meilleure solution consiste souvent à utiliser une compréhension de liste (en particulier lorsque le code d'origine utilise lambda), ou à réécrire le code afin qu'il n'ait pas besoin d'une liste du tout. Particulièrement délicat est map()invoqué pour les effets secondaires de la fonction; la transformation correcte consiste à utiliser une forboucle régulière (car créer une liste serait tout simplement inutile).
• [...]

Builtins

• [...]
• Supprimé reduce(). À utiliser functools.reduce()si vous en avez vraiment besoin; cependant, 99% du temps, une forboucle explicite est plus lisible.
• [...]

La fonctionnalité de mapet a filterété intentionnellement modifiée pour renvoyer les itérateurs, et la réduction a été supprimée d'être intégrée et placée functools.reduce.

Donc, pour filteret map, vous pouvez les envelopper list()pour voir les résultats comme vous l'avez fait auparavant.

>>> def f(x): return x % 2 != 0 and x % 3 != 0
...
>>> list(filter(f, range(2, 25)))
[5, 7, 11, 13, 17, 19, 23]
>>> def cube(x): return x*x*x
...
>>> list(map(cube, range(1, 11)))
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
>>> import functools
>>> def add(x,y): return x+y
...
>>> functools.reduce(add, range(1, 11))
55
>>>

La recommandation est maintenant de remplacer votre utilisation de la carte et du filtre par des expressions de générateurs ou des compréhensions de liste. Exemple:

>>> def f(x): return x % 2 != 0 and x % 3 != 0
...
>>> [i for i in range(2, 25) if f(i)]
[5, 7, 11, 13, 17, 19, 23]
>>> def cube(x): return x*x*x
...
>>> [cube(i) for i in range(1, 11)]
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
>>>

Ils disent que pour les boucles, il est 99% plus facile à lire qu'à réduire, mais je resterais avec functools.reduce.

Edit : le chiffre de 99% est tiré directement de la page Quoi de neuf en Python 3.0 rédigée par Guido van Rossum.

En complément des autres réponses, cela ressemble à un bon cas d'utilisation pour un gestionnaire de contexte qui remappera les noms de ces fonctions à celles qui renvoient une liste et introduisent reducedans l'espace de noms global.

Une implémentation rapide pourrait ressembler à ceci:

from contextlib import contextmanager    

@contextmanager
def noiters(*funcs):
    if not funcs: 
        funcs = [map, filter, zip] # etc
    from functools import reduce
    globals()[reduce.__name__] = reduce
    for func in funcs:
        globals()[func.__name__] = lambda *ar, func = func, **kwar: list(func(*ar, **kwar))
    try:
        yield
    finally:
        del globals()[reduce.__name__]
        for func in funcs: globals()[func.__name__] = func

Avec une utilisation qui ressemble à ceci:

with noiters(map):
    from operator import add
    print(reduce(add, range(1, 20)))
    print(map(int, ['1', '2']))

Qui imprime:

190
[1, 2]

Juste mes 2 cents :-)

Puisque la reduceméthode a été supprimée de la fonction intégrée de Python3, n'oubliez pas d'importer le functoolsdans votre code. Veuillez consulter l'extrait de code ci-dessous.

import functools
my_list = [10,15,20,25,35]
sum_numbers = functools.reduce(lambda x ,y : x+y , my_list)
print(sum_numbers)

Voici les exemples de fonctions Filtrer, mapper et réduire.

nombres = [10,11,12,22,34,43,54,34,67,87,88,98,99,87,44,66]

//Filtre

oddNumbers = list (filtre (lambda x: x% 2! = 0, nombres))

print (oddNumbers)

//Carte

multiplyOf2 = liste (carte (lambda x: x * 2, nombres))

imprimer (multiplyOf2)

//Réduire

La fonction de réduction, car elle n'est pas couramment utilisée, a été supprimée des fonctions intégrées de Python 3. Elle est toujours disponible dans le module functools, vous pouvez donc faire:

de functools import réduire

sumOfNumbers = réduire (lambda x, y: x + y, nombres)

print (sumOfNumbers)

L'un des avantages de la cartographie, du filtrage et de la réduction est leur lisibilité lorsque vous les "enchaînez" ensemble pour faire quelque chose de complexe. Cependant, la syntaxe intégrée n'est pas lisible et est tout "en arrière". Je suggère donc d'utiliser le PyFunctionalpackage ( https://pypi.org/project/PyFunctional/ ). Voici une comparaison des deux:

flight_destinations_dict = {'NY': {'London', 'Rome'}, 'Berlin': {'NY'}}

Version PyFunctional

Syntaxe très lisible. Tu peux dire:

"J'ai une séquence de destinations de vol. D'où je veux obtenir la clé dict si la ville est dans les valeurs dict. Enfin, filtrez les listes vides que j'ai créées dans le processus."

from functional import seq  # PyFunctional package to allow easier syntax

def find_return_flights_PYFUNCTIONAL_SYNTAX(city, flight_destinations_dict):
    return seq(flight_destinations_dict.items()) \
        .map(lambda x: x[0] if city in x[1] else []) \
        .filter(lambda x: x != []) \

Version Python par défaut

Tout est en arrière. Vous devez dire:

"OK, donc, il y a une liste. Je veux en filtrer les listes vides. Pourquoi? Parce que j'ai d'abord obtenu la clé dict si la ville était dans les valeurs dict. Oh, la liste à laquelle je fais cela est flight_destinations_dict. "

def find_return_flights_DEFAULT_SYNTAX(city, flight_destinations_dict):
    return list(
        filter(lambda x: x != [],
               map(lambda x: x[0] if city in x[1] else [], flight_destinations_dict.items())
               )
    )