`filter` auf Funktionsrückgaben

[mutetella]

Ich hab' in den built-ins, in den itertools und functools gesucht aber nichts "fertiges" dafür gefunden:

Code: Alles auswählen

[f(value) for f in functions]

Kann das sein?

[BlackJack]

@mutetella: Ja das kann sein. (Was hat das mit dem Betreff zu tun?)

[mutetella]

@BlackJack
Ups...

Code: Alles auswählen

[result for result in (f(4) for f in functions) if result]

oder

Code: Alles auswählen

all(f(value) for f in functions)

Sowas in der Art meinte ich. Eben wie `filter()` nur anderst herum...

[DasIch]

Es kann gut sein dass sowas in der stdlib nicht ist. Wenn die Funktion aber häufig genug genutzt oder irgendwie üblich wäre, würde man sie sicherlich mit Hoogle finden. Allerdings findet sich weder Functor f => a -> f (a -> b) -> f b noch `a -> [(a -> b)] -> ` (der Link dazu stört den BBCode Parser). Ich hab mal bei der Suche den Filter Teil ignoriert weil sich der draufsetzen lässt.

Da sich nichts findet, würde ich mal davon ausgehen dass die Funktion nicht besonders populär ist oder irgendeinen üblichen Namen hat. Sie lässt sich allerdings auf Basis von map sehr einfach implementieren.

Code: Alles auswählen

Prelude> let f x = map ($ x)
Prelude> :type f
f :: a -> [a -> b] -> [b]
Prelude> let f' x = fmap ($ x)
Prelude> :type f'
f' :: Functor f => a -> f (a -> b) -> f b

[pillmuncher]

@mutetella: sowas vielleicht?

Code: Alles auswählen

In [1]: def foo(x):
   ...:     return x * 2
   ...: 

In [2]: def bar(x):
   ...:     return x + 1
   ...: 

In [3]: def baz(x):
   ...:     return x * x
   ...: 

In [4]: def apply(function, value):
   ...:     return function(value)
   ...: 

In [5]: from itertools import repeat

In [6]: list(map(apply, [foo, bar, baz], repeat(3)))
Out[6]: [6, 4, 9]

Verglichen mit einer List Comprehension wäre mir das aber zuviel intelektueller Aufwand.

[mutetella]

Ok, ich seh' schon, es wird nichts "fertiges" angeboten…

@pillmuncher: Ja, über 'ne LC ist das schnell gelöst, aber das, was `filter()` macht auch. Und eben das war der Vater des Gedankens…

[snafu]

Code: Alles auswählen

[result for result in (f(4) for f in functions) if result]

oder

Code: Alles auswählen

all(f(value) for f in functions)

Sowas in der Art meinte ich. Eben wie `filter()` nur anderst herum...

Mir ist die Aufgabenstellung noch nicht klar. Was genau möchtest du: Herausfinden ob die Anwendung eines Wertes auf verschiedene Funktionen bei jeder dieser Funktionen `True` ergibt? Oder bei mindestens einer (das wäre `any()` anstelle von `all()`)? Oder nur Ergebnisse merken, die zu `True` evaluieren (d.h. `result != 0`, `len(result) > 0` und ähnliches), was `filter()` mit mehreren Funktionen entspräche?

EDIT: Mit dieser LC merkt man sich diejenigen Werte, für die alle Funktionen "etwas Wahres" ergeben haben:

Code: Alles auswählen

[value for value in values if all(func(value) for func in functions)]

Natürlich kann man den Teil mit `all()` auch als Lambda-Funktion in `filter()` einbetten, aber darin sehe ich keinen Mehrwert.

[mutetella]

Was genau möchtest du: Herausfinden ob die Anwendung eines Wertes auf verschiedene Funktionen bei jeder dieser Funktionen `True` ergibt? Oder bei mindestens einer (das wäre `any()` anstelle von `all()`)?

Ich hatte mich schlichtweg gefragt, ob es in einem "battery included" Modul bereits eine Funktion gibt, die das eine oder andere liefert. So wie die built-in `filter()` das mit einer Sequenz von Werten macht, nur eben mit einer Sequenz an Funktionen.
Mir ging es jetzt gar nicht unbedingt um eine Lösung (die ja relativ trivial ist) sondern darum, ob es etwas wie `filter()` gibt, allerdings nicht `filter(function, values)` sondern `filter(value, functions)`.

Hat sich ja nun erledigt…