Python入门(七)：对象类型之元组

1. 元组特性

  列表是有序对象的集合并且支持原处修改，元组与列表的差别就在于它不支持原地修改。元组主要有以下特点：

1). 有序集合、通过偏移量来提取数据
与字符和列表相似，元组是一个位置有序的对象的集合 (从左到右)，通过偏移量提取数据，支持索引和分片。

2). 不可变、固定长度、异构以及任意嵌套
因为元组是不可变的序列，不支持原处修改，因此长度固定；元组里面的对象可以是各种类型，支持异构；元组中可以嵌套元组，列表，字典等对象。

  元组可以看作是对象引用的数组，元组存储指向其他对象的存取点 (引用) 。

这里说明一下，Python的不可变类型和可变类型在内存中的问题。我们知道，任何变量都是对一个对象的引用，在赋值过后指向数据所在的内存。对于不可变类型中的数字和字符串，不同的变量名若是对应相同的数据，它们指向的内存地址一样。对于可变类型和元组，不同的变量名若是有相同的数据，它们指向的内存地址不一样。 以上均在VS Code中测试，注意IDE和交互模式下不同，大家可以自行测试。

交互模式下，对于不可变类型，不同变量名指向相同的内存地址的情况：数字仅限小数字(参见之前的博客Python入门(三):对象类型之数字)，字符串仅限没有空格和其他符号的连续字符。

#*******不可变类型********
##元组
t1 = (123,)
t2 = (123,)
print('tuple:',id(t1)==id(t2))
##数字
n1 = 1.2e30
n2 = 1.2e30
print('number:',id(n1)==id(n2))
##字符串
s1= 'hello python aaaaaaaaaa, bcd'
s2 = 'hello python aaaaaaaaaa, bcd'
print('string:',id(s1)==id(s2))

#*******可变类型********
##列表
l1 = [123]
l2 = [123]
print('list:', id(l1)==id(l2))
##字典
d1 = dict(a = 1, b = 2, c = 3)
d2 = dict(a = 1, b = 2, c = 3)
print('dictionary:',id(d1)==id(d2))

运行结果如下：

tuple: False
number: True
string: True
list: False
dictionary: False

2. 元组操作

2.1 基本操作

• 创建元组
  通过(对象1，对象2…)创建元组。需要注意的是：对于单个对象，需要在对象后面加一个逗号，表明是元组，否则会被认作是对象的一个括号的表达式。

## 空元组
>>> a =()
>>> a
()

## 一个对象的元组
>>> a= (40,)
>>> a
(40,)
###不加逗号的情况
>>> a=(40)
>>> a
40
>>> type(a)
<class 'int'>

##多个对象的元组
>>> a = ('abc',123,456)
>>> a
('abc', 123, 456)

通过tuple(iterabel)创建元组。iterable为可迭代对象

>>> a = tuple('abc')
>>> a
('a', 'b', 'c')
>>> a = tuple([123,456,789])
>>> a
(123, 456, 789)

• 元组的索引和分片

t1 = tuple(['hello',123,'python',456])

##索引
print(t1[1])      #打印元组第2个元素
print(t1[0][-1])  #打印元组第1个元素字符串中的最后一个字符

##分片
print(t1[1:3])    #打印元组第2和3个元素
print(t1[3::-2])  #逆向打印元组元素，步长为2

运行结果为：

123
o
(123, 'python')
(456, 123)

• 长度、合并、重复、成员测试

t1 = tuple(['hello',123,'python',456])
t2 = ('C++', 000)
##长度
print( len(t1))  

##合并 
print( t1+t2 )

print( t2+t1 )

##重复
print( t2*3 )

##成员关系
print('python'in t1, 'c++'in t1)

运行结果：

4
('hello', 123, 'python', 456, 'C++', 0)
('C++', 0, 'hello', 123, 'python', 456)
('C++', 0, 'C++', 0, 'C++', 0)
True False

• 搜索和计数
  注意，搜索的元素不在元组的时候，会报错，在下面的代码中已经注释掉

t1 = tuple(['hello',123,'python',456])

##搜索并返回下标
print( t1.index(123) )
#print( t1.index(000) )

##计数
print(t1.count('python'))
print(t1.count(000))

运行结果：

1
1
0

2.2 关于元组的不可变性

  元组的不可变性只适用于元组本身顶层，而并非其内部的内容。例如，元组内部的列表还是可以改变的。
顶层修改会报错

t = (123, ['hello', 'python'], 456, {'key1':1, 'key2':2})
t[1] = 'abc'
##运行结果
TypeError: 'tuple' object does not support item assignment

内部的内容如果是可变类型，支持修改

t = (123, ['hello', 'python'], 456, {'key1':1, 'key2':2})
t[1][1] = 'C++'
print(t)
t[-1]['key1'] = 10
print(t)

运行结果如下：

(123, ['hello', 'C++'], 456, {'key1': 1, 'key2': 2})
(123, ['hello', 'C++'], 456, {'key1': 10, 'key2': 2})

• 为什么有了列表还要元组
  元组的不可变性提供了完整性，可以确保元组在程序中不会被另一个引用修改。元组这种角色类似其他语言中的“常数”声明，不过这种常数概念在Python中是和对象联系在一起的。
  此外，元组可以作为字典的键，而列表不能。