Python列表（知识点句句经典）

__add__, __class__, __class_getitem__, __contains__, __delattr__, __delitem__, __dir__, __doc__, __eq__, __format__, __ge__, __getattribute__, __getitem__, '__gt__', __hash__, __iadd__, __imul__, __init__, __init_subclass__, __iter__, __le__, __len__, __lt__, __mul__, __ne__, __new__, __reduce__, __reduce_ex__, __repr__, __reversed__, __rmul__, __setattr__, __setitem__, __sizeof__, __str__, __subclasshook__, append, clear, copy, count, extend, index, insert, pop, remove, reverse, sort

• 列表=list。

• 输入dir(list)或dir([])查看列表中的所有方法。

print(dir(list))
print(dir([]))

• 列表用于在单个变量中同时存储多个值。

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

• 如果把数组比作一个集装箱的话，那么Python的列表就是一个工厂的仓库。

• 列表真的非常有用基本上所有的Python程序都要使用到列表。

• 创建列表和创建普通变量一样，用中括号括起一堆数据就可以了，数据之间用逗号隔开。

list1 = [1, 2, 3, 4, 5]
print(list1)            # [1, 2, 3, 4, 5]

• 可以创建一个鱼龙混杂的列表，可以创建一个空列表。

list1 = []
print(list1)            # []

list2 = [1, "2", 3.3, (4,)]
print(list2)            # [1, '2', 3.3, (4,)]

• 使用list()函数创建一个列表。

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

• 列表a和列表b它们的值是相同的，但是id（内存地址）却不同。

a = [1, 2, 3, 4]
b = [1, 2, 3, 4]
print(a == b)           # True

• 可以在列表中嵌套序列。

a = ["字符串", [1, 2, 3], (1, 2, 3), {1: "星期一", 2: "星期二"}, {1, 2, 3}, 1, 2, 3, 4, 5]
print(a[0])              # 字符串
print(a[1])              # [1, 2, 3]
print(a[1][0])           # 1

• 列表里面可以存放多个列表称为多维列表（看得懂就背，看不懂学到后面再回来背）。

a1 = [1, 2, 3, 4, 5]     # 一维列表
print(a1[0])             # 1
print(a1[4])             # 5

a2 = [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]        # 二维列表
print(a2[0][0])          # 1
print(a2[1][0])          # 6

a3 = [[[1, 2, 3], [4, 5, 6]], [7, 8, 9]]        # 三维列表
print(a3[0][0][0])       # 1
print(a3[0][1][0])       # 4

• 一维列表和二维列表都是比较常见的，三维列表和四维列表极少数地方才用的到（看得懂就背，看不懂学到后面再回来背）。

• 在Python中可以直接定义二维列表（看得懂就背，看不懂学到后面再回来背）。

a = [[1, 2, 3, 5], [6, 7, 8, 9]]
print(a[0][0])           # 1
print(a[1][3])           # 9

• 在Python中使用嵌套的for循环创建二维列表（看得懂就背，看不懂学到后面再回来背）。

a = []                   # 创建一个空列表
for x in range(4):       # 循环四次
    a.append([])         # 在空列表中添加一个空列表
    for y in range(5):   # 循环五次
        a[x].append(y)   # 为内层列表添加元素，x是索引值，第一个索引为0
print(a)                 # [[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]

• 在Python中使用列表推导式创建二维列表（看得懂就背，看不懂学到后面再回来背）。

a = [[y for y in range(5)]for x in range(4)]        # 在列表推导式里面再创建一个列表推导式
print(a)             # [[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]

• 可以将二维列表转换成一维列表（看得懂就背，看不懂学到后面再回来背）。

a = [[0, 1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15]]
b = []
for x in a:             # 循环列表里面的元素
    for y in x:         # 循环列表里面的列表中的元素
        b.append(y)     # 将每一个元素添加到新列表中
print(b)                # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

• 可以遍历二维列表（看得懂就背，看不懂学到后面再回来背）。

a = [[1, 2, 3, 4, 5], [6, 7, 8]]
for i1 in a:            # 循环列表中的元素
    for i2 in i1:       # 循环列表里面的列表中的元素
        print(i2)       # 将列表里面的列表中的元素输出
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8

• 可以遍历列表中的元素和二维列表中的元素（看得懂就背，看不懂学到后面再回来背）。

a = [[0, 0, 0], 1, 2, 3, [4, 5, 6]]
for i in a:
    if type(i) == list:
        for j in i:
            print(j, end="")
    else:
        print(i, end="")
# 000123456

• 可以对列表中的单个元素或多个元素进行重新赋值。

# 对单个元素进行重新赋值

a = [1, 2, 3, 4, 5]
a[0] = 6
print(a)             # [6, 2, 3, 4, 5]

# 对多个元素进行重新赋值
a[:2] = [6, 7, 8]
print(a)             # [6, 7, 8, 3, 4, 5]

a[5] = 7 # 如果超出范围会报错
print(a)             # 报错

• 乘号*也可以运用到列表中。

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

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

• 使用in关键字判断左边的值是否包含在右边的列表中，包含返回True，不包含返回False。

a = [1, 2, 3, 4, 5]
print(1 in a)        # True

• 使用not in关键字判断左边的值是否不包含在右边的列表中，不包含返回True，包含返回False。

a = [1, 2, 3, 4, 5]
print(1 not in a)       # False

• 列表相当灵活，所以它的内容不可能总是固定的，可以向列表中添加元素。

• 向列表中添加元素有四种方法:append()、extend()、insert()、+=。

• 删除列表中的元素有三种方法:remove()、del、pop()。

• 使用append()方法向列表末尾添加一个元素。

lis = [1, 2, 3, 4]
lis.append(5)           # 整数
print(lis)              # [1, 2, 3, 4, 5]

lis.append("星期五")    # 字符串
print(lis)              # [1, 2, 3, 4, 5, '星期五']

lis.append([6, 7])      # 列表
print(lis)              # [1, 2, 3, 4, 5, '星期五', [6, 7]]

lis.append((8, 9))      # 元组
print(lis)              # [1, 2, 3, 4, 5, '星期五', [6, 7], (8, 9)]

lis.append({1: "星期一", 2: "星期二"})    # 字典
print(lis)              # [1, 2, 3, 4, 5, '星期五', [6, 7], (8, 9), {1: '星期一', 2: '星期二'}]

lis.append({10, 11})    # 集合
print(lis)              # [1, 2, 3, 4, 5, '星期五', [6, 7], (8, 9), {1: '星期一', 2: '星期二'}, {10, 11}]

lis.append(None)        # None
print(lis)              # [1, 2, 3, 4, 5, '星期五', [6, 7], (8, 9), {1: '星期一', 2: '星期二'}, {10, 11}, None]

• 使用extend()方法向列表末尾添加多个元素。

lis = [1, 2, 3, 4]
lis.extend("星期五")     # 字符串
print(lis)              # [1, 2, 3, 4, '星', '期', '五']

lis.extend([5, 6])      # 列表
print(lis)              # [1, 2, 3, 4, '星', '期', '五', 5, 6]

lis.extend((7, 8))      # 元组
print(lis)              # [1, 2, 3, 4, '星', '期', '五', 5, 6, 7, 8]

lis.extend({1: "星期一", 2: "星期二"})    # 字典
print(lis)              # [1, 2, 3, 4, '星', '期', '五', 5, 6, 7, 8, 1, 2]

lis.extend({9, 10})     # 集合
print(lis)              # [1, 2, 3, 4, '星', '期', '五', 5, 6, 7, 8, 1, 2, 9, 10]

• append()方法是将整个序列添加进去，extend()方法是将整个序列拆分后一个元素一个元素的添加进去。

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

lis.extend([7, 8])
print(lis)           # [1, 2, 3, 4, [5, 6], 7, 8]

• +=与extend()方法实现的效果是一样的。

lis = [1, 2, 3, 4]
lis += "星期五"         # 字符串
print(lis)              # [1, 2, 3, 4, '星', '期', '五']

lis += [5, 6]           # 列表
print(lis)              # [1, 2, 3, 4, '星', '期', '五', 5, 6]

lis += (7, 8)           # 元组
print(lis)              # [1, 2, 3, 4, '星', '期', '五', 5, 6, 7, 8]

lis += {1: "星期一", 2: "星期二"}   # 字典
print(lis)              # [1, 2, 3, 4, '星', '期', '五', 5, 6, 7, 8, 1, 2]

lis += {9, 10}          # 集合
print(lis)              # [1, 2, 3, 4, '星', '期', '五', 5, 6, 7, 8, 1, 2, 9, 10]

• 使用insert()方法向列表任意位置添加一个元素，它有两个参数，第一个参数代表要插入的位置，第二个参数代表要插入的元素。

lis = [1, 2, 3, 4]
lis.insert(5, 5)                # 整数
print(lis)                      # [1, 2, 3, 4, 5]

lis.insert(6, "星期五")         # 字符串
print(lis)                      # [1, 2, 3, 4, 5, '星期五']

lis.insert(7, [6, 7])           # 列表
print(lis)                      # [1, 2, 3, 4, 5, '星期五', [6, 7]]

lis.insert(8, (8, 9))           # 元组
print(lis)                      # [1, 2, 3, 4, 5, '星期五', [6, 7], (8, 9)]

lis.insert(9, {1: "星期一", 2: "星期二"})     # 字典
print(lis)                      # [1, 2, 3, 4, 5, '星期五', [6, 7], (8, 9), {1: '星期一', 2: '星期二'}]

lis.insert(10, {10, 11})        # 集合
print(lis)                      # [1, 2, 3, 4, 5, '星期五', [6, 7], (8, 9), {1: '星期一', 2: '星期二'}, {10, 11}]

lis.insert(11, None)            # None
print(lis)                      # [1, 2, 3, 4, 5, '星期五', [6, 7], (8, 9), {1: '星期一', 2: '星期二'}, {10, 11}, None]

• 使用count()方法计算它的参数在列表中出现的次数。

lis = [1, 1, 2, 3, 4]
lis.count(1)                 # 得到结果后并没有任何动作
print(lis)                   # [1, 1, 2, 3, 4]

x = lis.count(1)             # 将值赋给一个变量
print(x)                     # 2

• 使用index()方法计算它的参数在列表中出现的位置，如果列表中有相同的元素只会返回相同元素的第一个元素的索引。

lis = [1, 2, 1, 3, 4]
x = lis.index(1, 1, 3)
print(x)                         # 2

• 使用clear()方法清空列表，得到一个空列表。

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

• 使用clear()方法比直接定义一个空列表更节省性能。

• 使用copy()方法生成一个新列表，复制原列表中的所有元素（copy是深拷贝）。

lis1 = [1, 2, 3, 4]
lis2 = lis1.copy()              # 生成一个新的列表
print(lis1, id(lis1))           # [1, 2, 3, 4] 2327305644352
print(lis2, id(lis2))           # [1, 2, 3, 4] 2327308475328

lis = [1, 1, 2, 3, 4]
x = lis.index(4, 0, 5)          # 将值赋给一个变量
print(x)                        # 4

• 使用remove()方法删除元素，你并不需要知道该元素在列表中的具体位置只需要知道它存在列表中就可以了。

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

• 使用pop()方法，默认弹出列表中最后一个元素，当你为它加上一个索引的时候它会弹出这个索引对应的元素。

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

• 使用reverse()方法，将整个列表原地翻转。

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

• 使用sort()方法，对列表进行排序，默认从小到大排序。

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

lis.sort(reverse=True)           # 从大到小排序
print(lis)                       # [4, 3, 2, 1]

lis.sort(reverse=False)          # 从小到大排序
print(lis)                       # [1, 2, 3, 4]

• 使用del关键字删除列表中任意位置的元素。

lis = [1, 2, 3, 4]
del lis[0]                    # 删除某个元素
print(lis)                    # [2, 3, 4]

• 使用del关键字删除整个列表。

lis = [1, 2, 3, 4]
del lis

• 如果要从列表中删除一个元素且不在以任何方式使用它就使用del关键字和remove()方法，如果要从列表中删除一个元素，且还要继续使用它就使用pop()方法。

lis1 = [1, 2, 3, 4]
del lis1[0]                       # 不能把del语句赋一个变量
print(lis1)                       # [2, 3, 4]

lis2 = lis1.remove(2)             # 将删除的结果赋给一个变量
print(lis2)                       # None

x = lis1.pop()                    # 将删除的结果赋给一个变量
print(x)                          # 4

• 序列中的每一个元素都对应着一个索引值，通过索引值就可以访问序列中的单个元素。

a1 = "你好星期五"
print(a1[0])                      # 你
print(a1[1])                      # 好

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

• 索引分为正数索引和负数索引。

• 如果索引为正数，从0开始，执行顺序从左往右。

a = "Python"
print(a[0])                # p

• 如果索引为负数，从-1开始，执行顺序从右往左。

a = "Python"
print(a[-6])                # p

• 通过将索引指定为-1，可以让Python返回最后一个列表元素。

lis = [1, 2, 3, 4]
print(lis[-1])                     # 4

• 如果需要一次性获取多个列表元素，可以使用切片。

• 用冒号:隔开两个索引值左边是开始位置右边是结束位置，如果没有开始位置Python会默认开始位置为0，如果没有结束位置，Python会得到从指定索引值开始到列表末尾的所有元素。

lis = [1, 2, 3, 4]
print(lis[:3])                     # [1, 2, 3]
print(lis[0:])                     # [1, 2, 3, 4]

• 如果没有放入任何索引值只有一个冒号将得到整个列表的拷贝。

lis = [1, 2, 3, 4]
print(lis[:])                      # [1, 2, 3, 4]

• 切片操作实际上还可以接收第三个参数，其代表的就是步长，不指定它的时候该值为1，把步长设置为-1，就相当于复制一个反转的列表。

lis = [1, 2, 3, 4]
print(lis[0:3:2])                 # [1, 3]
print(lis[::-1])                  # [4, 3, 2, 1]
print(lis[::2])                   # [1, 3]

• 我们发现列表还是挺聪明的竟然会懂得比较大小，当列表包含多个元素的时候默认是从第一个元素开始比较，只要有一个PK赢了就算整个列表赢了。

lis1 = [1, 2]
lis2 = [3, 4]
print(lis1 < lis2)                 # True

• 使用list()函数把其它序列转换成列表。

a1 = (1, 2, 3, 4, 5)
print(list(a1))                    # [1, 2, 3, 4, 5]

a2 = {1: "星期一", 2: "星期二"}
print(list(a2))                    # [1, 2]

a3 = {1, 2, 3, 4, 5}
print(list(a3))                    # [1, 2, 3, 4, 5]

• 可以使用for循环遍历列表。

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

• 可以使用while循环遍历列表（一般不用while循环，都是用for循环）。

• 使用len()函数计算列表的长度。

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

• Python计算列表长度时从1开始，所以不会遇到差1错误。

• 使用type()函数查看列表的类型。

a = [1, 2, 3, 4, 5]
print(type(a))                     # <class 'list'>

• 使用min()函数找出数字列表中的最小值。

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

• 使用max()函数找出数字列表中的最大值。

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

• 使用sum()函数计算数字列表中的总和。

a = [1, 2, 3, 4, 5]
print(sum(a))                     # 15

• 列表推导式是指循环创建列表（看得懂就背，看不懂学到后面再回来背）。

列表推导式语法:[表达式 for 自定义变量 in 可迭代对象 if条件表达式]（条件表达式不是必须的）。

• 列表推导式就相当于for循环创建列表的简化版（看得懂就背，看不懂学到后面再回来背）。

• 列表推导式会遍历后面的可迭代对象，然后按照for循环前面的表达式进行运算，最终生成列表（看得懂就背，看不懂学到后面再回来背）。

• 在列表推导式中for循环后面可以跟if条件判断，if条件判断是for循环中的语句（看得懂就背，看不懂学到后面再回来背）。

a = [i for i in range(11) if i % 2 == 0]
print(a)                           # [0, 2, 4, 6, 8, 10]

• 使用列表推导式将创建新元素的代码和for循环合并成一行（看得懂就背，看不懂学到后面再回来背）。

lis = [i for i in range(11)]
print(lis)                     # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

lis = [i+2 for i in range(11)]
print(lis)                     # [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

lis = [i*2 for i in range(11)]
print(lis)                     # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]