112

我阅读了 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()在实践中使用？

4

13 回答 13

165

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

函数返回的数字是多少？

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

与C中的内存地址相同吗？

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

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

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

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

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

于 2013-03-27T19:05:37.130 回答
55

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

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

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

于 2013-03-27T18:59:55.300 回答
11

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

于 2015-03-16T21:11:41.710 回答
10

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()函数可以方便地创建不透明句柄以在从 C 调用时返回到 C 代码python。这样做，您可以轻松地使用字典从其句柄中查找对象，并保证它是唯一的。

于 2013-03-27T19:04:33.313 回答
5

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

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

于 2013-03-27T19:16:29.020 回答
5

如果您使用的是 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

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

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

于 2014-09-20T02:31:11.797 回答
3

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

于 2013-03-27T19:04:22.853 回答
2

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

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

于 2013-03-27T19:01:48.157 回答
2

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

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

于 2013-03-27T19:06:00.250 回答
2

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

于 2016-04-14T19:32:34.057 回答
1

我有点晚了，我会谈谈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。它几乎就像内存地址一样工作。

于 2019-11-14T18:50:20.493 回答
0

在 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
于 2019-07-09T13:43:54.933 回答
0

小心（关于下面的答案）......这是正确的，因为 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
于 2019-11-23T18:59:12.767 回答