本文介绍了Python中List和Tuple类型的基础知识。List是有序集合，可随时增删改元素，介绍了创建、查看、添加、删除、替换等操作及常用方法；Tuple创建后不能修改，有创建单元素tuple和“可变”tuple的特殊情况。还对比了两者，指出使用场景及存储差异。
文章目录
一、List类型
1. 创建List
list是Python内置的数据结构。list是一种有序的集合，可以随时添加和删除其中的元素。构造list非常简单，按照上面的代码，直接用 [ ] 把list的所有元素都括起来，就是一个list对象。由于Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型。
eg:
L = ["Adam", 95.5, "Lisa", 85, "Bart", 59]
print(L)
运行结果：
['Adam', 95.5, 'Lisa', 85, 'Bart', 59]
注意：
L = []是合法的，表示空List
2. list查看元素
1. 索引访问
和c语言中的数组一样，下标从0开始
eg:
L = [95.5, 85, 59]
print(L[0])
print(L[1])
print(L[2])
结果：
95.5
85
59
注意：L[3]会下标越界，程序出错
2. 倒序索引访问
说明：就是类似c语言中数组下标倒过来，-1表示倒数第一个。
注意：c语言中是不能这样的
eg:
L = [95.5, 85, 59]
print(L[-1])
print(L[-2])
print(L[-3])
结果：
59
85
95.5
3. 切片访问
arr = [1, 2, 3, 4, 5, 6]
print(arr[:3]) # 输出：[1, 2, 3]
print(arr[1:-1]) # 输出：[2, 3, 4, 5]
print(arr[-3:]) # 输出：[4, 5, 6]
4. list添加元素
调用方法的都是改变原List
-
用
append()方法，将一个元素添加到list序列末尾
eg:在列表的末尾添加45L = [95.5, 85, 59] L.append(45) print(L)结果:
[95.5, 85, 59, 45] -
将一个list添加到list序列末尾
-
用
extend方法，将一个list添加到list序列末尾，改变原list
eg:lst = [1, 2] lst.extend([3, 4, 5]) print(lst)结果:
[1, 2, 3, 4, 5] -
用
+，将一个list添加到list序列末尾，不改变原list
eg：a = [1, 2, 3] b = [4, 5] print(a + b)结果：
[1, 2, 3, 4, 5]
-
-
用
insert()方法在已有的任意位置插入元素
eg:在列表的头部插入100L = [95.5, 85, 59] L.insert(0, 100) print(L)结果：
[100,95.5, 85, 59]
5. list删除元素
-
pop()方法总是删掉list的最后 一个元素，并且它还返回这个元素，因此，我们执行 L.pop() 后，会自动打印出要删除的元素。
eg:删除列表中的最后一个元素，即45L = [95.5, 85, 59, 45] a = L.pop() print(a) print(L)结果:
45 [95.5, 85, 59] -
pop()方法传入下标，删除列表指定位置的一个元素，下标从0开始，并返回删除的元素。
eg:删除元素中的第3个元素，即59L = [95.5, 85, 59, 45] a = L.pop(2) print(a) print(L)结果：
59 [955, 85, 45] -
删除指定值的一个元素：
remove(value)方法。参数value改为['a', 'b']形式可以同时删除多个元素。但是注意:这样只能删除第一个指定的值，后面重复的不能删掉
eg：lst = [1, 2, 3, 2, 1] lst.remove(2) print(lst)结果：
[1, 3, 2, 1] -
用
clear()方法，清空整个列表
eg：lst = [1, 2] lst.clear() print(lst)结果：
[]
6. list替换元素
-
先用
pop()方法把该元素删除，再用insert()方法把要添加的元素添加进去 -
对list中的某一个索引赋值，就可以直接用新的元素替换掉原来的元素，list包含的元素个数保持不变。
eg:用90替换调列表中的第三个元素L = [95.5, 85, 59, 45] L[2] = 90 print(L)结果：
[95.5, 85, 90, 45]也可以用
L[-2] = 90，效果一样
7. list其他常用的方法
lst = [1, 2, 1, 3, 4]
# 1. 计算列表中元素为1的个数
print(lst.count(1)) # 输出：2
# 2. 得到列表中第一个值为2的元素的下标
print(lst.index(2)) # 输出：1
# 3. 反转
lst.reverse()
print(lst) # 输出： [4, 3, 1, 2, 1]
# 4. 排序
lst.sort(reverse=True) # 列表元素降序排列
print(lst) # 输出：[4, 3, 2, 1, 1]
# 5. 长度
len(lst) # 输出：4
二、Tuple类型
1. 创建tuple
-
tuple一旦创建完毕，就不能修改了。所以，tuple没有 append()方法，也没有insert()和pop()方法。也就是说没有增删改，只有查的功能：
-
语法：创建tuple和创建list唯一不同之处是用
( )替代了[ ]。
eg：a = (1, 2, 3, 'ace') a[0] = 9 print(a)
注意：获取 tuple 元素的方式和 list 是一模一样的，我们可以正常使用 t[0]，t[-1]等索引方式访问元素，但是不能赋值成别的元素。另外，
L = ()是合法的，表示空tuple。
2. 创建单元素tuple
说明：tuple和list一样，可以包含 0 个、1个和任意多个元素。包含多个元素的 tuple，前面我们已经创建过了。但是，创建单元素 tuple 要多加一个逗号，
eg: 创建一个单元组1
t = (1, )
print(t)
结果：
(1)
如果是：
t = (1, )
则结果为：
1
解释：因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果 (1) 被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。
3. “可变”的tuple
说明：“可变”的tuple指的是tuple里面的一个或多个元素为list，而list中的元素是可以修改的，我们修改list的中的元素，表面上造成了tuple元素的改变。
eg:
t = ('Tom', 'Wang', ['Zhao', 'Li'])
L = t[2]
L[0] = 'Maik'
print(t)
结果:
('Tom', 'Wang', ['Maik', 'Li'])
三、list和tuple的对比
1.元组中的元素是无法修改的，事实上我们在项目中尤其是多线程环境中可能更喜欢使用的是那些不变对象（一方面因为对象状态不能修改，所以可以避免由此引起的不必要的程序错误，简单的说就是一个不变的对象要比可变的对象更加容易维护,更加安全。
另一方面因为没有任何一个线程能够修改不变对象的内部状态，一个不变对象自动就是线程安全的，这样就可以省掉处理同步化的开销。一个不变对象可以方便的被共享访问）。
所以结论就是：如果不需要对元素进行添加、删除、修改的时候，可以考虑使用元组，当然如果一个方法要返回多个值，使用元组也是不错的选择。
2.元组在创建时间和占用的空间上面都优于列表。
3.列表是动态的、可变的，元组是静态的、不可变的。这必然导致了其存储方式的不一样。
lst = []
print(lst.__sizeof__())
t = ()
print(t.__sizeof__())
# 结果：
40
24
可以看到，空的元组和列表，列表要比元组多占用16个字节。8个字节用来存储指针（元组是静态的，不需要指针），另外8个字节用来预留一个元素位置，方便后续添加元素。
lst = []
print(lst.__sizeof__())
lst.append(1)
print(lst.__sizeof__())
lst.append(2)
print(lst.__sizeof__())
lst.append(3)
print(lst.__sizeof__())
lst.append(4)
print(lst.__sizeof__())
lst.append(5)
print(lst.__sizeof__())
# 结果：
40
72
72
72
72
104
可以看见，每次预留的元素位置被占满后，会自动再分配32个字节的空间，也就是4个元素位置。
t = ()
print(t.__sizeof__())
t = (1,)
print(t.__sizeof__())
# 结果：
24
32
可以看见，元组没有预留，这也是其是静态的所导致的。
扫一扫
2212
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
