Python急速入门——（第五章：列表）_调取lst=[11,22,63,49,56,96,86,156,200]列表,下标间隔3的数字-CSDN博客

本文链接：https://blog.csdn.net/weixin_73870552/article/details/134876219

Python急速入门——（第五章：列表）

1.为什么使用列表
2.列表对象的创建
3.列表元素的特点
4.列表的查询操作
5.列表的相关操作

1.为什么使用列表

变量可以存储一个元素，而列表可以存储N多个不同类型的数据，程序可以对这些数据进行整体操作（列表也相当于其他语言中的数组）。

a = 10 # 变量存储的是一个对象的引用
arr = [10, '张三', True]
print(id(a))
print(id(10))
print(id('张三'))
print(id(True))
print(id(arr))
print(type(arr))
print(arr)

一个输出结果：

140730783683656
140730783683656
2583088884752
140730782161768
2583089534528
<class 'list'>
[10, '张三', True]

内存示意图：

在这里插入图片描述

列表对象的id是778，存储的是当前列表中其他对象的id；列表对象的名字是arr，arr的id指向列表对象。

2.列表对象的创建

1.方法1：

列表需要使用中括号[]，元素之间使用英文的逗号进行分隔。

"""创建列表的第一种方式，使用[]"""
lst = [12, 3, 4]
print(lst)

输出：

[12, 3, 4]

2.方法2：

使用内置函数list。

"""列表的第二种创建方式，使用内置函数list"""
lst2 = list([1, '张三', True])

3.创建空列表：

lst = []
lst1 = list()
print(lst, lst1)

输出：

[] []

3.列表元素的特点

1.列表元素按顺序有序排序，一个索引映射一个数据：

在这里插入图片描述

起始位置下标是0，后一位是1，依次类推；最后一位下标也可以是-1，前一位是-2，以此类推。

2.列表可以存储重复数据。

3.任意数据类型混存。

4.根据需要动态分配和回收内存S。

4.列表的查询操作

4.1获取指定元素的索引

使用函数index()：

1）如果查询列表中N个相同元素，只返回相同元素中的第一个元素的索引。

"""若查询N个相同元素，只返回元素中的第一个元素的索引"""
lst1 = ['hello', 'world', 98, 'hello']
print(lst1.index('hello'))

输出：

2）如果查询的元素在列表中不存在，则会抛出ValueError。

"""若查询的元素在列表中 不存在，则会抛出ValueError"""
print(lst1.index(99))

报错：

在这里插入图片描述
3）还可以在指定的start和stop之间进行查找。

"""在指定的范围内查找"""
#  print(lst1.index('hello', 1, 3)) # 在索引1到3的范围内查找，不包括3
# 会报错
print(lst1.index('hello', 1, 4)) # 可以找的到hello

输出：

4.2获取列表中的单个元素

正向索引从0到N-1；逆向索引从-N到-1；指定索引不存在，抛出IndexError。

lst1 = ['hello', 'world', 98, 'hello', 'world', 234]
# 正向索引
print(lst1[0])
# 逆向索引
print(lst1[-3])
# 指定索引不存在
print(lst1[10])

输出：

在这里插入图片描述

4.3获取列表中的多个元素

1.语法格式：列表名[start:stop:step]。

lst2 = [10, 20, 30, 40, 50, 60]
# start为1，stop为6，step为1
print(lst2[1:6:1])

输出：

[20, 30, 40, 50, 60]

2.切片操作：

1）切片的结果：原列表片段的拷贝。

lst2 = [10, 20, 30, 40, 50, 60]
# start为1，stop为6，step为1
print(lst2[1:6:1])

lst3 = lst2[1:6:1]
print('lst2的id：', id(lst2))
print('lst3的id：', id(lst3))

输出：

[20, 30, 40, 50, 60]
lst2的id： 2340299241216
lst3的id： 2340299360064

2）切片的范围：从start到stop，不包括stop。

3）step默认为1：

可以简写为简写为[start:stop]或[start:stop:]。

"""step省略不写"""
# 相当于lst2[1:6:1] 默认步长是1
print(lst2[1:6])
print(lst2[1:6:]) # 和上面的那种写法效果一样

输出：

[20, 30, 40, 50, 60]
[20, 30, 40, 50, 60]

4）step为正数：

# 切片的第一个元素默认为是列表的第一个元素
print(lst2[:6:1])
# 切片的最后一个元素默认为之列表的最后一个元素
print(lst2[1::1])
# 全为默认值，从第一个元素开始到最后一个元素结束，步长为1
# 这个切片的值和原列表相等
print(lst2[::])
print(lst2 == lst2[::])
print(lst2 is lst2[::])

输出：

[10, 20, 30, 40, 50, 60]
[20, 30, 40, 50, 60]
[10, 20, 30, 40, 50, 60]
True
False

注意：即使切片的值和原列表一样，它们的id也是不一样的。

5）ste[为负数：

[:stop:step]：切片的第一个元素默认为是列表的最后一个元素。
[start::step]：切片的最后一个元素默认是列表的第一个元素。

print('原列表：', lst2)
# 切片的第一个元素是列表的最后一个元素
print(lst2[:-5:-1])
print(lst2[:1:-1])
# 切片的最后一个元素是列表的第一个元素
print(lst2[-1::-1])
print(lst2[6::-1])
# 把一个列表倒置
print('倒置：', lst2[::-1])

输出：

原列表： [10, 20, 30, 40, 50, 60]
[60, 50, 40, 30]
[60, 50, 40, 30]
[60, 50, 40, 30, 20, 10]
[60, 50, 40, 30, 20, 10]
倒置： [60, 50, 40, 30, 20, 10]

3.一些奇怪的写法，见到要知道是什么意思：

print('原列表：', lst2)
print(lst2[1:]) # start为1，其余的各种值均为默认，step为1，stop为列表的最后一个数
print(lst2[:6:]) # stop为6，其余的各种值均为默认，step为1，start为列表中的第一个数
print(lst2[:6])
print(lst2[0:-1]) # start为0，stop为-1，就是最后一个元素，step为默认值1
print(lst2[-1:0]) # 这里默认步长是1，为正数，所以切片为空
print(lst2[-1:0:-1]) # 这样切片就不为空了

输出：

原列表： [10, 20, 30, 40, 50, 60]
[20, 30, 40, 50, 60]
[10, 20, 30, 40, 50, 60]
[10, 20, 30, 40, 50, 60]
[10, 20, 30, 40, 50]
[]
[60, 50, 40, 30, 20]

4.4列表元素的遍历和判断

1.用in和not in来判断一个元素是否在列表中：

"""用 in 和 not in 来判断指定元素是否在列表内"""
lst = [1, 20, 'zhangsan', True]
print(1 in lst)     # True
print(2 in lst)     # False
print(1 not in lst) # False
print(2 not in lst) # True

输出：

True
False
False
True

2.用for循环来遍历列表：

print("原列表：", lst)
for item in lst:
    print(item)

输出：

原列表： [1, 20, 'zhangsan', True]
1
20
zhangsan
True

5.列表的相关操作

5.1列表元素的添加操作

1.append()，比较常用

作用：在列表的，末尾添加一个元素。

# 使用append增加一个元素
lst = [1, 2, 3, 'hello', 'world', 7]
lst.append(8)
print(lst)
# 如果append一个列表会怎么样？
lst2 = ['hello', 'world']
lst.append(lst2)
print(lst)
# 答案是将这个列表对象作为一个元素储存在lst的最后一个位置

输出：

[1, 2, 3, 'hello', 'world', 7, 8]
[1, 2, 3, 'hello', 'world', 7, 8, ['hello', 'world']]

2.extend()

作用：在列表的末尾添加多个元素。

"""使用extend添加多个元素(这多个元素只能写成列表的形式，字符串本身就是一个列表)"""
# extend的作用就是把一个列表中的元素追加到原列表的后面
print('当前列表：', lst)
# 可以把两lst2中的元素追加到lst的最后
lst2 = ['hello', 'world']
lst.extend(lst2)
print(lst)

输出：

当前列表： [1, 2, 3, 'hello', 'world', 7]
[1, 2, 3, 'hello', 'world', 7, 'hello', 'world']

extend的一些注意事项：

# 也可以这样追加
lst.extend(['2', 3])
print(lst)
# 单独追加数据时要写成[]列表的形式
lst.extend([1])
print(lst)
# 单独追加单个字符串时，不用加[]
lst.extend('h')
print(lst)
# 追加多个字符且不加[]，会把字符串拆分开来
lst.extend('hehe')
print(lst)
# 可以像这样追加空列表
lst.extend([])
lst.extend([[]])
print(lst)

输出：

[1, 2, 3, 'hello', 'world', 7, 'hello', 'world', '2', 3]
[1, 2, 3, 'hello', 'world', 7, 'hello', 'world', '2', 3, 1]
[1, 2, 3, 'hello', 'world', 7, 'hello', 'world', '2', 3, 1, 'h']
[1, 2, 3, 'hello', 'world', 7, 'hello', 'world', '2', 3, 1, 'h', 'h', 'e', 'h', 'e']
[1, 2, 3, 'hello', 'world', 7, 'hello', 'world', '2', 3, 1, 'h', 'h', 'e', 'h', 'e', []]

3.insert()

作用：在列表的任意位置添加一个元素。

# 想在索引为1的位置后面插入一个0
lst = [1, 2, 3, 4, 5]
lst.insert(1, 0)
# 第一个参数是索引，第二个参数是要插入的数据
print(lst)

输出：

[1, 0, 2, 3, 4, 5]

4.切片：

作用：在列表的任意位置添加多个元素（有局限性）。

lst = [1, 2, 'hello', 'world', 4]
print('原列表：', lst)
lst[1:] = [1, 2, 4] # 在索引为1的位置后面添加元素，同时将原列表索引为1及其后面的元素删除
print('添加后的列表：', lst)

输出：

原列表： [1, 2, 'hello', 'world', 4]
添加后的列表： [1, 1, 2, 4]

注意事项：

lst = [1, 2, 'hello', 'world', 4]

'''注意事项，可以类比extend'''
# 追加字符串不带[]，字符串会被拆分
lst[1:] = 'hello'
print(lst)
# 可以追加空列表
lst[1:] = []
print(lst)
lst[1:] = [[]]
print(lst)
# 追加单个数据要带[]
# lst[1:] = 1 # 直接报错
lst[1:] = [1]
print(lst)

输出：

[1, 'h', 'e', 'l', 'l', 'o']
[1]
[1, []]
[1, 1]

5. 使用+或+=为列表添加新的元素：

可以理解成C++中的运算符重载，使用+=可以在原列表的基础上添加元素，而不会创建一个新的列表；使用+会创建一个新的列表。

lst = [1, 2, 3]
print(id(lst))
lst += [4]  # 在原列表基础上添加元素，地址不变
print(id(lst))
print(lst)

lst = lst + [2, 3] # 此时等号左边的lst和右边的lst已经不是一个列表了，地址不一样
print(id(lst), lst)
"""
可能的输出结果：
2220525610432
2220525610432
[1, 2, 3, 4]
2220525567168 [1, 2, 3, 4, 2, 3]
"""

lst + [4]就相当于lst.extend([4])；但lst = lst + [2, 3]不可以看作lst = lst.extend([2, 3])。

'''
追加空列表
'''
lst = [1, 2, 3]
lst += [[]]
print(lst)
lst = lst + [[]]
print(lst)
'''
输出：
[1, 2, 3, []]
[1, 2, 3, [], []]
'''

5.2列表元素的删除

1.remove()

1）作用：根据Value删除列表中的元素

2）注意事项：一次删除一个元素；重复元素只删除第一个；元素不存在抛出ValueError

# 初始化列表1-10
lst = []
for i in range(1, 11):
    lst.append(i)
lst.insert(1, 1)

"""remove()函数"""

print('原列表：', lst)
# 删除指定元素2
lst.remove(2)
print('删除2：', lst)
# 删除重复元素1，只能删除第一个
lst.remove(1)
print('删除1：', lst)
# 元素不存在，会报错
"""lst.remove(100)"""
# 错误信息：list.remove(x): x not in list

输出：

原列表： [1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
删除2： [1, 1, 3, 4, 5, 6, 7, 8, 9, 10]
删除1： [1, 3, 4, 5, 6, 7, 8, 9, 10]

2.pop()

1）作用：删除一个指定索引位置上的元素。

2）注意事项：指定索引不存在抛出错误IndexError；不指定索引，默认删除列表中的最后一个元素。

"""pop()根据索引移除元素"""
print('原列表：', lst)
# 移除3位置处的元素
lst.pop(3)
print(lst)
# 不指定索引，默认移除列表最后一个元素
lst.pop()
print(lst)
# 指定索引不存在，报错
"""lst.pop(100)"""
# 报错：IndexError: pop index out of range

输出：

原列表： [1, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 3, 4, 6, 7, 8, 9, 10]
[1, 3, 4, 6, 7, 8, 9]

3.切片：

一个作用：删除多个元素。

"""切片，删除多个元素，但是会产生一个新的列表对象"""
print('原列表：', lst)
# 删除1,2位置的元素
lst[1:3] = [] # 将1,2位置的元素用空列表中的元素代替
print(lst)
# 产生新列表的删除方式
print('原列表：', lst, id(lst))
new_lst = lst[1:3]
print('新列表：', new_lst, id(new_lst))
print(new_lst)

输出：

原列表： [1, 3, 4, 6, 7, 8, 9]
[1, 6, 7, 8, 9]
原列表： [1, 6, 7, 8, 9] 2555523651136
新列表： [6, 7] 2555524564800
[6, 7]

4.clear()

作用：清空列表中的元素。

print('原列表：', lst)
lst.clear()
print(lst)

输出：

原列表： [1, 6, 7, 8, 9]
[]

5.del()

作用：直接销毁列表对象。

del lst
"""print(lst)"""
# 直接报错

5.3列表元素的修改

1.单个元素的修改：

lst = [1, 2, 3, 4, 5]
lst[0] = 0
print(lst)

2.修改多个元素

1）改变数组大小的修改：

特点：不支持跳着修改。

例1：

lst = [1, 2, 3, 4, 5]
lst[1:3] = [20, 30, 99]
print(lst)  # [1, 20, 30, 99, 4, 5]
# 使用切片修改列表的规则：先删后放

输出：

[1, 20, 30, 99, 4, 5]

例2：

"""会把1位置后的元素全部删除（包括1位置）"""
lst = [1, 2, 3, 4, 5]
lst[1:] = [6, 7, 8, 9, 10, 11]
print(lst)
# 可以超范围

输出：

[1, 6, 7, 8, 9, 10, 11]

2）不改变列表元素数量的修改：

跳着修改

例1：

# 跳着修改，这种操作不会改变列表中的元素个数
lst = [1, 2, 3, 4, 5]
lst[1:4:2] = ['hello', 'world']
"""lst[1:4:2] = ['hello', 'world', 'hello']"""
# 直接报错，因为切片中只有两个元素，放三个元素进去是没有空间的
# ValueError: attempt to assign sequence of size 3 to extended slice of size 2
print(lst)

输出：

[1, 'hello', 3, 'world', 5]

例2：

lst = [1, 2, 3, 4, 5]
lst[1::2] = ['hello', 'world']
print(lst)
# lst[1::2] = ['hello', 'world', 'hello']
# 报错
# ValueError: attempt to assign sequence of size 3 to extended slice of size 2

输出：

[1, 'hello', 3, 'world', 5]

5.4列表元素的排序操作

1.调用sort()

功能：

列表中的所有元素按照默认按从小到大的顺序进行排序；
可以指定reverse=True，进行降序排序；
不产生新的列表对象。

# 不指定reverse，reverse默认为False，升序排序
lst = [11, 32, 22, 54, 21, 8]
print("原列表：", lst, id(lst))
lst.sort()
print('升序排序后的列表：', lst, id(lst)) # id不变，不产生新的列表元素
# 指定reverse为True，降序排序
lst.sort(reverse=True)
print('降序排序后的列表：', lst, id(lst))
lst.sort(reverse=False) # 相当于不指定reverse
print(lst)

输出：

原列表： [11, 32, 22, 54, 21, 8] 2592096474688
升序排序后的列表： [8, 11, 21, 22, 32, 54] 2592096474688
降序排序后的列表： [54, 32, 22, 21, 11, 8] 2592096474688
[8, 11, 21, 22, 32, 54]

2.调用内置函数sorted()

功能：

默认是升序排序；
产生一个新的列表对象；
可以指定reverse=True来进行降序排序。

"""调用内置函数sorted()"""
lst = [11, 32, 22, 54, 21, 8]
print("原列表：", lst, id(lst))
new_lst = sorted(lst)
print("升序排序后的列表：", new_lst, id(new_lst))
# 指定reverse进行降序排序
desc_lst = sorted(lst, reverse=True)
print("降序排序后的列表：", desc_lst, id(desc_lst))

输出：

原列表： [11, 32, 22, 54, 21, 8] 2592097781568
升序排序后的列表： [8, 11, 21, 22, 32, 54] 2592096474688
降序排序后的列表： [54, 32, 22, 21, 11, 8] 2592097664384

3.如果排序不同类型的数据会怎样？

1）字符串类型的数据不能和其他类型数据进行排序。

lst = [11, 32, 1, 22, 54, 21, 8, True, False, 3.14]
lst.sort()
print(lst)
# 除了字符类型的数据不能同其他类型的数据比较外，其他类型的数据都可以参与排序
# bool类型的数据，True当做1，False当做0

输出：

[False, 1, True, 3.14, 8, 11, 21, 22, 32, 54]

2）字符串类型的数据只能和字符串类型的数据排序。

lst = ['zhangsan', 'lisi', 'wangwu']
lst.sort()
print(lst)
# 字符类型的数据只能和字符类型的数据进行比较，所以字符类型的数据也只能和字符类型的数据相互排序

输出：

['lisi', 'wangwu', 'zhangsan']

3）结论：字符串类型的数据只能和字符串类型的数据排序（能排序的前提是能比较）。

5.5列表生成式

列表生成式就是“生成列表的公式”。

语法格式：

在这里插入图片描述

注意：

要想使用列表生成式，列表中的元素必须有一定的规律；
“表示列表元素的表达式”中，通常包含自定义变量。

例：

"""创建一个值为1-10的列表"""
lst = [i for i in range(1, 11)]
print(lst)

"""生成一个值为2,4,6,8,10的列表"""
lst = [i*2 for i in range(1, 6)]
print(lst)

"""生成一个值为2,4,8,16...的列表"""
lst = [i*i for i in range(1, 10)]
print(lst)

输出：

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[2, 4, 6, 8, 10]
[1, 4, 9, 16, 25, 36, 49, 64, 81]

带if条件判断的列表生成式：

for循环后面还可以加上if判断，比如仅计算偶数的平方。

lst = [x*x for x in range(1, 11) if x % 2 == 0]
print(lst)
'''
输出:
[4, 16, 36, 64, 100]
'''

若if在for后面，不能加else; 若if在for前面，必须加else。

lst = [x*x for x in range(1, 11) if x % 2 == 0 else 0] # 报错
lst = [x if x % 2 == 0 for x in range(1, 11)] # 报错
'''
正确写法：
'''
lst = [x*x for x in range(1, 11) if x % 2 == 0]
lst = [x if x % 2 == 0 else -x for x in range(1, 11)]

可以使用两层循环：

lst = [m + n for m in "ABC" for n in "XYZ"]
print(lst)
'''
输出：
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
'''

import os
lst = [d for d in os.listdir(".")]

5.6 列表的复制

1. 使用切片和copy函数浅拷贝：

lst = [1, 2, 3]
print(id(lst))
lst2 = lst[:]
print(id(lst2))
lst3 = lst.copy()
print(id(lst3))
'''
可能的输出：
1807681709504
1807681662528
1807682007872
'''

浅拷贝创建的是一个新对象，但它只复制了对象的顶层元素引用，而不是列表中的内容。

a = [1, [2], [1, 2]]
print(id(a))
print(id(a[1][0]))
b = a.copy()
print(id(b), b)
print(id(b[1][0]))
a[0] = 2 # 修改顶层，b不变
a[2] = 3
a[1][0] = 3 # 修改a深层列表中的数据，b中会跟着改变
print(b)
'''
输出：
2507043659648
2507041997072
2507043653184 [1, [2], [1, 2]]
2507041997072
[1, [3], [1, 2]]
'''

2. 使用deepcopy深拷贝：

import copy
a = [1, [2], [1, 2]]
b = copy.deepcopy(a)

a[1][0] = 3 # 无论如何改变a，b都不会改变
print(a)
print(b)
'''
输出：
[1, [3], [1, 2]]
[1, [2], [1, 2]]
'''