Python学习笔记（列表）

第16节课 列表

1 内置容器与序列

在Python中，我们经常需要处理和组织多个数据，内置容器就为我们提供了方便的方式，来去存储和管理数据的集合。

• 列表
• 字符串
• 元组
• 集合
• 字典

序列，是一种特殊类型的内置容器，强调元素的有序性（不是说排序，元素的出入顺序是可以确定的）和可迭代性（可以通过角标、切片、循环的方式来访问数据元素），常见的序列类型包括：

• 列表
• 元组
• 字符串
• 字节序列
• 范围对象（Range）

2 列表的定义与创建

列表是一种有序的可变序列（容器中的元素是可以改变的），它可以容纳任意类型的元素（整数、小数、字符串、布尔、列表、字典、元组…都可以），当然为了方便统一管理和存储，一般都建议存储的是同类型的元素。

为什么会存在列表？就是因为不想用多个变量存储多个数据，这样子的话不方便操作。

a = 1
b = 2
c = 1
d = 3
arr = [1,2,1,3]

所谓的列表，就是堆内存中，地址连续且大小相等的一组连续的存储空间

列表中，元组之间用逗号分隔，整个列表用方括号[]括起来的。

# 创建空列表
arr = []        # []

# 通过list()内置函数创建空列表
arr = list()    # []

# 利用list()内置函数将一个字符串转换为列表
arr = list("abc")   # ['a', 'b', 'c']

# 利用list()内置函数将range()转换为列表
arr = list(range(2,11,2))   # [2, 4, 6, 8, 10]

arr = [1, 2, 3, 4, 5]   # [1, 2, 3, 4, 5]

# 不推荐这么进行赋值 一般建议同类型
arr = [3.14, "Hello", True, 2 + 3j, print]

# 创建长度为10， 默认值为0的列表
arr = [0] * 10  # [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

# 列表推导式 就是通过循环来创建一个列表
arr = [i for i in range(1, 11)] # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

arr = [i ** 2 for i in range(1, 11)] # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

arr = [i for i in range(1, 101) if i % 3 == 0 and i % 5 == 0] # [15, 30, 45, 60, 75, 90]

# 可以将其他的列表转为当前的列表
lst = [1, 2, 3, 4]
arr = [i + 1 for i in lst] # [2, 3, 4, 5]

# 集合input map使用
# 输入 1 2 3
arr = input("输入一组数字，用空格隔开：").split(" ")
# ['1', '2', '3']
arr = list(map(int, input("输入一组数字，用空格隔开：").split(" ")))
# [1, 2, 3]
arr = [int(i) for i in input("输入一组数字，用空格隔开：").split(" ")] 
# [1, 2, 3]
print(arr)  

3 序列的通用操作

适用于列表、元组、字符串

（1）索引

就是元素在序列中的位置，位置默认都是从0开始的，可以通过索引来访问任何合法位置的元素

arr = [1, 2, 3, 4, 5]

序列除了支持正数角标外，也支持负数角标，负数角标意义为倒数第几个

arr = [1, 2, 3, 4, 5]
print(arr[0])
print(arr[4])
print(arr[-1])
print(arr[-3])
# print(arr[5]) # IndexError: list index out of range 角标越界
# print(arr[-6]) # IndexError: list index out of range

（2）切片

就是通过一种快捷的方式，来获取序列中一个连续的子区间

sequence[start:stop:step]，和之间的range很像

• start 指的是起始角标 不写的话 默认从角标0开始
• stop 指的是结束角标 不取 [start, stop)，不写的话，默认一直到最后一个元素（包含）
• step 指的是步长，不写的话默认为1

arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 从角标2开始，直到表尾 步长默认为1
print(arr[2:]) # [3, 4, 5, 6, 7, 8, 9]
# 从角标2开始，直到表尾 步长为2
print(arr[2::2]) # [3, 5, 7, 9]
# 从角标0开始，直到角标6（不包含） 步长1
print(arr[:6]) # [1, 2, 3, 4, 5, 6]
# 从角标2开始，直到角标8（不包含） 步长3
print(arr[2:8:3]) # [3, 6]
# 从头到尾 步长2
print(arr[::2]) # [1, 3, 5, 7, 9]
# 逆序
print(arr[::-1]) # [9, 8, 7, 6, 5, 4, 3, 2, 1]
# 从角标2到倒数第2个（不包含），步长2
print(arr[2:-2:2]) #[3, 5, 7]
# 从倒数第2个到角标2 步长2
print(arr[-2:2:2]) # []
# 从倒数第2个到角标2 步长-2
print(arr[-2:2:-2]) # [8, 6, 4]

正步长 step > 0 start在前，stop在后 start -> stop 从左到右

负步长 step < 0 start在后，stop在前 start -> stop 从右到左

（3）连接与重复

可以使用+做序列的拼接，可以使用*做序列的重复

arr1 = [1, 2, 3]
arr2 = [4, 5, 6]
arr3 = arr1 + arr2
print(arr1) #[1, 2, 3]
print(arr2) #[4, 5, 6]
print(arr3) #[1, 2, 3, 4, 5, 6]
arr4 = arr3 * 3
print(arr3) #[1, 2, 3, 4, 5, 6]
print(arr4) #[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]

（4）长度与最值

就是关于列表的一些内置函数，重点对序列进行操作

arr = [1, 3, 2]
print(len(arr)) # 3 列表中的元素个数 
print(max(arr)) # 3 列表中的最大值
print(min(arr)) # 1 列表中的最小值
print(sum(arr)) # 6 列表中的元素和
max = 10
print(max(arr)) # TypeError: 'int' object is not callable

（5）成员资格检查

使用 in 和 not in 来判断一个元素是否存在与序列当中，计算结果为布尔类型

arr = [1, 3, 2]
print(4 in arr)
print(4 not in arr)
s = "Hello World Python"
print("Python" in s)
print("X" not in s)

4 列表对象函数

对象函数是区别于内置函数和自定义函数的，内置函数我们可以直接调用，自定义函数先定义后调用，对象函数必须通过具体的对象来进行调用 对象.函数()，说白这些函数可以认为是某一个数据对象自身携带的功能。具体看一下列表中的对象函数都有哪些：

>>> help()
help> list # 查看list的详细介绍

append(object)：在列表末尾添加元素object

arr = [1, 2, 3]
arr.append(4)
print(arr)
arr.append(5)
print(arr)

insert(index,object)：在指定角标index处，插入元素object

arr = [1, 2, 3]
"""
 1   2   3
 0   1   2
-3  -2  -1
"""
arr.insert(0, 4)
print(arr) # [4, 1, 2, 3]
arr.insert(3, 5)
print(arr) # [4, 1, 2, 5, 3]
arr[0] = 6
print(arr) # [6, 1, 2, 5, 3]
arr.insert(5, 4) # 在表尾添加
print(arr) # [6, 1, 2, 5, 3, 4]
arr.insert(len(arr), 7) # 在表尾添加
print(arr) # [6, 1, 2, 5, 3, 4, 7]

# 当index > len(arr) 看做表尾添加
arr.insert(1000, 8) # [6, 1, 2, 5, 3, 4, 7, 8]
print(arr)
# 当index < -len(arr) 看做表头添加
arr.insert(-10, 9) # [9, 6, 1, 2, 5, 3, 4, 7, 8]
print(arr)

arr.insert(4, True)
print(arr) # [9, 6, 1, 2, True, 5, 3, 4, 7, 8]

extend(sequence)：将序列sequence中的元素逐个添加在表尾

arr1 = [1, 2, 3]
arr2 = [4, 5, 6]
arr1.append(arr2)
print(arr1) # [1, 2, 3, [4, 5, 6]]
print(len(arr1))

arr1 = [1, 2, 3]
arr2 = [4, 5, 6]
arr1.extend(arr2)
print(arr1) # [1, 2, 3, 4, 5, 6]

remove(value)：从左到右删除列表中第一次出现的元素value，没返回值，找不到会报错

arr = [3,2,1,3,2,1]
arr.remove(3)
print(arr) # [2, 1, 3, 2, 1]
# 如果删除一个不存在的元素 则报错
arr.remove(6) # ValueError: list.remove(x): x not in list
print(arr)

pop(index)：删除指定角标index处的元素，并将其返回，如果角标不在合法范围内，则报错

arr = [1,2,3,4]
# 删除表尾 -> 出栈
# append 在表尾添加 -> 入栈
print(arr.pop())    # 4
print(arr)          # [1, 2, 3]
print(arr.pop(0))   # 1
print(arr)          # [2, 3]
print(arr.pop(5))   # IndexError: pop index out of range
print(arr)

额外补充：

对于栈的操作 进栈push 出栈pop 查看栈顶 peek

对于队列的操作 入队pull 出队poll 查看队首 element

del 关键字：不是列表对象函数，删除元素但不会返回其值

arr = [1,2,3,4]
# 通过角标删除一个元素
del arr[0]
print(arr) # [2,3,4]
# del arr[-8] # IndexError: list assignment index out of range
arr = [1,2,3,4,5,6,7,8,9]
# 通过切片删除一组元素
del arr[::2]
print(arr) # [2, 4, 6, 8]

sort()：排序

arr = [9,2,4,8,3,1,6,5,7]
arr.sort()
print(arr)

arr = [9,2,4,8,3,1,6,5,7]
arr.sort(reverse=True)
print(arr)

arr = ["banana", "apple","cat","dog","elephant","fruit","girlfreind"]
arr.sort()
print(arr)

arr = ["banana", "apple","cat","dog","elephant","fruit","girlfreind"]
# 本身的比较方式是按照元素内容来排序
arr.sort(key=len) # 指定比较的方式 按照序列长度比大小
print(arr)

# Python中 也有关于排序的内置函数 sorted()
arr1 = [9,2,4,8,3,1,6,5,7]
# 以原数组为源 创建新的副本并进行排序 不会对源数据进行改变
arr2 = sorted(arr1)
print(arr1)
print(arr2)

reverse()：反转列表

arr = [9,2,4,8,3,1,6,5,7]
arr.reverse()
print(arr)

count(value)：统计元素value出现的次数

arr = [1,0,1,0,1,1,1,1,0,1,0,1]
print(arr.count(1))
print(arr.count(0))
print(len(arr))

index(value, start)：从指定start默认0处开始从左到右查找元素value第一次出现的位置

arr = [1,0,1,0,1,1,1,1,0,1,0,1]
print(arr.index(0)) # 1
print(arr.index(0,5)) # 8

clear()：清空列表 -> []

copy()：浅拷贝列表

arr1 = [1,2,3,4,5,6]
arr2 = arr1
arr1[0] = 666
print(arr1)
print(arr2)

arr1 = [1,2,3,4,5,6]
arr2 = arr1.copy() # 创建新的列表对象 和源列表内容一样
arr1[0] = 666
print(arr1) # [666, 2, 3, 4, 5, 6]
print(arr2) # [1, 2, 3, 4, 5, 6]

arr1 = [1, 2, 3, [4, 5, 6]]
arr2 = arr1.copy()
arr1[3][0] = 666
print(arr1) # arr1 = [1, 2, 3, [666, 5, 6]]
print(arr2) # arr2 = [1, 2, 3, [666, 5, 6]]