blocks|key|1322148|text|这是因为为了检查是否在字典中，Python需要做的第一件事就是尝试散列对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1322149|作为另一种设计决策，Python可能已经处理了这种情况；它将在dict.__contains__实现中完成，捕获TypeError并返回False。但与不处理异常相比，这为用户提供的信息更少，因此可以说用处较小。|offset|length|style|CODE|1322150|entityMap^0|0|V|H|1K|9|1W|5|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]|$D|N|E|O|F|G]|$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|I|$]]

That's because the first thing Python needs to do in order to check whether it's in the dict is to attempt to hash the object. 

As an alternate design decision, Python could potentially have handled this case; it would be done in <code>dict.__contains__</code> implementation, catching the <code>TypeError</code> and returning <code>False</code>. But this provides less information to the user than just leaving the exception unhandled, and is therefore arguably less useful.

blocks|key|3768212|text|这是因为检查字典成员资格要求首先对对象进行散列，然后使用__eq__进行比较。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|3768213|考虑下面的玩具示例：|3768214|class+Key(object):
++def+__hash__(self):
++++print('calling+hash')
++++return+1

++def+__eq__(self,+other):
++++print('calling+eq')
++++return+True

dct+=+{1:+2}
Key()+in+dct
#+calling+hash
#+calling+eq|code-block|syntax|javascript|3768215|在您的示例中，set()无法通过散列阶段，并且会正确地引发错误，而不是静默传递。|3768216|entityMap^0|L|2|S|6|0|0|0|7|5|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|W|8|@]|E|@]|F|$]]|$1|I|3|J|5|K|7|X|8|@]|E|@]|F|$L|M]]|$1|N|3|O|5|6|7|Y|8|@$9|Z|A|10|B|D]]|E|@]|F|$]]|$1|P|3|-4|5|6|7|11|8|@]|E|@]|F|$]]]|Q|$]]

That's because checking for dictionary membership requires that the object be hashed first and then compared using <code>__eq__</code>.

Consider the following toy example:

<pre><code>class Key(object):
 def __hash__(self):
 print('calling hash')
 return 1

 def __eq__(self, other):
 print('calling eq')
 return True

dct = {1: 2}
Key() in dct
# calling hash
# calling eq
</code></pre>

In your example, the <code>set()</code> does not get past the hash stage, and an error is correctly raised, rather than passed silently.

blocks|key|1452699|text|将集合作为字典中的关键字是有问题的，因为集合是一个可变的数据结构。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1452700|当你将一些东西添加到集合中时会发生什么？应该继续将'a‘视为字典中的关键字，还是应该将具有a的原始值的其他集合视为关键字？|1452701|要使用类似set的结构作为键，请使用不可变的“frozenset”。您不能在实例化之后更改frozenset的值，因此python可以安全地允许它成为dict中的一个键。|1452702|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Making a set be a key in a dictionary is iffy because set is a mutable data structure. 

What happens when you add some things to the set? Should 'a' continue to be treated as a key in the dict or should some other set with the original value of a be treated as a key instead? 

To use a set-like structure as a key, use an immutable 'frozenset' instead. You cannot change the value of a frozenset after instantiating it and so python can safely allow it to be a key in a dict.

blocks|key|1452730|text|这样更有用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1452731|1452732|key+in+d被认为等同于|offset|length|style|CODE|1452733|any(key+==+k+for+k+in+d)|code-block|syntax|javascript|1452734|对于不可散列的对象，这实际上可能是真的：|1452735|d+=+{frozenset():+1}
key+=+set()
print(any(key+==+k+for+k+in+d))+#+prints+True|1452736|因此，尝试总是为不可散列的对象返回False将会造成不一致。从理论上讲，我们可以尝试回退到for循环，但这将导致O(len(d))性能下降，并使字典的好处化为乌有。|1452737|此外，即使key+in+d对于不可访问的key总是False，或者如果它有某种回退，大多数发生这样的测试的实例仍然可能是由于bug而不是故意的。异常比False结果更有用。|1452738|entityMap^0|0|0|0|8|0|0|0|0|H|5|19|3|0|5|8|K|3|P|5|23|5|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|C|3|D|5|6|7|Z|8|@$E|10|F|11|G|H]]|9|@]|A|$]]|$1|I|3|J|5|K|7|12|8|@]|9|@]|A|$L|M]]|$1|N|3|O|5|6|7|13|8|@]|9|@]|A|$]]|$1|P|3|Q|5|K|7|14|8|@]|9|@]|A|$L|M]]|$1|R|3|S|5|6|7|15|8|@$E|16|F|17|G|H]|$E|18|F|19|G|H]]|9|@]|A|$]]|$1|T|3|U|5|6|7|1A|8|@$E|1B|F|1C|G|H]|$E|1D|F|1E|G|H]|$E|1F|F|1G|G|H]|$E|1H|F|1I|G|H]]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|W|$]]

It's more useful that way.

<hr>

<code>key in d</code> is supposed to be equivalent to

<pre><code>any(key == k for k in d)
</code></pre>

which can actually be True for unhashable objects:

<pre><code>d = {frozenset(): 1}
key = set()
print(any(key == k for k in d)) # prints True
</code></pre>

So trying to always return <code>False</code> for unhashable objects would create an inconsistency. In theory, we could try to fall back to that <code>for</code> loop, but that would lead to silent O(len(d)) performance degradation and defeat the benefits of a dict for little gain.

Also, even if <code>key in d</code> was always <code>False</code> for an unhashable <code>key</code>, or if it had some kind of fallback, most instances where such a test even happens would still probably be due to bugs rather than deliberate. An exception is more useful than a <code>False</code> result.

If an object is unhashable, like a set, it is an error to ask whether it's a key of a dictionary:

<pre><code>&gt;&gt;&gt; key = set()
&gt;&gt;&gt; key in {}
Traceback (most recent call last):
TypeError: unhashable type: 'set'
</code></pre>

I'm just wondering why this is.

edit: I understand that the object needs to be hashed, but not why it needs to be an error if it can't.

If an object is unhashable it's an error to ask if it's a dictionary key

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

如果一个对象是不可散列的，比如一个set，那么询问它是否是字典中的键是错误的：>>> key = set()>>> key in {}Traceback (most recent call last):TypeError: unhashable type: 'set'我只是想知道为什么会这样。编辑:我知道对象需要散列，...

问如果一个对象是不可哈希的，那么询问它是否是一个字典键是错误的
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如果一个对象是不可哈希的，那么询问它是否是一个字典键是错误的EN