列表
列表基本语法
（1） python列表是python 内置的数据结构对象之一， 相当于数组
（2） 列表是用"[]"包含，内有任意的数据对象，每一个数据对象以逗号（","）分割，每个数据对像称之为元素
（3） python 列表是一个有序的序列
（4） python 列表支持任意的嵌套，嵌套的层次深度没有限制
（5） python中序列长度个数是从0开始计算的
列表的定义
mylist = list()
print(mylist)
mylist2 = []
print(mylist2)
mylist3 = list('python')
print(mylist3)输出结果：
[]
[]
['p', 'y', 't', 'h', 'o', 'n']
列表的索引
# 0 1 2
lst = [10,20,30]
# -3 -2 -1
lst = ['a','b','c','d','e','f']
print(lst[0]) # 获取第一个元素
print(lst[1]) # 获取第二个元素
print(lst[2]) # 获取第三个元素
lst[3] = "x" # 注意. 列表是可以发⽣改变的. 这⾥和字符串不⼀样
print(lst)输出结果：
a
b
c
['a', 'b', 'c', 'x', 'e', 'f']
len
获取容器类型数据中元素个数
listvar = ['a', 'b', 'c', 'x', 'e', 'f']
length = len(listvar)
res = listvar[length-1]
print(res)
# 简写
res = listvar[len(listvar)-1]
print(res)输出结果：
f
f
列表的切片 (同元组)
语法 => 列表[::] 完整格式：[开始索引:结束索引:间隔值]
(1)[开始索引:] 从开始索引截取到列表的最后
(2)[:结束索引] 从开头截取到结束索引之前(结束索引-1)
(3)[开始索引:结束索引] 从开始索引截取到结束索引之前(结束索引-1)
(4)[开始索引:结束索引:间隔值] 从开始索引截取到结束索引之前按照指定的间隔截取列表元素值
(5)[:]或[::] 截取所有列表
lst = ['a','b','c','d','e','f','g']
# (1)[开始索引:] 从开始索引截取到列表的最后
res =lst[2:]
print(res)
# ['c', 'd', 'e', 'f', 'g']
# (2)[:结束索引] 从开头截取到结束索引之前(结束索引-1)
res =lst[:3]
print(res)
# ['a', 'b', 'c']
# (3)[开始索引:结束索引] 从开始索引截取到结束索引之前(结束索引-1)
res = lst[3:5]
print(res)
# ['d', 'e']
# (4)[开始索引:结束索引:间隔值] 从开始索引截取到结束索引之前按照指定的间隔截取列表元素值
# 正向截取
res = lst[::5] # 0 5 10
print(res)
# ['a', 'f']
# 逆向截取
res = lst[::-3] # -1 -4 -7
print(res)
# ['g', 'd', 'a']
# (5)[:]或[::] 截取所有列表
res = lst[:]
res = lst[::]
print(res)
# ['a', 'b', 'c', 'd', 'e', 'f', 'g']
# (6)列表的获取 (同元组)
# 0 1 2
lst = [10,20,30]
# -3 -2 -1
print(lst[-1])
# 30
列表方法： 增
append
往列表中添加元素， 该元素可以是任何形式的数据结构或者对象， 添加的对象作为列表中的一个元素，放到最后一位。
a = ['a']
print(a)
a.append('b')
print(a)
['a', 'b']
a.append(['c'])
print(a)
a.append({1: 2})
print(a)输出结果：
['a']
['a', 'b']
['a', 'b', ['c']]
['a', 'b', ['c'], {1: 2}]
extend
用于在列表末尾一次性追加另一个序列中的多个值，不是把对象完整的添加，而是把其中每一项拿出来。
注：有的说extend只能是列表， 这种说法不对，可以是序列式的数据结构。
a = ['a']
b,c = [],[]
b.append(a)
c.extend(a)
print(a)
print(b)
print(c)输出结果：
['a']
[['a']]
['a']
extend 和 append 的区别：
append:把整体添加进来
extend:把每一项添加进来
insert
两个参数， 第一个是insert的位置， 第二个是insert的元素。
a = ['s',3,4]
a.insert(2,'x')
print(a)
a.insert(2,'y')
print(a)输出结果：
['s', 3, 'x', 4]
['s', 3, 'y', 'x', 4]
列表的删除 ( 可切片 )
1.一次删一个
lst = ["a","b","c","d","e","f","g"]
del lst[2]
print(lst)结果输出：
['a', 'b', 'd', 'e', 'f', 'g']
2.一次删一堆
lst = ["a","b","c","d","e","f","g"]
del lst[1:-1]
print(lst)结果输出：
['a', 'g']
3.注意点
lst = ["a","b","c","d","e","f","g"]
res = lst[1:-1]
del res # 删除的是res这个变量 和 列表无关
print(lst)结果输出：
['a', 'b', 'c', 'd', 'e', 'f', 'g']
pop
通过指定索引删除元素,若没有索引则移除最后那个 (推荐)
默认移除最后一个，如果指定第几个，便移除第几个。
传参数，传的是index。
lst = ['d','s','j']
# 不指定下标,默认删除最后一个
res = lst.pop()
print(res)
print(lst)
# 指定下标,删除具体某个元素
res = lst.pop(1)
print(res)
print(lst)结果输出：
['d', 's', 'j']
['d', 'j']
['d']
remove
通过给予的值来删除,如果多个相同元素,默认删除第一个
lst = ["张三","李四","赵云","王麻子","赵云"]
res = lst.remove("赵云")
print(res)
print(lst)
切片删除
a = ['d','s','j']
del a[1:3]
print(a)结果输出：
['d']
clear 清空列表
a = ['d','s','j']
a.clear()
print(a)结果输出：
[]
列表的修改 ( 可切片 )
改单个值
lst = ["a","b","c","d","e","f","g"]
lst[1] = "hello"
print(lst)结果输出：
['a', 'hello', 'c', 'd', 'e', 'f', 'g']
改多个值
如果使用切片进行修改,要求数据必须是Iterable可迭代性数据
lst = ["孙悟空","猪八戒","白骨精"]
lst[1:4] = "你好"
print(lst)结果输出：
['孙悟空', '你', '好']
改多个值(带有步长)
带有步长的切片修改,切出几个元素就修改几个元素,数量要一致.
lst = ["a","b","c","d","e","f","g"]
lst[::3] = "xyz" # 0 3 6
#lst[::3] = "ab" #error
print(lst)结果输出：
['x', 'b', 'c', 'y', 'e', 'f', 'z']
列表方法： 查
count： 计算列表中元素的数量
Index： 查看列表某个元素的位置下标
a = ['d','s','j']
print(a.index('s'))
a = ['d','s','d','x','y']
print(a)
print(a.count('d'))
print(a.count('x'))输出结果：
1
['d', 's', 'd', 'x', 'y']
2
1
列表方法： 排序
sort：列表本身排序
默认从小到大排序。
a = [1,4,6,2,5]
print(a)
a.sort()
print(a)
a.sort(reverse=True)
print(a)
a = ['a','d','c']
print(a)
a.sort()
print(a)
a.sort(reverse=True)
print(a)输出结果：
[1, 4, 6, 2, 5]
[1, 2, 4, 5, 6]
[6, 5, 4, 2, 1]
['a', 'd', 'c']
['a', 'c', 'd']
['d', 'c', 'a']
sort和sorted的区别：
1： sort是列表的方法， sorted是对一个序列数据对象的方法
2： sort改变了列表， sorted不改变数据结构本身
a = [1,4,6,2,5]
print(a)
print(sorted(a))
print(a)结果输出：
[1, 4, 6, 2, 5]
[1, 2, 4, 5, 6]
[1, 4, 6, 2, 5]
列表的拼接 (同元组)
lst1 = ["张三","李四"]
lst2 = ["王五","赵六"]
res = lst1 + lst2
print(res)结果输出：
['张三', '李四', '王五', '赵六']
列表的重复 (同元组)
lst1 = ["张三","李四"]
res = lst1 * 3
print(res)结果输出：
['张三', '李四', '张三', '李四', '张三', '李四']
列表方法： 反转
reverse: 列表反转
a = ['d','s','j']
print(a)
a.reverse()
print(a)
a = [1,4,5,3]
print(a)
a.reverse()
print(a)结果输出：
['d', 's', 'j']
['j', 's', 'd']
[1, 4, 5, 3]
[3, 5, 4, 1]
列表循环
a = ['d','s','j']
for item in a:
print (item)结果输出：
d
s
j
列表的嵌套
lst = ["a", "b","c",["d","e",[1, "f", "g", "h"],"i"]]
print(lst[3][2][1])
lst[3][2][2] = lst[3][2][2].upper()
print(lst)
lst[3][2][0] = lst[3][2][0] + 99
print(lst)输出结果：
f
['a', 'b', 'c', ['d', 'e', [1, 'f', 'G', 'h'], 'i']]
['a', 'b', 'c', ['d', 'e', [100, 'f', 'G', 'h'], 'i']]
列表的深浅拷贝
a = 100
b = a
a = 200
print(b)输出结果：
100
lst1 = [1,2,3]
lst2 = lst1
lst1.append(4)
print(lst2)输出结果：
[1, 2, 3, 4]
1.浅拷贝
方法一 (推荐)
import copy
lst1 = [1,2,3]
lst2 = copy.copy(lst1)
lst1.append(10)
print(lst2)
print(lst1)输出结果：
[1, 2, 3]
[1, 2, 3, 10]
方法二：
import copy
lst1 = [1,2,3]
lst2 = lst1.copy()
lst1.append(11)
print(lst1)
print(lst2)输出结果：
[1, 2, 3, 11]
[1, 2, 3]
2.深拷贝
把所有层级的容器元素都单独拷贝一份,放到独立的空间中
import copy
lst1 = [1,2,3,[4,5,6]]
lst2 = copy.copy(lst1)
lst1[-1].append(77)
lst1.append(8888)
print(lst2)
print(lst1)输出结果：
[1, 2, 3, [4, 5, 6, 77]]
[1, 2, 3, [4, 5, 6, 77], 8888]
import copy
lst1 = [1,2,3,[4,5,6]]
lst2 = copy.deepcopy(lst1)
lst1[-1].append(999)
print(lst2)
print(lst1)输出结果：
[1, 2, 3, [4, 5, 6]]
[1, 2, 3, [4, 5, 6, 999]]
其他容器的深拷贝
import copy
lst1 = (1,2,3,{"a":1,"b":[10,20]})
lst2 = copy.deepcopy(lst1)
lst1[-1]["b"].append(30)
print(lst1)
print(lst2)输出结果：
(1, 2, 3, {'a': 1, 'b': [10, 20, 30]})
(1, 2, 3, {'a': 1, 'b': [10, 20]})
深浅拷贝总结:
浅拷贝：
只拷贝一级容器中的所有元素独立出一个单独的空间。
深拷贝:
把所有层级的容器中所有元素都单独拷贝一份，形成独立的空间。
浙公网安备 33010602011771号