元组tuple

列表是可变序列 可以任意修改 可以进行增加修改删除和查找

而元组是不可变序列 不能任意修改元组中的元素 只有查找

元组创建

()创建

a = (10,20,30)
b = 40,50,60
c = (100,)
print(type(a))
print(type(b))
print(type(c))
# <class 'tuple'>
# <class 'tuple'>
# <class 'tuple'>
d = (100)
print(type(d))
# <class 'int'>

tuple()创建

print(tuple())
print(tuple("abc"))
print(tuple(range(3)))
print(tuple([2,3,4]))
# ()
# ('a', 'b', 'c')
# (0, 1, 2)
# (2, 3, 4)
# tuple()可以接收列表字符串其他序列类型迭代器等生成元组

 元组元素访问与计数

元组元素不可以修改但是访问计数和切片与列表类似

a = (20,10,30,9,8)
print(a[2])
# 30
# a[2] = 333    # 因为元组不支持修改所以这里会产生报错
print(a.index(30))
print(a.count(30))
print(a[1:4])
# 2
# 1
# (10, 30, 9)

元组排序

列表中的list.soted()修改原列表对象 但元组只能使用内置函数sorted(tupleObj)生成新的列表对象 

a = (20,10,30,9,8)
b = sorted(a)
print(type(b))
print(b)
# <class 'list'>
# [8, 9, 10, 20, 30]

排序了但是生成的是列表对象

 zip()

# zip()将多个列表对应位置元素组合成为元组，并返回这个zip对象，如果迭代器元素个数不同，返回最短的
a = (10,20,30)
b = (40,50,60)
c = (70,80,90,100)
d = zip(a,b,c)
print(d)
# <zip object at 0x0000020A9FD2E340>   # 这里生成的是一个zip对象
e = list(d)
print(e)
# [(10, 40, 70), (20, 50, 80), (30, 60, 90)]

生成器推导式创建元组

1. 形式上与列表推导式类似 只是这个使用小括号
2. 列表推导式直接生成列表对象 但是这个生成一个生成器对象既不是列表对象也不是元组对象
3. 可以通过生成器对象进行迭代或遍历 但是只能进行一次

a = [x for x in range(5)]
print(a)
# [0, 1, 2, 3, 4]
b = (x for x in range(5))
# <generator object <genexpr> at 0x000002BEC2D3CE80>
print(b)
c = tuple(b)
print(c)
d = tuple(b)
print(d)
# (0, 1, 2, 3, 4)
# ()        # 只能用一次 第二次就会返回空的
# 当然如果想通过生成器对象生成列表对象 就用list 来生成就可以

__next__()

e = (x for x in range(3))
print(e.__next__())
print(e.__next__())
print(e.__next__())
print(e.__next__())
# 0
# 1
# 2
# StopIteration      # 因为指针一个一个偏移 没有第四个元素了 所以会报错

元组总结

1. 元组不可变 只可以访问和查找
2. 元组访问与查找的速度比列表快
3. 与整数和字符串一样，元组可以作为字典的键，列表则永远不可以作为字典的键使用