python list浅拷贝_Python 列表(list)与浅拷贝深拷贝介绍

列表 list

问题：

容器

如何将计算运算的数据临时存在一个地方，同时又方便 添加，删除，修改等操作？

什么是列表：

列表是一种容器

列表是可以被改变序列

列表是由一系列特定元素组成的，元素与元素之间可能没有任何关联关系，但他们之间有先后顺序关系联关系，但他们之间有先后顺序关系

python3中序列类型简介：

字符串 str　　列表 list　　元组 tuple　　字节串 bytes　　字节数组 bytearray

创始空列表的字面值

L = [] # L绑定空列表

注： 表达式[] 会创建一个空的列表

创建非空列表的字面值

L = [1,2,3,4]

L = ["北京","上海","深圳"]

L = [1,"Two",3.14,"四"]

L = [1,2,[3.1,3.2],4]

列表的构造(创建)函数 list

list()　　　　　　　　　　 #创建一个空的列表，等同于[]

list(iterable(可迭代))　　#用可迭代对象创建一个列表

#示例：

L = list() #L 绑定空列表等同于 L = []

L = list("hello") #L = ["h","e","l","l","o"]

L = list(range(1,10,2)) #L = [1,3,5,7,9]

列表的运算

#算术运算：

+ += * *=

#+ 用于拼接列表

x = [1,2,3]

y= [4,5,6]

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

#+= 将原列表与右侧的可迭代对象的数据追加，得到新的列表#语法：#x += 可迭代对象#如：

x = [1,2,3]

x+= [4,5,6]

x+= "ABC"x+= range(1,10,3)#注：#+= 运算符是用原可迭代对象的数据进行追加，原列表的ID不变

# 如：

s = "ABC"

print(id(s)) 　　#???

s += "123"

print(id(s)) 　　# 和上面的不相同

L = [1，2，3]

print(id(L))　　#???

L = "123"

print(id(L)) 　　# ???

#* 生成重复的列表

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

#*= 生成重复的列表，用原变量绑定更新后的列表

x = [1,2,3]

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

列表的比较运算：

#运算符：

　　>=　　==　　!=

说明：

列表的比较规则与字符串的比较规则相同

列表要求每两个元素能依次进行比较，否则会出现类型错误

#示例：

[1,2,3] == [1,2,3] #True

[1,2,3] != [1,3,2] #True

[1,2,3] < [1,3,2] #True

[1,2,3] >= [1,2] #True

[1,"Two"] > ["Two",1] #TypeError (语法错误)

[1,"two",3.14] < [1,"二",2.8] #True

列表是可迭代对象

L = [1,3,5,7]for x inL:print(x) #打印 1 3 5 7

列表的 in / not in 运算符

判断一个值是否存在于列表中，如果存在返回True，否则返回False

(同字符串的in和not in 用法相同)

not in 返回值与in 相反

#示例：

x = [1,"Two",3,"四"]3 in x #True

"3" in x #False

10 in x #False

10 not in x #True

练习：

写一个程序，让用户输入很多个正整数，当输入负数时结束输入，将用户输入的数存于列表L中，打印这个列表

如：

请输入：1　　请输入：2　　请输入：3　　请输入：4　　请输入：-1

打印如下：

[1,2,3,4]

#L = []

x = int(input("请输入："))

L+= [x] 　　#把x 放在列表中，追加到L的末尾

L =[] #创建一个列表，准备存放数字

whileTrue:#每次输入一个数，如果次数小于0，则退出循环，否则把

#这个数放在列表中

x= int(input("请输入："))if x <0:breakL+=[x]print("列表的内容是：",L)

列表的索引操作

语法：

列表[整数表达式]

用法：

等用于字符串的索引

索引分为正向索引和反向索引，规则写字符串索引规则完全相同

#示例：

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

print(L[-1]) #4

# 注

# 列表是可变的序列， 列表支持索引赋值，列表可以通过索引赋值改变

列表中的元素

#语法：#列表[整数在表达式] = 表达式#示例：

L = [1，2，3,4]

L[2] = 3.14 #改变了第三个元素的值

列表的切片操作

#取值：#列表[起始值：终止值]#列表[起始值：终止值：步长]#列表的切片取值返回一个列表，规则等同于字符串切片规则#示例；

L = list(range(10))

L2= L[::2] 　　#L2 = (0,2,4,6,8)

列表的切片赋值

#作用：#可以改变源列表的排列，可以插入，修改和删除数据#语法：#列表[切片] = 可迭代对象#说明：#切片赋值的赋值运算符(=)的右侧必须是一个可迭代对象#示例：

L = [2,3,4]

L[0:1] = [1.1,2.2] #L = [1.1,2.2,3,4]

L[2:] = [3.3,4.4,5.5] #L = [1.1, 2.2, 3.3, 4.4, 5.5]

L[1:4] = [] #切出 2.2，3.3，4.4 ，没加入新数据

L[1:] = range(5,9) #L=[ 1.1, 5, 6, 7, 8]

L = [2,5]

L[1:1] = [3，4] #L=[2，3，4，5]

L[0:0] = range(2) #L = [0,1,2,3,4,5]

L[6:] =[6,7] #L = [0,1,2,3,4,5,6,7]

切片注意事项：

对于步长不等于1的切片赋值，赋值运算符的右侧的可迭代对象提供的元素的个数，一定要等于切片的段数

L = [1,2,3,4,5,6]

L[::2] = "ABC" #对的

L[::2] = "ABCDE" #错的

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

L = [1,2,3,4,5,6,7]del L[-1] #L = [1,2,3,4,5,6]

del L[::2] #L = [2，4，6]

# 练习；

# 已知有列表：

# L= [3，5]

#(1)用索引和切片操作，将原列表改变为：

# L= [1,2,3,4,5,6]l = [3,5]l[1:1] = [4]l[3:] = [6]l[len(l):] = [7] # 在长度最后一个插入l[0:0] =[1,2]print(l)

print(id(l))

#(2)将列表反转，删除最后一个元素后，打印此列表：

# 　　...

#print(L) #[6,5,4,3,2]

#将列表反转

l[::] = l[::-1] #ID 不变

del l[-1]print(l)

print("l=",id(l))

python3 中常用于序列的函数：

len(x) # 返回序列的长度

max(x) # 返回序列的最大值元素

min(x) # 返回序列的最小值元素

sum(x) # 返回序列中所有元素的和(元素必须是数值类型)(全部相加)

any(x) # 真值测试，如果列表中其中一个值为真值则返回True

all(x) # 真值测试，如果列表中所有值为真值才返回True，否则返回False

# 序列函数

reversed(seq)   # 返回原序列反向顺序的可迭代对象

sorted(iterable,reverse=False)   # 返回已排序的列表

#示例：

L = [8,3,6,2,7]print(len(L)) #5

print(max(L)) #8

print(min(L)) #2

print(sun(L)) #26

print(any(x)) #True

print(all(x)) #True

#示例：

L = [1,2,3,4]for x inL:print(x) #1 2 3 4

for x inreversed(L):print(x) #4 3 2 1L2=[5,8,3,7,1]

L3= sorted(L2) #L3 = [1,3,5,7,8]

L4 = sorted(L2,reverse=True) #降序排序 L4 = [8,7,5,3,1]

练习：

#1，写程序，让用户循环输入一些正整数，当输入-1时结束输入，将这些整数存于列表L中。#1)打印出你共输入了几个有效的数(不算结束的-1)#2)打印你输入的最大数是多少？#3)打印你输入的最小数是多少？#4)打印你输入的这些数的平均值是多少？

l= []#创建空列表

whileTrue:

n= int(input("请输入整数："))if n == -1:break #停止输入

l += [n] #空列表加上转N列表

print("已输入：",l)print("你共输入了%d个有效的数："%len(l))print("最大值是：",max(l))print("最小值是：",min(l))print("你输入的这些数的平均值是：",sum(l)/len(l))

#2.写一个程序，让用户输入两个或以上的正整数，当输入小于零的数时结束输入(不允许输入重复的数)#1)打印这些数的和#2)打印这些数的最大数#3)打印这些数的最二大的数#4)删除最小的一个数，并打原来的列表

l= [] #创建一个容器，用变量来绑定

whileTrue:

n= int(input("请输入整数："))if n <0:if len(l)<2:print("请重新输入两次以上整数")continue

break

if n not inl:

l+=[n]print('和是：',sum(l))

l=sorted(l)print("最大数是",l[-1])print("最二大数是：",l[-2])

i = l[0]

for x in range(len(l)):

if l[x] == i:

del l[x]

break

print(l)

python3 中常用的列表方法

#方法 # 意义

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)按原输入的内容在屏幕上输出内容#2)打印出你共输入了多少文文字#3)打印出你共输入了多少行字符#如：#请输入：ABC#请输入：abc#请输入：123#请输入：《回车》#你输入的内容是：#ABC#abc#123#你输入了3行文字#你输入了9个字符

l =[]whileTrue:

s= input("请输入：")if not s: #当输用户直接输入回车时，得到空字符串

breakl.append(s)#将字符串s追加到l列表末尾

print(l)print("你输入的内容是：")for text inl:print(text)print("你输入了",len(l),"行文字")

count=0for text inl:

count+= len(text) #把每一行字符串长度累加到count中

print("你输入两",count,"个字符")

深拷贝 和 浅拷贝

浅拷贝  shallow copy

#浅拷贝是指在复制过程中，只复制一层变量，不会复制深层变量绑定的对象的复制过程#如：

L1 = [1，2,[3.1，3.2]]

L2=L1.copy()

L2[2][0] = 3.14

print(L1) #[1,2,[3.14,3.2]]

print(L2) #[1,2,[3.14,3.2]]

深拷贝  deep copy

#深拷贝会在复制过程中，逐渐复制深层对象，实现两个对象的完全独立#如：#deepcopy

import copy #导入考拷贝模块

L1 = [1，2,[3.1，3.2]]

L2=copy.deepcopy(L1)

L2[2][0] = 3.14

print(L1) #[1,2,[3.1,3.2]]

print(L2) #[1,2,[3.14,3.2]]

#小结：

L1 = [1，2，[3.1，3.2]]

L2= L1 #不拷贝

L3 = L1.copy() #浅拷贝

importcopy

L4= copy.deepcopy(L1) #深拷贝

列表与字符串比较：

列表和字符串都是序列，元素之间有先后关系

字符串中每个元素只能存储字符，而列表可以存储任意类型 的元素

字符串是不可变的序列，而列表是可变的序列

列表和字符串都是可迭代对象

字符串的文本解析方法

#方法名 # 说明

S.split(sep=None) #将字符串，使用sep作用分隔符分割S字符串返回分割后的字符串列表，当不给定参数时，用空白符作为分隔符

S.splitlines() #将字符串接换行符“\n” 分为分隔符进行分割返回分割后的列表

S.join(iterable) #用可迭代对象中的字符串，返回一个是中间 (在字符串中加上字符)用S进行分隔的字符串

#示例：

s = 'Beijing is capital'L= s.split() #L = ["Beijing","is","capital"]

s2 = "-".join(L) #s2 = "Beijing-is-capital"

练习：

#有字符串"hello" 生成字符串"h e l l o" 和"h- e-l-l-o"

s = "hello"s2= " ".join(s)

s2= "-".join(s)

创建列表的方法有几种：

#字面值：

[1,2,3]#构造函数：

list(range(1,4))

列表推导式 list comprehension

列表推导式用可迭代对象创建列表的表达式

#作用：#用简易方法生成列表#语法：#[表达式 for 变量 in 可迭代对象]#或#[表达式 for 变量 in 可迭代对象 if 真值表达式]

#示例：#生成一个数值为1~9的整数的平方的列表，如：

L = [1,4,9,16,25,36,49,64,81]#用循环语句：

L =[]for x in range(1,10):

L.append(x** 2)

练习：

#用列表推导式生成 1~ 100 内所有奇数组成的列表结果是：[1,3,5,7,......,99]#示例：

生成一个数值为1~9的奇数的平方的列表，如：

L= [1，9，25，49，81]

L= [x**2 for x in range(1,10)if x % 2 == 1]

列表推导式的嵌套：

#语法：

[表达式 for 变量1 in 可迭代对象1 if 真值表达式1 for 变量2 in 可迭代对象2 if 真值表达式2 ....]

#示例：#将列表[10,20,30] 中的元素与列表[1,2,3] 元素分别相加，将得到的元素放于一个列表中...

L = [x+y for x in [10,20,30] for y in [1,2,3]]print(L) #[11,12,13,21,22,23,31,32,33]

练习：

#用字符串"ABC"和"123" 生成如下列表：

["A1","A2","A3","B1","B2","B3","C1","C2","C3"]

l= [x+y for x in "ABC" for y in "123"]print(l)

#生成一个列表，此列表为x的平方加1不能被5整数的数的列表条件：(x ** 2 + 1) % 5 !=0#x 的取值范围是：0<= x < 100

l= [x for x in range(0,100) if (x **2 + 1 )% 5 !=0]print(l)