Python06-列表合集和深浅拷贝

目录

1、创建列表

2、列表的增删改查

2.1增

2.2删

2.3改

2.4查

3、列表的计算和嵌套列表

4、浅拷贝和深拷贝

5、列表推导式

---

1、创建列表

中括号将所有的元素放进去，不同元素之间使用逗号分隔

rhyme = [1,2,3,4,5,"上山打老虎"]
print("rhyme")

将列表元素每一个打印出来：

for each in rhyme:
    print(each)

访问单个元素，rhyme[0]访问第一个，一次下推 ，形成下标索引，一抓一个准。当元素很多时，我们访问最后一个元素，可以用rhyme[-1],或下面的方法：

length = len(rhyme)
rhyme[length - 1]

列表切片，rhyme[0:3]，打印出来的就是前四个元素，rhyme[2:]表示的就是第二个之后的，rhyme[0,6,2]表示以步进2展示的元素，rhyme[::-2]倒叙以-2步进展示。

2、列表的增删改查

2.1增

append（）：在列表的末尾加一个元素，只能加一个元素。extend（）可以加很多个，必须是一个可迭代对象，新得内容是追加到原列表最后一个元素的后面。同样利用列表的切片一样可以达到增的效果，无切片不python。

s=[1,2,3,4]
s.append(5)    #添加元素5
s.extend([5,6,7,8])    #继续添加4个元素

s=[1,2,3,4]
s[len(s):] = [5]
s[len(s):] = [5,6,7,8]

insert()，第一个参数指定待插入的位置，第二个参数插入元素

s = [1,3,4,5]
s.insert(1,2)
s    #[1,2,3,4,5]
s.insert(0,0)    #[0,1,2,3,4,5]
s.insert(len(s),6)    #[0,1,2,3,4,5,6],类似append()

2.2删

remove(),当删除的元素有相同的，只删除最小下标的那个元素。pop()删除某个位置上的元素，参数是下标的索引值。

s = [0,1,2,3,4]
s.remove[2]    #[0,1,3,4]
s.pop(2)    #[0,1,3,4]
s.clear()    #[]删除所有，形成空列表

2.3改

列表是可变的，字符串是不可变的，使用下标索引的方法，用赋值运算符将新的值替换进去，或者切片的方法。

s=[1,2,3,4,5]
s[3]=6    #[1, 2, 3, 6, 5]
s[2:]=["a","b","c"]    #[1, 2, 'a', 'b', 'c']

若进行一个列表的排序，调用sort（）和reverse（）方法，从小到大和调换顺序

s = [8,6,4,2,4,6]
s.sort()    #[2,4,4,6,6,8]
s.reverse()    #[8,6,6,4,4,2]

#或者
s = [8,6,4,2,4,6]
s.sort(reverse=True)    #[8,6,6,4,4,2]

2.4查

count（），查找元素，index（）查找索引值，index还有两个可以选的参数 index（x,start,end）,从下标start开始查找到下标end

s = ["A","B","C",2,3,3,4,5]
s.count(3)    #2
s.index("B")    #1
s[s.index("2")] = "D"    #["A","B","C","D",3,3,4,5]
s.index(3)    #返回4
s.index(3,5,7)    #返回5

copy（）进行拷贝（浅拷贝）

s = ["A","B","C",1,2,3,4]
s1 = s.copy()    #拷贝
s2 = s[:]    #切片方法拷贝

3、列表的计算和嵌套列表

s = [1,2,3]
s1 = [4,5,6]
s+s1    #[1, 2, 3, 4, 5, 6]
s*3    #[1, 2, 3, 1, 2, 3, 1, 2, 3]

嵌套列表，如[1,2,[3,4]]，多维列表，CTRL+J换行。

访问嵌套列表，使用循环。

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

对于上面的代码段，修改一个元素，实际改变的是3个元素，这是因为内部嵌套的列表不是独立的列表，而是对同一个列表的三次引用而已。所以用循环逐一赋值创建列表或者用列表推导式。

matrix = [(1,2,3),(4,5,6),(7,8,9)]
"""或者"""
matrix = [(1,2,3),
          (4,5,6),
          (7,8,9)]

matrix[0]    #[1,2,3]
matrix[0][0]    #1
matrix[1][1]    #5

#访问每个元素
for i in matrix:
    for each in i:
        print(each)
#结尾设置空格,并三个一行，执行到print()默认换行
for i in matrix:
    for each in i:
        print(each，end='')
    print()

"""迭代生成二维列表"""
A = [0]*3    #[0,0,0]
for i range(3):    #三次迭代
    A[1] = [0]*3
print(A)    #[[0,0,0],[0,0,0],[0,0,0]]

"""列表不同"""
s = [1,2,3]
s1 = [1,2,3]
s1 is s    #返回false，因为地址不同，is返回true和false

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

4、浅拷贝和深拷贝

这里介绍一下变量和对象，例如写下赋值语句 a = "python"。python解释器将创建变量a、创建一个对象（分配一个内存）用来存储"python"，将变量与对象，通过指针连接起来，从变量到对象的连接称之为引用(变量引用对象)。

浅拷贝：创建新对象，其内容是原对象的引用。它仅仅只拷贝了一层，拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。调用列表的copy（）方法或者使用切片的语法。如下代码：

所以浅拷贝处理一维列表是没问题的，更改原列表不会修改新列表，但是二维列表（或者嵌套列表）浅拷贝原列表的变化，会更改里面的子列表。其拷贝的只是原列表的引用。

"""浅拷贝"""
a = [1,2,[3,4]]
b = a.copy()
print(b)    #[1, 2, [3, 4]]
a[2][1] = "x"
print(a)    #[1, 2, [3, 'x']]
print(b)    #[1, 2, [3, 'x']]
a[0] = "y"
print(a)    #['y', 2, [3, 'x']]
print(b)    #[1, 2, [3, 'x']]

深拷贝：由于浅拷贝只是拷贝的原列表的引用，因此我们介绍深拷贝，深拷贝拷贝了对象的所有元素，包括多层嵌套的元素。深拷贝出来的对象是一个全新的对象，不再与原来的对象有任何关联。改变原列表不会对新列表有任何影响。

只有一种形式copy模块中的 deepcopy 函数

import copy
x = [[1,2,3],[4,5,6],[7,8,9]]
y = copy.copy.(x)    #浅拷贝
y1 = copy.deepcopy(x)    #深拷贝
x[1][1] = 0
print(y)    #变成[4，0，6]
print(y1)    #不会变化

5、列表推导式

 对于[[0]*3]*3创建的列表来说只是同一列表的3次引用，我们使用列表推导式来创建此列表如下

a = [[0]*3 for i in range(3)]

"""应用列表推导式"""
s = [1,2,3,4,5]
s = [i * 2 for i in s]
print(s)    #[2, 4, 6, 8, 10]

"""原方法"""
s = [1,2,3,4,5]
for i in range(len(s)):
    s[i] = s[i]*2
print(s)    #[2, 4, 6, 8, 10]

列表推导式要比循环语句快一倍以上的速度，列表推导式在python解释器中是以更快的C语言来运行的。

x = [i for i in range(5)]    #[1,2,3,4]
y = [c * 2 for c in "fishc"]    #['ff','ii','ss','hh','cc']
z = [ord(c) for c in "fishc"]    #将每个字母转化为编码为[102, 105, 115, 104, 99]

matrix = [[1,2,3],
          [4,5,6],
          [7,8,9]]
co12 = [row[1] for row in matrix]    #提取出[2,5,8]
diag = [matrix[i][i] for i in range(len(matrix))]    #获得对角线元素[1,5,9]
aa = [matrix[i][2-i] for i in range(len(matrix))]    #获得逆对角元素[3,5,7]

循环是通过迭代逐个修改列表中的元素，而列表推导式则是直接创建一个新的列表。

列表表达式还可以添加用于筛选的 if 分句：

先执行for语句（for i in range（10））--if语句（if i % 2 == 0）--表达式（i）

"""筛选偶数"""
even = [i for i in range(10) if i % 2 == 0]
print(even)    #[0, 2, 4, 6, 8]

"""筛选F开头的单词"""
words = ["Great","Fishc","Brillent","Excellent","Fantistic"]
fwords = [w for w in words if w[0] == 'F']
print(fwords)    #['Fishc', 'Fantistic']

对于列表推导式的嵌套：嵌套外循环放前面，内循环放后面

"""列表推导式"""
matrix = [[1,2,3],[4,5,6],[7,8,9]]
flatten = [col for row in matrix for col in row]
print(flatten)    #[1, 2, 3, 4, 5, 6, 7, 8, 9]降维


"""迭代式"""
flatten = []
for row in matrix:    #获取每一行，取出一个三维列表，一整行
    for col in row:    #获取该行的每一个数字，放入col
        flatten.append(col)

"""列表推导式"""
[x + y for x in "fishc" for y in "FISHC"]
#['fF', 'fI', 'fS', 'fH', 'fC', 'iF', 'iI', 'iS', 'iH', 'iC', 'sF', 'sI', 'sS', 'sH', 'sC', 'hF', 'hI', 'hS', 'hH', 'hC', 'cF', 'cI', 'cS', 'cH', 'cC']笛卡尔乘积
"""迭代"""
_ = []
for x in "fishc":
    for y in "FISHC":
        _.append(x + y)

"""列表推导式"""
[[x,y] for x in range(10) if x % 2 == 0 for y in range(10) if y % 3 == 0]
'''
[[0, 0], [0, 3], [0, 6], [0, 9], [2, 0], [2, 3], [2, 6], [2, 9], [4, 0], [4, 3], [4, 6], [4, 9], [6, 0], [6, 3], [6, 6], [6, 9], [8, 0], [8, 3], [8, 6], [8, 9]]
'''

• 临时变量可以用下划线表示 _
• 冒号代表这是语句段，下一行自动缩进，表以下代码为从属语句