Python学习笔记:元组（tuple）有关内容

元组是跟列表非常类似的一种容器类型，但是列表是可变的，形式是list[  ]，元组是不可变的，形式为tuple(  )。

1.创建元组。

元组的创建方法与列表类似，只有一点不同，元组内至右一个元素的时候需要在元素后面加上一个逗号（，）。因为元组的形式是用

小括号来包含元素的，但是小括号也是数学公式中的，所以会产生歧义，此时系统默认不是元组类型，所以需要加上逗号来区分。

>>> T = (1,2,3)
>>> T
(1, 2, 3)
>>> T = (1)
>>> T
1
>>> print(type(T)) 
<class 'int'>   #此时为int类型
>>> T = ('abc')
>>> print(type(T))
<class 'str'>  #此时为str类型
>>> T = (1,)
>>> print(T,type(T))
(1,) <class 'tuple'>  #此时为tuple类型
>>> T
(1,)
>>> 

只有一个元素时，输出时会加上一个逗号为了防止认为是数学上面的小括号。

元组内的元素也可以是元组或者列表。

>>> T = ((1,2,3),4)
>>> T
((1, 2, 3), 4)
>>> T = ([1,2,3],4)
>>> T
([1, 2, 3], 4)

同样的列表中的元素也可以是元组或者列表。

>>> L = [(1,2,3),4]
>>> L
[(1, 2, 3), 4]
>>> L = [[1,2,3],4]
>>> L
[[1, 2, 3], 4]

2.访问元组。

访问元组与列表相似，都是通过索引来访问的。

>>> T = (1,2,3,'abc')
>>> T
(1, 2, 3, 'abc')
>>> T[0]
1
>>> T[-1]
'abc'

试图修改元组内容，出现异常。

>>> T = (1,2,3,'abc')
>>> T
(1, 2, 3, 'abc')
>>> T[0]
1
>>> T[0] = 2
Traceback (most recent call last):
  File "<pyshell#101>", line 1, in <module>
    T[0] = 2
TypeError: 'tuple' object does not support item assignment

3.切片操作。

元组也支持切片操作，除了不能用切片操作来对元组进行修改之外与列表没有大的区别。

>>> T = (1,2,3,'a','b','c')
>>> T
(1, 2, 3, 'a', 'b', 'c')
>>> T[1:4]
(2, 3, 'a')
>>> T[-1:-3]
()
>>> T[-3:-1]
('a', 'b')
>>> T[:4:2]
(1, 3)
>>> T[5:1:-2]
('c', 'a')

试图用切片来修改，出现异常。

>>> T = (1,2,3)
>>> T
(1, 2, 3)
>>> T1 = (4,5)
>>> T1
(4, 5)
>>> T[1:3] = T1
Traceback (most recent call last):
  File "<pyshell#106>", line 1, in <module>
    T[1:3] = T1
TypeError: 'tuple' object does not support item assignment

4.删除元组。

列表中可以用 del 来删除列表中的某个元素，但是由于元组是不可变得，所以不能使用 del 删除某个元素。 

>>> L = [1,2,3]
>>> L
[1, 2, 3]
>>> del L[0]  #删除列表中的元素 成功
>>> L
[2, 3]
>>> T = (1,2,3)
>>> T
(1, 2, 3)
>>> del T[0]  #试图删除元组中的元素 失败报错
Traceback (most recent call last):
  File "<pyshell#39>", line 1, in <module>
    del T[0]
TypeError: 'tuple' object doesn't support item deletion

但是可以直接删除整个元组的内容。

>>> T = (1,2,3)
>>> T
(1, 2, 3)
>>> del T  #删除整个元组
>>> T      #删除后试图输出，出现异常，T 没有定义
Traceback (most recent call last):
  File "<pyshell#43>", line 1, in <module>
    T
NameError: name 'T' is not defined
>>> L = [1,2,3]
>>> L
[1, 2, 3]
>>> del L  #删除整个列表
>>> L      #删除后试图输出，出现异常，L 没有定义
Traceback (most recent call last):
  File "<pyshell#47>", line 1, in <module>
    L
NameError: name 'L' is not defined

5.元组跟列表一样可以使用 运算符 “ +”  “ * ” 。

>>> T = (1,2,3)
>>> T
(1, 2, 3)
>>> T*3
(1, 2, 3, 1, 2, 3, 1, 2, 3)
>>> T2 = ('a','b','c')
>>> T2
('a', 'b', 'c')
>>> T + T2
(1, 2, 3, 'a', 'b', 'c')

6.元组的有关函数。

因为元组的不可变性，所以很多列表中可以使用的函数，元组中不能够再使用。但是还有些基本的函数可以用。

1>. len()  函数用来统计元组的元素个数。

>>> T = (1,2,3,'abc')
>>> T
(1, 2, 3, 'abc')
>>> len(T)
4

2>. max( )  min ( ) 函数，用来计算元组中的最大数和最小数。

>>> T = (1,2,3)
>>> T
(1, 2, 3)
>>> max(T)
3
>>> min(T)
1

若元素是单个字母时，根据ASCII大小输出。

>>> T = ('a','b','c')
>>> T
('a', 'b', 'c')
>>> max(T)
'c'
>>> min(T)
'a'

若元素是字符串时，也是根据字符串的ASCII大小输出（与长度无关）。

>>> T = ('aaa','zz')
>>> T
('aaa', 'zz')
>>> max(T)
'zz'
>>> min(T)
'aaa'

3>. sum( )  函数。

sum( ) 函数用来计算元组中的元素之和，数字可以计算，字符则会出现异常。

>>> T = (1,2,3)
>>> T
(1, 2, 3)
>>> sum(T)
6
>>> T = ('a','b','c')
>>> T
('a', 'b', 'c')
>>> sum(T)
Traceback (most recent call last):
  File "<pyshell#74>", line 1, in <module>
    sum(T)
TypeError: unsupported operand type(s) for +: 'int' and 'str'

4>. tuple（） 可将其他类型转换成元组类型并返回副本，不改变原有数据类型。

>>> T = [1,2,3]
>>> T
[1, 2, 3]
>>> type(T)
<class 'list'>
>>> tuple(T)
(1, 2, 3)
>>> type(T)
<class 'list'>
>>> print(type(tuple(T)))  #返回的是元组类型副本。
<class 'tuple'>

python 2.x版本中还有cmp() 函数用来，比较两个元组是否相同或者谁大谁小，但是pyth3.x版本中没有了。

8.元组的  “”“某些可变内容””“。

元组的元素的是不可变的，但是元组中元素的元素是可变的，如果元素中包含了一个列表元素，由于列表是可变的，所以元组看起来好像也是改变了，

但是此时改变的是列表中的元素，而元组中的元素并没有改变，元组的元素是一个列表还是一个列表但是列表的内容不同而已。

>>> T = ([1,2,3],1,2,3)
>>> T
([1, 2, 3], 1, 2, 3)
>>> T[0][0] = 'abc'
>>> T
(['abc', 2, 3], 1, 2, 3)

9.默认集合类型。

所有的多对象、逗号分隔的，没有明确用符号定义的（比如用方括号表示列表和圆括号表示元组），这些集合默认的类型都是元组。（摘自：python核心编程）。

>>> 'a',1,'abc'
('a', 1, 'abc')
>>> x,y = 1,2
>>> x,y
(1, 2)

可以看出，输出后用圆括号包括，是元组。

10.列表 VS 元组。（摘自：python核心编程）

一个经常会被问道的问题是：“为什么我们要区分元组和列表变量？” ，这个问题也可以被表述为“我们真的需要两个相似的序列类型么？” ， 一个原因是在有的情况

下，使用其中的一种类型要优于使用另一种类型。

最好使用不可变类型变量的一个情况是，如果你在维护一些敏感的数据，并且需要把这些数据传递给一个并不了解的函数（或许是一个根本不是你写的API），作为

一个只负责一个软件某一部分的工程师，如果你确信你的数据不会被调用的函数篡改，你会觉得安全了许多。

一个需要可变类型参数的例子是，在管理动态数据集合时。你需要先把它们创建出来，逐渐的或者不定期的添加它们，或者有时还要移除一些单个的元素。这是一个

必须使用可变类型对象的典型例子。幸运的是，通过内建的list(0 和 tuplp() 转换函数，你可以非常轻松的在两者之间进行转换。

list()和tuple() 函数允许你用一个列表来创建一个元组，反之亦然。如果你有一个元组变量，但是你需要你个列表变量，因为你要更新一下它的对象，这时list(0 函数

就是你最好的帮手，如果你有一个列表变量，并且向把它传递给一个函数，或许一个API，而你又想任何人弄乱你的数据，这时tuple()函数就非常有用。