python基础入门5：列表-----创建、增、删、改、查

前言

本文主要讲述python程序列表的创建，增、删、改、查。本文学习材料来自马士兵Python中入门基础版(基础语法) 2020最新版Python小白教程。视频链接https://www.bilibili.com/video/BV1wD4y1o7AS?p=46&spm_id_from=pageDriver

---

提示：以下是本篇文章正文内容，下面案例可供参考

列表-----创建、增、删、改、查

列表可用于存储 $N$ 多元素，便于程序对数据的整体操作。
变量存储的是一个对象的引用, 列表可包含多个位置，每个位置可用于存储一个变量对象的引用。
无论是变量对象还是列表对象，每个对象存储其id，然后指向其具体内容。

• 变量对象内存示意图

• 列表对象内存示意图

如下代码说明列表与其元素的关系：

s1 = 'hello'
s2 = 'world'
a = 10
list = ['hello', 'world', 10]
print('列表list的标识为：', id(list))
print('列表list的类型为：', type(list))
print('列表list的值为：', list)

'''列表list元素‘hello’的具体内容'''#(1)
print('列表list元素‘hello’的标识为：', id(list[0]))
print('列表list元素‘hello’的类型为：', type(list[0]))
print('列表list元素‘hello’的值为：', list[0])

'''字符串‘hello’的具体内容'''#(2)
print('字符串‘hello’的标识为：', id(s1))
print('字符串‘hello’的类型为：', type(s1))
print('字符串‘hello’的值为：', s1)

print(bool(s1 in list))
print(bool(s2 in list))
print(bool(a in list))

输出结果为：
列表list的标识为：  2777735096256
列表list的类型为： <class 'list'>
列表list的值为： ['hello', 'world', 10]

列表list元素‘hello’的标识为： 1378257939248
列表list元素‘hello’的类型为： <class 'str'>
列表list元素‘hello’的值为： hello

字符串‘hello’的标识为： 1378257939248
字符串‘hello’的类型为： <class 'str'>
字符串‘hello’的值为： hello

True
True
True

(1)与(2)的具体内容完全相同。

列表的创建

列表创建方式

1. 直接使用中括号[]。
2. 使用python内置函数list()，列表中的元素可以用小括号包裹，也可以用中括号包裹。
3. 列表生成式（可用于生成具有一定规律的列表）。代码语法为：
   列表名 = [想要产生的元素的关于自定义变量的表达式 for 自定义变量 in 范围]
   【例】

'''使用[]创建列表'''
lst1 = ['hello', 'world', 10]
lst_multi = [[1, 2, 3], [4, 5,6]]
print(lst_multi, len(lst_multi[0]), len(lst_multi[1]))#创建二维列表，并查看每一行的元素个数
print(lst1, type(lst1))
'''使用内置函数list()创建列表'''
lst2 = list(('hello', 'world', 10))
print(lst2, type(lst2))
lst3 = list(['hello', 'world', 10])
print(lst3, type(lst3))
'''使用列表生成式创建列表'''
lst = [i*i for i in range(10)]#产生10以内数的平方数
print(lst)
lst = [i for i in 'Python']#产生python的字母组成
print(lst)

输出结果为：
['hello', 'world', 10] <class 'list'>
[[1, 2, 3], [4, 5, 6]] 3 3
['hello', 'world', 10] <class 'list'>
['hello', 'world', 10] <class 'list'>
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
['P', 'y', 't', 'h', 'o', 'n']

列表的特点

1. 列表元素按顺序有序排序
2. 索引映射唯一个数据
3. 列表可以存储重复数据
4. 任意数据类型可以混存
5. 根据需要动态分配回收内存

列表就像一个收纳盒，盒子包含很多小方格，每个小方格都有自己唯一的编号，每个小方格都可以放一个东西，所放东西无要求，可以是小首饰，可以是小皮筋，可以袜子等等，每个小方格的隔板可以自由移动。

列表查询

列表索引

获取某个元素的索引

使用index()方法获取, 该方法是隶属于列表范围的。
代码写法：

列表名.index(需要查的元素)

【例】

lst1 = ['hello', 'world', 10, 'hello']
#查找列表lst1中world的索引
print(lst1.index('world'))

输出结果为：
1

【注】使用index()方法的注意事项：

1. 如果列表中存在 $N$ 个相同元素，使用 列表名.index(需要查找的元素) 这种方法获取的是相同元素中的第一个元素的索引。
2. 如果查询的元素不存在，则会跳出ValueError
3. 可指定范围进行查找元素

【例】查找 lst1 = [‘hello’, ‘world’, 10, ‘hello’] 相关元素

'''1. 查找hello的索引'''
print(lst1.index('hello'))

'''2. 查找不存在的元素'''
print(lst1.index('你好'))

'''3. 指定范围查找'''
print(lst1.index('hello', 1, 4))

输出结果为：

0 
ValueError: '你好' is not in list
3

通过索引编号获取列表中的元素

索取元素代码写法

列表名[元素编号]

列表索引编号规则

1. 正向起始编号为0，若列表中元素有 $n$ 个,则最大的索引编号为 $n-1$。
2. 倒向，即从最后一个元素开始编号的话，则是 $-1$ 开始，若列表中元素有 $n$ 个，则列表第一个元素按倒向编号的话，其索引编号为 $-n$

【例】分别以正向倒向获取列表
lst1 = [‘hello’, ‘world’, 10, ‘hello’] 中的10。

分析：按正向来看，10 为列表lst1的第三个元素，编号从0开始，第三个元素的编号即为2；按倒向来看，10 为列表lst1 中的倒数第二个元素，编号从-1开始，倒数第二个元素的话其编号为-2.
演示代码如下：

print(lst1[2])
print(lst1[-2])

列表切片

获取列表中的多个元素

语法格式：

列表名[起始端点start: 结束端点stop: 步长step]

1. 列表切片是一个新的列表对象，其结果是原列表片段的拷贝；

2. 拷贝的范围为[start, stop), 不包括索引为stop的这一元素；

3. 如果执行切片操作时不写步长step，则默认步长为1，即语法格式为：

   列表名[起始端点start: 结束端点stop]

4. 若按正向索引编号执行切片操作，步长step为正数，若写为列表名[:stop:step], 则默认切片的第一个元素是列表的第一个元素；若写为列表名[start::step]，则省略了终端索引编号，则默认切片的最后一个元素是列表的最后一个元素。

5. 若按倒向索引编号执行切片操作，则步长step为负数，若写为列表名[:stop:step], 则默认切片的第一个元素是列表的最后一个元素；若写为列表名[start::step]，则省略了终端索引编号，则默认切片的最后一个元素是列表的第一个元素。
   【例】

lst = [1, 2, 3, 4, 5, 6, 7]
print('原列表为：', lst, id(lst))
lst1 = lst[1:6:1]
print('切片结果为：', lst1,id(lst1))

输出结果为：

原列表为： [1, 2, 3, 4, 5, 6, 7] 2339735594944
切片结果为： [2, 3, 4, 5, 6] 2339736913536

【例】

lst2 = lst[1:6]#省略步长step，默认为1
lst3 = lst[:6:2]#正向切片省略起始索引端点，默认为0。步长为2
lst4 = lst[1::2]#正向切片省略终端索引端点，默认为列表最后一个索引值。步长为2
lst5 = lst[6:2:-1]#倒序切片时，步长必须写明。
lst6 = lst[-1:-5:-1]
lst7 = lst[:-5:-1]#倒向切片省略起始索引端点，默认为列表的最后一个元素的索引，这里即默认为-1或6。步长为-1
lst7 = lst[-1::-1]#倒向切片省略终端端点，默认为列表的第一个元素的索引，这里即默认为-7或0。步长为-1
print('lst2为：', lst2)
print('lst3为：', lst3)
print('lst4为：', lst4)
print('lst5为：', lst5)
print('lst6为：', lst6)
print('lst7为：', lst7)
print('lst8为：', lst8)

输出结果为：

lst2为： [2, 3, 4, 5, 6]
lst3为： [1, 3, 5]
lst4为： [2, 4, 6]
lst5为： [7, 6, 5, 4]
lst6为： [7, 6, 5, 4]
lst7为： [7, 6, 5, 4]
lst8为： [7, 6, 5, 4, 3, 2, 1]

• 判断指定元素在列表中是否存在

元素 in 列表名
元素 not in 列表名

'''python代码举例'''
print(8 in lst)
print(8 not in lst)

输出结果为：
False
True

• 列表元素的遍历

for 迭代变量 in 列表名

列表元素的增加操作

向列表中添加新的元素有以下几种方法：

1. append(), 在列表的末尾添加一个新的对象。代码语法可写为：列表名.append(需要添加的元素)
2. extend(), 在列表的末尾添加一个序列中的多个值。代码语法可写为：列表名.entend(需要添加的序列名)
3. insert(), 在列表的任意位置添加一个元素。代码语法可写为：列表名.insert(意图添加对象的索引编号, 意图添加的对象)
4. 切片，在列表的某一段添加元素或序列列表名(start:end) = 所需要添加的对象或序列。

代码示例：

lst = ['happy', 1, 2, 3, 4, 'world']
lst.append(8)#在列表的最后位置添加元素8
print(lst)
lst.extend([8])#在列表的最后位置添加序列[8]
print(lst)
lst.extend({9})#在列表的最后位置添加序列{9}
print(lst)
lst.extend((7,6))#在列表的最后位置添加序列(7,6)或[7,6]或{7,6}
#lst.extend([7,6])
#lst.extend({7,6})
print(lst)
lst.insert(2, [10, 11])
print(lst)
lst[2:4]=['new', 'year']
print(lst)

输出结果为：

['happy', 1, 2, 3, 4, 'world', 8]
['happy', 1, 2, 3, 4, 'world', 8, 8]
['happy', 1, 2, 3, 4, 'world', 8, 8, 9]
['happy', 1, 2, 3, 4, 'world', 8, 8, 9, 7, 6]
['happy', 1, [10, 11], 2, 3, 4, 'world', 8, 8, 9, 7, 6]
['happy', 1, 'new', 'year', 3, 4, 'world', 8, 8, 9, 7, 6]

列表元素的删除操作

列表元素的删除可使用如下方法来操作。

1. remove(), 一次性删除一个元素；若列表中有重复元素，则只删除按正向排序的第一个元素；若删除列表中本不存在的元素的返回ValueError。代码语法可写为：列表名.remove(需要删除的元素或对象)
2. pop(), 删除一个指定索引位置上的元素；指定索引不存在则返回IndexError；不指定索引，删除列表中最后一个元素。代码语法可写为：列表名.pop(需要删除元素或对象的索引值，若不写则默认删除列表最后一个元素)
3. 切片，一次性至少删除一个元素。代码语法可写为：列表名[start:end]=[]，此处不包含end这一索引值的元素。
4. clear(), 清空列表。
5. del直接删除列表。

代码示例：

lst = [1, 2, 3, 4, 1, 1]
lst.remove(1)#删除lst中的指定元素1，若有多个相同元素，则删除第一个
print(lst)
lst.remove(8)#删除lst不存在的元素返回ValueError
lst.pop()#删除指定索引值的元素，不写索引值则默认删除最后一个元素
print(lst)
lst.pop(3)#删除索引值为3的元素
print(lst)
lst[1:3]=[]#删除索引编号为1,2的列表元素
print(lst)
lst.clear()#清空列表中的所有元素
print(lst)
del lst#直接删除列表对象
print(lst)

输出结果为：

[2, 3, 4, 1, 1]
ValueError: list.remove(x): x not in list
[2, 3, 4, 1]
[2, 3, 4]
[2]
[]
NameError: name 'lst' is not defined

列表元素的修改

1. 单个元素赋值。为指定索引的元素赋予新的值
2. 切片元素赋值。为指定切片的元素赋予新值。

代码示例：

lst = ['happy', 1, 2, 3]
lst[3] = '!'#修改后列表的第三个索引值指向'!'这个对象的id，与3这个对象的id链接断开。3这个对象成为内存垃圾，被系统回收。
print(lst)
lst[1:3] = ['new', 'year']
print(lst)

输出结果为：

['happy', 1, 2, '!']
['happy', 'new', 'year', '!']

列表的排序操作

列表的排序常见的两种操作方法为：

1. 调用sort()方法，列表中所有元素默认按照从小到大的顺序进行排列，可以指定reverse = True，则进行降序排列。原列表变为排序后的新列表，但并不产生新的列表对象
2. 调用内置函数sorted(), 可以指定reverse = True，进行降序排列，原列表不发生改变，产生新的列表对象。

代码示例：

lst = [4, 5, 3, 4, 9]
'''使用方法sort()进行排序'''
lst.sort()
print('不指定reverse产生的排序列表为：', lst)
lst.sort(reverse=True)
print('指定reverse为True产生的排序列表为：', lst)
lst.sort(reverse=False)
print('指定reverse为False产生的排序列表为：', lst)

'''使用内置函数sorted()进行排序'''

new_lst = sorted(lst)
print('不指定reverse产生的新的列表排序对象为：', new_lst)
new_lst = sorted(lst, reverse=True)
print('指定reverse为True产生的新的列表排序对象为：', new_lst)
new_lst = sorted(lst, reverse=False)
print('指定reverse为False产生的新的列表排序对象为：', new_lst)

输出结果为：

不指定reverse产生的排序列表为： [3, 4, 4, 5, 9]
指定reverse为True产生的排序列表为： [9, 5, 4, 4, 3]
指定reverse为False产生的排序列表为： [3, 4, 4, 5, 9]

不指定reverse产生的新的列表排序对象为： [3, 4, 4, 5, 9]
指定reverse为True产生的新的列表排序对象为： [9, 5, 4, 4, 3]
指定reverse为False产生的新的列表排序对象为： [3, 4, 4, 5, 9]