Clojure style function "threading" in Python

Question

Clojure ha una macro "->" che inserisce ciascuna espressione in modo ricorsivo come primo argomento dell'espressione successiva.

Questo significa che ho potuto scrivere:

(-> arg f1 f2 f3) 

e si comporta come (tubazioni shell):

f3(f2(f1(arg))) 

desidero fare questo in Python; tuttavia, la ricerca sembra essere un incubo! Non ho potuto cercare "->", e nemmeno potrei cercare la funzione Python threading!

C'è un modo per sovraccaricare, diciamo, il | operatore in modo che potrei scrivere questo in Python?

arg | f1 | f2 | f3 

Grazie!

Answer 1

È possibile implementare facilmente qualcosa di simile.

def compose(current_value, *args): 
    for func in args: 
     current_value = func(current_value) 
    return current_value 

def double(n): 
    return 2*n 

print compose(5, double, double) # prints 20 

Answer 2

No, non c'è (almeno sanamente). Né vorresti. Perché non scrivere semplicemente f3(f2(f1(arg)))? O meglio ancora, modella il tuo problema in un modo che non richiede ricorsione.

Potrebbe essere possibile sovraccaricare | avvolgendo espressioni in una classe e definendo __or__ in quella classe, ma per favore, per amore di Guido, non farlo.

Si potrebbe anche fare ciò che ha scritto btilly, ma non lo consiglierei neanche. Lavora all'interno di ciò che la lingua ti fornisce.

Answer 3

O forse utilizzare la funzione di ridurre nel modo seguente:

reduce(lambda x,f : f(x), [f1,f2,f3], arg) 

Answer 4

Mentre io simpatizzo con il desiderio di creare nuovi costrutti del linguaggio fresco (à la Lisp macro), in realtà non è il Python filosofia per fare questo:

Ma come hanno detto gli intervistati, è possibile eseguire la propria concatenazione in vari modi. Ecco uno che è forse più esplicitamente Lisp-like, se che si adatta la vostra fantasia:

a = lambda x: x*2 
b = lambda x: x+1 

def chain(first, *args): 
    if len(args) == 0: 
     return first 
    else: 
     return first(chain(*args)) 

print chain(b, a, 1) 

Answer 5

Sulla soluzione di Howard:

def T(*args): 
    return reduce(lambda l, r: r(l), args) 

def dbl(n): 
    return 2*n 

T(5,dbl,dbl) 
#=> 20 

T(5,dbl,dbl,lambda x: 3*x) 
#=> 60 

Answer 6

Oppure provate http://dev-tricks.net/pipe-infix-syntax-for-python Un modulo che forniscono una sintassi simile:

fib() | take_while(lambda x: x < 1000000) 
     | where(lambda x: x % 2) 
     | select(lambda x: x * x) 
     | sum() 

Answer 7

C'è un thread function nella libreria pytoolz (in realtà ce ne sono due, fanno cose leggermente diverse su funzioni di più ar guments).

Esiste anche un'implementazione cython della libreria pytoolz denominata cytoolz che è probabilmente più efficiente. Può essere installato utilizzando pip.

Answer 8

Un po 'tardi alla festa, ma ecco un metodo più pulito, imo.Soddisferà la maggior parte delle esigenze FP.

def stream(*args): 
    return reduce(lambda a, t: t[0](t[1], a), args[1:], args[0]) 

Una mappa di base, filtro, ridurre:

>>> my_list = [1, 2, 3, 4, 5] 
>>> stream(my_list, 
... (map, lambda x: x ** 2), 
... (filter, lambda x: x < 20), 
... (reduce, lambda a, x: a + x)) 
30