对象变动(Mutation)

当你将一个变量赋值为另一个可变类型的变量时，对这个数据的任意改动会同时反映到这两个变量上去。新变量只不过是老变量的一个别名而已。对象可变与不可变性，是对内存地址而言的。现在讲述的这个情况只是针对可变数据类型。

不可变对象（需要复制到新内存）

常见不可变对象类型：int，string，float，tuple，bool ，frozenset，bytes

def int_test(): 
    i = 77
    j = 77
    print(id(77))                  #140396579590760
    print('i id:' + str(id(i)))      #i id:140396579590760
    print('j id:' + str(id(j)))      #j id:140396579590760
    print i is j                    #True
    j = j + 1
    print('new i id:' + str(id(i)))  #new i id:140396579590760
    print('new j id:' + str(id(j)))  #new j id:140396579590736
    print i is j                    #False

if __name__ == '__main__':
    int_test()

首先i和j都指向77这个内存块。然后我们修改j的值，按道理j修改之后应该i的值也发生改变的，因为它们都是指向的同一块内存，但结果是并没有。因为int类型是不可变类型，所有其实是j复制了一份到新的内存地址然后+1，然后j又指向了新的地址。所以j的内存id发生了变化。

内存变化如下：

可变对象（在原内存上修改）

常见可变对象类型：list，dict，set，user-defined classes(unless specifically made immutable)

def dict_test():
    a = {}	
    b = a
    print(id(a))	# 140367329543360
    a['a'] = 'hhhh'
    print('id a:' + str(id(a)))	# id a:140367329543360
    print('a:' + str(a))	# a:{'a': 'hhhh'}
    print('id b:' + str(id(b)))	# id b:140367329543360
    print('b:' + str(b))	# b:{'a': 'hhhh'}

if __name__ == '__main__':
    dict_test()

可以看到a最早的内存地址id是140367329543360 然后把a赋值给b其实就是让变量b的也指向a所指向的内存空间。然后我们发现当a发生变化后，b也跟着发生变化了。因为list是可变类型，所以并不会复制一份再改变，而是直接在a所指向的内存空间修改数据，而b也是指向该内存空间的，自然b也就跟着改变了。

对于列表，首地址是不可变的，而对于列表内的所有元素进行修改，会改变单个元素的地址（指向不同的引用）。所以说对于列表中的单个元素而言是不可变的，对于整体列表而言是可变的，如下图所示

python函数的参数传递

由于python规定参数传递都是传递引用，也就是传递给函数的是原变量实际所指向的内存空间，修改的时候就会根据该引用的指向去修改该内存中的内容，所以按道理说我们在函数内改变了传递过来的参数的值的话，原来外部的变量也应该受到影响。但是上面我们说到了python中有可变类型和不可变类型，这样的话，当传过来的是可变类型(list,dict)时，我们在函数内部修改就会影响函数外部的变量。而传入的是不可变类型时在函数内部修改改变量并不会影响函数外部的变量，因为修改的时候会先复制一份再修改。下面通过代码证明一下：

def test(a_int, b_list):
    a_int = a_int + 1
    b_list.append('13')
    print('inner a_int:' + str(a_int))
    print('inner b_list:' + str(b_list))

if __name__ == '__main__':
    a_int = 5
    b_list = [10, 11]

    test(a_int, b_list)

    print('outer a_int:' + str(a_int))
    print('outer b_list:' + str(b_list))

运行结果如下:

inner a_int:6

inner b_list:[10, 11, '13']

outer a_int:5

outer b_list:[10, 11, '13']

好啦！答案显而易见啦，经过test()方法修改后，传递过来的int类型外部变量没有发生改变，而list这种可变类型则因为test()方法的影响导致内容发生了改变。

在很多的其他语言中在传递参数的时候允许程序员选择值传递还是引用传递(比如c语言加上号传递指针就是引用传递，而直接传递变量名就是值传递)，*而python只允许使用引用传递，但是它加上了可变类型和不可变类型，听说python只允许引用传递是为方便内存管理，因为python使用的内存回收机制是计数器回收，就是每块内存上有一个计数器，表示当前有多少个对象指向该内存。每当一个变量不再使用时，就让该计数器-1，有新对象指向该内存时就让计数器+1，当计时器为0时，就可以收回这块内存了。

slots魔法

在Python中，每个类都有实例属性。默认情况下Python用一个字典来保存一个对象的实例属性。这非常有用，因为它允许我们在运行时去设置任意的新属性。

然而，对于有着已知属性的小类来说，它可能是个瓶颈。这个字典浪费了很多内存。Python不能在对象创建时直接分配一个固定量的内存来保存所有的属性。因此如果你创建许多对象（我指的是成千上万个），它会消耗掉很多内存。
不过还是有一个方法来规避这个问题。这个方法需要使用__slots__来告诉Python不要使用字典，而且只给一个固定集合的属性分配空间。

这里是一个使用与不使用__slots__的例子：

不使用 __slots__:

class MyClass(object):
  def __init__(self, name, identifier):
      self.name = name
      self.identifier = identifier
      self.set_up()
  # ...

使用 __slots__:

class MyClass(object):
  __slots__ = ['name', 'identifier']
  def __init__(self, name, identifier):
      self.name = name
      self.identifier = identifier
      self.set_up()
  # ...

第二段代码会为你的内存减轻负担。通过这个技巧，有些人已经看到内存占用率几乎40%~50%的减少。

稍微备注一下，你也许需要试一下PyPy。它已经默认地做了所有这些优化。

参考资料：

【1】python可变和不可变对象：https://www.jianshu.com/p/c5582e23b26c

对象变动(Mutation)

不可变对象（需要复制到新内存）

可变对象（在原内存上修改）

python函数的参数传递

__slots__魔法

slots魔法