相关疑难解决方法(0)

我有两个Python字典,我想编写一个返回这两个字典的表达式,合并.update()如果它返回结果而不是就地修改dict,那么该方法将是我需要的.

>>> x = {'a': 1, 'b': 2}
>>> y = {'b': 10, 'c': 11}
>>> z = x.update(y)
>>> print(z)
None
>>> x
{'a': 1, 'b': 10, 'c': 11}

我怎样才能获得最终合并的词典z,不是x吗？

(要清楚的是,最后一次胜利的冲突处理dict.update()也是我正在寻找的.)

__slots__Python中的目的是什么- 特别是关于我何时想要使用它,何时不想使用它？

我试图了解引擎盖下的python哈希函数.我创建了一个自定义类,其中所有实例都返回相同的哈希值.

class C(object):
    def __hash__(self):
        return 42

我只是假设上面的类中只有一个实例可以随时出现在一个集合中,但实际上一个集合可以有多个具有相同散列的元素.

c, d = C(), C()
x = {c: 'c', d: 'd'}
print x
# {<__main__.C object at 0x83e98cc>:'c', <__main__.C object at 0x83e98ec>:'d'}
# note that the dict has 2 elements

我进行了一些实验,发现如果我重写__eq__方法使得类的所有实例比较相等,那么该集只允许一个实例.

class D(C):
    def __eq__(self, other):
        return hash(self) == hash(other)

p, q = D(), D()
y = {p:'p', q:'q'}
print y
# {<__main__.D object at 0x8817acc>]: 'q'}
# note that the dict has only 1 element

所以我很想知道dict有多个具有相同哈希的元素.谢谢!

注意:编辑问题以给出dict(而不是set)的例子,因为答案中的所有讨论都是关于dicts的.但这同样适用于集合; 集合也可以有多个具有相同散列值的元素.

Python字典查找算法如何在内部工作？

mydi['foo'] 

如果字典有1,000,000个术语,是否执行了树搜索？我是否期望在关键字符串的长度或字典的大小方面表现？也许将所有内容都填入字典中就像为500万字符串的字符串编写树搜索索引一样好？

我正在研究python如何实现字典.python字典实现中的一个等式涉及使用等式的空字典时隙的伪随机探测

j = ((j*5) + 1) % 2**i

这里解释了.

我已经读过这个问题,Python的内置字典是如何实现的,基本上理解字典是如何实现的.

我不明白的是为什么/如何等式:

j = ((j*5) + 1) % 2**i   

循环通过所有剩余的 2**i.例如,如果i = 3总起始大小为8, j则通过循环:

0
1
6
7
4
5
2
3
0

如果起始大小是16,它将经历循环:

0 1 6 15 12 13 2 11 8 9 14 7 4 5 10 3 0

这对于探测字典中的所有插槽非常有用. 但为什么它有效呢？ 为什么 j = ((j*5)+1)工作但没有工作,j = ((j*6)+1) 或者j = ((j*3)+1) 两者都陷入较小的周期.

我希望能够更直观地理解这一点,而不仅仅是方程式,这就是他们使用它的原因.

我想知道是否有可能获得与此代码相同的输出:

d = {'a':None,'b':'12345','c':None}
nones=False
for k,v in d.items(): 
  if d[k] is None:
    nones=True      

要么

any([v==None for v in d.values()])

但没有for循环迭代器或生成器？

我发现一些链接谈论切换案例在c ++中比其他更快,因为它可以在编译中进行优化.然后我找到了一些人们的建议,使用字典可能比If语句更快.然而,大多数谈话都是关于某些人的工作结束,最后讨论他们应该首先优化代码的其他部分,除非你做了数百万的其他事情,否则无关紧要.谁能解释为什么会这样？

假设我有100个唯一的数字将不断地流入python代码.我想检查它是哪个号码,然后执行一些操作.所以我可以做大量的if else,或者我可以将每个数字放在字典中.为了论证,让我们说它是一个单一的线程.

有人理解python和低级执行之间的层可以解释这是如何工作的吗？

谢谢 :)

我写了一个快速的Python脚本来比较两个文件,每个文件包含无序的哈希值,以验证两个文件除了顺序之外是否相同.然后我用Ruby重写了它以用于教育目的.

Python实现需要几秒钟,而Ruby实现需要大约4分钟.

我有一种感觉,这很可能是由于我缺乏Ruby知识,对我做错了什么想法？

环境是Windows XP x64,Python 2.6,Ruby 1.8.6

蟒蛇

f = open('c:\\file1.txt', 'r')

hashes = dict()

for line in f.readlines():
    if not line in hashes:
        hashes[line] = 1
    else:
        hashes[line] += 1


print "Done file 1"

f.close()

f = open('c:\\file2.txt', 'r')

for line in f.readlines():
    if not line in hashes:
        print "Hash not found!"
    else:
        hashes[line] -= 1

f.close()

print "Done file 2"

num_errors = 0

for key in hashes.keys():
    if hashes[key] != 0:
        print "Uneven hash count: %s" % …

我有一个包含500万个字符串元素的列表,这些元素存储为pickle对象.

a = ['https://en.wikipedia.org/wiki/Data_structure','https://en.wikipedia.org/wiki/Data_mining','https://en.wikipedia.org/wiki/Statistical_learning_theory','https://en.wikipedia.org/wiki/Machine_learning','https://en.wikipedia.org/wiki/Computer_science','https://en.wikipedia.org/wiki/Information_theory','https://en.wikipedia.org/wiki/Statistics','https://en.wikipedia.org/wiki/Mathematics','https://en.wikipedia.org/wiki/Signal_processing','https://en.wikipedia.org/wiki/Sorting_algorithm','https://en.wikipedia.org/wiki/Data_structure','https://en.wikipedia.org/wiki/Quicksort','https://en.wikipedia.org/wiki/Merge_sort','https://en.wikipedia.org/wiki/Heapsort','https://en.wikipedia.org/wiki/Insertion_sort','https://en.wikipedia.org/wiki/Introsort','https://en.wikipedia.org/wiki/Selection_sort','https://en.wikipedia.org/wiki/Timsort','https://en.wikipedia.org/wiki/Cubesort','https://en.wikipedia.org/wiki/Shellsort']

为了删除重复项,我使用set(a),然后我再次通过列表list(set(a)).

我的问题是:

即使我重新启动python,并从pickle文件中读取列表,list(set(a))每次的顺序是否相同？

我很想知道这个哈希 - >列表排序是如何工作的.

我测试了一个小数据集,它似乎有一致的排序.

In [50]: a = ['x','y','z','k']

In [51]: a
['x', 'y', 'z', 'k']

In [52]: list(set(a))
['y', 'x', 'k', 'z']

In [53]: b=list(set(a))

In [54]: list(set(b))
['y', 'x', 'k', 'z']

In [55]: del b

In [56]: b=list(set(a))

In [57]: b
['y', 'x', 'k', 'z']

我希望将a的键替换dict为较短的变体,以便它可以以紧凑的形式通过电线发送.有没有办法更新密钥,而不是创建一个新项目dict并删除旧的？

我现在在做什么:

>>> a = dict(long_key=None)
>>> a['l'] = a['long_key']
>>> del a['long_key']

我想做的是这样的事情:

>>> a = dict(long_key=None)
>>> a.update_key('long_key', 'l')

我不确定dict自己的内部情况.但是,似乎 update_key可以避免需要删除旧密钥.