Python组合数据类型（二）
目录
1、列表的基本操作
（1）列表的增删和修改
（2）列表元素
（3）列表相加
（4）区分a+=b和a=a+b
（5）列表的乘法
2、列表的切片
3、列表比较大小
4、列表的应用
（1）列表的排序
（2）排序函数
（3）列表的多元素排序
（4）自定义比较函数
（5）复杂列表的自定义排序
（6）多级排序
（7）元组的排序
5、列表和元组的高级用法
（1）列表的相关函数
（2）列表的映射
（3）列表的过滤
6、列表生成式
7、元组生成式
8、二维列表
9、二维元组
10、列表的拷贝
（1）普通的拷贝
11、列表转化
1、列表的基本操作
在Python中，列表有很多的功能，它的内部能包含多种的数据类型，整数，浮点数，字符串，甚至是一个列表，一个元组，下面我们来详细介绍一下：
（1）列表的增删和修改
列表不像元组，它内部的元素可以被修改，而且列表还可以增加或删除一些元素：
我们可以通过列表元素的下标直接修改元素：
a = ["123" , "hello" , "zero"]
a[2] = "one"
print(a)结果：
我们可以通过“del”关键字，来通过下标删除指定的元素：
a = ["123" , "hello" , "zero"]
del a[2]
print(a)结果
对于给列表添加元素，我们会先介绍两种：
①使用“+=”（不会创建新的列表）：
a = ["123" , "hello" , "zero"]
a += ["boy"]
print(a)会在列表的尾部再添加应该元素“boy”
②使用“append（）”函数：
a = ["123" , "hello" , "zero"]
a.append(90)
print(a)会在列表的尾部再添加应该元素90
（+=用于添加多个元素，append（）用于添加单个元素）（也不会创建一个新的列表）
（2）列表元素
a = ["123" , "hello" , "zero"]
b = [88 , ["hello"] , ("yes")]
c = [a , b]
print(c)
a[0] = "CSDN"
print(c)列表中的每个元素的内容都是对其对象的引用，当我们修改对象的内容的时候，列表也会随之改变：
所以让我们看看上面代码的结果：
c中的两个元素指向了a和b，当我们修改a或b时，c也会发生改变：
（3）列表相加
在Python中，我们可以通过加号来把两个列表连接起来，当我们把这两个相加的新列表赋值给一个新的变量，这个新的列表就和之前的两个列表无关了，我们即使修改两个旧列表的数值，也不会对新的列表产生改变：
a = ["123" , "hello" , "zero"]
b = [88 , ["hello"] , ("yes")]
c = a + b
a[0] = "ooo"
print(c)结果：
（4）区分a+=b和a=a+b
在前面的文章我们提到过，在给变量赋值时，a+=b和a=a+b是相同的，但是对于列表来说，这两个代码是有区别的：
a = b =[1,2,3]
a += [4]
print(a,b)
a = a + [5]
print(a,b)结果：
在Python中，对于列表来说，a+=b是把b追加到列表a的尾部，但不产生新的列表对象，但是a=a+b不仅会把b追加到a的尾部，还会在内存处创建一个新的地方，然后让a重新指向这个新的数据。
（5）列表的乘法
列表的乘法多种多样，在不同的位置相乘会有不同的效果，我们下面用一个简单的代码来区分：
a = [1,2]
b = a *3 #用三个a生成了新的列表b
print(b)
c = [a *3] #用三个a生成了新的列表c
print(c)
d = [a] * 3 #用a连续乘了三次，本质还是a
print(d)
e = a.append(8) #不会创建一个新的列表对象
print(e)
print(b)
print(c)
print(d) #包含8输出：
2、列表的切片
列表的切片会重新返回列表，用法和字符串切片相同
3、列表比较大小
列表的大小比较和元组很相似，也是把两个列表的元素逐个比较大小，即第一个跟第一个比较，第二个跟第二个比较，如果出现不可比较的就报错！
4、列表的应用
（1）列表的排序
在Python中，它为我们提供了十分丰富且方便的函数，用来给列表排序（后面会提到），但是我们也要学会自己手搓一个简单的排序函数，方便理解内部的原理：
一个简单的排序函数：
def Scypaixu (a) : #从小到大排序
n = len(a) #n等于7
for i in range(n-1) : #从0到6依次遍历
for j in range(i+1 , n) : #从i+1到7
if a[i] > a[j]:
a[i] , a[j] = a[j] , a[i]
lst = [1,55,6,89,99,3,5]
Scypaixu(lst)
print(lst)输出：
你可以把这个函数看成：我们先让第一个元素默认最小，然后后面的几个元素通过循环，一个个的来和第一个元素比较，如果没他小，就换下一个，比他小，就换小的那个，再让下一个来（类似守擂台）
（顺便说一下，因为上面包含了两个for循环，所以他的时间复杂度是O（n^2），如果是一个循环就是O（n），没有循环就是O（1），而Python为我们提供的排序函数的复杂的是O（n*log（n），有着更快更高效的效率！）
（2）排序函数
激动人心的排序函数终于来了，用好了排序函数，就方便我们做很多的事情：
我们可以用sort（）函数对列表进行排序：
a = [1,3,55,89,100,84]
a.sort()
print(a)结果：
而sorted（）则是返回把列表进行从小到大排序后得到的新列表，旧列表保持不变：
a = [1,3,55,89,100,84]
b = sorted(a)
print(b)
print(a)结果：
当然我们还可以通过使用“reverse”关键字来让排序的方法从“从小到大”变成“从大到小”
a = [1,3,55,89,100,84]
a.sort(reverse = True)
print(a)结果:
（3）列表的多元素排序
在一个列表内，如果有一个元素内部包含很多的元素，比如一个列表里面包含很多的元组，每个元组都包含了学生姓名，成绩，年龄，如果我们使用sort（）函数，就默认是先按照姓名排序，再按照成绩，再年龄。
（4）自定义比较函数
我们在Python中可以用key函数来自定义如何去比较，从而不仅仅局限于从大到小或从小到大：
例子：
比如我们想要根据各个数字的个位数大小来排序，我们可以通过key函数这样去实现：
def Scykey (x) :
return x % 10
a = [95,12,64,43,1]
a.sort(key = Scykey)
print(a)输出：
我们会通过key来调取对应的函数的返回值，再把其返回值根据大小排序！
（5）复杂列表的自定义排序
像前面所说，一个列表内部的元素可能包含很多的信息，那么我们怎么来根据我们的需要来排序呢：
我们先要介绍一个表达式，即lambda函数表达式：
我们举两个例子：
lambda x: x[2]
#表示一个函数，参数是x，返回值是x[2]
k = lambda x,y : x+y
#k是一个函数，参数是x,y，返回值是x+y
我们下面来把上面的例子应用到一个具体的代码中去：
students = [
("John" , "A" , 15),
("Mike", "B", 12),
("Mike", "C", 18),
("Bom", "A", 10)
]
students.sort(key = lambda x : x[2])
#按年龄排序
print(students)
students.sort(key = lambda x : x[1])
#按成绩排序
print(students)
students.sort(key = lambda x : x[0])
#按姓名排序
print(students)
#注意，sort（）函数只会在原有的基础上对列表进行排序，如果用“a = students.sort(key = lambda x : x[2])”再print（a）是不会有输出的！！！！！！！！！结果：
（这里注意一下按照姓名排序，Python中的排序是稳定排序，当按照某规则排序时，遇到两组相同的数据，那么这两个谁之前在前面，排序的时候谁就在前面）
（6）多级排序
有时我们我们遇到相同的数据时，不希望是Python的稳定排序来决定谁在前谁在后，我们希望可以通过这两组数据其他的不同之处，来决定两组数据的顺序：
我们可以通过函数返回值的顺序与大小，对我们的列表的各个元素进行多级排序：
def f(x) :
return (-x[2] , x[1] , x[0])
#先按照年龄从高到低，再按照成绩从高到低，最后按照名字
students = [
("John" , "A" , 15),
("Mike", "B", 12),
("Mike", "C", 18),
("Bom", "A", 10)
]
students.sort(key = f)
print(students)结果：
（7）元组的排序
前面我们已经了解过，元组一旦被生成，就不能改变其内容（顺序，长度，各个元素的数值）：
因为元组的这些特性，所以元组无sort函数，但是我们可以用sorted函数得到排序后的新列表（sorted函数的返回值是一个新的列表）！
我们来看一个简单的例子：
a = (24 , 1 , 998 , 76 , 45)
b = sorted(a)
print(b)
#用sorted函数来对元组进行排序
try :
a.sort()
except Exception as e:
print(e)
#不能用sort函数，会报错结果：
5、列表和元组的高级用法
（1）列表的相关函数
| 函数 | 作用 |
| append（x） | 添加元素x到列表尾部 |
| extend（x） | 添加列表x中的元素到列表尾部 |
| insert（i，x） | 将元素x插到下标i处 |
| remove（） | 删除元素x（del是通过下标删除） |
| reverse（） | 颠倒整个列表 |
| index（x） | 查找元素x，找到则返回第一次出现的下标，找不到就返回异常！ |
注意区分append函数和extend函数：
a = ["string" , "hello" , 123456]
b = ["string" , "hello" , 123456]
a.append([1,2,3])
print(a)
b.extend([1,2,3])
print(b)我们可以在电脑上运行这个代码来看到区别：
而remove（）函数是删除第一次遇到的指定元素：
a = [23 , 3 , 5 , 88 , 90 , 3 , 3, 3]
a.remove(3) #只会删去第二个元素
print(a)（2）列表的映射
对于列表的映射，我们会涉及到map关键字：
常见的格式是：map（函数or方法 ， 序列），map会把括号里面的序列里的元素逐个的放到函数中，然后再返回，并且把返回值组合成一个新的序列：
例子：
def Scy(x) :
print("输出原序列的每个元素的数值：",x)
return x*x*x
b = [1,2,3]
a = map(Scy , b)
print(list(a))
print(b) #原列表不变结果：
（3）列表的过滤
我们在Python中可以用filter关键字来对列表进行筛选：
基本格式：filter（函数 ， 序列）
我们会把序列中的各个元素依次放到函数中，然后抽取序列中令函数为True的元素，和map相似，这个会返回一个延时求值对象，可以转换成list、tuple、set
例子：
def f(x) :
return x % 2 == 0
lst = tuple(filter(f , [1,2,3,4,5,6,7,8,9,10]))
print(lst)输出：
6、列表生成式
列表生成式可以让我们快速的获取我们想要的数据，比如我们想要得到一个列表，里面是从1到10的整数的平方，如果一个个打，未免过于麻烦，于是我们可以用列表生成式：
a = [x*x for x in range(1,11)]
print(a)输出：
上面的列表生成式要从右往左读：即在for循环中，我们让从1到11（不包括11）的整数，取前面的x*x（即平方）
我们还可以在后面添加附加条件，比如我们要把上面的偶数再提取出来，我们可以在后面增加一个if语句：
a = [x*x for x in range(1,11) if x % 2 ==0]
print(a)
既然可以写一个循环，那我们就可以写双重循环，比如给定两组字符串，我们想让其中的元素两两组合在一起：
a = [x+y for x in "ABC" for y in "XYZ"]
print(a)
但如果我们在某处添加一个中括号，输出结果又会变得截然不同：
a = [[x+y for x in "ABC"] for y in "XYZ"]
print(a)
7、元组生成式
元组生成式和列表生成式很相似，括号方面就是把中括号改成了小括号，并且要在括号内添加tuple字样：
a = (tuple(x*x for x in range(1,11)))
print(a)8、二维列表
我们可以把二位列表看成是一个矩阵，其中a[i][j]就是第i行，第j列个元素：
！！！这里我们要先说一个错误的生成二维数列表的方法：
在二维列表中，每一个a[i][j]都有一个自己的指针，指向了某个地方，所以如果我们只改变了某一个元素，其他的应该是不会受到影响的：
a = [0 , 0 , 0]
b = [a]*3
print(b)
b[0][1] = 6
print(b)
我们看见第一行的输出确实很像一个二维列表，但是当我们改变了一个元素时，居然还有两个元素被改变了，这是因为我们的b中，有三个元素，而这三个元素都指向了a，所以当我们改变一个时，剩下的两个也会改变
那么现在我们就来正确的写出一个二维列表：
①纯手工制作
a = [[1,2,3] , [4,5,6] , [7,8,9]]
a[0][1] = 1000
print(a)②双重循环的列表生成式
a = [[x+y for x in range(1,4)] for y in range(4,7)]
print(a)③朴素做法
lst = []
for i in range(1 , 4) :
lst.append([0] * 3)
print(lst)9、二维元组
我们可以用元组生成式来生成一个二维元组：
a = tuple(tuple(0 for i in range (3)) for j in range(3))
print(a)输出：
10、列表的拷贝
（1）普通的拷贝
在Python中我们可以用切片的方法来拷贝一个列表：
a = [1,2,3,4,5,6]
b = a[:]
print(b)结果：
注意：我们拷贝过来的列表是一个新的对象，它的内容虽然和原列表相似，但是并非指向了同一个地方：
a = [1,2,3,4,5,6]
b = a[:]
print(b)
print(a is b) #a和b是否指向相同的地址
print(a == b) #a和b是否拥有相同的数值
a[2] = 999
print(a) #a改变了
print(b) #b没改变输出：
（2）列表的深拷贝
我们的Python中分为浅拷贝和深拷贝，一般情况都是浅拷贝，深层拷贝需要特殊的包的调用：
我们先来看浅拷贝：
a = [1,2,3,4,[2,3]]
b = a[:]
print(b)
a[4][1] = 99999
print(a)
print(b)输出：
我们发现让我们改变了a时，b居然也发生了改变，照理说他们应该指向不同的地方，只是数值一样，这是因为浅拷贝就是把外层的给复制下来了，但是内层的嵌套却还是相同的指向了一个对象，如果使用深拷贝，就是真正的两个对象了，无论是内层的还是外层的都是独立的：
现在我们使用一下深拷贝：
深拷贝我们会用到deepcopy（）函数，以及要调用copy这个包：
import copy
a = [1,2,3,4,[2,3]]
b = copy.deepcopy(a)
print(b)
a[4][1] = 99999
print(a)
print(b)输出：
11、列表转化
在Python中，我们可以像给数据类型转换一样，也给列表转换为元组等：
a = [1,2,3,4,5,6]
b = tuple(a)
print(b)
c = list(b)
print(c)输出：
以上就是Python数据组合类型（二）:)