05 列表

目录

 一、列表

1. 什么是列表（list）

2. 列表的语法

3. 列表的作用

二、列表的查操作

1. 查单个

2. 切片

① 完整语法

② 省略写法 

3. 遍历

① 语法

 ② 逆序输出列表（重点）

三、列表的增删改

1. 函数速查

2. 增 - 增加元素

3. 删 - 删除元素

4. 改 - 修改元素

四、列表相关操作

1. 数学运算（+、*）

2. 比较运算

3.  in和not in

4. 列表相关函数（其他容器数据也适用）

5. 列表相关方法

五、列表推导式

---

 一、列表

1. 什么是列表（list）

1）列表是python自带的容器型数据类型，将[ ]作为容器的标志，里面多个元素(数据)用逗号隔开：

[数据1, 数据2, 数据3, ...]

2）容器特点

列表是可变的(可变指的是元素的个数和元素的值可变)-支持增删改；

列表是有序的(顺序影响结果，并且支持索引操作)

3）列表对元素的要求

列表对元素没有要求，任何数据都可以作为列表的元素

列表和元组唯一的区别是：列表[]可变（增删改）。而元组()不可变

# 1）
# 列表是有序的
print([10, 20, 30] == [20, 10, 30])    # False
# 集合是无序的
print({10, 20, 30} == {20, 10, 30})    # True

# 2）空列表
list1 = []

# 3)任何数据都可以是列表的元素
list2 = [10, 2.3, True, 'abc', [10, 20], {'a': 10, 'b': 20}, {1, 2}]
print(list2)

2. 列表的语法

1) 具有数据的列表：变量 = [数据1, 数据2, 数据3, 数据4......]

2) 空列表：① 变量 = list()   ② list1 = [ ]

    通过[] 定义一个列表或者使用list()内置方法生成。

3) 列表中每个数据也被称为元素，每个元素通过“，”分割。

4) 若 ls2 = ls1，其实是把ls1的地址赋值给ls2，操作ls2列表是也同时操作了ls1

3. 列表的作用

需要同时处理多个数据的时候就可以使用列表

示例：

# 场景：定义变量保存一个班所有学生的分数
# 1）不使用列表
score1 = 90
score2 = 78
score3 = 91
score4 = 62
score5 = 77
score6 = 80
score7 = 93
score8 = 99
score9 = 58
score10 = 64

print('平均分：', (score1 + score2 + score3 + score4 + score5 + score6 + score7 + score8 + score9 + score10)/10)

max_score = score1
if score2 > max_score:
    max_score = score2
if score3 > max_score:
    max_score = score3
if score4 > max_score:
    max_score = score4
if score5 > max_score:
    max_score = score5
if score6 > max_score:
    max_score = score6
if score7 > max_score:
    max_score = score7
if score8 > max_score:
    max_score = score8
if score9 > max_score:
    max_score = score9
if score10 > max_score:
    max_score = score10
print('最高分:', max_score)


# 2)使用列表
scores = [90, 78, 91, 62, 77, 80, 93, 99, 58, 64]
print('平均分：', sum(scores)/len(scores))
print('最高分：', max(scores))

二、列表的查操作

1. 查单个

获取列表中的一个元素

语法：列表[索引]

说明：

列表	可以是具体的一个列表数据，也可以是保存列表的变量
[ ]	固定写法
索引	又叫下标，是列表中元素的位置信息
	列表一旦确定，列表中元素的索引值就确定：
	元素从前往后对应的索引值从0开始不断加1；
	元素从后往前对应的索引值从-1开始不断减1

索引：

注意：索引值不能越界

# 案例
print([10, 20, 30][索引])

scores = [90, 87, 99, 61, 36, 45]
print(scores[1])                # 87
print(scores[-1], scores[5])    # 45 45

# print(scores[6])     # 报错(索引越界了)

2. 切片

获取列表中的部分元素。

① 完整语法

语法：列表[开始下标 : 结束下标 : 步长]

获取开始下标和结束下标确定的范围内的所有元素

(开始下标对应的值能取到，结束下标对应的元素取不到)

a. 如何去看切片结果

第一步：确定结果是否为[ ]

看开始下标对应元素到结束下标对应元素的方向和步长的方向是否一致，如果不一致结果一定是[ ](步长为正，表示从前往后；步长为负表示从后往前)

第二步：确定有效范围

开始下标对应的元素取得到，结束下标对应的元素取不到

第三步：按照步长的值在有效范围内获取元素

步长绝对值为1就一个一个地取；步长绝对值为2就取1个跳过1个再取一个；步长绝对值为3就取1个跳过2个再取一个。(每取一个元素后，下一个要取的元素的下标为上一个元素的下标加上步长)

b. 如何写切片的代码

开始下标  -  需要的结果中第一个元素的下标
结束下标  -  需要的结果中最后一个元素的后面那个元素(从前往后取)或者前面那个元素(从后往前取)的下标
步长  -  获取方向决定正负、获取方式决定绝对值

注意：如果要获取到最后一个元素，可以省略结束下标

scores = [90, 87, 99, 61, 36, 45]
print(scores[0:-3])    
print(scores[1:-1])
# 注意：如果要获取到最后一个元素，可以省略结束下标
print(scores[2:], scores[2:6])

 

tvs = ['甄嬛传', '琅琊榜', '庆余年', '玫瑰的故事', '狂飙', '开端', '庆余年2', '三国演义']

# 练习1
print(tvs[1:-2:2])  # 结果不为[] ['琅琊榜', '玫瑰的故事']
print(tvs[-1:0:3])  # 结果为[]
print(tvs[0:4:1])   # ['甄嬛传', '琅琊榜', '庆余年', '玫瑰的故事']
print(tvs[1:-1:3])  # ['琅琊榜', '狂飙']

print(tvs[-1:1:-2])     # ['三国演义', '开端', '玫瑰的故事']
print(tvs[6:-7:3])      # []
print(tvs[-7:-2:-1])    # []
print(tvs[-6:3:1])      # ['庆余年']


# 练习2
# 1) ['琅琊榜', '庆余年', '玫瑰的故事', '狂飙']
print(tvs[1:-3])
# 2)['狂飙', '开端', '庆余年2']
print(tvs[-4:-1])
# 3) [ '玫瑰的故事', '庆余年2']
print(tvs[3:-1:3])
# 4) ['三国演义', '庆余年2', '开端', '狂飙']
print(tvs[-1:-5:-1])
# 5) ['庆余年2', '狂飙', '庆余年']
print(tvs[-2:1:-2])

② 省略写法 

完整的语法：

列表[开始下标:结束下标:步长]

a.省略步长
列表[开始下标 : 结束下标]   -   省略步长相当于步长为1

b.省略开始下标
列表[ : 结束下标 : 步长]   -   省略开始下标，表示获取的元素的时候从第一个元素(步长为正)或者最后一个元素开始(步长为负)

c.省略结束下标
列表[开始下标 : : 步长]   -  省略结束下标，表示从开始下标对应的位置开始，一直取取完为止

tvs = ['甄嬛传', '琅琊榜', '庆余年', '玫瑰的故事', '狂飙', '开端', '庆余年2', '三国演义']
print(tvs[-1:1])
print(tvs[3:-2])
print(tvs[:-4:2])
print(tvs[:3:-2])
print(tvs[3::-1])
print(tvs[3::2])
print(tvs[2:])
print(tvs[::-1])
print(tvs[:])
print(tvs[:4])

3. 遍历

① 语法

语法1：

for 变量 in 列表:
    循环体(变量依次获取到的是列表中的每个元素)

语法2：依次获取每个元素的索引值，来获取每个元素

for x in range(列表长度):
    循环体(变量依次取到的是每个元素索引值, 可以通过列表[索引]来获取对应的元素)

列表长度： len(列表) 

案例：

scores = [90, 87, 99, 61, 36, 45]

# 方法1
for x in scores:
    print(x)

# 方法2
# len(列表)  -  获取列表中元素的个数
for x in range(len(scores)):
    print(x, scores[x])

 

 ② 逆序输出列表（重点）

scores = [90, 87, 99, 61, 36, 45]

# 方法1：5 4 3 2 1 0
for x in range(len(scores)-1, -1, -1):
    print(x, scores[x])


# 方法2：-1 -2 -3 ... -6
for x in range(-1, -len(scores)-1, -1):
    print(x, scores[x])

 

三、列表的增删改

1. 函数速查

2. 增 - 增加元素

1）列表.append(元素) —— 在指定列表的最后添加指定的元素

movies = ['魁拔', '肖生克的救赎', '沉默的羔羊', '绿皮书', 'V字仇杀队', '间谍过家家', '霸王别姬', '战狼']
print(movies)

movies.append('流浪地球')
print(movies)

案例：

# 案例1：在nums中的每个偶数的后面添加一个元素0
nums = [89, 67, 90, 44, 52, 51, 37]
new_nums = []
for x in nums:
    new_nums.append(x)
    if x % 2 == 0:
        new_nums.append(0)
print(new_nums)    # [89, 67, 90, 0, 44, 0, 52, 0, 51, 37]

 练习：

# 练习1：获取nums中所有的奇数
nums = [82, 67, 90, 44, 52, 51, 37, 90]
new_nums = []
for i in nums:
    if i % 2 != 0:
        new_nums.append(i)
print(new_nums)    # [67, 51, 37]
print('-----------------------分------割------线-----------------------')
# 练习2：将nums中所有的偶数都除以2
nums1 = [82, 67, 90, 44, 52, 51, 37, 90]
new_nums1 = []
for j in nums1:
    if j % 2 == 0:
        new_nums1.append(j / 2)
    else:
        new_nums1.append(j)
print(new_nums1)    # [41.0, 67, 45.0, 22.0, 26.0, 51, 37, 45.0]
print('-----------------------分------割------线-----------------------')
# 练习3：将scores中所有的0分都替换成'补考'
scores = [89, 67, 90, 0, 44, 0, 52, 0, 51, 37]
new_scores = []
for k in scores:
    if k == 0:
        new_scores.append('补考')
    else:
        new_scores.append(k)
print(new_scores)    # [89, 67, 90, '补考', 44, '补考', 52, '补考', 51, 37]

 2）列表.insert(索引, 元素) —— 将列表中指定索引对应的元素前插入指定元素

 案列：

movies = ['魁拔', '肖生克的救赎', '沉默的羔羊', '绿皮书', 'V字仇杀队', '间谍过家家', '霸王别姬', '战狼']
print(movies)

movies.insert(-1, '恐怖游轮')
print(movies)

练习：

nums2 = [190, 89, 6, -28, 89, -298, 10]
for i in range(len(nums2)):
    if nums2[i] < 0:
        nums2.insert(i, 100)
        break
print(nums2)    # [190, 89, 6, 100, -28, 89, -298, 10]

3. 删 - 删除元素

1) del 列表[索引] —— 删除列表中指定索引对应的元素

2) 列表.remove(元素) —— 删除列表中第一个指定元素

movies = ['魁拔', '肖生克的救赎', '沉默的羔羊', '绿皮书', 'V字仇杀队', '间谍过家家', '霸王别姬', '战狼']

del movies[-2]

movies.remove('肖生克的救赎')

3) 列表.pop( ) ——  取走列表最后一个元素并且返回

    列表.pop(索引) —— 取走列表指定索引对应的元素并且返回

movies = ['魁拔', '肖生克的救赎', '沉默的羔羊', '绿皮书', 'V字仇杀队', '间谍过家家', '霸王别姬', '战狼']
print(movies)

result = movies.pop(2)
print(movies)
print(result)

4. 改 - 修改元素

列表[索引] = 数据 —— 将列表中指定索引对应的元素修改成指定的数据

movies = ['魁拔', '肖生克的救赎', '沉默的羔羊', '绿皮书', 'V字仇杀队', '间谍过家家', '霸王别姬', '战狼']
print(movies)

movies[2] = '蝴蝶效应'
print(movies)

四、列表相关操作

1. 数学运算（+、*）

1) 列表1 + 列表2 —— 创建一个新的列表，列表中元素就是原来两个列表中的所有元素(列表的合并)

nums1 = [10, 20, 30]
nums2 = [100, 200]
result = nums1 + nums2
print(result)       # [10, 20, 30, 100, 200]

 2) 列表 * N   ——  将列表中的元素重复N次产生一个新的列表

result = nums1 * 3
print(result)
# [10, 20, 30, 10, 20, 30, 10, 20, 30]

2. 比较运算

1) 比较是否相等： ==、!=

print(nums1 == [10, 20, 30])        # True
print(nums1 == [20, 10, 30])        # False

2) 比较大小： 只有两个列表之间才可以比较大小，比较的是第一对不相等的元素的大小 

print([10, 100, 200, 300] > [20, 1])            # False
print([10, 100, 200, 300] > [10, 200])          # False

3.  in和not in

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

nums1 = [10, 20, 30, 100]
print(100 in nums1)        # True
print([10, 20] in nums1)   # False

nums1 = [[10, 20], 30, 100]
print(10 in nums1)         # False
print([10, 20] in nums1)   # True

4. 列表相关函数（其他容器数据也适用）

sum、max、min、sorted、len、list

函数	描述
sum(列表)	求列表中所有元素的和
max(列表)/min(列表)	求列表中元素的最大值/最小值
sorted(列表)	将列表中的元素升序排序，产生一个新的列表
sorted(列表, reverse=True)	将列表中的元素降序排序，产生一个新的列表
len(列表)	获取列表中元素的个数
list(数据)	将指定容器型数据转换成列表 （所有的容器型数据类型的数据都可以转换成列表）

scores = [90, 87, 99, 61, 36, 45]
print(sum(scores))
print(max(scores))
print(min(scores))

print(sum(range(101))    # 5050

result = sorted(scores)
print(result)       # [36, 45, 61, 87, 90, 99]

result = sorted(scores, reverse=True)
print(result)       # [99, 90, 87, 61, 45, 36]

print(len(scores))
print(len(range(100))

print(list('abc123'))       # ['a', 'b', 'c', '1', '2', '3']
print(list(range(5)))

5. 列表相关方法

列表.clear()	清空列表
列表.copy()	复制指定列表产生一个一模一样的新列表
列表.count(元素)	统计指定数据在指定列表中出现的次数
列表.extend(容器)	将指定容器中所有的元素都添加到指定列表中
列表.index(元素)	获取列表中第一个指定元素对应的索引（0开始的索引值）
列表.reverse()	将指定列表倒序
列表.sort()	将列表中的元素升序排序
列表.sort(reverse=True)	将列表中的元素降序排序

注意： 

1. 列表.copy()、列表[:]、列表*1、列表+[] 这几个操作的功能一样！

2. 上面sorted函数排序不只针对列表，对容器型数据都行，且不改变原列表；

而相关方法中的排序（最后三个）是会改变原列表的，并且只有列表能使用。

# 1. 列表.clear()  - 清空列表
nums = [1, 90, 78, 3682]
print(nums)
nums.clear()
print(nums)

# 2. 列表.copy()      -   复制指定列表产生一个一模一样的新列表
# 列表.copy()、列表[:]、列表*1、列表+[] 这几个操作的功能一样！
list1 = [19, 28, 90, 78, 56, 45]
list2 = list1           # 直接用一个变量给另外一个变量赋值，赋的地址，赋完值之后两个变量指向的是同一个列表
list3 = list1.copy()
print('list1:', list1)
print('list2:', list2)
print('list3:', list3)

list1.append(100)
print('list1:', list1)
print('list2:', list2)
print('list3:', list3)

# 3. 列表.count(数据)       -   统计指定数据在指定列表中出现的次数
list1 = [19, 28, 90, 78, 56, 45, 19, 19, 28, 19]
print(list1.count(19))
print(list1.count(28))
print(list1.count(100))

# 4.列表.extend(容器)   -   将指定容器中所有的元素都添加到指定列表中
list1 = [10, 20, 30]

list1.extend('abc')
print(list1)        # [10, 20, 30, 'a', 'b', 'c']

nums = [1, 90, 78, 3682]
list1.extend(nums)
print(list1)

# 5.列表.index(元素)   -  获取列表中指定元素的第一个索引值(返回的是0开始的索引值)
list1 = [19, 28, 90, 78, 56, 45, 19, 19, 28, 19]
print(list1.index(90))
print(list1.index(19))
# print(list1.index(100))

# 6.列表.reverse()   -  将指定列表倒序
names = ['张三', '李四', '王五', '小明']
print(names)
names.reverse()
print(names)

# 7.
# 列表.sort()     -   将列表中的元素升序排序
# 列表.sort(reverse=True)     -   将列表中的元素降序排序
list1 = [19, 28, 90, 78, 56, 45, 19, 19, 28, 19]
print(list1)

list1.sort(reverse=True)
print(list1)

五、列表推导式

1. 结构一

语法：表达式 for 变量 in 容器]

工作原理：让变量去容器中取值，一个一个地取，取完为止，每取一个值就计算一次表达式并且将计算结果作为列表的一个元素

# 案例
result1 = [x*2 for x in range(5)]
print(result1)

# 练习1：使用列表推导式提取nums中所有元素的个位数
nums = [198, 78, 93, 67, 89, 23, 71]
# [8, 8, 3, 7, 9, 3, 1]
result = [i % 10 for i in nums]
print(result)

# 练习2：使用列表推导式将列表中元素的元素都乘以100
nums = [198, 78, 93, 67, 89, 23, 71]
result = [i * 100 for i in nums]
print(result)

# 练习3：使用列表推导式获取字符串列表中每个元素的长度
str_list = ['python', 'java', 'go', 'c', 'javascript']
# [6, 4, 2, 1, 10]
result = [len(i) for i in str_list]
print(result)

2. 结构二

语法：[表达式 for 变量 in 容器 if 条件语句]

工作原理：让变量去容器中取值，一个一个地取，取完为止，每取一个值就判断一次条件是否成立，如果成立才计算表达式的结果作为列表的一个元素

# 案例
result = [x for x in range(1, 15) if x % 2]
print(result)

# 练习1：使用列表推导式提取nums中所有的偶数
nums = [19, 8, 78, 93, 37, 82, 19]
result = [i for i in nums if i % 2 == 0]
print(result)

# 练习2：使用列表推导式删除scores中所有不及格的分数
scores = [99, 87, 50, 65, 43, 20, 91, 74]
result = [score for score in scores if score >= 60]
print(result)

# 练习3：提取list1中所有的整数，并且将每一个整数都乘以2
list1 = [1.23, 9, 'abc', '12', 23, 9.1, [10, 20], 45]
result = [i * 2 for i in list1 if type(i) == int]
print(result)

# 练习4：使用列表推导式将nums中所有的偶数都整除2，所有的奇数都乘以2 （思考）
nums = [19, 8, 78, 93, 37, 82, 19]
result = [i * 2 if i % 2 else i // 2 for i in nums]
print(result)