主要涉及知识点
列表是我们python里面最常见的数据类型，我们主要有以下的操作。
1、索引
2、切片
3、追加
4、删除
5、长度
6、循环 （也称遍历）
7、包含
8、嵌套
例如定义列表：
|
1
2
3
|
List2
=
[
'openstack'
,
'python'
,
'linux'
,
"docker"
,
"zabbix"
,
"nginx"
,
"linux"
,
"linux"
,
"123"
,
"ww33##"
]
或者
List2
=
list
([
'openstack'
,
'python'
,
'linux'
,
"docker"
,
"zabbix"
,
"nginx"
,
"linux"
,
"linux"
,
"123"
,
"ww33##"
])
|
主要涉及的基本方法以及介绍
| 方法名 |
方法介绍 |
简单示例 |
| append |
在列表末尾追加一个元素 |
List2.append('docker') 即可在末尾插入docker |
| Insert |
在列表中某一位置插入某元素 |
List2.insert(2,”mysql”) 这里的2指的是列表元组的下标 表示在第三位插入mysql |
| remove |
删除列表的某一元素 |
List2.remove("linux") 删除值为linux的元素 |
| clear |
清空列表的值， |
List2.clear() 类似于del List2 两者都能清空列表 |
| pop |
该方法默认删除最后一个元素 |
List2.pop() #默认删除最后一个元素 List2.pop(1)#删除下标为1的元素 |
| index |
索引，查找某个元素的位置 |
List2.index("linux") #查找linux的位置，查找结果为下标，如果有多个相同的元素，只能确定第一个元素的位置 |
| count |
统计某个元素出现几次 |
List2.count("linux")统计linux元素出现的次数 |
| reverse |
翻转，将列表元素前后位置置换 |
List2.reverse() #将列表元素翻转 print(List2) |
| sort() |
排序按照（AScall码）先是特殊符号，然后数字字母首字母 |
List2.sort() #将列表元素排序 print(List2) |
| copy |
复制列表 |
list3=List2.copy() print(List2,list3) |
| extend() |
可以合并两个列表，将某个列表的元素追加到一个列表 |
list1=['123',123,'abc'] List2.extend(list1) 打印List2 ['openstack', 'python', 'linux', 'docker', 'zabbix', 'nginx', 'linux', 'linux', '123', 'ww33##', '123', 123, 'abc'] |
简单的示例：
一、列表的定义
|
1
2
3
4
5
6
7
|
>>> List2
=
list
([
'openstack'
,
'python'
,
'linux'
,
"docker"
,
"zabbix"
,
"nginx"
,
"linux"
,"
linux
","
123
","
ww33
##"])
>>>
print
(List2)
[
'openstack'
,
'python'
,
'linux'
,
'docker'
,
'zabbix'
,
'nginx'
,
'linux'
,
'linux'
,
'123'
,
'ww33##'
]
或者List2
=
[
'openstack'
,
'python'
,
'linux'
,
"docker"
,
"zabbix"
,
"nginx"
,
"linux"
,"
linux
","
123
","
ww33
##"] 我们直接用后面的这种定义，检验和模拟相关方法和切片等。
|
二、切片与列表取值
切片主要就是针对获取列表中部分或者单个元素的方法，通过下标访问列表中的元素，下标从0开始计数
取列表中的某一个值（通过下标取值，下标从0开始）
|
1
2
3
4
5
6
7
8
9
10
11
|
List2
=
[
'openstack'
,
'python'
,
'linux'
,
"docker"
,
"zabbix"
,
"nginx"
,
"linux"
,
"linux"
,
"123"
,
"ww33##"
]
print
(List2[
0
])
print
(List2[
1
])
print
(List2[
-
2
])
结果：
openstack
python
123
我们发现在取值时下标为零的恰好取的值为是第一位元素，更好的证明了下标从零开始这一说法，
同时发现
print
(List2[
-
2
])恰好是倒数第二位元素，由此可见不仅顺着取值，可以倒着取值。
|
|
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
|
切片：访问里面的前多个值：
List2
=
[
'openstack'
,
'python'
,
'linux'
,
"docker"
,
"zabbix"
,
"nginx"
,
"linux"
,
"linux"
,
"123"
,
"ww33##"
]
print
(List2[
0
:
3
])
#取前三个
结果：
[
'openstack'
,
'python'
,
'linux'
]
再试试
print
(List2[:
3
])
结果：
[
'openstack'
,
'python'
,
'linux'
]
由此我们可以看出开始下标是
0
的时候，可以省略不写，还需要注意下标[
0
:
3
]能取到
1
,
2
,
3
位的元素，
即表示第四位取不到，在我们边界取值时需要注意。
print
(List2[
3
:
-
1
])
#取不到最后一位
print
(List2[
3
:])
#取得第四位到最后一位
print
(List2[
2
:
9
:
2
])
#取出下标为第二位到下标为9之间的 每隔一个元素取一次
print
(List2[
-
3
:
-
1
])
#倒着取值取出倒数第三位和倒数第二位
print
(List2[
-
3
:])
#取出倒数的后三位
print
(
List
[
0
::
2
])
#每隔一个元素取一次
print
(
list
[::
2
])
#每隔一个元素取一次 和上面的一样
结果：
[
'docker'
,
'zabbix'
,
'nginx'
,
'linux'
,
'linux'
,
'123'
]
[
'docker'
,
'zabbix'
,
'nginx'
,
'linux'
,
'linux'
,
'123'
,
'ww33##'
]
[
'linux'
,
'zabbix'
,
'linux'
,
'123'
]
[
'linux'
,
'123'
]
[
'linux'
,
'123'
,
'ww33##'
]
|
三、列表增加元素
主要使用append的方法追加元素，在末尾增加
|
1
2
3
4
|
List2.append(
"winner"
)
print
(List2)
结果：
[
'openstack'
,
'python'
,
'linux'
,
'docker'
,
'zabbix'
,
'nginx'
,
'linux'
,
'linux'
,
'123'
,
'ww33##'
,
'winner'
]
|
在某一位置插入一元素，可以使用insert方法实现
|
1
2
3
4
5
|
List2.insert(
2
,
"baidu"
)
#在第三位插入元素baidu
print
(List2)
结果：
[
'openstack'
,
'python'
,
'baidu'
,
'linux'
,
'docker'
,
'zabbix'
,
'nginx'
,
'123'
,
'ww33##'
]
由此看出在某位置插入时，该位置元素整体向后移动。
|
给列表中增加元素除了insert和append方法外，我们还可以使用“+”号的方式增加元素
|
1
2
3
|
list2
=
[
"winner"
,
"mysql5.6"
,
"mariadb"
,
"redis"
,
"tomcat"
,
"redis"
]
>>> list2
+
[
1998
,
2007
,
2017
,
"winnerlook"
,
"openstack"
]
[
'winner'
,
'mysql5.6'
,
'mariadb'
,
'redis'
,
'tomcat'
,
'redis'
,
1998
,
2007
,
2017
,
'winnerlook'
,
'openstack'
]
|
此外我们还可以使用extend方法增加元素
|
1
2
3
|
list2.extend([
"DBA"
,
"linux SRA"
])
>>> list2
[
'winner'
,
'mysql5.6'
,
'mariadb'
,
'redis'
,
'tomcat'
,
'redis'
,
'DBA'
,
'linux SRA'
]
|
小结：
1.+ 运算符连接列表以创建一个新列表。列表可包含任何数量的元素；没有大小限制（除了可用内存的限制）。然而，如果内存是个问题，那就必须知道在进行连接操作时，将在内存中创建第二个列表。在该情况下，新列表将会立即被赋值给已有变量 a_list 。因此，实际上该行代码包含两个步骤 — 连接然后赋值 — 当处理大型列表时，该操作可能（暂时）消耗大量内存。
2.列表可包含任何数据类型的元素，单个列表中的元素无须全为同一类型。下面的列表中包含一个字符串、一个浮点数和一个整数。
3.append() 方法向列表的尾部添加一个新的元素。（现在列表中有 四种 不同数据类型！）
4. 列表是以类的形式实现的。“创建”列表实际上是将一个类实例化。因此，列表有多种方法可以操作。extend() 方法只接受列表作为参数，并将该参数的每个元素都添加到原有的列表中。
5. insert() 方法将单个元素插入到列表中。第一个参数是列表中将被顶离原位的第一个元素的位置索引。列表中的元素并不一定要是唯一的；比如说：现有两个各自独立的元素，其值均为 'Ω':，第一个元素 a_list[0] 以及最后一个元素 a_list[6] 。
entend()和eppend()方法区别
1.extend() 方法只接受一个参数，而该参数总是一个列表，并将列表 a_list 中所有的元素都添加到该列表中。
2.如果开始有个 3 元素列表，然后将它与另一个 3 元素列表进行 extend 操作，结果是将获得一个 6 元素列表。
3. 另一方面， append() 方法只接受一个参数，但可以是任何数据类型。在此，对一个 3 元素列表调用 append() 方法。
4. 如果开始的时候有个 6 元素列表，然后将一个列表 append［添加］上去，结果就会……得到一个 7 元素列表。为什么是 7 个？因为最后一个元素（刚刚 append［添加］ 的元素） 本身是个列表 。列表可包含任何类型的数据，包括其它列表。这可能是你所需要的结果，也许不是。但如果这就是你想要的，那这就是你所得到的。
四、修改某元素的值
修改某元素的值，一般通过重新赋值的方法实现。
|
1
2
3
4
5
|
List2[
2
]
=
"我的钢铁"
List2[
-
1
]
=
"人生苦短，我用python!"
#List2.insert(2,"baidu")
print
(List2)
[
'openstack'
,
'python'
,
'我的钢铁'
,
'docker'
,
'zabbix'
,
'nginx'
,
'123'
,
'人生苦短，我用python!'
]
|
五、删除
删除分为删除一个和全部删除，在删除个别的时候，我们可以用remove()方法和pop()方法，用del和clear()方法可以删除整个列表。接下来根据实例分析一下几种方法有什么区别。
pop()方法中间的参数是下标，不带参数的时候默认删除最后一位。
|
1
2
3
4
5
6
7
8
|
List2.pop(
1
)
print
(List2)
结果
[
'openstack'
,
'linux'
,
'docker'
,
'zabbix'
,
'nginx'
,
'123'
,
'ww33##'
]
List2.pop(
-
4
)
print
(List2)
结果：
[
'openstack'
,
'python'
,
'linux'
,
'docker'
,
'nginx'
,
'123'
,
'ww33##'
]
|
remove()方法中间的参数直接是元素的内容
|
1
2
3
4
5
6
7
8
9
10
11
|
List2.remove(
'linux'
)
print
(List2)
结果：
[
'openstack'
,
'python'
,
'docker'
,
'zabbix'
,
'nginx'
,
'123'
,
'ww33##'
]
当列表存在相同元素linux时：
List2
=
[
'openstack'
,
'linux'
,
'python'
,
'linux'
,
"docker"
,
"zabbix"
,
"nginx"
,
"123"
,
'linux'
,
"ww33##"
]
List2.remove(
'linux'
)
print
(List2)
结果：
[
'openstack'
,
'python'
,
'linux'
,
'docker'
,
'zabbix'
,
'nginx'
,
'123'
,
'linux'
,
'ww33##'
]
当存在多个值时只会删除一个值
|
clear()方法使用 ，是对整个列表的处理
|
1
2
3
4
|
List2.clear()
print
(List2)
结果：
[]
|
del 可以删除整个列表或单个元素
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
del
List2
print
(List2)
del
List
[
2
]
结果：
Traceback (most recent call last):
File
"C:/Users/Administrator/PycharmProjects/s14/jiounumber.py"
, line
21
,
in
<module>
print
(List2)
NameError: name
'List2'
is
not
defined
删除个别元素 结合切片
List2
=
[
'openstack'
,
'云计算'
,
'python'
,
"中国"
,
"中东"
,
'linux'
,
123
,
"ww33##"
]
del
List2[
2
]
print
(List2)
结果：
[
'openstack'
,
'云计算'
,
'中国'
,
'中东'
,
'linux'
,
123
,
'ww33##'
]
|
观察结果，可以发现del是删除了定义的列表而，clear()是清空了列表的元素。
六、查询某个元素位置以及出现的次数（列表元素可以重复）
对列表的查询主要有统计列表是多大的长度和查询某内容的元素在什么位置，主要使用index()索引方法和count()元素出现次数方法实现，。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
List2
=
[
'openstack'
,
'python'
,
'linux'
,
"docker"
,
"zabbix"
,
"nginx"
,
"123"
,
"ww33##"
]
索引：
print
(List2.index(
"linux"
))
结果
2
统计：
print
(List2.count(
"linux"
))
结果
1
List2
=
[
'openstack'
,
'linux'
,
'python'
,
'linux'
,
"docker"
,
"zabbix"
,
'linux'
,
"nginx"
,
"123"
,
"ww33##"
]
print
(List2.index(
"linux"
))
print
(List2.count(
"linux"
))
结果：
1
3
|
由此可以看到，当一个元素含有多个形同的元素时，索引一般是找到第一个该元素。
七、列表的翻转以及排序
可以通过reverse()方法和sort()方法实现对列表的翻转和排序，所谓翻转，就是将列表元素的位置重翻转，而排序主要是根据Ascall码来排序，
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
List2
=
[
'openstack'
,
'linux'
,
'python'
,
'linux'
,
"docker"
,
"zabbix"
,
'linux'
,
"nginx"
,
"123"
,
"ww33##"
]
List2.reverse()
print
(List2)
结果：
[
'ww33##'
,
'123'
,
'nginx'
,
'linux'
,
'zabbix'
,
'docker'
,
'linux'
,
'python'
,
'linux'
,
'openstack'
]
排序：
List2.sort()
print
(List2)
[
'123'
,
'docker'
,
'linux'
,
'linux'
,
'linux'
,
'nginx'
,
'openstack'
,
'python'
,
'ww33##'
,
'zabbix'
]
再稍微复杂一点，里面添加中文和整数等内容
List2
=
[
'openstack'
,
'云计算'
,
'python'
,
123
,
"docker"
,
"zabbix"
,
'linux'
,
30.84
,
"123"
,
"ww33##"
]
List2.sort()
print
(List2)
执行结果：
Traceback (most recent call last):
File
"C:/Users/Administrator/PycharmProjects/s14/jiounumber.py"
, line
24
,
in
<module>
List2.sort()
TypeError: unorderable types:
int
() <
str
()
整型和字符串无法比较，接下来，再试试
List2
=
[
'openstack'
,
'云计算'
,
'python'
,
"中国"
,
"中东"
,
'linux'
,
"123"
,
"ww33##"
]
List2.sort()
print
(List2)
[
'123'
,
'linux'
,
'openstack'
,
'python'
,
'ww33##'
,
'中东'
,
'中国'
,
'云计算'
]
|
由此发现列表的排序还是很NB的，关于上面的整型和字符串无法比较的，我们可以将整形转换成字符串比较。
八、循环、包含以及copy()、extend()方法
循环，一般是通过for循环的方式将列表中的元素打印出来的方法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
List2
=
[
'openstack'
,
'云计算'
,
'python'
,
"中国"
,
"中东"
,
'linux'
,
"123"
,
"ww33##"
]
for
i
in
List2 :
print
(i)
print
(List2)
结果：
openstack
云计算
python
中国
中东
linux
123
ww33
##
[
'openstack'
,
'云计算'
,
'python'
,
'中国'
,
'中东'
,
'linux'
,
'123'
,
'ww33##'
]
通过循环我们就可以找出列表的每个元素。同时我们也可以看出这时的打印和之前的有所不同
|
包含 ：我们可以判断某个内容是否在该列表里面，结果的返回值是布尔值Ture或者False,存在为真不存在为假。
|
1
2
3
4
5
6
7
8
9
10
|
List2
=
[
'openstack'
,
'云计算'
,
'python'
,
"中国"
,
"中东"
,
'linux'
,
123
,
"ww33##"
]
print
(
'linuxww'
in
List2)
print
(
'中东'
in
List2)
print
(
123
in
List2)
print
(
12
in
List2)
结果：
False
True
True
False
|
entend方法 使用该方法，可以将两个列表合并到一个里面，同时对其中的一个值不会发生任何的影响。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
List2
=
[
'openstack'
,
'云计算'
,
'python'
,
"中国"
,
"中东"
,
'linux'
,
123
,
"ww33##"
]
List1
=
[
123
,
'abc'
,
'中国'
]
#print( 'linuxww' in List2)
#print('中东' in List2)
print
(List2,List1)
print
(List1)
List1.clear()
print
(List1)
结果：
[
'openstack'
,
'云计算'
,
'python'
,
'中国'
,
'中东'
,
'linux'
,
123
,
'ww33##'
] [
123
,
'abc'
,
'中国'
]
[
123
,
'abc'
,
'中国'
]
[]
由此发现extend方法并不会影响被合并列表（List1）的值，只有自己做其他操作时才会发生变化。
|
copy()方法
可以实现列表的复制
|
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
|
List2
=
[
'openstack'
,
'云计算'
,
'python'
,
"中国"
,
"中东"
,
'linux'
,
123
,
"ww33##"
]
list3
=
List2.copy()
print
(List2,list3)
结果：
[
'openstack'
,
'云计算'
,
'python'
,
'中国'
,
'中东'
,
'linux'
,
123
,
'ww33##'
]
[
'openstack'
,
'云计算'
,
'python'
,
'中国'
,
'中东'
,
'linux'
,
123
,
'ww33##'
]
注意事项：
List2
=
[
'openstack'
,
'云计算'
,
'python'
,[
"中国"
,
"中东"
],
'linux'
,
123
,
"ww33##"
]
list3
=
List2.copy()
print
(List2)
print
(list3)
List2[
2
]
=
"MYSQl DBA"
List2[
3
][
1
]
=
"北京"
print
(List2)
print
(list3)
执行结果：
[
'openstack'
,
'云计算'
,
'python'
, [
'中国'
,
'中东'
],
'linux'
,
123
,
'ww33##'
]
[
'openstack'
,
'云计算'
,
'python'
, [
'中国'
,
'中东'
],
'linux'
,
123
,
'ww33##'
]
[
'openstack'
,
'云计算'
,
'MYSQl DBA'
, [
'中国'
,
'北京'
],
'linux'
,
123
,
'ww33##'
]
[
'openstack'
,
'云计算'
,
'python'
, [
'中国'
,
'北京'
],
'linux'
,
123
,
'ww33##'
]
我们将列表List2中的List2[
2
]的python和List2[
3
][
1
]的中东更改为List2[
2
]
=
"MYSQl DBA"
和List2[
3
][
1
]
=
"北京
输出后发现复制的那一部分List2[
3
][
1
]复制后是一样的，而List2[
2
]的值会不一样。主要是内存的地址原因。
同时对这种情况想要复制相同的是不行的
List2
=
[
'openstack'
,
'云计算'
,
'python'
,[
"中国"
,
"中东"
],
'linux'
,
123
,
"ww33##"
]
list3
=
List2
print
(List2)
print
(list3)
List2[
2
]
=
"MYSQl DBA"
List2[
3
][
1
]
=
"北京"
print
(List2)
print
(list3)
这里给list3赋值为List2这时会发现更改List2时，会直接更改list3的值
[
'openstack'
,
'云计算'
,
'python'
, [
'中国'
,
'中东'
],
'linux'
,
123
,
'ww33##'
]
[
'openstack'
,
'云计算'
,
'python'
, [
'中国'
,
'中东'
],
'linux'
,
123
,
'ww33##'
]
[
'openstack'
,
'云计算'
,
'MYSQl DBA'
, [
'中国'
,
'北京'
],
'linux'
,
123
,
'ww33##'
]
[
'openstack'
,
'云计算'
,
'MYSQl DBA'
, [
'中国'
,
'北京'
],
'linux'
,
123
,
'ww33##'
]
要想复制完全一样的，我们可以导入copy模块
import
copy
List2
=
[
'openstack'
,
'云计算'
,
'python'
,[
"中国"
,
"中东"
],
'linux'
,
123
,
"ww33##"
]
list3
=
copy.deepcopy(List2)
print
(List2)
print
(list3)
List2[
2
]
=
"MYSQl DBA"
List2[
3
][
1
]
=
"北京"
print
(List2)
print
(list3)
执行的结果：
[
'openstack'
,
'云计算'
,
'python'
, [
'中国'
,
'中东'
],
'linux'
,
123
,
'ww33##'
]
[
'openstack'
,
'云计算'
,
'python'
, [
'中国'
,
'中东'
],
'linux'
,
123
,
'ww33##'
]
[
'openstack'
,
'云计算'
,
'MYSQl DBA'
, [
'中国'
,
'北京'
],
'linux'
,
123
,
'ww33##'
]
[
'openstack'
,
'云计算'
,
'python'
, [
'中国'
,
'中东'
],
'linux'
,
123
,
'ww33##'
]
这时发现，List2元素的值改变不会影响list3的值，下面的这种copy，我们称为deep.copy，而列表的
copy()方法是一种浅copy
|
九、列表的其他操作
除了以上主要操作，我们还可以对列表做以下的操作。列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表
|
1
2
3
4
5
6
7
8
|
List2
=
[
'openstack'
,
'云计算'
,
'python'
,
"中国"
,
"中东"
,
'linux'
,
123
]
list3
=
[
"open"
,
"ip"
,
"config"
]
print
(List2
+
list3)
print
(list3
*
3
)
结果：
[
'openstack'
,
'云计算'
,
'python'
,
'中国'
,
'中东'
,
'linux'
,
123
,
'open'
,
'ip'
,
'config'
]
[
'open'
,
'ip'
,
'config'
,
'open'
,
'ip'
,
'config'
,
'open'
,
'ip'
,
'config'
]
+
号实现的功能和之前的append()方式一样，而
*
表示重复，后面的的数字表示重复的次数。
|
python列表函数
在上面我们分析了python的列表方法，python列表还有一部分列表函数，常见的有max(list),min(list)以及len(list)和list(seq):
len(list ) 就是上面提到的列表的长度，
max(list) 列表的最大值
min(list)列表的最小值
list(seq)将元组转换为列表，我们知道元组的基本属性和列表一样，区别就在于列表使用[]方括号定义，而元组是()小括号定义，以及元组的元素不能重新赋值。
示例
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
List2
=
[
'openstack'
,
'云计算'
,
'python'
,
"中国"
,
"中东"
,
'linux'
,
123
]
list3
=
[
"open"
,
"ip"
,
"config"
,
'999'
,
'2929'
,]
tet
=
(
"www"
,
"www"
,
1234
)
print
(
type
(tet))
print
(
list
(tet))
print
(
type
(
list
(tet)))
print
(List2
+
list3)
print
(list3
*
3
)
print
(
len
(list3))
print
(
max
(list3))
print
(
min
(list3))
结果：
<
class
'tuple'
>
#元组tet的类型
[
'www'
,
'www'
,
1234
]
#print(list(tet))元组转换列表输出
<
class
'list'
>
#print(type(list(tet)))元组转化列表后的类型验证
[
'openstack'
,
'云计算'
,
'python'
,
'中国'
,
'中东'
,
'linux'
,
123
,
'open'
,
'ip'
,
'config'
,
'999'
,
'2929'
]
[
'open'
,
'ip'
,
'config'
,
'999'
,
'2929'
,
'open'
,
'ip'
,
'config'
,
'999'
,
'2929'
,
'open'
,
'ip'
,
'config'
,
'999'
,
'2929'
]
5
#print(len(list3))列表list3的长度统计
open
#print(max(list3)) 列表的最大值
2929
#print(min(list3)) 列表最小值
|
十、列表的嵌套
在上面讲到列表的copy()方法时，我们就用到了列表，因为列表的元素可以是任何类型，所以列表的元素还可以是列表，这时候的列表就会形成嵌套关系。
例如：
|
1
2
3
4
|
List2
=
[
'openstack'
,
'云计算'
,
'python'
,
"中国"
,
"中东"
,[[
"open"
,
"ip"
],
"config"
,
'999'
,
'2929'
,]]
print
(List2)
结果： 实现三层嵌套
[
'openstack'
,
'云计算'
,
'python'
,
'中国'
,
'中东'
, [[
'open'
,
'ip'
],
'config'
,
'999'
,
'2929'
]]
|
十一、列表嵌套处理
列表有很好的灵活性，我们可以使用列表的嵌套，但是在使用列表嵌套的时候，我们要想简单的实现嵌套列表的遍历就会发现一定的问题，代码和实践如下：
|
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
|
#!/usr/bin/env python
#_*_coding:utf-8_*_
list3
=
[
"openatck"
,
"docker"
,
"linux"
,
"and"
,
"list"
,
"dict"
,
"set"
,[[
"openatck646646"
,
"docker47575"
],
for
each_item
in
list3:
if
isinstance
(each_item,
list
):
for
seach_item
in
each_item:
print
(seach_item)
else
:
print
(each_item)
结果：
openatck
docker
linux
and
list
dict
set
[
'openatck646646'
,
'docker47575'
]
linux8888
上面定义的列表是一个三层的嵌套，我们用循环遍历的时候发现还是显示列表，所以我们在这里就对列表
处理，就是进行下面的处理，多次判断是否包含列表。需要注意的是isintance(
object
,
type
),这里的
对象名不能是
list
,否则
type
输入
list
会报错的，这就是占用关键字报错的原因。
更改完善后：
#!/usr/bin/env python
#_*_coding:utf-8_*_
list3
=
[
"openatck"
,
"docker"
,
"linux"
,
"and"
,
"list"
,
"dict"
,
"set"
,[[
"openatck646646"
,
"docker47575"
],
"weinenr"
,
"qee"
]]
for
each_item
in
list3:
if
isinstance
(each_item,
list
):
for
seach_item
in
each_item:
if
isinstance
(seach_item,
list
):
for
each_item2
in
seach_item:
print
(each_item2)
else
:
print
(seach_item)
else
:
print
(each_item)
结果：
openatck
docker
linux
and
list
dict
set
openatck646646
docker47575
weinenr
qee
由于是
3
层的嵌套所以需要进行
2
层的输出格式的判断，如果存在列表则继续循环遍历，不是列表则
直接输出
|
总结：以上内容主要是python中对列表的操作，全部属于基础知识，并且所有的示例都是亲手实践所得到的结果,由于经验不足，或许只能理解列表知识的一部分，还请各位朋友多多指教！
