06-列表的操作

g列表的操作

---

列表相加操作

格式：变量 = 列表1 + 列表2
结果：集合两个列表所有元素的新列表
注意：+两侧都要是列表类型

# L = [1,2,3]
# L1 = [4,5,6]
# print(L+L1)

列表相乘操作

格式：变量 = 列表 * 整数
结果：原列表内所用元素复制N遍的新列表

# L = [1,2,3]
# print(L*2)

索引操作

变量[索引]

分片操作

• 格式：变量 = 列表[:]
  获取整个列表
• 格式：变量 = 列表[:结束索引]
  获取列表开头到结束索引之前的数据组成的列表
• 格式：变量 = 列表[开始索引:]
  获取列表开始索引到列表末尾的数据组成的列表
• 格式：变量 = 列表[开始索引:结束索引]
  • 获取开始索引和结束索引之间的数据组成的列表（包含开始索引，不包含结束索引）
• 格式：变量 = 列表[开始索引:结束索引:间隔值]
  • 获取开始索引和结束索引之间的数据（按照间隔值来获取）组成的列表（包含开始索引，不包含结束索引）

# L = [1,2,3,4,5,6,7,8,9]
# L1 = L[6:3:-1]
# print(L1)

成员检测

• 检测一个数据是否在列表中
  格式：值 in 列表
  结果：布尔值

• 检测一个数据是否不在列表中
  格式：值 not in 列表
  结果：布尔值

列表的遍历操作

---

for...in

• 格式：
  for 变量 in 列表：
  使用变量

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

while

• 格式
  i = 0
  while i<len(列表):
  使用列表中的元素(列表[i])
  i += 1

# L = [1,2,3,4,5,6,7]
# i = 0
# while i<len(L):
#     print(L[i])
#     i += 1

遍历同等长度的二级列表

列表 = [[值1,值2],[值1,值2],....]
for 变量1,变量2 in 列表:
    使用变量1和变量2

注意：变量1取二级列表中的第一个值，变量2取第二个值

# L = [[1,2],[3,4],[5,6]]
# for val,var in L:
#     print(val,var)

遍历非同等长度的二级列表

列表 = [[值1，值2]，[值1，值2,值3],[值]...]
for 变量1 in 列表:
    for 变量2 in 变量1:
        使用变量2(变量2是二级列表中的每个值)

# L = [[1,2],[3,4],[5,6,7]]
# for val in L:
#     print(val,type(val))
#     for var in val:
#         print(var,type(var))

列表的十一种操作方法

copy() 复制列表

• 涉及深浅拷贝，此为浅拷贝

clear()

• 清空列表

append()
功能：向列表的末尾添加新的元素
格式：列表.append(值)
返回值：None
注意：新添加的值在列表的末尾，该函数直接操作原有列表

# L.append(8)
# L.append(7)
# print(L)

insert()
功能：在指定位置之前插入元素
格式：列表.insert(索引,值)
返回值:None
注意：直接改变原有列表

# L.insert(0,1)
# print(L)

extend()
功能：前一个列表继承另一个序列，即直接将另一个序列中的元素添加到这个列表中，如果这个序列是字符串，字符串中每个字符作为一个元素添加到列表中
格式：列表.extend(序列)
返回值：None
注意：直接改变原有列表

# L.append(L1)
# print(L)
# L.extend(L1)
# print(L)

pop()
功能：在列表中移除一个元素
格式：列表.pop(索引)
返回值：无
注意：没有指定索引，默认移除最后一个元素

# L.pop()
# L.pop(0) #可以传递索引值  来删除指定的元素
# print(L)

remove()
功能：移除指定的值，但只能移除列表中该值第一次出现的元素
格式：列表.remove(值)
返回值：无
注意：如果有索引的情况下推荐使用POP移除，效率比remove高

# L.remove([7,8,9])
# L.remove(8) #如果有多个相同的元素  默认删除第一个
# print(L)

index()
功能：获取某个元素在列表中的索引,只能获取第一个出现的该元素的索引，拥有3个参数
格式：index(元素，开始索引，结束索引)
返回值：整数
注意：值不存在与列表或指定区间内时抛出异常错误！

# print(L.index(8))
# print(L.index(7,5))
# L = [2,1,5,4,2,4,6,4,2,1,5]
# print(L.pop(L.index(5,L.index(5)+1)))
# print(L)

count()
功能：计算某个元素出现的次数
格式：列表.count(值)
返回值：整数

# L = [2,1,5,4,2,4,6,4,2,1,5]
# print(L.count(2))
# print(L.count(5))
# print(L.count(6))

sort()
功能：列表排序

• 格式：列表.sort() 按照从小到大排序（数字）
• 格式：列表.sort(reverse=True) 按照从大到小排序（数字）
• 格式：列表.sort(key=函数) 对值进行指定的函数处理之后在从小到大排序
• 格式：列表.sort(key=函数，reverse=True) 对值进行指定的函数处理之后在从大到小排序
  返回值：None
  注意：直接改变原有列表

# L = [2,1,4,3,7,6]
# L.sort()
# print(L)
# L = [2,1,4,3,7,6]
# L1 = L.sort()
# L1 = sorted(L)
# print(L)
# print(L1)

L = [
    {"name":"jack","age":18},
    {"name":"rose","age":22},
    {"name":"tom","age":102},
    {"name":"jerry","age":19}
    ]
L.sort(key=lambda x:x["name"])
print(L)

reverse()
功能：列表反转操作
格式：列表.reverse()
返回值：None

# L = [2,1,4,3,7,6]
# L.reverse()
# print(L)

列表推导式

列表的推导公式默认是层层嵌套的关系
格式：

例1：已知L = [1,2,3,4,5,6,7,8,9],求变量L内所有元素的平方组成的列表

for循环写法：

# L1 = []
# for val in L:
#     L1.append(val**2)
# print(L1)

列表推导式

# L1 = [var**2 for var in L]
# print(L1)

例2：求L中所有偶数的平方

for循环写法

# L1 = []
# for val in L:
#     if val % 2 == 0:
#         L1.append(val**2)
# print(L1)

列表推导式

# L1 = [val**2 for val in L if val%2==0]
# print(L1)

例3：L = ["jack","ada","tom","WE","file","continue","break"]求列表中所有元素的长度组成的列表

# L1 = [len(i) for i in L]
# print(L1)

例4：已知str="abc" str2="ABC" 求两个字符串中的元素的所有组合

# L1 = [x+y for x in str1 for y in str2 ]
# print(L1)

例5：求x,y组成的元组 x是1~5之间的偶数 y是1~6之间的奇数

# L1 = [x for x in range(1,5) if x % 2==0]
# print(tuple(L1))
# L2 = [y for y in range(1,6) if y % 2==1]
# print(tuple(L2))
#
# list1 = [(x,y) for x in range(2,6,2) for y in range(1,7,2)]
# print(list1)

# L = [(x,y) for x in range(1,5) if x%2==0 for y in range(1,7) if y%2==1]
# print(L)

例6：已知 L = [[1,2,3],[4,5,6],[7,8,9]]求[3,6,9]组成的列表

# L1 = [i[2] for i in L]
# print(L1)

例7：求上面列表中[1,5,9]组成的列表

# L1 = [L[i][i] for i in range(len(L))]
# print(L1)

# i = 0,1,2
# 当i = 0  L[i] = [1,2,3]  L[i][i] = 1
# 当i = 1  L[i] = [4,5,6]  L[i][i] = 5
# 当i = 2  L[i] = [7,8,9]  L[i][i] = 9

深浅拷贝

需要用到copy模块，import copy

赋值操作 赋值后的列表跟随元列表进行改变

• 赋值操作直接把新变量的内存地址指向赋值的变量的内存地址，所以原变量变化时，新变量随之变化

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

浅拷贝 只拷贝外层列表 内层列表跟随原列表进行改变

• 浅拷贝只能拷贝外层内容，内层内容相当于做了映射；所以原变量外层变化时，新变量不变化，原变量内层变化时，新变量跟着变化

# L1 = copy.copy(L)
# L.append(5)
# L[2][2].append(7)
# print(L)
# print(L1)

深拷贝 深拷贝拷贝整个列表 不跟随原列表进行改变

# L1 = copy.deepcopy(L)
# L.append(5)
# L[2][2].append(7)
# print(L)
# print(L1)

元组的操作

元组的遍历

for ... in

变量 = (值1,值2,值3...)
for 变量 in 元组:
    使用变量获取元组的每个值

# t = (1,2,3,4)
# for val in t:
#     print(val)

while

i = 0
while i<len(元组):
    使用元组变量[i]访问每个值
    i += 1

# t = (1,2,3,4)
# i = 0
# while i < len(t):
#     print(t[i])
#     i += 1

遍历长度相同的多级元组

元组 = ((值1,值2...),(值1,值2...)...)
for 变量1，变量2.. in 元组:
    使用变量1和变量2

# t = ((1,2),(3,4),(5,6))
# for val,var in t:
#     print(val,var)

遍历长度不同的多级元组

元组 = ((值1,值2...),(值1,值2...)...)
for 变量1 in 元组:
    for 变量2 in 变量1：
        使用变量2获取每个值

# t = ((1,2),(3,4,5),(6,7))
# for val in t:
#     for var in val:
#         print(val,var)

元组的操作方法

index()

获取指定值在元组中的索引值
格式：元组.index(值)
返回值：整数
print(t.index(2))

count()

计算某个值在元组中出现的次数
格式：元组.count(值)
返回值：整数
print(t.count(2))

元组推导式

• 元组的推导式形式和列表的基本一致，唯一不一样的是生成的不是一个新的元组，而是一个生成器，生成器用for循环遍历出数值

基本格式：

格式： 变量 = (i for i in 元组)
结果：不是元组而是一个生成器

带条件格式：

格式： 变量 = (i for i in 元组 if 条件表达式)
结果：不是元组而是一个生成器

多循环推导式：

格式： 变量 = (x+y for x in 元组1 for y in 元组2)
结果：不是元组而是一个生成器   x+y可以是其他操作

带条件的多循环推导式：

格式： 变量 = (x+y for x in 元组1 for y in 元组2 if 条件表达式)
结果：不是元组而是一个生成器   x+y可以是其他操作