Python教程 -基础数据类型 list 列表

• 列表是一个有序的序列
• 列表中所有的元素放在 [ ] 中间，并用逗号分开
• 一个 列表 可以包含不同类型的元素，但通常使用时各个元素类型相同

特征

占用空间小，浪费内存空间少

声明列表变量

• 列表元素可以是任意数据类型，也可以混搭
• 可以数组嵌套数组，俗称二元数组

lis = [1, 2, 3, 1.11]
lis = ["a", "b", "c"]
lis = [True, False]
lis = [{"a": 123}, {"b": 456}]
lis = [[1], [2]]
lis = [(1), (2)]
lis = [1, 1.2, "2", True, {}, [], ()]

列表常见运算操作

运算符 +

# + 运算
a = [1] + [2, 3, ] + [4, 5]
print(a)

b = [1, 2] + ["3", "4"]
print(b)

# 输出结果
[1, 2, 3, 4, 5]
[1, 2, '3', '4']

•  变量 b 是赋值两个不同数据类型的列表，虽然不会报错，但是 pycharm 会有 warning
• Expected type ‘List[int]’ (matched generic type ‘List[_T]’), got ‘List[str]’ instead
• 本来应该是 List[int]，但后面用了 List[str] 代替，不过我也没 get 到这个 warn 想干嘛哈哈

运算符 *

# * 运算
a = [1, 2] * 3
print(a)

# 输出结果
[1, 2, 1, 2, 1, 2]

索引（下标）取值

# 索引
a = [1, 2, True, {"name": "小菠萝"}, ["how", "hi"]]

print(a[0])
print(a[2])
print(a[-1])
print(a[-2])

# 输出结果
1
True
['how', 'hi']
{'name': '小菠萝'}

切片取值

• 和字符串一样，列表也可以切片
• 使用语法：列表[start : end : step]，获取列表中在 [start, end) 范围的子列表
• 注意范围 [start, end) 包含 start，不包含 end
• step 是步长，设为 n，则每隔 n 个元素获取一次

# 切片
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(a[:])  # 取全部
print(a[0:])  # 取第一个元素到最后一个元素
print(a[::-1])  # 逆序取全部元素
print(a[2:5])  # 取第三个元素到第五个元素

# 输出结果
[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
[0, 9, 8, 7, 6, 5, 4, 3, 2, 1]
[3, 4, 5]

切片赋值

注意：赋值的值也必须是列表，否则会报错  TypeError: can only assign an iterable

# 切片赋值
a = ["1", "2", "3"]
print(a)
a[:] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]  # 切片获取所有元素，并重新赋值
print(a)

a[2:4] = [33, 44]
print(a)

a[2:4] = []  # 相当于去掉第 3、4 个元素
print(a)

a[:] = []  # 将 a 赋值为空列表
print(a)

# 输出结果
['1', '2', '3']
[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
[1, 2, 33, 44, 5, 6, 7, 8, 9, 0]
[1, 2, 5, 6, 7, 8, 9, 0]
[]

关键字 in

• 通过关键字 in 检查列表中是否包含指定元素，返回 bool 值
• not in 则是取反

# in、not in
a = [1, 2, True, {"name": "小菠萝"}, ["how", "hi"]]

print(1 in a)
print(3 in a)
print({"name": "小菠萝"} in a)
print(False not in a)

# 输出结果
True
False
True
True

列表常见会用上的内置函数

len()

获取列表长度

# 获取列表长度 
print(len([1, 2, 3, 4])) 

# 输出结果 
4

max()

获取列表值最大的元素

最简单的栗子

# max
a = [1, 2, 3]
print(max(a))

# 输出解雇
3

不同数据类型的栗子

# 其他栗子 
a = [1, 2, True, 3]
print(max(a))

a = ["a", "b", "c"]
print(max(a))

a = [[1, 2], [3, 4], [3, 5]]
print(max(a))

# 输出结果
3
c
[3, 5]

同一个列表里包含不同数据类型的话呢？

a = ["a", "b", 1]
print(max(a))

# 输出结果
    print(max(a))
TypeError: '>' not supported between instances of 'int' and 'str'

• 很明显，直接报错了，提示 > 运算符不支持在 int 、str 两种数据类型做运用
• 所以，使用 max、min 函数时，列表的数据记得是同一个数据类型哦

传多个参数的栗子

上面的栗子都是给 max 函数传递了单个参数

print(max(1, 2, 3))
print(max([1, 2], [1, 2, 3]))

# 输出结果
3
[1, 2, 3]

会返回最大的那一个参数值

查看 max() 源码

def max(*args, key=None): # known special case of max
    """
    max(iterable, *[, default=obj, key=func]) -> value
    max(arg1, arg2, *args, *[, key=func]) -> value

    With a single iterable argument, return its biggest item. The
    default keyword-only argument specifies an object to return if
    the provided iterable is empty.
    With two or more arguments, return the largest argument.
    """
    pass

两种传值方式

max(iterable, *[, default=obj, key=func])

倘若只传一个列表，那么可以指定 default 参数值，当传的列表为空的时候，返回 default 值

max(arg1, arg2, *args, *[, key=func])

可以传多个参数，返回最大的参数值

min()

• 获取列表值最小的元素
• 跟 max() 就是反过来了，不再举栗子咯

list 常见方法

list.append(x)

介绍

• 在列表的末尾添加一个元素
• 相当于  a[len(a):] = [x]

返回值

None

栗子

# append
a = [1, 2, 3]
b = [4, 5, 6]

print(a.append(1))
print(a)

a.append(b)
print(a)

# 输出结果
None
[1, 2, 3, 1]
[1, 2, 3, 1, [4, 5, 6]]

a.append(b) 会将整个列表当做一个元素添加进去哦

list.extend(iterable)

介绍

• 使用可迭代对象中的所有元素来扩展列表
• 粗俗点：在列表后面接另一个列表
• 相当于  a[len(a):] = iterable

返回值

None

栗子

# extend
a = [1, 2, 3]
b = [4, 5, 6]

print(a.extend([]))
print(a)

a.extend(b)
print(a)

a = [1, 2, 3]
b = [4, 5, 6]

print(a + b)

# 输出结果
None
[1, 2, 3]
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6]

extend() 有点像列表相加，但还是有区别的

a.extend(b) 和 a+b 的区别

• extend() 传的参数只要求是可迭代对象
• 但是列表相加，要求都是列表
• 而可迭代对象的讲解可以参考：

前置知识

• 如果给定一个 list 或 tuple，我们可以通过 for 循环来遍历这个 list 或 tuple，这种遍历我们称为迭代（Iteration）
• 在 Python 中，迭代是通过 for … in 来完成的

lists = [1, 2, 3, 4, 5]
for i in lists:
    print(i)

可迭代对象

• for 循环不仅可以用在 list 或 tuple 上，还可以用在其他可迭代对象上
• list 这种数据类型虽然有下标，但很多其他数据类型是没有下标的，但是只要是可迭代对象，无论有无下标，都可以迭代

dicts = {
    "a": 1,
    "b": 2
}
for i in dicts:
    print(i)

# 输出结果
a
b

如何判断一个对象是否是可迭代对象？

from collections import Iterable

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

dicts = {
    "a": 1,
    "b": 2
}

print(isinstance(lists, Iterable))
print(isinstance(dicts, Iterable))
print(isinstance({"test"}, Iterable))
print(isinstance(1234, Iterable))

# 输出结果
True
True
True
False

enumerate 函数

• 循环列表的话，默认是只返回元素值，如果想同时拿到元素值和对应的下标值呢？
• enumerate 函数可以把 list 变成一个 索引-元素对的迭代对象，然后循环遍历这个对象即可

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

# 看看是不是迭代对象
print(isinstance(enumerate(lists), Iterable))

# 循环
for ind, val in enumerate(lists):
    print(ind, val)

# 输出结果
True
0 1
1 2
2 3
3 4
4 5

多嵌套列表

for x, y in [(1, 1), (2, 4), (3, 9)]:
    print(x, y)

# 输出结果
1 1
2 4
3 9

总结

任何可迭代对象都可以作用于 for 循环，包括我们自定义的数据类型，只要符合迭代条件，就可以使用 for 循环

list.insert(i, x)

介绍

• 在给定的位置插入一个元素
• i：是要插入的元素的索引
• x：插入的元素值
•  a.insert(0, x) 插入列表首位
•  a.insert(len(a), x)  等同于  a.append(x)

返回值

None

栗子

# insert
a = [1, 2, 3]
print(a.insert(0, 0))
print(a)

b = [4, 5, 6]
a.insert(999, b)
print(a)

# 输出结果
None
[0, 1, 2, 3]
[0, 1, 2, 3, [4, 5, 6]]

如果 i 值大于列表长度，那么就会在列表末尾添加元素

list.remove(x)

介绍

• 移除列表中第一个值为 x 的元素
• 如果没有这样的元素，则抛出 ValueError 异常

返回值

None

栗子

# remove
a = [1, 2, 3, 1]
print(a.remove(1))
print(a)

a.remove(4)

# 输出结果
None
[2, 3, 1]
Traceback (most recent call last):
    a.remove(4)
ValueError: list.remove(x): x not in list

list.pop([i])

介绍

• 删除列表中指定位置的元素并返回它
• 如果没有指定位置，a.pop() 将会删除并返回列表中的最后一个元素
• [i] 代表参数 i 是可选的，不是必填的，不是让你传 [1] 、[2] 这种参数

返回值

被删除的元素值

栗子

# pop
a = [1, 2, 3, 4]
print(a.pop(3))
print(a)

a.pop()
print(a)

a.pop(1)
print(a)

# 输出结果
4
[1, 2, 3]
[1, 2]
[1]

list.clear()

介绍

• 移除列表中的所有元素
• 等价于 del a[:]

返回值

None

栗子

# clear
a = [1, 2, 3, 4]
print(a.clear())
print(a)

# 输出结果
None
[]

list.index(x[, start[, end]])

介绍

• 返回列表中第一个值为 x 的元素的索引
• 如果没有这样的元素将会抛出 ValueError 异常
• 可选参数 start 和 end 是切片符号，用于将搜索限制为列表的特定子序列
• 返回的索引是相对于整个序列的开始计算的，而不是 start 参数

返回值

索引值

栗子

# index
a = [1, 2, 3, 4]
print(a.index(2))
print(a.index(1, 0, 2))
print(a.index(33))

# 输出结果
1
0
Traceback (most recent call last):
    print(a.index(33))
ValueError: 33 is not in list

list.count(x)

介绍

返回元素 x 在列表中出现的次数

返回值

次数

栗子

# count
a = [1, 2, 1, 4]
print(a.count(1))
print(a.count(3))

# 输出结果
2
0

list.sort(*, key=None, reverse=False)

介绍

对列表中的元素进行排序（参数可用于自定义排序）

返回值

None

栗子

# sort
a = [4, 3, 2, 1]
print(a.sort())
print(a)

a.sort(reverse=True)
print(a)

# 输出结果
None
[1, 2, 3, 4]
[4, 3, 2, 1]

list.reverse()

介绍

翻转列表中的元素

返回值

None

栗子

# reverse()
a = [1, 2, 3, 4]
print(a.reverse())
print(a)

# 输出结果
None
[4, 3, 2, 1]

list.copy()

介绍

• 返回列表的一个浅拷贝
• 等价于 a[:]

返回值

原来的列表

栗子

# copy
a = [1, 2, 3, [1, 2, 3]]
print(a.copy())

b = a.copy()
a[1] = 11
print(a)
print(b)
a[3][2] = 22
print(a)
print(b)

# 输出结果
[1, 2, 3, [1, 2, 3]]
[1, 11, 3, [1, 2, 3]]
[1, 2, 3, [1, 2, 3]]
[1, 11, 3, [1, 2, 22]]
[1, 2, 3, [1, 2, 22]]

可以从结果看出，的确是浅拷贝