标签: list-comprehension

如果我有序列序列(可能是元组列表),我可以使用itertools.chain()来展平它.但有时我觉得我宁愿把它写成一种理解.我只是想不出怎么做.这是一个非常具体的案例:

假设我想在序列中交换每对元素.我在这里使用字符串作为序列:

>>> from itertools import chain
>>> seq = '012345'
>>> swapped_pairs = zip(seq[1::2], seq[::2])
>>> swapped_pairs
[('1', '0'), ('3', '2'), ('5', '4')]
>>> "".join(chain(*swapped_pairs))
'103254'

我在序列的偶数和奇数切片上使用zip来交换对.但我最终得到了一个现在需要扁平化的元组列表.所以我使用chain().有没有办法可以用理解来表达它？

如果你想发布你自己的解决方案来解决交换对的元素的基本问题,请继续,我会投票给任何教我新东西的东西.但是,即使答案是"不,你做不到",我也只会接受一个针对我的问题的答案.

以下哪项更好用,为什么？

方法1:

for k, v in os.environ.items():
       print "%s=%s" % (k, v)

方法2:

print "\n".join(["%s=%s" % (k, v) 
   for k,v in os.environ.items()])

我倾向于引导第一个更容易理解,但这可能只是因为我是Python新手,列表理解对我来说仍然有些陌生.第二种方式是否更像Pythonic？我假设没有性能差异,但我可能错了.这两种技术的优点和缺点是什么？

(从Dive到Python的代码)

我想知道为什么列表理解比附加到列表要快得多.我认为差异只是表达,但事实并非如此.

>>> import timeit 
>>> timeit.timeit(stmt='''\
t = []
for i in range(10000):
    t.append(i)''', number=10000)
9.467898777974142

>>> timeit.timeit(stmt='t= [i for i in range(10000)]', number=10000)
4.1138417314859

列表理解速度提高了50%.为什么？

我想从Python中的常量列表中创建一个lambda对象列表; 例如:

listOfNumbers = [1,2,3,4,5]
square = lambda x: x * x
listOfLambdas = [lambda: square(i) for i in listOfNumbers]

这将创建一个lambda对象列表,但是,当我运行它们时:

for f in listOfLambdas:
    print f(),

我希望它会打印出来

1 4 9 16 25

相反,它打印:

25 25 25 25 25

似乎lambdas都被赋予了错误的参数.我做错了什么,有没有办法解决它？我认为我在Python 2.4中.

编辑:更多的尝试事情,并提出了这样的想法:

listOfLambdas = []
for num in listOfNumbers:
    action = lambda: square(num)
    listOfLambdas.append(action)
    print action()

将预期的正方形从1打印到25,然后使用之前的print语句:

for f in listOfLambdas:
    print f(),

仍然给了我所有25的.现有的lambda对象在这两个打印调用之间是如何变化的？

相关问题:为什么map()和列表理解的结果不同？

CoffeeScript文档声明列表推导应该能够执行选择/过滤操作:

它们应该能够处理大多数你将使用循环,每个/ forEach,map或select/filter的地方.

你可以想象你可以在一条线上做点什么,result = item for item in list if item % 2 == 0 但是我能来的最近

list = [1,2,3,4]
result = []
for item in list
  if item % 2 == 0 then result.push item

什么是最简洁的方法来过滤CoffeeScript中的列表？

是否有可能在Python中定义递归列表理解？

可能是一个简单的例子,但有些东西:

nums = [1, 1, 2, 2, 3, 3, 4, 4]
willThisWork = [x for x in nums if x not in self] # self being the current comprehension

有可能这样吗？

我有一个列表,它将始终只包含1和0.我需要获得列表的非零索引列表:

a = [0, 1, 0, 1, 0, 0, 0, 0]
b = []
for i in range(len(a)):
    if a[i] == 1:  b.append(i)
print b

实现这一目标的"pythonic"方式是什么？

我正在回答这个问题,我更喜欢这里的生成器表达并使用它,我认为它会更快,因为生成器不需要先创建整个列表:

>>> lis=[['a','b','c'],['d','e','f']]
>>> 'd' in (y for x in lis for y in x)
True

Levon在他的解决方案中使用了列表理解,

>>> lis = [['a','b','c'],['d','e','f']]
>>> 'd' in [j for i in mylist for j in i]
True

但是当我做这些LC的时间结果比生成器快时:

~$ python -m timeit -s "lis=[['a','b','c'],['d','e','f']]" "'d' in (y for x in lis for y in x)"
    100000 loops, best of 3: 2.36 usec per loop
~$ python -m timeit -s "lis=[['a','b','c'],['d','e','f']]" "'d' in [y for x in lis for y …

我试图使用比较字符串对象的列表理解,但其中一个字符串是utf-8,json.loads的副产品.场景:

us = u'MyString' # is the utf-8 string

我的问题的第一部分,为什么这会返回False？:

us.encode('utf-8') == "MyString" ## False

第二部分 - 如何在列表理解中进行比较？

myComp = [utfString for utfString in jsonLoadsObj
           if utfString.encode('utf-8') == "MyString"] #wrapped to read on S.O.

编辑:我正在使用使用Python 2.7的Google App Engine

这是一个更完整的问题示例:

#json coming from remote server:
#response object looks like:  {"number1":"first", "number2":"second"}

data = json.loads(response)
k = data.keys()

I need something like:
myList = [item for item in k if item=="number1"]  

#### I thought this would work:
myList = [item for item …

在Python 3中,列表理解只是语法糖,用于生成list函数的生成器表达式？

例如是以下代码:

squares = [x**2 for x in range(1000)]

实际上在后台转换成以下内容？

squares = list(x**2 for x in range(1000))

我知道输出是相同的,并且Python 3修复了列表推导所具有的周围命名空间的令人惊讶的副作用,但就CPython解释器所做的事情而言,前者转换为后者,或者是否有任何区别在如何执行代码？

背景

我发现,在评论部分等价的这一主张这个问题,和快速谷歌搜索显示了同样的要求正在作出这里.

在Python 3.0文档中的新内容中也提到了这一点,但措辞有些含糊:

还要注意,列表推导具有不同的语义:它们更接近于list()构造函数中的生成器表达式的语法糖,特别是循环控制变量不再泄漏到周围的范围中.