嵌套列表&列表切片&列表推导式

109 阅读 0 评论 72 点赞

我是靠谱客的博主欢喜丝袜，这篇文章主要介绍嵌套列表&列表切片&列表推导式，现在分享给大家，希望可以做个参考。

一、列表使用【重点掌握】

1.列表嵌套

列表的嵌套，其实就是一个列表中的元素又是一个列表

注意：操作嵌套列表，只要把要操作元素的下标当作变量名来使用即可
复制代码# 1.一维列表 list1 = [23,5,6,7,7] print(list1[1]) for n1 in list1: print(n1) # 2.二维列表 list2 = [[2,3,4],[True,False],["abc",4,6,7]] print(list2[1]) print(list2[1][0]) """ 工作原理： list2中存储了三个小列表的地址三个小列表中又分别存储了不同数据的地址 """ # 二维列表的遍历 # 方式一 for sublist in list2: for ele in sublist: print(ele) # 方式二 for i in range(len(list2)): for j in range(len(list2[i])): print(list2[i][j])
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
# 1.一维列表
list1 = [23,5,6,7,7]
print(list1[1])
for n1 in list1:
    print(n1)


# 2.二维列表
list2 = [[2,3,4],[True,False],["abc",4,6,7]]
print(list2[1])
print(list2[1][0])

"""
工作原理：
    list2中存储了三个小列表的地址
    三个小列表中又分别存储了不同数据的地址
"""

# 二维列表的遍历
# 方式一
for sublist in list2:
    for ele in sublist:
        print(ele)


# 方式二
for i in range(len(list2)):
    for j in range(len(list2[i])):
        print(list2[i][j])

2.列表切片

复制代码""" 【面试题】什么是切片，请举例说明切片：根据指定的区间，指定的步长，在列表，元组或字符串等有序集合中进行截取，形成一个新的列表，元组或字符串语法：列表名[start:end:step] start:开始索引，可以省略，默认为0，不省略的情况下包含在内 end:结束索引，可以省略，默认为索引的结束【len - 1 或 -len】,不省略的情况下不包含在内 step：表示步长，可以省略，默认为1 索引： 0 1 2 3 4 5 6 7 8 -9 -8 -7 -6 -5 -4 -3 -2 -1 注意：切片之后会得到一个新的列表，对原列表没有任何影响 """ list1 = [11,22,33,44,55,66,77,88,99] # 一、一般情况 # 1.省略step print(list1[1:4]) # [22, 33, 44] print(list1[1:4:1]) # [22, 33, 44] print("*" * 30) # 2.省略start print(list1[:4]) # [11,22,33,44] print(list1[:4:1]) print("*" * 30) # 3.省略end print(list1[1:]) # [22, 33, 44, 55, 66, 77, 88, 99] print(list1[1::1]) # [22, 33, 44, 55, 66, 77, 88, 99] print(list1[1:8]) # [22, 33, 44, 55, 66, 77, 88] # 注意：start不管是否省略，都包含在内，但是，end如果不省略，则不包含，省略则包含在内 print("*" * 30) list1 = [11,22,33,44,55,66,77,88,99] # 4.start和end都是正数 """ 结论1：如果start和end同符号，则可以采用如下规律判断 a.计算start + step的结果 b.判断上述结果是否在start和end区间内 c.如果不在区间内，则结果直接为[],如果存在，则依次计算 """ print(list1[1:6:2]) # [22,44,66] print(list1[1:6:-1]) # [] print(list1[6:1:1]) # [] print(list1[6:1:-1]) # [77, 66, 55, 44, 33] print("*" * 30) list1 = [11,22,33,44,55,66,77,88,99] # 5.start和end都是负数 print(list1[-1:-6:1]) # [] print(list1[-1:-6:-1]) # [99,88,77,66,55] print(list1[-6:-1:1]) # [44,55,66,77,88] print(list1[-6:-1:-1]) # [] print("*" * 30) # 6.start和end一个为正数，一个为负数 """ 结论2：如果start和end一个为正数，一个为负数，则判断的索引以start的正负作为参考 """ """ 索引： 0 1 2 3 4 5 6 7 8 -9 -8 -7 -6 -5 -4 -3 -2 -1 """ list1 = [11,22,33,44,55,66,77,88,99] print(list1[1:-6:1]) # [1:-6:1]---》[1:3:1]---》[22,33] print(list1[1:-6:-1]) # [1:-6:-1]--->[1:3:-1]--->[] print(list1[-1:6:1]) # [-1:6:1]----》[-1:-3:1]---》[] print(list1[-1:6:-1]) # [-1:6:-1]--->[-1:-3:-1]----》[99,88] print(list1[-5:6:1]) # [-5:6:1]----》[-5:-3:1]---》[55,66] print("*" * 30) # 二、特殊情况 # 1 # print(list1[100]) # IndexError print(list1[100:]) # [] # 2. print(list1[0:-1]) # [11, 22, 33, 44, 55, 66, 77, 88] print(list1[0:8]) # [11, 22, 33, 44, 55, 66, 77, 88] # 3. print(list1[4:100]) # [55, 66, 77, 88, 99] print(list1[4:]) # [55, 66, 77, 88, 99] # 4. print(list1[::1]) # 拷贝，顺序获取 [11, 22, 33, 44, 55, 66, 77, 88, 99] print(list1[0:9:1]) print(list1[::-1]) # 逆序获取 [99, 88, 77, 66, 55, 44, 33, 22, 11] print(list1[-1:-10:-1]) # 5. print(list1[-1:0]) # [-1:-9:1]---->[] print(list1[-1:0:-1]) # [-1:-9:-1]---->[99,88,.....22] # 6. """ 结论3：start和step未省略，end省略，step为正数，则向右获取，step为负数，向左获取 """ print(list1[-6::1]) # [44, 55, 66, 77, 88, 99] print(list1[-6::-1]) # [44, 33, 22, 11] print(list1[6::1]) # [77, 88, 99] print(list1[6::-1]) # [77, 66, 55, 44, 33, 22, 11] print(list1[0::1]) # [11, 22, 33, 44, 55, 66, 77, 88, 99] print(list1[0::-1]) # [11]
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
"""
【面试题】什么是切片，请举例说明


切片：根据指定的区间，指定的步长，在列表，元组或字符串等有序集合中进行截取，形成一个新的列表，元组或字符串

语法：列表名[start:end:step]
    start:开始索引，可以省略，默认为0，不省略的情况下包含在内
    end:结束索引，可以省略，默认为索引的结束【len - 1  或 -len】,不省略的情况下不包含在内
    step：表示步长，可以省略，默认为1

索引：
    0   1   2   3   4   5   6   7   8
  -9   -8  -7  -6  -5  -4  -3  -2   -1

注意：切片之后会得到一个新的列表，对原列表没有任何影响
"""
list1 = [11,22,33,44,55,66,77,88,99]


# 一、一般情况
# 1.省略step
print(list1[1:4])  # [22, 33, 44]
print(list1[1:4:1]) # [22, 33, 44]

print("*" * 30)

# 2.省略start
print(list1[:4])  # [11,22,33,44]
print(list1[:4:1])

print("*" * 30)

# 3.省略end
print(list1[1:])  # [22, 33, 44, 55, 66, 77, 88, 99]
print(list1[1::1])  # [22, 33, 44, 55, 66, 77, 88, 99]
print(list1[1:8])  # [22, 33, 44, 55, 66, 77, 88]

# 注意：start不管是否省略，都包含在内，但是，end如果不省略，则不包含，省略则包含在内

print("*" * 30)

list1 = [11,22,33,44,55,66,77,88,99]

# 4.start和end都是正数
"""
结论1：

如果start和end同符号，则可以采用如下规律判断
    a.计算start + step的结果
    b.判断上述结果是否在start和end区间内
    c.如果不在区间内，则结果直接为[],如果存在，则依次计算
"""
print(list1[1:6:2])   # [22,44,66]
print(list1[1:6:-1])  # []

print(list1[6:1:1])   # []
print(list1[6:1:-1])  # [77, 66, 55, 44, 33]

print("*" * 30)

list1 = [11,22,33,44,55,66,77,88,99]

# 5.start和end都是负数
print(list1[-1:-6:1])   # []
print(list1[-1:-6:-1])  # [99,88,77,66,55]

print(list1[-6:-1:1])   # [44,55,66,77,88]
print(list1[-6:-1:-1])  # []

print("*" * 30)


# 6.start和end一个为正数，一个为负数
"""
结论2：如果start和end一个为正数，一个为负数，则判断的索引以start的正负作为参考
"""
"""
索引：
    0   1   2   3   4   5   6   7   8
   -9  -8  -7  -6  -5  -4  -3  -2   -1
"""
list1 = [11,22,33,44,55,66,77,88,99]

print(list1[1:-6:1])   # [1:-6:1]---》[1:3:1]---》[22,33]
print(list1[1:-6:-1])  # [1:-6:-1]--->[1:3:-1]--->[]

print(list1[-1:6:1])   # [-1:6:1]----》[-1:-3:1]---》[]
print(list1[-1:6:-1])  # [-1:6:-1]--->[-1:-3:-1]----》[99,88]


print(list1[-5:6:1])  # [-5:6:1]----》[-5:-3:1]---》[55,66]

print("*" * 30)


# 二、特殊情况
# 1
# print(list1[100])   # IndexError
print(list1[100:])   # []


# 2.
print(list1[0:-1])   # [11, 22, 33, 44, 55, 66, 77, 88]
print(list1[0:8])    # [11, 22, 33, 44, 55, 66, 77, 88]


# 3.
print(list1[4:100])  # [55, 66, 77, 88, 99]
print(list1[4:])     # [55, 66, 77, 88, 99]


# 4.
print(list1[::1])  # 拷贝，顺序获取  [11, 22, 33, 44, 55, 66, 77, 88, 99]
print(list1[0:9:1])

print(list1[::-1])  # 逆序获取    [99, 88, 77, 66, 55, 44, 33, 22, 11]
print(list1[-1:-10:-1])


# 5.
print(list1[-1:0])   # [-1:-9:1]---->[]
print(list1[-1:0:-1])   # [-1:-9:-1]---->[99,88,.....22]


# 6.
"""
结论3：start和step未省略，end省略，step为正数，则向右获取，step为负数，向左获取
"""
print(list1[-6::1])   # [44, 55, 66, 77, 88, 99]
print(list1[-6::-1])  # [44, 33, 22, 11]

print(list1[6::1])   # [77, 88, 99]
print(list1[6::-1])  # [77, 66, 55, 44, 33, 22, 11]

print(list1[0::1])   # [11, 22, 33, 44, 55, 66, 77, 88, 99]
print(list1[0::-1])   # [11]

二、列表推导式【重点掌握】

列表推导式，就是指的轻量级循环创建列表
复制代码# 列表推导式/列表生成式:是Python提供的用于创建一个列表的快捷方式 # 语法：[新列表中元素的规律 for循环 if语句] # 执行顺序：for循环----》if语句【可省略】----》元素规律 # 1.需求：生成一个列表[2,4,6,8,10] # 方式一 list1 = list(range(2,11,2)) print(list1) # 方式二 new_list1 = [] for i in range(1,6): new_list1.append(i * 2) print(new_list1) # 方式三 ******* new_list2 = [i * 2 for i in range(1,6)] print(new_list2) print(type(new_list2)) # 练习：生成一个列表[1,4,9,16,25] new_list3 = [pow(i,2) for i in range(1,6)] print(new_list3) # 2.生成一个列表[1,9,25,49,81] new_list21 = [i ** 2 for i in range(1,10,2)] print(new_list21) new_list22 = [i ** 2 for i in range(1,10) if i % 2 == 1] print(new_list22) # 练习：生成一个列表，其中的元素是1~30之间3的倍数 new_list23 = [i for i in range(1,31) if i % 3 == 0] print(new_list23) new_list23 = [i * 3 for i in range(1,11)] print(new_list23) # 3.在列表推导式中可以书写多个for或if，相当于嵌套,从左往右是依次嵌套的关系 list31 = [] for a in "abc": for b in "xyz": list31.append(a + b) print(list31) list32 = [a + b for a in "abc" for b in "xyz"] print(list32) list33 = [i for i in range(1,31) if i % 3 == 0 if i % 6 == 0] print(list33) # 练习：已知列表[3,5,6,7,"abc",56,True,"gagha"],将其中的数字元素提取出来，生成一个新的列表 list1 = [3,5,6,7,"abc",56,True,"gagha"] list41 = [ele for ele in list1 if type(ele) == int] print(list41) # isinstance(变量，类型)：判断一个变量的类型是否是指定类型 list42 = [ele for ele in list1 if isinstance(ele,int)] print(list42)
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
# 列表推导式/列表生成式:是Python提供的用于创建一个列表的快捷方式
# 语法：[新列表中元素的规律  for循环  if语句]
# 执行顺序：for循环----》if语句【可省略】----》元素规律


# 1.需求：生成一个列表[2,4,6,8,10]
# 方式一
list1 = list(range(2,11,2))
print(list1)

# 方式二
new_list1 = []
for i in range(1,6):
    new_list1.append(i * 2)
print(new_list1)

# 方式三                   *******
new_list2 = [i * 2 for i in range(1,6)]
print(new_list2)
print(type(new_list2))

# 练习：生成一个列表[1,4,9,16,25]
new_list3 = [pow(i,2) for i in range(1,6)]
print(new_list3)


# 2.生成一个列表[1,9,25,49,81]
new_list21 = [i ** 2 for i in range(1,10,2)]
print(new_list21)


new_list22 = [i ** 2 for i in range(1,10) if i % 2 == 1]
print(new_list22)


# 练习：生成一个列表，其中的元素是1~30之间3的倍数
new_list23 = [i for i in range(1,31) if i % 3 == 0]
print(new_list23)

new_list23 = [i * 3 for i in range(1,11)]
print(new_list23)

# 3.在列表推导式中可以书写多个for或if，相当于嵌套,从左往右是依次嵌套的关系
list31 = []
for a in "abc":
    for b in "xyz":
        list31.append(a + b)
print(list31)

list32 = [a + b for a in "abc" for b in "xyz"]
print(list32)


list33 = [i for i in range(1,31) if i % 3 == 0 if i % 6 == 0]
print(list33)

# 练习：已知列表[3,5,6,7,"abc",56,True,"gagha"],将其中的数字元素提取出来，生成一个新的列表
list1 = [3,5,6,7,"abc",56,True,"gagha"]
list41 = [ele for ele in list1 if type(ele) == int]
print(list41)

# isinstance(变量，类型)：判断一个变量的类型是否是指定类型
list42 = [ele for ele in list1 if isinstance(ele,int)]
print(list42)