python : reduzieren können übersetzt werden in die Liste Verstehens wie map, lambda-und filter?

Bei der Programmierung in python, die ich jetzt vermeiden map, lambda und filter durch die Liste Verstehens, weil es einfacher zu Lesen und schneller in der Ausführung. Aber kann reduce ersetzt werden, wie gut?

E. g. ein Objekt hat ein Betreiber union() funktioniert auf einem anderen Objekt, a1.union(a2), und gibt ein 3. Objekt von gleichen Typ.

Habe ich eine Liste von Objekten:

L = [a1, a2, a3, ...]

Wie die union () - all diese Objekte mit Liste Verstehens, das entspricht:

result = reduce(lambda a, b :a.union(b), L[1:], L[0])

In manchen Fällen: keine. Aber hängt. Bitte geben Sie eine spezifische Abfrage, die Sie im Sinn haben
Beispiele dafür?
Setzen die Gewerkschaften sind ein schlechtes Beispiel, denn Sie können einfach tun result = set().union(*L), das hat den Vorteil, dass die Arbeit, auch wenn L wird eine leere Liste. Jedenfalls lambda a, b :a.union(b) geschrieben werden kann prägnanter als set.union, da in python obj.method(args) ist das gleiche wie cls.method(obj, args)
Guido sagt, um eine for-Schleife verwenden anstelle von reduzieren. Er ist kein fan von FP-Konstrukte.

InformationsquelleAutor Eric H. | 2014-06-25

18

Es ist kein Geheimnis, dass die Verringerung ist nicht unter die bevorzugten Funktionen von den Pythonistas.

Generisch, reduzieren ist ein linke Falte auf eine Liste

Es ist konzeptionell einfach zu schreiben, eine Falte in Python, das wird klappen Links oder rechts auf ein iterierbar:
```
def fold(func, iterable, initial=None, reverse=False):
    x=initial
    if reverse:
        iterable=reversed(iterable)
    for e in iterable:
        x=func(x,e) if x is not None else e
    return x
```
Ohne schwachen hack, dies kann nicht repliziert werden, in einem Verständnis, weil es ist nicht Akku-Typ Funktion in ein Verständnis.

Nur verwenden, verringern -- oder schreiben, das macht mehr Sinn.

InformationsquelleAutor dawg
4

Nicht wirklich. Liste Verstehens sind ähnlich map, und möglicherweise filter.

InformationsquelleAutor bigblind
4

Da eine Liste Verständnis definitionally erzeugt eine weitere Liste, Sie können es nicht verwenden, zum generieren von einem einzigen Wert. Das sind nicht für, dass. (Naja... es ist diese fiesen trick verwendet, die eine durchgesickerte detail in alten Versionen von python, die es tun können. Ich bin nicht einmal zum kopieren der Beispiel-code hier. Tun Sie das nicht.)

Wenn Sie sind besorgt über die stilistischen Aspekte der reduce() und seinesgleichen, nicht sein. Benennen Sie Ihre Reduzierungen und Sie werden in Ordnung sein. So, während:
```
all_union = reduce(lambda a, b: a.union(b), L[1:], L[0])
```
ist nicht so toll, dieses:
```
def full_union(input):
    """ Compute the union of a list of sets """

    return reduce(lambda a, b: a.union(b), input[1:], input[0])

result = full_union(L)
```
ist ziemlich klar.

Wenn Sie sind besorgt über Geschwindigkeit, check-out die toolz und cytoolz - Pakete, die sind "schnell" und "wahnsinnig schnell" bezeichnet. Auf große Datenbestände, werden Sie oft lassen Sie vermeiden die Verarbeitung Ihrer Daten mehr als einmal oder laden Sie die ganze Reihe im Speicher auf einmal, im Gegensatz zu Liste Verstehens.
- Um die reduce() Ausdruck selbst lesbar, machen das erste argument nicht ein lambda. Zum Beispiel: reduce(set.union, <list of sets>) Manchmal wird von Ihnen verlangen, zu definieren (und somit Namen) der Betreiber irgendwo außerhalb der Aufruf reduce.
InformationsquelleAutor Nate
2

Einer gemeinsamen Nutzung zu reduzieren, ist zu reduzieren, eine Liste von Listen. Sie können eine Liste mit Verständnis statt.
```
L = [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
```
mit reduzieren
```
from functools import reduce  # python 3
flattened = reduce(lambda x, y: x + y, L)

print(flattened)

[1, 2, 3, 2, 3, 4, 3, 4, 5]
```
mit list comp
```
flattened = [item for sublist in L for item in sublist]

print(flattened)

[1, 2, 3, 2, 3, 4, 3, 4, 5]
```
Wenn Ihr problem kann gelöst werden, indem Sie die auf der flachen Liste, dies ist ein effektiver Ersatz. Kontrast-diese one-Liner, die für das gegebene Beispiel:
```
all_union = reduce(lambda a, b: set(a).union(set(b)), L)

{1, 2, 3, 4, 5}

all_union = set([item for sublist in L for item in sublist])

{1, 2, 3, 4, 5}
```
- Verwenden sum(L, []). Das heißt, die Summe/list comprehension erzeugt einen "full-length" - Liste, wo reduce(operator.or_, map(set, L), set()) würde nicht.
InformationsquelleAutor Nicholas Morley

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

mit reduzieren

mit list comp