day0506列表的进阶

最新推荐文章于 2023-03-07 19:08:06 发布

x萧先生

最新推荐文章于 2023-03-07 19:08:06 发布

阅读量624

点赞数

文章标签： python

本文链接：https://blog.csdn.net/x9527488/article/details/124284685

版权

day05/06列表的进阶

1.什么是列表(list)

**列表是容器型数据类型；将[ ]作为容器的标志，里面多个元素用逗号隔开: [元素1, 元素2, 元素3,…]
元素：列表中的元素可以是任何类型的数据; 同一个列表中的元素的类型可以不同

特点：1.可变的(指的是元素的个数、元素的值和元素的顺序可变)；2.有序的(元素有表示顺序的编号)

a = [ ]      a是一个空列表

b =     [ 100,  200,  True,  'a b c' ]
c =     [ 100, 200, ['a b c', 123] ]

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

d = [100,
     12.5,  

     'a b c',
     [1, 2],
     (10, 20),
     {'name': '余婷', 'age': 18},
     {1, 5},
     lambda x: x**2]

print(type(d))    # <class 'list'>
print(b)

练习：定义变量保存一个班所有学生的成绩

方法一：

score 1 = 90 ,  score 2 = 78  score 3 = 56  , score 4 = 98,   score 5 = 99 ,   score 6 = 70

方法二：

scores = [90, 78, 56, 98, 99, 70]

------

2. 获取列表元素（查）

1.获取单个元素

语法：列表[下标] - 获取指定下标对应的元素

说明：列表 - 任何结果是列表的表达式(具体的列表数据、保存列表数据的变量、…)

[ ] - 固定写法:

下标 - 又叫索引；它是元素在容器中的位置标志(元素在容器中的顺序值)
下标值的范围有两种：

**1）从0开始不断加1的下标值，其中0表示第一个、1表示第二个、…
**

**2）从-1开始不断减1的下标值，其中 -1表示倒数第一个、-2 表示倒数第二个、…

**注意：下标不能越界

list1 = [10, 20, 30, 'a b c']

print(list1[1], list1[-3])
print(list1[-1], list1[3])

print(list1[10])        # IndexError: list index out of range

print(l ist1[-5])        # IndexError: list index out of range

2. 获取部分元素(列表切片) - 同时获取列表中的多个元素

1)语法：列表[开始下标:结束下标:步长]
2)规则：
a.如果步长为正，表示从前往后取（从开始下标到结束下标）, 开始下标对应的元素能取到，结束下标对应的元素取不到
b.如果步长为负，表示从后往前取（从开始下标到结束下标），开始下标对应的元素能取到，结束下标对应的元素取不到

movies = ['阿甘正传', '肖生克的救赎', '当幸福来敲门', '霸王别姬', '花样年华', '人在囧途']
print(movies[1:5:1])    # ['肖生克的救赎', '当幸福来敲门', '霸王别姬', '花样年华']
print(movies[1:-1:1])   # ['肖生克的救赎', '当幸福来敲门', '霸王别姬', '花样年华']
print(movies[5:1:1])    # []
print(movies[5:1:-1])   # ['人在囧途', '花样年华', '霸王别姬', '当幸福来敲门']
print(movies[5:1:-2])   # ['人在囧途', '霸王别姬']
print(movies[1:-1:-2])  # []
print(movies[1:-2:1])   # ['肖生克的救赎', '当幸福来敲门', '霸王别姬']
print(movies[-1:-5:-2])     # ['人在囧途', '霸王别姬']
print(movies[-4:2:1])   # []

1)省略步长: 列表[ 开始下标 : 结束下标 ]

省略步长就相当于步长为1：列表[ 开始下标 : 结束下标 ] == 列表[ 开始下标:结束下标 :1 ]

names = ['海贼王', '火影', '死神', '妖精的尾巴', '柯南', '犬夜叉', '进击的巨人', '一人之下']
print(names[1:-2])      # ['火影', '死神', '妖精的尾巴', '柯南', '犬夜叉']
print(names[-1:5])      # []

2)省略开始下标: 列表 [ :结束下标 : 步长 ] / 列表[ : 结束下标 ]

如果步长为正，省略开始下标表示从第一个元素开始往后取，取到结束下标对应的位置，结束下标取不到。
如果步长为负，省略开始下标表示从最后一个元素开始往前取，取到结束下标对应的位置，结束下标取不到。

print(names[:-2])       # ['海贼王', '火影', '死神', '妖精的尾巴', '柯南', '犬夜叉']
print(names[:5:2])      # ['海贼王', '死神', '柯南']
print(names[:-3:-1])    # ['一人之下', '进击的巨人']

3)省略结束下标: 列表 [ 开始下标 : : 步长 ] / 列表[ 开始下标: ]

如果步长为正，省略结束下标，从开始下标取到最后一个元素
如果步长为负，省略结束下标，从开始下标取到第一个元素

names = ['海贼王', '火影', '死神', '妖精的尾巴', '柯南', '犬夜叉', '进击的巨人', '一人之下']
print(names[2:])        # ['死神', '妖精的尾巴', '柯南', '犬夜叉', '进击的巨人', '一人之下']

print(names[-3::-1])    # ['犬夜叉', '柯南', '妖精的尾巴', '死神', '火影', '海贼王']

print(names[4::-2])     # ['柯南', '死神', '海贼王']

print(names[-2::-3])    # ['进击的巨人', '妖精的尾巴', '海贼王']

4)同时省略开始下标和结束下标：列表[::步长] / 列表[:]

开始下标和结束下标都省，那么整个选择范围就是原列表

print(names[::-1])   # 倒序  ['一人之下', '进击的巨人', '犬夜叉', '柯南', '妖精的尾巴', '死神', '火影', '海贼王']
print(names[::-2])   # ['一人之下',  '犬夜叉', 妖精的尾巴', '火影']
print(names[:])      # ['海贼王', '火影', '死神', '妖精的尾巴', '柯南', '犬夜叉', '进击的巨人', '一人之下']

3.遍历(一个一个的把所有元素取出来)

方法一：直接遍历出列表中的元素
for 变量 in 列表:
循环体
(变量取到的就是列表中的元素)

方法二：通过遍历获取所有元素的下标来遍历元素

for 下标 in range(列表长度):
列表[下标]

方法三（了解）

for 下标, 元素 in enumerate(列表):
循环体

games = [‘斗地主’, ‘欢乐麻将’, ‘开心消消乐’, ‘三国杀’, ‘王者荣耀’, ‘英雄联盟’]

1）直接获取元素（掌握）

for item in games:
    print('item:', item)

2）直接获取下标，通过下标获取元素(掌握)

len(列表) - 获取列表中元素的个数： index 下标索引

for index in range(len(games)):
   
	print('下标:', index, '元素:', games[index])

3）同时获取下标和元素(了解)

for index, item in enumerate(games):
    print('index:', index, 'item:', item)

enumerate(games)  -> [(0, '斗地主'), (1, '欢乐麻将'),... ]

for x in [12, 34, 45]:

print(x)

for x, y in [(1, 2), [10, 20], 'ab']:

print('x y:', x, y)

for x,y,z in [(1, 2, 3), (10, 20, 30), 'a b c', ['name', 'age', 'sex']]:

print('x y z:', x, y, z)

scores = [10, 78, 90, 8, 77, 65, 100]   ->  ['不及格', 78, 90, '不及格', 77, 65, 100]

练习：

1）用一个列表保存一个班10个学生的成绩

scores = [45, 89, 78, 90, 65, 70, 23, 57, 100, 66]

2）计算10个学生的总成绩

3）计算10个学生的平均成绩

length = len(scores)
sum 1 = 0
for item in scores:
    sum 1 += item
print('总成绩:', sum 1, '平均成绩:', sum 1 / length)

4）统计不及格学生的人数

count = 0
for item in scores:
    if item < 60:
        count += 1
print('不及格人数:', count)

5）获取10个学生成绩最高成绩的值

max 1 = scores[0]         # 假设第一个元素的值最大
for item in scores[1:]:
    if item > max 1:
        max 1 = item
print('最高分:', max 1)

3. 元素的增删改

1. 增 - 添加元素

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

names = ['余婷', '张瑞燕', '迪丽热巴', '古力娜扎']
print(names)    # ['余婷', '张瑞燕', '迪丽热巴', '古力娜扎']

names.append('蔡徐坤')
print(names)    # ['余婷', '张瑞燕', '迪丽热巴', '古力娜扎', '蔡徐坤']

2) 列表.insert(下标, 元素) - 在指定下标对应的元素前插入指定元素

names.insert(2, ' 杨幂 ')
print(names)            # ['余婷', '张瑞燕', '杨幂', '迪丽热巴', '古力娜扎', '蔡徐坤']

names.insert(0, '胡歌')   # ['胡歌', '余婷', '张瑞燕', '杨幂', '迪丽热巴', '古力娜扎', '蔡徐坤']
print(names)

names.insert(-1, '彭于晏')
print(names)        # ['胡歌', '余婷', '张瑞燕', '杨幂', '迪丽热巴', '古力娜扎', '彭于晏', '蔡徐坤']

2. 删 - 删除元素

1) del 列表[下标]

names = ['胡歌', '余婷', '张瑞燕', '杨幂', '迪丽热巴', '古力娜扎', '彭于晏', '蔡徐坤']
del names[3]         # 删除 杨幂
print(names)        # ['胡歌', '余婷', '张瑞燕', '迪丽热巴', '古力娜扎', '彭于晏', '蔡徐坤']

del names[-1]
print(names)      # ['胡歌', '余婷', '张瑞燕', '迪丽热巴', '古力娜扎', '彭于晏']

del names[7]      # Index Error: list assignment index out of range

del names         # 删除整个列表

2) 列表.remove(元素) - 删除列表中指定的元素

a. 如果元素不存在会报错

b. 如果元素有多个，只删第一个

names = ['胡歌', '余婷', '张瑞燕', '杨幂', '迪丽热巴', '古力娜扎', '彭于晏', '迪丽热巴', '蔡徐坤', '迪丽热巴']
names.remove('杨幂')
print(names)    # ['胡歌', '余婷', '张瑞燕', '迪丽热巴', '古力娜扎', '彭于晏', '迪丽热巴', '蔡徐坤', '迪丽热巴']

names.remove('朱茵')   # ValueError: list.remove(x): x not in list

names.remove('迪丽热巴')
print(names)

3）列表.pop( ) - 取出列表中最后一个元素, 并返回

列表.pop(下标) - 取出列表中指定下标对应的元素，并返回(下标不能越界)

names = ['胡歌', '余婷', '张瑞燕', '杨幂', '迪丽热巴', '古力娜扎', '彭于晏', '蔡徐坤']
del_name = names.pop()
print(names, del_name)    # ['胡歌', '余婷', '张瑞燕', '杨幂', '迪丽热巴', '古力娜扎', '彭于晏'] 蔡徐坤

del_name = names.pop(-2)
print(names, del_name)    # ['胡歌', '余婷', '张瑞燕', '杨幂', '迪丽热巴', '彭于晏'] 

作业1：用一个列表保存学生的分数，删除列表中所有低于60分的成绩

scores = [90, 45, 52, 10, 89, 67, 55, 32, 69, 100]

最终结果： [90, 89, 67, 69, 100]

3. 改 - 修改元素的值

语法：列表[下标] = 新元素 - 修改指定下标对应的元素(下标不能越界)

teleplays = ['琅琊榜', '亮剑', '庆余年', '爱情公寓', '人民的名义', '甄嬛传', '请回答1988']
teleplays[3] = '爱情公寓4'
print(teleplays)

练习：scores = [10, 78, 90, 8, 77, 65, 100] -> [‘不及格’, 78, 90, ‘不及格’, 77, 65, 100]

方法一：

scores = [10, 78, 90, 8, 77, 65, 100]
for index, item in enumerate(scores):
    if item < 60:
        scores[index] = '不及格'

print(scores)   # ['不及格', 78, 90, '不及格', 77, 65, 100]

#方法二：

scores = [10, 78, 90, 8, 77, 65, 100]
new_scores = [ ]
for item in scores:
    if item < 60:
        new_scores.append('不及格')
    else:
        new_scores.append(item)
print(new_scores)    # ['不及格', 78, 90, '不及格', 77, 65, 100]

04. 列表相关操作

1.数学运算: +, *

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

list1 = [1, 2, 3]
list2 = [100, 200]
print(list1 + list2)    # [1, 2, 3, 100, 200]

2）列表N * N列表 - 列表中的元素重复 N 次产生一个新的列表(N是>=0的整数)

list3 = list1 * 3      
print(list 3)          # [1,2,3, 1,2,3, 1,2,3]

2. 比较运算符

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

print([1, 2, 3] == [1, 2, 3])   # True
print([1, 2, 3] == [1, 3, 2])   # False

补充：is 的用法

数据1 is 数据2 - 判断两个数据是否相等 (判断数据的地址)

数据1 == 数据2 - 判断两个数据是否相等 (判断数据的值)

注意：如果给不同的变量赋相同的可变值，地址不一样；赋相同不可变的值地址相同

list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = list1
print(list1 == list2)    # True
print(list1 is list2)    # False
print(list1 is list3)    # True

字典可变

a = {'name': 100}
b = {'name': 100}
print({'name': 100} == {'name': 100})    # True
print(a is b)   # False

元组不可变

x = (10, 20)
y = (10, 20)
print(x is y)    # True

数字和字符串不可变

m = 100
n = 100
print(m is n)   # False

m = 'abc'
n = 'abc'
print(m is n)    # False

2) 比较大小: >, <, >=, <=

两个列表比较大小，就是比较第一对不相等的元素的大小

print ([1, 2, 3, 4, 5, 6] > [ 10, 0, 0, 0, 0]) # False

3. in 和 not in

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

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

练习1：有两个列表A和B，使用列表C来获取两个列表中公共的元素

例如: A = [1, ‘a’, 4, 90] B = [‘a’, 8, ‘j’, 1] --> C = [1, ‘a’]

A = [1, 'a', 4, 90]
B = ['a', 8, 'j', 1]
C = []
for x in A:
    if x in B:
        C.append(x)
print(C)

练习2：有一个长度是10的列表，数组内有10个人名，要求去掉重复的

例如:names = [‘张三’, ‘李四’, ‘大黄’, ‘张三’] -> names = [‘张三’, ‘李四’, ‘大黄’]

names = ['张三', '李四', '大黄', '张三', '张三', '张三', '大黄', '王五']
new_names = []
for x in names:
    if x not in new_names:
        new_names.append(x)
print(new_names)

05. 相关函数

sum、max、min、sorted、len、list

1）sum(序列) - 求序列中所有元素的和；要求序列中的元素必须是数字

scores = [90, 89, 78, 56, 77.9, 81]
print(sum(scores))

2）max(序列) - 获取序中最大的元素; 序列中的元素支持比较运算并且类型一致

print(max(scores))      # 90

print(min(scores))

3)sorted(序列) - 将序列中的元素从小到大排序，返回排序之后的新列表

new_scores = sorted(scores)
print(scores)    # 不会修改原列表
print(new_scores)   # [56, 77.9, 78, 81, 89, 90]

sorted(序列, reverse=True) - 序列中的元素从大到小排序，返回排序之后的新列表

scores = [90, 89, 78, 56, 77.9, 81]
new_scores = sorted(scores, reverse=True)
print(new_scores)    # [90, 89, 81, 78, 77.9, 56]

4）len(序列) - 获取序列中元素的个数

5）list(数据) - 将数据转换成列表；

所有的序列都可以转换成列表; 将序列中的元素作为列表的元素

print(list('abc'))    # ['a', 'b', 'c']
print(list(range(4)))  # [0, 1, 2, 3]

06. 列表相关方法

1. 列表.clear() – 清空列表(删除列表中所有的元素)

nums = [10, 2, 100]
nums.clear()
print(nums)    # []

2. 列表.copy() - 复制原列表产生一个相同的新列表(数据相同，地址不同);浅拷贝

nums = [1, 2, 'abc']
new_nums = nums.copy()
print(new_nums)    # [1, 2, 'abc']
print(nums is new_nums)   # False

id(变量) - 获取变量中保存的地址(获取变量中保存的数据的地址)

print(id(nums), id(new_nums))

直接赋值和拷贝

list1 = [1, 2, 3]
list2 = list1      # 直接赋值
print(list2)   # [1, 2, 3]
list3 = list1.copy()    # 拷贝  list1[:]、list1*1、 list1+[]
print(list3)    # [1, 2, 3]

list1.append(100)
print(list2)      # [1, 2, 3, 100]
print(list3)    # [1, 2, 3]

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

scores = [90, 89, 89, 70, 100, 100, 23, 100, 89, 89]
print(scores.count(100))

练习：获取列表中元素出现最多的次数

max_count = 0
for x in scores:
    count = scores.count(x)
    if count > max_count:
        max_count = count
print(max_count)

4. 列表.extend(序列) - 将序列中所有的元素都添加到列表中

nums = [1, 2]
nums.extend('abc')
print(nums)    # [1, 2, 'a', 'b', 'c']

nums.extend([10, 20, 30])
print(nums)    # [1, 2, 'a', 'b', 'c', 10, 20, 30]

nums = [1, 2]
nums.append('abc')
print(nums)    # [1, 2, 'abc']

nums.append([10, 20, 30])
print(nums)    # [1, 2, 'abc', [10, 20, 30]]

5. 列表.index(元素) - 获取指定元素在列表中下标(0 ~ 长度-1)

如果元素有多个，只返回第一个的下标（获取第一次出现的位置）

如果元素不存在，会报错

song = ['晴天', '大不了重头再来', '只因你太美', '成都', '晴天', '阳光总在风雨后']
print(song.index('只因你太美'))   # 2

print(song.index('晴天'))        # 0

print(song.index('偏爱'))        # ValueError: '偏爱' is not in list

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

song = [‘晴天’, ‘大不了重头再来’, ‘只因你太美’, ‘成都’, ‘晴天’, ‘阳光总在风雨后’]

song.reverse()
print(song)

7. 列表.sort() - 将列表中的元素从小到大排序（不会产生新的列表，直接修改原列表中元素的顺序）

列表.sort(reverse=True) - 将列表中的元素**从大到小排序（**不会产生新的列表，直接修改原列表中元素的顺序）

nums = [23, 99, 3, 56, 7, 23, 45]
nums.sort()
print(nums)    # [3, 7, 23, 23, 45, 56, 99]

nums = [23, 99, 3, 56, 7, 23, 45]
nums.sort(reverse=True)
print(nums)   # [99, 56, 45, 23, 23, 7, 3]

nums = [10, 20, 30, 10, 20, 40]
print(len(nums))    # 6
print(nums.count(20))   # 2
print(nums.index(30))  # 2

07. 列表的推导式

1.什么是列表推导式 - 用来快速产生一个列表的表达式

1)基本语法：

[表达式 for 变量 in 序列]

产生元素的原理：让变量去序列取值，一个一个的取每取一个值就将表达式的结果作为列表的一个元素
a = [ ]
for 变量 in 序列:
a.append(表达式)
返回 a

list1 = [1 for x in range(4)]   # [1, 1, 1, 1]

list2 = [x for x in range(4)]   # [0, 1, 2, 3]

list3 = [x**2 for x in range(4)]    # [0, 1, 4, 9]

list4 = [x+y for x, y in enumerate([10, 20, 30])]    # [10, 21, 32]

2)带条件语句的推导式

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

相当于：
a = [ ]
for 变量 in 序列:
if 条件语句:
a.append(表达式)
返回 a

list5 = [x for x in range(10, 20) if x % 3 == 0]  # [12, 15, 18]
print(list5)
list6 = [x for x in range(10, 20) if x % 2]
print(list6)   # [11, 13, 15, 17, 19]

练习1：删除列表中分数低于60的成绩（筛选）

scores = [10, 89, 78, 56, 45, 30, 99, 89, 76]
new_scores = [x for x in scores if x >= 60]
print(new_scores)   # [89, 78, 99, 89, 76]

练习2：将列表中所有的元素乘以2（变形）

nums = [2, 5, 9, 20]
new_nums = [x*2 for x in nums]
print(new_nums)    # [4, 10, 18, 40]

作业

已知一个数字列表，求列表中心元素。

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

已知一个数字列表，求所有元素和。

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
sum1 = 0
for x in nums:
 sum1 += x
print(sum1)

已知一个数字列表，输出所有奇数下标元素。

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
print(nums[1: -1: 2])

已知一个数字列表，输出所有元素中，值为奇数的元素。

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
list1 = []
for x in nums:
    if x % 2 != 0:
        list1.append(x)
print(list1)

已知一个数字列表，将所有元素乘二。

例如：nums = [1, 2, 3, 4] —> nums = [2, 4, 6, 8]

nums = [1, 2, 3, 4]
nums1 = []
for x in nums:
    x *= 2
    nums1.append(x)
print(nums1)

6.有一个长度是10的列表，数组内有10个人名，要求去掉重复的

例如:names = [‘张三’, ‘李四’, ‘大黄’, ‘大黄’, ‘张三’, ‘张三’, ‘张三’] -> names = [‘张三’, ‘李四’, ‘大黄’]

names = ['张三', '李四', '大黄', '大黄', '张三', '张三', '张三']
names1 = []
for x in names:
    if x not in names1:
        names1.append(x)
print(names1)

7.用一个列表来保存一个节目的所有分数，求平均分数(去掉一个最高分，去掉一个最低分，求最后得分)

scores = [75, 80, 95, 60, 74, 67, 85, 90, ]
scores1 = [75, 80, 95, 60, 74, 67, 85, 90, ]
x = max(scores)
y = min(scores)
scores.remove(x)
scores.remove(y)
sum1 = 0
for x in scores:
    sum1 += x
print(sum1 / len(scores1))

8.有两个列表A和B，使用列表C来获取两个列表中公共的元素

例如: A = [1, ‘a’, 4, 90] B = [‘a’, 8, ‘j’, 1] --> C = [1, ‘a’]

A = [1, 'a', 4, 90]
B = ['a', 8, 'j', 1]
C = []
for x in A:
    if x in B:
        C.append(x)
print(C)

9.*有一个数字列表，获取这个列表中的最大值.(注意: 不能使用max函数)

例如: nums = [19, 89, 90, 600, 1] —> 600

nums = [19, 89, 90, 600, 1]
list2 = [0]
for x in nums:
    if x > list2[0]:
        list2[0] = x
print(list2)

10.*获取列表中出现次数最多的元素

例如：nums = [1, 2, 3,1,4,2,1,3,7,3,3] —> 打印:3

创建一个列表，列表中有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]

nums = [70, 88, 91, 70, 107, 234, 91, 177, 282, 197]
nums1 = []
for x in nums:
    if x not in nums1:
        nums1.append(x)
nums1.sort(reverse=True)
print(nums1)

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

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

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

list1 = []
for x in range(1, 101):
    if x % 10 == 3 or x == 3:
        list1.append(x)
print(list1)

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

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

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

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

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

nums = ["good", "nice", "see you", "bye"]
list3 = [len(x) for x in nums]
print(list3)

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

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

list1 = [24, 'abc', 99, True, 21, 38, 'hello']
list2 = [x for x in list1 if type(x) != int or (x % 10) > 5]
print(list2)

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

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

list1 = [(10, 20, 30), ('abc', 'hello'), (1, 2, 3.4), (True, False)]
list2 = [x[-1] for x in list1]
print(list2)

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

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

list1 = [23, 4, 67, 88, 90, 21]
list2 = [x * 2 if x % 2 != 0 else int(x / 2) for x in list1]
print(list2)

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

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

list1 = [10, 20, 34, 10, 9, 78]
list2 = []
for x, y in enumerate(list1):
    if y == 10:
        list2.append(x)
print(list2)


20的下标：[1]

list1 = [10, 20, 34, 10, 9, 78]
list2 = []
for x, y in enumerate(list1):
    if y == 20:
        list2.append(x)
print(list2)

30的下标：[]

list1 = [10, 20, 34, 10, 9, 78]
list2 = []
for x, y in enumerate(list1):
    if y == 30:
        list2.append(x)
print(list2)

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

例如：
[1, 2, 3, 4, 5]   -> True
print(sorted(nums) == nums)

[23, 45, 78, 90]  -> True
print(sorted(nums1) == nums1)

[1, 3, 2, 4, 5]	-> False
print(sorted(nums2) == nums2)

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

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

A = [10, 20, 30, 40, 50]
B = [100, 200, 300]
list3 = []
index = 0
while len(list3) != len(A) + len(B):
    if index < len(A):
        list3.append(A[index])
    if index < len(B):
        list3.append(B[index])
    index += 1
print(list3)

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

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

A = [10, 20, 30, 40, 50]
B = [25, 44, 60]
print(sorted(A + B))