人工智能之python打卡学习100天计划-day06

常用数据结构之元组

上次学习了Python中的列表，它是一种容器型数据类型，我们可以通过定义列表类型的变量来保存和操作多个元素。当然，Python中容器型的数据类型肯定不止列表一种，接下来学习另一种重要的容器型数据类型，它的名字叫元组（tuple）。

1.定义和使用元组

在Python中，元组也是多个元素按照一定的顺序构成的序列。元组和列表的不同之处在于，元组是不可变类型，这就意味着元组类型的变量一旦定义，其中的元素不能再添加或删除，而且元素的值也不能进行修改。定义元组通常使用()字面量语法，也建议大家使用这种方式来创建元组。元组类型支持的运算符跟列表是一样。下面的代码演示了元组的定义和运算。

#定义一个3元组
t1 = (11,10,22)
#定义一个4元组
t2 = ('cat',20,True,'猫')

#查看变量的类型
print(type(t1),type(t2))  #  <class 'tuple'> <class 'tuple'>
#查看元组中元素的数量 
print(len(t1),len(t2))   #  3 4
 
#通过索引运算获取元组中的元素
print(t1[0],t1[-3]) # 11  11
print(t2[3],t2[-1]) # 猫 猫

#循环遍历元组中的元素  
for member in t2:
    print(member)  # cat  20  True  猫
    
#成员运算
print(100 in t1)  #False
print(40 in t2)   #False

#拼接
t3 = t1 + t2
print(t3)    #(11, 10, 22, 'cat', 20, True, '猫')

#切片
print(t3[::3])  #(11, 'cat', '猫') ---从元组头开始，到元组尾结束，步长为3

#比较运算
print(t1 == t3) #False
print(t1 >= t3) #False
print(t1 < (30,11,55)) #True

一个元组中如果有两个元素，我们就称之为二元组；一个元组中如果五个元素，我们就称之为五元组。需要提醒大家注意的是，()表示空元组，但是如果元组中只有一个元素，需要加上一个逗号，否则()就不是代表元组的字面量语法，而是改变运算优先级的圆括号，所以(‘hello’, )和(100, )才是一元组，而**(‘hello’)和(100)只是字符串和整数**。我们可以通过下面的代码来加以验证。

# 空元组
a = ()
print(type(a))

#不是元组
b = ('hello')
print(type(b))
c = (100)
print(type(c))

#一元组
d = ('hello',)
print(type(d))
e = (100,)
print(type(e))

2.元组的应用场景

例1：打包和解包操作

当我们把多个用逗号分隔的值赋给一个变量时，多个值会打包成一个元组类型；当我们把一个元组赋值给多个变量时，元组会解包成多个值然后分别赋给对应的变量，如下面的代码所示。

# 打包
a = 1, 10, 100
print(type(a),a)

#解包
i, j, k = a
print(i,j,k)

在解包时，如果解包出来的元素个数和变量个数不对应，会引发ValueError异常，错误信息为：too many values to unpack（解包的值太多）或not enough values to unpack（解包的值不足）。

a = 1, 10, 100, 1000
# i, j, k = a             # ValueError: too many values to unpack (expected 3)
# i, j, k, l, m, n = a    # ValueError: not enough values to unpack (expected 6, got 4)

有一种解决变量个数少于元素的个数方法，就是使用星号表达式，有了星号表达式，我们就可以让一个变量接收多个值，代码如下所示。需要注意的是，用星号表达式修饰的变量会变成一个列表，列表中有0个或多个元素。还有在解包语法中，星号表达式只能出现一次。

a = 1, 10, 100, 1000
i, j, *k = a
print(i, j, k)  

i, *j, k = a
print(i, j, k)   

*i, j, k = a
print(i, j, k)   

*i, j = a
print(i, j)     

i, *j = a
print(i, j)        

i, j, k, *l = a
print(i, j, k, l)    

i, j, k, l, *m = a
print(i, j, k, l, m)    

需要说明一点，解包语法对所有的序列都成立，这就意味着对列表以及我们之前讲到的range函数返回的范围序列都可以使用解包语法。

a, b, *c = range(1, 10)
print(a, b, c)
a, b, c = [1, 10, 100]
print(a, b, c)
a, *b, c = 'hello'
print(a, b, c)

例2：交换两个变量的值

交换两个变量的值是编程语言中的一个经典案例，在很多编程语言中，交换两个变量的值都需要借助一个中间变量才能做到，如果不用中间变量就需要使用比较晦涩的位运算来实现。在Python中，交换两个变量a和b的值只需要使用如下所示的代码。

a = 1
b = 2
a, b = b, a
print(a,b)

a = 3 
b = 4
c = 5
a, b, c = c, a, b
print(a, b, c)

需要说明的是，上面并没有用到打包和解包语法，Python的字节码指令中有ROT_TWO和ROT_THREE这样的指令可以实现这个操作，效率是非常高的。但是如果有多于三个变量的值要依次互换，这个时候没有直接可用的字节码指令，执行的原理就是我们上面讲解的打包和解包操作。

例3.元组和列表的比较

1.元组是不可变类型，不可变类型更适合多线程环境，因为它降低了并发访问变量的同步化开销。关于这一点，我们会在后面讲解多线程的时候为大家详细论述。
2.元组是不可变类型，通常不可变类型在创建时间和占用空间上面都优于对应的可变类型。我们可以使用sys模块的getsizeof函数来检查保存相同元素的元组和列表各自占用了多少内存空间。我们也可以使用timeit模块的timeit函数来看看创建保存相同元素的元组和列表各自花费的时间，代码如下所示。

import sys
import timeit

a = list(range(1000000))
b = tuple(range(1000000))
print(sys.getsizeof(a), sys.getsizeof(b))

print(timeit.timeit('[1,2,3,4,5,6,7,8,9,0]'))
print(timeit.timeit('(1,2,3,4,5,6,7,8,9,0)'))

3.Python中的元组和列表是可以相互转换的，我们可以通过下面的代码来做到

# 将元组转换成列表
info = ('cat', 175, False, 'hot')
print(list(info))       
# 将列表转换成元组
fruits = ['apple', 'banana', 'orange']
print(tuple(fruits))   

总结

列表和元组都是容器型的数据类型，即一个变量可以保存多个数据。列表是可变数据类型，元组是不可变数据类型，所以列表添加元素、删除元素、清空、排序等方法对于元组来说是不成立的。但是列表和元组都可以进行拼接、成员运算、索引和切片这些操作，推荐大家使用列表的生成式语法来创建列表，它很好用，也是Python中非常有特色的语法。