day6_python基础内容四——列表

---

前言

Python学习的第6天，今天主要学习基础语法中的列表，主要学习内容包含：列表的概念、如何获取列表元素、列表的增删改操作、in和not in操作、列表相关运算符、列表相关函数、列表相关方法。并补充学习了Python中三目运算符的知识。

---

# 一、列表

列表是Python中常见的容器型数据类型。在Python中，变量可分为非容器型数据类型的变量和容器型数据类型的变量；
非容器型数据类型 — 相当于一个盒子里面只有一个格子，所以同一时间只能保存一个数据。例如：int、float、bool、None
容器型数据类型 — 相当于一个盒子里面有多个格子，每个格子可以存储不一样的数据，所以同一时间就可以保存多个数据。例如：list、dict、set、tuple、str等。
容器型数据类型变量存在的意义：可以批量处理数据，大大提高了效率。
列表属于序列的一种，序列是Python中最基本的数据结构，序列都可以做的操作包括：查、增、删、改、成员判断。

1.列表的概念

1)什么是列表：
列表list是容器型数据类型，将[]中括号作为容器标志，里面多个元素用逗号隔开。
元素：指的是容器中每一个独立的数据
list = [元素1, 元素2, 元素3, 元素4, 元素5,…]

2）容器的特点：从两个角度进行讲解：可变性和有序性
容器的可变性分为：
①可变：可变指的是容器支持增删改操作
②不可变：不可变指的是容器不支持增删改操作
容器的有序性分为：
①有序：容器有序指的是容器支持下标index操作
②无序：容器无序指的是容器不支持下标index操作

3）列表的特点：
①列表是可变的：可变指的是元素的个数、值和顺序可变 — 支持增删改操作
②列表是有序的：容器有序指的是容器支持下标index操作
列表中元素：任何类型的数据都可以作为列表的元素，同一个列表中的元素可以是不同类型的数据。（列表对数据类型没有要求）

2.列表的操作(重点)

2.1查

列表的查即获取列表元素，获取列表元素有三种情况：一是获取单个元素；二是获取部分元素（切片）；三是获取全部元素（遍历）。

2.1.1 获取单个元素

语法：
列表[下标]

说明：
①列表	——	任何结果是列表的表达式，例如：保存列表的变量或者具体的列表数据
②[]	——	方括号，固定写法
③下标	——	下标是有序序列中元素的位置信息。下标：index,下标又叫索引。
            python中有序序列中元素的下标有两种：
           第一种下标值：从前到后下标值从0开始依次增加（正向下标）：index = [0, 1, 2, 3, 4, 5,...]
           第二种下标值：从后往前下标值从-1开始依次减少（负向下标）:index = [..., -5, -4, -3, -2, -1]                       

示例：

list1 = [1, 34, 5, 23]
print(list1[0])     # 获取list1中下标是0的元素---> 1
print(list1[1])     # 获取list1中下标是1的元素---> 34
print(list1[3])     # 获取list1中下标是3的元素(最后一个值)---> 23
print(list1[-1])    # 获取list1中下标是-1的元素(倒数第一个值)---> 23
print(list1[-2])    # 获取list1中下标是-2的元素(倒数第二个值)---> 5

2.1.2 切片 — 获取部分元素（使用最多）

切片的三步骤：

1. 确定是否可以获取到数据，如果开始下标到结束下标的方向和步长对应的方向(步长为正表示从前往后，步长为负表示从后往前)一致，就可以取到数据，否则就是空值。（可以看开始下标值的正负和步长（正负）的正负：同向（同正或者同负）可取到，异向（正负或者负正）取不到）
2. 确定有效范围（位置信息）：开始下标对应的元素可以取到，结束下标对应的元素取不到
3. 确定切片结果：在有效范围内按照步长绝对值取数据；绝对值为1就一个一个的取，绝对值为2就跳一个取一个，绝对值为2就跳两个取一个，绝对值为4就跳三个取一个。

1) 语法1（完整语法）：
列表[开始下标: 结束下标: 步长]

说明：
①取值方向问题：
    开始下标到结束下标的方向和步长对应的方向(步长为正表示从前往后，步长为负表示从后往前)一致，就可以取到数据。
    开始下标到结束下标的方向如果和步长对应的方向不一致，一定取不到数据就是空值。
②步长step：步长为正，从前往后取，正向下标；步长为负，从后往前取，负向下标。
③结束下标值对应的元素取不到。

示例：

#练习1：写出以下表达式的打印结果
heroes = ['李白', '李信', '张飞', '关羽', '刘备', '安琪拉', '瑶', '孙膑']
print(heroes[0:5:2])                # ['李白', '张飞',  '刘备']
print(heroes[1:-2:-1])              # []
print(heroes[2:-2:2])               # ['张飞', '刘备']
print(heroes[-2:0:-3])              # ['瑶', '关羽']
print(heroes[-1:-4:1])              # []
print(heroes[0:6:3])                # ['李白', '关羽']
print("-------------------分割线----------------------")
# 练习2：已知列表heroes = ['李白', '李信', '张飞', '关羽', '刘备', '安琪拉', '瑶', '孙膑']，写切片获取指定内容（应用最多）：
print(heroes[2:5:1])        # ['张飞', '关羽', '刘备']
print(heroes[0:4:1])        # ['李白', '李信', '张飞', '关羽']
print(heroes[-2:-5:-1])     # ['瑶', '安琪拉', '刘备']
print(heroes[1:6:2])        # ['李信',  '关羽',  '安琪拉']
print(heroes[-1:-4:-2])     # ['孙膑', '安琪拉']
print(heroes[1:-1:5])       # ['李信', '瑶']

2）语法2：省略步长
列表[开始下标: 结束下标]      #默认步长为1

3）语法3：省略开始下标    	#默认从列表的最开始元素取（列表的最开始元素由步长的正负确定）
列表[:结束下标]   /   列表[: 结束下标:步长]
①列表[:结束下标]			#默认步长为1   
②列表[: 结束下标:步长]	#如果步长为正，从第一个元素开始往后取，一直取到结束下标对应元素的前一个元素为止；如果步长为负，从倒数第一个元素开始从后往前取，一直取到结束下标对应元素的前一个下标对应元素为止。

4）语法4：省略结束下标    #默认取到列表的最后一个数（列表的最后一个数由步长的正负决定）
列表[开始下标:]   /   列表[开始下标: :步长]   
①列表[开始下标: :步长]   #如果步长为正，从开始下标开始从前往后取，取完为止;如果步长为负，从开始下标开始从后往前取，一直取完结束。
②列表[开始下标:]  		#默认步长为1

5）语法：省略开始下标和结束下标
列表[: : 步长]  			#如果步长为正，从开始下标开始从前往后取，取完为止； 如果步长为负，从开始下标开始从后往前取，取完为止。

# 练习3：已知列表heroes = ['李白', '李信', '张飞', '关羽', '刘备', '安琪拉', '瑶', '孙膑']，写切片获取指定内容（应用最多）：
print(heroes[2:5])          # ['张飞', '关羽', '刘备']
print(heroes[3::-2])        # ['关羽', '李信']
print(heroes[-3::-1])       # ['安琪拉', '刘备', '关羽', '张飞', '李信', '李白']
print(heroes[:-4:2])        # ['李白', '张飞']
print(heroes[1::3])         # ['李信', '刘备', '孙膑']
print(heroes[:-2])          # ['李白', '李信', '张飞', '关羽', '刘备', '安琪拉']

2.1.3 遍历 — 将元素一个一个的全部取出来即获取全部元素（应用也是最多）

方法一：直接获取元素
for循环：
for 变量 in 列表:		#此处变量依次获取的就是列表中的每一个元素
    循环体

方法二：通过获取每个元素的下标来获取元素
for 变量 in range(列表长度):		#此处的变量依次获取的是列表中元素的下标
    循环体

补充：获取列表的长度— len(列表)

示例：

# 练习4：已知学生的分数scores = [90, 78, 54, 67, 88, 30, 59]中保存所有学生的分数：
#1）统计不及格的学生人数
# 2）计算学生平均分
scores = [90, 78, 54, 67, 88, 30, 59]
count = 0
sum1 = 0
average_scores = 0
for x in scores:
    sum1 += x
    average_scores = sum1 / len(scores)
    if x < 60:
        count += 1
print(count, average_scores)

print('------------分割线------------------------')

scores = [90, 78, 54, 67, 88, 30, 59]
count = 0
sum1 = 0
average_scores = 0
for index in range(len(scores)):
    sum1 += scores[index]
    average_scores = sum1 / len(scores)
    if scores[index] < 60:
        count += 1
print("不及格的学生人数:", count, '\n学生平均分:', average_scores)

2.2 增 —— 添加元素

1）追加—— append:追加；添加；附加
语法：列表.append(元素)   —   将小括号中的元素添加到列表中的最后位置

2）插入 —  insert：插入，嵌入
语法：列表.insert(下标, 元素)   —   将小括号中的元素添加到列表中下标对应的元素的前面

列表.append(元素) 示例：

list1 = [1, 2, 3, 4]
print(list1)
# 在列表list1中添加元素11
list1.append(11)
print(list1)

# 练习：scores保存多个学生的分数，提取所有分数中不及格的分数
scores = [90, 78, 65, 45, 55, 89, 99]
new_scores = []
for x in scores:
    if x < 60:
        new_scores.append(x)
print(new_scores)

列表.insert(下标, 元素) 示例：

nums = [10, 23, 30, 40]
print(nums)
# 在nums列表中元素30前插入一个数据100
nums.insert(2, 100)
print(nums)			#[10, 23, 100, 30, 40]

# 练习：已知一个列表，列表中的元素已经从小到大排好序，插入输入的数据，要求插入后不影响顺序。
nums1 = [12, 23, 56, 78, 99, 120]
# 插入80   -> [12, 23, 56, 78, 80, 99, 120]
# 插入2    ->  [2, 12, 23, 56, 78, 99, 120]

value = 98
for index in range(len(nums1)):
    if nums1[index] > value:
        nums1.insert(index, value)
        break
else:
    nums1.append(value)
print(nums1)

2.3 删 —— 删除元素

1)语法1：
del 列表[下标]    — 删除指定下标对应的元素

2)语法1：
列表.remove(元素)   —   删除指定的元素
#如果元素不存在会报错：
#如果列表中有多个相同元素，只删除最前面的那个元素：

3）语法：pop:弹出
列表.pop()    —   取出最后一个元素
列表.pop(下标)  —   取出指定下标对应的元素

示例：

#已知列表tvs = ['海贼王', '大秦帝国', '七龙珠', '还珠格格', '甄嬛传', '大秦帝国', '伪装者', '秦时明月', '亮剑', '大秦帝国']，根据要求输出结果。
tvs = ['海贼王', '大秦帝国', '七龙珠', '还珠格格', '甄嬛传', '大秦帝国', '伪装者', '秦时明月', '亮剑', '大秦帝国']
del tvs[2]
print(tvs)		# ['海贼王', '大秦帝国', '还珠格格', '甄嬛传', '大秦帝国', '伪装者', '秦时明月', '亮剑', '大秦帝国']

tvs.remove('还珠格格')
print(tvs)		#['海贼王', '大秦帝国', '甄嬛传', '大秦帝国', '伪装者', '秦时明月', '亮剑', '大秦帝国']

tvs.remove('大秦帝国')
print(tvs)		#['海贼王', '甄嬛传', '大秦帝国', '伪装者', '秦时明月', '亮剑', '大秦帝国']

tvs.pop()
print(tvs)		#['海贼王', '甄嬛传', '大秦帝国', '伪装者', '秦时明月', '亮剑']

tvs.pop(1)
print(tvs)		#['海贼王', '大秦帝国', '伪装者', '秦时明月', '亮剑']

del、remove和pop的区别：
del、remove是将列表中的元素彻底删除，内存中再也没有该元素了；
pop相当于将列表中的元素移出该列表，但是该元素没有消失，仅仅只是移出该列表，该元素还存在。

2.4 改 —— 修改元素

修改列表中的元素的值，其它元素以及下标不动。
语法：

列表[下标] = 值          —   将列表中指定下标对应的元素改成指定的值

示例：

# 练习：将scores中所有不及格的分数改为0分：
scores = [90, 34, 89, 55, 88]
for index in range(len(scores)):
    if scores[index] < 60:
        scores[index] = 0
print(scores)

练习：

#已知最喜爱的电影列表favorite_movies = ['放牛班的春天', '长津湖', '战狼', '环太平洋', '金刚']，根据以下要求进行操作打印。
favorite_movies = ['放牛班的春天', '长津湖', '战狼', '环太平洋', '金刚']
favorite_movies[0] = '刺客信条'  #将下标0对应的元素‘放牛班的春天’改成元素‘刺客信条’
print(favorite_movies)    # ['刺客信条', '长津湖', '战狼', '环太平洋', '金刚']
favorite_movies.append('速度与激情8')   #追加'速度与激情8'
print(favorite_movies)      #['刺客信条', '长津湖', '战狼', '环太平洋', '金刚', '速度与激情8']
favorite_movies.insert(2, '雪国列车')   #在下标为2的对应元素的前面插入'雪国列车'
print(favorite_movies)       # ['刺客信条', '长津湖', '雪国列车', '战狼', '环太平洋', '金刚', '速度与激情8']
del favorite_movies[-1]     # 删除下标-1的对应元素
print(favorite_movies)      # ['刺客信条', '长津湖', '雪国列车', '战狼', '环太平洋', '金刚']
favorite_movies.remove('环太平洋')      #删除指定元素'环太平洋'
print(favorite_movies)     # ['刺客信条', '长津湖', '雪国列车', '战狼', '金刚']
favorite_movies.pop()       # 删除最后一个元素
print(favorite_movies)      # ['刺客信条', '长津湖', '雪国列车', '战狼']
favorite_movies.pop(0)      #删除下标0的对应元素
print(favorite_movies)      # ['长津湖', '雪国列车', '战狼']

2.5 in操作 —— 成员判断

元素 in 列表 — 判断列表中是否存在指定的元素
元素 not in 列表    —   判断列表中是否不存在指定的元素

判断的结果为True和False

3.列表相关

3.1 列表相关的运算符

1.数学运算符：+ 、 *
1）加 + —— 用于两个列表的拼接，实现将两个列表中的元素合并产生一个新的列表

语法：列表1 + 列表2

2）乘 * —— 实现将列表中的元素重复多次形成新的列表

语法：列表 * N   /   N * 列表
#（N为正整数）
#列表中的元素重复N次产生一个新的列表

2.比较运算符：（比较大小的数据其数据类型要一致）
补充：不同的类型可以使用 == 和 != 来比较是否相等，但是不能使用< 、> 、>= 、<= 来比较大小

1. == 、!=

2. < > >= <=
   两个列表比较大小，比较的是第一对(下标相等)不相等的元素的大小

print([12, 34, 45, 57] > [23, 34, 56, 66])          # False
print([12, 34, 45, 57] > [12, 34, 35, 66])              # True

3.2 列表相关函数

3.2.1 max、 min — 最大值、最小值

max(序列)   —   获取序列中最大的元素
min(序列)   —   获取序列中的最小元素

要求：序列中的元素可以比较大小，元素的数据类型要一致

3.2.2 sum — 求和函数

sum(数字序列)     —   求序列中所有的元素的和

3.2.3 sorted — 排序

sorted(序列)     ——将序列中的元素从小到大排序（升序），产生一个新的列表。
sorted(序列, reverse=True) ——将序列中的元素从大到小排序（降序），产生一个新的列表。

3.2.4 len

len(序列)       —   获取序列中的元素的个数（获取序列的长度）

3.2.4 list — 类型转换

list(序列)    —— 所有的序列都可以转换成列表，将序列的元素作为列表的元素创建一个新的列表

3.3 列表相关方法

#方法1：
列表.clear()	————清空列表

#方法2：
列表.copy()		————复制列表产生一个一模一样的新列表，此处的copy只是复制列表中的值，copy后产生的列表其地址与原列表的地址不同。
#①列表.copy()  —  浅拷贝
#②列表[:]、列表*1、列表+[]	——	都是浅拷贝

#方法3：
列表.count(元素)		————统计列表中指定元素的个数

#方法4：
列表.extend(序列)	————将序列中的元素全部添加到列表中(批量添加)
# 列表.append()	————只添加一个元素

#方法5：
列表.index(元素)		————获取元素在列表中的下标值（返回正向下标值）
# 1）情况一：如果元素在列表中有多个，列表.index(元素)只返回第一个出现的元素
# 2）情况二：如果元素不在列表中，列表.index(元素)则会报错

#方法6：
列表.reverse()        ——    列表逆序，不会产生新的数据

#方法7：
列表.sort()		————排序
# 列表.sort()	————从小到大排序（升序）
# 列表.sort(reverse=True)	————从大到小排序（降序）

3.4 列表推导式

列表推导式快速创建列表的表达式。

3.4.1 推导式结构1

[表达式 for 变量 in 序列]    ————让变量在序列中取值，一个一个的取，取完为止，每取一个值就将表达式的值作为列表的一个元素。
#此处的表达式一般和变量相关

示例

# 练习1：使用列表推导式获取nums中所有元素的个位数
nums = [23, 89, 90, 56, 41, 802]
new_nums = [x % 10 for x in nums]
print(new_nums)		# [3, 9, 0, 6, 1, 2]

# 练习2：是用列表推导式将nums中所有的元素乘以10
# [230, 890, 900, 560, 410, 8020]
nums = [23, 89, 90, 56, 41, 802]
new_nums1 = [i * 10 for i in nums]
print(new_nums1)		# [230, 890, 900, 560, 410, 8020]

# 练习3：已知分数列表，将列表中的元素全部换成'及格' - True 或者'不及格'-False
# ['及格', '及格', '不及格', '及格', '不及格', '及格']
# [True, True, False, True, False, True]
scores = [90, 78, 45, 67, 39, 89]
new_scores = [x >= 60 for x in scores]
print(new_scores)	# [True, True, False, True, False, True]
# 三目运算符:根据条件二选一
new_scores1 = ['及格' if x >= 60 else '不及格' for x in scores]
print(new_scores1)	#['及格', '及格', '不及格', '及格', '不及格', '及格']

3.4.2 推导式结构2

[表达式 for 变量 in 序列 if 条件语句]     ————让变量在序列中取值，一个一个地取，取完为止，每取一个值就判断条件语句是否为True，如果为True就计算表达式的结果为列表的元素。

示例：

# 练习1：使用列表推导式提取nums中所有的奇数
nums = [23, 89, 90, 56, 41, 802]
result = [x for x in nums if x % 2]
print(result)		# [23, 89, 41]

# 练习2：已知一个列表，提取列表中所有的字符串
list1 = [10, 23.9, 'hello', True, '12', 0]
result1 = [i for i in list1 if type(i) == str]
print(result1)		# ['hello', '12']

# 练习3：已知一个列表，提取列表中所有的整数，并且将整数加3
list1 = [10, 23.9, 'hello', True, '12', 0]
list2 = [x+3 for x in list1 if type(x) == int]
print(list2)		#[13, 3]

三目运算符：
在python中三目运算符的语法：

值1 if 表达式 else 值2      —     如果表达式的值为True结果就是值1，否则结果就是值2

---

总结

今日学习列表及其相关知识，在python中列表和元组是应用较多的序列。系统的学习将为今后学习其它数据结构打下基础。对于文中出现的语法需要多记多记，以便能够在应用时拿得出来。