《python核心编程》：6--元组

元组为容器存储，不可变类型，顺序访问

元组中的元素可以为任意对象

元组很多操作与列表类似，除下面两点外：

i）元组用（），列表用[]

ii）元组为不可变类型，列表为可变类型。

尤其是第ii）条，

另外创建的元组中只有一个元素的时候，要用逗号，如（2，）

>>> a = (2)
>>> type(a)
<type 'int'>
>>> a = (2,)
>>> type(a)
<type 'tuple'>
>>> b = ()
>>> type(b)
<type 'tuple'>

虽然元组为不可变的，但元组的元素可以是可变的。

所有的多对象的，逗号分隔的，没有明确用符号定义的，这些集合默认的类型都是元组。

看下面的例子

>>> x, y = 1, 2
>>> x, y
(1, 2)
>>> 'a', 3, ['m', 'l']
('a', 3, ['m', 'l'])            # 结果是元组
>>> def foo():
...     a = 1
...     b = 2
...     c = 3
...     return a, b, c              # 函数一次返回三个结果，其实返回的是一个元组
...
>>> foo()
(1, 2, 3)
>>> 4, 2 < 3, 5                 # <操作符的优先级要高于逗号操作符，因此这还是一个元组
(4, True, 5)

拷贝python对象，深拷贝和浅拷贝

python中，对象赋值实际上是简单的对象的引用

>>> a = [1, 2, 3]
>>> b = a                 # 从下面可知这里拷贝的是a的引用， 而不是列表对象[1,2,3]
>>> b
[1, 2, 3]
>>> a[0] = 'a'
>>> b
['a', 2, 3]

浅拷贝  （书中一例）

>>> person = ['name', ['savings', 100.0]]
>>> hubby = person[:]                        # 浅拷贝方式1：[:]切片方式
>>> wifey = list(person)                     # 浅拷贝方式2：工厂函数，如list(),dict()
>>> id(person), id(hubby), id(wifey)
(3078605100L, 3078605580L, 3078605900L)      # 可以看到这三个对象是三个不同的对象
>>> hubby[0] = 'joe'
>>> wifey[0] = 'jane'
>>> hubby
['joe', ['savings', 100.0]]                  # 修改了hubby[0]
>>> wifey                                    # 修改了wifey[0]
['jane', ['savings', 100.0]]
>>> person[1][1] = 50                        # 修改了person[1][1]
>>> hubby
['joe', ['savings', 50]]                     # hubby的hubby[1][1]也改变了
>>> wifey
['jane', ['savings', 50]]                    # wifey的wifey[1][1]也改变了
>>> person
['name', ['savings', 50]]                    # 注意person的person[0]没有改变

明显这里对person中的列表元素的拷贝，其实只拷贝了引用。再看下面的一个小例子

>>> a = [(1, [2, 3]), [4, 5]]
>>> b = a[:]
>>> id(b)
3078517772L
>>> id(a)
3075988236L
>>> a[0][1][0] = 'a'
>>> a
[(1, ['a', 3]), [4, 5]]
>>> b
[(1, ['a', 3]), [4, 5]]                # 对元组里的列表的拷贝，依旧是浅拷贝，但对元组的拷贝并不是只拷贝引用

浅拷贝还有第三种方式，就是用copy模块中的copy函数拷贝。

如果要进行深拷贝，就要使用copy模块中的deepcopy函数

有关拷贝：

 i）非容器类型没有被拷贝一说

ii）元组中值包含原子类型对象，则对它的深拷贝也不会进行。