小编Ray*_*ger的帖子

我发现如果我在开头初始化一个空字典,然后在for循环中添加元素到字典中(大约110,000个键,每个键的值是一个列表,也在循环中增加),速度下降为for循环去.

我怀疑问题是,字典在初始化时并不知道密钥的数量而且它没有做一些非常聪明的事情,所以也许存储冲突变得非常频繁而且速度变慢.

如果我知道密钥的数量以及这些密钥究竟是什么,那么在python中是否有任何方法可以使dict(或哈希表)更有效地工作？我依稀记得,如果你知道密钥,你可以巧妙地设计哈希函数(完美哈希？)并预先分配空间.

一名学生问了这个问题,我不确定.

猜测包括:"计数","清算","分块","完整",......

标准库文档没有说明它代表什么,并且没有类似命名的函数来指示模式.有没有人知道实际的词源,也许有一个权威的参考来支持它？

我使用字典作为查找表,但我开始怀疑列表是否会更适合我的应用程序 - 查找表中的条目数量不是那么大.我知道列表在引擎盖下使用C数组,这使我得出结论,在列表中只查找几个项目比在字典中更好(访问数组中的一些元素比计算哈希更快).

我决定介绍其他选择,但结果让我感到惊讶.列表查找只有单个元素才能更好!请参见下图(log-log plot):

所以问题就出现了:为什么列表查找执行得如此糟糕？我错过了什么？

在一个侧面问题上,在大约1000个条目之后,在dict查找时间中引起我注意的其他东西是一个小"不连续".我单独绘制了dict查找时间来显示它.

ps1我知道数组和散列表的O(n)vs O(1)摊销时间,但通常情况下,迭代数组的少量元素比使用散列表更好.

ps2这是我用来比较字典和列表查找时间的代码:

import timeit

lengths = [2 ** i for i in xrange(15)]

list_time = []
dict_time = []
for l in lengths:
    list_time.append(timeit.timeit('%i in d' % (l/2), 'd=range(%i)' % l))
    dict_time.append(timeit.timeit('%i in d' % (l/2),
                                   'd=dict.fromkeys(range(%i))' % l))
    print l, list_time[-1], dict_time[-1]

ps3使用Python 2.7.13

我想找到列表中项目第n次出现的索引.例如,

x=[False,True,True,False,True,False,True,False,False,False,True,False,True]

第n个真实的索引是什么？如果我想要第五次出现(第四次,如果零索引),答案是10.

我想出来:

indargs = [ i for i,a in enumerate(x) if a ]
indargs[n]

请注意,x.index在某个点之后返回第一次出现或第一次出现,因此据我所知,这不是解决方案.

对于类似于上述情况的情况,还有numpy的解决方案,例如使用cumsum和where,但我想知道是否有一种无懈可击的方法来解决问题.

自从我第一次遇到这个问题以来,我一直关注性能,同时为项目Euler问题实现了Eratosthenes筛选,但这是我在其他情况下遇到的更普遍的问题.

编辑:我得到了很多很棒的答案,所以我决定做一些性能测试.以下是timeit具有len搜索第4000 /第1000真实的元素的列表的执行时间(以秒为单位).列表是随机的True/False.源代码链接如下; 这是一个混乱的触摸.我使用了海报名称的短/修改版本来描述除了listcomp上面的简单列表理解之外的函数.

True Test (100'th True in a list containing True/False)
         nelements      eyquem_occur eyquem_occurrence            graddy            taymon          listcomp       hettinger26         hettinger
             3000:          0.007824          0.031117          0.002144          0.007694          0.026908          0.003563          0.003563
            10000:          0.018424          0.103049          0.002233          0.018063          0.088245          0.003610          0.003769
            50000:          0.078383          0.515265          0.002140          0.078074          0.442630          0.003719          0.003608
           100000:          0.152804          1.054196 …

在python文档中,我可以看到deque是一个特别的集合,高度优化从左侧或右侧弹出/添加项目.例如文件说:

Deques是堆栈和队列的概括(名称发音为"deck",是"双端队列"的缩写).Deques支持线程安全,内存有效的附加和从双端队列的弹出,在任一方向上具有大致相同的O(1)性能.

尽管列表对象支持类似的操作,但它们针对快速固定长度操作进行了优化,并导致pop(0)和insert(0,v)操作的O(n)内存移动成本,这些操作改变了底层数据表示的大小和位置.

我决定使用ipython进行一些比较.谁能解释一下我在这里做错了什么:

In [31]: %timeit range(1, 10000).pop(0)
 10000 loops, best of 3: 114 us per loop

In [32]: %timeit deque(xrange(1, 10000)).pop() 
10000 loops, best of 3: 181 us per loop

In [33]: %timeit deque(range(1, 10000)).pop()
1000 loops, best of 3: 243 us per loop

我需要为iOS应用程序创建一个Python REST/JSON Web服务来进行交互.网络上没有前端.

什么是最快,最轻量级的框架用于此？学习曲线的实施还考虑了吗？

从研究中我已经完成了Django-Tastypie或Djanjo-Piston看起来最好的选择,Tastypie获胜因为代码库正在积极维护？

我有这个清单:

colors = ["R", "G", "B", "Y"]

我希望从中获得4个随机字母,但包括重复.

运行这个只会给我4个独特的字母,但绝不会有任何重复的字母:

print(random.sample(colors,4))

如何获得4种颜色的列表,可能重复的字母？

我一直在尝试在Python中性能优化BFS实现,我的原始实现是使用deque来存储节点队列以进行扩展,使用dict来存储相同的节点,这样我就可以有效地查找它是否已经打开.

我尝试通过移动到OrderedDict来优化(简单性和效率).但是,这需要更多的时间.完成400次样本搜索,使用deque/dict需要2秒,而使用OrderedDict需要3.5秒.

我的问题是,如果OrderedDict与两个原始数据结构具有相同的功能,它的性能至少应该相似吗？或者我在这里遗漏了什么？代码示例如下.

仅使用OrderedDict:

open_nodes = OrderedDict()
closed_nodes = {}
current = Node(start_position, None, 0)
open_nodes[current.position] = current

while open_nodes:
  current = open_nodes.popitem(False)[1]
  closed_nodes[current.position] = (current)

  if goal(current.position):
    return trace_path(current, open_nodes, closed_nodes)

  # Nodes bordering current
  for neighbor in self.environment.neighbors[current.position]:
    new_node = Node(neighbor, current, current.depth + 1)
    open_nodes[new_node.position] = new_node

使用双端队列和字典:

open_queue = deque()
open_nodes = {}
closed_nodes = {}
current = Node(start_position, None, 0)
open_queue.append(current)
open_nodes[current.position] = current

while open_queue:
  current = open_queue.popleft()
  del open_nodes[current.position]
  closed_nodes[current.position] = (current)

  if …

我需要制作一堆类变量,我想通过循环遍历这样的列表来实现:

vars=('tx','ty','tz') #plus plenty more

class Foo():
    for v in vars:
        setattr(no_idea_what_should_go_here,v,0)

可能吗？我不想让它们成为一个实例(在__init__中使用self),而是作为类变量.

Python的sqlite3 :memory:选项提供比等效的磁盘数据库更快的查询和更新.如何将基于磁盘的数据库加载到内存中,对其执行快速操作,然后将更新后的版本写回磁盘？

问题如何在python中浏览内存sqlite数据库似乎有关,但它侧重于如何在内存数据库中使用基于磁盘的浏览工具.问题如何在Python中将内存中的SQLite数据库复制到另一个内存中的SQLite数据库？也是相关的,但它是Django特有的.

我目前的解决方案是一次一个地读取所有表,从基于磁盘的数据库到元组列表,然后手动重新创建内存数据库的整个数据库模式,然后从中加载数据进入内存数据库的元组列表.在对数据进行操作之后,该过程相反.

肯定有更好的办法!