python之09-tuple元组

详细请参考：https://www.cnblogs.com/Neeo/articles/11212374.html

1、元组的基本操作

1>创建元组

Python中，元组（tuple）用一对小括号()表示，元组内的各元素以逗号分隔。

t = ()
print(type(t))  # <type 'tuple'>
t1 = ('name', )
print(t1)  # ('name',)
print(type(t1))  # <type 'tuple'>

注：元组中特别注意逗号的使用，一不小心创建的元组就会成为字符串。比如：

 t=('name')
 print(t,type(t))  #name <class 'str'>

2>元组的索引和切片

tups = ('name', 'wwj', 'age', 'good', 'hello')
print(tups)
#按照索引取值
print(tups[0])  # name
print(tups[-1])  # good
#取两者之间（范围）的值
print(tups[1:4])  # ('wwj', 'age', 'good')
print(tups[::2])  # ('name', 'age', 'hello')
#翻转元组
print(tups[::-1])  # ('hello', 'good', 'age', 'wwj', 'name')

3>for循环取值

for i in tups:
    print(i)
#for循环执行结果
name
wwj
age
good
hello

4>元组拼接：+

t1 = (1, 2, 3)
t2 = ('ab', 'cd', 'fg')
t = t1 + t2
print(t, type(t))  # (1, 2, 3, 'ab', 'cd', 'fg') <class 'tuple'>

5>元组的重复：*

t2 = ('ab', 'cd', 'fg')
t = t2 * 3
print(t, type(t))  # ('ab', 'cd', 'fg', 'ab', 'cd', 'fg', 'ab', 'cd', 'fg') <class 'tuple'>

6>成员资格测试：in，not in

t1 = ('ab', 'cd', 'fg')
print('ab' in t1)  # True
print('w' in t1)  # False
print(123 not in t1)  # True

7>元组的打包与解包

t = 1, 2, 3  # 打包
print(t, type(t))  # (1, 2, 3) <class 'tuple'>

x, y, z = t  # 解包
print(x)  # x
print(y)  # y
print(z)  # z

打包：将1、2、3打包赋值给变量t，相当于将3个苹果打包到一个盒子内。
解包：从盒子t中将3个苹果取出来，分别交给x、y、z
注意：解包这里需要注意的是，盒子里有几个苹果，必须有几个对应的变量接收。多了不行，少了也不行。

8>平行赋值

x, y = 3, 4
print(x,y)
print(x)

练习：打印斐波那契序列

x, y = 0, 1
while x < 50:
    x, y = y, x + y
    print(x)
#执行结果
1
1
2
3
5
8
13
21

9>删除元组

t = (1, 2, 4)
print(t)  # (1, 2, 4)
del t
print(t)  # NameError: name 't' is not defined

注意，这里说的删除仅是删除整个元组，而不是删除元组中某个元素。

10>总结

元组中常用的操作符：

操作符(表达式)	描述	重要程度
+	合并	**
*	重复	**
in	成员资格	****
for i in (1, 2, 3):print(i)	迭代	*****
t[2]	索引取值	*****
t[start:stop:step]	切片（截取）	*****

元组的几个内置的函数：

方法	描述	重要程度
max(tuple)	返回元组内最大的元素	**
min(tuple)	返回元组内最小的元素	**
tuple(seq)	将序列转换为元组	*****
len(tuple)	返回元组长度	*****

2、 元组的嵌套

与列表一样，元组也能嵌套存储数据：

t = (1, (2, 3), [4, [5, 'c']], {'a': 'b'}, {8, 7})
for item in t:
    print(item)
'''
1
(2, 3)
[4, [5, 'c']]
{'a': 'b'}
{8, 7}
'''

元组内可以存储的数据类型相当丰富，也可以发现，嵌套元素也会当成一个整体称为元组的子元素。但是我们说元组是不可更改的，但我们发现其中是由列表的，这是怎么回事？

t = (1, (2, 3), [4, [5, 'c']], {'a': 'b'}, {8, 7})
t[0] = 'x'  # TypeError: 'tuple' object does not support item assignment

通过上例，可以发现，元组内的普通元素不允许修改，但是列表是可变，我们能否把列表替换为别的元素呢？

t = (1, (2, 3), [4, [5, 'c']], {'a': 'b'}, {8, 7})
print(t[2])  # [4, [5, 'c']]
t[2] = 'w'  # TypeError: 'tuple' object does not support item assignment

通过上例也可以发现，如果列表被当成了元组的普通元素，那么它也是不可以修改的，遵循元组不可变特性。但是我们如果试图修改列表中的子元素呢？

t = (1, (2, 3), [4, [5, 'c']], {'a': 'b'}, {8, 7})
t[2][0] = 'w'
print(t)  # (1, (2, 3), ['w', [5, 'c']], {'a': 'b'}, {8, 7})

上例，可以发现，t[2][0]指的是列表中的第一个元素，我们在第2行修改它，然后发现是可以修改成功的。这是为什么呢？元组内的普通元素不允许修改，嵌套的子元素是否能够修改取决于这个子元素本身属于什么数据类型，如这个子元素是列表，那就可以修改，如果是元组，就可不以修改。

那么，了解完元组，你可能更有疑问了，除了不可变之外，元组跟列表没啥区别么？我们通过与列表的对比，来证明存在即是真理！

需要注意的是，元组并没有增、删功能。那么元组如此设计，以放弃增、删为代价换来了什么呢？

性能！是的，换来了性能！不信请看，以下演示代码由IPython（Python的另一个发行版本）完成。

2.3 列表与元组的比较

1> 创建生成速度

创建的同样大小的list和tuple，观察变化

上例的意思是说我们创建一个长度为5的列表，大概执行了7次大循环，每次大循环中进行10000000次小循环。这个7次大循环，每次耗时（平均值）139 ns，每次（标准）偏差2.34 ns。而创建同样长度的元组，每次仅耗时17.3 ns，对比创建列表的耗时139 ns，可以看到创建元组的速度快很多。

2>遍历速度

我们循环遍历元组和列表，可以看到遍历列表耗时4.73 µs，而元组这边耗时823 ns。
要知道1微秒(μs)=1000纳秒(ns)，元组的遍历性能相比列表也是快很多了。

3>存储开销

可以看到，元组在存储空间上面也占优势。

4>哈希比较

简单来说，Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来确定唯一的输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

Python中可哈希（hashable）类型：字符串、元组、对象。可哈希类型就是我们常说的不可变类型，优点是性能经过优化，多线程安全，不需要锁，不担心被恶意篡改或者不小心修改了。

不可哈希类型：字典、列表、集合。相对于可哈希类型，使用起来相对灵活。