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  in L:
　　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 =[] # 创建一个列表，准备存放数字
while True:
　　# 每次输入一个数，如果次数小于0，则退出循环，否则把
　　# 这个数放在列表中
　　x= int(input("请输入："))
　　if x < 0:
　　　　break
　　　　L += [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 in L:
　　print(x)   # 1 2 3 4 
for x in reversed(L):  
　　print(x)   # 4 3 2 1
L2 =[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 = []# 创建空列表
while True:
    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 = []  # 创建一个容器，用变量来绑定
while True:
    n = int(input("请输入整数："))
    if n < 0:
        if len(l)<2:        
            print("请重新输入两次以上整数")
            continue
        break
    if n not in l:
    　　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 = []
while True:
    s = input("请输入：")
    if not s:  # 当输用户直接输入回车时，得到空字符串
        break
        l.append(s) # 将字符串s追加到l列表末尾
print(l)
print("你输入的内容是：")
for text in l:
    print(text)
print("你输入了",len(l),"行文字")
count = 0
for text in l:
    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（）  #浅拷贝
import copy
L4 = copy.deepcopy（L1）  # 深拷贝

列表与字符串比较：

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

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

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

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

字符串的文本解析方法

# 方法名                        # 说明    
S.split(sep=None)              # 将字符串，使用sep作用分隔符分割S字符串返回分割后的字符串列表，当不给定参数时，用空白符作为分隔符
S.splitlines()                 # 将字符串接换行符“
” 分为分隔符进行分割返回分割后的列表
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)