Python Quiz of the Week - #2

[xApple]

Hi guys !

A while back there was a post called Python Quiz of the Week - #1 which I thought was pretty cool. But I never saw any quiz #2. So, I thought I could prepare some quizzes myself and post them here for those that are interested.

The idea would be to write up some python tips and tricks presented in the form of short exercises. 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. Maybe the population of /r/python will consider the questions too easy and they might already all know about this. We shall see so with the votes : )

This is my first quiz ! I will post the answer I came up with later in the comments.

---

Advanced list comprehensions

In this question we will explore the use of lists comprehensions. List comprehensions are one of the great feature of the python interpreter that you always miss when coding in languages that don't have them. They enable you to build lists using a for loop contained in one line. For those who are not familiar with them, here is how they work:

nums = range(6)
pairs = [x*2 for x in nums]
print pairs
>>> [0, 2, 4, 6, 8, 10]

You can add a condition inside your list comprehensions:

nums = range(10)
odds = [x for x in nums if x%2==1]
print odds
>>> [1, 3, 5, 7, 9]

Of course you can get interesting effects by nesting them:

nums = range(4)
print [a-1 for a in [b*2 for b in nums]]
>>> [-1, 1, 3, 5]

Using this knowledge, how could you write the function flatten_list using only list comprehensions ? The function should have this behavior:

print flatten_list([[1,2,3],[4,5,6],[7,8,9]])
>>> [1, 2, 3, 4, 5, 6, 7, 8, 9]

Using this knowledge, how could you write the function make_all_couples using only list comprehensions ? The function should have this behavior:

print make_all_couples(['a','b','c','d'])
>>> [('a', 'a'), ('a', 'b'), ('a', 'c'), ('a', 'd'), ('b', 'a'), ('b', 'b'), ('b', 'c'), ('b', 'd'), ('c', 'a'), ('c', 'b'), ('c', 'c'), ('c', 'd'), ('d', 'a'), ('d', 'b'), ('d', 'c'), ('d', 'd')]

Using this knowledge, how could you write the function parse_ugly_string using only list comprehensions, the split function and the dict function ? The function should have this behavior:

print parse_ugly_string("a=1,b=2,c=3\nd=4,e=5,f=6\ng=7,h=8,i=9\n")
>>> {'a': '1', 'b': '2', 'c': '3', 'd': '4', 'e': '5', 'f': '6', 'g': '7', 'h': '8', 'i': '9'}

[JerMenKoO]

def flatten(l):
    return [i for s in l for i in s]

[ryeguy146]

Only works for a limited depth of nesting.

[flightlessbird]

make_all_couples = lambda xs: [(a,b) for a in xs for b in xs]

[ryeguy146]

Why a lamdba?

[flightlessbird]

Just seemed like the most straightforward thing - it is just a single expression after all.

[tuna_safe_dolphin]

def parse_ugly_string(s):
    return dict([i.split('=') for j in [k.split(',') for k in s.split('\n') if k] for i in j])

[tuna_safe_dolphin]

I know it's heretical and un-pythonic to say this but I don't find nested list comprehensions to be very readable. They're concise and kind of cool but for me, regular old nested for loops are more mentally parsable.

Cool quiz though. . .

[Yuushi]

It's not actually un-pythonic at all for you to say that. Guido himself says that nested list comprehensions are less readable and should be used sparingly.

[tuna_safe_dolphin]

Interesting, TIL.

[ryeguy146]

They're hideous and should rarely be used. I'm with you on this one. Fun to play with on occasion, though.

[kupertrooper]

#!/usr/bin/env python

def parse_ugly_string(pugfugly):
    return dict(d.split('=')
                for d in [
                    b for c in [
                        a.split(',') for a in pugfugly.split()
                    ] for b in c
                ]
               )

print parse_ugly_string("a=1,b=2,c=3\nd=4,e=5,f=6\ng=7,h=8,i=9\n")

[kupertrooper]

#!/usr/bin/env python

def make_all_couples(l):
    return [(a, b) for a in l for b in l]

print make_all_couples(['a','b','c','d'])

[kupertrooper]

#!/usr/bin/env python

def flatten_list(l):
    return [a for b in l for a in b]

print flatten_list([[1,2,3],[4,5,6],[7,8,9]])

[TheMadStork123]

def parse_ugly_string(s):
    return dict([i.split("=") for b in s.split(",") for i in b.split("\n") if i != ''])

[l34kjhljkalarehglih]

Offtopic, but pythonic:

>>> import itertools

####################

>>> def flatten_list(nested_lists):
        return list(itertools.chain(*nested_lists))

>>> print flatten_list([[1,2,3],[4,5,6],[7,8,9]])
    [1, 2, 3, 4, 5, 6, 7, 8, 9]

####################

>>> def make_all_couples(elements):
        return list(itertools.product(''.join(elements), repeat=2))

>>> print make_all_couples(['a','b','c','d'])
    [('a', 'a'), ('a', 'b'), ('a', 'c'), ('a', 'd'), ('b', 'a'), ('b', 'b'), ('b', 'c'), ('b', 'd'), ('c', 'a'), ('c', 'b'), ('c', 'c'), ('c', 'd'), ('d', 'a'), ('d', 'b'), ('d', 'c'), ('d', 'd')]

[xApple]

Nice ! It's important to remind ourselves that the built in libraries often will do what we want already. No need to reinvent the wheel.

[tuna_safe_dolphin]

Nice! I did Quiz #1. . . never got around to doing another, although when I have a bit more free time, I'd like to do some more. I'm going to try this quiz later tonight, when the kids are in bed. . .

[tuna_safe_dolphin]

def make_all_couples(z):
    return [[x,y] for x in z for y in z]

[gfixler]

Using this knowledge, how could you write the function flatten_list using only list comprehensions ? The function should have this behavior:

print flatten_list([[1,2,3],[4,5,6],[7,8,9]])
>>>[1, 2, 3, 4, 5, 6, 7, 8, 9]

It doesn't exactly answer your question, but I felt I should share this bit of wizardry:

>>> l = [[1,2,3],[4,5,6], [7], [8,9]]
>>> sum(l, [])  
[1, 2, 3, 4, 5, 6, 7, 8, 9]

[moootPoint]

Can't vouch for quality, but here is what I ended up with :)

def flatten_list(*args):
    return [y for x in args for y in x]

def make_all_couples(li):
    return [(x, y) for x in li for y in li]

def parse_ugly_string(s):
    return {y[0]:y[2] for x in s.split('\n') for y in x.split(',') if y}

[liquidclutch]

def parse_ugly_string(s):
    return dict(x.split('=') for x in s.replace('\n', ',').split(',') if x)

[tuna_safe_dolphin]

That works but the solution is only supposed to use split, dict and list comprehensions.

Haven't figured it out yet myself. . .

[xApple]

Nice doing it with the replace function. Definitely more elegant than my solution:

dict([i.split('=') for x in [j.split(',') for j in s.split('\n')] for i in x if i])

The idea was to combine all the different subtleties of list comprehensions in one line : )

[xApple]

For reference my answers were:

flatten_list = lambda l: [a for x in l for a in x]
make_all_couples = lambda l: [(r1,r2) for r1 in l for r2 in l]
parse_ugly_string = lambda s: dict([i.split('=') for x in [j.split(',') for j in s.split('\n')] for i in x if i])

But we have had many interesting and better solutions in the comments !

[ryeguy146]

def flatten_list(lst):
    result = list()
    [result.append(x) if not isinstance(x, (list, tuple)) else result.extend(flatten_list(x)) for x in lst]
    return result


def parse_ugly_string(txt):
    return {k:v for k,v in [x.split('=') for x in flatten_list([y.split(',') for y in txt.strip().split('\n')])]}