【Python】列表（list）的基础操作_python列表的基本操作

Python列表创建

使用 [ ] 直接创建列表

使用 [ ] 直接创建列表

listname = [element1 , element2 , element3 , ... , elementn]
1

比如：

num = [1, 2, 3, 4, 5, 6, 7]
1

另外，使用此方式创建列表时，列表中元素可以有多个，也可以一个都没有，例如：

emptylist = [ ]
1

使用 list() 函数创建列表

除了使用[ ]创建列表外，Python 还提供了一个内置的函数 list()，使用它可以将其它数据类型转换为列表类型。
例如：

#将字符串转换成列表
2. list1 = list("hello")
3. print(list1)
4.
4. #将元组转换成列表
5. tuple1 = ('Python', 'Java', 'C++', 'JavaScript')
6. list2 = list(tuple1)
7. print(list2)
9.
8. #将字典转换成列表
9. dict1 = {'a':100, 'b':42, 'c':9}
10. list3 = list(dict1)
11. print(list3)
14.
12. #将区间转换成列表
13. range1 = range(1, 6)
14. list4 = list(range1)
15. print(list4)```
#创建空列表
16. print(list())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行结果：

['h', 'e', 'l', 'l', 'o']
['Python', 'Java', 'C++', 'JavaScript']
['a', 'b', 'c']
[1, 2, 3, 4, 5]
[]
1
2
3
4
5

Python访问列表元素

列表是 Python 序列的一种，我们可以使用索引（Index）访问列表中的某个元素（得到的是一个元素的值），
也可以使用切片访问列表中的一组元素（得到的是一个新的子列表）。
使用索引访问列表元素的格式为：

listname[i]
1

其中，listname 表示列表名字，i 表示索引值。列表的索引可以是正数，也可以是负数。
使用切片访问列表元素的格式为：

listname[start : end : step]
1

其中，listname 表示列表名字，start 表示起始索引，end 表示结束索引，step 表示步长。

1. url = list("http://c.biancheng.net/shell/")
2.
3. #使用索引访问列表中的某个元素
4. print(url[3]) #使用正数索引
5. print(url[-4]) #使用负数索引
6.
7. #使用切片访问列表中的一组元素
8. print(url[9: 18]) #使用正数切片
9. print(url[9: 18: 3]) #指定步长
10. print(url[-6: -1]) #使用负数切片
1
2
3
4
5
6
7
8
9
10

运行结果：

p
e
['b', 'i', 'a', 'n', 'c', 'h', 'e', 'n', 'g']
['b', 'n', 'e']
['s', 'h', 'e', 'l', 'l']
1
2
3
4
5

Python 删除列表

实际开发中并不经常使用 del 来删除列表，因为 Python 自带的垃圾回收机制会自动销毁无用的列表，即使开发者不手动删除，Python 也会自动将其回收。
del 关键字的语法格式为：

del listname
1

Python 删除列表实例演示：

1. intlist = [1, 45, 8, 34]
2. print(intlist)
3. del intlist
4. print(intlist)
1
2
3
4

运行结果：

[1, 45, 8, 34]
Traceback (most recent call last):
File "C:\Users\mozhiyan\Desktop\demo.py", line 4, in <module>
print(intlist)
NameError: name 'intlist' is not defined
1
2
3
4
5

Python list 列表添加元素

“+”号添加

1. language = ["Python", "C++", "Java"]
2. birthday = [1991, 1998, 1995]
3. info = language + birthday
4.
5. print("language =", language)
6. print("birthday =", birthday)
7. pri nt("info =", info)
1
2
3
4
5
6
7

运行结果：

language = ['Python', 'C++', 'Java']
birthday = [1991, 1998, 1995]
info = ['Python', 'C++', 'Java', 1991, 1998, 1995]
1
2
3

特点：使用+会生成一个新的列表，原有的列表不会被改变。
+更多的是用来拼接列表，而且执行效率并不高，如果想在列表中插入元素，应该使用下面几个专门的方法。

append()方法添加

append() 方法用于在列表的末尾追加元素。

listname.append(obj)
1

其中，listname 表示要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列
表、元组等。

1. l = ['Python', 'C++', 'Java']
2. #追加元素
3. l.append('PHP')
4. print(l)
5.
6. #追加元组，整个元组被当成一个元素
7. t = ('JavaScript', 'C#', 'Go')
8. l.append(t)
9. print(l)
10.
11. #追加列表，整个列表也被当成一个元素
12. l.append(['Ruby', 'SQL'])
13. print(l)
1
2
3
4
5
6
7
8
9
10
11
12
13

运行结果：

['Python', 'C++', 'Java', 'PHP']
['Python', 'C++', 'Java', 'PHP', ('JavaScript', 'C#', 'Go')]
['Python', 'C++', 'Java', 'PHP', ('JavaScript', 'C#', 'Go'), ['Ruby', 'SQL']]
1
2
3

特点：此方法会将它们视为一个整体，作为一个元素添加到列
表中，从而形成包含列表和元组的新列表。

extend()方法添加

extend() 和 append() 的不同之处在于：extend() 不会把列表或者元祖视为一个整体，而是把它们包含的元素
逐个添加到列表中。

extend() 方法的语法格式如下：

listname.extend(obj)
1

其中，listname 指的是要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是
列表、元组等，但不能是单个的数字。

1. l = ['Python', 'C++', 'Java']
2. #追加元素
3. l.extend('C')
4. print(l)
5.
6. #追加元组，元祖被拆分成多个元素
7. t = ('JavaScript', 'C#', 'Go')
8. l.extend(t)
9. print(l)
10.
11. #追加列表，列表也被拆分成多个元素
12. l.extend(['Ruby', 'SQL'])
13. print(l)
1
2
3
4
5
6
7
8
9
10
11
12
13

运行结果：

['Python', 'C++', 'Java', 'C']
['Python', 'C++', 'Java', 'C', 'JavaScript', 'C#', 'Go']
['Python', 'C++', 'Java', 'C', 'JavaScript', 'C#', 'Go', 'Ruby', 'SQL']
1
2
3

insert()方法插入

append() 和 extend() 方法只能在列表末尾插入元素，如果希望在列表中间某个位置插入元素，那么可以使用
insert() 方法。

insert() 的语法格式如下：

listname.insert(index , obj)
1

其中，index 表示指定位置的索引值。insert() 会将 obj 插入到 listname 列表第 index 个元素的位置。
当插入列表或者元祖时，insert() 也会将它们视为一个整体，作为一个元素插入到列表中，这一点和 append()
是一样的。

1. l = ['Python', 'C++', 'Java']
2. #插入元素
3. l.insert(1, 'C')
4. print(l)
5.
6. #插入元组，整个元祖被当成一个元素
7. t = ('C#', 'Go')
8. l.insert(2, t)
9. print(l)
10.
11. #插入列表，整个列表被当成一个元素
12. l.insert(3, ['Ruby', 'SQL'])
13. print(l)
14.
15. #插入字符串，整个字符串被当成一个元素
16. l.insert(0, "http://c.biancheng.net")
17. print(l)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

运行结果：

['Python', 'C', 'C++', 'Java']
['Python', 'C', ('C#', 'Go'), 'C++', 'Java']
['Python', 'C', ('C#', 'Go'), ['Ruby', 'SQL'], 'C++', 'Java']
['http://c.biancheng.net', 'Python', 'C', ('C#', 'Go'), ['Ruby', 'SQL'], 'C++', 'Java']
1
2
3
4

提示，insert() 主要用来在列表的中间位置插入元素，如果你仅仅希望在列表的末尾追加元素，那我更建议使用
append() 和 extend()。

Python list 列表删除元素

在 Python 列表中删除元素主要分为以下 3 种场景：

• 根据目标元素所在位置的索引进行删除，可以使用 del 关键字或者 pop() 方法；
• 根据元素本身的值进行删除，可使用列表（list类型）提供的 remove() 方法；
• 将列表中所有元素全部删除，可使用列表（list 类型）提供的 clear() 方法。

del：根据索引值删除元素

del 可以删除列表中的单个元素，格式为：

del listname[index]
1

其中，listname 表示列表名称，index 表示元素的索引值。
del 也可以删除中间一段连续的元素，格式为：

del listname[start : end]
1

其中，start 表示起始索引，end 表示结束索引。del 会删除从索引 start 到 end 之间的元素，不包括 end 位
置的元素。
使用 del 删除单个列表元素：

1. lang = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
2.
3. #使用正数索引
4. del lang[2]
5. print(lang)
6.
7. #使用负数索引
8. del lang[-2]
9. print(lang)
1
2
3
4
5
6
7
8
9

运行结果：

['Python', 'C++', 'PHP', 'Ruby', 'MATLAB']
['Python', 'C++', 'PHP', 'MATLAB']
1
2

使用 del 删除一段连续的元素：

1. lang = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
2.
3. del lang[1: 4]
4. print(lang)
5.
6. lang.extend(["SQL", "C#", "Go"])
7. del lang[-5: -2]
8. print(lang)
1
2
3
4
5
6
7
8

运行结果：

['Python', 'Ruby', 'MATLAB']
['Python', 'C#', 'Go']
1
2

pop()：根据索引值删除元素

pop() 方法用来删除列表中指定索引处的元素，具体格式如下：

listname.pop(index)
1

其中，listname 表示列表名，index 表示索引值。如果不写 index 参数，默认会删除列表中的最后一个元素，类似于数据结构中的“出栈”操作。

1. nums = [40, 36, 89, 2, 36, 100, 7]
2. nums.pop(3)
3. print(nums)
4. nums.pop()
5. print(nums)
1
2
3
4
5

运行结果：

[40, 36, 89, 36, 100, 7]
[40, 36, 89, 36, 100]
1
2

大部分编程语言都会提供和 pop() 相对应的方法，就是 push()，该方法用来将元素添加到列表的尾部，类似于
数据结构中的“入栈”操作。但是 Python 是个例外，Python 并没有提供 push() 方法，因为完全可以使
用 append() 来代替 push() 的功能

remove()：根据元素值进行删除

该方法会根据元素本身的值来进行删除操作。需要注意的
是，remove() 方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发
ValueError 错误。

1. nums = [40, 36, 89, 2, 36, 100, 7]
2. #第一次删除 36
3. nums.remove(36)
4. print(nums)
5. #第二次删除 36
6. nums.remove(36)
7. print(nums)
8. #删除 78
9. nums.remove(78)
10. print(nums)
1
2
3
4
5
6
7
8
9
10

运行结果：

[40, 89, 2, 36, 100, 7]
[40, 89, 2, 100, 7]
Traceback (most recent call last):
File "C:\Users\mozhiyan\Desktop\demo.py", line 9, in <module>
nums.remove(78)
ValueError: list.remove(x): x not in list
1
2
3
4
5
6

最后一次删除，因为 78 不存在导致报错，所以我们在使用 remove() 删除元素时最好提前判断一下。

clear()：删除列表所有元素

Python clear() 用来删除列表的所有元素，也即清空列表，请看下面的代码：

1. url = list("http://c.biancheng.net/python/")
2. url.clear()
3. print(url)
1
2
3

运行结果：

[]
1

Python list 列表修改元素

修改单个元素

1. nums = [40, 36, 89, 2, 36, 100, 7]
2. nums[2] = -26 #使用正数索引
3. nums[-3] = -66.2 #使用负数索引
4. print(nums)
1
2
3
4

运行结果：

[40, 36, -26, 2, -66.2, 100, 7]
1

修改一组元素

在进行这种操作时，如果不指定步长（step 参数），Python 就不
要求新赋值的元素个数与原来的元素个数相同；这意味，该操作既可以为列表添加元素，也可以为列表删除元 素。

1. nums = [40, 36, 89, 2, 36, 100, 7]
2.
3. #修改第 1~4 个元素的值（不包括第 4 个元素）
4. nums[1: 4] = [45.25, -77, -52.5]
5. print(nums)
1
2
3
4
5

运行结果：

[40, 45.25, -77, -52.5, 36, 100, 7]
1

如果对空切片（slice）赋值，就相当于插入一组新的元素：

1. nums = [40, 36, 89, 2, 36, 100, 7]
2. #在 4 个位置插入元素
3. nums[4: 4] = [-77, -52.5, 999]
4. print(nums)
1
2
3
4

运行结果：

[40, 36, 89, 2, -77, -52.5, 999, 36, 100, 7]
1

使用切片语法赋值时，Python 不支持单个值，例如下面的写法就是错误的：

nums[4: 4] = -77
1

但是如果使用字符串赋值，Python 会自动把字符串转换成序列，其中的每个字符都是一个元素，请看下面的代
码：

s = list("Hello")
s[2:4] = "XYZ"
print(s)
1
2
3

运行结果：

['H', 'e', 'X', 'Y', 'Z', 'o']
1

使用切片语法时也可以指定步长（step 参数），但这个时候就要求所赋值的新元素的个数与原有元素的个数相
同，例如：

1. nums = [40, 36, 89, 2, 36, 100, 7]
2. #步长为 2，为第 1、3、5 个元素赋值
3. nums[1: 6: 2] = [0.025, -99, 20.5]
4. print(nums)
1
2
3
4

运行结果：

[40, 0.025, 89, -99, 36, 20.5, 7]
1

Python list 列表查找元素

index() 方法

index() 方法用来查找某个元素在列表中出现的位置（也就是索引），如果该元素不存在，则会导致ValueError 错误，所以在查找之前最好使用 count() 方法判断一下。

listname.index(obj, start, end)
1

其中，listname 表示列表名称，obj 表示要查找的元素，start 表示起始位置，end 表示结束位置。
start 和 end 参数用来指定检索范围：
• start 和 end 可以都不写，此时会检索整个列表；
• 如果只写 start 不写 end，那么表示检索从 start 到末尾的元素；
• 如果 start 和 end 都写，那么表示检索 start 和 end 之间的元素。

index() 方法会返回元素所在列表中的索引值。

1. nums = [40, 36, 89, 2, 36, 100, 7, -20.5, -999]
2. #检索列表中的所有元素
3. print( nums.index(2) )
4. #检索 3~7 之间的元素
5. print( nums.index(100, 3, 7) )
6. #检索 4 之后的元素
7. print( nums.index(7, 4) )
8. #检索一个不存在的元素
9. print( nums.index(55) )
1
2
3
4
5
6
7
8
9

运行结果：

3
5
6
Traceback (most recent call last):
File "C:\Users\mozhiyan\Desktop\demo.py", line 9, in <module>
 print( nums.index(55) )
ValueError: 55 is not in list
1
2
3
4
5
6
7

count()方法

count() 方法用来统计某个元素在列表中出现的次数，基本语法格式为：

listname.count(obj)
1

如果 count() 返回 0，就表示列表中不存在该元素，所以 count() 也可以用来判断列表中的某个元素是否存在。

1. nums = [40, 36, 89, 2, 36, 100, 7, -20.5, 36]
2. #统计元素出现的次数
3. print("36 出现了%d 次" % nums.count(36))
4. #判断一个元素是否存在
5. if nums.count(100):
6. print("列表中存在 100 这个元素")
7. else:
8. print("列表中不存在 100 这个元素")
1
2
3
4
5
6
7
8

运行结果：

36 出现了 3 次
列表中存在 100 这个元素
1
2