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()在实践中何时使用？

您的帖子问了几个问题：

该函数返回的数字是多少？

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

与C中的内存地址是否相同？

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

如果是，为什么数字不立即随数据类型的大小增加（我认为是整数）？

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

我们什么时候真正使用id( )功能？

几乎没有。id()（或其等效项）在is运算符中使用。

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

这个例子可以帮助您更多地了解这个概念。

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

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

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

后者通常可以帮助您调试奇怪的错误，例如，将可变对象作为参数传递给类，然后将其分配给类中的本地var。突变那些对象将突变一个类中的变量。这表现为多种行为同时改变的奇怪行为。

最近，我在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（）就是这样一种功能。

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

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

如果您使用的是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到256ID的数字按升序排列，且相差16。

id()函数返回的数字是赋予存储在内存中的每个项目的唯一ID，从逻辑上讲，它与C中的存储位置相同。

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

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

的is操作者使用它来检查两个对象是否是相同的（而不是相等）。从中返回的实际值id()几乎没有用到任何东西，因为它没有真正的意义，并且与平台有关。

确切地说，它是对象在内存中的地址。但是，它具有附加的元数据，需要对象的属性和在存储器中的位置来存储元数据。因此，当您创建名为list的变量时，还将为该列表及其元素创建元数据。

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

我有一个id()在日志记录中使用值的想法。
它很便宜，而且很短。
以我为例，我使用龙卷风，并且id()希望有一个锚点来对通过Web套接字分散并混合在文件中的消息进行分组。

从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

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

注意（关于下面的答案）...这是真的，因为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