【python语法】 列表的使用与列表函数

列表一般方法

列表元素的遍历

常用的遍历方法：以下标的形式遍历列表元素（这种方法可以修改列表元素）；通过创建副本的形式打印列表元素（这种方式只用来输出结果，不能修改元素）

list1 = ['Google', 'Runoob', 1997, 2000]
# 以地址形式遍历列表，可以改变列表的元素
for i in range(len(list1)):
    print(list1[i])
    if list1[i] == "Google":
        list1[i] = "microsoft"
print(list1)  # 列表元素发生改变，列表：['microsoft', 'Runoob', 1997, 2000]

for i in list1:
    print(i)
    if i == "Runoob":  # i 是列表元素的副本，修改i不会影响到列表元素本身
        i = "apple"
print(list1)  # 列表元素没有发生改变，list1 = ['microsoft', 'Runoob', 1997, 2000]

del 删除列表中的元素

del 的用法是：

del list[i]  # 其中list[i]代指的是元素值

查找列表中的对应元素并删除：

list1 = ['Google', 'Runoob', 1997, 2000, 2020, 3080]
for i in range(len(list1)):
    print(list1[i])
    if list1[i] == 1997:
        del list1[i]
        break  # 在目标元素删除之后，其余的元素会自动补全删除元素的空位（下标向前移一位），在删除后需要跳出循环否则会造成数组越界的错误

print(list1)  # list1 = ['Google', 'Runoob', 2000, 2020, 3080](元素 1997 已经被删除)

这种情况只适用于用下标遍历列表的情况，创建副本遍历列表不会删除任何元素（列表元素不改变）

list1 = ['Google', 'Runoob', 1997, 2000, 2020, 3080]
for data in list1:
    if data == 3080:
        del data  # 因为data 是原列表的副本，所以列表元素不会被被删除
print(list1)  # list1 = ['Google', 'Runoob', 1997, 2000, 2020, 3080](列表元素不改变)

列表运算符

常见的运算符有以下几种：

• +：归并：将两个列表中的元素汇总在一个列表中
• *：重复：将一个列表中的元素重复 n 次
• len()：求长度：返回列表的长度
• in \ not in :判断对应的元素是否在列表中
• 注意：列表中没有 “ - ”运算

list1 = ['Google', 'Runoob', 1997, 2000, 2020, 3080]
list2 = ['Google','apple', 'samsumg', 'dell', 'intel', 'amd', 100000, 555]
print(len(list1),len(list2))  # 6 8 （返回两个长度值）
print(list1 + list2)  # ['Google', 'Runoob', 1997, 2000, 2020, 3080, 'Google', 'apple', 'samsumg', 'dell', 'intel', 'amd', 100000, 555]  将两个列表的元素进行累加（不会过滤重复的元素）
print(list2 * 2)  # ['Google', 'apple', 'samsumg', 'dell', 'intel', 'amd', 100000, 555, 'Google', 'apple', 'samsumg', 'dell', 'intel', 'amd', 100000, 555]  将列表元素变为原来的 2 倍（每种元素的数量都变成原来的 2 倍）
print(1997 in list2)  # False 元素不在列表中
print('dell' not in list1) # True 元素在列表中

列表嵌套

列表嵌套是将一个列表作为元素存储在另一个列表之中；此时外层列表的第一个下标代表对应的内层列表

用法：

a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n]
print(x)  # [['a', 'b', 'c'], [1, 2, 3]]
# 将内层列表看作外层列表的元素  
print(x[0][1])  # 输出 x列表中的下标为 0 的列表中下标为1的元素  b
print(x[1][2])  # 第一个下标决定是哪个列表，第二个下标决定是列表中的哪个元素  3
list3 = [[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]
# 遍历嵌套列表中的所有元素
for lists in list3:
    # print(data)
    for duallists in lists:
        # print(duallists)
        for i in duallists:
            print(i, end="")   # 123456789101112  (输出了嵌套列表中的所有元素)

遍历嵌套列表中的元素时，有几层嵌套就用几层循环，这样可以逐个输出列表元素

列表常用函数

list.append()

append() 函数功能是在列表的末尾添加新的元素，用法：

list.append(args)

• args ：参数；可以是单独的元素，也可以是列表（如果是列表会将列表作为一个元素添加到之前的列表中）

mylist = [1, 2, 3, 4, 5, 6]
mylist.append(60)
print(mylist)  # [1, 2, 3, 4, 5, 6, 60]（添加了新的元素）
mylist.append([99,100,101])
print(mylist)  # [1, 2, 3, 4, 5, 6, 60, [99, 100, 101]]（将列表作为新的元素添加到之前的列表中）

list.pop()

pop() 函数弹出列表元素，当pop()函数不带参数时，默认弹出最后一个元素；当pop()函数带有参数时，弹出下标为函数参数的元素

mylist = [1, 2, 3, 4, 5, 6]
mylist.pop()
print(mylist)  # [1, 2, 3, 4, 5] 弹出最后的元素
mylist.pop(1)
print(mylist)  # [1, 3, 4, 5] 弹出下标为 1 的元素

list.extend()

extend() 函数，在列表后添加新的列表元素，函数的参数是一个可迭代对象（列表，元组），将参数对象中的元素添加到原列表中；函数用法：

list.extend(iter)

• iter：可迭代对象，调用后元素会添加到原列表中

mylist = [1, 2, 3, 4, 5, 6]
mylist.extend([4, 5, 6, 78, 9]) 
print(mylist)   # [1, 2, 3, 4, 5, 6, 4, 5, 6, 78, 9] 列表添加了参数中的列表元素
mylist.extend((8, 12, 66, 50))
print(mylist)  # [1, 2, 3, 4, 5, 6, 4, 5, 6, 78, 9, 8, 12, 66, 50] 列表添加了参数中元组的元素

list.index()

index() 函数，列表元素查询，返回对应元素的下标

mylist = [1, 2, 3, 4, 5, 6, 4, 5, 6, 78, 9, 8, 12, 66, 50]
print(mylist.index(78))   # 9 元素 78 的下标为 9

list.insert()

insert() 函数，向指定的位置插入指定的元素，有两个参数，第一个参数是指定位置在列表中的下标，第二个参数是需要插入的元素；用法：

list.insert(index,args)

• index：插入元素的下标
• args：插入的元素

mylist = [1, 2, 3, 4, 5, 6, 4, 5, 6, 78, 9, 8, 12, 66, 50]
mylist.insert(7,"google") 
print(mylist)  # [1, 2, 3, 4, 5, 6, 4, 'google', 5, 6, 78, 9, 8, 12, 66, 50] 插入指定的元素
print(mylist.index("google"))  # 7 返回元素的下标

list.remove()

remove() 函数，删除第一个元素（只删除第一个参数中对应的元素；不会删除其他对应的元素）；用法：

list.remove(arg)

• arg：需要删除的元素

mylist = [1, 2, 3, 4, 5, 6, 4, 5, 6, 78, 9, 8, 12, 66, 50]
mylist.remove(5)
print(mylist)  # [1, 2, 3, 4, 6, 4, 5, 6, 78, 9, 8, 12, 66, 50]  第一个 5 被删除了

list.reverse()

reverse() 函数，将列表元素顺序反转

mylist = [1, 2, 3, 4, 5, 6, 4, 5, 6, 78, 9, 8, 12, 66, 50]
mylist.reverse()
print(mylist)  # [50, 66, 12, 8, 9, 78, 6, 5, 4, 6, 5, 4, 3, 2, 1]  列表顺序反转

max||min

max()找出列表中数值，或者ASCII值最大的元素，反之min() 找出列表中数值或者ASCII值最小的元素

mylist = ['a','t','c','s0']
print(max(mylist))  # t
print(min(mylist))  # a

list.sort()

sort() 函数对列表进行排序，默认的排序规则是从小到大排序（根据数值或者ASCCII值）

mylist = ['a','t','c','s0']
mylist.sort()
print(mylist)  # ['a', 'c', 's0', 't']  根据ASCII值从小到大排序的结果

浅拷贝与深拷贝||list.copy()

浅拷贝，拷贝后的列表与原列表指向同一内存空间，拷贝后元素发生变化时，原列表元素也跟着变化（因为修改的是同一块内存空间）；深拷贝，开辟一块新的内存空间，创建源列表的副本并赋值给新的列表对象（指向新的列表对象）新列表修改元素不会影响原列表不是同一块内存

深拷贝函数用法：

list2 = list1.copy()

• list2 : 新列表
• list1: 源列表

mylist = [1, 5, 6, 8, 9, 77]
mylistnew = mylist  # 浅拷贝
print(id(mylist), id(mylistnew))  #  2180719247936 2180719247936  浅拷贝，新的变量指向原列表的地址
mylistnew[2] = 100000
print(mylistnew, mylist)  # 修改的是同一块内存空间  [1, 5, 100000, 8, 9, 77] [1, 5, 100000, 8, 9, 77]
# 深拷贝
mylistnew = mylist.copy()   # 深拷贝重新开辟一块内存空间存放原列表（数据）的副本
print(id(mylistnew), id(mylist))  # 2180719241344 2180719247936  深拷贝的列表与原列表存储空间不同
mylistnew[0] = "google"  # ['google', 5, 100000, 8, 9, 77] [1, 5, 100000, 8, 9, 77]  修改任一变量互不影响
print(mylistnew, mylist)