- 👨💻作者简介: 大家好,我是小火车~~
- 🛳️个人主页: 上进小火车的博客
- 📗系列专栏: 本文收藏在《Python基础从0到1》专栏
- ✉️如果文章知识点有错误的地方,请指正! 和大家一起学习一起进步🎈
- 🔥如果觉得博主的文章还不错的话,请👍三连支持👍一下博主哦
- ➡️各系列思维导图链接
Python列表和元组
一🥖.列表定义
列表是Python中内置有序可变序列，列表的所有元素放在一对中括号“[]”中，并使用逗号分隔开；
一个列表中的数据类型可以各不相同，可以同时分别为整数、实数、字符串等基本类型，甚至是列表、字典以及其他自定义类型的对象。
[1,2,3,2.4,5]
[0.01,"zhangsan",[1,2,3]]
创建
- 使用“=”直接将一个列表赋值给变量即可创建列表对象。例如：a_list = []，b_list = [1，2,3]
- 使用list()函数将元组、range对象、字符串或其他类型的可迭代对象类型的数据转换为列表。
例如：a_list = list(“Hello”) 将字符串 “hello” 转换成列表 [‘H’，‘e’，‘l’，‘l’，‘o’]
删除
>>>x =[1,2,3]
>>>del x[1] #删除指定位置元素
>>>x
-----------------------------------------------------------
[1，3]
当不再使用时，使用del命令删除整个列表 例如：
>>>del x #删除整个列表
>>>x
Traceback (most recent call last):
File "<pyshell#6>", line 1, in <module>
x
NameError: name 'x' is not defined
二🍔.列表元素的增加
2.1 append()
向列表尾部追加一个元素，不改变其内存首地址，属于原地操作。 例如：
>>>x = [1,2,3]
>>>x.append(4)
>>>x
[1,2,3,4]
2.2 insert()
向列表任意位置插入一个元素，不改变其内存首地址，属于原地操作。
例如：
>>>x = [1,3,4]
>>>x.insert(1,2)
>>>x
[1,2,3,4]
2.3 extend()
将另一个迭代对象的所有元素添加至该列表对象尾部，不改变其内存首地址，属于原地操作。
例如：
>>>x = [1,2]
>>>x.extend([3,4])
>>>x
[1,2,3,4]
2.4 运算符" + " 和" * "
并不是真的为列表添加元素，而是创建一个新列表,不属于原地操作，而是返回新列表。
>>> x = [1,2,3]
>>>y = x + [4]
>>>y
[1,2,3,4]
>>>y = x*2
>>>y
[1,2,3,4,1,2,3,4]
此时x保持不变，依旧是[1,2,3]
三🥪.列表元素的删除
3.1 pop()
使用列表的pop()方法删除并返回指定（默认为最后一个）位置上的元素，如果给定的索引超出了列表的范围则抛出异常。
>>>x = [1,2,3,4]
>>>x.pop() #弹出并返回尾部元素
4
>>>x.pop(1) #弹出并返回指定位置的元素
>>>2
3.2 remove()
删除首次出现的指定元素，如果列表中不存在要删除的元素，则抛出异常。
例如：
>>>x = [1,2,2,3,4]
>>>x.remove(2)
>>>x
[1,2,3,4]
3.3 clear()
清空列表。
例如：
>>>x = [1,2,3,4]
>>>x.clear()
>>>x
[ ]
3.4 del
删除列表中的指定位置上的元素。
例如：
>>>x = [1,2,3,4]
>>>del x[1]
>>>x
[1,3,4]
四🍞.列表元素访问与计数
4.1 count()
统计指定元素在列表对象中出现的次数。
例如：
>>> x =[1,2,3,3,4,5]
>>>x.count(3)
2
>>>x.count(0)
0
4.2 index()
获取指定元素首次出现的下标，若列表对象中不存在指定元素，则抛出异常。
例如：
>>>x = [1,2,3,2,2,4]
>>>x.index(2)
1
4.3 in
测试列表中是否存在某元素
例如：
>>>x = [1,2,3,4]
>>>3 in x
True
>>>5 in x
False
五🥮.列表排序
5.1 sort()
按照指定规则对所有元素进行排序，默认规则是直接比较规则大小。
例如：
>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]
>>> import random
>>> random.shuffle(aList) #随机降序
>>> aList
[3, 4, 15, 11, 9, 17, 13, 6, 7, 5]
>>> aList.sort() #默认是升序排序
>>> aList.sort(reverse = True) #降序排序
>>> aList
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
5.2 reverse()
将列表中所有元素原地逆序排列。
例如：
>>>x = [1,3,2,4,6,5]
>>>x.reverse()
>>>x
[5,6,4,2,3,1]
5.3 sorted()
使用内置函数sorted对列表进行排序并返回新列表，不对原列表做任何修改。
例如：
>>>x = [6,4,2,4,1]
>>> sorted(x) #升序排序
[1,2,4,4,6]
>>> sorted(aList,reverse = True) #降序排序
[6,4,4,2,1]
>>>x
[6,4,2,4,1]
5.4 reversed()
返回一个逆序排列后的迭代对象，不对原列表做任何修改。
>>>x =[1,5,3,6,2]
>>>list(reversed(x))
[2,6,3,5,1]
>>>x
[1,5,3,6,2]
六🍰.用于序列操作的常用内置函数
6.1 len()
返回列表中的元素个数，同样适用于元组、字典、集合、字符串等。
6.2 max()、 min()
返回列表中的最大或最小元素，同样适用于元组、字典、集合、range对象等。
6.3 sum()
对列表的元素进行求和运算。
6.4 zip()
返回可迭代的zip对象。
例如：
>>> aList = [1, 2, 3]
>>> bList = [4, 5, 6]
>>> cList = zip(a, b) #返回zip对象
>>> cList
<zip object at 0x0000000003728908>
>>> list(cList) #把zip对象转换成列表
[(1, 4), (2, 5), (3, 6)]
6.5 enumerate()
返回可迭代的zip对象。
例如：
>>> aList = [1, 2, 3]
>>> bList = [4, 5, 6]
>>> cList = zip(a, b) #返回zip对象
>>> cList
<zip object at 0x0000000003728908>
>>> list(cList) #把zip对象转换成列表
[(1, 4), (2, 5), (3, 6)]
七🫕.遍历列表和列表推导式
7.1 遍历列表的三种方式
a = ['a','b','c','d','e','f']
for i in a:
print(i)
for i in range(len(a)):
print(i,a[i])
for i,ele in enumerate(a):
print(i,ele)
7.2 列表推导式
列表推导式使用非常简洁的方式来快速生成满足特定需求的列表，代码具有非常强的可读性。
语法形式：
[表达式 for 变量 in 序列或迭代对象]
列表推导式在逻辑上相当于一个循环，只是形式更加简洁。
lis = [i for i in range(100)]
print(lis)
使用列表推导式实现嵌套列表的平铺
>>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
相当于：
>>> vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> result = []
>>> for elem in vec:
for num in elem:
result.append(num)
>>> result
[1, 2, 3, 4, 5, 6, 7, 8, 9]
过滤不符合条件的元素 从列表中选择符合条件的元素组成新的列表
>>> aList = [-1,-4,6,7.5,-2.3,9,-11]
>>> [i for i in aList if i>0]
[6, 7.5, 9]
在列表推导式中使用多个循环，实现多序列元素的任意组合，并且可以结合条件语句过滤特定元素
>>> [(x, y) for x in range(3) for y in range(3)]
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
>>> [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
列表综合练习
写一个循环，不断的问用户想买什么，用户选择一个商品编号，就把对应的商品添加到购物车里，最终用户输入q退出时，打印购物车里的商品列表
products = [['iphone',6888],['三星',3000],['小米',2500]]
shopping_car = []
flag = True
while flag:
print("******商品列表******")
for index,i in enumerate(products):
print("%s. %s| %s" %(index,i[0],i[1]))
choice = input("请输入您想购买的商品的编号：")
if choice.isdigit():#isdigit()判断变量是什么类型
choice = int(choice)
if choice>=0 and choice<len(products):
shopping_car.append(products[choice])
print("已经将%s加入购物车" %(products[choice]))
else:
print("该商品不存在")
elif choice == "q":
if len(shopping_car)>0:
print("您打算购买以下商品：")
for index,i in enumerate(shopping_car):
print("%s. %s| %s" %(index,i[0],i[1]))
else:
print("您的购物车中没有添加商品")
flag = False
八🍡.列表切片
列表元素支持用索引访问，正向索引从0开始
colors=["red","blue","green"]
print(colors[0])
print(colors[1])
---------------------------------
red
blue
同时，也可以使用负向索引(python中有序序列都支持负向索引)
print(colors[-1])
---------------------------------
green
8.1 列表的切片操作
切片操作不是列表特有的，python中的有序序列都支持切片，如字符串，元组。
切片的返回结果类型和切片对象类型一致，返回的是切片对象的子序列，如：对一个列表切片返回一个列表，字符串切片返回字符串。
li=["A","B","C","D"]
格式： li[start : end : step]
start是切片起点索引，end是切片终点索引，但切片结果不包括终点索引的值。step是步长默认是1。
t=li[0:3] ["A","B","C"] #起点的0索引可以省略，t=li[:3]
t=li[2: ] ["C","D"] #省略end，则切到末尾
t=li[1:3] ["B","C"]
t=li[0:4:2] ["A","C"] #从li[0]到li[3],设定步长为2。
如何确定start和end，他们是什么关系？ 在step的符号一定的情况下，start和end可以混合使用正向和反向索引，无论怎样，你都要保证 start和end之间有和step方向一致元素 间隔，否则会切出空列表
t=li[0:2]
t=li[0:-2]
t=li[-4:-2]
t=li[-4:2]
上面的结果都是一样的；t为[“A”,“B”]
t=li[-1:-3:-1]
t=li[-1:1:-1]
t=li[3:1:-1]
t=li[3:-3:-1]
上面的结果都是一样的；t为[“D”,“C”]
t=li[-1:-3]
t=li[-1:1]
t=li[3:1]
t=li[3:-3]
都切出空列表
同时，step的正负决定了切片结果的元素采集的先后
省略start 和 end表示以原列表全部为目标
t=li[::-1] t--->["D","C","B","A"] #反向切，切出全部
t=li[:] t--->["A","B","C","D"] #正向切全部
8.2 使用切片来原地修改列表内容
>>> aList = [3, 5, 7]
>>> aList[len(aList):] = [9] #在尾部追加元素
>>> aList
[3, 5, 7, 9]
>>> aList[:3] = [1, 2, 3] #替换前3个元素
>>> aList
[1, 2, 3, 9]
>>> aList[:3] = [] #删除前3个元素
>>> aList
[9]
8.3 使用del与切片结合来删除列表元素
>>> aList = [3,5,7,9,11]
>>> del aList[:3] #删除前3个元素
>>> aList
[9, 11]
>>> aList = [3,5,7,9,11]
>>> del aList[::2] #删除偶数位置上的元素
>>> aList
[5, 9]
8.4 切片返回的是列表元素的浅复制
所谓浅复制，是指生成一个新的列表，并且把原列表中所有元素的引用都复制到新列表中。
例如：
>>> aList = [3, 5, 7]
>>> bList = aList #bList与aList指向同一个内存
>>> bList
[3, 5, 7]
>>> bList[1] = 8 #修改其中一个对象会影响另一个
>>> aList
[3, 8, 7]
>>> aList == bList #两个列表的元素完全一样
True
>>> aList is bList #两个列表是同一个对象
True
>>> id(aList) #内存地址相同
19061816
>>> id(bList)
19061816
>>> aList = [3, 5, 7]
>>> bList = aList[::] #切片，浅复制
>>> aList == bList #两个列表的元素完全一样
True
>>> aList is bList #但不是同一个对象
False
>>> id(aList) == id(bList) #内存地址不一样
False
>>> bList[1] = 8 #修改其中一个不会影响另一个
>>> bList
[3, 8, 7]
>>> aList
[3, 5, 7]
九🧀. 元组
元组属于不可变序列（元素集合），一旦创建，用任何方法都不可以修改其元素。从形式上，元组的所有元素放在一对圆括号中，元素之间用逗号分隔。
9.1 元组的创建与删除
创建 使用“=”将一个元组赋值给变量
例如：
>>>x = (1,2,3) #直接把元组赋值给一个变量
>>>x
(1,2,3)
创建只有一个元素的元组
x =(3)
print(type(x))
x =(3,)
print(type(x))
输出
<class 'int'>
<class 'tuple'>
创建空元组的方法
>>>x = () #空元组
>>>x
()
>>>x = tuple() #空元组
>>>x
()
使用tuple函数将其他序列转换为元组
>>>tuple(range(5))
(0,1,2,3,4)
>>> tuple('abcdefg') #把字符串转换为元组
('a', 'b', 'c', 'd', 'e', 'f', 'g')
>>> aList
[-1, -4, 6, 7.5, -2.3, 9, -11]
>>> tuple(aList) #把列表转换为元组
(-1, -4, 6, 7.5, -2.3, 9, -11)
删除 使用del可以删除元组对象，不能删除元组中的元素
9.2元组与列表的区别
- 元组中的数据一旦定义就不允许更改。
- 元组没有append()、extend()和insert()等方法，无法向元组中添加元素。
- 元组没有remove()或pop()方法，也无法对元组元素进行del操作，不能从元组中删除元素。
- 从效果上看，tuple( )冻结列表，而list( )融化元组。
9.3 元组的优点
- 元组的速度比列表更快。
- 元组对不需要改变的数据进行“写保护”将使得代码更加安全。
- 元组可用作字典键（特别是包含字符串、数值和其它元组这样的不可变数据的元组）。元组有时还作为函数的返回值返回（返回多个值）。
十🥧.其他专栏
❤️《Python基础从0到1》专栏
🧡《Python进阶从0到1》专栏
💛《Python爬虫》专栏
💚《Python数据处理》专栏
316
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
