列表_列表[::]-CSDN博客

本文链接：https://blog.csdn.net/zhangxuelong461/article/details/104050261

【列表 list】

列表list
1. 列表是由一系列特定元素组成的，元素和元素之间没有任何关联关系，但他们之间有先后顺序关系
2. 列表是一种容器
3. 列表是序列的一种>>> x = [1,2,3]
4. 列表是可以被改变的序列
python中的序列类型简介（sequence）
字符串str
列表list
元组tuple
字节串bytes
字节数组bytearray
创建列表：
1. 创建一个空列表的字面值
  L = []
2. 创建非空列表
  L = [1,2,3,4]
  L = [‘北京’，‘上海’,‘重庆’]
  L = [1,2,[3.1,3.2]]
列表的构造（创建）函数list
list() 生成一个空列表等同于[]
list(iterable) 用可迭代对象创建一个列表
示例：
```
L = list()  L 为空列表
L = list('ABCD')   L----->['A','B','C','D']
L = list(range(1,10,2))
```

列表的运算：

算术运算：+ += * *=
+ (拼接列表)

x = [1,2,3]
y = [4,5,6]
x + y = [1,2,3,4,5,6]

+= (用于原列表与左侧可迭代对象进行拼接，生成新的列表)(右侧必须是可迭代对象)

x = [1,2,3]
x += [4,5,6]  # x = [1,2,3,4,5,6]
x += ['ABC']  # x = [1,2,3,'ABC']
x += 'ABC'    # X = [1,2,3,'A','B','C']

* (生成重复的列表)

x = [1,2,3]  x * 2  # x = [1,2,3,1,2,3]

*=(用于生成重复的列表，同时用变量绑定新列表)

x = [1,2]  
x *= 3         # x = [1,2,1,2,1,2]

比较运算：< <= > >= == !=

x = [1,2,3]
y = [2,3,4]3908168

x != y      # True
x > [1,2]   # True
x < y  	    # True
[1,3,2] > [1,2,3] # True
["AB","CD"] > ["AC","BD"] # False
[1,'two'] > ['two',1]   # TypeError(比较的类型要一样，否则会报错)

in/not in
用于判断一个数据元素是否存在于容器内（列表），如果存在，返回True,如果不存在则返回False

列表的索引(index)/切片(slice)：
1. 列表的索引语句：
  
  列表[整数表达式]
  用法：
  列表的索引取值与字符串的索引取值规则完全相同
  列表的索引为正向索引和反向索引
2. 列表的索引赋值：
  列表是可变的序列，可以通过索引赋值改变列表的元素
  语法：
  列表[索引] = 表达式
  示例：
  x = [1,2,3,4]
  x[2] = 3.14 # x = [1,2,3.14,4]
3. 列表的切片：
  列表[:]
  列表[::]140213287639896
  列表的切片返回一个列表，规则等同于字符串的切片
  示例：
  l = list(range(9))
  l[1:9:2] # [1,3,5,7]
4. 列表的切片赋值语法：
  语法：
  列表[切片] = 可迭代对象
  说明：
  切片赋值的赋值运算符的右侧必须是一个可迭代对象
  示例：
```
L = [2,3,4]
L[O:1] = [1.1,2.2]               #把索引0位置切掉了
print(L)   # [1.1,2.2,3,4]
L[0:0] = [0,1]   # [0,1,2,3,4]   # 在索引0位置添加元素
l = [2,3,4]
l[:]   # [2,3,4]
l[:] = [7,8]  # [7,8]
s = list(range(1,9))
s[1::2] = [2.2,4.4,6.6,8.8] 
print(s)  # [ 1,2.2,3,4.4,5,6.6,7,8.8]
```
5. 注意事项：
  对于步长不等于1的切片赋值，赋值运算符的右侧的可迭代对象提供元素的个数一定要等于切片切出的段数
  例如：
  L = [1,2,3,4,5,6]
  L[::2] = ‘ABCD’ # 错的（步长为2是1,3,5只有三段，而你添加的却有四段）
  L[::2] = ‘ABC’ # 对的

del 语句用于删除列表元素
语法：
del 列表[索引]
del 列表[切片]
示例：

L = [1,2,3,4,5]
*del L[0]  # L = [2,3,4,5]
*del L[-1] # L = [1,2,3,4]
*del L [::2] # L = [2,4] 把135删掉了
*del L     # name 'L' is not defined删除了整个列表

python3中常用的序列函数：
len(x) 返回序列的长度
max(x) 返回序列的最大值元素
min(x) 返回序列的最小值元素
sum(x) 返回序列中所有元素的和（元素必须是数值类型）
any(x) 真值测试，如果列表中其中一个值为真值则返回True，否则返回False
all(x) 真值测试，如果列表中所有值为真值，则返回True，只要有一个为假，则返回False
python3中常用的列表方法（method）
list.index(value[,begin[,end]]),返回对应元素的下标
begin为开始索引,end为结束索引，当value不存在时触发valueError
list.insert(index,obj)将某个元素查放到列表中的指定位置
list.count(x)　返回列表中元素的个数
list.remove(x) 从列表中删除第一次出现的值
list.copy() 复制此列表（只复制一层，不会复制深层对象）
list.append(x) 在列表中追加单个元素
list.extend(list) 在列表中追加一个列表
list.clear() 清空列表，返回一个空列表[],del L则是删除列表name ‘L’ is not defined 【但是等同于del list[::]】
list.sort(reverse = False)
将列表的顺序按值的大小从小到大的顺序进行排列
list.reverse() 列表的反转
list.pop([index]) 删除对应的列表元素，如果不加索引，默认删除最后一个元素同时返回移除的位置
字符串文本解析方法split 和 join
S.split(sep = None) 将字符串，使用sep作为分隔符分割S字符串，【返回分割后的字符串的列表】，当不给定参数时，用空白字符作为分隔符进行分割
S.join(iterable) 用可迭代对象中的字符串，【返回】一个中间用S进行分隔的【字符串】
例如:
```
s = 'Beijing is captital'
l = s.split(' ') # l = ['Beijing','is','captital']
s = '小张,20,100'
l = s.split(',') # l = ['小张',20,100]


l = ['aaa','bbb','ccc']
'-'.join(l)  # 'aaa-bbb-ccc'
```

深拷贝deep copy和浅拷贝shallow copy

浅拷贝：
是指在复制过程中只复制一层变量，不会复制深层变量绑定的对象的复制过程
(共用同一个对象，一变多变)

l = [3.1,3.2]
l1 = [1,2,l]
l2 = l1.copy()   #等同于l1[:]  浅拷贝
print(l1)   # [1,2,[3.1,3.2]]
print(l2)   # [1,2,[3.1,3.2]]
l2[2][0] = 3.14
print(l1)   # [1,2,[3.14,3.2]]  #对l2改变，l1也会改变
print(l2)   # [1,2,[3.14,3.2]]   
>>> l = [1,2,3]
>>> l2 = l
>>> l[1]=2.2
>>> l
[1, 2.2, 3]
>>> l2
[1, 2.2, 3]

深拷贝：
import copy # 导入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]]
l2[2][0] = 3.14
print(l1) # [1,2,[3.1,3.2]] #对l2改变，原有的l1不会变
print(l2) # [1,2,[3.14,3.2]]
注：
深拷贝通常只对可变对象进行复制，不可变对象通常不变
```
>>> s1 = 'hello'
>>> s2 = s1
>>> s2 += 'world'
>>> s2
'helloworld'
>>> s1      #s2改变s1并没变
'hello'
因为s1是字符串，字符串是不可变的，所以s1不会改变
```

列表推倒式list comprehension(是表达式)
列表推倒式是用可迭代对象依次生成带有多个元素的列表的表达式
作用：
用简易方法生成列表
语法：
[表达式 for 变量 in 可迭代对象]
或
[表达式 for 变量 in 可迭代对象 if 真值表达式]
示例：
```
l = [x*x for x in range(1,10)]
#生成1~9的平方的列表
l = [x + y for x in range(3,5) for y in range(4,6)]
# 这样也是可以的[7,8,8,9]  (推倒式的嵌套)
l = [x for x in range(1,100) if x % 2 != 0]
# 打印出奇数
```

列表推倒式的嵌套：
语法：
[表达式1 for 变量1 in 可迭代对象1 if 真值表达式1 for 变量2 in 可迭代对象2 if 真值表达式2]
示例：

l1 = [2,3,5]
l2 = [7,11,13]
#将l1中的全部元素与l2中的全部元素依次相乘后放到列表l3中
l3 = [x * y for x in l1 for y in l2]		
print(l3)      #  [14, 22, 26, 21, 33, 39, 35, 55, 65]