python 对象/变量

对象

Every object has an identity, a type and a value.

1. 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).

2. An object’s type is also unchangeable. The type() function returns an object’s type (which is an object itself).

3. 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.

1. 不可变（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

2. 可变（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 = 3print "id(3):", id(3)   # 56715624fun(b)print "id(b):", id(b)   # 56715624print '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 = 3b = [c, [2, 3]]print "id(c):", id(c)   # 57698664print "id(b):", id(b)   # 63265352fun(b)print "id(b):", id(b)   # 63265352print '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 = 3b = [c, [2, 3]]print "id(c):", id(c)   # 52455784print "id(b):", id(b)   # 54286920fun(b[:])               # 对b进行切片操作，即等于copy.copy(b)print "id(b):", id(b)   # 54286920print 'b:', b           # [3, [0, 3]]

对列表的复制会产生一个新的列表，与新的列表id。
切片操作与浅层复制是相等的：a[:] 等价于 copy.copy[a]
深层复制可以迭代copy操作，使得列表中的列表也被复制，即完全产生一个新的value相同的列表，新列表与旧列表没有任何联系，对列表中的列表的修改不会影响原列表。可以写成copy.deepcopy(b)。

Reference

Python中的id函数到底是什么？
python基础（5）：深入理解 python 中的赋值、引用、拷贝、作用域

原文出处：https://www.cnblogs.com/fugeny/p/9690656.html