小编Wil*_*ill的帖子

我正在尝试学习整齐的pythonic做事方式,并想知道为什么我的for循环不能以这种方式重构:

q  = [1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5]
vm = [-1, -1, -1, -1]

for v in vm:
    if v in q:
        p.append(q.index(v))
    else:
        p.append(99999)

vm[p.index(max(p))] = i

我尝试用以下代码替换for循环:

[p.append(q.index(v)) if v in q else p.append(99999) for v in vm]

但它不起作用.该for v in vm:循环由逐出数字vm基于当他们来到下一对q.

我一直在研究python脚本来分析CSV.其中一些文件相当大(1-2百万条记录),脚本需要数小时才能完成.

我改变了记录从for-in循环处理到while循环的方式,并且加速非常显着.演示如下:

>>> def for_list():
...     for d in data:
...             bunk = d**d
... 
>>> def while_list():
...     while data:
...             d = data.pop(0)
...             bunk = d**d
... 
>>> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> import timeit
>>> timeit.timeit(for_list)
1.0698931217193604
>>> timeit.timeit(while_list)
0.14515399932861328

几乎快一个数量级.我从来没有看过python字节码,但我可能会说,但事实证明它while_list有更多的指令.

那么这里发生了什么？这里有原则我可以申请其他课程吗？是否有for比这快十倍的情况while？

编辑:正如@HappyLeapSecond指出的那样,我并不完全清楚内部发生了什么timeit .差异消失了以下:

>>> def for_list():
...     data = [x for x in range(1000)]
... …

在这个关于 python one-liner 的问题的评论中，我突然想到我不知道 python 如何处理匿名文件对象。从问题：

open(to_file, 'w').write(open(from_file).read())

有两个open不使用with关键字的调用（这通常是我处理文件的方式）。我过去曾使用过这种未命名的文件。IIRC，文件上似乎有一个剩余的操作系统级锁，该锁会在一两分钟后过期。

那么这些文件句柄会发生什么？他们是通过垃圾收集清理的吗？通过操作系统？当close()被调用时 Python 机器和文件会发生什么，当脚本完成并经过一段时间后，这一切都会发生吗？

我正在尝试使用Python格式化整数列表,但是我在实现我想要的方面遇到了一些困难.

输入是整数的排序列表:

list = [1, 2, 3, 6, 8, 9]

我希望它的输出是一个像这样的字符串:

outputString = "1-3, 6, 8-9"

到目前为止,我设法实现的目标是:

outputString = "1-2-3, 6, 8-9"

如果它已经连续,我很难告诉我的代码忽略一个Int.

到目前为止,这是我的代码:

def format(l):
    i = 0
    outputString = str(l[i])
    for x in range(len(l)-1):
        if l[i + 1] == l[i]+1 :
            outputString += '-' + str(l[i+1])
        else :
            outputString += ', ' + str(l[i+1])
        i = i + 1
    return outputString

感谢您的帮助和见解:)

SO上的一个常见问题是从列表列表中删除重复项.由于列表不可用,因此set([[1, 2], [3, 4], [1, 2]])抛出TypeError: unhashable type: 'list'.这类问题的答案通常涉及使用元组,元组是不可变的,因此可以清除.

这个回答什么使得列表不可用？包括以下这些:

如果散列值在存储在字典中的特定插槽后发生更改,则会导致字典不一致.例如,最初列表将存储在位置A,该位置是基于散列值确定的.如果哈希值发生变化,如果我们查找列表,我们可能无法在位置A找到它,或者根据新的哈希值,我们可能会找到一些其他对象.

但我不太明白,因为可以使用其他类型的字典键可以毫无问题地进行更改:

>>> d = {}
>>> a = 1234
>>> d[a] = 'foo'
>>> a += 1
>>> d[a] = 'bar'
>>> d
{1234: 'foo', 1235: 'bar'}

很明显,如果a更改的值,它将散列到字典中的不同位置. 为什么同样的假设对于列表是危险的？ 为什么以下是散列列表的不安全方法,因为无论如何我们都在使用它们？

>>> class my_list(list):
...   def __hash__(self):
...     return tuple(self).__hash__()
...
>>> a = my_list([1, 2])
>>> b = my_list([3, 4])
>>> c = my_list([1, 2])
>>> foo = [a, …