python 列表与元组 详解

索引

学习之前 先介绍一下索引在python中 有两种索引模式
正向索引：从左到右，起始位置 0
反向索引：从右到左，起始位置 -1

正向索引

反向索引

列表

列表是 Python 中最基本、最常见的数据结构。
列表中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。
列表都可以进行的操作包括索引，切片，加，乘，检查成员。

常见方法

方法	介绍
list.append(obj)	在列表末尾添加新的对象
list.count(obj)	统计某个元素在列表中出现的次数
list.extend(seq)	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)	从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)	将对象插入指定位置
list.pop([index=-1])	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)	移除列表中某个值的第一个匹配项
list.reverse()	反向列表中元素
list.sort( key=None, reverse=False)	对原列表进行排序
list.clear()	清空列表
list.copy()	复制列表

函数

函数	介绍
len(list)	列表元素个数
max(list)	返回列表元素最大值
min(list)	返回列表元素最小值
list(seq)	将元组转换为列表

举例

实例-增

增加元素
 - append(item):将item添加到列表的最后位置。	
 - insert(pos,item):将item插入的指定位置。
 - pos如果超过最大索引，将item插入最后位置 	
 - pos如果小于最小索引，将item插入到最开始位置
 - extend(iterable):将序列内元素全部插入到尾部

举例

names = ['zs','ls','ww']
# 新增同学ml
names.append("ml")
print(names) # ['zs','ls','ww','ml'] #将内容追加到列表后

names.insert(0,'ml')
print(names) # ['ml', 'zs', 'ls', 'ww', 'ml']将ml插入到第一个位置
names.insert(1000,'111')
print(names)#['ml', 'zs', 'ls', 'ww', 'ml', '111'] 如果超过最大索引，将item插入最后位置
names.insert(-1000,'111')
print(names) #['111', 'ml', 'zs', 'ls', 'ww', 'ml', '111'] 在开始位置插入

names.extend([1,2,3,4]) 
print(names)# ['111', 'ml', 'zs', 'ls', 'ww', 'ml', '111', 1, 2, 3, 4]追加另一个序列
names.extend(range(1,100))
print(names) #['111', 'ml', 'zs', 'ls', 'ww', 'ml', '111', 1, 2, 3, 4, 1, 2, 3, 4, 5, 6,...]

实例-删

已知索引删元素,返回被删除的元素
 - pop():删除最后一个元素 	
 - pop(index):删除指定位置的元素。
 - 已知元素删元素：remove(item)：删除第一次满足条件的指定元素，不存在会报错 
 - del 待删的对象，不属于列表特有
 - clear：清空列表，只剩空列表

举例

li = [1,2,3,4,5,6,2]

# pop
# 删除最后一个元素 	
li.pop()  
print(li) # [1, 2, 3, 4, 5, 6]
# 删除指定位置元素
li.pop(3) # 
print(li) #删除元素4 [1, 2, 3, 5, 6]
li.pop(100) # 报错，索引错误
print(li)

# # remove
li.remove(3)
print(li) # 删除元素3本身 [1, 2, 5, 6]
li.remove(10) # 错误，元素不存在
li.remove(2)
print(li)# 删除第一次出现的元素 2 [1, 5, 6]

# del
del li[2]
print(li) #删除下标是2的元素[1, 5]
li = [1,2,3,4,5,6,2]
del li[1:3] # 删除元素2，3
print(li) #[1, 4, 5, 6, 2]
del li # 删除列表li

# clear
li = [1,2,3,4,5,6,2]
li.clear() # []
print(li)

实例-改

通过操作来实现修改
 - 列表名[index] = new_value 	
 - reverse():列表倒序
 - sort():按照Unicode编码排序,同种类型才可以比较

举例

li = [1,2,3,4,5,6,2]
li[2] = 30
print(li) # 修改下标是2的内容[1, 2, 30, 4, 5, 6, 2]

# reverse() 列表倒序
li.reverse()
print(li) #反转列表  [2, 6, 5, 4, 30, 2, 1]

# sort 按照Unicode编码排序,同种类型才可以比较
li.sort()
print(li) #对原列表进行排序,按照Unicode编码排序,[1, 2, 2, 3, 4, 5, 6]
li2 = ['a','w','e','g']
li2.sort()
print(li2) # ['a','e','g','w']
li3 = ['你','好','大家好']
li3.sort()
print(li3) #['你', '大家好', '好']

实例-查

已知索引查元素： 列表名[index]
已知元素查索引：index(item):将第一个满足条件元素的索引值返回。（保证元素在列表中）
count(item):统计item在列表中出现的次数

li = [1,2,3,4,5,6,2]
p = li.index(2)
print(p) # 返回元素下标 1
li.index(10) # 报错

#count  统计在列表种出现的次数
print(li.count(10)) #0
print(li.count(2))#2
print(li.count(3))#1

元组

定义：元组是一个不可修改的,元素以逗号分隔的以小括号包围的有序序列。
特点：不可修改，有序的，序列。
格式： 元组名= (item1,item2,...)
由于元组不可改变，故没有增加和删除的方法

注意

空元组可以直接写一对圆括号 () ,
如果表示只包含 一个元素的元组，该元素后必	须添加逗号。

举例

t1 = () # 空元组
t2 = (1,) # 包含一个元素的元组
t3 = (1) # 仅表示数字1，不是元组类型

内置方法

方法	介绍
len(tuple)	计算元组元素个数。
max(tuple)	返回元组中元素最大值。
min(tuple)	返回元组中元素最小值。
tuple(iterable)	将可迭代系列转换为元组。

元组运算符

符号	介绍	举例
+	连接	(1, 2, 3) + (4, 5, 6)
*	复制	（1，）*5
in、not in	成员运算符	判断值是否在元组内

#创建方式
t1 = (1, 10.31, 'python')
t2 = 1, 10.31, 'python'
print(t1, type(t1)) # (1, 10.31, 'python') <class 'tuple'>
print(t2, type(t2)) # (1, 10.31, 'python') <class 'tuple'>

#索引和切片
tuple1 = (1, 2, 3, 4, 5, 6, 7, 8)
print(tuple1[1])  # 2
print(tuple1[5:])  # (6, 7, 8)
print(tuple1[:5])  # (1, 2, 3, 4, 5)
tuple2 = tuple1[:]
print(tuple2)  # (1, 2, 3, 4, 5, 6, 7, 8)

#更新和删除
week = ('Monday', 'Tuesday', 'Thursday', 'Friday')
week = week[:2] + ('Wednesday',) + week[2:]
print(week)  # ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday')

总结

不同点

基础

1：列表是动态的，长度大小不固定，可以随意地增加、删减或者改变元素。
2：元组是静态的，长度大小固定，无法增加删减或者改变。

存储方式

l = [1,2,3,4]
print(l.__sizeof__()) #72
tup = (1,2,3,4)
print(tup.__sizeof__())#56
"""
可以看出 元组的存储空间比列表小16字节
"""

原因

由于列表是动态的，所以它需要存储指针，来指向对应的元素（上述例子中，对于 int 型，8 字节）。
另外，由于列表可变，所以需要额外存储已经分配的长度大小（8 字节），这样才可以实时追踪列表空间的使用情况，当空间不足时，及时分配额外空间。

深入

#列表
l = []
print(l.__sizeof__())  #空列表的存储空间为40字节
t = ()
print(t.__sizeof__()) #空列表的存储空间为24字节
l.append(1)
print(l.__sizeof__())#72 加入了元素1之后，列表为其分配了可以存储4个元素的空间
l.append(2)
print(l.__sizeof__())#72
l.append(3)
print(l.__sizeof__())#72
l.append(4)
print(l.__sizeof__())#72
l.append(5)
print(l.__sizeof__())#104 加入元素5之后，列表的空间不足，所以又额外分配了可以存储4个元素的空间

#元组
t = ()
print(t.__sizeof__()) #空列表的存储空间为24字节
t =(1,)
print(t.__sizeof__()) #空列表的存储空间为32字节
t =(1,2)
print(t.__sizeof__()) #空列表的存储空间为40字节
t =(1,2,3)
print(t.__sizeof__()) #空列表的存储空间为48字节

说明

上面的例子，大概描述了列表空间分配的过程。
我们可以看到，为了减小每次增加 / 删减操作时空间分配的开销，Python 每次分配空间时都会额外多分配一些，这样的机制保证了其操作的高效性：增加 / 删除的时间复杂度均为 O(1)。
但是对于元组，情况就不同了。元组长度大小固定，元素不可变，所以存储空间固定。

相同点

• Python 中的列表和元组都支持负数索引
• 列表和元组都支持切片操作
• 列表和元组都可以随意嵌套
• 两者也可以通过 list() 和 tuple() 函数相互转换

最后

列表和元组的性能

元组要比列表更加轻量级一些，所以总体上来说，元组的性能速度要略优于列表。

列表和元组的使用场景

如果存储的数据和数量不变，选用元组更合适。
如果存储的数据或数量是可变的，则用列表更合适。