第八天学Python：元组及其常用指令、元组和列表的区别

列表、元组、字典、集合等等都是尤为常用的Python自带的数据类型，前天说了列表（List），今天就来说一下元组（Tuple）

• 元组（Tuple）

元组是一种不可变的序列，它也可以存储各种数据类型，用小括号表示，元素之间用逗号 “ , ” 分隔。
不可变包含：增加、删除、修改、变换位置、排序等

• （不可变有一种特殊情况，详见目录最后一条：“绝对不可变吗？”）

test1=()          #空元组
test2=('K',1,6)   #多数据类型
test3=(1)         #这句话是不对的
test4=(1,)        #一个元素的命名方式
test5=(1,test2)   #元组嵌套
test6='KSY',18    #省略小括号

当只给元组赋一个变量的时候，不能像 test3=(1) 那样写。因为Python会把小括号认为是一种数学符号，而不是元组

>>> text3=(1)
>>> type(text3)
<class 'int'>

正确的写法应是如test4=(1,)这样，在元素的后面加一个逗号。

另外，在省略小括号定义元组的时候，也可以这么写：

>>> name,age='ksy',18 #既可以看做连续赋值，又可以看做一个元组赋值
>>> name
'ksy'
>>> age
18
>>> name,age
('ksy',18)
>>> type((name,age))
<class 'tuple'>

在单独输入 name 或 age 时，返回值分别是 ‘ksy’ 和 18，但是输入name,age整体时，返回值就是元组 (‘ksy’,18) 了。
元组的基本格式就说完了，接下来说说基本操作：

元组的操作基本方法

自带指令

与列表不同，元组自带的操作指令只有两个，这可能是不可变序列这个性质导致的。

count：统计指定元素个数

Num = (1,1,1,2,2,3,4,1,5)
Num.count(1)
'''
返回值：4
'''

index：返回指定元素下标

Num = (1,1,1,2,2,3,4,1,5)
Num.index(1)
Num.index(2)
'''
返回1的下标：0
返回2的下标：3
'''

可见，index会返回查到的第一个元素的下标

常用操作/函数

运算符

in

test1 = (1,2,3)
1 in test1
'''
返回值：True
'''

“ * ”

t=('A',)
t*4
print(t)
'''
t*4后输出：('A', 'A', 'A', 'A')
print(t):('A',)
'''

可见*不会改变元组本身，这种符号可以用于给另一个元组赋值

t2 = t*4
t3 = t*-4
print(t2)
print(t3)
'''
返回t2:('A', 'A', 'A', 'A')
返回t3:()
'''

在乘以正整数的时候，会产生一个复制了正整数倍的新元组；而在乘以负数的时候，会产生一个空元组。
如果输入小数呢？

t4=t*4.5
'''
报错：TypeError: can't multiply sequence by non-int of type 'float'
'''

看来是不能用小数

“ + ”

加号一般用于元组的合并

test1 = (1,2,3)
tset2 = ('A','B')
test3 = test1 + test2
print(test3)
'''
(1, 2, 3, 'A', 'B')
'''

len：统计元素个数

Num = (1,1,1,2,2,3,4,1,5)
len(Num)
'''
返回值：
'''

sum：求和

Num = (1,1,1,2,2,3,4,1,5)
sun(Num)
'''
20
'''

其实用for语句也能达到相同的效果

Sum = 0
for i in Num:
	Sum = Sum + i
print(Sum)

返回值同样是20

查找元素

元组的每个序列也都是有自己的下标的，可以直接输入下标来查找元素

>>> Num = (1, 2.5 ,5, 5.5)
>>> Num[2]
5

元组和列表一样，也是可以切片的

>>> Num[2:]
(5, 5.5)

max：返回最大值元素

max函数可以返回数值型的最大值

>>> Num = (1, 2.5 ,5, 5.5)
>>> max(Num)
5.5

也可以返回字符型的最大值

>>> A=('A','B','X')
>>> max(A)
'X'

但是不能把数值型和字符型变量放在一起比较

>>> Num = (1, 2.5 ,5, 5.5 ,'A')
>>> max(Num)
TypeError: '>' not supported between instances of 'str' and 'float'

min：返回最小值元素

用法和max是相同的，就不必多说了

tuple、list：格式转换

当我们定义元组失误出错的时候，我们可以先把元组转换成列表，在列表里改正以后，再转换回元组。
其实重新定义一个新的元组可以：）
元组转换为列表直接用list函数就行

T = (1,2,'A')
L = list(T)
print(L)
'''
[1, 2, 'A']
'''

反之同理

t = tuple(L)
print(t)
'''
(1,2,'A')
'''

del：删除元组

由于元组的不可变性，我们不能对元组的某个元素进行删除操作。所以在元组里，del函数只能删除整个元组

A=(1,2,3)
del(A)
print(A)
'''
报错：NameError: name 'A' is not defined
'''

元组与列表的区别

性质

列表和元组都是可以存储多种数据类型的有序集合，但是列表是可变的，元组却不可变，这主要跟它们的存储方式有关

存储方式

列表

列表是可变序列，也就是说列表是动态的，它可以随意增加删除修改排序元素。
（sizeof是获得对象占用内存大小的指令）

>>> L = [1,2,3,4]
>>> L.__sizeof__()
72
>>> L.append(64)
>>> L.__sizeof__()
104

如上，在给列表增加足够大的元素的时候，系统原本给列表分配的空间就不够了，所以又会给列表额外分配空间。

元组

而元组在定义好的时候，存储空间就固定了，而且元组没有增加删除修改排序等操作，所以这个空间是固定的，也就是说元组是静态的

现在来看一下存储相同元素的元组和列表所占的空间：

>>> L = [1,2,3]
>>> T = (1,2,3)
>>> L.__sizeof__()
64
>>> T.__sizeof__()
48

看起来少了16字节，这是有原因的，跟存储指针等等有关，有机会的话会再来说的。

适用情况

列表和元组各有各的好处，完全是根据需要来自己选择存储数据的方法的，假如我只是要存储一个固定的数组，那用元组明显是好过列表；但是当我需要一个以后可以编辑的集合，那还是要用列表来存储数据的：）

绝对不可变吗？

• 当元组里包含列表时，元组里的列表元素可变

元组不可变有一种特殊情况，当元组里的元素是可变对象（如列表）时，这个列表里的元素可以修改的。元组的不可变只是限制在元组这一层。例如：

>>> L = [1,2]
>>> T = (0,L)
>>> T
(0, [1, 2])
#修改元组这一层的元素
>>> T[0] = 2
TypeError: 'tuple' object does not support item assignment
#修改列表这一层的元素
>>> T[1][0] = 2
>>> T
(0, [2, 2])
#列表甚至还可以添加元素
>>> T[1].append(3)
>>> T
(0, [2, 2, 3])
#删除列表元素也可以
>>> del T[1][2]
>>> T
(0, [2, 2])

…
…
嗯今天就说这么多好了，相比列表的灵活，元组的使用更为简单，二者各有各的好处，而我们只是根据需要来选择合适的存储方式而已。

声明：文章仅供学习交流使用，若有程序错误和写法不当之处烦请私信我，我将及时改正，还请海涵，谢谢！