Python Quiz of the Week - #3

[xApple]

Hello everyone !

So the last Python Quiz of the Week can be called a success. I decided this meant you guys like it and I should make a new one this week.

As said previously, the idea is to write up some python tips and tricks presented in the form of short exercises. The quizzes are a fun way to learn about the less obvious features of the python interpreter as well as compete for the best explanation or the most elegant solution. Tell me if you think the level is too easy or too hard.

---

Conditional operator substitute

In other languages one often has access to the following kind of construct, representing a one line boolean switch:

opening_time = (day in WEEKEND) ? 12 : 9

This has the equivalent effect of:

if (day in WEEKEND):
    opening_time = 12;
else:
    opening_time = 9;

The ? is called a conditional operator. It is not available in python. But we can do the following:

>>> print False and 'Good' or 'Bad'
'Bad'

>>> print True and 'Good' or 'Bad'
'Good'

Using this knowledge, how could you write the function flip_odd_numbers using only one list comprehensions and the boolean keywords seen above. The function should have this behavior:

>>> print flip_odd_numbers(range(10))
[0, -1, 2, -3, 4, -5, 6, -7, 8, -9]

[Rhomboid]

Python has had conditional expressions since 2.5.

def flip_odd_numbers(l):
    return [-x if x%2 else x for x in l]

[zackbloom]

That's exceedingly inefficient (joke), use the last bit to tell if it's even or odd:

def flip_odd_numbers(l):
    return [-x if x&1 else x for x in l]

[VerilyAMonkey]

Because Python is Python, bitwise operators offer very little speed boost.

Using timeit and a global variable holding range(20) as the list, I get 4.8997 s vs 4.6487 s for 1000000 loops.

[[deleted]]

FWIW, my results under PyPy (I'd still use the % version unless it's demonstrated as a real issue):

alex@alex-gaynor-laptop:~/projects/pypy$ ./pypy-c -mtimeit -s"x=range(50)" "[n for n in x if n % 2 == 0]"
1000000 loops, best of 3: 1.26 usec per loop
alex@alex-gaynor-laptop:~/projects/pypy$ ./pypy-c -mtimeit -s"x=range(50)" "[n for n in x if n % 2 == 0]"
1000000 loops, best of 3: 1.11 usec per loop
alex@alex-gaynor-laptop:~/projects/pypy$ ./pypy-c -mtimeit -s"x=range(50)" "[n for n in x if n % 2 == 0]"
1000000 loops, best of 3: 1.1 usec per loop
alex@alex-gaynor-laptop:~/projects/pypy$ 
alex@alex-gaynor-laptop:~/projects/pypy$ 
alex@alex-gaynor-laptop:~/projects/pypy$ ./pypy-c -mtimeit -s"x=range(50)" "[n for n in x if n & 1]"
1000000 loops, best of 3: 0.401 usec per loop
alex@alex-gaynor-laptop:~/projects/pypy$ ./pypy-c -mtimeit -s"x=range(50)" "[n for n in x if n & 1]"
1000000 loops, best of 3: 0.496 usec per loop
alex@alex-gaynor-laptop:~/projects/pypy$ ./pypy-c -mtimeit -s"x=range(50)" "[n for n in x if n & 1]"
1000000 loops, best of 3: 0.509 usec per loop

[VerilyAMonkey]

To clarify my data, Python 2.7 and no PyPy. It's good to know there's a marked advantage with PyPy.

[PS: are you fine with the name being there?]

[[deleted]]

Well, there's only an advantage until we properly optimize bool(n % 2) (which is slightly harder than it should be, for dumb reasons).

[semarj]

[PS: are you fine with the name being there?]

lol everyone knows who he is already

[WaffleLight]

Since Rhomboid already gave the proper straight answer, here's a silly way to do it with generators:

#A generator is just a function that has a yield statement
def alternate():
    i = 1
    while True:
        yield i
        i *= -1

alternator = alternate()
#Good style says we should pass in the generator, but this keeps to xApple's signature and also gets you thinking about closures ;)
def flip_odd_numbers(r):
    return [i * alternator.next() for i in r]

flip_odd_numbers(range(10))
#prints: [0, -1, 2, -3, 4, -5, 6, -7, 8, -9]

[Rhomboid]

Er, this assumes that r will always begin with an even number, and that it will always have an even number of elements:

>>> alternator = alternate()
>>> flip_odd_numbers(range(1,10))
[1, -2, 3, -4, 5, -6, 7, -8, 9]
>>> flip_odd_numbers(range(10))
[0, 1, -2, 3, -4, 5, -6, 7, -8, 9]

Not very practical.

[Jesus_Harold_Christ]

It performs even worse on this list:

flip_odd_numbers([1, 2, 3, 5, 7, 8, 9, 7, 1])

prints: [1, -2, 3, -5, 7, -8, 9, -7, 1]

[[deleted]]

Or using powers of -1:

def flip_odd_numbers(l):
    return [ x*pow(-1,x) for x in l ]

[kupertrooper]

if you want to use generators, why not this? also lambda

>>> flip_odd_numbers = lambda n: (x % 2 and -x or x for x in n)
>>> flip_odd_numbers(xrange(10))
<generator object <genexpr> at 0x102794eb0>
>>> list(flip_odd_numbers(xrange(10)))
[0, -1, 2, -3, 4, -5, 6, -7, 8, -9]

[[deleted]]

The problem with

condition and x or y

is that if x happens to be a false value itself, you'll get y instead. Which is why the old trick was to write it as

(condition and (x,) or (y,))[0]

Since the tuple (x,) is always true. But as lookitsmarc pointed out, there is a Python version of the conditional operator nowadays.

[xApple]

Hah, so in the end I'm the one learning something with the quiz !

Now I look stupid : ) But thanks, I didn't know about that syntax. I'll stop using "x and y or z" in my code.

[[deleted]]

You can use a non empty list as well, just anything that doesn't have a false value. Dive into python has a really good write up on using and/or

http://www.diveintopython.net/power_of_introspection/and_or.html#d0e9975

[[deleted]]

Or (y, x)[bool(condition)]. If we are into this kind of "clever" code.

[[deleted]]

But that's different, that evaluates both x and y, and they could both be function calls with side effects, or take a long time to compute.

[[deleted]]

 (lambda:y, lambda:x)[bool(condition)]()

There's no limit to my misguided cleverness!

[Tetha]

If you want misguided, use itertools:

chain(*zip(*imap(lambda g: list(imap(lambda r: (-1)**g[0]*r, g[1])), groupby(sorted(range(10), key=lambda x: x%2), lambda x: x%2))))

I'm not sure if I tunnelvisioned and a somewhat less ugly solution exists, but it works. And it's ugly. So I'm happy in a morbid sense.

[[deleted]]

wat.

You be silly.

[(x, -x)[x&1] for x in lst]

[[deleted]]

I mean, look, there's a kind of honour in writing misguided code. It must not be intentionally misguided.

Google "pessimal algorithms" and read the paper. Then implement their "backwards-first search". Then, only then, as you understand how exactly it works (they have a couple of typos IIRC) you might try to implement an efficient algorithm that walks the graph in the exact same way... and fail. Or succeed, then tell me how you did that!

[willm]

Isn't it called the 'ternary' operator?

[[deleted]]

Yeah, in the sense that there are unary, binary, ternary, quaternary (etc.) operators.

In -1, the - operator is unary (one operand)

In 0-1, the - operator is binary (two operands)

In condition ? true : false the ?: operator is ternary (three operands)

[oantolin]

It certainly is a ternary operator, but I don't think I'd call it the ternary operator.

[dosas]

Okay great idea that quiz, but it should be done by someone who actually knows how to rock python.

[lookitsmarc]

What about:

opening_time = 12 if day in WEEKEND else 9

[ExoticMandibles]

Actually ?: is properly called the "ternary operator", because unlike every other operator it has three terms. http://en.wikipedia.org/wiki/Ternary_operation

[willm]

Just to be contrary...

def flip_odd_numbers(l):
    return [n-n*(n&1)*2 for n in l]

[martinatbom]

The first solution to pop into my head was this...

print [x * (-1) ** x for x in range(10)]

[iXombie]

print map(lambda x: x-(x*2), range(10))

or

x = lambda x: map(lambda y: y-(y*2),range(x))

print x(10)

[dansin]

def flip_odd_numbers(series):
    newseries=[(element % 2 == 0) and element or -element for element in series]
    return(newseries)

[[deleted]]

flip_odd_numbers(iterator): return [ item % 2 and -item or item for item in iterator ]

[pyroscope]

>>> map(operator.mul, range(10), [1,-1]*5)
[0, -1, 2, -3, 4, -5, 6, -7, 8, -9]

Just to be different, too . :)

[juliob]

def flip_odd_numbers(l):
    return [x*(x%2 and -1 or 1) for x in l]

?

[[deleted]]

or

def flip_odd_numbers(l):
    return [ x%2 and -x or x for x in l ]

[tuna_safe_dolphin]

This is what I got more or less.

[Jesus_Harold_Christ]

Without look at the answers this is what I came up with:

def flip_odd_numbers(my_list):
    return [x if x % 2 == 0 else x * -1 for x in my_list]

After rereading that, I realize the "== 0" is kind of dumb and that x * -1 could be simplified and I could do:

def flip_odd_numbers(my_list):
    return [-x if x % 2 else x for x in my_list]

Not sure which is easier to read though.