blocks|key|190973|text|这是内存中对象的位置的标识……|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|190974|这个例子可能会帮助你更好地理解这个概念。|190975|foo+=+1
bar+=+foo
baz+=+bar
fii+=+1

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

>+1532352
>+1532352
>+1532352
>+1532352|code-block|syntax|javascript|190976|这些都指向内存中的相同位置，这就是为什么它们的值是相同的。在本例中，1只存储一次，任何其他指向1的内容都将引用该内存位置。|CODE|190977|entityMap^0|8|2|0|0|0|Y|1|1B|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|V|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|W|8|@$9|X|A|Y|B|O]|$9|Z|A|10|B|O]]|D|@]|E|$]]|$1|P|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|Q|$]]

That's the identity of the location of the object in memory...

This example might help you understand the concept a little more.

<pre><code>foo = 1
bar = foo
baz = bar
fii = 1

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

&gt; 1532352
&gt; 1532352
&gt; 1532352
&gt; 1532352
</code></pre>

These all point to the same location in memory, which is why their values are the same. In the example, <code>1</code> is only stored once, and anything else pointing to <code>1</code> will reference that memory location.

blocks|key|192786|text|答案是几乎永远不会。ID主要在Python内部使用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|192787|一般的Python程序员可能永远不需要在代码中使用id()。|offset|length|style|CODE|192788|entityMap^0|0|P|4|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

The answer is pretty much never. IDs are mainly used internally to Python.

The average Python programmer will probably never need to use <code>id()</code> in their code.

blocks|key|2816571|text|is操作符使用它来检查两个对象是否相同(而不是相等)。从id()返回的实际值几乎从来没有用过任何东西，因为它没有真正的意义，而且它依赖于平台。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2816572|entityMap^0|0|2|S|4|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

The <code>is</code> operator uses it to check whether two objects are identical (as opposed to equal). The actual value that is returned from <code>id()</code> is pretty much never used for anything because it doesn't really have a meaning, and it's platform-dependent.

blocks|key|3029115|text|id()确实返回被引用对象的地址(在CPython中)，但是您的困惑来自于python列表与C数组有很大的不同。在python列表中，每个元素都是一个引用。因此，您所做的与下面的C代码更相似：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3029116|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("%25p+%25p+%25p",+arr[0],+arr[1],+arr[2]);|code-block|syntax|javascript|3029117|换句话说，您打印的是引用中的地址，而不是相对于列表存储位置的地址。|3029118|在我的例子中，我发现id()函数在创建不透明的句柄以便在从C调用python时返回到C代码中很方便，这样，您就可以很容易地使用字典从它的句柄中查找对象，并且保证它是唯一的。|3029119|entityMap^0|0|4|0|0|0|A|4|W|6|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|P|$]]

<code>id()</code> does return the address of the object being referenced (in CPython), but your confusion comes from the fact that python lists are very different from C arrays. In a python list, every element is a reference. So what you are doing is much more similar to this C code:

<pre><code>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]);
</code></pre>

In other words, you are printing the address from the reference and not an address relative to where your list is stored.

In my case, I have found the <code>id()</code> function handy for creating opaque handles to return to C code when calling <code>python</code> from C. Doing that, you can easily use a dictionary to look up the object from its handle and it's guaranteed to be unique.

blocks|key|3029143|text|你的帖子问了几个问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3029144|3029145|函数返回的数字是多少？|blockquote|3029146|3029147|3029148|它是“一个整数(或长整型)，保证该对象在其生命周期内是唯一且恒定的。”(Python+Standard+Library+-+Built-in+Functions)一个唯一的数字。没有更多，也没有更少。可以将其视为Python对象的社会保险号或雇员id号。|offset|length|3029149|3029150|是否与C中的内存地址相同？|3029151|3029152|3029153|从概念上讲，是的，因为它们都被保证在其有生之年在其宇宙中是唯一的。在Python的一个特定实现中，它实际上是相应C对象的内存地址。|3029154|3029155|如果是，为什么不立即增加数据类型的大小(我假设它是整型的)？|3029156|3029157|3029158|因为列表不是数组，而列表元素是引用，而不是对象。|3029159|我们什么时候才能真正使用id(+)函数？|style|CODE|3029160|3029161|几乎从来没有。您可以通过比较两个引用的ids来测试它们是否相同，但is+operator一直是推荐的方法。id(+)只有在调试情况下才真正有用。|3029162|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/2/library/functions.html#id|1|https://docs.python.org/2/reference/expressions.html#is^0|0|0|0|0|0|Z|1A|0|0|0|0|0|0|0|0|0|0|0|0|C|5|0|0|X|2|1H|5|X|B|1|0^^$0|@$1|2|3|4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1I|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1L|8|@]|9|@$J|1M|K|1N|1|1O]]|A|$]]|$1|L|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]|$1|M|3|N|5|E|7|1Q|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1R|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1T|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1U|8|@]|9|@]|A|$]]|$1|T|3|U|5|E|7|1V|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1W|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1X|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|Z|3|10|5|6|7|1Z|8|@$J|20|K|21|11|12]]|9|@]|A|$]]|$1|13|3|-4|5|6|7|22|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|23|8|@$J|24|K|25|11|12]|$J|26|K|27|11|12]]|9|@$J|28|K|29|1|2A]]|A|$]]|$1|16|3|-4|5|6|7|2B|8|@]|9|@]|A|$]]]|17|$18|$5|19|1A|1B|A|$1C|1D]]|1E|$5|19|1A|1B|A|$1C|1F]]]]

Your post asks several questions:
<blockquote>
What is the number returned from the function?
</blockquote>
It is &quot;an integer (or long integer) which is guaranteed to be unique and constant for this object during its lifetime.&quot; <a href="https://docs.python.org/2/library/functions.html#id" rel="nofollow noreferrer">(Python Standard Library - Built-in Functions)</a> A unique number. Nothing more, and nothing less. Think of it as a social-security number or employee id number for Python objects.
<blockquote>
Is it the same with memory addresses in C?
</blockquote>
Conceptually, yes, in that they are both guaranteed to be unique in their universe during their lifetime. And in one particular implementation of Python, it actually is the memory address of the corresponding C object.
<blockquote>
If yes, why doesn't the number increase instantly by the size of the data type (I assume that it would be int)?
</blockquote>
Because a list is not an array, and a list element is a reference, not an object.
<blockquote>
When do we really use <code>id( )</code> function?
</blockquote>
Hardly ever. You can test if two references are the same by comparing their ids, but the <a href="https://docs.python.org/2/reference/expressions.html#is" rel="nofollow noreferrer"><code>is</code> operator</a> has always been the recommended way of doing that. <code>id( )</code> is only really useful in debugging situations.

blocks|key|2816608|text|它是对象在内存中的地址，正如文档所说的那样。但是，它具有附加的元数据，需要对象的属性和内存中的位置来存储元数据。因此，当您创建名为list的变量时，还会为list及其元素创建元数据。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2816609|因此，除非您是该语言的绝对专家，否则您无法根据前一个元素确定列表中下一个元素的id，因为您不知道该语言随元素一起分配的内容。|2816610|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

It is the address of the object in memory, exactly as the doc says. However, it has metadata attached to it, properties of the object and location in the memory is needed to store the metadata. So, when you create your variable called list, you also create metadata for the list and its elements.

So, unless you an absolute guru in the language you can't determine the id of the next element of your list based on the previous element, because you don't know what the language allocates along with the elements.

blocks|key|3029179|text|我从python开始，当我使用交互式shell来查看我的变量是否被赋值给相同的东西，或者它们看起来是一样的时候，我使用id。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3029180|每个值都是一个id，这是一个与它在计算机内存中的存储位置相关的唯一数字。|3029181|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I am starting out with python and I use id when I use the interactive shell to see whether my variables are assigned to the same thing or if they just look the same.

Every value is an id, which is a unique number related to where it is stored in the memory of the computer.

blocks|key|192861|text|如果你使用的是python+3.4.1，那么你的问题会得到一个不同的答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|192862|list+=+[1,2,3]
id(list[0])
id(list[1])
id(list[2])|code-block|syntax|javascript|192863|返回：|192864|1705950792+++
1705950808++#+increased+by+16+++
1705950824++#+increased+by+16|192865|整数-5到256都有一个恒定的id，并且在多次找到它时，它的id不会改变，这与它之前或之后的所有其他数字不同，每次你找到它时都会有不同的id。从-5到256的数字的id按升序排列，不同的数字按16不同。|offset|length|style|CODE|192866|id()函数返回的数字是存储在内存中的每个项的唯一id，与C中的内存位置类似。|192867|entityMap^0|0|0|0|0|2|2|5|3|20|2|23|3|2O|2|0|0|4|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@$M|Z|N|10|O|P]|$M|11|N|12|O|P]|$M|13|N|14|O|P]|$M|15|N|16|O|P]|$M|17|N|18|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|19|8|@$M|1A|N|1B|O|P]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|T|$]]

If you're using python 3.4.1 then you get a different answer to your question.

<pre><code>list = [1,2,3]
id(list[0])
id(list[1])
id(list[2])
</code></pre>

returns:

<pre><code>1705950792 
1705950808 # increased by 16 
1705950824 # increased by 16
</code></pre>

The integers <code>-5</code> to <code>256</code> have a constant id, and on finding it multiple times its id does not change, unlike all other numbers before or after it that have different id's every time you find it.
The numbers from <code>-5</code> to <code>256</code> have id's in increasing order and differ by <code>16</code>.

The number returned by <code>id()</code> function is a unique id given to each item stored in memory and it is analogy wise the same as the memory location in C.

blocks|key|193134|text|Rob的答案(上面大多数人投票)是正确的。我想补充的是，在某些情况下，使用in是有用的，因为它允许比较对象并找出哪些对象引用了您的对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|193135|后者通常可以帮助你调试奇怪的bug，比如可变对象被作为参数传递给类，并被分配给类中的本地变量。改变这些对象将改变类中的变量。这表现在多个事物同时发生变化的奇怪行为中。|193136|最近，我在一个Python/Tkinter应用程序中遇到了这个问题，在该应用程序中，编辑一个文本输入字段中的文本会在我键入时更改另一个文本输入字段中的文本:)|193137|下面是一个示例，说明如何使用函数id()来跟踪这些引用的位置。无论如何，这并不是一个涵盖所有可能情况的解决方案，但您已经明白了。同样，ID在后台使用，用户看不到它们：|193138|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())+)|code-block|syntax|javascript|193139|输出：|193140|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'}|193141|变量名中的下划线用于防止名称冲突。函数使用"fromwhere“参数，这样您就可以让它们知道从哪里开始搜索引用。此参数由一个函数填充，该函数列出给定命名空间中的所有名称。Globals()就是这样一个函数。|193142|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|X|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

Rob's answer (most voted above) is correct. I would like to add that in some situations using IDs is useful as it allows for comparison of objects and finding which objects refer to your objects.

The later usually helps you for example to debug strange bugs where mutable objects are passed as parameter to say classes and are assigned to local vars in a class. Mutating those objects will mutate vars in a class. This manifests itself in strange behavior where multiple things change at the same time.

Recently I had this problem with a Python/Tkinter app where editing text in one text entry field changed the text in another as I typed :)

Here is an example on how you might use function id() to trace where those references are. By all means this is not a solution covering all possible cases, but you get the idea. Again IDs are used in the background and user does not see them:

<pre><code>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()) )
</code></pre>

OUTPUT:

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

Underscores in variable names are used to prevent name colisions. Functions use "fromwhere" argument so that you can let them know where to start searching for references. This argument is filled by a function that lists all names in a given namespace. Globals() is one such function.

blocks|key|193146|text|我有一个想法是在日志记录中使用id()的值。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|193147|它很便宜，而且很短。|193148|在我的例子中，我使用tornado，而id()希望有一个锚点来将分散和混合在文件中的消息按web套接字进行分组。|193149|entityMap^0|F|4|0|0|J|4|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|K|$]]

I have an idea to use value of <code>id()</code> in logging. 
It's cheap to get and it's quite short. 
In my case I use tornado and <code>id()</code> would like to have an anchor to group messages scattered and mixed over file by web socket.

blocks|key|2816732|text|从python+3开始，id被赋值给一个值，而不是一个变量。这意味着如果你像下面这样创建两个函数，那么这三个id都是相同的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2816733|>>>+def+xyz():
...+++++q=123
...+++++print(id(q))
...
>>>+def+iop():
...+++++w=123
...+++++print(id(w))
>>>+xyz()
1650376736
>>>+iop()
1650376736
>>>+id(123)
1650376736|code-block|syntax|javascript|2816734|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

As of in python 3 id is assigned to a value not a variable. This means that if you create two functions as below, all the three id's are the same.

<pre><code>&gt;&gt;&gt; def xyz():
... q=123
... print(id(q))
...
&gt;&gt;&gt; def iop():
... w=123
... print(id(w))
&gt;&gt;&gt; xyz()
1650376736
&gt;&gt;&gt; iop()
1650376736
&gt;&gt;&gt; id(123)
1650376736
</code></pre>

blocks|key|2816796|text|我来晚了一点，我会谈谈Python3。要理解id()是什么以及它(和Python)是如何工作的，请考虑下面的示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2816797|>>>+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|code-block|syntax|javascript|2816798|你需要把右边的所有东西都看作是对象。每次你赋值的时候，你创建了新的对象，这意味着新的id。在中间你可以看到一个“野性”对象，它只为function+-+id(1000)创建。因此，它的生命周期仅适用于该行代码。如果你检查下一行，你会看到，当我们创建新的变量x时，它和那个野生对象具有相同的id。它的工作原理很像内存地址。|2816799|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I'm a little bit late and i will talk about Python3. To understand what id() is and how it (and Python) works, consider next example:

<pre><code>&gt;&gt;&gt; x=1000
&gt;&gt;&gt; y=1000
&gt;&gt;&gt; id(x)==id(y)
False
&gt;&gt;&gt; id(x)
4312240944
&gt;&gt;&gt; id(y)
4312240912
&gt;&gt;&gt; id(1000)
4312241104
&gt;&gt;&gt; x=1000
&gt;&gt;&gt; id(x)
4312241104
&gt;&gt;&gt; y=1000
&gt;&gt;&gt; id(y)
4312241200
</code></pre>

You need to think about everything on the right side as objects. Every time you make assignment - you create new object and that means new id. In the middle you can see a "wild" object which is created only for function - id(1000). So, it's lifetime is only for that line of code. If you check the next line - you see that when we create new variable x, it has the same id as that wild object. Pretty much it works like memory address.

blocks|key|2816812|text|要小心(关于下面的答案)……这是正确的，因为123介于-5和256之间……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2816813|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|code-block|syntax|javascript|2816814|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Be carefull (concerning the answer just below)...That's only true because 123 is between -5 and 256...

<pre><code>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
</code></pre>

I read <a href="http://docs.python.org/2/library/functions.html#id" rel="noreferrer">the Python 2 docs</a> and noticed the <code>id()</code> function:

<blockquote>
 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.
</blockquote>

So, I experimented by using <code>id()</code> with a list:

<pre><code>&gt;&gt;&gt; list = [1,2,3]
&gt;&gt;&gt; id(list[0])
31186196
&gt;&gt;&gt; id(list[1])
31907092 // increased by 896
&gt;&gt;&gt; id(list[2])
31907080 // decreased by 12
</code></pre>

What is the integer returned from the function? Is it synonymous to memory addresses in C? If so, why doesn't the integer correspond to the size of the data type?

When is <code>id()</code> used in practice?

What is the id( ) function used for?

我阅读了并注意到了id()函数：返回对象的标识。这是一个整数(或长整型)，它保证在此对象的生命周期内是唯一且恒定的。生命周期不重叠的两个对象可以具有相同的id()值。CPython实现细节:这是对象在内存中的地址。因此，我通过使用带有列表的id()进行了试验：>>> list = [1,2,3]>>> id(list[...

问id( )函数用来做什么？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问id( )函数用来做什么？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问id( )函数用来做什么？
EN