userplays = { "Alice"   : { "AC/DC" : 2,"The Raconteurs" : 3,"mogwai" : 1
                          },"Bob"     : { "The XX" : 4,"Lady Gaga" : 3,"mogwai" : 1,"The Raconteurs" : 1
                          },"Charlie" : { "AC/DC" : 7,"Lady Gaga" : 7
                          }
            }

获取所有乐队的列表：

[''Lady Gaga'',''mogwai'',''AC/DC'',''The Raconteurs'',''The XX'']

我可以

list(set(flatten([ [ band 
                     for band 
                     in playcounts.keys() ] 
                   for playcounts 
                   in userplays.values() ] ) ) )

flatten是从Flatten (an irregular) list of lists开始,但是可以不使用flatten,只使用list / dict理解吗？

{k:v for v in userplays.values() for k in v.keys()}.keys()

生产：

[''Lady Gaga'',''The XX'']

至少在Python 3.3中,这也更快：

import timeit

userplays = { "Alice"   : { "AC/DC" : 2,"Lady Gaga" : 7
                          }
            }


def f1():
    set(b for v in userplays.values() for b in v.keys())

def f2():
    {k:v for v in userplays.values() for k in v.keys()}.keys()    

t1=timeit.Timer(f1).timeit(10000)
t2=timeit.Timer(f2).timeit(10000)
faster=abs(t1-t2) / max(t1,t2)
print("""
set:                {:.4} seconds
dict:               {:.4} seconds
faster of those is  {:.4%} faster

""".format(t1,t2,faster))

输出：

set:                0.02448 seconds
dict:               0.01988 seconds
faster of those is  18.7907% faster

编辑

仅仅为了纯粹的好奇心,我比较了在单行中可以做到的各种方式.

结果如下：

f1: set from a generator expression
f2: keys from a dict comprehension
f3: set comprehension
f4: set from a list comprehension

       rate/s      f4       f1       f2       f3 
f4    358,650    0.0%   -13.4%   -31.7%   -41.3% 
f1    414,246   15.5%     0.0%   -21.1%   -32.2% 
f2    525,230   46.4%    26.8%     0.0%   -14.1% 
f3    611,158   70.4%    47.5%    16.4%     0.0%

你可以看到集合理解是最快的,然后是字典理解.

以下是生成Perl样式基准的代码：

import timeit
import locale
locale.setlocale(locale.LC_NUMERIC,"")

userplays = { "Alice"   : { "AC/DC" : 2,"Lady Gaga" : 7
                          }
            }

def f1():
    """set from a generator expression"""
    set(b for v in userplays.values() for b in v.keys())

def f2():
    """keys from a dict comprehension"""
    {k:v for v in userplays.values() for k in v.keys()}.keys()    

def f3():
    """set comprehension"""
    {b for v in userplays.values() for b in v.keys()}

def f4():
    """set from a list comprehension"""
    set([b for v in userplays.values() for b in v.keys()])

def test_table(funcs,c):
    results={k.__name__:timeit.Timer(k).timeit(c) for k in funcs}
    fastest=sorted(results,key=results.get,reverse=True)
    table=[]
    table.append(['' '',''rate/s'']+fastest)
    for e in fastest:
        temp=[]
        temp.append(e)
        temp.append(int(round(float(c)/results[e])))
        t2=[''{:.1%}''.format((results[x]-results[e])/results[e]) for x in fastest]
        table.append(temp+t2)
    print()    
    for e in funcs:
        print(''{}: {}''.format(e.__name__,e.__doc__))
    print()            
    pprint_table(table)    

def format_num(num):
    """Format a number according to given places.
    Adds commas,etc. Will truncate floats into ints!"""

    try:
        inum = int(num)
        return locale.format("%.*f",(0,inum),True)

    except (ValueError,TypeError):
        return str(num)

def get_max_width(table,index):
    """Get the maximum width of the given column index"""
    return max([len(format_num(row[index])) for row in table])        

def pprint_table(table):
    col_paddings = []
    for i in range(len(table[0])):
        col_paddings.append(get_max_width(table,i))

    for row in table:
        # left col
        print(row[0].ljust(col_paddings[0] + 1),end='' '')
        # rest of the cols
        for i in range(1,len(row)):
            col = format_num(row[i]).rjust(col_paddings[i] + 2)
            print (col,end='' '')
        print()

test_table([f1,f2,f3,f4],100000)

ls = [myfunc(a,b,i) for a in a_list for b in b_list]

但也将i传入myfunc,这是一个从0开始的索引,并为每个新元素递增.

例如：

a_list = ''abc''
b_list = ''def''

应该导致

ls = [myfunc(''a'',''d'',0),myfunc(''a'',''e'',1),''f'',2),myfunc(''b'',3),4),...
      myfunc(''c'',8]

我知道我可以使用enumerate()来表示正常情况,即.

ls = [myfunc(a,i) for a,i in enumerate(a_list)]

但是,当有两个人时,我无法弄清楚如何干净利落地做到这一点.我以前找不到这个问题.

from itertools import product

ls = [myfunc(a,i) for i,(a,b) in enumerate(product(a_list,b_list))]

对于无法使用product()的情况,您可以将多个循环放在生成器表达式中,然后将enumerate()添加到该表达式中.假设您需要过滤a_list的某些值：

gen = (a,b for a in a_list if some_filter(a) for b in b_list)
ls = [myfunc(a,b) in enumerate(gen)]

另一种选择是增加一个单独的柜台; itertools.count()为您提供了一个计数器对象,它使用next()生成一个新值：

from itertools import count

counter = count()
ls = [myfunc(a,next(counter)) 
      for a in a_list if some_filter(a)
      for b in b_list]

毕竟,实质上枚举(iterable,start = 0)相当于zip(itertools.count(start),iterable).