id() 函数是干什么用的？

Question

我阅读了the Python 2 docs 并注意到id() 函数：

返回对象的“身份”。这是一个整数（或长整数），保证该对象在其生命周期内是唯一且恒定的。生命周期不重叠的两个对象可能具有相同的 id() 值。

CPython 实现细节：这是对象在内存中的地址。

所以，我尝试使用带有列表的id()：

>>> list = [1,2,3]
>>> id(list[0])
31186196
>>> id(list[1])
31907092 // increased by 896
>>> id(list[2])
31907080 // decreased by 12

函数返回的整数是多少？它是 C 中内存地址的同义词吗？如果是，为什么整数不对应数据类型的大小？

id()在实践中什么时候使用？

Answer 1

您的帖子提出了几个问题：

函数返回的数字是多少？

它是“一个整数（或长整数），保证该对象在其生命周期内是唯一且恒定的。”(Python Standard Library - Built-in Functions) 一个唯一的数字。没有更多，也没有更少。将其视为 Python 对象的社会保险号或员工 ID 号。

C中的内存地址是不是也一样？

从概念上讲，是的，因为它们都保证在其一生中都是独一无二的。而在 Python 的一种特定实现中，它实际上是对应的 C 对象的内存地址。

如果是，为什么数字不会立即增加数据类型的大小（我假设它是 int）？

因为列表不是数组，而列表元素是引用，而不是对象。

我们什么时候真正使用id( )函数？

几乎没有。您可以通过比较它们的 id 来测试两个引用是否相同，但 is operator 一直是推荐的方法。 id( ) 仅在调试情况下才真正有用。

Answer 2

这就是对象在内存中的位置的标识...

这个例子可能会帮助你更多地理解这个概念。

foo = 1
bar = foo
baz = bar
fii = 1

print id(foo)
print id(bar)
print id(baz)
print id(fii)

> 1532352
> 1532352
> 1532352
> 1532352

这些都指向内存中的相同位置，这就是它们的值相同的原因。在示例中，1 仅存储一次，其他任何指向 1 的内容都将引用该内存位置。

Answer 3

id() 确实返回了被引用对象的地址（在 CPython 中），但您的困惑来自 Python 列表与 C 数组非常不同的事实。在 python 列表中，每个元素都是一个 reference。所以你所做的和这段 C 代码更相似：

int *arr[3];
arr[0] = malloc(sizeof(int));
*arr[0] = 1;
arr[1] = malloc(sizeof(int));
*arr[1] = 2;
arr[2] = malloc(sizeof(int));
*arr[2] = 3;
printf("%p %p %p", arr[0], arr[1], arr[2]);

换句话说，您打印的是参考中的地址，而不是相对于您的列表存储位置的地址。

在我的例子中，我发现 id() 函数可以方便地创建不透明的句柄，以便在从 C 调用 python 时返回到 C 代码。这样做，您可以轻松地使用字典从句柄中查找对象并且保证是独一无二的。

Answer 4

Rob 的回答（上面投票最多）是正确的。我想补充一点，在某些情况下，使用 ID 很有用，因为它允许比较对象并找出哪些对象引用了您的对象。

后者通常可以帮助您调试奇怪的错误，例如将可变对象作为参数传递给类并分配给类中的本地变量。改变这些对象将改变一个类中的变量。这表现为奇怪的行为，即多个事物同时发生变化。

最近我在使用 Python/Tkinter 应用程序时遇到了这个问题，其中在一个文本输入字段中编辑文本会在我输入时更改另一个文本输入字段中的文本:)

这是一个示例，说明如何使用函数 id() 来跟踪这些引用的位置。无论如何，这并不是涵盖所有可能情况的解决方案，但您明白了。再次在后台使用 ID，用户看不到它们：

class democlass:
    classvar = 24

    def __init__(self, var):
        self.instancevar1 = var
        self.instancevar2 = 42

    def whoreferencesmylocalvars(self, fromwhere):
        return {__l__: {__g__
                    for __g__ in fromwhere
                        if not callable(__g__) and id(eval(__g__)) == id(getattr(self,__l__))
                    }
                for __l__ in dir(self)
                    if not callable(getattr(self, __l__)) and __l__[-1] != '_'
                }

    def whoreferencesthisclassinstance(self, fromwhere):
        return {__g__
                    for __g__ in fromwhere
                        if not callable(__g__) and id(eval(__g__)) == id(self)
                }

a = [1,2,3,4]
b = a
c = b
democlassinstance = democlass(a)
d = democlassinstance
e = d
f = democlassinstance.classvar
g = democlassinstance.instancevar2

print( 'My class instance is of', type(democlassinstance), 'type.')
print( 'My instance vars are referenced by:', democlassinstance.whoreferencesmylocalvars(globals()) )
print( 'My class instance is referenced by:', democlassinstance.whoreferencesthisclassinstance(globals()) )

输出：

My class instance is of <class '__main__.democlass'> type.
My instance vars are referenced by: {'instancevar2': {'g'}, 'classvar': {'f'}, 'instancevar1': {'a', 'c', 'b'}}
My class instance is referenced by: {'e', 'd', 'democlassinstance'}

变量名中的下划线用于防止名称冲突。函数使用“fromwhere”参数，以便您可以让他们知道从哪里开始搜索引用。此参数由一个列出给定名称空间中所有名称的函数填充。 Globals() 就是这样一个函数。

Answer 5

我从 python 开始，在使用交互式 shell 时使用 id 来查看我的变量是否分配给相同的东西，或者它们是否看起来相同。

每个值都是一个id，它是一个唯一的数字，与它在计算机内存中的存储位置有关。

Answer 6

如果您使用的是 python 3.4.1，那么您的问题会得到不同的答案。

list = [1,2,3]
id(list[0])
id(list[1])
id(list[2])

返回：

1705950792   
1705950808  # increased by 16   
1705950824  # increased by 16

整数 -5 到 256 有一个常量 id，并且在多次找到它时，它的 id 不会改变，这与它之前或之后的所有其他数字不同，每次找到它时都有不同的 id。 从-5 到256 的数字具有递增顺序的ID，并且相差16。

id() 函数返回的数字是存储在内存中的每个项目的唯一 ID，它与 C 中的内存位置类似。

Answer 7

is 运算符使用它来检查两个对象是否相同（而不是相等）。从id() 返回的实际值几乎从未用于任何事情，因为它没有真正的意义，而且它依赖于平台。

Answer 8

答案几乎是永远不会。 ID 主要在 Python 内部使用。

一般的 Python 程序员可能永远不需要在他们的代码中使用 id()。

Answer 9

正如文档所说，它是内存中对象的地址。但是，它附加了元数据，需要对象的属性和内存中的位置来存储元数据。因此，当您创建名为 list 的变量时，您还会为列表及其元素创建元数据。

因此，除非您是该语言的绝对大师，否则您无法根据前一个元素确定列表中下一个元素的 id，因为您不知道该语言与元素一起分配什么。

Answer 10

我想在日志记录中使用 id() 的值。
它很便宜，而且很短。
在我的情况下，我使用龙卷风，id() 希望有一个锚点，通过网络套接字将分散和混合在文件中的消息分组。

Answer 11

我有点晚了，我会谈谈Python3。要了解 id() 是什么以及它（和 Python）是如何工作的，请考虑下一个示例：

>>> x=1000
>>> y=1000
>>> id(x)==id(y)
False
>>> id(x)
4312240944
>>> id(y)
4312240912
>>> id(1000)
4312241104
>>> x=1000
>>> id(x)
4312241104
>>> y=1000
>>> id(y)
4312241200

您需要将右侧的所有内容都视为对象。每次进行分配时-您都会创建新对象，这意味着新的ID。在中间，您可以看到仅为函数创建的“野生”对象 - id(1000)。所以，它的生命周期只针对那行代码。如果您检查下一行 - 您会看到当我们创建新变量 x 时，它具有与该 Wild 对象相同的 id。它几乎就像内存地址一样工作。

Answer 12

在 python 3 中，id 被分配给一个值而不是一个变量。这意味着如果您创建如下两个函数，则所有三个 id 都是相同的。

>>> def xyz():
...     q=123
...     print(id(q))
...
>>> def iop():
...     w=123
...     print(id(w))
>>> xyz()
1650376736
>>> iop()
1650376736
>>> id(123)
1650376736

Answer 13

小心（关于下面的答案）...这是正确的，因为 123 介于 -5 和 256 之间...

In [111]: q = 257                                                         

In [112]: id(q)                                                            
Out[112]: 140020248465168

In [113]: w = 257                                                         

In [114]: id(w)                                                           
Out[114]: 140020274622544

In [115]: id(257)                                                         
Out[115]: 140020274622768