Python 中的 `id()` 函数用于什么？

问题描述：

我阅读了Python 2 文档并注意到了该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()实际什么时候用？

解决方案 1：

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

函数返回的数字是多少？

它是“一个整数（或长整数），保证在该对象的生命周期内唯一且恒定。 ” （Python 标准库 - 内置函数）一个唯一的数字。不多也不少。可以将其视为 Python 对象的社会保险号或员工 ID 号。

和C语言中的内存地址一样吗？

从概念上讲，是的，因为它们都保证在它们的生命周期内是独一无二的。并且在 Python 的一个特定实现中，它实际上是相应 C 对象的内存地址。

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

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

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

几乎从不。您可以通过比较它们的 ID 来测试两个引用是否相同，但运算is符始终是推荐的执行方式。id( )仅在调试情况下才真正有用。

解决方案 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将引用该内存位置。

解决方案 3：

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() 就是这样一个函数。

解决方案 4：

id()确实返回了被引用对象的地址（在 CPython 中），但你的困惑来自于 Python 列表与 C 数组非常不同这一事实。在 Python 列表中，每个元素都是一个引用。所以你所做的更类似于这个 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()函数非常方便，可用于在python从 C 调用时创建不透明句柄以返回到 C 代码。这样做，您可以轻松地使用字典从其句柄中查找对象，并且保证它是唯一的。

解决方案 5：

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

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

解决方案 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 中的内存位置类似。

解决方案 7：

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

解决方案 8：

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

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

解决方案 9：

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

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

解决方案 10：

id()我有一个想法，可以在日志中使用 value 。

它获取起来很便宜，而且很短。

在我的例子中，我使用 tornado，并id()希望有一个锚点，通过 Web 套接字将分散和混合在文件中的消息分组。

解决方案 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 时，它具有与该野生对象相同的 id。它几乎像内存地址一样工作。

解决方案 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

解决方案 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