2021-10-09

9、数据类型详解——列表

列表是一组有序的数据组合，列表中的数据可以被修改

1.列表的定义

• 通过中括号进行定义 [ ]
• 使用 list 函数定义
• 定义列表中的元素，需要每个元素之间使用逗号，进行分隔
• 列表是可变序列，通常用于存放同类项目的集合

2.列表的基本操作

# 列表的定义和基本操作
varlist1 = [1,2,3,4]
varlist2 = ['a', 'b', 'c', 'd']

# 列表之间的拼接操作,通过加号将两个列表拼接成一个
print(varlist1+varlist2)

# 列表元素的重复添加
print(varlist1*3)

# 检测列表中的是否存在该元素
res = 'a' in varlist2
print(res)

# 列表的索引操作
print(varlist2[2])
print(varlist1[-2])

# 列表中修改元素
# varlist2[2] = 'cc'
# print(varlist2)

# 列表中追加元素
varlist1.append(5)      # 只能追加单个元素
varlist1.append([5, 6, 7, 8])   #列 表中嵌入新列表
print(varlist1)

# 列表元素的删除
del varlist1[2]
print(varlist1)

# 列表长度的检索
print(len(varlist1))

3.列表的切片操作

# 列表的切片操作

varlist = ['吴京', '甄子丹', '李连杰', '刘德华', '郭富城', '张国荣', '张学友', '黎明']

'''
语法规则：
varlist[x:x:x] ====> [开始索引:结束索引:步进值]
                    [2] 调用列表元素
                    [2:] 顺序从2号元素开始截取
                    [:6] 顺序从列表开始到6号元素截取
                    [] [:] [::] 截取列表所有元素
                    [:: -1] 逆序截取全部元素
                    [-2:-5:-1] 逆序截取对应元素
              0      1         2        3       4       5        6      7
varlist = ['吴京', '甄子丹', '李连杰', '刘德华', '郭富城', '张国荣', '张学友', '黎明']
             -8      -7      -6      -5       -4       -3      -2       -1          
'''
print(varlist[2])
print(varlist[2:])
print(varlist[:6])
print(varlist[1:6:2])
print(varlist[::])
print(varlist[::-1])
print(varlist[-2:-5:-1])

#使用切片方式，对数据进行更新
print(varlist)
varlist[2:4] = ['张三','李四']
print(varlist)
varlist[2:4] = ('陈大')
print(varlist)

# 使用切片方式进行删除。
del varlist[2:4]
print(varlist)

#使用切片方式进行元素增加
varlist[2:4] = ['陈大', '李二']
varlist[2:6:2] = ['陈大','李二']
print(varlist)

4.列表的应用操作

# 列表的应用操作

varlist = ['吴京', '甄子丹', '李连杰', '刘德华', '郭富城', '张国荣', '张学友', '黎明']

# 检测当前列表的长度
res = len(varlist)
print(res)

# 检测当前列表元素指定的元素出现的次数
res = varlist.count('张学友')
print(res)


# 列表后追加新元素 append('新增元素')
varlist.append('谢霆锋')
print(varlist)

# 列表指定位置添加新元素 insert（指定元素位置,添加元素）
varlist.insert(0,'张家辉')
print(varlist)

# 列表元素的pop(指定出栈元素位置)弹出，出栈操作,默认最后的元素开始出战。
res = varlist.pop(6)
print(res)

# 列表元素的移除remove(指定移除元素)，列表中相关元素全部移除
varlist1 = [1,2,3,12,23,32,43,54,71,45,65,74,27,1,2,3,4,5,6]
varlist1.remove(3)
print(varlist1)

# index()可以查找指定元素在列表中的出现的位置
# index(查询元素,列表开始元素,列表结束元素)

res = varlist1.index(2,2,20)
print(res)

# extend()列表的扩展添加
res = varlist1 + ['a','b','c']
print(res)
varlist1.extend(['a','b','c'])
print(varlist1)

# reverse()列表元素的反转
varlist1.reverse()
print(varlist1)

# copy() 元素列表的复制操作
varlist2 = ['a', 'b', 'c', 'd', [11, 22, 33, 44]]
print(varlist2)
res = varlist2.copy()
# del res[2]
del res[4][2]
print(res)

5.列表的深拷贝与浅拷贝

# 简单拷贝的操作
varlist = [1, 2, 3, 4]
newlist = varlist.copy()
print(varlist,id(varlist))
print(newlist,id(newlist))
varlist1 = [1, 2, 3, 4, ['a', 'b', 'c', 'd']]
newlist1 = varlist1.copy()
# 浅拷贝，当拷贝的列表中，如果对多维列表的元素进行操作时，原来被拷贝的列表也会进行相同操作。
del newlist1[4][1]
print(varlist1,id(varlist1))
print(newlist1,id(newlist1))
'''
[1, 2, 3, 4, ['a', 'b', 'c', 'd']] 2188394834496
[1, 2, 3, 4, ['a', 'b', 'c', 'd']] 2188398785152
删除后
[1, 2, 3, 4, ['a', 'c', 'd']] 2292397058624
[1, 2, 3, 4, ['a', 'c', 'd']] 2292397470400
'''
print(varlist1[4],id(varlist1[4]))
print(newlist1[4],id(varlist1[4]))
'''
['a', 'c', 'd'] 1846594278720
['a', 'c', 'd'] 1846594278720
浅拷贝中，仅拷贝了外层列表，嵌套列表中的数据依旧操作相同的存储信息
'''
# 深拷贝操作，完全拷贝全部数据
import copy  #导入拷贝模块
varlist2 = [1, 2, 3, 4, ['a', 'b', 'c', 'd']]
newlist2 = copy.deepcopy(varlist2)
del newlist2[4][1]
print(varlist2[4],id(varlist2[4]))
print(newlist2[4],id(varlist2[4]))

6.列表推导式

• 基本列表推导式

变量 = [临时变量操作结果 for 临时变量 in 容器类型数据]

# 列表推导式
# 假设需要生成0到9的平方列表
varlist = []
for i in range(10):
    i **= 2
    varlist.append(i)
print(varlist)
# 使用MAP函数和list函数生成列表
varlist1 =[]
varlist1 = list(map(lambda x: x**2, range(10)))
print(varlist1)
# 列表推导式 [元素操作  for循环条件]
varlist2 = [i**2 for i in range(10)]
print(varlist2)

# 将字符串'1234' ==> [2,4,6,8]
# 常规的方法
varstr = '1234'
newlist = []
for i in varstr:
    newlist.append(int(i)*2)
print(newlist)
# 列表推导式
newlist1 = [int(x)*2 for x in varstr]
print(newlist1)

• 带判断条件的列表推导式

变量 = [临时变量操作结果 for 临时变量 in 容器类型数据 条件表达式]

# 带判断的列表推导式
'''
例子： 0 - 9 的列表，取偶数
'''
#一般的取值
newlist = []
for i in range(10):
    if i % 2 == 0:
        newlist.append(i)
print(newlist)

# 列表推导式操作
newlist1 = [x for x in range(10) if x % 2 == 0]
print(newlist1)

# 多次循环判断推导式
'''
实例：[1,2,4] /  [4,5,6]
组成不相同两个列表组合

'''
# 普通的表达式
combs = []
for x in [1,2,4]:
    for y in [4,5,6]:
        if x != y:
            combs.append((x, y))
print(combs)

# 列表推导式
combs1 = [(a, b) for a in [1, 2, 4] for b in [4, 5, 6] if a != b]
print(combs1)

• 嵌套的列表推导式

#嵌套列表推导式
'''
将3行4列的列表，交换行列数值
'''
matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12]
]
res = [[row[i] for row in matrix] for i in range(4)]
print(res)

res2 = []
for i in range(4):
    newlist = []
    for now in matrix:
        newlist.append(now[i])
    res2.append(newlist)
print(res2)
#练习：使用列表推导式完成99乘法表运算
varlist1 = [[a*b for b in range(1, 10) if a <= b] for a in range(1, 10)]
print(varlist1)

7.列表推导式练习

#使用列表推导式
'''
将字典和对于的数据转换成列表 ，在转换成字符串
{"user": 'admin', 'age':20, 'phone':'133'}
==> ['user = admin','age = 20', 'phone = 133']
'''

vardict = {"user": 'admin', 'age': 20, 'phone': '133'}

# 1、字典的特性：直接取值则时取走字典最前端的值；取字典对应参数在需要后者表达式
for i in vardict:
    print(i)
    print(vardict[i])
# 使用内置函数调用字典
for k, j in vardict.items():
    print(f'{k}={j}')

vardict1 = [f'{i}={vardict[i]}' for i in vardict]
print(vardict1)

res = '&'.join(vardict1)
print(res)


# 2、使用列表推导式完成，把列表中的字符全部转化为小写

varlist = ['AAAAA', 'Bbbbb', 'CCCccc']
varlist1 = [i.lower() for i in varlist]
print(varlist1)

# 3、x是 0-5 之间的偶数 ， y是0-5之间的奇数，把x,y组成一个元组，放在列表中

varlist2 = [(x, y) for x in range(0,6,2) for y in range(1,6,2)]
print(varlist2)

newlist = [(a,b)for a in range(6) for b in range(6) if a % 2 == 0 and b % 2 ==  1 ]
print(newlist)

newlist1 = [f'{c}x{d}={c*d}' for c in range(1,10) for d in range(1, 10) if c <= d]
print(newlist1)

# 4、求M,N矩阵和元素的乘积,使用列表表达式
'''
M = [
        [1,2,3]
        [4,5,6]
        [7,8,9]
]
N = [
        [2,2,2]
        [3,3,3]
        [4,4,4]
]
使其列表一一对应相乘得出
[[2， 4， 6], [12, 15, 18], [28, 32, 36]]
'''
M = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
N = [[2, 2, 2], [3, 3, 3], [4, 4, 4]]
newlist = []
for i in range(3):
    res = []
    for j in range(3):
        res.append(M[i][j]*N[i][j])
    newlist.append(res)
print(newlist)
# 使用列表推导式求解
newlist1 = [[M[a][b]*N[a][b] for b in range(3)] for a in range(3)]
print(newlist1)