Python List不可哈希，但元组可哈希

在本文中，我们将介绍为什么Python中的列表（List）是不可哈希的（unhashable），而元组（Tuple）是可哈希的（hashable）的原因。我们将深入探讨什么是哈希（Hash）以及列表和元组的区别，并为您提供示例来说明这些概念。

阅读更多：Python 教程

什么是哈希？

在计算机科学中，哈希（Hash）是将数据映射到固定大小的值的过程。这个固定大小的值称为哈希值（Hash value）或散列值（Hash code）。哈希函数（Hash function）负责执行这个映射过程。

哈希函数使用输入数据的特征来生成一个唯一的哈希值。这个哈希值用于快速查找、比较和检索数据。通过哈希函数，我们可以将数据存储在哈希表（Hash Table）或字典（Dictionary）中，从而可以在常量时间内访问特定数据。

特点：
1. 相同的输入始终产生相同的哈希值；
2. 哈希值的大小是固定的；
3. 不同的输入通常产生不同的哈希值；
4. 即使输入数据的大小变化微小，哈希值也会有很大的差异；
5. 哈希函数必须是高效执行的。

列表（List）的特点

在Python中，列表是有序、可变和可重复的对象。这意味着您可以通过索引访问列表的元素，并且可以在不更改其标识符的情况下修改和更新列表。列表可以包含不同的数据类型（如整数、浮点数、字符串等）。

例子：

my_list = [1, 2, 3, 'a', 'b', 'c']

然而，由于列表是可变的，也就意味着列表的哈希值是不稳定的。列表对象的哈希值是根据其内容计算的，而内容是可以更改的。这就是为什么列表是不可哈希的原因。换句话说，我们无法使用列表作为字典的键或集合的元素。

示例：

hash([1, 2, 3])  # 报错：TypeError: unhashable type: 'list'

元组（Tuple）的特点

与列表相反，元组是有序、不可变和可重复的对象。这意味着元组一旦创建，就无法对其进行更改。与列表不同，元组可以用作字典的键或集合的元素，因为元组的哈希值是稳定的。

元组的不可变性使得它们在不希望数据被意外更改时非常有用，也使得它们可以作为字典的键，从而提高了字典的快速查找性能。

例子：

my_tuple = (1, 2, 3, 'a', 'b', 'c')

示例：

hash((1, 2, 3))  # 有效输出

在上述示例中，我们可以成功地计算元组的哈希值，因为元组是不可变的。这也是为什么元组是可哈希的原因。

总结

Python中的列表（List）是不可哈希的，因为它们是可变的。这意味着列表的内容可以更改，从而导致列表的哈希值发生变化。而元组（Tuple）是不可变的，因此它们的哈希值是确定的。元组可以用作字典的键或集合的元素，而列表不能。

了解列表和元组的哈希性质对我们正确使用它们非常重要。根据需要选择使用列表或元组，可以提高代码的可读性和性能。

希望本文能帮助您深入理解Python中的列表不可哈希、元组可哈希的原因。

Python List unhashable, but tuple hashable?

In this article, we will explain why lists in Python are unhashable, whereas tuples are hashable. We will explore what hashing is, the differences between lists and tuples, and provide examples to illustrate these concepts.

What is Hashing?

In computer science, hashing is the process of mapping data to a fixed-size value. This fixed-size value is known as the hash value or hash code. A hash function is responsible for performing this mapping.

A hash function uses the characteristics of the input data to generate a unique hash value. This hash value is used for fast lookup, comparison, and retrieval of data. Through hash functions, we can store data in hash tables or dictionaries and access specific data in constant time.

Characteristics of hashing:
1. The same input always produces the same hash value.
2. The size of the hash value is fixed.
3. Different inputs usually produce different hash values.
4. Even a slight change in input data results in a significant difference in hash values.
5. Hash functions must be efficiently computable.

Characteristics of Lists

In Python, lists are ordered, mutable, and allow duplicates. This means you can access elements of a list through indexing and modify/update the list without changing its identifier. Lists can contain different data types such as integers, floats, strings, etc.

Example:

my_list = [1, 2, 3, 'a', 'b', 'c']

However, due to their mutability, the hash value of a list is unstable. The hash value of a list is computed based on its contents, which can be changed. This is why lists are unhashable. In other words, we cannot use lists as keys in dictionaries or elements in sets.

Example:

hash([1, 2, 3])  # TypeError: unhashable type: 'list' is raised

Characteristics of Tuples

In contrast to lists, tuples are ordered, immutable, and allow duplicates. Once created, tuples cannot be modified. Unlike lists, tuples can be used as keys in dictionaries or elements in sets because the hash value of a tuple is stable.

The immutability of tuples makes them useful when you don’t want the data to be accidentally changed and allows them to be used as keys in dictionaries, improving the lookup performance of dictionaries.

Example:

my_tuple = (1, 2, 3, 'a', 'b', 'c')

Example:

hash((1, 2, 3))  # Valid output is generated

In the above example, we can successfully compute the hash value of a tuple because tuples are immutable. This is why tuples are hashable.

Summary

Lists in Python are unhashable because they are mutable. This means that the contents of a list can be changed, resulting in a change in the hash value of the list. Tuples, on the other hand, are immutable, so their hash values remain stable. Tuples can be used as keys in dictionaries or elements in sets, while lists cannot.

Understanding the hashability of lists and tuples is important for using them correctly. Choosing between lists and tuples based on their intended uses can improve the readability and performance of your code.

We hope this article helps you understand why lists are unhashable and tuples are hashable in Python.## Python中的哈希（Hashing）概念

在计算机科学中，哈希（Hashing）是将数据映射到固定大小值的过程。这个固定大小的值称为哈希值（Hash value）或散列值（Hash code）。哈希函数（Hash function）是负责执行这个映射过程的算法。

哈希函数采用输入数据的特性来生成唯一的哈希值。这个哈希值用于快速的查找、比较和检索数据。通过哈希函数，我们可以将大量的数据存储在哈希表（Hash Table）或者字典（Dictionary）中，并能够在常量时间内访问特定的数据。

哈希函数具有以下特点：
1. 相同的输入始终产生相同的哈希值。
2. 哈希值的大小固定。
3. 不同的输入通常产生不同的哈希值。
4. 即使输入数据稍微变化，哈希值也会有很大的不同。
5. 哈希函数必须是高效执行的。

通过哈希函数，我们可以实现快速的数据存储和检索。哈希表（Hash Table）是一个常用的数据结构，它使用哈希函数来映射数据到内存地址，从而实现常量时间的查找操作。

列表（List）的特点

在Python中，列表是一种有序、可变和可以包含重复元素的数据结构。这意味着我们可以使用索引访问列表中的元素，并且可以通过修改同一个标识符来改变列表的内容。列表可以包含不同的数据类型，如整数、浮点数、字符串等。

例如：

my_list = [1, 2, 3, 'a', 'b', 'c']

然而，由于列表是可变的，它们的哈希值是不稳定的。列表对象的哈希值是根据其内容计算的，而列表的内容是可以被修改的。这就是为什么列表是不可哈希的原因。换句话说，我们不能使用列表作为字典的键或集合的元素。

示例：

hash([1, 2, 3])  # 报错：TypeError: unhashable type: 'list'

元组（Tuple）的特点

与列表相反，元组是一种有序、不可变且可以包含重复元素的数据结构。一旦创建，元组的内容无法被修改。与列表不同，我们可以使用元组作为字典的键或集合的元素，因为元组的哈希值是稳定的。

元组的不可变性使得它们在不希望数据被意外更改时非常有用，同时也可以作为字典的键，提高字典的快速查找性能。

例如：

my_tuple = (1, 2, 3, 'a', 'b', 'c')

示例：

hash((1, 2, 3))  # 有效输出

在上述示例中，我们可以成功计算元组的哈希值，因为元组是不可变的。这也是为什么元组是可哈希的原因。

总结

在Python中，列表是不可哈希的，因为它们是可变的。这意味着列表的内容可以被修改，从而导致列表的哈希值发生变化。而元组是不可变的，因此它们的哈希值保持不变。元组可以用作字典的键或集合的元素，而列表则不能。

了解列表和元组的哈希特性对于正确使用它们非常重要。根据需求选择使用列表或元组，可以提高代码的可读性和性能。

希望本文能帮助您深入理解为什么Python中的列表不可哈希，而元组可哈希。