列表 list

列表概述

# 创建列表
test = [1, 2, 3, 4]
# 列表可以放置多个类型元素，字符串，整数，浮点数等等
# 使用for循环迭代循环打印列表内容
for i in test:
  print(i)

 # 单独访问列表其中一个元素，使用下标索引访问，下标从0开始
test[0] --> 1
test[-1]  --> 列表最后一个元素

列表切片

# 列表切片
test = [1, 2, 3, 4, 5, 6]
test[0:2] --> [1, 2, 3]
test[:3]  --> [1, 2, 3, 4]
test[2:]  --> [3, 4, 5, 6]
test[:] --> [1, 2, 3, 4, 5, 6]

# 同样可以设置步进跳着获取元素
test[1:3:2] --> [2]
test[::2] --> [1, 3, 5]

# 反方向步进获取元素
test[::-2] --> [6, 4, 2]

# 将整个列表倒叙
test[::-1] --> [6, 5, 4, 3, 2, 1]

列表的增删改查

增加元素

# 使用append()添加元素，在列表的末尾添加指定元素，每次只能添加一个元素
test = [1, 2, 3]
test.append(4) --> test = [1, 2, 3, 4]

# extend()，可以添加一个可迭代对象
test.extend(["hello", "it"]) --> test = [1, 2, 3, 4, "hello", "it"]
# 注意使用extend()方法添加内容必须是一个可迭代对象，添加的内容会添加在列表最后一个元素后面

# 同样可以使用切片进行添加元素
a = [1, 2, 3]
a[len(a)] = 7 --> a = [1, 2, 3, 7]
a[len(a):] = [6, 7] --> a = [1, 2, 3, 7, 6, 7]

# 使用insert()方法在列表指定位置添加元素，共有两个参数，第一个是插入的位置，第二个是插入的元素，如果第一个参数大于列表的索引会从最后一个元素后面添加
b = [1, 3, 4]
b.insert(1, 2) --> b = [1, 2, 3, 4]
b.insert(len(b), 5) --> b = [1, 2, 3, 4, 5]  # 添加到末尾

删除元素

# 将指定的元素删除使用remove()方法，如果元素不存在会报错，如果存在多个相同元素，则会删除最开始的那个元素
c = [1, 2, 3]
c.remove(1) --> c = [2, 3]

# 删除指定索引的元素使用pop()方法
c.pop(1) --> c = [2]

# 使用clear()方法清空列表元素
c.clear() --> c = []

修改元素

# 列表和字符串的最大区别就是列表可以修改，字符串不可以修改
d = [1, 2, 3]
d[0] = "hello" --> d = ["hello", 2, 3]

# 利用切片可以将多个列表元素进行替换修改
d[1:] = ["word", "!!"] --> d = ["hello", "word", "!!"]

# 列表从小到大排序，使用sort()方法，列表所有元素必须是同一数据类型
e = [4, 2, 1, 5]
e.sort() --> e = [1, 2, 4, 5 ]

# 列表从大到下排序，使用reverse()，同样需要都是同一数据类型
e.reverse() --> e = [5, 4, 2, 1]

查找元素

# 获取列表元素某个元素的个数，使用count()
f = [1, 1, 2, 3, 5]
f.count(1) --> 2

# 查找某个元素的索引值，使用index()方法，如果列表有多个相同元素，只返回第一个元素索引
f.count(1) -->0
# 当不知道列表元素的索引，可以使用index方法进行替换
f[f.index(5)] = 99 = f = [1, 1, 2, 3, 99]
# index()方法有两个参数可以指定开始和结束位置
index(元素, start, stop)

# 列表的拷贝，使用copy()方法，浅拷贝
ff = f.copy() --> ff = [1, 1, 2, 3, 5]
# 使用切片同样可以实现，浅拷贝
ff = f[:]

列表的加法和乘法

列表的加法实际是列表的拼接，列表的乘法则是重复列表元素若干次

# 列表加法
s = [1, 2, 3]
z = [4, 5, 6]
s + z = [1, 2, 3, 4, 5, 6]

# 列表乘法
s*3 = [1, 2, 3, 1, 2, 3, 1, 2, 3]

嵌套列表

在列表里面嵌入一个或多个列表成为列表的嵌套。

# 二维嵌套列表
a = [[1, 2, 4], [4, 5, 6]]
b = [[1, 2, 4],
     [4, 5, 6]]

# 嵌套列表的访问，通过下标或者循环获取元素值
a[0][0] = 1
a[1][0] = 4
for i in a:
  for x in i:
    print(x)

 # 通过乘法嵌套列表，每个嵌套元素属于同一内存地址，修改一个元素其他元素也都会跟着修改
lists = [[]] * 3
lists = [[], [], []]
lists[0].append(3)
lists = [[3], [3], [3 ]]

浅拷贝和深拷贝

列表的赋值，如果没有使用拷贝，直接将列表赋值给变量，修改列表，变量的值也会相对修改。

a = [1, 3, 4]
b = a
a[0] = 3 # a --> [3, 3, 4]  b  --> [3, 3, 4]

浅拷贝

使用 copy() 方法进行浅拷贝，不过浅拷贝只可以适用于一维列表，多维列表使用浅拷贝无法将列表进行完全拷贝，浅拷贝只是拷贝最外层列表。

# 此时修改a的元素值b列表则不会发生改变

# 使用copy()
a = [1, 3, 4]
b = a.copy()

# 使用切片同样可以实现拷贝
b = a[:]

深拷贝

此时需要进行模块的导入 import copy

import copy
a = [[1, 3, 4], [1, 3, 4], [1, 3, 4]]
# 浅拷贝
b = copy.copy(a)
# 深拷贝
c = copy.deepcopy(a)

列表推导式

使用列表推导式相对于循环迭代拥有更高的执行效率，语法： [expression for target in iterable]和[expression for target in iterable if condition] ,列表推导式依然可以进行嵌套，语法：

[expression for target1 in iterable
            for target2 in iterable
            .....
            for targetN in iterable
]
[expression for target1 in iterable if condition1
            for target2 in iterable if condition2
            .....
            for targetN in iterable if conditionN
]

a = [1, 2, 3, 4]
# 对列表元素全部乘以2
for i in range(0, len(a)):
  a[i] = a[i]*2

# 使用列表推导式
[i*2 for i in a]

# 例一
test1 = [i for i in range(3)]  # test1 --> [0, 1, 2]

# 例二
test = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
]
test2 = [i[1] for i in test]  # test2 --> [2, 5, 8]

# 例三
test = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
]
test2 = [test[i][i] for i in range(len(test))]  # test2 --> [1, 5, 9]

# 列表推导式进阶--末尾添加if进行条件判断
b = [i for i in range(10) if i % 2 == 0]  # b --> [0, 2, 4 ,6, 8]
# 执行顺序是：先执行for循环，然后执行if语句判断，最后执行最开始语句加入列表

# 列表推导式的嵌套
# 例四
test = [
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
]
c = [i for a in test for i in a]  # c --> [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 列表推导式的嵌套添加if进行条件判断
d = [[x, y] for x in range(4) if x % 2 == 0 for y in range(4 ) if y % 3 == 0]
# d --> [[0, 0], [0, 3], [2, 0], [2, 3]]