[Python] l'amore per il pitone

[unknown]

Ciao a tutti,

Intanto mi presento: alcuni di voi mi conoscono dai tempi di stacktrace.it,
altri da thinkcode.tv (ero uno dei compagni di merende di Marco Beri).
Vengo da 1000 anni di lavoro in Java, giocando con Ruby nel frattempo e
piu' di recente andando decisamente verso Scala.

Mi sono buttato su Python per un nuovo lavoro. Ho letto un paio di libri
(partendo da quello di Marco ovviamente), ne ho spulciati altri 3 o 4, mi
sono fatto i koan derivati da quelli di Ruby, scrivo un po' di codice qua e
la'... ma non riesco ancora a far sbocciare l'amore.

Ogni volta che devo scrivere self mi viene un conato di vomito, quando devo
manipolare una collezione penso a quanto piu' facile e' in Ruby o Scala,
leggo che GVR mal sopporta FP e mi intristisco... non sono qui a fare il
troll, al contrario, voglio decisamente far funzionare questa relazione.

Per cui vi chiedo, cosa mi suggerite di fare per far scattare
l'infatuazione tra me e il pitone? Per farvi un esempio, a pycon.ca ho
visto un bel tutorial<https://github.com/pyconca/2013-wiki/wiki/Tutorials#notable-features-of-python>di
James Powell tutto incentrato sui generatori e quello mi e' piaciuto
molto (purtroppo non c'e' il video, ma la filosofia e' piu' o meno questa:
http://vimeo.com/53039281 ). Insomma, cose cosi'. Suggerimenti?

Grazie e ciao
Giuliano

[unknown]

2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>

quando devo manipolare una collezione penso a quanto piu' facile e' in Ruby

Post by unknown
o Scala

Giuliano,
magari puoi aggiungere due righe di codice per mostrare le differenze e la
maggior facilità di gestire una collezione in Ruby o Scala?

Se posso capire i conati per il self non riesco davvero a immaginare un
modo molto più facile per gestire le collezioni di quello di Python.

Ciao.
Marco.
P.S. Ovviamente salto tutta la fase dei saluti ecc. visto che ci
frequentiamo da anni (in fondo sei tu il protagonista di
http://beri.it/2009/12/22/la-neve/ che mi ha fatto andare su Radio24
http://beri.it/2012/03/19/voi-siete-qui/).

[unknown]

2013/9/17 Marco Beri <marcoberi a gmail.com>

Post by unknown
2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>
quando devo manipolare una collezione penso a quanto piu' facile e' in

Post by unknown
Ruby o Scala

Giuliano,
magari puoi aggiungere due righe di codice per mostrare le differenze e la
maggior facilità di gestire una collezione in Ruby o Scala?

Ok, raccatto un paio di esempi e posto.

Post by unknown
Se posso capire i conati per il self non riesco davvero a immaginare un
modo molto più facile per gestire le collezioni di quello di Python.

Facile e' facile, ma l'impressione per me e' di dover scrivere un sacco di
codice per fare anche solo le cose piu' semplici.

Post by unknown
Ciao.
Marco.
P.S. Ovviamente salto tutta la fase dei saluti ecc. visto che ci
frequentiamo da anni (in fondo sei tu il protagonista di
http://beri.it/2009/12/22/la-neve/ che mi ha fatto andare su Radio24
http://beri.it/2012/03/19/voi-siete-qui/).

'Auz, il mio senso di colpa iniziava giusto a scemare, cosi' lo riporti a
mille per altri 2-3 anni... :)

Ciao
Giuliano

[unknown]

2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>

Facile e' facile, ma l'impressione per me e' di dover scrivere un sacco di

Post by unknown
codice per fare anche solo le cose piu' semplici.

Ommamma... questa tua affermazione mi lascia basito... Non vedo l'ora che
tu posti il codice.

Se devo scegliere una cosa che mi ha all'istante fatto innamorare di Python
sono proprio i dictionary e la loro semplicità e comodità (e vincono di
misura sull'indentazione significativa).

'Auz, il mio senso di colpa iniziava giusto a scemare, cosi' lo riporti a

Post by unknown
mille per altri 2-3 anni... :)

:P

Ciao.
Marco.

[unknown]

Esempio 1
I lambda in python sono verbosi e visto che i vari map, reduce, filter, ...
non sono metodi della collezione, si compongono in modo che io percepisco
come innaturale.
Ad esempio, diciamo che abbiamo un array di interi e vogliamo somarne i
cubi.

Post by unknown

a = [1, 7, 22, 3]

=> [1, 7, 22, 3]

Post by unknown

a.map{|x| x*x*x }.reduce{|sum, x| sum + x}

=> 11019

Scala:
scala> val a = Array(1, 7, 22, 3)
a: Array[Int] = Array(1, 7, 22, 3)

scala> a.map(x => x*x*x).reduce((sum, x) => sum+x)
res1: Int = 11019

Post by unknown

a = [1, 7, 22, 3]
reduce(lambda sum, x: sum+x, map(lambda x: x*x*x, a))

11019

Rendo l'idea? Python non solo e' il piu' verboso (perche' devi ripetere
"lambda"), ma non ti consente di comporre i metodi naturalmente (in questo
python e' piu' FP-oriented degli altri, ma faccio piu' fatica a leggerlo,
immaginatevi di comporre 4 o 5 manipolazioni o piu', che e' una cosa che si
fa abbastanza naturalmente in Scala o Ruby (o Smalltalk, che poi e' il
precursore di questo stile).

Ciao
Giuliano

PS: vi da' fastidio il top posting per una cosa cosi'?
PPS: so che Python ha la funzione sum(), immaginatevi un'altra operazione
analoga che abbia senso con una reduce... :)


2013/9/17 Marco Beri <marcoberi a gmail.com>

Post by unknown
2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>
quando devo manipolare una collezione penso a quanto piu' facile e' in

Ruby o Scala

Giuliano,
magari puoi aggiungere due righe di codice per mostrare le differenze e la
maggior facilità di gestire una collezione in Ruby o Scala?
Se posso capire i conati per il self non riesco davvero a immaginare un
modo molto più facile per gestire le collezioni di quello di Python.
Ciao.
Marco.
P.S. Ovviamente salto tutta la fase dei saluti ecc. visto che ci
frequentiamo da anni (in fondo sei tu il protagonista di
http://beri.it/2009/12/22/la-neve/ che mi ha fatto andare su Radio24
http://beri.it/2012/03/19/voi-siete-qui/).
--
http://beri.it/ - Un blog
http://beri.it/i-miei-libri/ - Qualche libro
_______________________________________________
Python mailing list
Python a lists.python.it
http://lists.python.it/mailman/listinfo/python

[unknown]

2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>

Post by unknown
Esempio 1
I lambda in python sono verbosi e visto che i vari map, reduce, filter,
... non sono metodi della collezione, si compongono in modo che io
percepisco come innaturale.
Ad esempio, diciamo che abbiamo un array di interi e vogliamo somarne i
cubi.

a = [1, 7, 22, 3]

=> [1, 7, 22, 3]

a.map{|x| x*x*x }.reduce{|sum, x| sum + x}

=> 11019
scala> val a = Array(1, 7, 22, 3)
a: Array[Int] = Array(1, 7, 22, 3)
scala> a.map(x => x*x*x).reduce((sum, x) => sum+x)
res1: Int = 11019

a = [1, 7, 22, 3]
reduce(lambda sum, x: sum+x, map(lambda x: x*x*x, a))

11019
Rendo l'idea? Python non solo e' il piu' verboso (perche' devi ripetere
"lambda"), ma non ti consente di comporre i metodi naturalmente (in questo
python e' piu' FP-oriented degli altri, ma faccio piu' fatica a leggerlo,
immaginatevi di comporre 4 o 5 manipolazioni o piu', che e' una cosa che si
fa abbastanza naturalmente in Scala o Ruby (o Smalltalk, che poi e' il
precursore di questo stile).

a = [1, 7, 22, 3]
sum(x**3 for x in a)

11019

Beat that :-)

Ciao.
Marco.

[unknown]

2013/9/17 Marco Beri <marcoberi a gmail.com>

Post by unknown

a = [1, 7, 22, 3]
sum(x**3 for x in a)

11019
Beat that :-)

Ok, come dicevo nel PPS lascia perdere sum, immaginati un'altra funzione.
Per cui sarebbe:
reduce(lambda sum, x: sum+x, x**3 for x in a)

Le comprehension sono analoghe ad applicare map, che io sappia, quindi
quello che mi stai dicendo e': lasciati sedurre, dimenticati di map,
focalizzati sulle comprehension se vuoi essere sintetico, cosi' risparmi un
lambda.

Ho capito bene?

Ciao
Giuliano

[unknown]

2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>

Post by unknown
2013/9/17 Marco Beri <marcoberi a gmail.com>

a = [1, 7, 22, 3]

sum(x**3 for x in a)

11019

Ok, come dicevo nel PPS lascia perdere sum, immaginati un'altra funzione.
reduce(lambda sum, x: sum+x, x**3 for x in a)

Per la precisione quando hai un generatore come argomento lo devi

Post by unknown

reduce(lambda sum, x: sum+x, (x*x*x for x in a))

Le comprehension sono analoghe ad applicare map, che io sappia, quindi
quello che mi stai dicendo e': lasciati sedurre, dimenticati di map,
focalizzati sulle comprehension se vuoi essere sintetico, cosi' risparmi un
lambda.
Ho capito bene?

Non ti chiederei mai di dimenticarti di map, però faccio fatica a pensare a
un esempio che non possa fare a meno delle lambda limitandosi alle list
comprehension. Io le trovo quasi onnipotenti.

Prova a farmi un esempio un po' meno banale dove, secondo te, non si possa
fare a meno delle lambda.

Ciao.
Marco.
-------------- parte successiva --------------
Un allegato HTML è stato rimosso...
URL: <http://lists.python.it/pipermail/python/attachments/20130917/a0b4a3ef/attachment.html>

[unknown]

2013/9/17 Marco Beri <marcoberi a gmail.com>

Post by unknown
Per la precisione quando hai un generatore come argomento lo devi

reduce(lambda sum, x: sum+x, (x*x*x for x in a))

Yacky! :(

Post by unknown
Non ti chiederei mai di dimenticarti di map, però faccio fatica a pensare
a un esempio che non possa fare a meno delle lambda limitandosi alle list
comprehension. Io le trovo quasi onnipotenti.

Capito.

Post by unknown
Prova a farmi un esempio un po' meno banale dove, secondo te, non si possa
fare a meno delle lambda.

Non ce l'ho cosi' sui due piedi, la mia forma mentis e' ferma su map, mo'
mi riprogrammo il cervello e vediamo.

Pero' non vorrei fossilizzarmi sulle collezioni, in realta' sono proprio
alla ricerca di altri spunti.

Ciao
Giuliano

[unknown]

2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>

Post by unknown
Pero' non vorrei fossilizzarmi sulle collezioni, in realta' sono proprio
alla ricerca di altri spunti.

Questa lista è piena di fan di itertools, qualcuno di loro qualche spunto
te lo darà :-)

Ciao.
Marco.

[unknown]

2013/9/17 Marco Beri <marcoberi a gmail.com>

Post by unknown
2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>

Post by unknown
Pero' non vorrei fossilizzarmi sulle collezioni, in realta' sono proprio
alla ricerca di altri spunti.

Questa lista è piena di fan di itertools, qualcuno di loro qualche spunto
te lo darà :-)

Mi sa che non riesco a spiegarmi. Non ho nulla contro itertools, anzi, per
fortuna che esiste.

Mettiamola cosi': se uno di voi viene da Ruby o ha esperienza Ruby/Scala
quali sono le cose che vi fanno lavorare meglio in Python? (lasciamo
perdere Java, e' come sparare sulla croce rossa)

Ciao
Giuliano

[unknown]

2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>

Post by unknown
Mettiamola cosi': se uno di voi viene da Ruby o ha esperienza Ruby/Scala
quali sono le cose che vi fanno lavorare meglio in Python? (lasciamo
perdere Java, e' come sparare sulla croce rossa)

Temo che tu sia nel posto sbagliato. Questo e' un "covo di pythonisti" e
ruby non e' molto preso in considerazione.
Personalmente lo ho guardato, ho trovato una sintassi INUTILMENTE
innaturale e ho chiuso e deletato il file del tutorial.
Scala dovrei guardarlo, se avessi tempo. Ma visto anche il problema che poi
non ci farei nulla se non per il piacere di averlo conosciuto, e il tempo
e' tiranno ma non benevolo come Guido ..

Carlos

[unknown]

2013/9/17 Carlos Catucci <carlos.catucci a gmail.com>

Post by unknown
Temo che tu sia nel posto sbagliato. Questo e' un "covo di pythonisti" e
ruby non e' molto preso in considerazione.
Personalmente lo ho guardato, ho trovato una sintassi INUTILMENTE
innaturale e ho chiuso e deletato il file del tutorial.
Scala dovrei guardarlo, se avessi tempo. Ma visto anche il problema che
poi non ci farei nulla se non per il piacere di averlo conosciuto, e il
tempo e' tiranno ma non benevolo come Guido ..

Capito, allora cambio approccio: ogni volta che trovo qualcosa di
frustrante condivido con voi e vediamo se mi potete offrire un punto di
vista diverso.

Ad esempio, il consiglio di favorire le comprehension a map e' utile.

Ciao
Giuliano

[unknown]

2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>

Post by unknown
Ad esempio, il consiglio di favorire le comprehension a map e' utile.

Come per Marco, sono una delle cose che mi hanno "charmato" del Pythone.
Lambda usate si e no una volta in quasi 5 anni.

Carlos

[unknown]

2013/9/17 Carlos Catucci <carlos.catucci a gmail.com>

Post by unknown
2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>

Post by unknown
Ad esempio, il consiglio di favorire le comprehension a map e' utile.

Come per Marco, sono una delle cose che mi hanno "charmato" del Pythone.
Lambda usate si e no una volta in quasi 5 anni.

Mi sa che ti batto in un'oretta, a volte anche meno. Per me e' naturale
manipolare collezioni con filter, all, reduce, ecc.

Quindi forse sarebbe interessante capire come fare le stesse cose senza
lambda.

Ciao,
Giuliano

[unknown]

2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>

Post by unknown
Quindi forse sarebbe interessante capire come fare le stesse cose senza
lambda.

fai esempio in pseudocodice e vediamo se cosa possiamo tirarne fuori noi
serpari

Carlos

[unknown]

2013/9/17 Carlos Catucci <carlos.catucci a gmail.com>

Post by unknown
2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>

Post by unknown
Quindi forse sarebbe interessante capire come fare le stesse cose senza
lambda.

fai esempio in pseudocodice e vediamo se cosa possiamo tirarne fuori noi
serpari

Post by unknown

a = [2, -4, 27, 44, 13, 0]
filter(lambda x: x > 5, a)

[27, 44, 13]

Post by unknown

Post by unknown

[x for x in a if x > 5]

[27, 44, 13]
Immagino che tu vada diretto con la seconda, mentre a me viene naturale la
prima (la trovo piu' "intention revealing", dice chiaramente che sto
filtrando la lista).

Torna?

Ciao,
Giuliano

[unknown]

[...] Ad esempio, data una lista di interi, per estrarre quelli

a = [2, -4, 27, 44, 13, 0] filter(lambda x: x > 5, a)

[27, 44, 13]

[x for x in a if x > 5]

[27, 44, 13]
Immagino che tu vada diretto con la seconda, mentre a me viene
naturale la prima (la trovo piu' "intention revealing", dice
chiaramente che sto filtrando la lista).
Torna?

No, perch? la versione Python ? altrettanto compatta, e chi ha
esperienza con Python non ha problemi a capire le intenzioni del codice.

Il problema ? che non puoi comporre facilmente pi? filtri, ma come ti
ho detto Python non ? un linguaggio funzionale come l'"altro" che ti
ho suggerito.

[...]

Ciao Manlio

[unknown]

2013/9/17 Manlio Perillo <manlio.perillo a gmail.com>

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

[...] Ad esempio, data una lista di interi, per estrarre quelli

a = [2, -4, 27, 44, 13, 0] filter(lambda x: x > 5, a)

[27, 44, 13]

[x for x in a if x > 5]

[27, 44, 13]
Immagino che tu vada diretto con la seconda, mentre a me viene
naturale la prima (la trovo piu' "intention revealing", dice
chiaramente che sto filtrando la lista).
Torna?

No, perch? la versione Python ? altrettanto compatta, e chi ha
esperienza con Python non ha problemi a capire le intenzioni del codice.

Intendevo "torna" l'uso della comprehension con un if embedded.

Detto cio', non mi puoi dire seriamente che la versione con la
comprehension e' altrettanto comunicativa: il problema non e' capirla in
toto, il problema e' che devi leggerti tutta la comprehension per sapere se
otterrai una collezione con la stessa numerosita', se stai trasformando gli
elementi o cosa. Se inveci usi filter, map, ecc. lo sai al volo, non devi
leggere il dettaglio della trasformazione. Questo e' il nocciolo di come
manipolare le collezioni che deriva dal mondo Smalltalk.

Comunque, ribadisco, non voglio mica convincervi, neh... :)

Ciao,
Giuliano

[unknown]

2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>

Post by unknown
Comunque, ribadisco, non voglio mica convincervi, neh... :)

Sarebbe fatica inutile, siamo avvolti dalle spire ;)

Carlos

[unknown]

Post by unknown

[...] Ad esempio, data una lista di interi, per estrarre quelli

a = [2, -4, 27, 44, 13, 0] filter(lambda x: x > 5, a)

[27, 44, 13]

[x for x in a if x > 5]

[27, 44, 13]
Immagino che tu vada diretto con la seconda, mentre a me viene
naturale la prima (la trovo piu' "intention revealing", dice
chiaramente che sto filtrando la lista).
Torna?

No, perch? la versione Python ? altrettanto compatta, e chi ha
esperienza con Python non ha problemi a capire le intenzioni del codice.
Intendevo "torna" l'uso della comprehension con un if embedded.

Ah, ok; si torna.

Post by unknown
Detto cio', non mi puoi dire seriamente che la versione con la
comprehension e' altrettanto comunicativa: il problema non e'
capirla in toto, il problema e' che devi leggerti tutta la
comprehension per sapere se otterrai una collezione con la stessa
numerosita', se stai trasformando gli elementi o cosa. Se inveci
usi filter, map, ecc. lo sai al volo, non devi leggere il dettaglio
della trasformazione. Questo e' il nocciolo di come manipolare le
collezioni che deriva dal mondo Smalltalk.
Comunque, ribadisco, non voglio mica convincervi, neh... :)

Non c'è bisogno.
Ti ho consigliato Haskell, no?
Io l'ho studiato per un pò di tempo ed è uno dei miei linguaggi
preferiti; ma uso Python perchè sono più produttivo.

Tra l'altro se vuoi la versione più verbosa/leggibile, puoi sempre
usare filter e reduce.

Però tieni conto che le chiamate a funzione, in Python, non sono molto
efficienti (ed infatti è una cosa che spesso mi da fastidio, dato che
mi ritrovo spesso a comporre piccole funzioni).

Inoltre tieni conto che in Python 3.x, reduce non è più una funzione
builtin, ma è stata spostata nel modulo functools (invece filter è
ancora una builtin).


Ciao Manlio

[unknown]

2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>

Post by unknown
Detto cio', non mi puoi dire seriamente che la versione con la
comprehension e' altrettanto comunicativa: il problema non e' capirla in
toto, il problema e' che devi leggerti tutta la comprehension per sapere se
otterrai una collezione con la stessa numerosita', se stai trasformando gli
elementi o cosa. Se inveci usi filter, map, ecc. lo sai al volo, non devi
leggere il dettaglio della trasformazione. Questo e' il nocciolo di come
manipolare le collezioni che deriva dal mondo Smalltalk.

Il fatto e' che si comunica almeno in due, dopotutto. Quindi dipende a chi
comunichi.
Personalmente a me le list comprehension piacciono molto, perche' le trovo
estremamente dichiarative, molto piu' dichiarative dei classici funzionali
a botte di map e filter. Le LC hanno anche il marginale vantaggio che
mantengono leggibilita' relativa anche quando le cose si complicano un
pochetto. Quando si complicano molto, richiedono una refattorizzazione
banale che riporta la leggibilita' a livelli elementari (usando generatore
e predicato con nome).

In realta' questi sono esempi relativamente giocattolo in cui avere una
lambda coincisa sembra un vantaggio competitivo notevole.
Pero' nella maggior parte del codice che ho scritto, mi sono relativamente
di rado trovato ad usare, per esempio, predicati o funzioni mappate che non
avessero senso definite in modo stabile.

In particolare, tu hai acchiappato il caso in cui le LC sono piu'
sfortunate, quello in cui le usi per filter *senza* map.

[unknown]

2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>

Post by unknown
Immagino che tu vada diretto con la seconda, mentre a me viene naturale la
prima (la trovo piu' "intention revealing", dice chiaramente che sto
filtrando la lista).
Torna?

Au contraire, la list comprehension e', come dice il nome stesso,
comprensibile anche a chi non conosca il Python, la lambda e' criptica come
puo' esserlo l'operatore ternario del C per un non iniziato.

Io pero' ti chiedevo esempi di pseudocodice (e non di codice Python) dove
useresti appunto map e reduce pittosto che le LC.

Carlos

[unknown]

2013/9/17 Carlos Catucci <carlos.catucci a gmail.com>

Post by unknown
Au contraire, la list comprehension e', come dice il nome stesso,
comprensibile anche a chi non conosca il Python, la lambda e' criptica come
puo' esserlo l'operatore ternario del C per un non iniziato.

https://en.wikipedia.org/wiki/List_comprehension#History

:D

Post by unknown
Io pero' ti chiedevo esempi di pseudocodice (e non di codice Python) dove
useresti appunto map e reduce pittosto che le LC.

Non e' particolarmente interessante focalizzarsi ne' su map/reduce ne'
sulle collezioni in generale.

Comunque, un altro esempio e' questo => puoi usare itertools.chain per
implementare una flatmap (sicuro che non vuoi il codice Python? allora non
leggere :) )

Post by unknown

func = lambda 2 * x
func(2)

4

Post by unknown

a = [1, 2, 3, 4]
b = [2, 3, 4, 5]
map(func, a)

[2, 4, 6, 8]

Post by unknown

from itertools import *
list(chain(*[a, b]))

[1, 2, 3, 4, 2, 3, 4, 5]

Post by unknown

list(chain([a, b]))

[[1, 2, 3, 4], [2, 3, 4, 5]]

Post by unknown

list(chain(*map(func, a)))

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

Post by unknown

list(chain(*map(func, [a, b])))

[1, 2, 3, 4, 1, 2, 3, 4, 2, 3, 4, 5, 2, 3, 4, 5]

Post by unknown

func2 = lambda iter: sum(iter)
func2(a)

10

Post by unknown

list(chain(*map(func2, [a, b])))

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

Post by unknown

func2 = lambda iter: [sum(iter)]
func2(a)

[10]

Post by unknown

map(func2, [a, b])

[[10], [14]]

Post by unknown

list(chain(*map(func2, [a, b])))

[10, 14]

Post by unknown

list(chain.from_iterable(map(func2, [a, b]))) # this saves you from

typing at the expense of typing from_iterable
[10, 14]
Cosi' facendo se la tua collezione e' gia' flat hai un'eccezione (perche' i
singoli elementi non sono iterabili).

Qual e' il modo migliore per implementare una flatmap in Python?

Ciao,
Giuliano

[unknown]

2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>

Post by unknown
https://en.wikipedia.org/wiki/List_comprehension#History
:D

Non ho mai affernato che le abbiano inventate per il Python, ma il bello di
Python e' che ha preso il meglio di altri linguaggi unendolo

Post by unknown
on e' particolarmente interessante focalizzarsi ne' su map/reduce ne'

Post by unknown
sulle collezioni in generale.

Era per dire, va bene qualsiasi cosa

Post by unknown
Comunque, un altro esempio e' questo => puoi usare itertools.chain per

Post by unknown
implementare una flatmap (sicuro che non vuoi il codice Python? allora non
leggere :) )

Ngueeee mi tratta maleeeeeeeeeee ;P

Post by unknown

Post by unknown

func = lambda 2 * x
func(2)

4

Post by unknown

a = [1, 2, 3, 4]
b = [2, 3, 4, 5]
map(func, a)

[2, 4, 6, 8]

Post by unknown

from itertools import *
list(chain(*[a, b]))

[1, 2, 3, 4, 2, 3, 4, 5]

Post by unknown

list(chain([a, b]))

[[1, 2, 3, 4], [2, 3, 4, 5]]

Post by unknown

list(chain(*map(func, a)))

File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

Post by unknown

list(chain(*map(func, [a, b])))

[1, 2, 3, 4, 1, 2, 3, 4, 2, 3, 4, 5, 2, 3, 4, 5]

Post by unknown

func2 = lambda iter: sum(iter)
func2(a)

10

Post by unknown

list(chain(*map(func2, [a, b])))

File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

Post by unknown

func2 = lambda iter: [sum(iter)]
func2(a)

[10]

Post by unknown

map(func2, [a, b])

[[10], [14]]

Post by unknown

list(chain(*map(func2, [a, b])))

[10, 14]

Post by unknown

list(chain.from_iterable(map(func2, [a, b]))) # this saves you from

typing at the expense of typing from_iterable
[10, 14]
Cosi' facendo se la tua collezione e' gia' flat hai un'eccezione (perche'
i singoli elementi non sono iterabili).
Qual e' il modo migliore per implementare una flatmap in Python?

Mmmm senza esempi pratici mi spiazzi ;)

Carlos

[unknown]

2013/9/17 Carlos Catucci <carlos.catucci a gmail.com>

Post by unknown
2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>

Post by unknown
https://en.wikipedia.org/wiki/List_comprehension#History
:D

Non ho mai affernato che le abbiano inventate per il Python, ma il bello
di Python e' che ha preso il meglio di altri linguaggi unendolo

Manno', intendevo che la "comprensibilita'" del costrutto non c'entra
niente:
http://bytes.com/topic/python/answers/851952-etymology-list-comprehension
Non e' questione di capire il costrutto meglio di un altro, ma di
comprendere nel senso di includere.

Post by unknown

Post by unknown
on e' particolarmente interessante focalizzarsi ne' su map/reduce ne'

Post by unknown
sulle collezioni in generale.

Era per dire, va bene qualsiasi cosa

Post by unknown
Comunque, un altro esempio e' questo => puoi usare itertools.chain per

Post by unknown
implementare una flatmap (sicuro che non vuoi il codice Python? allora non
leggere :) )

Ngueeee mi tratta maleeeeeeeeeee ;P

Ma no, dai, suvvia... :D

Post by unknown

Post by unknown
Qual e' il modo migliore per implementare una flatmap in Python?

Mmmm senza esempi pratici mi spiazzi ;)

Ok, provo con un'altra: qual e' il modo migliore in python di contare tutti
gli elementi di una lista che soddisfano un criterio?
2 esempi:

1) contare tutti gli elementi piu' grandi di 5
2) contare tutti gli elementi uguali al massimo

Post by unknown

Post by unknown

Post by unknown
a = [2, -4, 27, 44, 13, 0]
len(x for x in a if x > 5)

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: object of type 'generator' has no len()

Post by unknown

Post by unknown

Post by unknown
len([x for x in a if x > 5])

3

Post by unknown

Post by unknown

Post by unknown
list_max = max(a)
len([x for x in a if x == list_max])

1

Post by unknown

Post by unknown

Post by unknown
len([x for x in a if x == max(a)]) # anche cosi' insomma

1


Nota che questo problema lo puoi risolvere anche con una select/filter,
seguita da una reduce.

Sto ingranando?

Ciao,
Giuliano

[unknown]

2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>

Post by unknown
Nota che questo problema lo puoi risolvere anche con una select/filter,
seguita da una reduce.
Sto ingranando?

Yep!!

Carlos

[unknown]

On 17/09/13 19:32, Piergiuliano Bossi wrote:

[...]

Post by unknown
Ok, provo con un'altra: qual e' il modo migliore in python di contare
tutti gli elementi di una lista che soddisfano un criterio?
1) contare tutti gli elementi piu' grandi di 5
2) contare tutti gli elementi uguali al massimo

a = [2, -4, 27, 44, 13, 0]
len(x for x in a if x > 5)

File "<stdin>", line 1, in <module>
TypeError: object of type 'generator' has no len()

len([x for x in a if x > 5])

3

list_max = max(a)
len([x for x in a if x == list_max])

1

len([x for x in a if x == max(a)]) # anche cosi' insomma

1

Domanda, forse naive. A parte la soddisfazione/divertimento di costruire
dei one-liner qual è il vero vantaggio di tale super-sinteticità? perché

Post by unknown

number_list = [2, -4, 27, 44, 13, 0]
up_limit = 5
counter = 0

... if i > up_limit:
... counter += 1
...

Post by unknown

counter

3

Inserito in un contesto più complesso, così non un po' più chiaro?

Ciao,
Lorenzo.

[unknown]

2013/9/17 Lorenzo Sutton <lorenzofsutton a gmail.com>

Post by unknown
Domanda, forse naive. A parte la soddisfazione/divertimento di costruire
dei one-liner qual è il vero vantaggio di tale super-sinteticità? perché

number_list = [2, -4, 27, 44, 13, 0]
up_limit = 5
counter = 0

... counter += 1
...

counter

3
Inserito in un contesto più complesso, così non un po' più chiaro?

:D

N risposte, tutte vere dal mio punto di vista, alcune estremamente
soggettive:
1) 1000 anni di lavoro in Java ti portano a idolatrare la sinteticita' e
detestare la verbosita'
2) meno codice scrivo e meno bugs ho
3) meno codice scrivo e piu' devo alzare il livello di astrazione e piu'
alzo anche il livello di riuso
4) non so perche', ma io veramente capisco piu' facilmente e piu'
velocemente il seguente (in Scala) rispetto a quello che hai scritto tu:
a.count(_ > 5)
Non escludo di scrivermi una count che prende una collezione e un predicato
e scrivere (in Python)
count(lambda x: x > 5, a)
Oppure rassegnarmi con:
len([x for x in a if x > 5])

Domanda di riserva: non c'e' una len() che funziona direttamente sul
generatore e non richieda di costruire una lista? Trovo il seguente
abbastanza orrido:
sum(1 for x in generator)

Vedi http://stackoverflow.com/questions/7460836/how-to-lengenerator

Ciao
Giuliano

[unknown]

Post by unknown
2013/9/17 Lorenzo Sutton <lorenzofsutton a gmail.com
<mailto:lorenzofsutton a gmail.com>>
Domanda, forse naive. A parte la soddisfazione/divertimento di
costruire dei one-liner qual è il vero vantaggio di tale

number_list = [2, -4, 27, 44, 13, 0]
up_limit = 5
counter = 0

... counter += 1
...

counter

3
Inserito in un contesto più complesso, così non un po' più chiaro?
:D
N risposte, tutte vere dal mio punto di vista, alcune estremamente
1) 1000 anni di lavoro in Java ti portano a idolatrare la sinteticita' e
detestare la verbosita'
2) meno codice scrivo e meno bugs ho
3) meno codice scrivo e piu' devo alzare il livello di astrazione e piu'
alzo anche il livello di riuso
4) non so perche', ma io veramente capisco piu' facilmente e piu'
a.count(_ > 5)

Tutti punti validi e forse come dici tu soggettivi.

A me piace l'idea di esplicitare l'algoritmo, certo in questo caso è
talmente banale che forse è un esempio poco significativo.

Se dovessi definire l'algoritmo per eseguirlo io con carta e penna (o a
mente) farei così: scorro ogni elemento della lista, se è maggiore di 5
aggiungo 1 a un "contatore" (mentale, una segnetto che faccio su un
foglio, un dito...). Quando ho finito di scorrere tutti i numeri vedo il
valore del contatore.

Tornando al titolo del topic... una delle cose che amo di Python è che
riesco a "esprimere" questi ragionamenti e a tradurli in codice meglio e
più velocemente rispetto ad altri linguaggi che ho usato... Anche qui
questioni soggettive forse.

Ciao.
Lorenzo.

[unknown]

2013/9/17 Lorenzo Sutton <lorenzofsutton a gmail.com>

Post by unknown
A me piace l'idea di esplicitare l'algoritmo, certo in questo caso è
talmente banale che forse è un esempio poco significativo.
Se dovessi definire l'algoritmo per eseguirlo io con carta e penna (o a
mente) farei così: scorro ogni elemento della lista, se è maggiore di 5
aggiungo 1 a un "contatore" (mentale, una segnetto che faccio su un foglio,
un dito...). Quando ho finito di scorrere tutti i numeri vedo il valore del
contatore.

Capito.

Post by unknown
Tornando al titolo del topic... una delle cose che amo di Python è che
riesco a "esprimere" questi ragionamenti e a tradurli in codice meglio e
più velocemente rispetto ad altri linguaggi che ho usato... Anche qui
questioni soggettive forse.

Si', un po' difficile da trasferire ad altri, ma capisco cosa vuoi dire.

Grazie e ciao
Giuliano

[unknown]

[...] Domanda di riserva: non c'e' una len() che funziona
direttamente sul generatore e non richieda di costruire una lista?

No, perch? un generatore pu? generare una sequenza infinita.
Mentre alcuni linguaggi permettono all'equivalente di len di non
tornare, questo non ? vero in Python.

In realt? la ragione pratica ? che len chiama semplicemente il medoto
__len__ dell'oggetto, che fa parte del protocollo per implementare le
sequenze.
Un generatore non pu? definire tale metodo.

Sempre in realt?, in alcuni linguaggio l'equivalente di len ?
implementata per sequenze di cui non si conosce in anticipo la lunghezza.

Ovviamente puoi rimediare definendo una tua funzione length che ? pi?
generica, che per? sar? anche meno efficiente se la applichi alle
sequenze builtin.

[...]

Ciao Manlio

[unknown]

2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>

Post by unknown

a = [2, -4, 27, 44, 13, 0]
len(x for x in a if x > 5)

File "<stdin>", line 1, in <module>
TypeError: object of type 'generator' has no len()

len([x for x in a if x > 5])

3

list_max = max(a)
len([x for x in a if x == list_max])

1

len([x for x in a if x == max(a)]) # anche cosi' insomma

1

import timeit
timeit.timeit("len([1 for x in a if x == max(a)])", "a = [2, -4, 27,

44, 13, 0]")
5.89989202538311

Post by unknown

timeit.timeit("len([1 for x in a if x == max_a])", "a = [2, -4, 27, 44,

13, 0];max_a=max(a)")
1.4572058739309028

Circa 4 volte più veloce, come è ovvio visto che fa una volta sola max
invece che 5.

Oltre al fatto che mi da un certo fastidio usare una funzione su una lista
che sto percorrendo.

Ciao.
Marco.

[unknown]

2013/9/17 Marco Beri <marcoberi a gmail.com>

Post by unknown

Post by unknown

a = [2, -4, 27, 44, 13, 0]

Post by unknown
len(x for x in a if x > 5)

File "<stdin>", line 1, in <module>
TypeError: object of type 'generator' has no len()

Post by unknown
len([x for x in a if x > 5])

3

Post by unknown
list_max = max(a)
len([x for x in a if x == list_max])

1

Post by unknown
len([x for x in a if x == max(a)]) # anche cosi' insomma

1

import timeit
timeit.timeit("len([1 for x in a if x == max(a)])", "a = [2, -4, 27,

44, 13, 0]")
5.89989202538311

Post by unknown

timeit.timeit("len([1 for x in a if x == max_a])", "a = [2, -4, 27,

44, 13, 0];max_a=max(a)")
1.4572058739309028
Circa 4 volte più veloce, come è ovvio visto che fa una volta sola max
invece che 5.

Si', non ci piove, l'ho solo riportata per completezza, ma non scrivere mai
codice cosi'.

Post by unknown
Oltre al fatto che mi da un certo fastidio usare una funzione su una lista
che sto percorrendo.

Concordo.

Ciao,
Giuliano

[unknown]

[...] Non e' particolarmente interessante focalizzarsi ne' su
map/reduce ne' sulle collezioni in generale.
Comunque, un altro esempio e' questo => puoi usare itertools.chain
per implementare una flatmap (sicuro che non vuoi il codice Python?
allora non leggere :) )

Non tutti conoscono Scala e sanno cosa fa flatmap.
Comunque se ho capito quello che fa:

##BEGIN##
def flatmap(seq, fun):
for x in seq:
for y in fun(x):
yield y


def foo(x):
return [x - 1, x, x + 1]


print list(flatmap([1, 2, 3, 4, 5], foo))
##END##

La list alla fine serve a stampare correttamente la sequenza "lazy"
(Python non ? Haskell).

[...]

Ciao Manlio

[unknown]

2013/9/17 Manlio Perillo <manlio.perillo a gmail.com>

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

[...] Non e' particolarmente interessante focalizzarsi ne' su
map/reduce ne' sulle collezioni in generale.
Comunque, un altro esempio e' questo => puoi usare itertools.chain
per implementare una flatmap (sicuro che non vuoi il codice Python?
allora non leggere :) )

Non tutti conoscono Scala e sanno cosa fa flatmap.

Beh, dai, e' comune a svariati linguaggi (eg: in Ruby e' facile da
implementare). In pratica e' una map, seguita da una flatten, cosi' se la
collezione risultante e' nestata la appiattisci. Vedi ad esempio
http://stackoverflow.com/questions/1077015/python-list-comprehensions-compressing-a-list-of-lists

Comunque se ho capito quello che fa:
Hai decisamente capito. :)

##BEGIN##
yield y
return [x - 1, x, x + 1]
print list(flatmap([1, 2, 3, 4, 5], foo))
##END##
La list alla fine serve a stampare correttamente la sequenza "lazy"

Bello, mi piace molto, ma soffre lo stesso problema dell'uso di chain:
lancia un'eccezione se la lista di partenza e' gia' "piatta".

print list(flatmap([1, 2, 3, 4, 5], lambda x: x + 1))

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 3, in flatmap
TypeError: 'int' object is not iterable

(Python non ? Haskell).

Potrebbe diventare la tua tagline ogni volta che mi scrivi un messaggio. ;)

Ciao,
Giuliano

[unknown]

[...] ##BEGIN## def flatmap(seq, fun): for x in seq: for y in
fun(x): yield y
def foo(x): return [x - 1, x, x + 1]
print list(flatmap([1, 2, 3, 4, 5], foo)) ##END##
La list alla fine serve a stampare correttamente la sequenza
"lazy"
Bello, mi piace molto, ma soffre lo stesso problema dell'uso di
chain: lancia un'eccezione se la lista di partenza e' gia'
"piatta".

print list(flatmap([1, 2, 3, 4, 5], lambda x: x + 1))

Traceback (most recent call last): File "<stdin>", line 1, in
<module> File "<stdin>", line 3, in flatmap TypeError: 'int' object
is not iterable

Si, perch? per "contratto" la funzione chiamata deve restituire una
sequenza.

Comunque non sono sicuro di capire cosa intendi con "lista di
partenza": ? quella che passi come primo argomento a flatmap?
In questo caso, non ? il motivo per cui la funzione fallisce.

La versione in Scala funziona in entrambi questi casi:

flatmap([1, 2, 3, 4, 5], lambda x: x + 1))
flatmap([1, 2, 3, 4, 5], lambda x: [x + 1))

?

E' facile modificare la funzione in modo da funzionare in ogni caso,
ma non mi sembra una buona idea.

[...]

Ciao Manlio

[unknown]

Post by unknown

print list(flatmap([1, 2, 3, 4, 5], lambda x: x + 1))

Traceback (most recent call last): File "<stdin>", line 1, in
<module> File "<stdin>", line 3, in flatmap TypeError: 'int' object
is not iterable

Si, perch? per "contratto" la funzione chiamata deve restituire una
sequenza.
Comunque non sono sicuro di capire cosa intendi con "lista di
partenza": ? quella che passi come primo argomento a flatmap?

Si', [1, 2, 3, 4, 5]

Post by unknown
In questo caso, non ? il motivo per cui la funzione fallisce.
flatmap([1, 2, 3, 4, 5], lambda x: x + 1))
flatmap([1, 2, 3, 4, 5], lambda x: [x + 1))
?

Ho toppato e alla grande: il comportamento di Scala e' identico a Python
(con un messaggio d'errore che e' tutto un programma, te lo risparmio). E'
Ruby quello con cui puoi fare flatmap su una collezione gia' piatta e non
si imbufalisce.
Ovvero:

irb(main):001:0> a = [1, 2, 3, 4, 5]
=> [1, 2, 3, 4, 5]
irb(main):002:0> a.flat_map{|x| x + 1}
=> [2, 3, 4, 5, 6]
irb(main):003:0> a.flat_map{|x| [x + 1]}
=> [2, 3, 4, 5, 6]
irb(main):004:0>

Questo proprio perche' la flatmap di Ruby e' analoga a fare una map,
seguita da una flatten.

Post by unknown
E' facile modificare la funzione in modo da funzionare in ogni caso,
ma non mi sembra una buona idea.

Ok.

Ciao,
Giuliano

[unknown]

[...] Ho toppato e alla grande: il comportamento di Scala e'
identico a Python (con un messaggio d'errore che e' tutto un
programma, te lo risparmio). E' Ruby quello con cui puoi fare
flatmap su una collezione gia' piatta e non si imbufalisce.

Ok, allora ha senso.
Puoi scrivere tranquillamente l'equivalente Python, sia modificando la
funzione che ho postato (controllando se il valore restituito dalla
funzione sia una sequenza o uno scalare), sia reimplementandola come
map seguita da flatten.

Peccato che flatten non sia disponibile in itertools, e non credo sia
implementabile in modo elegante.

[...]

Ciao Manlio

[unknown]

2013/9/18 Manlio Perillo <manlio.perillo a gmail.com>

Post by unknown
Peccato che flatten non sia disponibile in itertools, e non credo sia
implementabile in modo elegante.

Dipende cosa intendi con "elegante". A me questa non dispiace:

import collections as c

def flatten(obj):
"""

Post by unknown

list(flatten(1))

[1]

Post by unknown

list(flatten([1, 2, 3]))

[1, 2, 3]

Post by unknown

list(flatten([1, [2, 3], [4, 5], 6]))

[1, 2, 3, 4, 5, 6]
"""
stack = [obj]
while stack:
current = stack.pop()
if isinstance(current, c.Sequence):
stack.extend(reversed(current))
else:
yield current


if __name__ == '__main__':
import doctest
doctest.testmod()

Facilmente adattabile per una flatmap alla ruby. Non e testata molto (come
si puo' vedere), ma sembra ragionevole.

Si, avrei potuto usare ricorsione esplicita invece dello stack, ma poi si
sarebbe complicata la gestione del generatore, temo.
Poi possiamo girarci intorno: Python supporta alcuni costrutti funzionali
ma quello che e' e rimane e' un linguaggio *imperativo* ad oggetti.
In pratica le parti veramente funzionali di python girano intorno ad
itertools e functools e a poche features del core (LC).

Insomma, Python e' un linguaggio che *sceglie* di avere degli statement e
non di essere tutto un'espressione. Vorra' pur dire qualcosa.

[unknown]

2013/9/18 enrico franchi <enrico.franchi a gmail.com>

Post by unknown
2013/9/18 Manlio Perillo <manlio.perillo a gmail.com>

Post by unknown
Peccato che flatten non sia disponibile in itertools, e non credo sia
implementabile in modo elegante.

Niente male, concordo.

Post by unknown
import collections as c
"""

Post by unknown

list(flatten(1))

[1]

Post by unknown

list(flatten([1, 2, 3]))

[1, 2, 3]

Post by unknown

list(flatten([1, [2, 3], [4, 5], 6]))

[1, 2, 3, 4, 5, 6]
"""
stack = [obj]
current = stack.pop()
stack.extend(reversed(current))
yield current
import doctest
doctest.testmod()
Facilmente adattabile per una flatmap alla ruby. Non e testata molto (come
si puo' vedere), ma sembra ragionevole.
Si, avrei potuto usare ricorsione esplicita invece dello stack, ma poi si
sarebbe complicata la gestione del generatore, temo.
Poi possiamo girarci intorno: Python supporta alcuni costrutti funzionali
ma quello che e' e rimane e' un linguaggio *imperativo* ad oggetti.
In pratica le parti veramente funzionali di python girano intorno ad
itertools e functools e a poche features del core (LC).
Insomma, Python e' un linguaggio che *sceglie* di avere degli statement e
non di essere tutto un'espressione. Vorra' pur dire qualcosa.

Non so se c'e' un messaggio nella bottiglia, comunque a me personalmente
interessano i modelli misti FP+OO (in nessun ordine particolare), non
quelli puri.

Ciao
Giuliano

[unknown]

2013/9/18 Piergiuliano Bossi <pgbossi a gmail.com>

Post by unknown
Non so se c'e' un messaggio nella bottiglia, comunque a me personalmente
interessano i modelli misti FP+OO (in nessun ordine particolare), non
quelli puri.

Beh, Python puro sicuro non lo e'. Non ci prova, non gli interessa esserlo.
Ha elementi di tanti paradigmi. Pero' rimane *principalmente* un linguaggio
imperativo ad oggetti.
Puoi perfino impararci la programmazione funzionale. Molte dei pezzi piu'
interessanti sono funzionali.
Ci sono tutti gli aspetti di metaprogrammazione, funzioni e oggetti che
modificano classi, oggetti e funzioni.
Pero', alla fine dei conti, il grosso del codice e' codice ad oggetti
imperativo.

[unknown]

ciao,
che sappiate esiste un modo più elegante per evitare quello che segue?
x = UnCertaFunzioneCheRitornaINT()
if x>67: x=67
if x<-67: x=-67

in pratica mi vanno bene tutti i valori fra -67 e +67 e se sono fuori
filtro con il margine del range.

Vittorio

[unknown]

Post by unknown
ciao,
che sappiate esiste un modo più elegante per evitare quello che segue?
x = UnCertaFunzioneCheRitornaINT()
if x>67: x=67
if x<-67: x=-67

from math import copysign

Post by unknown

x = get_value_of_X()

... x = copysign(67,x)

Che ne dici? !-)

[unknown]

Post by unknown
ciao,
che sappiate esiste un modo più elegante per evitare quello che segue?
x = UnCertaFunzioneCheRitornaINT()
if x>67: x=67
if x<-67: x=-67
from math import copysign

x = get_value_of_X()

... x = copysign(67,x)
Che ne dici? !-)

Non male, ma speravo in un miracolo pythonesco del tipo

x = min_max(-67,67,UnCertaFunzioneCheRitornaINT())

colpo secco in una riga...
ma è già meglio della mia
vittorio

Post by unknown
--
valerio
_______________________________________________
Python mailing list
Python a lists.python.it
http://lists.python.it/mailman/listinfo/python

-------------- parte successiva --------------
Un allegato HTML è stato rimosso...
URL: <http://lists.python.it/pipermail/python/attachments/20130919/77fa9a36/attachment-0001.html>

[unknown]

x = copysign(min(abs(x), 67), x)
-------------- parte successiva --------------
Un allegato HTML è stato rimosso...
URL: <http://lists.python.it/pipermail/python/attachments/20130918/e35eb836/attachment.html>

[unknown]

Post by unknown
x = copysign(min(abs(x), 67), x)

/One line to rule them all/ !-)
+1

[unknown]

On Thu, Sep 19, 2013 at 8:43 AM, Valerio Maggio

Post by unknown

Post by unknown
x = copysign(min(abs(x), 67), x)

/One line to rule them all/ !-)

intorno ai 60 e copysign va importato quindi una riga in più

[unknown]

Post by unknown
On Thu, Sep 19, 2013 at 8:43 AM, Valerio Maggio

Post by unknown

Post by unknown
x = copysign(min(abs(x), 67), x)

/One line to rule them all/ !-)

intorno ai 60 e copysign va importato quindi una riga in più

Versione con soli operatori logici :

result = x>0 and (((x>67) and 67) or x) or (((x<-67) and -67) or x)

Lo so che come leggibilità non è il massimo ;)


G

[unknown]

2013/9/19 Giovanni Porcari <giovanni.porcari a softwell.it>

Post by unknown
result = x>0 and (((x>67) and 67) or x) or (((x<-67) and -67) or x)
Lo so che come leggibilità non è il massimo ;)

Ma è un bell'esercizio!

Grande.

[unknown]

Post by unknown
result = x>0 and (((x>67) and 67) or x) or (((x<-67) and -67) or x)
x = -67 if x < -67 else min(x, 67)

entrambe hanno prestazioni molto vicine a quella di Diego.

[unknown]

Post by unknown

Post by unknown
ciao,
che sappiate esiste un modo più elegante per evitare quello che segue?
x = UnCertaFunzioneCheRitornaINT()
if x>67: x=67
if x<-67: x=-67
from math import copysign

x = get_value_of_X()

... x = copysign(67,x)
Che ne dici? !-)

Non male, ma speravo in un miracolo pythonesco del tipo
x = min_max(-67,67,UnCertaFunzioneCheRitornaINT())
colpo secco in una riga...
ma è già meglio della mia
vittorio

x=UnCertaFunzioneCheRitornaINT()
x=min(max(x,-67),67)

[unknown]

2013/9/19 Diego Barrera <diegonebarrera a yahoo.it>:
x = min(max(x,-67),67)

non so perché ma mi son ritrovato a provare anche il contrario:
y = max(min(x, 67), -67)

risultato: x è più veloce di y.
27 milionesimi di secondo contro 59.
nel caso dipenda dal codice ho usato, eccolo:

from datetime import datetime
a, z = datetime.now(), 66

a = datetime.now()
x = min(max(z, -67), 67)
print x
print datetime.now() - a

a = datetime.now()
y = max(min(z, 67), -67)
print y
print datetime.now() - a

[unknown]

risultato: x è più veloce di y.

Post by unknown
27 milionesimi di secondo contro 59.

Non so la velocita' ma

from math import copysign

x = valore_che_vuoi

[x if x in range(-67,67) else copysign(67,x)]

Carlos (che adora le List Comprehension)

[unknown]

[x if x in range(-67,67) else copysign(67,x)] # 60 milionesimi

[x if x in range(-67,67) else copysign(67,x)][0] # 42 (senza unità :)

[unknown]

Post by unknown
[x if x in range(-67,67) else copysign(67,x)]
Carlos (che adora le List Comprehension)

Sì, fino a vederle anche dove non ci sono.
-------------- parte successiva --------------
Un allegato HTML è stato rimosso...
URL: <http://lists.python.it/pipermail/python/attachments/20130919/282790b8/attachment-0001.html>

[unknown]

Post by unknown
risultato: x è più veloce di y.

Post by unknown
27 milionesimi di secondo contro 59.

Non so la velocita' ma
from math import copysign
x = valore_che_vuoi
[x if x in range(-67,67) else copysign(67,x)]

Alternativa:

x = blah()
x = -67 if x < -67 else min(x, 67)

[unknown]

Post by unknown
x = blah()
x = -67 if x < -67 else min(x, 67)

Questa è la più leggibile di tutte, cosa piuttosto importante. :-)

[unknown]

Post by unknown

Post by unknown
x = blah()
x = -67 if x < -67 else min(x, 67)

Questa è la più leggibile di tutte, cosa piuttosto importante. :-)

Leggibile è leggibile, ma personalmente trovo più compatta e leggibile:

x = min(67, max(-67, blah()))

Ciao.
Marco.

[unknown]

Post by unknown

Post by unknown

Post by unknown
x = blah()
x = -67 if x < -67 else min(x, 67)

Questa è la più leggibile di tutte, cosa piuttosto importante. :-)

Leggibile è leggibile, ma personalmente trovo più compatta e
x = min(67, max(-67, blah()))

È più compatta in quantità trascurabile, ma più leggibile?

Non avevo letto con attenzione la specifica, e fino alla tua non l'avevo
capita: quella di Andrea è lampante. Dai, non ci credo che non trovi la
sua più leggibile della tua.


P.S.: te l'ho già detto ma mi tocca ripetere: ti prego, fai qualcosa per
migliorare il quoting. Ogni volta perdo un sacco di tempo a risistemare
(e no, lo sai che non ci rinuncio :-) ).

Se può essere un ulteriore motivo per smettere di usare GMail, ben venga,
no? ;-)

[unknown]

2013/9/19 Nicola Larosa <nico a teknico.net>

Post by unknown
P.S.: te l'ho già detto ma mi tocca ripetere: ti prego, fai qualcosa per
migliorare il quoting. Ogni volta perdo un sacco di tempo a risistemare
(e no, lo sai che non ci rinuncio :-) ).

Mi ricordi qual'era il problema? Ci sono altri che vedono male il mio
quoting?

Come sai ci tengo anche io :-)

Se può essere un ulteriore motivo per smettere di usare GMail, ben venga,

Post by unknown
no? ;-)

Onestamente non ne vedo la necessità.

Ciao.
Marco.
P.S. Questo messaggio l'ho lasciato apposta col quoting standard di Gmail.

[unknown]

2013/9/19 Nicola Larosa <nico a teknico.net <mailto:nico a teknico.net>>
P.S.: te l'ho già detto ma mi tocca ripetere: ti prego, fai qualcosa per
migliorare il quoting. Ogni volta perdo un sacco di tempo a risistemare
(e no, lo sai che non ci rinuncio :-) ).
Mi ricordi qual'era il problema? Ci sono altri che vedono male il mio
quoting?

Il problema è che se rispondo in testo liscio (come ancora faccio) e non
riformatto, il quoting viene come quello sopra: non abbastanza ">", spazi
in eccesso tra le ">" e il testo, linee troppo lunghe.

P.S. Questo messaggio l'ho lasciato apposta col quoting standard di Gmail.

[unknown]

Post by unknown
x = blah()
x = -67 if x < -67 else min(x, 67)

Questa è la più leggibile di tutte, cosa piuttosto importante. :-)

[unknown]

2013/9/19 Vittorio Spina <vittorio.spina a gmail.com>

Post by unknown
Non male, ma speravo in un miracolo pythonesco del tipo
x = min_max(-67,67,UnCertaFunzioneCheRitornaINT())

Beh, la versione di Diego (che preferisco) non è molto lontana da questa:

x = min(max(UnaCertaFunzioneCheRitornaINT(), -67), 67)

Ciao.
Marco.

[unknown]

Post by unknown

ciao, che sappiate esiste un modo pi? elegante per evitare quello
che segue? x = UnCertaFunzioneCheRitornaINT() if x>67: x=67 if
x<-67: x=-67
from math import copysign
... x = copysign(67,x)
Che ne dici? !-)

Non male, ma speravo in un miracolo pythonesco del tipo
x = min_max(-67,67,UnCertaFunzioneCheRitornaINT())

Non vedo nulla di pythonesco o miracoloso.
Semplicente ti basta definire questa funzione, ed usarla.

Post by unknown
colpo secco in una riga...

def clamp(x, min, max):
if x < min:
return min
elif x > max:
return max
else:
return x

x = clamp(x, -67, 67)


Le funzioni definite dall'utente e con lexical scoping sono
disponibili da Algol 60 (1960) (visto che parli di miracoli...)

Post by unknown
[...]

Ciao Manlio

[unknown]

Post by unknown
return min
return max
return x

Si potrebbe disquisire un po' sull'opportunità di togliere else/elif :)
-------------- parte successiva --------------
Un allegato HTML è stato rimosso...
URL: <http://lists.python.it/pipermail/python/attachments/20130919/c5459cee/attachment.html>

[unknown]

return max else: return x

Si potrebbe disquisire un po' sull'opportunit? di togliere
else/elif :)

Perche'?

P.S.:
ma perch? avete ISO-8859-1 come character encoding predefinito?
Non ? ora di passare tutti a UTF-8, cos? Thunderbird non mi incasina
l'encoding? :)



Ciao Manlio

[unknown]

Post by unknown

Si potrebbe disquisire un po' sull'opportunit? di togliere
else/elif :)

Perche'?

Perché trovo che return/return/return sia un pattern altrettanto leggibile
e più conciso, ma era solo una battuta :)
-------------- parte successiva --------------
Un allegato HTML è stato rimosso...
URL: <http://lists.python.it/pipermail/python/attachments/20130919/85d78933/attachment.html>

[unknown]

Post by unknown

Post by unknown

Si potrebbe disquisire un po' sull'opportunit? di togliere
else/elif :)

Perche'?

Perché trovo che return/return/return sia un pattern altrettanto
leggibile e più conciso, ma era solo una battuta :)

Cioe' intendi cosi'?

def clamp(x, min, max):
if x < min: return min
if x > max: return max
return x

[unknown]

Post by unknown
if x < min: return min
if x > max: return max
return x

Sì ma col return a capo. E senza usare i nomi min/max che sono builtin.
-------------- parte successiva --------------
Un allegato HTML è stato rimosso...
URL: <http://lists.python.it/pipermail/python/attachments/20130919/575c3cc7/attachment.html>

[unknown]

Post by unknown

Post by unknown

Si potrebbe disquisire un po' sull'opportunit? di togliere
else/elif :)

Perche'?

Perché trovo che return/return/return sia un pattern altrettanto
leggibile e più conciso, ma era solo una battuta :)

Io trovo più leggibile la prima soluzione, anche se meno concisa (ed
il compilatore produce due istruzioni finali in più per il `return None`).

Post by unknown
[...]

Ciao Manlio

[unknown]

ciao,

Il mio Thunderbird mi mostra il tuo messaggio nascosto all'interno della
discussione "l'amore per il pitone". Il tuo Thunderbird no?

Evita di rispondere a uno dei messaggi di quella discussione e poi
cambiato l'oggetto. Crea invece un nuovo messaggio, e la tua discussione
verrà mostrata separatamente dalle altre.

Anche questa è netiquette. Ed anche rottura di palle, sì, ma una volta
sola sperabilmente. :-)

(Una volta sola per ognuno, s'intende. Avanti il prossimo.)

[unknown]

Post by unknown
Evita di rispondere a uno dei messaggi di quella discussione e poi
cambiato l'oggetto.

Editing fail. Qualcosa come:

Evita di rispondere a un messaggio di una discussione preesistente
cambiando poi l'oggetto.

[unknown]

Post by unknown

Post by unknown
Evita di rispondere a uno dei messaggi di quella discussione e poi
cambiato l'oggetto.

Evita di rispondere a un messaggio di una discussione preesistente
cambiando poi l'oggetto.

Infatti questo 3d mi compare all'interno di un altro..
sta cosa non ho mai capito come funziona!
Cioe' se uno risponde ad un 3d cambiando l'oggetto,
me lo mostra nel 3d originale; a volte invece benche'
uno risponda al 3d crea un nuovo albero.. perche'?
Dipende dal client?

[unknown]

Post by unknown
Evita di rispondere a un messaggio di una discussione preesistente
cambiando poi l'oggetto.

Infatti questo 3d mi compare all'interno di un altro.. sta cosa non ho
mai capito come funziona!
Cioe' se uno risponde ad un 3d cambiando l'oggetto, me lo mostra nel
3d originale; a volte invece benche' uno risponda al 3d crea un nuovo
albero.. perche'?
Dipende dal client?

Credo di sì.

Ma il rimedio è semplice: indipendentemente dal client, non farlo. :-P

[unknown]

Il giorno 19/set/2013 13:08, "Diego Barrera" <diegonebarrera a yahoo.it> ha

Post by unknown

Post by unknown

Post by unknown
Evita di rispondere a uno dei messaggi di quella discussione e poi
cambiato l'oggetto.

Evita di rispondere a un messaggio di una discussione preesistente
cambiando poi l'oggetto.

Infatti questo 3d mi compare all'interno di un altro..
sta cosa non ho mai capito come funziona!
Cioe' se uno risponde ad un 3d cambiando l'oggetto,
me lo mostra nel 3d originale; a volte invece benche'
uno risponda al 3d crea un nuovo albero.. perche'?
Dipende dal client?

Purtroppo sì... le specifiche indicano che nella risposta ad una mail venga
inserito un campo di identificazione che fa riferimento alla mail a cui si
risponde, i client seri costruiscono l'albero delle mail attraverso questi
identificativi... pro... la tua risposta finisce direttamente sotto alla
mail a cui hai risposto, quindi se il thread sui sviluppa in più rami è più
facile seguirli. Contro... se inizi un nuovo thread rispondendo ad una
mail, questa finisce nel thread precedente.

Altri client (purtroppo gmail, web o app che sia, è uno di questi) ordina i
thread in base all'oggetto... e nelle risposte non mantiene gli id (ma non
sono sicuro su questa seconda parte)... quello che avviene è che al cambio
di una sola lettera nell'oggetto ti spezza il thread... anche se non vuoi.
Altro fatto negativo.... accoda tutti i messaggi e non te li presenta
nell'affine nell'ordine giusto... creando un unico ramo di risposte.

Ora che cui penso... se leggi con Thunderbird via IMAP, vedi l'albero
corretto... quindi probabilmente vengono mantenuti gli id.

Byez

[unknown]

Post by unknown

Post by unknown

Post by unknown
Evita di rispondere a uno dei messaggi di quella discussione e poi
cambiato l'oggetto.

Evita di rispondere a un messaggio di una discussione preesistente
cambiando poi l'oggetto.

Infatti questo 3d mi compare all'interno di un altro..
sta cosa non ho mai capito come funziona!
Cioe' se uno risponde ad un 3d cambiando l'oggetto,
me lo mostra nel 3d originale; a volte invece benche'
uno risponda al 3d crea un nuovo albero.. perche'?
Dipende dal client?

normalmente il client legge l'header In-Reply-To che ad esempio per questa
mail ora è:

In-Reply-To: <523ADAF8.3060907 a yahoo.it>

io spesso per pigrizia faccio reply di una mail del gruppo e poi elimino
l'header subito, questo crea un nuovo thread, anche se lascio lo stesso
subject.

Ricordo che però yahoo qualche anno fa scassava qualunque thread perché non
utilizzava correttamente questo header

sandro
*:-)

[unknown]

Post by unknown
ciao,
che sappiate esiste un modo più elegante per evitare quello che segue?
x = UnCertaFunzioneCheRitornaINT()
if x>67: x=67
if x<-67: x=-67

Ciao,
non so se hai contemplato la possibilità di usare moduli esterni ma io
uso spesso:
numpy.clip

Molto utile su arrai/liste ma dovrebbe funzionare.
Ciao
M.

[unknown]

Ciao,

Post by unknown

a = [2, -4, 27, 44, 13, 0]
filter(lambda x: x > 5, a)

[27, 44, 13]

[x for x in a if x > 5]

[27, 44, 13]
Immagino che tu vada diretto con la seconda, mentre a me viene naturale la
prima (la trovo piu' "intention revealing", dice chiaramente che sto
filtrando la lista).

Personalmente avrei optato per la seconda... :-)
Però mi incuriosiva sapere quele implementazione è la più veloce/efficiente...

In[1]: import random
In[2]: a = [random.randint(0,100) for _ in range(100000)]
In[3]: %timeit filter(lambda x: x > 5, a)
100 loops, best of 3: 9.14 ms per loop
In [4]: %timeit [x for x in a if x > 5]
100 loops, best of 3: 5.77 ms per loop

e la seconda sembra essere la "migliore"... per quello che può valere...

Pietro

[unknown]

[...] Come per Marco, sono una delle cose che mi hanno "charmato"
del Pythone. Lambda usate si e no una volta in quasi 5 anni.
Mi sa che ti batto in un'oretta, a volte anche meno. Per me e'
naturale manipolare collezioni con filter, all, reduce, ecc.
Quindi forse sarebbe interessante capire come fare le stesse cose
senza lambda.

Ovviamente si pu? fare, solo che non sar? compatto (ed elegante, per
chi ha gusto) come facevi prima.

Del resto, un p? di verbosit? in pi? non guasta (io mi trovo bene
anche in C), ed anzi a volte aumenta la leggibilit? per quelli che si
troveranno il tuo codice tra le mani tra qualche anno; l'importante ?
che non diventi un impedimento quando devi *manutenere* un programma.


P.S.:
mi scuso per il problema con le accentate, ma sembra un bug di
Thunderbird nella nuova release di Debian, che usa il charset del
messaggio originale (ISO-8859-1, aka latin-1) anche se poi nel
Content-Type usa il mio charset predefinito (UTF-8).



Ciao Manlio

[unknown]

2013/9/17 Marco Beri <marcoberi a gmail.com>

Post by unknown
Non ti chiederei mai di dimenticarti di map, però faccio fatica a pensare
a un esempio che non possa fare a meno delle lambda limitandosi alle list
comprehension. Io le trovo quasi onnipotenti.

+1000 per Marco. Che si conferma degno di sedere alla destra del Benevolo
Tiranno ;)
(Era un poco che non lo dicevo, stavo andando in crisi di astinenza)

Carlos

[unknown]

2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>

Post by unknown
I lambda in python sono verbosi e visto che i vari map, reduce, filter,
... non sono metodi della collezione, si compongono in modo che io
percepisco come innaturale.
Ad esempio, diciamo che abbiamo un array di interi e vogliamo somarne i
cubi.

a = [1, 7, 22, 3]

=> [1, 7, 22, 3]

a.map{|x| x*x*x }.reduce{|sum, x| sum + x}

=> 11019
scala> val a = Array(1, 7, 22, 3)
a: Array[Int] = Array(1, 7, 22, 3)
scala> a.map(x => x*x*x).reduce((sum, x) => sum+x)
res1: Int = 11019

a = [1, 7, 22, 3]
reduce(lambda sum, x: sum+x, map(lambda x: x*x*x, a))

11019

Ooops saro' io ma ..... la versione Python la legge anche mio figlio 14enne
che non conosce Python, le altre due fatico a capire cosa siano io che
programmo da quasi 25 anni in non so quanti linguaggi (e relativi cancheri
tirati prima di conoscere il python).


Poi, de gustibus, sia chiaro. Pero' la pulizia e chiarezza di Python
(regexp a parte ma li son loro a essere bacate) non la ho incontrata
altrove.

Carlos

[unknown]

Esempio 2
Come faccio a verificare che tutti gli elementi di una collezione
verifichino lo stesso predicato? In Python devo prima applicare il
predicato a tutti gli elementi e poi usare la funzione all(). In linguaggi
come Ruby uso il metodo all? di enumerable direttamente (Scala e' analogo).

Python

Post by unknown

Post by unknown

a = [2, 4, 8, 11]
all(i % 2 == 0 for i in a)

False

Ruby (non testato):
a = [2, 4, 8, 11]
a.all? {|i| i % 2 == 0}

In generale, la mia impressione e' che Enumerable per Ruby e tutta la
libreria di collezioni "monstre" in Scala ti danno un sacco di modi per
manipolare le tue collezioni che in scala devi costruirti a mano, partendo
da all, len, map, reduce e i metodi di itertools. Nell'esempio di sopra,
invece Python mi obbliga prima a mappare tutti i valori di una collezione e
poi comporre la funzione desiderata. Ma se quella collezione e' grande e il
predicato computazionalmente complesso all() comunque ci itera sopra nella
sua interezza, giusto?

Dove sbaglio?

Ciao
Giuliano



2013/9/17 Marco Beri <marcoberi a gmail.com>

Post by unknown
2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>
quando devo manipolare una collezione penso a quanto piu' facile e' in

Post by unknown
Ruby o Scala

Giuliano,
magari puoi aggiungere due righe di codice per mostrare le differenze e la
maggior facilità di gestire una collezione in Ruby o Scala?
Se posso capire i conati per il self non riesco davvero a immaginare un
modo molto più facile per gestire le collezioni di quello di Python.
Ciao.
Marco.
P.S. Ovviamente salto tutta la fase dei saluti ecc. visto che ci
frequentiamo da anni (in fondo sei tu il protagonista di
http://beri.it/2009/12/22/la-neve/ che mi ha fatto andare su Radio24
http://beri.it/2012/03/19/voi-siete-qui/).
--
http://beri.it/ - Un blog
http://beri.it/i-miei-libri/ - Qualche libro
_______________________________________________
Python mailing list
Python a lists.python.it
http://lists.python.it/mailman/listinfo/python

[unknown]

Esempio 2 Come faccio a verificare che tutti gli elementi di una
collezione verifichino lo stesso predicato? In Python devo prima
applicare il predicato a tutti gli elementi e poi usare la funzione
all(). In linguaggi come Ruby uso il metodo all? di enumerable
direttamente (Scala e' analogo).

Secondo me hai scelto il linguaggio sbagliato. Prova con Haskell.

Python non ? disegnato come linguaggio funzionale, intendendo come
linguaggio in cui ? facile comporre funzioni, anche anonime.

[...]

Ciao Manlio

[unknown]

2013/9/17 Manlio Perillo <manlio.perillo a gmail.com>

Post by unknown
Secondo me hai scelto il linguaggio sbagliato. Prova con Haskell.

Grazie, ma decisamente NO, grazie. :)

Post by unknown
Python non ? disegnato come linguaggio funzionale, intendendo come
linguaggio in cui ? facile comporre funzioni, anche anonime.

Capito, me ne faro' una ragione. Altri spunti?

Ciao
Giuliano

[unknown]

Post by unknown
2013/9/17 Manlio Perillo <manlio.perillo a gmail.com
<mailto:manlio.perillo a gmail.com>>
Secondo me hai scelto il linguaggio sbagliato. Prova con Haskell.
Grazie, ma decisamente NO, grazie. :)

Se ti piace la programmazione funzionale, ? il linguaggio che mi
sembra la rappresenti meglio.
Peccato che sia facile scrivere codice funzionale elegante e conciso,
ma anche facile arrivare a codice complesso ed ingestibile per noi
persone normali.

Post by unknown
Python non ? disegnato come linguaggio funzionale, intendendo come
linguaggio in cui ? facile comporre funzioni, anche anonime.
Capito, me ne faro' una ragione. Altri spunti?

Fare altra esperienza con il linguaggio.
Come ti gi? hanno detto, i generatori sono molto interessanti ed io ne
ho abusato molto.

Poi ci sono i decoratori, le metaclassi, i descrittori.
Ma se vieni da Ruby, non saprei dirti di pi?, anche perch? non conosco
Ruby.


Ciao Manlio

[unknown]

Nota: mi hanno fatto notare in privato che all() e' lazy e non e' vero che
comporta l'applicazione della trasformazione a tutti gli elementi della
collezione (perche' non trasforma la collezione in toto, bensi' usa il
generatore direttamente).

Ma tanto voi questo lo sapevate gia'. :)

Ciao,
Giuliano



2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>

Post by unknown
Esempio 2
Come faccio a verificare che tutti gli elementi di una collezione
verifichino lo stesso predicato? In Python devo prima applicare il
predicato a tutti gli elementi e poi usare la funzione all(). In linguaggi
come Ruby uso il metodo all? di enumerable direttamente (Scala e' analogo).
Python

Post by unknown

Post by unknown

a = [2, 4, 8, 11]
all(i % 2 == 0 for i in a)

False
a = [2, 4, 8, 11]
a.all? {|i| i % 2 == 0}
In generale, la mia impressione e' che Enumerable per Ruby e tutta la
libreria di collezioni "monstre" in Scala ti danno un sacco di modi per
manipolare le tue collezioni che in scala devi costruirti a mano, partendo
da all, len, map, reduce e i metodi di itertools. Nell'esempio di sopra,
invece Python mi obbliga prima a mappare tutti i valori di una collezione e
poi comporre la funzione desiderata. Ma se quella collezione e' grande e il
predicato computazionalmente complesso all() comunque ci itera sopra nella
sua interezza, giusto?
Dove sbaglio?
Ciao
Giuliano
2013/9/17 Marco Beri <marcoberi a gmail.com>

Post by unknown
2013/9/17 Piergiuliano Bossi <pgbossi a gmail.com>
quando devo manipolare una collezione penso a quanto piu' facile e' in

Post by unknown
Ruby o Scala

Giuliano,
magari puoi aggiungere due righe di codice per mostrare le differenze e
la maggior facilità di gestire una collezione in Ruby o Scala?
Se posso capire i conati per il self non riesco davvero a immaginare un
modo molto più facile per gestire le collezioni di quello di Python.
Ciao.
Marco.
P.S. Ovviamente salto tutta la fase dei saluti ecc. visto che ci
frequentiamo da anni (in fondo sei tu il protagonista di
http://beri.it/2009/12/22/la-neve/ che mi ha fatto andare su Radio24
http://beri.it/2012/03/19/voi-siete-qui/).
--
http://beri.it/ - Un blog
http://beri.it/i-miei-libri/ - Qualche libro
_______________________________________________
Python mailing list
Python a lists.python.it
http://lists.python.it/mailman/listinfo/python

--
Piergiuliano Bossi
Blog: http://thinkingbox.wordpress.com/
Twitter: http://twitter.com/thinkingbox (English)
Twitter: http://twitter.com/scatolapensante (Italiano)
Google+: https://plus.google.com/u/0/108187981162465525118

[unknown]

Post by unknown
Nota: mi hanno fatto notare in privato che all() e' lazy e non e'
vero che comporta l'applicazione della trasformazione a tutti gli
elementi della collezione (perche' non trasforma la collezione in
toto, bensi' usa il generatore direttamente).

Non credo sia corretto dire che `all` ? lazy.
Semplicemente `all` accetta qualsiasi sequenza e non ha bisogno di
consumarla tutta per ritornare.

Quindi se passi ad all un generatore, hai un comportamento lazy.


Ciao Manlio

[unknown]

2013/9/17 Manlio Perillo <manlio.perillo a gmail.com>

Post by unknown
Non credo sia corretto dire che `all` ? lazy.
Semplicemente `all` accetta qualsiasi sequenza e non ha bisogno di
consumarla tutta per ritornare.
Quindi se passi ad all un generatore, hai un comportamento lazy.

Si', hai ragione.

Ciao,
Giuliano

[unknown]

Post by unknown
Intanto mi presento: alcuni di voi mi conoscono dai tempi di
stacktrace.it <http://stacktrace.it>, altri da thinkcode.tv
<http://thinkcode.tv> (ero uno dei compagni di merende di
Marco Beri).

Ciao Piergiuliano.

Post by unknown
Ogni volta che devo scrivere self mi viene un conato di vomito,
quando devo manipolare una collezione penso a quanto piu' facile e'
in Ruby o Scala, leggo che GVR mal sopporta FP e mi intristisco...
non sono qui a fare il troll, al contrario, voglio decisamente far
funzionare questa relazione.

Non tutte le relazioni sono fatte per funzionare. Qual è la tua
motivazione per insistere?

Se è una libera scelta, forse potresti accettare il fatto che Python non
ti piace poi tanto, e usare ciò che ti piace di più

Se invece devi usarlo per forza, beh, forse è meglio di dover usare per
forza altre cose, ma di certo non è una bella situazione.

Al cuor non si comanda. :-)