python 对象/变量
对象
Every object has an identity, a type and a value.
- An object’s identity never changes once it has been created; you may think of it as the object’s address in memory. The ‘is’ operator compares the identity of two objects; the id() function returns an integer representing its identity (currently implemented as its address).
- An object’s type is also unchangeable. The type() function returns an object’s type (which is an object itself).
- The value of some objects can change. Objects whose value can change are said to be mutable; objects whose value is unchangeable once they are created are called immutable.
- 不可变（immutable）对象：
numbers, strings and tuples, etc.
可变对象的id基本上可以理解为该对象内存地址，而python中命名空间内的对象总是以标签的方式来操作，例如a=3，它会在内存中寻找一个int类型的value为3的对象，如果有则将其内存地址作为a的id，假如没有这样的对象，则会先新建一个int类型的value为3的对象，再将其内存地址作为a的id。
class Obj():
def __init__(self,arg):
self.x=arg
if __name__ == '__main__':
obj=Obj(1)
print id(obj) #32754432
obj.x=2
print id(obj) #32754432
s="abc"
print id(s) #140190448953184
s="bcd"
print id(s) #32809848
x=1
print id(x) #15760488
x=2
print id(x) #15760464
- 可变（mutable）对象：
dictionaries and lists, etc.、
在python中不可变对象总是唯一的，即使两个列表的大小，value对相同，但他们的id绝不可能相同，这是因为对象是可变的，假如id相同，则两个变量将可以协同变化。
class Obj():
def __init__(self,arg):
self.x=arg
def __eq__(self,other):
return self.x==other.x
if __name__ == '__main__':
obj1=Obj(1)
obj2=Obj(1)
print obj1 is obj2 #False
print obj1 == obj2 #True
lst1=[1]
lst2=[1]
print lst1 is lst2 #False
print lst1 == lst2 #True
s1='abc'
s2='abc'
print s1 is s2 #True
print s1 == s2 #True
a=2
b=1+1
print a is b #True
a = 19998989890
b = 19998989889 +1
print a is b #False
对象赋值
在python中一切皆为对象，赋值操作即是改变命名空间中的相应名字的指针，在相应的对象上即使反映为:从一个对象上撕下标签，再将该标签打到另外一个对象上。
对于可变对象来说，即为id地址的改变。
def fun(a):
print "id(a):", id(a) # 56715624
a = 4
print "id(a):", id(a) # 56715600
print "a:", a
b = 3
print "id(3):", id(3) # 56715624
fun(b)
print "id(b):", id(b) # 56715624
print 'b:', b
首先创建了对象int 3，该对象即有了一个id，再将其赋值给b（属于全局名字空间），b的id与int 3的id相同，所以b指向了3.再进行函数操作fun(b)时，首先进行了a=b=3的操作，a与b与3的id相同，共同指向对象3，然后a又进行了赋值操作，因为对象是不可变的（type决定了），所以必须新建对象int 4，并将a指向4，所以a的id改变了，a的value也相应的改变了。但是b是属于全局名字空间的，b并没有受到影响。
对于可变变量（列表）
def fun(a):
print "id(a):", id(a) # 63265352 a=b的操作，a、b的id相同
print a # [3, [2, 3]]
print id(c) # 57698664 指向全局变量c
a[0] = 1
print "id(a):", id(a) # 63265352 修改了a的value，但是id并未改变
c = 3
b = [c, [2, 3]]
print "id(c):", id(c) # 57698664
print "id(b):", id(b) # 63265352
fun(b)
print "id(b):", id(b) # 63265352
print 'b:', b # [1, [2, 3]] b的id与a相同，a、b的value同时改变
在此处赋值时，先进行a=b的操作，a、b的id相同，所以在fun内改变了a[0]，b也被改变了。
def fun(a):
print "id(a):", id(a) # 54309000 由于进行了copy操作，所以相当于传递了一个新的列表id给a，a的id与b则不相同了，
a上的浅层（axis=0）修改对b不起作用,但深层次（axis>0）的修改依然有效吗，这是因为此时a[1]与b[1]都指向同一个列表。
print a[0] is b[0] # False
print a[1] is b[1] # True
print a # [3, [2, 3]]
a[0] = 1
a[1][0] = 0
print a # [1, [0, 3]]
c = 3
b = [c, [2, 3]]
print "id(c):", id(c) # 52455784
print "id(b):", id(b) # 54286920
fun(b[:]) # 对b进行切片操作，即等于copy.copy(b)
print "id(b):", id(b) # 54286920
print 'b:', b # [3, [0, 3]]
对列表的复制会产生一个新的列表，与新的列表id。
切片操作与浅层复制是相等的：a[:] 等价于 copy.copy[a]
深层复制可以迭代copy操作，使得列表中的列表也被复制，即完全产生一个新的value相同的列表，新列表与旧列表没有任何联系，对列表中的列表的修改不会影响原列表。可以写成copy.deepcopy(b)。
Reference