本章主要详细总结了列表的相关知识点，只要包括列表的定义、列表的运算、列表的索引和切片、列表的方法、列表和字符串的转换函数和列表推导式、以及列表的深拷贝和浅拷贝等。
一、列表的概念
1、列表的定义
列表是一种容器 列表是序列的一种（ 序列：字符串 str（）、列表 list【】、元组 tuple{}）
列表是可以被改变的序列
列表中由一系列特定元素组成的，元素与元素之间可以没有任何的关联关系，但他们之间有先后顺序关系
2、创建空列表的字面值
L = [] # L变量绑定空列表
L = list()
3、创建非空列表的字面值
L = [1, 2, 3, 4]
L = ['Beijing', 'Shanghai', 'Shenzhen']
L = [1, 'Two', 3.14, '四']
L = [1, 2, [3.1, 3.2, 3.3], 4]
4、列表的构造(创建)函数 list
list() 生成一个空的列表，等同于 []
list(iterable) 用可迭代对象初始化（创建）一个列表
5、示例
L = list() # L绑定空列表
L = list("hello") # L绑定['h', 'e', 'l', 'l', 'o']
L = list(range(1, 10, 2))二、列表的运算
1、算术运算
+ += * *=
1）+ 用于拼接列表
x = [1, 2, 3]
y = [4, 5, 6]
z = x + y # z = [1,2,3,4,5,6] ，新的列表，有先后顺序 2）+= 用原列表与左侧列表拼接，用变量绑定拼接后的列表
x = [1, 2, 3 ]
y = [4, 5, 6 ]
x += y # 等同于 x = x+y 3）* 生成重复的列表
x = [1, 2] * 3 # x = [1,2,1,2,1,2]
4）*= 用原列表生成重复的列表
x = [1, 2, 3]
x *= 4 # x =[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
# x *= y 等同于 x = x * y2、列表的比较运算
1）运算符
< <= > >= == !=
2）比较的规则同字符串的规则相同
x = [1, 2, 3]
y = [1, 2, 4]
x != y # True
x <= y # True
y > x # True
["AB", 'abc', '123'] < ['AB', '123', 'abc'] # False
[1, 'two'] > ['two', 1] # TypeError
3、列表的 in / not in 运算符
1）作用
判断一个值是否存在于列表中。如果存在返回True, 否则返回False
not in 的返回值与 in 运算符相反
2）示例
2 in [1, 2, 3, 4] # True
'2' in [1, 2, 3, 4] # False三、列表的索引操作
1、语法
列表[整数表达式]
2、用法
正向索引：0 ~ len(x)-1
反向索引：-len(x) ~ -1
3、示例
L = list("ABCD")
print(L[1]) # B4、列表的索引赋值
列表是可变的，可以通过索引赋值改变列表中的元素
示例
L = [1, 2, 3, 4]
L[2] = 3.1
print(L)四、列表的切片
1、语法
列表[:]
列表[::]
2、说明
列表的切片取值返回一个列表，规则等同于字符串切片规则
示例
x = list(range(10))
y = x[1:9:2] # 奇数
y = x[::] # 复制x列表 3、列表的切片赋值
1）语法
列表[切片slice] = 可迭代对象
2）作用
可以改变原列表的排列，可以插入数据和修改数据
可以用切片改变列表对应的元素的值
3）说明
切片的赋值运算符(=)的右侧必须是一个"可迭代对象"
4）示例
L = [2, 3, 4]
L[1:2] = [3.1, 3.2] # L = [2, 3.1, 3.2, 4] 在第二位置放两个数，以前的被替换
L[:1] = [1.1, 2.2] # L=[1.1, 2.2, 3.1, 3.2, 4] 在第一个位置放两个数，以前的被替换
L = [2, 3, 4]
L[2:] = [] # L = [2, 3] 清空3位置之后的数
L = [2, 3, 4]
L[:0] = [0, 1] # L = [0, 1, 2, 3, 4] 在第一个位置之前添加 两个数
L = [2, 3, 4]
L[3:] = [5, 6, 7] # L = [2, 3, 4, 5, 6, 7] 从第四个位置追加数值
L = [2, 3, 4]
L[1:2] = "ABC" # L = [2, 'A', 'B', 'C', 4]
L = [1, 2]
L[2:] = range(3, 10) # L = [1,2,3,4....9]5）切片注意事项
对于步长不等1的切片赋值，赋值运算符的右侧的可迭代对象提供的数据元素的个数一定要等于切片切出的段数
例如：
L = [1, 2, 3, 4, 5, 6]
L[::2] = 'ABC' # 正确
L[::2] = 'ABCDE' # 错误
五、列表的删除
del 语句时可以用来删除列表元素
1、语法
del 列表[索引]
del 列表[切片]
2、示例
L = [1, 2, 3, 4, 5, 6]
del L[1]
del L[2]
del L[-1]
L = [1, 2, 3, 4, 5, 6]
del L[::2]六、python3中常用的序列函数
len(x) 返回序列的长度
max(x) 返回序列的最大值元素
min(x) 返回序列中最小值元素
sum(x) 返回序列中所有元素的和(元素必须是数字)
any(x) 真值测试, 如果列表中的其中一个元素 为真值，则返回True
all(x) 真值测试, 如果列表中的所有元素都为真值， 则返回True,否则返回False
示例:
L = [1, 7, 0, 3, 2]
print(len(L)) # 5
print(max(L)) # 7
print(min(L)) # 0
print(sum(L)) # 13
print(any(L)) # True
print(all(L)) # False七、python3中常用的列表方法(method)
详见：>>> help(list)
| 方法 | 意义 |
|---|---|
| L.index(v [, begin[, end]]) | 返回对应元素的索引下标, begin为开始索引，end为结束索引,当 value 不存在时触发ValueError错误 |
| L.insert(index, obj) | 将某个元素插放到列表中指定的位置 |
| L.count(x) | 返回列表中元素的个数 |
| L.remove(x) | 从列表中删除第一次出现在列表中的值 |
| L.copy() | 复制此列表（只复制一层，不会复制深层对象) |
| L.append(x) | 向列表中追加单个元素 |
| L.extend(lst) | 向列表追加另一个列表 |
| L.clear() | 清空列表,等同于 L[:] = [] |
| L.sort(reverse=False) | 将列表中的元素进行排序，默认顺序按值的小到大的顺序排列 |
| L.reverse() | 列表的反转，用来改变原列表的先后顺序 |
| L.pop([index]) | 删除索引对应的元素，如果不加索引，默认删除最后元素，同时返回删除元素的引用关系 |
八、列表的排序函数
1、sorted 函数
用于生成一个排序后的列表
格式：
sorted(iterable, reverse=False)
2、reversed(seq)
返回原序列反序的可迭代对象
示例:
L = [7, 9, 5, 1, 3]
L2 = sorted(L) # L2 = [1, 3, 5, 7, 9]
L3 = sorted(L, reverse=True) # L3 = [9, 7, 5, 3, 1]
for x in reversed(L):
print(x) # 3 1 5 9 7九、列表与字符串
1、列表和字符串的比较
1）.都是序列，有先后顺序
2）.列表是可变的，字符串是不可变的
3）.列表可以存储任意类型的数，字符串只能存储字符
2、字符串的文本解析方法 split 和 join方法
1）S.split(sep=None)
将字符串使用sep作为分隔符分割S字符串，返回分割后的字符串列表，当不给定参数时默认用空白字符作为分隔符分割
2）S.join(iterable)
用可迭代对象中提供的字符串,返回一个中间用S进行分隔的字符串
3）示例
s = 'Beijing is capital'
L = s.split(' ') # L = ['Beijing', 'is', 'capital']
L = ["C:", "Windows", "System32"]
s = '\\'.join(L) #s=r"C:\Windows\System32"十、深拷贝 deep copy 和浅拷贝 shallow copy
1、浅拷贝 shallow copy
L = [3.1, 3.2]
L1 = [1, 2, L]
L2 = L1.copy() # 浅拷贝，只复制一层
print(L1) # [1, 2, [3.1, 3.2]]
print(L2) # [1, 2, [3.1, 3.2]]
L[0] = 3.14
print(L1) # [1, 2, [3.14, 3.2]]
print(L2) # [1, 2, [3.14, 3.2]]2、 说明
浅拷贝是指在复制过程中，只复制一层变量，不会复制深层变量绑定的对象的复制过程
3、深拷贝 deep copy
对所有可变对象进行层层复制,实现对象的各自独立
示例
import copy # 导入复制模块
L = [3.1, 3.2]
L1 = [1, 2, L]
L2 = copy.deepcopy(L1) # 实现深拷贝
print(L1) # [1, 2, [3.1, 3.2]]
print(L2) # [1, 2, [3.1, 3.2]]
L[0] = 3.14
print(L1) # [1, 2, [3.14, 3.2]]
print(L2) # [1, 2, [3.1, 3.2]] #此列表不受影响十一、列表推导式 list comprehesion
列表推导式是用可迭代对象依次生成带有多个元素的列表的表达式
1、作用
用简易方法生成列表
2、语法
[表达式 for 变量 in 可迭代对象]
或
[表达式 for 变量 in 可迭代对象 if 真值表达式]
3、示例
# 生成一个列表，此列表内的数值是1~9的方平
L = [x ** 2 for x in range(1, 10)]
# 以前的方法：
L = []
for x in range(1, 10):
L.append(x ** 2)4、列表推导式的嵌套
1）语法
[表达式
for 变量1 in 可迭代对象1 if 真值表达式1
for 变量2 in 可迭代对象2 if 真值表达式2
...]
2）示例
用字符串"ABC" 和 "123" 生成如下列表: ['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
L = [x + y for x in "ABC" for y in "123"]十二、习题集
1、第一题
已知用户输入的字符串是以逗号分隔开的数据，如：s = '100,200,300,500,800'，试用程序算法将其转化为数字的列表：L = [100, 200, 300, 500, 800]
s = '100,200,300,500,800'
L = []
TMP = s.split(",")
for x in TMP:
L.append(int(x))
print(L)2、第二题
有一些数存在于列表中,如： L = [1, 3, 2, 1, 6, 4, 2, .... 98, 82]，将列表中的数字存入到另一个列表L2中,
要求:重复出现多次的数字只在列表L2中保留一份
L = [1, 3, 2, 1, 6, 4, 2, 98, 6, 82]
L2 = []
for x in L:
if x not in L2:
L2.append(x)
print(L)
print(L2)3、第三题
输入任意整数，先判断输入的数是否为质数（只能被1和自身正常的数），如果是质数，则加入到列表中。再次输入任意整数，在判断……直至输入的数小于等于1为止。
最后打印您输入的质数。
（所用知识点：输入输出，死循环，求余，for，range，列表。。。）
L = []
while True:
number = int(input("请输入一个整数："))
if number <= 1:
break
for x in range(2,number):
if number % x == 0:
break
else:
L.append(number)
print(L)4、第四题
生成前40个斐波那契数列：1 1 2 3 5 8 ......
要求将这些数保持在列表中。最后打印这些数
fb = [1,1]
for x in range(2,41):
fb.append(fb[x-1] + fb[x-2])
print(fb)5、第五题（求完全数）
完全数是指除自身以外的所有的因数相加之和等于自身的数
例： 1 + 2 + 3 = 6 # 1,2,3都是6的因数（能被一个数x整除的数为y，则y为x的因数）
求 4~5个完全数并打印出来。
number = 1
print("完全数探索．．．．")
sum(perfect_number)
while number:
number += 1
factor = [] # 临时因数
for x in range(1,number):
if number % x == 0:
if x not in factor:
factor.append(x)
if sum(factor) == number:
print(number)