python--赋值与深浅拷贝

参考：http://www.cnblogs.com/Eva-J/p/5534037.html#undefined

一、python的变量及其存储

  在高级语言中，变量是对内存及其地址的抽象。对于python而言，python的一切变量都是对象，变量的存储，采用了引用语义的方式，存储的只是一个变量的值所在的内存地址，而不是这个变量的值本身。

引用语义与值语义详解

引用语义：在python中，变量保存的是对象(值)的引用，我们称为引用语义。采用这种方式，变量所需的存储空间大小一致，因为变量只是保存了一个引用。也被称为对象语义和指针语义。
 
值语义：有些语言采用的不是这种方式，它们把变量的值直接保存在变量的存储区里，这种方式被我们称为值语义，例如C语言，采用这种存储方式，每一个变量在内存中所占的空间就要根据变量实际的大小而定，无法固定下来。

值语义和引用语义的区别：
 
值语义： 死的、 傻的、 简单的、 具体的、 可复制的
引用语义： 活的、 聪明的、 复杂的、 抽象的、不可复制的

  我们来看一张简单易懂的图理解一下python的引用语义和C语言值语义在内存中的存储情况，左右两个图，分别表示了python中变量存储与C语言中变量存储区别：

二、各基本数据类型的地址存储及改变情况

  在python中的数据类型包括：bool、int、long、float、str、set、list、tuple、dict等等。我们可以大致将这些数据类型归类为简单数据类型和复杂的数据结构。

  如果一个数据类型，可以将其他的数据类型作为自己的元素，我就认为这是一种数据结构。数据结构的分类有很多种，但是在Python中常用的只有集合、序列和映射三种结构。对应python中的set、list(tuple、str)、dict；常用的数据类型有int、long、float、bool、str等类型。（其中，str类型比较特别，因为从C语言的角度来说，str其实是一个char的集合，但是这与本文的关联不大，所以我们暂时不谈这个问题）

  由于python中的变量都是采用的引用语义，数据结构可以包含基础数据类型，导致了在python中数据的存储是下图这种情况，每个变量中都存储了这个变量的地址，而不是值本身；对于复杂的数据结构来说，里面的存储的也只只是每个元素的地址而已

三、变量的赋值

  在python中，对象的赋值就是简单的对象引用，这点和C++不同。如下：

list_a = [1,2,3,"hello",["python","C++"]]
list_b = list_a

  这种情况下，list_b和list_a是一样的，他们指向同一片内存，list_b不过是list_a的别名，是引用。我们可以使用 list_b is list_a 来判断，返回true，表明他们地址相同，内容相同。也可使用id(x) for x in list_a, list_b 来查看两个list的地址。
赋值操作（包括对象作为参数、返回值）不会开辟新的内存空间，它只是复制了新对象的引用。也就是说，除了list_b这个名字以外，没有其它的内存开销。修改了list_a，就影响了list_b；同理，修改了list_b就影响了list_a。

  注：增强赋值以及共享引用：（应该是只对list有用？）

  x = x + y，x 出现两次，必须执行两次，性能不好，合并必须新建对象 x，然后复制两个列表合并属于复制/拷贝

  x += y，x 只出现一次，也只会计算一次，性能好，不生成新对象，只在内存块末尾增加元素，当 x、y 为list时， += 会自动调用 extend 方法进行合并运算

四、拷贝

  我们已经详细了解了变量赋值的过程。对于复杂的数据结构来说，赋值就等于完全共享了资源，一个值的改变会完全被另一个值共享。
  然而有的时候，我们偏偏需要将一份数据的原始内容保留一份，再去处理数据，这个时候使用赋值就不够明智了。python为这种需求提供了copy模块。提供了两种主要的copy方法，一种是普通的copy，另一种是deepcopy。我们称前者是浅拷贝，后者为深拷贝。
  深浅拷贝一直是所有编程语言的重要知识点，下面我们就从内存的角度来分析一下两者的区别。

浅拷贝

  不管多么复杂的数据结构，浅拷贝都只会copy一层。

看上面两张图，我们加入左图表示的是一个列表sourcelist，sourcelist = [‘str1’,‘str2’,‘str3’,‘str4’,‘str5’,[‘str1’,‘str2’,‘str3’,‘str4’,‘str5’]]；

下图在原有的基础上多出了一个浅拷贝的copylist，copylist = [‘str1’,‘str2’,‘str3’,‘str4’,‘str5’,[‘str1’,‘str2’,‘str3’,‘str4’,‘str5’]]；
sourcelist和copylist表面上看起来一模一样，但是实际上在内存中已经生成了一个新列表，copy了sourceLst，获得了一个新列表，存储了5个字符串和一个列表所在内存的地址。
  但是：如果对sourcelist[5] 进行增删改时，copylist也会相应改变，因为他们指向相同的地址，如：sourcelist[5][0]=“str_test”，相应的，copylist，也会相应改变

在字典套字典、列表套字典、字典套列表，列表套列表，以及各种复杂数据结构的嵌套中，所以当我们的数据类型很复杂的时候，用copy去进行浅拷贝就要非常小心。。。

浅拷贝有三种形式：切片操作，工厂函数，copy模块中的copy函数

切片操作：list_b = list_a[:] 或者 list_b = [each for each in list_a]
工厂函数：list_b = list(list_a)
copy函数：list_b = copy.copy(list_a)

深拷贝

  深拷贝——即python的copy模块提供的另一个deepcopy方法。深拷贝会完全复制原变量相关的所有数据，在内存中生成一套完全一样的内容，在这个过程中我们对这两个变量中的一个进行任意修改都不会影响其他变量。
  其实深拷贝就是在内存中重新开辟一块空间，不管数据结构多么复杂，只要遇到可能发生改变的数据类型，就重新开辟一块内存空间把内容复制下来，直到最后一层，不再有复杂的数据类型，就保持其原引用。这样，不管数据结构多么的复杂，数据之间的修改都不会相互影响。

关于拷贝的警告

1. 对于非容器类型，如数字，字符，以及其它“原子”类型，没有拷贝一说。产生的都是原对象的引用。
2. 如果元组变量值包含原子类型对象，即使采用了深拷贝，也只能得到浅拷贝

五、陷阱：使用可变的默认参数

def foo(a, b, c=[]):
# append to c
# do some more stuff

永远不要使用可变的默认参数，可以使用如下的代码代替：

def foo(a, b, c=None):
    if c is None:
        c = []
    # append to c
    # do some more stuff

‍‍与其解释这个问题是什么，不如展示下使用可变默认参数的影响：‍‍

In[2]: def foo(a, b, c=[]):
...        c.append(a)
...        c.append(b)
...        print(c)
...
In[3]: foo(1, 1)
[1, 1]
In[4]: foo(1, 1)
[1, 1, 1, 1]
In[5]: foo(1, 1)
[1, 1, 1, 1, 1, 1]

同一个变量c在函数调用的每一次都被反复引用。这可能有一些意想不到的后果。