python2.4 generator expression > python2.3 list expression

[snacktime]

I need to convert a generator expression to a list expression so it
will work under python 2.3.

I rewrote this:

for c in range(128):
even_odd = (sum(bool(c & 1<<b) for b in range(8))) & 1

As this:

for c in range(128):
bo = [bool(c & 1<<b) for b in range(8)]
even_odd = sum(bo) & 1
Seems to work, is there a better way to do this?

[Terry Reedy]

"Christos TZOTZIOY Georgiou" <tz**@sil-tec.gr> wrote in message
news:0i******** *************** *********@4ax.c om...

On 21 Feb 2005 06:48:19 -0500, rumours say that Dan Sommers
<[e-mail] >

for c in range( 128 ):
even_odd = 0
print '%3d' % c,
while c:
c &= c - 1
even_odd = not even_odd
print int( even_odd )

Just for the sake of people who haven't messed with bit manipulation in C
or
assembly, the effect of
c &= c - 1
is to reset the rightmost (less significant) '1' bit of a number (ie
change it
to '0').

Cute. I tried it a few times until I saw why it works. But it is also
dangerous (within a loop like the above) in a language like current Python
(and unlike C/assembler) in which the binary representation of -1 is
effectively a left infinite string of '1's: ...1111111111

Terry J. Reedy

[Christos TZOTZIOY Georgiou]

On Mon, 21 Feb 2005 10:55:05 -0800, rumours say that Bryan <be****@gmail.c om>
might have written:
[i]

is to reset the rightmost (less significant) '1' bit of a number (ie
change it to '0').
[bryan]i tried c &= c - 1 but i'm not getting the least significant or
rightmost bit reset to zero. am i misunderstandin g something?
>>2 & 1 # 2 = 0x10; reset right most would be 0x10

<snip>

[Duncan] The difference between the original "reset the rightmost '1' bit", and your
interpretation: "reset the rightmost bit" is the "'1'".

The rightmost bit that is set is reset. So 0x10 -> 0, and 0x1010 -> 0x1000.

<snip>

thanks duncan... you're right, i did intrepret this as "reset the rightmost bit"
instead of "reset the rightmost '1' bit". and i must have read what christos
wrote 100 times!!!

Don't worry, Bryan, I'm probably more to blame, since I have this tendency to
interject parenthesized sub-sentences all over my paragraphs, that probably
confuse more than clarify things ( self.remind(pro se is not code) :).

Perhaps I should crosspost my replies (esp. the ones with nested parentheses) to
comp.lang.lisp ...
--
TZOTZIOY, I speak England very best.
"Be strict when sending and tolerant when receiving." (from RFC1958)
I really should keep that in mind when talking with people, actually...

[Duncan Booth]

Dan Sommers wrote:

Seems to work, is there a better way to do this?

for c in range( 128 ):
even_odd = 0
print '%3d' % c,
while c:
c &= c - 1
even_odd = not even_odd
print int( even_odd )

Okay, so your inner loop is only counting to 8, but IMO this is a good
example of how to use a better algorithm instead of optimizing the code
of a naïve one. My inner loop only iterates over 1-bits.

Here's yet another way to achieve the same results. This version doesn't
iterate over any bits at all:

import operator
parity = [ False ]
for i in range(7): parity += map(operator.no t_, parity)

And if you want the same output:
for even_odd in parity:

print int(even_odd)

[Dan Sommers]

On 22 Feb 2005 09:14:50 GMT,
Duncan Booth <du**********@i nvalid.invalid> wrote:

Here's yet another way to achieve the same results. This version doesn't
iterate over any bits at all:

import operator
parity = [ False ]
for i in range(7):

parity += map(operator.no t_, parity)

Very clever! :-)

Picking a nit, that version iterates over *two* sets of bits. The "for"
loop over each possible bit in the input values. The "map" function
over the parity bits accumulated up to that point. And the "+="
operator over those same bits again. Make that *three* sets of bits.

I stand humbled.

Regards,
Dan

--
Dan Sommers
<http://www.tombstoneze ro.net/dan/>
μ₀ × ε₀ × c² = 1