列表

1.列表的概念

  • 列表的数据项可以是不同的类型，在[]中表示，用,分隔

  • 创建一个空列表

    • 实际开发中，无法预测到底有多少个值，所以创建空列表
    • 1

  • 创建方式：

    • lst=[]

    • 通过list()函数

      lst=list(range(1,15,5))
print(lst)
# [1, 6, 11]
2. 列表的索引和切片
课前补充：
a=[1,2,3]
b=[1,2,3]
print(id(a),id(b))
c=1
print(id(c),id(a[0]),id(b[0]))
'''
1639465046536 1639465047048
140721792056384 140721792056384 140721792056384
'''

相同内容的列表的地址不同，但是相同下标的相同内容地址相同，说明列表是可变的，与字符串相对。

a=list("abcd")
print(a)
a=list({1,2,1,2})
print(a)
a=list({"m":"1","n":"2"})
print(a)
print(a*2)
print([1,2]+['a','b'])
a=[1,2,3,4,5,6]
print(a[2:4])
print(a)
'''
['a', 'b', 'c', 'd']
[1, 2]
['m', 'n']
['m', 'n', 'm', 'n']
[1, 2, 'a', 'b']
[3, 4]
[1, 2, 3, 4, 5, 6]
'''
3.列表的常用操作

  1. 添加元素

    函数 功能
    append(obj) 在列表末尾添加元素obj
    extend(seq) 在列表末尾一次性增加另一个序列seq中的多个元素（seq：元素列表，可以是列表、元组、集合、字典，若为字典,则仅会将键(key)作为元素依次添加至原列表的末尾）
    insert(index,obj) 将元素obj插入到列表的index位置 
    print("===========")
a=[1,2]
b=a.append([3,4])
print(a)
print(b)

a=[1,2,3]
b=a.extend([3,4])
print(a)
print(b)

a=[1,3]
b=a.insert(1,8)
print(a)
print(b)

del a
print(a)
'''
[1, 2, [3, 4]]
None
[1, 2, 3, 3, 4]
None
[1, 8, 3]
None
NameError: name 'a' is not defined

'''

  2. 删除元素

    函数 功能
    remove(obj) 删除列表中第一次出现的obj元素
    clear() 删除列表中的所有位置
    pop(index==-1) 删除列表中index处的元素（默认index=-1），并且返回该元素的值
    del 删除列表或者对应的下标位置的值

  3. 查找函数

    index(obj,start=0,end=-1)

  4. 元素排序

    sort()函数：对列表中的元素进行排序

    但是注意：

    l=[1,'a',3,'56','D']
print(l.sort())
# TypeError: '<' not supported between instances of 'str' and 'int' 不同类型报错

    reverse()函数：将列表中的元素反转（逆序），并且没有返回值

    a=[1,2,3]
a.reverse()
print(a.reverse())
print(a)
'''
None #注意函数没有返回值
[1, 2, 3]
'''

  5. 统计元素个数

    count()函数

  6. 补充

    镶嵌列表（相当于多维列表）

    a=[[1,2,3],[7,8,9],[10,11,12]]
print(a[2][2])
# 12
a=[[1,2,3]*2]*2
print(a)
# [[1, 2, 3, 1, 2, 3], [1, 2, 3, 1, 2, 3]]

    在列表上进行其他操作

    函数 功能
    enumerate(list) 将一个可遍历的数据对象(如列表、元组或者字符串)组合成一个索引序列，同时列出数据和数据下标
    zip(list1,list2) 将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表
    map(fun,list) 将函数作用到每一个列表元素当中，然后返回由这些元素组成的列表 
    s=[1,3,4,5]
print(len(s))
print(max(s))
print(min(s))
print(sum(s))
'''
4
5
1
13
'''

    w=[1,2,3,4,5]
e=[100,200,300,7,8,9,10]
q=enumerate(w)
# print(q)
print(*q) #快速打开隐式列表，但是只展示一次
print(list(q))
print(list(zip(e,w)))
print(map(str,w))
print(list(map(str,w)))
'''
(0, 1) (1, 2) (2, 3) (3, 4) (4, 5)
[]
[(100, 1), (200, 2), (300, 3), (7, 4), (8, 5)]
<map object at 0x000001F76E52FCC8>
['1', '2', '3', '4', '5']

'''

补充三：列表后中存放的是数据的地址，而不是值本身

无论对列表了l1进行什么增删改查操作，都不会影响它本身的存储，只是改变了存储的内容，但是对l1重新赋值，地址就会发生改变

注意：*产生的效果

补充四：直接赋值、浅拷贝、深拷贝、

浅拷贝：拷贝父对象，不会拷贝对象内部的子对象

深拷贝：copy模块的deecopy，完全拷贝了父对象和子对象

# 浅拷贝
a=[1,2,[3,4]]
b=a.copy()
print(a)
print(b)
a[0]=100 #父对象不变
print(a)
print(b)
a[2][0]=8 #子对象发生改变
print(a)
print(b)
'''
[1, 2, [3, 4]] 
[1, 2, [3, 4]]
[100, 2, [3, 4]]
[1, 2, [3, 4]]
[100, 2, [8, 4]]
[1, 2, [8, 4]]
'''

# 深拷贝
import copy

a=[1,2,[3,4]]
b=copy.deepcopy(a) #完全不会改变
print(a)
print(b)
a[0]=100
print(a)
print(b)
a[2][0]=8
print(a)
print(b)
'''
[1, 2, [3, 4]]
[1, 2, [3, 4]]
[100, 2, [3, 4]]
[1, 2, [3, 4]]
[100, 2, [8, 4]]
[1, 2, [3, 4]]
'''
4.列表推导
'''
执行顺序:各语句之间是镶套关系，左边第二个语句是最外层，一次往右进一层，左边的第一条语句是
最后一层。
'''
import random

l1=[x*x for x in range(10)]
print(l1)
l1=[]
# 等价于：
# for x in range(10):
#     l1.append(x*x)
# print(l1)
# 写到这里复习一下列表的添加：append(obj) extend(seq) insert(index,obj)

# 使用列表推导式实现嵌套列表的平铺
vec=[[1,2,3],[4,5,6],[7,8,9]]
print([num for a in vec for num in a]) # a是其中的嵌套列表，num是嵌套列表中的元素
# 这个列表中有两个循环，其中一个循环可以看作是外循环，执行的慢，第二个循环是内循环，执行的快

# 在列表推导式中使用if过滤不符合条件的元素
l2=[-1,5,6,-8,-7]
print([i for i in l2 if i>0])

# 查找列表中最大元素的位置
x=[random.randint(1,10) for i in range(20)] # 生成介于[1,10]之间的整数20个
m=max(x)
print([index for index,value in enumerate(x) if value==m])
'''
enumerate函数：将可遍历的对象组合成一个索引，有编号有数值。
运用这个函数，找到最大值的位置。
'''

注意：

ls=[i**2  if i%2==0 else i**3 for i in range] #如果有else语句，需要把整个选择语句放在前面