为什么以下在Python中出现意外行为？

>>> a = 256
>>> b = 256
>>> a is b
True           # This is an expected result
>>> a = 257
>>> b = 257
>>> a is b
False          # What happened here? Why is this False?
>>> 257 is 257
True           # Yet the literal numbers compare properly

我使用的是Python 2.5.2.尝试一些不同版本的Python,似乎Python 2.3.3显示了99到100之间的上述行为.

基于以上所述,我可以假设Python在内部实现,使得"小"整数以不同于大整数的方式存储,is运算符可以区分.为什么泄漏抽象？当我不知道它们是否是数字时,比较两个任意对象以查看它们是否相同的更好的方法是什么？

关于id类型对象的某些东西str(在python 2.7中)让我很困惑.该str类型是不变的,所以我希望,一旦它被创建,它将始终具有相同的id.我相信我不会这么说自己,所以我会发布一个输入和输出序列的例子.

>>> id('so')
140614155123888
>>> id('so')
140614155123848
>>> id('so')
140614155123808

所以同时,它一直在变化.但是,在指向该字符串的变量之后,事情会发生变化:

>>> so = 'so'
>>> id('so')
140614155123728
>>> so = 'so'
>>> id(so)
140614155123728
>>> not_so = 'so'
>>> id(not_so)
140614155123728

因此,一旦变量保存该值,它就会冻结id.的确,在del so和之后del not_so,id('so')开始的输出再次改变.

这是不相同的行为与(小)整数.

我知道不变性和拥有相同之间没有真正的联系id; 仍然,我试图弄清楚这种行为的来源.我相信那些熟悉python内部的人会比我更少惊讶,所以我试图达到同样的目的......

更新

尝试使用不同的字符串会产生不同的结果......

>>> id('hello')
139978087896384
>>> id('hello')
139978087896384
>>> id('hello')
139978087896384

现在它是平等的......

我已经尝试了一些关于绑定和未绑定方法的代码.当我们调用它们时,我认为它们都会返回对象.但是当我id()用来获取一些信息时,它会返回一些我不理解的东西.

IDE:Eclipse

插件:pydev

Class C(object):
    def foo(self):
        pass

cobj = C()

print id(C.foo)    #1
print id(cobj.foo) #2

a = C.foo
b = cobj.foo

print id(a)        #3
print id(b)        #4

输出是......

5671672

5671672

5671672

5669368

为什么#1和#2返回相同的ID？它们不是不同的对象吗？如果我们分配C.foo和conj.foo两个变量,#3和#4返回不同的id.

我认为#3和#4表明它们不是同一个对象,但#1和#2 ......

绑定方法的id和未绑定方法有什么区别？

在Java中,显式声明的字符串由JVM实现,因此相同String的后续声明会产生两个指向同一String实例的指针,而不是两个单独的(但相同的)字符串.

例如:

public String baz() {
    String a = "astring";
    return a;
}

public String bar() {
    String b = "astring"
    return b;
}

public void main() {
    String a = baz()
    String b = bar()
    assert(a == b) // passes
}

我的问题是,CPython(或任何其他Python运行时)对字符串做同样的事情吗？例如,如果我有一些课程:

class example():
    def __init__():
        self._inst = 'instance' 

并创建此类的10个实例,它们中的每一个都有一个实例变量引用内存中的相同字符串,或者我最终会得到10个单独的字符串？

两个python对象具有相同的ID，但“ is”操作返回false，如下所示：

a = np.arange(12).reshape(2, -1)
c = a.reshape(12, 1)
print("id(c.data)", id(c.data))
print("id(a.data)", id(a.data))

print(c.data is a.data)
print(id(c.data) == id(a.data))

这是实际输出：

id(c.data) 241233112
id(a.data) 241233112
False
True

我的问题是...为什么“ c.data是a.data”即使它们指向相同的ID，从而指向相同的对象，也返回false？我以为如果它们具有相同的ID，它们指向相同的对象，或者我错了吗？谢谢！

我有一份表格清单

v = [0,0,0,0,0,0,0,0,0]

我在代码中的某个地方

vec=v
vec[5]=5

这既改变v和vec:

>>> print vec
[0, 0, 0, 0, 0, 5, 0, 0, 0]
>>> print v
[0, 0, 0, 0, 0, 5, 0, 0, 0]

为什么要v改变？

据我所知，使用“=”复制对象实际上只是创建对同一对象的另一个引用。所以如果我这样做

a = [1, 2, 3]
b = a
print(id(a), id(b), a is b)

我的输出是2367729946880 2367729946880 True，这很好而且很明显。

如果我复制列表，它们有不同的 id：

a = [1, 2, 3]
b = a.copy()
c = a.copy()
print(id(b), id(c), b is c)

输出：2646790648192 2646790705984 False。

到目前为止，一切都很好。不过，如果我尝试直接在打印中创建副本，它们会意外地具有相同的 id：

a = [1, 2, 3]
print(id(a.copy()), id(a.copy()))

输出：2209221063040 2209221063040

这是怎么发生的？

我尝试了很多不同的东西，比如：

• 将副本分配给同一行中的变量，以防存在一些单行优化，因为 Python 是一种解释语言

a = [1, 2, 3]
b, c = a.copy(), a.copy()
print(id(b), id(c))

输出：2545996280192 2545996337984

• 将副本传递给函数以避免使用“=”

def f(a, b):
    print(id(a), id(b)) …