Day4 列表

置顶 innateking118

已于 2023-03-15 18:43:20 修改

阅读量139

点赞数

文章标签： python 开发语言

于 2023-03-14 20:43:32 首次发布

本文链接：https://blog.csdn.net/innateking118/article/details/129539639

版权

Day4

重点

遍历时需注意列表的范围

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

append使用是一般创建一个新的空列表，在新列表中加入符合条件的元素

列表.insert（下标，元素） - 将元素插入到列表中指定下标对应的元素前

insert使用是在现有的列表中，用下标进行遍历，在对应位置的地方插入元素

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

列表*.remove**(元素) - 删除列表中第一个指定的元素删除过后元素不存在了*

使用del和remove时需注意在遍历下标时，删除了元素，列表的大小就改变了，某些元素就会遍历不到

列表**.pop**() - 取出列表中最后一个元素，并且返回（pop操作就是从列表中取走的数据）*

列表*.pop**(下标) - 取出列表中指定下标元素*

数据 in 列表 - 判断指定数据是否是列表中的元素

数据 not in 列表 - 判断指定数据是否不是列表中的元素

用in 和not in 可以对列表中重复的元素进行判断

在pycharm里添加快捷键

在这里插入图片描述

列表

1.什么是列表（list）

1.列表是Python提供的容器型数据类型（序列）（可以同时保存多个数据）；

将中括号[ ]作为容器的标志，里面多个元素用逗号隔开：[ 数据1, 数据2, 数据3, …]

2.列表是可变的（元素的个数和值可变-支持增删改查）；

列表是有序的（元素有顺序对应的位置的信息；元素的顺序影响结果 -支持索引操作）

3.元素：任何类型的数据都可以作为列表的元素

说明：

容器型数据 - 可以同时保存多个数据

元素 - 容器中的每个独立的数据，就是这个容器的元素。

1）空列表

list1=[]
print(list1)

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

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

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

b. 一个列表的元素可以是多个不同类型的数据
```
list3 = [10, 1.23, True, None, '小花']
```
c.列表中的元素也可以是列表
```
list4 = [10, 20, [30, 40]]
```

3)列表是有序的

print([10, 20] == [20, 10])  # False 证明列表是有序的
print({10, 20} == {20, 10})  # True因为集合是无序的则为True

2.列表的增删改查

1.查 - 获取列表中的元素

1) 查单个

- 获取列表中的某一个元素

语法：列表[索引] - 获取列表中指定索引对应元素
说明：

a.列表 - 需要获取元素的列表对象(可以是保存一个列表的变量，也可以是具体的列数据)

b.[ ] - 固定写法

c.下标 - 又叫索引；列表的下标指的是列表中的元素在列表中的位置信息。

列表一旦确定，列表中的每个元素对应的索引就确定：

第一种下标（通用的）：元素从前往后对应的下标从0开始依次增加

第二种下标：元素从后往前对应的下标从-1开始依次减少

注意：下标不能越界

nums = [10, 29, 23]
print(nums[-1], nums[2])	#23 23
print(nums[0])				#10
print(nums[3])				#报错！因为下标越界了

2) 切片

- 同时获取多个元素(列表结果的结果是列表)

1）完整语法：

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

a. 说明
列表 - 需要获取元素列表
[] - 固定写法
开始下标、结束下标、步长 - 必须是整数
开始下标 - 决定从哪儿开始取
结束下标 - 决定取到哪儿结束
步长 - 决定取的时候怎么取(是一个一个的按顺序取，还是跳着取；是从前往后取(步长为正)还是从后往前取(步长为负))

2）使用切片

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('---------------------------------------华丽的分割线------------------------------------')
movies = ['肖生克的救赎', '霸王别姬', '阿甘正传', '钢铁侠', '蜘蛛侠', '蝙蝠侠', '蚁人', '雷神', '复仇者联盟']
# ['霸王别姬', '阿甘正传', '钢铁侠']
print(movies[1:4:1])

# ['阿甘正传','蜘蛛侠', '蚁人']
print(movies[2:-2:2])

# ['雷神', '阿甘正传']
print(movies[-2:1:-5])

print('---------------------------------------华丽的分割线------------------------------------')
# ['肖生克的救赎', '钢铁侠', '蚁人']
print(movies[0:-2:3])

# ['复仇者联盟', '雷神', '蚁人', '蝙蝠侠']
print(movies[-1:-5:-1])

# ['钢铁侠', '霸王别姬']
print(movies[3:0:-2])

# ['雷神', '蝙蝠侠', '钢铁侠']
print(movies[-2:2:-2])
# ['霸王别姬', 蝙蝠侠']
print(movies[1:-3:4])

3）切片省略的写法

完整的切片语法：列表[开始下标:结束下标:步长]

a.省略步长 - 相当于步长为1
列表[开始下标:结束下标]
b.省略开始下标 - 获取元素的从头开始取（步长为为正，从第一个元素开始；步长为负，从最后一个元素开始）
列表[:结束下标:步长]

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

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

print(movies[:-2:2])        # ['肖生克的救赎', '阿甘正传',  '蜘蛛侠', '蚁人']
print(movies[:2:-2])        # [ '复仇者联盟', '蚁人', '蜘蛛侠']
print(movies[:4])           # ['肖生克的救赎', '霸王别姬', '阿甘正传', '钢铁侠']

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

print(movies[::-2])         # ['复仇者联盟', '蚁人', '蜘蛛侠', '阿甘正传', '肖生克的救赎']

3）遍历

- 一个一个的获取列表中所有的元素

方法1 - 直接获取元素
for 变量 in 列表：
循环体(变量依次获取到的就是列表中的每个元素)
方法2 - 通过获取所有元素的下标来获取元素
for 变量 in range(len(列表)):
循环体(列表[变量])
方法3：
for 变量1,变量2 in enumerate(列表):
循环体(变量1依次获取的是每个元素的下标；变量2依次获取的是每个元素)
注：len(列表) - 获取列表长度

# 方法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('---------------------------------------华丽的分割线------------------------------------')
list1 = [
    [10, 20],
    [100, 200],
    [1, 2]
]
for x in list1:
    print('x:', x[-1])

print('---------------------------------------华丽的分割线------------------------------------')
scores = [90, 89, 87, 81, 79, 93, 67, 56, 43, 99]
for x in range(len(scores)):
    print(x, scores[x])

print('---------------------------------------华丽的分割线------------------------------------')
for index, item in enumerate(scores):
    print('index:', index, 'item:', item)

2.改 - 修改元素的值

1）列表[下标] = 新值

- 修改列表中指定下标对应的元素为指定的新值

nums = [10, 20, 30]
print(nums)
nums[0] = 23
print(nums)			#[23,20,30]

3.增 - 添加元素

1）列表.append(元素)

- 在指定的最后添加指定的元素

heroes = ['王昭君', '猪八戒', '孙悟空', '后羿', '鲁班7号']
print(heroes)   # ['王昭君', '猪八戒', '孙悟空', '后羿', '鲁班7号']

heroes.append('赵云')
print(heroes)   # ['王昭君', '猪八戒', '孙悟空', '后羿', '鲁班7号', '赵云']


#提取scores中所有不及格的分数，产生一个新的列表
scores = [90, 34, 79, 99, 100, 77, 56, 67, 55]
new_scores = []
for y in scores:
    if y < 60:
        new_scores.append(y)
print(new_scores)			#[34,56,55]

# 练习1：利用append删除列表中所有的奇数
nums = [89, 45, 99, 65, 93, 81, 29, 88, 76, 59, 66]
# [88, 76, 66]
new_nums = []
for x in nums:
    if x % 2 == 0:
        new_nums.append(x)
print(new_nums)

2）列表.insert（下标，元素）

- 将元素插入到列表中指定下标对应的元素前

heros=['王昭君','猪八戒','孙悟空','后裔','鲁班7号']
print(heros)					#['王昭君', '猪八戒', '孙悟空', '后裔', '鲁班7号']
heros.insert(1,'赵云')
print(heros)					#['王昭君', '赵云', '猪八戒', '孙悟空', '后裔', '鲁班7号']

4.删 - 删除元素

1）del 列表[下标]

- 删除列表中指定下标对应的元素

heros=['王昭君','猪八戒','孙悟空','后裔','鲁班7号']
print(heros)
del heros[1]
print(heros)		## ['王昭君', '孙悟空', '后羿', '鲁班7号']

2）列表.remove(元素)

- 删除列表中第一个指定的元素删除过后元素不存在了

heros=['王昭君','猪八戒','孙悟空','后裔','猪八戒','鲁班7号']
print(heros)
heros.remove('猪八戒')
print(heros)				#只删除一个猪八戒
#heros.remove('赵云')		#若删除不存在的元素 则会报错

3）列表.pop()

列表.pop() - 取出列表中最后一个元素，并且返回（pop操作就是从列表中取走的数据）

列表.pop(下标) - 取出列表中指定下标元素

heros = ['王昭君', '猪八戒', '孙悟空', '后裔', '鲁班7号']
result1 = heros.pop()
print(result1)				#取出列表中最后一个元素，鲁班7号
result2 = heros.pop(2)
print(heros, result2)		#['王昭君', '猪八戒', '后裔'] 孙悟空

3.列表其他应用

1.列表的加法

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

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

2.列表的乘法

列表’ * ‘N、N’ * '列表 - 将列表重复N次产生一个新的列表

必须是一个列表乘以正整数

A=[10,20,30]
B=A*2
print(B)				#[10,20,30,10,20,30]
print(['小明', '小花'] * 4) 
#['小明', '小花', '小明', '小花', '小明', '小花', '小明', '小花']

3.列表比较运算

1）比较是否相等：== 、！=

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

2）比较大小：>、<、>=、<=

列表1>列表2

两个列表比较大小，比较的是第一对不相等的元素的大小（相同位置上的元素是一对）

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

4. in和not in

数据 in 列表 - 判断指定数据是否是列表中的元素

数据 not in 列表 - 判断指定数据是否不是列表中的元素

A = [10, 20, 30]
B = [1, 2, 3, 4, 5]
print(10 in A)			#True
print(10 in B)			#False

4. 列表相关函数

sum、max、min、sorted

sum(列表) - 求列表中所有元素的和（列表中的元素必须全部是数字）

A = [10, 20, 30]
print(sum(A))			#60

max(列表) - 获取列表中的最大元素

min(列表) - 获取列表中的最小元素

sorted(列表) - 将列表中的元素升序排序（从大到小），产生一个新列表，不改变原列表

scores=[56,278,324,355,53,5,4,43]
new_scores=sorted(scores)
print(new_scores)			#[355,324,278,56,53,43,5,4]

new_scores=sorted(scores,reverse=True)
print(new_scores)			#[4,5,43,53,56,278,324,355]

5.列表的相关方法

1.列表.clear()

- 清空列表

nums = [10, 9, 89, 23]
print(nums)     # [10, 9, 89, 23]
nums.clear()
print(nums)     # []

2.列表.count(元素)

- 统计列表中指定元素的个数

列表.count(元素)   -   统计列表中指定元素的个数
nums = [10, 9, 89, 23, 10]
print(nums.count(100))
print(nums.count(9))
print(nums.count(10))

3.列表.extend(序列)

- 将序列中的元素全部添加到列表中

list1 = [10, 20]
list1.extend([100, 200])
print(list1)    # [10, 20, 100, 200]

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

4.列表.index(元素)

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

nums = [10, 9, 89, 23, 10]
# print(nums.index(100))        # ValueError: 100 is not in list
print(nums.index(89))           # 2
print(nums.index(10))           # 0

5.列表.reverse()

- 将列表倒序

nums = [10, 9, 89, 23, 50]
nums.reverse()
print(nums)     # [50, 23, 89, 9, 10]

6.列表.sort()和sorted(序列)的区别

1.列表.sort()

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

列表.sort(reverse=True) - 将列表中的元素从大到小排序

nums = [10, 9, 89, 23, 50]
result = nums.sort()
print(nums)         # [9, 10, 23, 50, 89]
print(result)       # None

nums = [10, 9, 89, 23, 50]
nums.sort(reverse=True)
print(nums)         # [89, 50, 23, 10, 9]

2.sorted(序列)

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

# 列表
nums = [19, 28, 3, 3, 4, 23]
result = sorted(nums)
print(nums)  # [19, 28, 3, 3, 4, 23]
print(result)  # [3, 3, 4, 19, 23, 28]

# 字符串
nums = 'fghjkj'
result = sorted(nums)
print(nums)  # fghjkj
print(result)  # ['f', 'g', 'h', 'j', 'j', 'k']

# 元组
nums = (2, 3, 21, 2, 3, 45, 90)
result = sorted(nums)
print(nums)  # (2, 3, 21, 2, 3, 45, 90)
print(result)  # [2, 2, 3, 3, 21, 45, 90]

# 集合
nums = {'g', 'f', 'f', 's', 'r', 'k'}
result = sorted(nums)
print(nums)  # [19, 28, 3, 3, 4, 23]
print(result)  # [3, 3, 4, 19, 23, 28]

nums = {'g': 2, 'a': 4, 'c': 8}
result = sorted(nums)
print(nums)  # {'g': 2, 'a': 4, 'c': 8}
print(result)  # ['a', 'c', 'g']

7.列表赋值问题

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

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

2)拷贝

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

# 需求：已知一个列表，现在需要创建和原列表一模一样的新的列表
nums = [10, 20, 30, 40]

# 1)直接赋值  -  一个变量直接给另外一个变量赋值，赋的是地址，赋值后两个变量指向的是同一块内存
nums2 = nums
print('nums:', nums)#nums: [10, 20, 30, 40]
print('nums2:', nums2)#nums2: [10, 20, 30, 40]

# 2)拷贝
# 一个变量通过拷贝的方式给另外一个变量赋值，赋值的时候会先复制原来变量中的数据，创建一个新的数据，然后将新的数据对应的内存地址给新的变量
nums3 = nums*1
print('nums3:', nums3)#nums3: [10, 20, 30, 40]

nums4 = nums + []
print('nums4:', nums4)#nums4: [10, 20, 30, 40]

nums5 = nums[:]
print('nums5:', nums5)#nums5: [10, 20, 30, 40]

nums6 = nums.copy()
print('nums6:', nums6)#nums6: [10, 20, 30, 40]

print('---------------------------------------修改后------------------------------------')
nums.append(100)
print('nums:', nums)#nums: [10, 20, 30, 40, 100]

print('nums2:', nums2)#nums2: [10, 20, 30, 40, 100]
print('nums3:', nums3)#nums3: [10, 20, 30, 40]
print('nums4:', nums4)#nums4: [10, 20, 30, 40]
print('nums5:', nums5)#nums5: [10, 20, 30, 40]
print('nums6:', nums6)#nums6: [10, 20, 30, 40]

8.列表的推导式

- 快速创建列表的表达式（代码简洁）

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：将nums中所有的元素乘以2
nums = [10, 23, 89, 67]
result = [x*2 for x in nums]
print(result)       # [20, 46, 178, 134]

# 案例2：获取nums中所有元素的个位数
nums = [103, 230, 89, 67]
result = [x % 10 for x in nums]
print(result)       # [3, 0, 9, 7]

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：删除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]

#案例2：提取nums中所有奇数的个位数

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

作业

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

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

#方法一
scores = [45, 60, 89, 30, 12, 59, 99, 80, 71, 66]
new_scores=[]
for y in scores:
    if y < 60:
        new_scores.append(y)
print(new_scores)

#错误的方法
scores = [45, 60, 89, 30, 12, 59, 99, 80, 71, 66]
for y in scores:
    if y < 60:
        scores.remove(y) 	#最终输出有误 ，因为遍历删除获取数据时，数据不能全部取到
print(scores)				#[60,89,12,99,80,71,66] 12<60 则输出有错

#方法二
scores = [45, 60, 89, 30, 12, 59, 99, 80, 71, 66]
new_scores = scores *1
for y in new_scores:
    if y < 60:
        scores.remove(y) 	
print(scores)			#对数据进行备份，遍历备份的列表，对原列表进行删除操作	

#方法三
# 0   1   2   3   4   5   6   7   8   9
#[45, 60, 89, 30, 12, 59, 99, 80, 71, 66]
#从最后的元素进行取数，逆向遍历进行删除操作
scores = [45, 60, 89, 30, 12, 59, 99, 80, 71, 66]
for x in range(len(scores)-1,-1,-1):
    if scores[x] < 60:
        del scores[x] 	
print(scores)

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

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

names = ['小明', '张三', '李四', '张三', '张三', '小明', '王五', '王五']
i = 1
new_names = []
for y in names:
    if y in new_names:
        continue
    if y == names[i]:
        new_names.append(y)
    else:
        new_names.append(y)
    i += 1
print(new_names)

#方法一
names = ['小明', '张三', '李四', '张三', '张三', '小明', '王五', '王五']
new_names = []
for y in names:
    if y  not in new_names:
        new_names.append(y)
print(new_names)		#['小明','张三','李四','王五']

#方法二
names = ['小明', '张三', '李四', '张三', '张三', '小明', '王五', '王五']
for x in range(len(names)):
    name = names.pop(0)
    if x not in names:
        names.append(name)
print(names)			#['李四','张三','小明','王五']

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

最好不用sorted对列表进行排序，程序运行时间会加长

#方法一
scores = [56, 278, 324, 355, 53, 5, 4, 43]
max1 = scores[0]
for x in scores:
    if x > max1:
        max1 = x
print(max1)

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]

#方法一
#将两个列表的第一个元素，进行比较，较小的元素放入新的列表，较大的放回原列表，直到某个列表为空，循环结束
#循环次数不确定
list1 = [10, 23, 39, 41, 52, 55, 80]
list2 = [9, 38, 55, 70]
new_list = []
while True:
    a1 = list1.pop(0)
    a2 = list2.pop(0)
    if a1 < a2:
        new_list.append(a1)     #若list1中的元素较小则放入新列表
        list2.insert(0, a2)     #list2中元素较大放回原列表
    else:
        new_list.append(a2)     #若list2中元素较小则将其放入新列表
        list1.insert(0, a1)     #list1中较大的元素放回

    if list1 == [] or list2 == []:
        new_list += list1 + list2   #list1和list2中有一个列表被排空了，另一个列表还剩下一些元素，将剩下的加入新的列表中
        break
print(new_list)

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

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

# list.insert(下标，num)
num = int(input('请输入一个数字：'))
list1 = [10, 23, 45, 67, 91]
if num >= list1[-1]:
    list1.append(num)		#如果输入的num值大于所有的元素，则直接在列表最后加上num
else:
    for x in range(len(list1)):
        if list1[x] > num:
            list1.insert(x, num)
            break
print(list1)