四：《Python基础语法汇总》— 列表&元组&集合

一：列表

列表是Python中最基本的数据类型之一，是可以存放多个多种元素的容器
列表是Python中序列的一种，是一个有序可变序列
由于列表是可变序列，所以可以对其里面的内容进行修改，无需重新开辟空间存储

1.下标与切片：

列表中也可以应用下标索引和切片，与在字符串中的应用一样

创建列表：

使用中括号 [] 将所有准备放入列表中的元素给包裹起来，不同元素之间使用英文逗号隔开

列表中可以放入整型，浮点型，字符串和变量名等

v = "123"
a = ["90",520,1.86,v,1,2,3]
#用正数正向索引打印1.86
print(a[2])
#用负数负向索引打印520
print(a[-6])
#用正向切片获取520~2
print(a[1:6])
print(a[-6:-1])
#用负向切片获取2~520
print(a[5:0:-1])
print(a[-2:-7:-1])

2.列表的方法与函数：

列表的常用操作方法有增加，删除，修改，查找

列表方法的调用：对象/变量名.方法()

一：增加

向列表中添加指定的元素

append()方法：在列表的末尾添加一个指定的元素，且每次只能添加一个元素

append()方法是对列表进行修改，其本身是没有返回值的，不能够直接输出

append()方法的语法格式：列表对象/变量名.append(元素)

a = [123,456]
a.append(789)
print(a)

extend()方法：

在末尾添加一个序列，extend()方法的参数必须是一个序列，其本身没有返回值
新添加的内容是将序列中的每一个元素都追加到原列表最后一个元素的后面
只能添加一个参数，但可以将多个参数存储在序列这一个参数里面

extend()方法的语法格式：列表对象/变量名.extend(序列)

a = [1,5,3,8,0]
a.extend(["122","你好",11])
print(a)

insert()方法：在指定的任意位置添加一个元素，insert()方法不是替换，而是让待插入位置上的元素整体后退

insert()方法的语法格式：列表对象/变量名.insert(指定待插入的下标位置,指定待插入的元素)

a = ["我","上","你"]
a.insert(1,"爱")
print(a)

二：删除

删除列表中的元素

pop()方法：删除指定下标位置上的元素

pop()方法的语法格式：列表对象/变量名.pop(要删除的那个元素的下标索引)

a = [1,2,3,4,5,3]
a.pop(3)
print(a)

remove()方法：删除指定的元素

如果列表中存在多个相匹配的元素，那么它只会删除第一个找到的元素

如果指定的那个元素不存在，那么程序会发生报错

remove()方法的语法格式：列表对象/变量名.remove(要删除的元素)

a = ["我","爱","12","你"]
a.remove("12")
print(a)

del销毁语句：销毁掉这个列表或者其元素，释放内存空间

del的语法格式：

del 列表名[要删除的某一元素的下标索引]
del 列表名

a = [1,2,3,4,5]
del a[2]
print(a)
del a
print(a)

注意： 当del已经将这个列表销毁时，再次访问输出会发生报错

clear()方法：清空列表中的所有元素，只留下空列表

clear()方法的语法格式：列表对象/变量名.clear()

a = [1,3,4,5,7,9]
a.clear()
print(a)

三：修改

先找到这个元素，然后对它进行重新赋值

根据下标直接修改：

替换单个元素的语法格式：列表名[要被替换的元素的下标索引] = 替换的元素

替换多个元素的语法格式：列表名[起始下标:结束下标:步长] = 替换的元素

a = [1,2,3,4,5,6,7]
a[2] = "我"
print(a)
a[0:5:2] = ["爱","love",0]
print(a)

当不知道某个元素的索引值，想将其替换成新的元素时：

列表名[列表名.index(被替换的元素)] = 替换的元素

a = [1,2,3,4,5,6]
a[a.index(3)] = "ai"
print(a)

reverse()方法：逆置，将列表中的元素翻转

reverse()方法的语法格式：列表名.reverse()

a = ["a",3,"yu",9,7,"se"]
a.reverse()
print(a)

sort()方法：只用于数字序列，对数字进行从小到大的排序

sort()方法的语法格式：列表名.sort()

a = [1,5,4,7,9,10,45,94,14]
a.sort()
print(a)

注意： reverse()的默认值为False，如果将它设置为True，那么排序的结果就会原地翻转

#直接实现数字从大到小排序
列表名.sort(reverse = True)
a = [1,3,23,65,34,78,10]
a.sort(reverse = True)

copy()方法：对一维列表进行拷贝

copy()方法的语法格式：列表对象/变量名.copy()

a = [1,3,5,7,9]
b = a.copy()
print(b)

四：查找

index()方法：通过指定的元素去查询下标，只找从左到右第一个找到的下标，当index()方法查询到一个不存在的元素时，会发生报错

index()方法的语法格式：对象/变量名.index(要查询的元素字符,起始点（刚才查询到的下标+1）,结束位置)

a = [1,2,3,4,5,4]
print(a.index(4))
print(a.index(4,2,4))

count()方法：用于统计指定的某个字符出现的次数

count()方法的语法格式：列表对象/变量名.count(要查询的元素)

a = [1,4,2,4,2,5,6,4]
print(a.count(4))

len()函数：查询列表中的元素长度

a = [1,5,4,87,34]
print(len(a))

3.成员判断符：

只应用于序列类型当中

符号	作用
`in`	左边是否在右边里
`not in`	左边是否不在右边里

a = [1,2,3,5,7,0]
print(3 in a)
print(8 not in a)

注意：

成员判断符只能判断一维列表的成员关系
若要判断嵌套列表里一维列表的元素，则应该先把它索引出来

a = [1,["long"],"泽"]
print("long" in a[1])

4.列表嵌套：

列表的加法与乘法：

列表的加法就是拼接，加号两边必须都是列表

a = ["我","爱","你"]
b = ["才","怪"]
print(a + b)

列表的乘法则是重复列表内的所有元素若干次

a = [1,2,3]
print(a * 3)

嵌套列表（二维列表）：

所谓的列表嵌套就是在列表里面嵌套一个新的列表

a = [[1,2,3],["才","怪"],[4,5,6]]

访问嵌套列表：

1. 访问嵌套列表中的元素可以用循环来实现，迭代一个列表，嵌套一层循环，迭代嵌套列表，则对应的使用嵌套列表，依此类推

a = [[1,2,3],[4,5,6],[7,8,9]]
for i in a:
    for w in i:
        print(w)

2. 通过下标索引来访问嵌套列表

a = [[1,2,3],
     [4,5,6],
     [7,8,9]]
print(a[1])

如果只给出一个下标索引的话，得到的是以行为单位的整个列表，而非嵌套列表中的列表

为了访问嵌套列表中的列表的元素，需要使用两次的下标索引

第一个下标索引指的是整个列表中的 “行”

第二个下标索引指的是这一行里面对应的 “列”

a = [[1,2,3],
     [4,5,6],
     [7,8,9]]
#访问第二行第三列的元素
print(a[1][2])

通过循环创建并初始化二维列表：

a = [] # 创建一个空列表
for i in range(3): # 循环3次
    b = [] # 创建一个空列表作为当前行的元素
    for j in range(3): # 循环3次
        b.append(0) # 将0添加到当前行列表中
    a.append(b) # 将当前行列表添加到二维列表中
print(a) # 输出二维列表

# 错误示范 -- 容易导致出现BUG
b = [[0] * 3] * 3
print(b)

5.同一性运算符：

符号	作用
`is`	用于检验两个变量是否指向同一对象

a = "wo"
b = "wo"
print(a is b) #True
a = [1,2,3]
b = [1,2,3]
print(a is b) #False

以上说明了在Python中，对于不同对象的存储机制是不一样的

如：

字符串是不可变的，当有多个变量名指向同一个字符串的情况时，它只需要在内存中开辟一个空间来存放就可以了
相比字符串，列表是可变的，列表内的元素可以添加或删除，尽管两个列表的内容一致，但Python还是要为它们开辟两个不同的空间位置进行存放

通过以上结论：检测二维列表a和b:

a = []
for i in range(3): 
    b = [] 
    for j in range(3): 
        b.append(0) 
    a.append(b) 
print(a) 
print(a[0] is a[1]) #False

结果是False，说明了不是同一对象，便不放在同一内存地址里面

# 错误示范 -- 容易导致出现BUG
b = [[0] * 3] * 3
print(b)
print(b[0] is b[1]) #True

结果是True，说明了是同一对象，且放在同一内存地址里面

经过以上实验论证，得知b的问题在于：试图通过乘号对一个嵌套列表进行拷贝，但其实它只是对同一个列表进行重复的引用

引用：

变量就是一个名字，一个标签，通过这个变量，就可以找到对应的数据，在Python中。变量不是一个盒子，因为当赋值运算发生的时候，Python并不是将数据放到变量里面去，而是将变量与数据进行挂钩，这个行为，我们称之为引用

将一个变量赋值给另一个变量，其实就是将一个变量引用传递给另一个变量

6.浅拷贝与深拷贝：

如果想要得到两个独立的列表，就要用到拷贝，拷贝之后的列表是独立的，而引用后的列表会随着远列表的改变而改变，一维列表用浅拷贝，多维列表用深拷贝

一：浅拷贝：

调用列表的copy()方法，copy()方法拷贝的是整个的列表对象，不仅仅是变量的引用

使用切片也可以实现浅拷贝

注意： 用浅拷贝处理一维列表是没有问题的，但如果是嵌套列表，对拷贝的那个列表是有干扰的，因为嵌套列表只是拷贝了外层的对象，如果包含嵌套对象的话，那么拷贝的只是其引用，要解决这个问题，就要用到深拷贝

二：深拷贝：

调用copy模块

copy()模块中有两个函数

（1）一个是copy()：实现的是浅拷贝

copy()的语法格式：

导入函数：import copy

使用函数：要接收拷贝的变量名 = copy.copy(提供列表的变量名)

import copy
a = [1,2,3,4,5,6,7,8,9]
b = copy.copy(a)
print(b)

（2）另一个是deepcopy()：实现的是深拷贝

deepcopy()的语法格式：

导入函数：import copy

使用函数：要接收拷贝的变量名 = copy.deepcopy(提供列表的变量名)

import copy
a = [[1,2,3],[4,5,6],[7,8,9]]
b = copy.deepcopy(a)
print(b)

深拷贝在原嵌套列表改变的同时，拷贝的列表也不会发生变化，因为deepcopy()函数在将原对象拷贝的同时，也将对象中所有的子对象一并进行了拷贝。如果存在多层嵌套的情况下，深拷贝也会拷贝每一层嵌套里的数据

注意： copy.copy()指的是copy模块中一个叫copy()的函数；变量名.copy()指的是列表的一个copy()方法，但它们所实现的都是浅拷贝

7.列表推导式：

列表推导式的构建：

基本语法一：

[表达式 for 变量 in 可迭代对象]

注意：

列表推导式一定要是一个列表，所以列表推导式要用 [] 包裹
由于列表推导式的结果是使用一组数据来填充这个列表的，所以需要一个for语句来搭配，最后在for语句的左侧放一个表达式，相当于循环体，经过运算才决定存放在列表中的数据
表达式是列表中的元素，它一定要是for循环中产生的值，不能是不被定义的，要与临时变量保持一致

a = [b for b in range(10)]
print(a) #最后的结果由i决定
a = [b + 1 for b in range(10)]
print(a) #列表中的每一个元素都加1
a = [b * 2 for b in "long"]
print(a) #将字符串中的每个元素重复两遍，并存储在列表中

ord()函数：将单个字符转换为对应的Unicode编码，并保存在列表

a = [ord(b) for b in "long"]
print(a)

通过列表推导式将嵌套列表中的元素提取出来：

a = [[1,2,3],
     [4,5,6],
     [7,8,9]]
b = [i[1] for i in a] #将每一行的第二个元素提取
print(b)

通过列表推导式将嵌套列表中对角线的元素提取出来：

a = [[1,2,3],
     [4,5,6],
     [7,8,9]]
b = [a[t][t] for t in range(len(a))] #获取从左上角到右上角上的元素
print(b)

注意： 循环是通过迭代来逐个修改原列表中的元素。而列表推导式则是直接创建一个新的列表，然后再拷贝给原先的列表名

基本语法二：

[表达式 for 变量 in 可迭代对象 if 条件判断]

注意： 执行顺序是先执行for语句，在执行if语句，最后在执行左侧的表达式

#求偶数
a = [i for i in range(10) if i % 2 == 0]
print(a)
#求奇数
a = [i + 1 for i in range(10) if i % 2 == 0]
print(a)
#筛选出开头为f的单词
a = ["for","great","from","apple"]
b = [i for i in a if i[0] == 'f']
print(b)

列表推导式的嵌套语法：

[表达式 for 变量 in 可迭代对象1

for 变量 in 可迭代对象2

…

for 变量 in 可迭代对象n]

注意： 1.嵌套的列表推导式对应嵌套循环

2. 外层循环是放在前面的，嵌套的循环是放在后面的，先执行前面的循环

#将二维列表将为一维列表
a = [[1,2,3],[4,5,6],[7,8,9]]
b = [z for i in a for z in i]
print(b)

#将二维列表将为一维列表
a = [[1,2,3],[4,5,6],[7,8,9]]
b = []
for i in a:
    for z in i:
        b.append(z)
print(b)

列表推导式的终极语法：

[表达式 for 变量 in 可迭代对象1 if 条件判断1

for 变量 in 可迭代对象2 if 条件判断2

…

for 变量 in 可迭代对象n if 条件判断n]

注意： 每个for语句的后面都可以追加一个if语句，用于进行条件筛选

a = [[1,2,3],[4,5,6],[7,8,9]]
b = [z+1 for i in a if i[1] > 1 for z in i if z % 2 == 0]
print(b)

8.列表的散装知识点：

1. 比较大小：

当有多个元素时，默认从第0索引元素开始比较。只要一个大，那整个列表就是大，不用进行后面的比较

a = [1,2,3]
b = [4,5,6]
print(a > b) #返回False

2. 拼接操作符：+

当要进行拼接的操作时，加号两边的对象类型必须保持一致，左边是列表，右边必须也得是列表

列表的拼接和字符串的拼接具有相似性，但并非完全一样，列表的拼接相当于使用extend()的方法，使用extend()方法来扩展列表会显得更加规范，随意使用加号去扩展列表的话，有一些操作是违规的

a = [1,2,3]
b = ["wo","ai"]
c = b + a
print(c)

二：元组

元组是Python中最基本的数据类型之一，是可以存放多个多种元素的容器
元组是Python中序列的一种，是一个有序不可变序列
由于元组是不可变的序列，所以无法对其里面的内容进行修改，一旦定义，就是固定的
元组既可以像列表那样同时容纳多种类型的对象，也拥有字符串不可改变的特性
当元组里面只有一个元素的时候，要在那个元素的结尾加上一个英文逗号，不然，那个元素就只是其本身原来的类型，不在是元组类型

a = (3,)
print(type(a))
b = ("嘟嘟",)
print(type(b))

访问一个元组的元素与访问一个列表的元素的方法是一样的，都是用下标索引
元组也可以进行切片操作，因为切片的含义是将目标对象中的元素以某种特定的组合导出一个新的对象，而并非修改对象本身
元组只支持index()方法，count()方法和len()函数，与列表的使用效果一样
拼接操作符 + 和重复操作符 * ，这两个运算符元组也可以使用
元组也可以进行嵌套，对于嵌套的元组也同样要使用嵌套的循环
可以利用列表推导式，对原组进行一个转换

a = (1,2,3,4,5)
c = [b * 2 for b in a]
print(c)

原理： 将a这个元组里边的每个元素都拿出来乘以2，然后把最终的结果生成一个列表

注意：

元组是不可变的，所以试图修改元组的内容，会出现报错
英文逗号是构成元组的基本条件，对于元组来说逗号才是关键，圆括号并不是关键，逗号隔开的一组集合的数据，那么它默认就是创建了一个元组
列表推导式不可将中括号改为原括号，这个写法生成的不是元组推导式，也没有元组推导式这种东西，生成的是生成器
最好输写元组时一直都加上圆括号，不然容易产生错误，且这样做有助于代码的可读性
当定义好的数据不希望被别人修改时，就使用元组存储

1.打包和解包：

生成一个元组，也叫做元组的打包，那么对应的，将它们一次性赋值给多个变量的行为，称之为解包

a = (1,"wo",0)
x,y,z = a
print(x)
print(y)
print(z)

注意： 这种行为不仅适用于元组，也适用于任何的序列类型

#如：列表
a = [1,"wo",0]
x,y,z = a
print(x)
print(y)
print(z)

#如：字符串
a = "1","wo","0"
x,y,z = a
print(x)
print(y)
print(z)

注意： 无论使用哪一种序列的解包，都要注意赋值号左面的变量名的数量必须与右边序列的元素数量保持一致，否则，就会发生报错

2.多重赋值：

a,b = 10,20
print(a)
print(b)

它背后的实现逻辑就是先通过元组进行打包，然后再将元组进行解包

注意： 元组也并非固若金汤，元组中的元素虽然是不可变的，但如果元组中的元素是指向一个可变的列表的时候，我们是可以修改列表里面的内容的

a = [1,2,3]
b = ["wo","ai"]
c = (a,b) #用一个元组将这两个列表放进去，此时，这个元组是可以被修改的
c[0][0] = 7 #访问c元组中的第一个元素，也就是a列表，访问a列表中的第一个元素，也就是1，将其修改为7
print(c)

三：集合

集合是Python中最基本的数据类型之一，是可以存放多个多种元素的容器
集合是Python中序列的一种，是一个无序且不重复的可变序列
因为集合是无序没有顺序的，所以集合是没有下标索引的，也就是找不到这个元素的位置
定义一个空集合用set()表示，{}表示的是空字典
集合可以进行遍历

a = {1,45,3,4,56,6}
print(a) #输出的结果顺序是随机被打乱的

a = set()
print(a) #空集合

1.集合的方法与函数：

集合的常用操作方法有增加，删除和查询

一：增加

add()方法：在集合的随机位置添加一个元素

add()方法的语法格式：集合对象/变量名.add(要添加的元素)

a = {34,31,68,90,46}
a.add(77)
print(a)

注意：

当添加的元素是原集合中已有的元素时，集合不会发生任何的改变
集合会默认去重，将重复的元素给自动去除掉，不做存储
add()方法一次只能添加一个元素，不然会报错

update()方法：将序列里的元素随机存储在集合中

update()方法的语法格式：集合对象/变量名.update(要添加的序列)

a = {"wo","ai",26,52,0}
a.update((46,"ui")) #存储了元组里面的元素
print(a)
a.update([46,"ui"]) #存储了列表里面的元素
print(a)
a.update([66,[46],"ui"]) #当要存储的元素有列表时，会发生报错
print(a)
a.update((46,(520,),"ui")) #存储了元组里面的元素，包含元组这个元素
print(a)

注意：

update()方法只能是添加一个序列类型，若是添加其它的类型，会发生报错
集合里只能存储不可变的类型，如：元组就可以存储，而列表就不能存储 – 可以存储列表里面的元素，但不能存储列表这个元素

二：删除

pop()方法：随机删除最后一个元素

pop()方法的语法格式：集合对象/变量名.pop()

a = {"wo",42,68,19,"ui"}
a.pop()
print(a)

注意： 因为集合元素的位置不确定，所以不知道删除的是哪个元素

remove()方法：删除指定的元素

remove()方法的语法格式：集合对象/变量名.remove(要删除的元素)

a = {"wo",42,68,19,"ui"}
a.remove(42)
print(a)

注意： 如果remove()方法指定的那个元素不存在，那么程序会发生报错

discard()方法：删除指定的元素

discard()方法的语法格式：集合对象/变量名.discard(要删除的元素)

a = {"wo",42,68,19,"ui"}
a.discard(42)
print(a)

注意： discard()方法与remove()方法的区别在于，当discard()方法指定的那个元素不存在时，程序不会发生报错，也不会做出任何改变，只会按原集合原样输出

del销毁语句：销毁掉这个集合，释放内存空间

del语句的语法格式：del 集合对象/变量名

a = {"wo",42,68,19,"ui"}
del a
print(a)

注意： 当del已经将这个集合销毁时，再次访问输出会发生报错

clear()方法：清空集合中的所有元素，只留下空集合

clear()方法的语法格式：集合对象/变量名.clear()

a = {"wo",52,11,"ai",4.63}
a.clear()
print(a)

三：查询

len()函数：查询集合中的元素长度

a = {"wo",52,"99",("123,"),0}
print(len(a))