相关疑难解决方法(0)

我已经看到了建议的解决方案和解决方法，但是找不到关于不允许在迭代过程中更改集的选择的解释。你能帮我理解为什么可以吗

In [1]: l = [1]

In [2]: for i in l:
            l.append(2*i)
            if len(l)>10:
                    break

In [3]: l
Out[3]: [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]

虽然这不行

In [4]: l = {1}

In [5]: for i in l:
            l.add(2*i)
            if len(l)>10:
                    break
---------------------------------------------------------------------------
RuntimeError                              Traceback (most recent call last)
<ipython-input-5-b5bdff4a382b> in <module>()
----> 1 for i in l:
      2         l.add(2*i)
      3         if len(l)>10:
      4                 break
      5

RuntimeError: Set changed size during iteration

在迭代时更改集合有什么不好？

我知道集合中的顺序未定义，因此next …

我有一个关于 python 如何处理字典中的数据的问题。假设我有一个简单的字典，其中一个数字作为键，一个数字作为值，如下所示：

a = { 5: 3, 20: 1, 1: 1, 5: 2, 100: 3, 11: 6,
     14: 1, 15: 2, 16: 4, 17: 2, 25: 1, 19: 1 }

我想遍历这本字典并打印出键。每次我循环遍历字典（如下所示）时，它都会按升序打印键。

这就是我想要它做的，但我想知道，据我所知，为什么会发生这种情况？它每次都会自动按升序排序吗？正如您在上面的字典中看到的，键显然不是按升序排列的，但下面的输出按升序打印它们。

我只是想获得一个清晰的理解，任何帮助将不胜感激。谢谢

例子

for i in a:
    print i

输出：

1
5
11
14
15
16
17
19
20
25
100

谁能解释一下这些python字典是如何列出内存中存储的变量的。我知道在 python 中内存管理是使用堆和堆栈完成的。但是我真的找不到关于创建字典变量时如何分配内存的简单解释，它是在堆栈帧还是堆空间中创建的？

我想知道python dict（字典/哈希表）是如何实现的。特别是如果我写类似

my_dict = {"key": {"key: {"key": "value"}}}

python解释器可能做什么？我想知道它的内部运作。

是否将每个字典都视为一个对象（通常是）？如果是这样，那么跨不同词典的相同键的哈希值是否相同？例如

dict1 = {"key": "value", "k": "v"}
dict2 = {"key": [1, 2.], "k": "value"}

在这两个不同的字典中对键的查找有何不同？另外，它如何确定铲斗的尺寸？还是类似于列表大小的处理？希望你能回答我的问题。谢谢！

编辑 -不，我不是问哈希表如何工作。我知道那部分。

我已经在Python中编写了一段时间,我已经习惯于认为字典具有最坏的O(n)时间复杂度(源代码).但是,在工作中我必须使用C#,而我最近才发现C#中的字典具有更好的时间复杂度(源代码).这是为什么？python词典比C#词汇有什么优势？

顺便问一下,哪种实施更常见？如果我不得不使用其他语言的标准库中的词典,他们最有可能具有什么时间复杂度？

谢谢!

我尝试比较 dict 和 if-else 哪个更快，如下所示。

d = {
    str  : lambda x: "'%s'" % str(x),
    int  : lambda x: str(x),
    float: lambda x: str(x),
}
items = ['a', 'b', 'c', 1, 2, 3, 4, 5, 1.0]

def use_dict():
    r = []
    for i in items:
        r.append(d[type(i)](i))
    return r

def use_if():
    r = []
    for i in items:
        if isinstance(i, str):
            r.append("'%s'" % str(i))
        elif isinstance(i, (int, float)):
            r.append(str(i))
    return r

if __name__ == '__main__':

    from timeit import timeit

    print 'use_dict:', …

这是一个相当简单的问题，我一直无法找到答案。如果我有一本字典，迭代它的复杂性是多少？

换句话说，诸如 之类的字典遍历的时间复杂度是多少for key in my_dict: print(key)？

我天真的理解是，由于 Python 中的字典是哈希图，因此我们需要迭代字典的所有可能的哈希值。

这看起来有点矫枉过正，但也许没问题，因为随着我们添加元素，字典会逐渐变大，所以我们通过始终拥有一个几乎满到恒定负载因子的字典来摊销成本？