Day8 列表详解（拷贝，推导式）——python学习之路

列表定义与基本操作

varlist1 = [1,2,3,4]
varlist2 = ['a','b','c','d']

# 列表的拼接
res = varlist1 + varlist2
print(res)				# [1, 2, 3, 4, 'a', 'b', 'c', 'd']

# 列表元素的重复
res = varlist1 * 3
print(res)				# [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]

# 检测元素是否存在于列表
res = '2' in varlist1
print(res)				# False

# 向列表元素中追加元素
varlist1.append('3.14')
print(varlist1)			# [1, 2, 3, 4, '3.14']

# 删除列表中的元素
del varlist1[1]
print(varlist1)			# [1, 3, 4, '3.14']

# 取出列表中最后一个元素, 列表最后一个元素会被删除
res = varlist1.pop()
print(res)				# 3.14

列表的切片操作

简单切片

# 列表[开始索引:结束索引:步进值]

varlist = [1,2,3,4,5,6,7]
# 1. 列表[开始索引:]      从开始索引到列表的最后
res = varlist[2:]
print(res)				#(输出) [3, 4, 5, 6, 7]

# 2. 列表[:结束值]       从开始到指定的结束索引之前
res = varlist[:4]
print(res)				#(输出) [1, 2, 3, 4]

# 3. 列表[开始索引:结束索引]  从开始索引到指定结束索引之前
res = varlist[2:4]
print(res)				#(输出) [3, 4]

# 4. 列表[开始索引:结束索引:步进值]  从指定索引开始到指定索引前结束, 按照指定步进值进行取值切片
res = varlist[1:5:2]
print(res)				#(输出) [2, 4]

# 5. 列表[:] 或 列表[::]     获取所有
res = varlist[::]
print(res)				#(输出) [1, 2, 3, 4, 5, 6, 7]

# 6. 列表[::-1]   倒着输出列表的元素
res = varlist[::-1]
print(res)				#(输出) [7, 6, 5, 4, 3, 2, 1]

使用切片，进行更新和删除

更新

# 使用切片进行更新
varlist = [1,2,3,4,5,6,7]

# 从指定下标开始, 到指定下标前结束, 并替换为对应的可迭代数据
varlist[1:5] = [7,8,9]
print(varlist)		#(输出) [1, 7, 8, 9, 6, 7]

# 如果给了步进值，则需要与要更新的元素个数对应
varlist[1:5:2] = [7,8]

删除

varlist = [1,2,3,4,5,6,7]
# 切片删除
del varlist[1:5:2]
print(varlist)		#(输出) [1, 3, 5, 6, 7]

列表相关函数

len()

varlist = [1,'two',3,'four',5,'six',7]
# len() 获取列表的长度
res = len(varlist)
print(res)			#(输出) 7

count()

varlist = [1,'two',3,'four',5,'six',7]
# count() 检测当前列表中元素出现的次数
res = varlist.count('six')
print(res)			#(输出) 1

insert()

varlist = [1,'two',3,'four',5,'six',7]
# insert() 可以向列表中指定的索引位置添加新的元素, 可以是负数索引, 如果索引超出列表长度则直接加在最后一个
varlist.insert(2,'nice')
print(varlist)		#(输出) [1, 'two', 'nice', 3, 'four', 5, 'six', 7]
varlist.insert(20,'out')
print(varlist)		#(输出) [1, 'two', 'nice', 3, 'four', 5, 'six', 7, 'out']

pop()

varlist = [1,'two',3,'four',5,'six',7]
# pop() 可以对指定索引位置上的元素做出栈操作, 返回出栈的元素
res = varlist.pop()     # 默认出栈最后一个元素
print(res)		#(输出) 7
res = varlist.pop(5)    # 指定下标出栈
print(res)		#(输出) six
# 元素出栈后在列表中会被删除

remove()

varlist = [1,'two',3,'four',5,'six',7]
# remove() 可以指定删除列表中的元素, 只删除第一个, 如果没找到则报错
varlist.remove('four')

index()

varlist = [1,'two',3,'four',5,'six',7]
# index() 可以查找指定元素在列表中第一次出现的位置, 即下标
print(varlist.index('six'))			#(输出) 5
# 可以在指定区间内查找元素的索引位置
print(varlist.index('six',2,6))

extend()

varlist = [1,'two',3,'four',5,'six',7]
# extend() 追加元素列表到原列表中
varlist.extend(['a','b','c'])
print(varlist)		#(输出) [1, 'two', 3, 'four', 5, 'six', 7, 'a', 'b', 'c']

clear()

varlist = [1,'two',3,'four',5,'six',7]
# clear()   清空列表内容
varlist.clear()
print(varlist)		#(输出) []

reverse()

varlist = [1,'two',3,'four',5,'six',7]
# reverse()     列表翻转
varlist.reverse()
print(varlist)		#(输出) [7, 'six', 5, 'four', 3, 'two', 1]

sort()

vars = [1,2,7,-8,4,5,-6,2,3]
# sort() 对列表进行排序, 默认从小到大排序
vars.sort()
print(vars)		#(输出) [-8, -6, 1, 2, 2, 3, 4, 5, 7]

# sort(reverse=True) 从大到小排序
vars.sort(reverse=True)
print(vars)		#(输出) [7, 5, 4, 3, 2, 2, 1, -6, -8]

# sort(key=func) 可以传递一个函数, 按照函数的处理结果进行排序
vars.sort(key=abs)
print(vars)		#(输出) [1, 2, 2, 3, 4, 5, -6, 7, -8]

浅拷贝与深拷贝

浅拷贝 copy

• 使用 copy 进行浅拷贝，可以把原有列表复制一份，对两个列表分别进行操作时互不影响

varlist = [1,'two',3,'four',5,'six',7]
newlist = varlist.copy()
print(newlist)		#(输出) [1, 'two', 3, 'four', 5, 'six', 7]
# 对 newlist 进行列表修改操作不影响 varlist

• 你以为拷贝了全部层，实际上只拷贝了第一层的浅拷贝

# 浅拷贝不能对多维列表里的子列表进行拷贝

# 如当前由copy得到的 newlist 列表中的子列表仍与 varlist 列表中的子列表引用同一份地址
varlist = [1,2,['one','two']]
newlist = varlist.copy()

# 删除新列表中子列表的第一个元素'one'
del newlist[2][0]
print(newlist)		#(输出) [1, 2, ['two']]
# 原列表也发生了改变
print(varlist)		#(输出) [1, 2, ['two']]

深拷贝 deepcopy

• 使用 copy.deepcopy 进行的深拷贝，不光拷贝了当前的列表, 同时把列表中的子列表也拷贝了一份
• 需要导入包 copy

import copy
varlist = [1,2,['one','two']]
newlist = copy.deepcopy(varlist)

# 删除新列表中子列表的第一个元素'one'
del newlist[2][0]

print(newlist)		#(输出) [1, 2, ['two']]
# 原列表 varlist 不受影响
print(varlist)		#(输出) [1, 2, ['one', 'two']]

列表推导式 list-compersions

• 一种快速生成新列表的方法, 可以由一个列表推导出另外一个新的列表

'''
语法:
    [变量 for 变量 in iterable]             直接输出原材料
    [变量(加工) for 变量 in iterable]        输出自己加工后的产品
    [变量 for 变量 in iterable if 条件]      输出符合标准的原材料
    [[变量 for 变量 in iterable] for 变量 in iterable]    输出经过另一个厂加工后的产品
tip: 新生成列表的元素的数据类型与 for 前面的数据类型相同
'''

参考实例：

# [变量 for 变量 in iterable]   输出0-9
varlist = [i for i in range(10)]
print(varlist)		#(输出) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# [变量(加工) for 变量 in iterable]   输出0-9的平方
varlist = [i**2 for i in range(10)]
print(varlist)		#(输出) [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# [变量(加工) for 变量 in iterable if 条件]     输出0-9内的偶数的平方
varlist = [i**2 for i in range(10) if i % 2 == 0]
print(varlist)		#(输出) [0, 4, 16, 36, 64]

# [[变量 for 变量 in iterable] for 变量 in iterable]  将行列互换
arr = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
    ['a', 'b', 'c']
]
varlist = [[row[i] for row in arr] for i in range(3)]
#(输出) [[1, 4, 7, 'a'], [2, 5, 8, 'b'], [3, 6, 9, 'c']]