我阅读了Python 2文档，并注意到了id()函数：
Return the"identity" of an object. This is an integer (or long integer) which is guaranteed to be unique and constant for this object during its lifetime. Two objects with non-overlapping lifetimes may have the same id() value.
CPython implementation detail: This is the address of the object in memory.
因此，我通过在列表中使用id()进行了实验：
1
2
3
4
5
6
7>>> list = [1,2,3]
>>> id(list[0])
31186196
>>> id(list[1])
31907092 // increased by 896
>>> id(list[2])
31907080 // decreased by 12
函数返回的整数是多少？ 它与C中的内存地址同义吗？ 如果是这样，为什么整数不对应于数据类型的大小？
在实践中何时使用id()？
仅仅因为您以脚本语言在数据结构中存储(例如)一个32位int并不意味着您将消耗32位以上的内存。 总是将元数据附加到您存储的任何数据中。 类型，大小，长度，等等等等。
cpython从堆中分配，而堆在分配和释放对象时会变得混乱。
Python数字不是简单的数据。 它们是在内部使用long开头的对象，然后在值太大时自动提升为BigNumber样式的表示形式。
可能有用：彻底改善Python：了解Python执行模型
您的帖子问了几个问题：
What is the number returned from the function?
它是"一个整数(或长整数)，在此对象的生存期内，保证该对象是唯一且恒定的"。 (Python标准库-内置函数)一个唯一编号。仅此而已。可以将其视为Python对象的社会保险号或员工ID号。
Is it the same with memory addresses in C?
从概念上讲，是的，因为它们在生命周期中都被保证在宇宙中是独一无二的。在Python的一种特定实现中，它实际上是相应C对象的内存地址。
If yes, why doesn't the number increase instantly by the size of the data type (I assume that it would be int)?
因为列表不是数组，列表元素是引用，而不是对象。
When do we really use id( ) function?
几乎没有。在is运算符中使用id()(或其等效项)。
我们通常将id()用于演示目的，例如此处stackoverflow.com/questions/17246693/
那就是对象在内存中的位置的标识...
这个例子可以帮助您更多地了解这个概念。
1
2
3
4
5
6
7
8
9
10
11
12
13
14foo = 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的内容将引用该内存位置。
但是，如果您使用的数字超出-5到256的范围，则不会获得相同的id作为fii变量。
多数民众赞成在非常有趣。您可以分享更多吗？
我认为这个答案具有误导性，因为对于大多数数字而言，这并不成立。请参阅" is"运算符对整数的行为异常。
id()确实返回(在CPython中)被引用对象的地址，但是您的困惑来自于事实，即python列表与C数组有很大的不同。在python列表中，每个元素都是一个引用。因此，您正在执行的操作与此C代码更加相似：
1
2
3
4
5
6
7
8int *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代码。这样做，您可以轻松地使用字典从其句柄中查找对象，并且可以保证独一无二。
如果您使用的是python 3.4.1，那么您会得到一个不同的答案。
1
2
3
4list = [1,2,3]
id(list[0])
id(list[1])
id(list[2])
返回：
1
2
31705950792
1705950808 # increased by 16
1705950824 # increased by 16
整数-5至256具有恒定的ID，并且多次查找时其ID不会改变，这与之前或之后的所有其他均具有不同ID的数字不同。
从-5到256的数字具有递增的ID，并且相差16。
id()函数返回的数字是分配给内存中存储的每个项目的唯一ID，以此类推，它与C中的内存位置相同。
我从python开始，在使用交互式外壳程序查看变量是否分配给同一事物或它们看起来是否相同时，我使用id。
每个值都是一个id，它是一个唯一的数字，与它在计算机内存中的存储位置有关。
罗伯的答案(上面投票最多)是正确的。我想补充一点，在某些情况下，使用ID很有用，因为它允许比较对象并查找哪些对象引用了您的对象。
后者通常可以帮助您调试奇怪的错误，例如，将可变对象作为参数传递给类，然后将其分配给类中的本地var。突变那些对象将突变一个类中的变量。这表现为多种行为同时改变的奇怪行为。
最近，我在Python / Tkinter应用程序中遇到了这个问题，该应用程序在一个文本输入字段中编辑文本会在我键入时更改另一个文本中的文本:)
这是一个示例，说明如何使用函数id()跟踪这些引用的位置。无论如何，这不是涵盖所有可能情况的解决方案，但是您明白了。再次在后台使用ID，用户看不到它们：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34class 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()) )
输出：
1
2
3My class instance is of 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()就是这样一种功能。
很好的解释！
确切地说，它是对象在内存中的地址。但是，它具有附加的元数据，需要对象的属性和在存储器中的位置来存储元数据。因此，当您创建名为list的变量时，还将为该列表及其元素创建元数据。
因此，除非您是该语言的绝对专家，否则您将无法基于前一个元素确定列表中下一个元素的ID，因为您不知道语言与元素一起分配了什么。
实际上，成为Python专家不会对预测任何对象id()有用。您需要非常熟悉所讨论的内存管理器(复数！)，知道它们在某个时间点的确切状态，并知道对象分配的确切顺序。换句话说：不会发生。
如果您绝对了解Python的所有细微差别，包括可能的内存管理器，那么您就是绝对的Python专家。
了解Python和了解特定的实现(例如CPython)是完全不同的两件事。甚至了解内在的CPython也无济于事，因为有多个内存管理器CPython会调用CPython的那部分而不是各自操作系统的一部分。正如Ive之前所说的，即使知道所有这些非Python的东西也不会帮助您，因为实际地址取决于内存管理器的运行时状态，有时甚至是随机的。
更不用说，这将毫无用处，因为依靠这样的东西将依赖于实现细节，因此是脆弱和僵化的。
答案几乎永远不会。 ID主要在Python内部使用。
一般的Python程序员可能永远不需要在代码中使用id()。
也许我不是一个普通的人，但是我经常使用id()。我想到了两个用例：一个(手动的，临时的)标识字典和一个对于标识重要但默认的repr不适用的对象的自定义repr()。
@delnan我不会争论那些是常见的情况。
我有一个想法在日志记录中使用id()的值。
它很便宜，而且很短。
就我而言，我使用龙卷风，id()希望有一个锚点来对通过Web套接字分散并混合在文件中的消息进行分组。
is运算符使用它来检查两个对象是否相同(相对于相等)。从id()返回的实际值几乎没有用于任何东西，因为它实际上没有含义，并且与平台有关。
从python 3开始，id被分配给一个值而不是一个变量。这意味着，如果您按以下方式创建两个函数，则三个ID都相同。
1
2
3
4
5
6
7
8
9
10
11
12
13>>> def xyz():
... q=123
... print(id(q))
...
>>> def iop():
... w=123
... print(id(w))
>>> xyz()
1650376736
>>> iop()
1650376736
>>> id(123)
1650376736
2413
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
