元组数据类型内置方法

元组数据类型内置方法

元组是不可变的列表，即元组的值不可更改，因此元组一般只用于只存不取的需求。也因此元组可以被列表取代掉，所以元组相比较列表使用的很少。元组相比较列表的优点为：列表的值修改后，列表的结构将会发生改变，而元组只需要存储，因此列表在某种程度上而言需要占用更多的内存。但是目前工业上内存已经不是问题了，所以工业上元组一般不会使用。

一、作用

​ 用于存储多个值，例如多个爱好，多门课程

二、定义方式

在()内可以有多个任意类型的值，逗号分隔元素

元组和列表一模一样，但是元组无法修改，元组在定义那一刻，他的元素个数以及他的值全部都固定了

# 第一种方式
tup = (1, 2, 3, 4, 5) # tup = (1, )
# 第二种方式
tup1 = tuple([1, 3, 4, 5])
print(tup)
print(tup1)

结果：

(1, 2, 3, 4, 5)
(1, 3, 4, 5)

三、常用内置方法

主要方法

1. 索引取值(只能获取值不能，修改值)

   tup = (1, 2, 3, 4, 5)
   print(tup[2])
   

   结果：

   3

2. 切片

tup = (1, 2, 3, 4, 5)

print(tup[2:])
print(tup[::2])

结果：

(3, 4, 5)
(1, 3, 5)

3. 长度len()

   tup = (1, 2, 3, 4, 5)
   print(len(tup))
   

   结果：

   5

4. 成员运算符in 和 not in

   tup = (1, 2, 3, 4, 5)
   print(1 in tup)
   

   结果：

   5

5. for循环

   tup = (1, 2, 3, 4, 5)
   for t in tup:
       print(t)
   

   结果：

   1
   2
   3
   4
   5

6. count

   tup = (1, 2, 3, 4)
   print(tup.count(1))
   

   结果：

   1

7. index

   tup = (1, 2, 3, 4)
   print(tup.index(2))
   

   结果：

   1

四、存在一个值还是多个值

	==多个值==

五、有序 or 无序

​ 有序

六、可变 or 不可变

​ 不可变

七、元组和列表的区别

l = ['a', 'b', 'c']
print(f"id(l[0]): {id(l[0])}")
l[0] = 'A'
print(f"id(l[0]): {id(l[0])}")

id(l[0]): 4357367208
id(l[0]): 4357775176

列表可变的原因是：索引所对应的值的内存地址是可以改变的,列表实质保存的是内存地址，索引对应着一个内存内置，只要索引对应内存地址改变则值就会被改变。

元组不可变得原因是：索引所对应的值的内存地址是不可以改变的，或者反过来说，只要索引对应值的内存地址没有改变，那么元组是始终没有改变的。

t1 = (['a', 'b', 'c'], 'wc', 'office')

print(f"id(t1[0]): {id(t1[0])}")
print(f"id(t1[1]): {id(t1[1])}")
print(f"id(t1[2]): {id(t1[2])}")

t1[0][0] = 'A'
print(f"t1[0][0]: {t1[0][0]}")
print(f"id(t1[0]): {id(t1[0])}")
print(f"t1: {t1}")

id(t1[0]): 205322000
id(t1[1]): 56624736
id(t1[2]): 56624672
t1[0][0]: A
id(t1[0]): 205322000
t1: (['A', 'b', 'c'], 'wc', 'office')

七、总结

7.1 常用操作和方法

1. 索引取值
2. 切片（顾头不顾尾，步长）
3. 长度len
4. 成员运算in和not in
5. 循环
6. count
7. index