相关疑难解决方法(0)

这是我试图变成列表理解的代码:

table = ''
for index in xrange(256):
    if index in ords_to_keep:
        table += chr(index)
    else:
        table += replace_with

有没有办法将else语句添加到此理解中？

table = ''.join(chr(index) for index in xrange(15) if index in ords_to_keep)

>>> x=[1,2]
>>> x[1]
2
>>> x=(1,2)
>>> x[1]
2

它们都有效吗？出于某种原因是首选吗？

在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()构造函数中的生成器表达式的语法糖,特别是循环控制变量不再泄漏到周围的范围中.

from django import forms

class SignUpForm(forms.Form):
    birth_day = forms.ChoiceField(choices=range(1,32))

我在渲染时遇到"Caught TypeError:'int'对象不可迭代". https://docs.djangoproject.com/en/dev/ref/models/fields/#field-choices说,choices参数采用列表或元组之类的迭代.

http://docs.python.org/library/functions.html#range表示range()创建一个列表.

为什么我收到错误？

我尝试使用map()将列表转换为str,但收到了不同的错误.

我知道函数可以在Python中返回多个值.我想要做的是将列表中的每个元素作为单独的返回值返回.这可以是任意数量的元素,具体取决于用户输入.我想知道是否有这样做的pythonic方式？

例如,我有一个函数将一对项作为数组返回,例如,它将返回[a, b].

但是,根据给定的输入,该函数可能会产生多对,这将导致函数返回[[a, b], [c, d], [e, f]].相反,我希望它回来[a, b], [c, d], [e, f]

到目前为止,我已经实现了一个非常粗暴的功能,有很多临时变量和计数,我正在寻找一个更清晰的建议.

感谢帮助!

我刚刚阅读了为什么 Python 中没有元组理解的问题？

在接受的答案的评论中，指出没有真正的“元组理解”。相反，我们当前的选择是使用生成器表达式并将生成的生成器对象传递给元组构造函数：

tuple(thing for thing in things)

或者，我们可以使用列表推导式创建一个列表，然后将该列表传递给元组构造函数：

tuple([thing for thing in things])

最后，与接受的答案相反，最近的一个答案指出元组推导确实是一件事（自 Python 3.5 起），使用以下语法：

*(thing for thing in things),

• 在我看来，第二个示例似乎也是首先创建生成器对象的示例。这样对吗？

• 就幕后发生的事情而言，这些表达之间有什么区别吗？在性能方面？我假设第一个和第三个可能有延迟问题，而第二个可能有内存问题（如链接评论中所述）。

• 比较第一个和最后一个，哪个更pythonic？

更新：

正如预期的那样，列表理解确实要快得多。我不明白为什么第一个比第三个快。有什么想法吗？

>>> from timeit import timeit

>>> a = 'tuple(i for i in range(10000))'
>>> b = 'tuple([i for i in range(10000)])'
>>> c = '*(i for i in range(10000)),'

>>> print('A:', timeit(a, number=1000000))
>>> print('B:', timeit(b, number=1000000))
>>> print('C:', timeit(c, number=1000000))

A: …

首先,我想测试生成器和列表理解之间的内存使用情况.本书给了我一个小小的代码片段,我在我的PC上运行它(python3.6,Windows),发现一些意想不到的东西.

1. 在书中,它说,因为列表理解必须创建一个真实的列表并为它分配内存,所以从列表理解中的itering必须比从生成器中的itering慢.
2. 当然,列表理解比生成器使用更多的内存.

FOllowing是我的代码,它不满足以前的意见(在sum函数中).

import tracemalloc
from time import time


def timeIt(func):
    start = time()
    func()
    print('%s use time' % func.__name__, time() - start)
    return func


tracemalloc.start()

numbers = range(1, 1000000)


@timeIt
def lStyle():
    return sum([i for i in numbers if i % 3 == 0])


@timeIt
def gStyle():
    return sum((i for i in numbers if i % 3 == 0))


lStyle()

gStyle()

shouldSize = [i for i in numbers if i % 3 == 0]

snapshotL = tracemalloc.take_snapshot()
top_stats …

我知道我可以通过这两种方法创建一个元组：

tuple([1, 2, 3])
(1, 2, 3)

我试图了解这里到底发生了什么：

tuple( (x, x*x) for x in [1, 2, 3] )

元组构造函数似乎需要一个列表，但下面的代码似乎不会生成一个列表

(x, x*x) for x in [1, 2, 3]

我也想知道为什么这不起作用：

( (x, x*x) for x in [1, 2, 3] )

对于字典，我似乎可以使用：

my_dict = dict()
my_dict = {}

但现在我想知道是否像元组一样存在差异。是():tuple()一种不同的::关系吗{}:dict()？

我一直很喜欢Python3.5中添加的元组理解:

In [128]: *(x for x in range(5)),
Out[128]: (0, 1, 2, 3, 4)

但是,当我return直接尝试元组理解时,我得到一个错误:

In [133]: def testFunc():
     ...:     return *(x for x in range(5)),
     ...: 
  File "<ipython-input-133-e6dd0ba638b7>", line 2
    return *(x for x in range(5)),
           ^
SyntaxError: invalid syntax    

这只是一个轻微的不便,因为我可以简单地将元组理解分配给变量并返回变量.但是,如果我尝试在字典理解中加入元组理解,我会得到同样的错误:

In [130]: {idx: *(x for x in range(5)), for idx in range(5)}
  File "<ipython-input-130-3e9a3eee879c>", line 1
    {idx: *(x for x in range(5)), for idx in range(5)}
          ^
SyntaxError: invalid syntax

我觉得这有点问题,因为在某些情况下,压缩对性能很重要.

在这些情况下使用字典和列表推导没有问题.当其他人做的时候,有多少其他情况是元组理解无法发挥作用？或许我使用它错了？

它让我想知道如果它的使用是如此有限或者我做错了什么的重点是什么？如果我没有做错什么,那么创建一个足够多的元组的最快/最pythonic方式是什么,以与列表和字典理解相同的方式使用？

可以使用以下代码创建列表：

>>> [i+1 for i in(0,1,2)]
[1, 2, 3]

元组可以做类似的事情吗？

>>> (i+1 for i in(0,1,2)),
(<generator object <genexpr> at 0x03A53CF0>,)

我会期望(1, 2, 3)作为输出。

我知道您可以做tuple(i+1 for i in(0,1,2))，但是既然您可以做[i+1 for i in(0,1,2)]，我希望元组也可以做类似的事情。

我目前正在使用带有 enumerate 的 for 循环从下面的元组列表中提取：

[(0, 'handle', 'VARCHAR(50)', 1, None, 1), (1, 'Firstname', 'TEXT', 1, None, 0), (2, 'Surname', 'TEXT', 1, None, 0), (3, 'Callname', 'TEXT', 1, None, 0), (4, 'Gender', 'INTEGER', 1, None, 0)]

我想要的是最终得到以下元组 ('handle', 'Firstname', 'Surname', 'Callname', 'Gender')

在不枚举它们并创建新元组的情况下，最有效的方法是什么，或者这是唯一的方法？

假设我有一个元组(4,5,6,7,8).我想迭代它,然后每次迭代只打印该索引后的数字.像这样:

for i in tuple:
    #print values to the right of i

输出示例:5,6,7,8,6,7,8,7,8,8.有什么帮助吗？我知道如何通过索引访问元组值,而不是相反.

a=[['1','3','2'],['11','22','33']]
k = [(float(a[i][j]) for j in range(0,3)) for i in range(0,2)]
>>> print k
[<generator object <genexpr> at 0x7f1a9d568f50>, <generator object <genexpr> at 0x7f1a9d568fa0>]

但我想得到[(1,3,2),(11,22,33)]为什么列表理解产生一个发电机？