Pyf20230313-14(Python列表)_列表scores里存放了6名同学的三次作业分数, scores=[["201910041001",7

需求：定义变量保存6个学生的成绩

#方法1：
s1 = 90
s2 = 87
s3 = 92
s4 = 67
s5 = 55
s6 = 69
s7 = 81
print((s1 + s2 + s3 + s4 + s5 + s6 + s7) / 7)

# 方法2：使用列表
scores = [90, 87, 92, 67, 55, 69, 81, 99]
print(sum(scores) / len(scores))
print(max(scores))
1
2
3
4
5
6
7
8
9
10
11
12
13
14

使用推荐：如果要同时处理多个数据，可以考虑列表

1.认识列表（list）

1）列表是容器型数据类型（序列)﹔将[]作为容器的标志，里面多个数据用逗号隔开：[数据1, 数据2, 数据3, …]
2）列表是可变的（可变指的是列表中元素的个数和元素的值可变 - 列表支持增删改）
列表是有序的（元素有顺序对应的位置的信息;元素的顺序影响结果 - 列表支持索引操作）
3）列表对元素的要求：没有要求，然和类型的数据都可以作为列表的元素。
注：元素 – 容器中每一个独立的数据，就是这个容器的元素

1.1 空列表

list1 = []
print(list1)
1
2

1.2 列表是有序的

print([10, 20, 30] == [30, 10, 20])  # False
print({10, 20, 30} == {30, 10, 20})  # True(集合是无序的,顺序不影响结果)
1
2

1.3 列表元素可以是任何类型的数据

a.一个列表中的元素可以是多个相同类型的数据

list2 = [10, 20, 40]
names = ['小明', '小花', '张三']
1
2

b.一个列表的元素可以是多个不同类型的数据

list3 = [10, 1.23, True, None, '小花']
1

c.列表中的元素也可以是列表

List4 = [10, 20, [30, 40]]
1

查 – 获取列表中元素的值

1.查单个 - 获取一个元素

1）语法
列表[索引] - 获取列表中指定索引对应元素
2）说明
列表 - 需要获取元素的列表对象（可以是保存一个列表的变量，也可以是具体的列数据）
[] - 固定写法
索引 - 又叫下标；指的是元素在列表中的位置信息。
列表一旦确定，列表中的每个元素对应的索引就确定，且列表中的每个元素有2个索引值:
a.元素从前往后索引从0开始不断增加
b.元素从后往前从-1开始不断减少

nums = [10, 20, 30, 40]
print(nums[1])
print([10, 20, 30, 40][1])
print(nums[-1])  # 或 print(nums[3])
1
2
3
4

2.切片 - 同时获取多个元素（列表切片的结果是列表）

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

2）说明：
列表 - 需要获取元素列表
[] - 固定写法
开始下标 - 决定从哪儿开始取
结束下标 - 决定取到哪儿结束
步长 - 决定取的时候怎么取(是一个一个的按顺序取，还是跳着取，还是从前往后取或从后往前取)

3）使用切片
a.确定切片结果
第一步：先确定结果是否为空，看开始下标对应的位置到结束下标对应的位置的方向和步长的方向是否一致
一致结果不为空，不一致结果一定为空。
第二步：如果结果不为空，再确定切片的有效范围（开始下标对应的元素能取到，结束下标对应元素取不到）
第三步：在有效范围内容，按照步长的反向和绝对值获取元素。
方向：步长为正，从开始下标到结束下标从前往后取；步长为负就从后往前取
绝对值：绝对值为1，就1个1个的取；绝对值为2，取1个跳1个再取1个；绝对值为3，取1个跳2个再取1个

b.怎么写切片代码获取指定元素
确定开始下标：需要的结果中第一个数据在列表的下标
确定结束下标：结束下标是结果中最后一项的后一个数据或者前一个数据的下标（看方向）
确定步长：正负看趋势（从前往后取还是从后往前取）；再看绝对值（看取的时候是一个一个的取的,还是跳着取的）

movies = ['肖生克的救赎', '霸王别姬', '阿甘正传', '钢铁侠', '蜘蛛侠', '蝙蝠侠', '蚁人', '雷神', '复仇者联盟']
print(movies[1:3:1])    # ['霸王别姬', '阿甘正传']
print(movies[0:-2:2])   # ['肖生克的救赎', '阿甘正传', '蜘蛛侠', ‘蚁人']
print(movies[5:0:2])    # []
print(movies[3:-1:-1])  # []
print(movies[-2:2:-2])  # ['雷神', '蝙蝠侠', '钢铁侠']
print(movies[6:2:-3])   # ['蚁人', '钢铁侠']
print(movies[1:-3:3])   # ['霸王别姬', '蜘蛛侠']
print('----------------------------------------')
print(movies[1:-1:1])   # ['霸王别姬', '阿甘正传', '钢铁侠', '蜘蛛侠', '蝙蝠侠', '蚁人', '雷神']
print(movies[-1:1:-2])  # ['复仇者联盟', '蚁人', '蜘蛛侠', '阿甘正传']
print(movies[-2:5:2])   # []
print(movies[0:-2:4])   # ['肖生克的救赎', '蜘蛛侠']
print(movies[5:-1:2])   # ['蝙蝠侠', '雷神']
print(movies[6:-6:-1])  # ['蚁人', '蝙蝠侠', '蜘蛛侠']
print('----------------------------------------')
# ['肖生克的救赎', '钢铁侠', '蚁人']
print(movies[0:7:3])
# ['复仇者联盟', '雷神', '蚁人', '蝙蝠侠']
print(movies[-1:-5:-1])
# ['钢铁侠', '霸王别姬']
print(movies[3:0:-2])
# ['雷神', '蝙蝠侠', '钢铁侠']
print(movies[-2:-7:-2])
# ['霸王别姬', 蝙蝠侠']
print(movies[1:int(6.5):4])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

2.1 切片省略的写法

完整的切片语法：列表[开始下标:结束下标:步长]
a.省略步长 - 相当于步长为1
列表[开始下标:结束下标]
b.省略开始下标 - 获取元素的从头开始取（步长为为正，从第一个元素开始；步长为负，从最后一个元素开始）
列表[:结束下标:步长]
c.省略结束下标 - 获取元素时候从开始下标开始，取完为止（有可能是取到最后一个，也有可能取到第一个）
完整的切片语法：列表[开始下标::步长]

print('----------------------------------------')
movies = ['肖生克的救赎', '霸王别姬', '阿甘正传', '钢铁侠', '蜘蛛侠', '蝙蝠侠', '蚁人', '雷神', '复仇者联盟']
print(movies[1:4])    # ['霸王别姬', '阿甘正传', '钢铁侠']
print(movies[-1:1])   # []
print('----------------------------------------')
print(movies[:-2:2])  # ['肖生克的救赎', '阿甘正传', '蜘蛛侠', '蚁人']
print(movies[:2:-2])  # ['复仇者联盟', '蚁人', '蜘蛛侠']
print(movies[:4])     # ['肖生克的救赎', '霸王别姬', '阿甘正传', '钢铁侠']
print('----------------------------------------')
print(movies[2::2])   # ['阿甘正传', '蜘蛛侠', '蚁人', '复仇者联盟']
print(movies[4::-1])  # ['蜘蛛侠', '钢铁侠', '阿甘正传', '霸王别姬', '肖生克的救赎',]
print(movies[3:])     # ['钢铁侠', '蜘蛛侠', '蝙蝠侠', '蚁人', '雷神', '复仇者联盟']
1
2
3
4
5
6
7
8
9
10
11
12

3.遍历 - 一个一个的获取列表中所有的元素

方法1 - 直接获取元素
for变量in列表:
循环体(变量依次获取到的就是列表中的每个元素)

方法2 – 通过获取所有元素的下标来获取元素
for 变量 in range(len(列表)):
循环体(列表[变量])
注: len(列表) - 获取列表长度

方法3:
for index, item in enumerate(列表)∶
循环体(变量1依次获取的是每个元素的下标;变量2依次获取的是每个元素)

scores = [90, 89, 87, 81, 79, 93, 67, 56, 43, 99]
# 方法1：
for x in scores:
    print(x)
# 求总分
sum1 = 0
for x in scores:
    sum1 += x
print('总分：', sum1)
# 统计90分以上的学生的人数
count = 0
for x in scores:
    if x > 90:
        count += 1
print('90分以上的学生的人数:', count)
print('方法1----------------------------------------')
list1 = [
    [10, 20],
    [100, 200],
    [1, 2]
]
for x in list1:
    print('x:', x[-1])

# 方法2：
print('方法2----------------------------------------')
scores = [90, 89, 87, 81, 79, 93, 67, 56, 43, 99]
for x in range(len(scores)):
    print(x, scores[x])

# 方法3：
print('方法3----------------------------------------')
for index, item in enumerate(scores):
    print('index:', index, 'item:', item)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

03 列表的增删改操作

1.增 - 添加元素

1.1 列表.append(元素） - 在指定列表的最后添加指定的元素（不会产生新的列表，而是直接在原列表中添加）

heroes = ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '卡牌', '蛇女']
print(heroes)
heroes.append('剑圣')
print(heroes)
1
2
3
4

例：提取scores中所有不及格的分数

scores = [89, 45, 99, 65, 93, 81, 29, 88, 76, 59, 66]
# [45, 29, 59]
fail_scores = []
for s in scores:
    if s < 60:
        fail_scores.append(s)
print(fail_scores)
1
2
3
4
5
6
7

练习1：利用append删除列表中所有的奇数

nums = [89, 45, 99, 65, 93, 81, 29, 88, 76, 59, 66]
new_nums = []
for n in nums:
    if n % 2 == 0:
        new_nums.append(n)
print(new_nums)
1
2
3
4
5
6

练习2：将scores中所有不及格的分数改成’补考’

scores = [89, 45, 99, 65, 93, 81, 29, 88, 76, 59, 66]
fail_scores = []
for s in scores:
    if s < 60:
        fail_scores.append('补考')
    elif s >= 60:
        fail_scores.append(s)
print(fail_scores)
1
2
3
4
5
6
7
8

1.2 列表.insert(下标, 元素) - 将指定元素插入到列表中指定下标对应的元素前

heroes = ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '卡牌', '蛇女']
heroes.insert(-1, '哈哈怪')
print(heroes)
1
2
3

2.删 - 删除元素

2.1 del 列表[下标] - 删除列表中指定下标对应的元素

heroes = ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '卡牌', '蛇女']
del heroes[1]
print(heroes)
1
2
3

2.2 列表.remove(元素) - 删除列表中的指定元素（如果元素有多个它只会删除第一个）

heroes = ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '卡牌', '蛇女', '金克斯']
heroes.remove('金克斯')
print(heroes)
1
2
3

2.3 pop - 将数据从列表中拿走

列表.pop() - 取出列表最后一个元素，并且返回
列表.pop(下标) - 取出列表中指定下标对应的元素，并且返回

print('pop----------------------------------------')
heroes = ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '卡牌', '蛇女']
result1 = heroes.pop()
print(result1, heroes)  # 蛇女 ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '卡牌']
result2 = heroes.pop(0)
print(result2, heroes)  # 寒冰射手 ['小炮', '维鲁斯', '金克斯', '小法', '卡牌']
1
2
3
4
5
6

3.改 - 修改元素的值

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

heroes = ['寒冰射手', '小炮', '维鲁斯', '金克斯', '小法', '卡牌', '蛇女']
heroes[1] = '孙悟空'
print(heroes)
1
2
3

练习：将scores中所有低于60分的成绩修改成0分(使用改)

scores = [89, 45, 99, 65, 93, 81, 29, 88, 76, 59, 66]
# 方法1
print('方法1----------------------------------------')
for s in range(len(scores)):
    if scores[s] < 60:
        scores[s] = 0
print(scores)
# 方法2
print('方法2----------------------------------------')
for index, s in enumerate(scores):
    if s < 60:
        scores[index] = 0
print(scores)
1
2
3
4
5
6
7
8
9
10
11
12
13

04 列表相关操作

1.列表加法运算

列表1 + 列表2 - 将两个列表合并成一个新的列表

A = [10, 20, 30]
B = [100, 200]
C = A + B
print(C)  # [10, 20, 30, 100, 200]
1
2
3
4

2.列表乘法运算

列表* N 、N *列表 - 将列表中的元素重复N次产生一个新的列表

C = A * 2
print(C)  # [10, 20, 30, 10, 20, 30]
D = ['小米', '华为', 'Apple']
print(D * 3)  # ['小米', '华为', 'Apple', '小米', '华为', 'Apple', '小米', '华为', 'Apple']
1
2
3
4

3.列表比较运算

3.1 比较是否相等：==、!=

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

3.2 比较大小：>、<、>=、<=

列表1 > 列表2
两个列表比较大小，比较的是第一对不相等的元素的大小(相同位置上的元素是一对)

print([10, 20, 30] > [1, 100, 200, 300, 400])  # True
print([10, 20, 30] > [10, 2, 100, 200, 300])  # True
1
2

4.in 和 not in

元素 in 列表 - 判断列表中是否存在指定的元素，返回布尔值
元素 ont in 列表 - 判断列表中是否不存在指定的元素，返回布尔值

print(10 in [10, 20, 30])  # True
print(10 in [[10, 20], 30])  # False
print([10, 20] in [10, 20, 30])  # False
1
2
3

练习：已经列表A和B，打印A和B的公共元素

A = ['后羿', '甄姬', '鲁班7号', '赵云']
B = ['小乔', '孙悟空', '猪八戒', '后羿', '盾山', '赵云']
for x in A:
    if x in B:
        print(x)
1
2
3
4
5

05 列表相关函数

1.sum（必须是数字序列才能求和） - 求数字序列中所有元素的数值和

scores = [98, 23, 56, 88, 90, 70]
result = sum(scores)
print(result)
print('把0-100的数相加----------------------------------------')
result = sum(range(101))
print(result)
1
2
3
4
5
6

2.max、min

max(序列) - 求序列中的最大元素

scores = [98, 23, 56, 88, 90, 70]
result = max(scores)
print(result)
1
2
3

min(序列) - 求序列中的最小元素

result = min(scores)
print(result)
1
2

补充：求最大值的逻辑
假设第一个元素是最大值保存到变量中，然后依次取出后面的每个元素和保存最大值的变量进行比较，如果后面取出来的值比最大值还大，就更新最大值

scores = [98, 23, 56, 100, 88, 90, 70]
max1 = scores[0]
for x in scores[1:]:
    if x > max1:
        max1 = x
print(max1)
1
2
3
4
5
6

3.sorted

3.1 sorted(序列) - 将序列中的元素按照从小到大的方式排序，创建一个新的列表。

scores = [98, 23, 56, 100, 88, 90, 70]
result = sorted(scores)
print(result)
1
2
3

3.2 sorted(序列, reverse=True) - 将序列中的元素按照从大到小的方式排序，创建一个新的列表并且返回

scores = [98, 23, 56, 100, 88, 90, 70]
result = sorted(scores, reverse=True)
print(result)
1
2
3

4.len

len(序列) - 统计序列中元素的个数

print(len(scores))   # 7
print(len(range(1, 100, 2)))   # 50个
1
2

5.list

list(序列) - 将指定的序列转换成列表(任何序列都可以转换成列表，转换的时候直接将序列中元素作为列表的元素)

a = list('1234')
print(a)

b = list(range(1, 100, 2))
print(b)

c = [a, 1, b, 5, 9.9, '哈哈']
print(c)
1
2
3
4
5
6
7
8

06 列表的其它函数

1. 列表.clear() - 清空列表

nums = [10, 9, 89, 23]
print(nums)
nums.clear()
print(nums)
print('以上情况方式与下面清空对比，上面的是正规清空方式，不占内存----------------------------------------')
nums = [10, 9, 89, 23]
print(nums)
nums = []
print(nums)
1
2
3
4
5
6
7
8
9

2. 列表.count() - 统计列表中指定元素的个数

nums = [10, 9, 89, 23, 10]
print(nums.count(9))
print(nums.count(10))
1
2
3

3. 列表.extend(序列) - 将序列中的元素全部添加到列表中

list1 = [10, 20]
list1.extend([100, 200])
print(list1)
print('extend与append的区别----------------------------------------')
list2 = [10, 20]
list2.append([100, 200])
print(list2)
1
2
3
4
5
6
7

4. 列表.index(元素) - 获取列表中指定元素对应的下标（返回的是从0开始的下标值）

nums = [10, 9, 89, 23, 10]
print(nums.index(23))
print(nums.index(10))  # 0（若有多个相同元素，则返回第一个元素的下标）
1
2
3

5. 列表.reverse() - 将列表倒序

nums = [10, 78, 89, 23, 33]
nums.reverse()
print(nums)   # [33, 23, 89, 78, 10]
1
2
3

6.

列表.sort() - 将列表中的元素从小到大排序(直接修改原列表元素的顺序)
列表.sort(reverse=True) - 将列表中的元素从大到小排序

print('----------------------------------------')
nums = [10, 78, 89, 23, 33]
result = nums.sort()
print(nums)    # [10, 23, 33, 78, 89]
print(result)  # None
1
2
3
4
5

sorted(序列) - 将列表中的元素从小到大排序(不修改原序列央元素的顺序，而是创建一个新的列表)

print('上面sort与sorted的区别----------------------------------------')
nums = [10, 78, 89, 23, 33]
result = sorted(nums)
print(nums)    # [10, 78, 89, 23, 33]
print(result)  # [10, 23, 33, 78, 89]
1
2
3
4
5

07 列表赋值问题

补充：python中的变量保存数据，保存的是数据在内存中的地址（Python中的变量全部都是指针变量）

1.拷贝和直接赋值

需求：已知一个列表，现在需要创建和原列表一模一样的新的列表

nums = [10, 78, 89, 23, 33]
1

1.1 直接赋值 - 一个变量直接给另外一个变量赋值，赋的是地址，赋值后两个变量指向的是同一块内存

nums1 = nums
print('nums:', nums)
print('nums1:', nums1)
1
2
3

1.2 拷贝 - 一个变量通过拷贝的方式给另外一个变量赋值，赋值的时候会先复制原来变量中的数据，创建一个新的数据，然后将新的数据对应的内存地址给新的变量

nums2 = nums * 1
print('nums2:', nums2)

nums3 = nums + []
print('nums3:', nums3)

nums4 = nums[:]
print('nums4:', nums4)

nums5 = nums.copy()
print('nums5:', nums5)

print('------------------修改后观察----------------------')
nums.append(100)
print('nums:', nums)    # [10, 78, 89, 23, 33, 100]
print('nums1:', nums1)  # [10, 78, 89, 23, 33, 100]
print('nums2:', nums2)  # [10, 78, 89, 23, 33]
print('nums3:', nums3)  # [10, 78, 89, 23, 33]
print('nums4:', nums4)  # [10, 78, 89, 23, 33]
print('nums5:', nums5)  # [10, 78, 89, 23, 33]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

08 列表推导式

列表推导式：快速创建列表的表达式(代码简洁)

1.列表推导式结构1

1）语法：
[表达式 for 变量 in 序列]

2）让变量去序列中取值，一个一个的取，取完为止，每取一个值就计算一次表达式的结果，并且将计算结果作为列表的一个元素

result = [10 for x in range(5)]
print(result)  # [10, 10, 10, 10, 10]

result = [x * 2 for x in range(5)]
print(result)  # [0, 2, 4, 6, 8]
1
2
3
4
5

例1：将nums中所有的元素乘以2

nums = [10, 23, 89, 67]
result = [x * 2 for x in nums]
print(result)  # [20, 46, 178, 134]
1
2
3

例2：获取nums中所有元素的个位数

nums = [10, 923, 89, 167]
result = [x % 10 for x in nums]
print(result)  # [0, 3, 9, 7]
1
2
3

2.列表推导式结构2

1）语法：
[表达式 for 变量 in 序列 if 条件语句]

2）让变量去序列中取值，一个一个的取，取完为止，每取一个值就判断一次条件是否成立，如果成立就计算表达式值作为列表的元素

result = [x * 2 for x in range(5) if x % 2 == 0]
print(result)  # [0, 4, 8]
1
2

例1：删除scores中所有不及格的分数

scores = [80, 99, 23, 67, 56, 82, 76, 45]
result = [x for x in scores if x >= 60]
print(result)  # [80, 99, 67, 82, 76]

nums = [103, 230, 89, 67, 78]
result = [x % 10 for x in nums if x % 2 != 0]
print(result)   # [3, 9, 7]
1
2
3
4
5
6
7

09 列表作业1

1. 基础题

1. 已知一个数字列表，打印列表中所有的奇数

   nums = [103, 230, 89, 67, 78]
   result = [x for x in nums if x % 2 != 0]
   print(result) 
   1
   2
   3

2. 已知一个数字列表，打印列表中所有能被能被3整除但是不能被2整除的数

   nums = [103, 230, 89, 67, 78, 3]
   result = [x for x in nums if x % 3 == 0 and x % 2 != 0]
   print(result) 
   1
   2
   3

3. 已知一个数字列表，计算所有偶数的和

   nums = [103, 230, 89, 67, 78, 3, 2]
   result = [x for x in nums if x % 2 == 0]
   print(sum(result))
   1
   2
   3

4. 已知一个数字列表，统计列表中十位数是1的数的个数

   nums = [103, 230, 89, 67, 78, 3, 2, 210, 310, 432]
   count = 0
   for x in nums:
       if x // 10 % 10 == 1:
           count += 1
   print(count)
   1
   2
   3
   4
   5
   6

5. 已知一个列表，获取列表中下标为奇数的所有元素(从0开始的下标值)

   例如: list1 = [10, 20, 5, 34, 90, 8]

   结果：[20, 34, 8]

   方法1：
   list1 = [10, 20, 5, 34, 90, 8]
   result = [x for index,x in enumerate(list1) if index % 2 != 0]
   print(result)
   方法2：
   print(list1[1::2])
     ```
   1
   2
   3
   4
   5
   6
   7

6. 已知一个数字列表，将列表中所有元素乘以2

   例如： nums = [10, 3, 6, 12] 乘2后: nums = [20, 6, 12, 24]

   nums = [10, 3, 6, 12]
   result = [x * 2 for x in nums]
   print(result)
   1
   2
   3

7. 已知一个列表，获取列表的中心元素

   例如：nums = [10, 2, 6, 12] -> 中心元素为: 2和6

   ​ nums = [10, 2, 6, 12, 10] -> 中心元素为：6

   方法1：
   nums = [10, 2, 6, 12]
   if len(nums) % 2 != 0:
       print(nums[int(len(nums) / 2)])
   else:
       print(nums[int(len(nums) / 2) - 1], nums[int(len(nums) / 2)])
       
   方法2：优化
   nums = [10, 2, 6, 12]
   if len(nums) % 2 != 0:
       print(nums[len(nums) // 2])
   else:
       print(nums[len(nums) // 2 - 1], nums[len(nums) // 2])
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13

8. 已知一个列表，获取列表中所有的整型元素

   例如：list1 = [10, 1.23, ‘abc’, True, 100, ‘hello’, ‘20’, 5]

   ​ 结果是: [10, 100, 5]

   list1 = [10, 1.23, 'abc', True, 100,  'hello', '20', 5]
   result = [x for x in list1 if type(x) == int]
   print(result)
   1
   2
   3

2. 进阶题

1. 定义一个列表保存多个学生的分数，删除列表中所以低于60分的值

   例如： scores = [45, 60, 89, 30, 12, 59, 99, 80, 71, 66] 删除后: scores = [60, 89, 99, 80, 71, 66]

   方法1：
   scores = [45, 60, 89, 30, 12, 59, 99, 80, 71, 66]
   result = [x for x in scores if x >= 60]
   print(result)
   方法2：
   scores = [45, 60, 89, 30, 12, 59, 99, 80, 71, 66]
   new_scores = scores.copy()
   for x in new_scores:
       if x < 60:
           scores.remove(x)
   print(scores)
   方法3：
   scores = [45, 60, 89, 30, 12, 59, 99, 80, 71, 66]
   for x in sorted(scores):
       if x < 60:
           scores.remove(x)
   print(scores)
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17

2. 已知一个列表保存了多个学生的姓名，要求去掉列表中重复的名字

   例如：names = [‘小明’, ‘张三’, ‘李四’, ‘张三’, ‘张三’, ‘小明’, ‘王五’, ‘王五’]

   ​ 去重后：names = [‘小明’, ‘张三’, ‘李四’, ‘王五’]

   方法1：
   names = ['小明', '张三', '李四', '张三', '张三', '小明', '王五', '王五']
   new_names = []
   for x in names:
       if x not in new_names:
           new_names.append(x)
   print(new_names)
   方法2：
   names = ['小明', '张三', '李四', '张三', '张三', '小明', '王五', '王五']
   count = len(names)
   for x in range(count):
       n = names.pop(0)
       if n not in names:
           names.append(n)
   print(names)
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15

3. 已知一个数字列表，获取列表中值最大的元素 （不能使用max函数）

   nums = [45, 60, 89, 30, 12, 59, 99, 80, 71, 66]
   max_num = nums[0]
   for x in nums:
       if x > max_num:
           max_num = x
   print(max_num)
   1
   2
   3
   4
   5
   6

4. 已知两个有序列表(列表中的元素已经按照从小到大的方式排好序)，要求合并两个列表，合并后元素还是从小到大排序

   例如: list1 = [10, 23, 39, 41, 52, 55, 80] list2 = [9, 38, 55, 70]

   合并后的结果: [9, 10, 23, 38, 39, 41, 52, 55, 55, 70, 80]

   方法1：
   list1 = [10, 23, 39, 41, 52, 55, 80]
   list2 = [9, 38,  55, 70]
   list3 = sorted(list1 + list2)
   print(list3)
   方法2：
   list1 = [10, 23, 39, 41, 52, 55, 80]
   list2 = [9, 38,  55, 70]
   list3 = []
   while True:
       a = list1.pop(0)
       b = list2.pop(0)
       if a < b:
           list3.append(a)
           list2.insert(0, b)
       else:
           list3.append(b)
           list1.insert(0, a)
       if list1 == [] or list2 == []:
           break
   list3 = list3 + (list1 + list2)  # list3 += list1 + list2
   print(list3)
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22

5. 已知一个有序数字列表(从小到大)，输入任意一个数字，将输入的数字插入列表中，要求插入后列表仍然保持从小到大排序的关系

   例如： list1 = [10, 23, 45, 67, 91] 输入: 50 -> list1 = [10, 23, 45, 50, 67, 91]

   方法1：
   list1 = [10, 23, 45, 67, 91]
   num = int(input('输入要插入的数：'))
   list1.append(num)
   list1.sort()
   print(list1)
   方法2：
   list1 = [10, 23, 45, 67, 91]
   num = int(input('输入要插入的数：'))
   n = len(list1)
   for x in range(n):
       if list1[x] > num:
           list1.insert(x, num)
           break
   else:
       list1.append(num)
   print(list1)
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17

10 列表作业2

1. 创建一个列表，列表中有10个数字, 保证列表中元素的顺序，对列表进行排重,并对列表使用进行降序排序

   例如：[70, 88, 91, 70, 107, 234, 91, 177, 282, 197]
           --- 去重之后 [70, 88, 91, 107, 234, 177, 282, 197]
       ---- 降序排序 [282, 234, 197, 177, 107, 91, 88, 70]
   1
   2
   3

   nums = [70, 88, 91, 70, 107, 234, 91, 177, 282, 197]
   new_num = []
   for n in nums:
       if n not in new_num:
           new_num.append(n)
   new_num.sort(reverse=True)
   print(new_num)
   1
   2
   3
   4
   5
   6
   7

2. 利用列表推导式, 完成以下需求

   a. 生成一个存放1-100中个位数为3的数据列表

   结果为 [3, 13, 23, 33, 43, 53, 63, 73, 83, 93]
   1

   方法1：
   result = [x for x in range(1,101) if x % 10 == 3]
   print(result)
   方法2：
   result = [x for x in range(3, 100, 10)]
   print(result)
   1
   2
   3
   4
   5
   6

   b. 利用列表推到是将 列表中的整数提取出来

   例如：[True, 17, "hello", "bye", 98, 34, 21] --- [17, 98, 34, 21]
   1

   nums = [True, 17, "hello", "bye", 98, 34, 21]
   result = [x for x in nums if type(x) == int]
   print(result)
   1
   2
   3

   c.利用列表推导式 存放指定列表中字符串的长度

   例如： ["good", "nice", "see you", "bye"] --- [4, 4, 7, 3]
   1

   nums = ["good", "nice", "see you", "bye"]
   result = [len(x) for x in nums]
   print(result)
   1
   2
   3

   d. 利用列表推导式删除列表中整数个位数小于5的元素

   例如：[24, 'abc', 99, True, 21, 38, 'hello'] --- ['abc', 99, True, 38, 'hello']
   1

   方法1：
   nums = [24, 'abc', 99, True, 21, 38, 'hello']
   result = [x for x in nums if type(x) == int and x % 10 >= 5 or type(x) != int]
   print(result)
   方法2:
   nums = [24, 'abc', 99, True, 21, 38, 'hello']
   result = [x for x in nums if not(type(x) == int and x % 10 < 5)]
   print(result)
   1
   2
   3
   4
   5
   6
   7
   8

   e. 利用列表推导式获取元素是元组的列表中每个元组的最后一个元素

   例如：[(10, 20, 30), ('abc', 'hello'), (1, 2, 3.4), (True, False)]  --- [30, 'hello', 3.4, False]
   1

   nums = [(10, 20, 30), ('abc', 'hello'), (1, 2, 3.4), (True, False)]
   result = [x[-1] for index, x in enumerate(nums)]
   print(result)
   1
   2
   3

   f.利用列表推导式将数字列表中所有的奇数乘以2，所有的偶数除以2

   例如: [23, 4, 67, 88, 90, 21]  -> [46, 2, 134, 44, 45, 42]
   1

   方法1：
   nums = [23, 4, 67, 88, 90, 21]
   result1 = [x * 2 for x in nums if x % 2 != 0]
   result2 = [int(x / 2) for x in nums if x % 2 == 0] 
   result3 = []
   for x in range(len(result1)):
       result3.append(result1[x])
       for y in range(len(result2)):
           if x == y:
               result3.append(result2[y])
   print(result3)
   方法2：
   nums = [23, 4, 67, 88, 90, 21]
   result = [x * 2 if x % 2 != 0 else x // 2 for x in nums]
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14

3. 已知一个列表获取列表中指定元素所有的下标

   例如：[10, 20, 34, 10, 9, 78]
   10的下标：[0, 3]
   20的下标：[1]
   30的下标：[]
   1
   2
   3
   4

   a = int(input('输入一个想要获取下标的整数：'))
   nums = [10, 20, 34, 10, 9, 78]
   x_index = []
   for index, x in enumerate(nums):
       if x == a:
           x_index.append(index)
   print(x_index)
   1
   2
   3
   4
   5
   6
   7

4. *已知一个数字列表，写程序判断这个列表是否是连续递增列表。

   例如：
   [1, 2, 3, 4, 5]   -> True
   [23, 45, 78, 90]  -> True
   [1, 3, 2, 4, 5]	-> False
   1
   2
   3
   4

   nums_list = [1, 3, 2, 4, 5]
   new_nums_list = sorted(nums_list)
   print(new_nums_list == nums_list)
   1
   2
   3

5. 已知两个列表，将两个列表按照下面的规律交叉合并

   A = [10, 20, 30, 40, 50]
   B = [100, 200, 300]
   结果：[10, 100, 20, 200, 30, 300, 40, 50]
   1
   2
   3

   方法1：
   A = [10, 20, 30, 40, 50]
   B = [100, 200, 300]
   C = []
   for x in range(len(A)):
       C.append(A[x])
       for y in range(len(B)):
           if x == y:
               C.append(B[y])
   print(C)
   方法2：
   A = [10, 20, 30, 40, 50]
   B = [100, 200, 300]
   C = []
   while True:
       C.append(A.pop(0))
       C.append(B.pop(0))
       if A == [] or B == []:
           break
   C += A + B
   print(C)
   方法3：
   A = [10, 20, 30, 40, 50]
   B = [100, 200, 300]
   for x in range(len(B)):
       A.insert(2*x + 1, B[x])
   print(A)
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27

6. 已知两个有序列表，将两个列表合并，合并后的新列表中元素仍然是递增列表

   A = [10, 20, 30, 40, 50]
   B = [25, 44, 60]
   结果：[10, 20, 25, 30, 40, 45, 50, 60]
   1
   2
   3

   A = [10, 20, 30, 40, 50]
   B = [25, 44, 60]
   C = sorted(A + B)
   print(C)
   1
   2
   3
   4