python基础再理解——复杂类型

Python中的复杂数据类型为多个同类型或不同类型数据提供单一表示。
根据数据之间的关系，复杂数据类型被分为三类:序列类型、集合类型和映射类型。

下面将常用类型列出来：

序列类型			集合类型	映射类型
字符串（str)	元组（tuple）	列表（list）	可变集合（set）	字典（dict）

一、序列类型

序列类型是一维元素向量元素之间存在先后关系通过序号访问。

（一）如何创建

1.字符串（str)

使用一对单引号''、双引号""和三引号''''''直接创建：

# 一对单引号
my_str_1 = '富强、民主、文明、和谐'
# 一对双引号
my_str_2 = "自由、平等、公正、法治"
# 一对三引号
my_str_3 = '''爱国、敬业、诚信、友善'''

2.元组（tuple）

用tuple()、逗号,分隔或者圆括号()圆括号是可选的进行创建：

# 使用圆括号创建一个空元组
my_tuple_empty_1 = ()
# 使用tuple()创建一个空元组
my_tuple_empty_2 = tuple()
# 创建有元素的元组
my_tuple_1 = ("富强" , "民主" , "文明" , "和谐")
# 创建有元素的元组——圆括号可以省略
my_tuple_2 = "自由" , 
# 创建有元素的元组——圆括号不能省略
my_tuple_3 = tuple(("富强" , "民主" , "文明" , "和谐"))

创建元组时需要注意的是，除非通过圆括号创建空元组，否则必须有至少一个逗号，不然会被识别为字符串类型。

3.列表（list）

用list()或者方括号[]创建列表：

# 用方括号创建一个空列表
my_list_empty_1 = []
# 用list()创建一个空列表
my_list_empty_2 = list()
# 在方括号中间放入元素进行列表创建
my_list_1 = ["爱国" , "敬业" , "诚信" , "友善"]
# 在给list()传入参数进行列表创建
my_list_2 = list(["爱国" , "敬业" , "诚信" , "友善"])

# 创建一个二维列表，即在列表中的元素也是一个列表
my_list_3 = [ [ "富强" , "民主" , "文明" , "和谐" ], ["爱国" , "敬业" , "诚信" , "友善"]]

（二）通用操作

1.支持索引

通过下标取值。
语法：序列变量名[下标值]，下标值从0开始计算，当为负数时从尾部往前计算。

# 创建一个字符串
my_str = "富强、民主、文明、和谐"
# 创建一个元组
my_tuple = "自由" , "平等" , "公正" , "法治"
# 创建列表
my_list = ["爱国" , "敬业" , "诚信" , "友善"]

# 使用下标取出字符串中第一位的元素
print(my_str[0])
# 使用下标取出元组中第一位的元素
print(my_tuple[0])
# 使用下标取出列表中倒数第一位的元素
print(my_list[-1])

# ====== 输出结果如下 ====== #
富
自由
友善

2. 支持切片

语法：序列变量名[下标开始值:下标结束值:步长值]
步长值是可以省略的，默认为1。步长值的意思就是切片区域内取值时要间隔步长值-1。
切片的下标值与索引的下标值计算方式是完全不同的！！！因为目的是对序列进行切分，那么起止值就应该是元素中间的空缺顺序。

在序列类型变量名后跟方括号，在方括号中用冒号分开写入的2个下标数值即表示进行切片取值：

# 创建一个字符串
my_str = "富强、民主、文明、和谐"
# 创建一个元组
my_tuple = "自由" , "平等" , "公正" , "法治"
# 创建列表
my_list = ["爱国" , "敬业" , "诚信" , "友善"]

# 使用2个下标值对字符串进行切片获取第2到4个元素
print(my_str[1:4])
# 使用2个下标值对元组进行切片获取第1到3个元素
print(my_tuple[0:3])
# 使用2个下标值对列表进行切片获取第3到4个元素
print(my_list[2:4])

# 传入步长值
# 使用2个下标值对字符串进行切片获取第2到4个元素
print(my_str[1:4:2])
# 使用2个下标值对元组进行切片获取第1到3个元素
print(my_tuple[0:3:2])
# 使用2个下标值对列表进行切片获取第3到4个元素
print(my_list[2:4:2])

# ====== 输出结果如下 ====== #
强、民
('自由', '平等', '公正')
['诚信', '友善']
强民
('自由', '公正')
['诚信']

3.连接两个序列

通过加号+可以连接两个序列，但需要是同一个类型。
例如：字符串只能和字符串连接。

# 字符串连接：
my_str_1 = "富强"
my_str_2 = "自由"
my_str = my_str_1 + my_str_2

# 元组连接：
my_tuple_1 = ("富强" , "民主")
my_tuple_2 = "文明" , "和谐"
my_tuple = my_tuple_1 + my_tuple_2

# 列表连接：
my_list_1 = ["公正"]
my_list_2 = ["爱国"]
my_list = my_list_1 + my_list_2 

print(my_str)
print(my_tuple)
print(my_list)

# ====== 输出结果如下 ====== #
富强自由
('富强', '民主', '文明', '和谐')
['公正', '爱国']

4.重复连接同一个序列

通过星号*可以将序列重复n次进行连接。

# 字符串连接：
my_str_1 = "富强"
my_str_2 = "自由"
my_str_1 = my_str_1 * 2
my_str_2 *= 2

# 元组连接：
my_tuple_1 = ("富强" , "民主")
my_tuple_2 = "文明" , "和谐"
my_tuple_1 = my_tuple_1 * 2
my_tuple_2 *= 2

# 列表连接：
my_list_1 = ["公正"]
my_list_2 = ["爱国"]
my_list_1 = my_list_1 * 2 
my_list_2 *= 2 

print(my_str_1)
print(my_str_2)

print(my_tuple_1)
print(my_tuple_2)

print(my_list_1)
print(my_list_2)

# ====== 输出结果如下 ====== #
富强富强
自由自由
('富强', '民主', '富强', '民主')
('文明', '和谐', '文明', '和谐')
['公正', '公正']
['爱国', '爱国']

5.检查指定元素是否存在于序列中

通过使用in可以判断元素存在的情况，当指定元素存在于序列中返回True，反之返回False。
使用not in判断元素不存在的情况，当指定元素不存在于序列中返回True，反之返回False。

_str = "民主"
my_str = "自由、平等、公正、法治"
my_tuple = ("富强" , "民主" , "文明" , "和谐")
my_list = ["爱国" , "敬业" , "诚信" , "友善"]

# 判断存在
print(_str in my_str)
print(_str in my_tuple)
print(_str in my_list)
# 判断不存在
print(_str not in my_str)
print(_str not in my_tuple)
print(_str not in my_list)

# ====== 输出结果如下 ====== #
False
True
False
True
False
True

6.计算序列长度

使用函数len()可以计算序列中元素的个数：

my_str = "自由"
my_tuple = ("富强" , "民主" )
my_list = ["爱国" , "敬业" , "诚信" ]

print(len(my_str))
print(len(my_tuple))
print(len(my_list))

# ====== 输出结果如下 ====== #
2
2
3

7.找出最大/最小元素

通过使用max()和min()函数可以找出序列中最大和最小的值。
对于字符串，是根据对应ASCII码进行元素大小计算。

max()语法如下：

max(iterable, *, key=None)
max(iterable, *, default, key=None)
max(arg1, arg2, *args, key=None)

min()语法如下：

min(iterable, *, key=None)
min(iterable, *, default, key=None)
min(arg1, arg2, *args, key=None)

以上语法中：
key 实参指定排序函数用的参数。
default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 ValueError。

my_str = "富强、民主、文明、和谐"
my_tuple = "自由" , "平等" , "公正" , "法治"
my_list = ["爱国" , "敬业" , "诚信" , "友善"]

# 找最大值
print(max(my_str))
print(max(my_tuple))
print(max(my_list))

# 找最小值
print(min(my_str))
print(min(my_tuple))
print(min(my_list))

# 使用key参数
num_list = ['哪吒','如来佛祖','猪八戒','如意金箍棒','南天门']
print(max(num_list))
print(min(num_list))
print(max(num_list,key=len))
print(min(num_list,key=len))

# 使用default参数
empty_list = []
print(max(num_list,default='没有最大值'))
print(min(num_list,default='没有最小值'))
# print(max(num_list)) # 因为empty_list为空，在没有给default的情况下会报错
# print(min(num_list)) # 因为empty_list为空，在没有给default的情况下会报错

# ====== 输出结果如下 ====== #
谐
自由
诚信
、
公正
友善
猪八戒
南天门
如意金箍棒
哪吒
猪八戒
南天门

8.计数

使用函数count()可以计算序列中元素的个数：

my_str = "富强、民主、文明、和谐"
my_tuple = ("富强" , "民主" )
my_list = ["爱国" , "敬业" , "诚信" ]

print(my_str.count('、'))
print(my_str.count('、', 3)) 
print(my_tuple.count('富'))
print(my_list.count('诚信'))

# ====== 输出结果如下 ====== #
3
2
0
1

需要注意的是字符串的count()可以传入三个参数，除了第一个目标对象，还可以传入开始索引值（默认为0）和结束索引值（默认最大值）。

9. 排序

使用sorted() 返回排序后的列表：

sorted(可遍历体, 指定排序函数, 是否反转)

指定排序函数和是否反转两个参数是可以省略的。
需要注意的是，反转是根据排序函数得出的大小进行反转，而不是将没有反转之前的结果直接反转。

my_str = "自由、平等、公正、法治"
my_tuple = ("富强民主" , "文明" , "和谐")
my_list = ["爱国敬业诚信" , "友善"]

print(sorted(my_str))
print(sorted(my_tuple))
print(sorted(my_list))

# 使用排序参数
print(sorted(my_str, key=len))
print(sorted(my_tuple, key=len))
print(sorted(my_list, key=len))

# 使用反转参数
print(sorted(my_str, key=len, reverse= True))
print(sorted(my_tuple, key=len, reverse= False))
print(sorted(my_list, key=len, reverse= False))

# ====== 输出结果如下 ====== #
['、', '、', '、', '公', '平', '正', '治', '法', '由', '等', '自']
['和谐', '富强民主', '文明']
['友善', '爱国敬业诚信']
['自', '由', '、', '平', '等', '、', '公', '正', '、', '法', '治']
['文明', '和谐', '富强民主']
['友善', '爱国敬业诚信']
['自', '由', '、', '平', '等', '、', '公', '正', '、', '法', '治']
['文明', '和谐', '富强民主']
['友善', '爱国敬业诚信']

10.遍历

使用for循环遍历本体。

# 字符串
my_str = "自由"
for item in my_str :
	print(item)
# 元组
my_tuple = ("富强民主" , "文明" , "和谐")
for item in my_tuple :
	print(item)

# 集合
my_list = ["爱国敬业诚信" , "友善"]
for item in my_list :
	print(item)

# ====== 输出结果如下 ====== #
自
由
富强民主
文明
和谐
爱国敬业诚信
友善

结合下标访问特性可以使用for循环或while循环进行通过下标遍历。

# 通过for循环遍历，while同理：
# 字符串
my_str = "自由"
for i in range(0,len(my_str)) :
	print(my_str[i])
# 元组
my_tuple = ("富强民主" , "文明" , "和谐")
for i in range(0,len(my_tuple)) :
	print(my_tuple[i])

# 集合
my_list = ["爱国敬业诚信" , "友善"]
for i in range(0,len(my_list)) :
	print(my_list[i])
	
# ====== 输出结果如下 ====== #
自
由
富强民主
文明
和谐
爱国敬业诚信
友善

11.子元素查找

index()函数返回一个目标对象所在索引位置：

index(目标对象, 开始索引位置, 结束索引位置) 

开始索引位置（默认为0）和结束索引位置（默认最大长度）可以省略这两个参数。
需要注意的是，使用index()进行索引位置获取时，如果目标对象不存在则会报错。

# 创建一个字符串
my_str = "富强、民主、文明、和谐"
# 创建一个元组
my_tuple = "自由" , "平等" , "公正" , "法治"
# 创建列表
my_list = ["爱国" , "敬业" , ["诚信" , "友善"]]

# print(my_str.index('富', 2, 5)) #只有第一个元素为富，从索引位置2开始找，找不到会报错
print(my_tuple.index("平等"))
print(my_list.index(["诚信" , "友善"]))

# ====== 输出结果如下 ====== #
1
2

（三）特有情况

1.字符串（str)

一旦生成，不可替换和删除。可以作为字典的键。

①大小写

my_str = "China"
# 将所有字符字母转大写
print(my_str.upper())
# 将所有字符字母转小写
print(my_str.lower())
# 将所有字符大小写互换
print(my_str.swapcase())
# 将首字母大写
print(my_str.capitalize())
# 若字母都是小写，则返回True，否则返回False
print(my_str.islower())
# 若字母都是大写，则返回True，否则返回False
print(my_str.isupper())

# ====== 输出结果如下 ====== #
CHINA
china
cHINA
China
False
False

②移除字符串头尾指定的字符

my_str = " www.baidu.com "

# 去除头尾的空格
print(my_str.strip())
# 去除头部的空格
print(my_str.lstrip())
# 去除尾部的空格
print(my_str.rstrip())

# 去除头尾的指定字符串
print(my_str.strip(" w.bmco"))
# 去除头部的指定字符串
print(my_str.lstrip(" w.b"))
# 去除尾部的指定字符串
print(my_str.rstrip(" mco"))

# ====== 输出结果如下 ====== #
www.baidu.com
www.baidu.com 
 www.baidu.com
aidu
aidu.com 
 www.baidu.

需要注意的是：在去除时是根据指定字符串中包含的字符进行判断，遇到不属于指定字符串中的中字符时停止。一定不要认为是要与指定字符串整体匹配才去除！！！

③分割字符串

使用split()进行字符串分割，返回分割后的列表：

split(分隔符,最大分割次数)

所有参数都可以省略
分隔符默认为空格，这儿要注意的是除非明确传入一个空格字符串作为分隔符，否则对于连续的空格会视为一个空格。
最大分割次数默认值为-1，表示全部分割。

# 创建一个字符串构成如下：
# 第一部分为：富强、民主、文明、和谐
# 第二部分为：自由、平等、公正、法治
# 第三部分为：爱国、敬业、诚信、友善
# 第一部分和第二部分用1个空格分开
# 第二部分和第三部分用连续的2个空格分开
my_str = "富强、民主、文明、和谐 自由、平等、公正、法治  爱国、敬业、诚信、友善"
# 默认根据空格进行分割，连续的空格视为一个空格
print(my_str.split())
# 指定根据空格进行分割
print(my_str.split(' '))
# 指定根据顿号进行分割
print(my_str.split('、'))
# 指定根据顿号进行分割，同时指定最大分割次数为1次
print(my_str.split('、'), 1)

# ====== 输出结果如下 ====== #
['富强、民主、文明、和谐', '自由、平等、公正、法治', '爱国、敬业、诚信、友善']
['富强、民主、文明、和谐', '自由、平等、公正、法治', '', '爱国、敬业、诚信、友善']
['富强', '民主', '文明', '和谐 自由', '平等', '公正', '法治  爱国', '敬业', '诚信', '友善']
['富强', '民主、文明、和谐 自由、平等、公正、法治  爱国、敬业、诚信、友善']

④拼接可遍历体

可以使用join() 可以拼接列表、元组、字典等可遍历体。
语法：拼接字符串.(可遍历体)

# 字符串拼接
my_str = "自由"
print('*'.join(my_str))
# 列表拼接
my_list = ["爱国" , "敬业" , "诚信" , "友善"]
print('、'.join(my_list))
# 元组拼接
my_tuple = ("富强" , "民主" , "文明" , "和谐")
print('、'.join(my_tuple))
# 可变集合拼接
my_set = {"自由", "平等", "公正", "法治"}
print('、'.join(my_set))
# 字典
my_dic = {"北京": "首都", "重庆": "山城"}
print('、'.join(my_dic))

# ====== 输出结果如下 ====== #
自*由
爱国、敬业、诚信、友善
富强、民主、文明、和谐
自由、公正、平等、法治
北京、重庆

需要注意的是：拼接字典时，是拼接的键。

⑤子元素查找

除了可以使用index()查找子元素，还可以使用find()或者rfind()进行查找。与index()的区别是，除了find()和rfind()只能用于字符串类型，更重要的区别是找不到时返回-1，而不是报错。
find()和rfind()都返回找到的第一个子元素所在起始索引位置。
区别是find()：从头至尾（从左往右）查找，rfind()：从尾往头（从右往左）查找。

find(目标对象, 开始索引位置, 结束索引位置) 
rfind(目标对象, 开始索引位置, 结束索引位置) 

开始索引位置（默认为0）和结束索引位置（默认最大长度）可以省略这两个参数。
需要注意的是，使用index()进行索引位置获取时，如果目标对象不存在则会报错。

# 创建一个字符串
my_str = "富强、民主、文明、和谐"

print(my_str.find('和')) 
print(my_str.find('和', 9)) 
print(my_str.find('和', 10)) 
print(my_str.find('和', 2, 5)) 

print(my_str.rfind('和')) 
print(my_str.rfind('和', 9)) 
print(my_str.rfind('和', 10)) 
print(my_str.rfind('和', 2, 5)) 

# ====== 输出结果如下 ====== #
9
9
-1
-1
9
9
-1
-1

需要注意的是：find()或者rfind()只影响查找的方向，不影响传入开始索引位置和结束索引位置两个参数。

⑥字符串替换

可以使用replace() 对字符串进行指定内容替换后返回新的字符串。
语法：字符串.replace(字符串中子字符串, 准备用来替换的字符串, 最大替换次数)
最大替换次数：这个参数可以省略，默认值为-1，表示全部替换。当传入指定次数时，表示最大替换这个传入的次数就停止替换了。

my_str = "富强、民主、文明、和谐"

print(my_str.replace("、", "|"))
print(my_str.replace("、", "|", 1))

# ====== 输出结果如下 ====== #
富强|民主|文明|和谐
富强|民主、文明、和谐

⑦比较大小

字符串之间可以用使用'<'、'<='、'>'、'>='、'=='、'!='比较大小比较大小，按照ascii码进行比较。比较的逻辑是，从开头至尾部逐个字符进行ascii码大小比较，当能区分大小时则返回当前比较结果，后面的字符就忽略了。

my_str_1 = 'abc'
my_str_2 = 'b'

print(my_str_2 > my_str_1)

# ====== 输出结果如下 ====== #
True

2.元组（tuple）

一旦生成，不可替换和删除。可以作为字典的键。

1.删除元组

可以使用del的来删除整个元组。

my_tuple = "富强" , "民主" , "文明" , "和谐"
del my_tuple
# 因为已经使用del删除了my_tuple这个元组，再打印就会报错
print(my_tuple)

2.求和

可以使用sum()对其中的所有元素进行求和。
语法：sum(可迭代对象,初始值)
初始值这个参数可以省略，默认为0。

my_tuple = 1,2,3
print(sum(my_tuple))
print(sum(my_tuple, 100))

# ====== 输出结果如下 ====== #
6
106

3.列表（list）

不能作为字典的键，不能是集合的元素。

（1）添加元素

①append()

可以使用append() 向列表末尾添加元素。
语法：列表.append(添加元素)
添加元素：可以是任何类型，但要注意的是当使用列表、字典这种引用类型作为添加元素时添加的是地址。所以添加后在原地址上的元素发生变化列表中添加的这个元素也会发生变化。

my_list_1 = ["爱国" , "敬业"]
my_list_2 = ["富强" , "民主"]
print(id(my_list_2))
# 添加字符串到列表结尾
my_list_1.append("诚信")
print(my_list_1)
my_list_1.append(my_list_2)
print(my_list_1)
my_list_2.append("文明")
print(id(my_list_2))
print(my_list_1)
my_list_2=['自由']
print(id(my_list_2))
print(my_list_1)

# ====== 输出结果如下 ====== #
1994126666440
['爱国', '敬业', '诚信']
['爱国', '敬业', '诚信', ['富强', '民主']]
1994126666440
['爱国', '敬业', '诚信', ['富强', '民主', '文明']]
1994120905544
['爱国', '敬业', '诚信', []]

②insert()

可以使用insert()将一个元素添加到指定索引位置。如果指定索引位置不存在，则将新元素添加到列表结尾。
语法：列表.insert(索引位置, 添加的元素)

my_list_1 = ["爱国" , "敬业"]
my_list_2 = ["富强" , "民主"]
print(id(my_list_2))
# 添加字符串到列表结尾
my_list_1.insert(0,"诚信")
print(my_list_1)
my_list_1.insert(10,my_list_2)
print(my_list_1)
my_list_2.insert(1,"文明")
print(id(my_list_2))
print(my_list_1)
my_list_2=['自由']
print(id(my_list_2))
print(my_list_1)

# ====== 输出结果如下 ====== #
1994126666056
['诚信', '爱国', '敬业']
['诚信', '爱国', '敬业', ['富强', '民主']]
1994126666056
['诚信', '爱国', '敬业', ['富强', '文明', '民主']]
1994120905544
['诚信', '爱国', '敬业', []]

③extend()

可以使用extend()将一个列表中的元素逐个添加到目标列表中。
语法：目标列表.insert(添加的列表)

my_list_1 = ["爱国" , "敬业"]
my_list_2 = ["富强" , "民主"]

my_list_1.extend(my_list_2)

# ====== 输出结果如下 ====== #
['爱国', '敬业', '富强', '民主']

（2）修改列表

①通过下标修改元素

语法：列表[索引位置值]=新的元素值。需要注意索引位置值不能越界，即最大值只能是列表长度-1。

my_list = ["爱国" , "敬业" , "诚信" , "友善"]
my_list[0] = '平等'
my_list[len(my_list) - 1] = '法治'
print(my_list)

# ====== 输出结果如下 ====== #
['平等', '敬业', '诚信', '法治']

②反转列表元素

语法：列表.reverse()
需要注意索引位置值不能越界，即最大值只能是列表长度-1。

my_list = ["富强" , "民主" , "文明" , "和谐"]
my_list.reverse()
print(my_list)
my_list.reverse()
print(my_list)

# ====== 输出结果如下 ====== #
['和谐', '文明', '民主', '富强']
['富强', '民主', '文明', '和谐']

③对列表进行排序

可以使用sort()对列表进行排序。
语法：列表.sort(key = 排序函数, reverse = 是否反转)
排序函数和是否反转两个参数都可以省略。

my_list = ["爱国 , 敬业" , "诚信友善"]
my_list.sort()
print(my_list)

my_list.sort(key = len)
print(my_list)

my_list.sort(key = len, reverse = False)
print(my_list)
my_list.sort(key = len, reverse = True)
print(my_list)

# ====== 输出结果如下 ====== #
['爱国 , 敬业', '诚信友善']
['诚信友善', '爱国 , 敬业']
['诚信友善', '爱国 , 敬业']
['爱国 , 敬业', '诚信友善']

（2）删除

①清空列表

可以使用clear()清空列表。注意不能直接给列表变量名赋值[]清空，因为这会重新创建一个列表而不是清空原有列表。
语法：列表.clear()

my_list = ["爱国 , 敬业" , "诚信友善"]
my_list.clear()
print(my_list)

# ====== 输出结果如下 ====== #
[]

② 删除指定下标元素并返回

可以使用pop()删除指定下标元素并返回。需要注意索引位置值不能越界，即最大值只能是列表长度-1。
语法：列表.pop(索引位置值)
索引位置值可以省略，默认值为-1。

my_list = ["爱国", "敬业", "诚信", "友善"]
my_list.pop()
print(my_list)
my_list.pop(0)
print(my_list)
my_list.pop(1)
print(my_list)

# ====== 输出结果如下 ====== #
['爱国', '敬业', '诚信']
['敬业', '诚信']
['敬业']

③删除指定元素

可以使用remove() 删除列表中的指定元素。
语法：列表.remove(指定元素)

my_list = ["自由", "平等", "公正", "法治"]
my_list.remove("自由")
print(my_list)
# my_list.remove("敬业") # 如果指定的元素不存在于列表中会报错

# ====== 输出结果如下 ====== #
['平等', '公正', '法治']

④删除元素或者列表

可以使用del删除列表中的指定元素或者整个列表。
语法：del 列表[起始索引号:结束索引号:步长值]
[起始索引号:结束索引号:步长值]：这部分就是切分的语法，可以省略，即表示删除整个列表。

my_list = ["富强" , "民主" , "文明" , "和谐"]
del my_list[1:2]
print(my_list)
del my_list
# print(my_list) #因为my_list已经被删除了，打印就会报错

# ====== 输出结果如下 ====== #
['富强', '文明', '和谐']

（3）其他

①判断

可以用双等号(==)判断两个列表是否相同。

my_list_1 = ["富强" , "民主" , "文明" , "和谐"]
print(id(my_list_1))
my_list_2 = ["富强" , "民主" , "文明"]
print(id(my_list_2))
my_list_2.append("和谐")
print(id(my_list_2))
print(my_list_1 == my_list_2)

my_list_1.insert(0, '中国')
my_list_2.insert(1, '中国')
print(my_list_1 == my_list_2)

# ====== 输出结果如下 ====== #
1994125740296
1994125731400
1994125731400
True
False

②复制列表

通过append()和insert()两个方法的使用，我们发现当把一个列表作为元素添加后如果改变列表会影响已经添加的元素。
为了避免这个情况我们就可以使用copy()复制列表中所有的元素生成一个新列表，但要注意的是这种方法只能复制第一层级（浅复制）。

my_list = ["富强" , "民主" , "文明" , "和谐"]
print(id(my_list))
my_list_copy = my_list.copy()
print(id(my_list_copy))
print(my_list_copy)

# 演示一下浅复制
my_list_1 = ["富强","民主"]
my_list_2 = ["文明","和谐"]
my_list_3 = [my_list_1,my_list_2]
# 创建一个列表，其中放置一个字符串元素和一个二维列表
my_list_4 = ["自由",my_list_3]
print(my_list_4)
# 删除二维列表中的尾部元素
my_list_2.pop()
print(my_list_4)
# 将列表进行浅复制
my_list_4_copy = my_list_4.copy()
my_list_2.pop()
print(my_list_4_copy)
my_list_4.pop(0)
print(my_list_4_copy)
print(my_list_4)

# ====== 输出结果如下 ====== #
1994125731656
1994125741000
['富强', '民主', '文明', '和谐']
['自由', [['富强', '民主'], ['文明', '和谐']]]
['自由', [['富强', '民主'], ['文明']]]
['自由', [['富强', '民主'], []]]
['自由', [['富强', '民主'], []]]
[[['富强', '民主'], []]]

③求和

可以使用sum()对其中的所有元素进行求和。
语法：sum(可迭代对象,初始值)
初始值这个参数可以省略，默认为0。

my_list =[1,2,3]
print(sum(my_list))
print(sum(my_list, 100))

# ====== 输出结果如下 ====== #
6
106

二、集合类型

（一）可变集合（set）

集合（set）是一个可变的无序的不重复元素序列。集合里不能有列表、字典等可变数据作为元素，不支持索引。

1.创建

使用set()直接创建或者使用大括号{}，但不能用s={}创建空可变集合，因为这样创建的是字典。

# 创建空可变集合，只能使用set
my_set_empty = set()
# 使用set，要添加的元素使用{}包起来
my_set_1 = set({"自由", "平等", "公正", "法治"})
# 使用set，要添加的元素使用()包起来
my_set_2 = set(("爱国", "敬业", "诚信", "友善"))
# 使用大括号
my_set_3 = {'富强', '民主', '文明', '和谐'}
print(type(my_set_empty))
print(my_set_empty)
print(type(my_set_1))
print(my_set_1)
print(type(my_set_2))
print(my_set_2)
print(type(my_set_3))
print(my_set_3)

# ====== 输出结果如下 ====== #
<class 'set'>
set()
<class 'set'>
{'自由', '公正', '平等', '法治'}
<class 'set'>
{'爱国', '敬业', '诚信', '友善'}
<class 'set'>
{'富强', '文明', '民主', '和谐'}

2.修改

（1）添加单个元素

可以使用add()添加单个元素。
语法：集合.add(单个元素)

my_set = set()
my_set.add("爱国")
print(my_set)

# ====== 输出结果如下 ====== #
{'爱国'}

（2）添加多个元素

可以使用update()添加多个元素，可以同时传入多个参数，但每个参数都需要是可遍历类型。
语法：列表.update(元素1,元素2...)

my_set = set()
my_set.update("爱国")
print(my_set)
my_set.update(["敬业", "诚信"])
print(my_set)

# ====== 输出结果如下 ====== #
{'爱', '国'}
{'爱', '诚信', '国', '敬业'}

3.删除

# 创建空可变集合，只能使用set
my_set_empty = set()
# 使用set，要添加的元素使用{}包起来
my_set_1 = set({"自由", "平等", "公正", "法治"})
# 使用set，要添加的元素使用()包起来
my_set_2 = set(("爱国", "敬业", "诚信", "友善"))

my_set_1.remove("自由")
print(my_set_1)
my_set_1.discard("平等")
print(my_set_1)
my_set_1.pop()
print(my_set_1)
my_set_1.clear() 
print(my_set_1)

# ====== 输出结果如下 ====== #
{'公正', '平等', '法治'}
{'公正', '法治'}
{'法治'}
set()

要注意的是：remove()删除元素不存在会报错，discard()则不会。

（3）返回排序后的列表

使用sorted() 返回排序后的列表，具体语法等可以参照上面写过的。

my_set = {"敬业", "诚信", "中国人"}

print(sorted(my_set))

# 使用排序参数
print(sorted(my_set, key=len))

# 使用反转参数
print(sorted(my_set, key=len, reverse= True))

# ====== 输出结果如下 ====== #
['中国人', '敬业', '诚信']
['诚信', '敬业', '中国人']
['中国人', '诚信', '敬业']

4.其他

1.检查指定元素是否存在于集合中

语法内容可以参照上面写过的in和not in。

my_set = {"富强" , "民主" , "文明" , "和谐"}
_str = "富强"
# 判断存在
print(_str in my_set)
# 判断不存在
print(_str not in my_set)

# ====== 输出结果如下 ====== #
True
False

2.计算集合长度

使用函数len()可以计算集合中元素的个数：

my_set = {"爱国" , "敬业" , "诚信" , "友善"}
print(len(my_set))

# ====== 输出结果如下 ====== #
4

3.找出最大/最小元素

通过使用max()和min()函数可以找出集合中最大和最小的值。具体语法可以参照上面写过的。

my_set = {'哪吒','如来佛祖','猪八戒','如意金箍棒','南天门'}

# 找最大值
print(max(my_set))

# 找最小值
print(min(my_set))

# 使用key参数
print(max(my_set, key=len))
print(min(my_set, key=len))

# 使用default参数
my_set_empty = set()
print(max(my_set_empty, default='没有最大值'))
print(min(my_set_empty, default='没有最小值'))
# print(max(my_set_empty)) # 因为my_set_empty为空，在没有给default的情况下会报错
# print(min(my_set_empty)) # 因为my_set_empty为空，在没有给default的情况下会报错

# ====== 输出结果如下 ====== #
猪八戒
南天门
如意金箍棒
哪吒
没有最大值
没有最小值

4.求和

可以使用sum()对其中的所有元素进行求和。
语法：sum(可迭代对象,初始值)
初始值这个参数可以省略，默认为0。

my_set = {1,2,3}
print(sum(my_set))
print(sum(my_set, 100))

# ====== 输出结果如下 ====== #
6
106

5.遍历

使用for循环遍历本体。

my_tuple = {"富强", "民主", "文明", "和谐"}

for item in my_tuple :
	print(item)

# ====== 输出结果如下 ====== #
自
由
富强民主
文明
和谐
爱国敬业诚信
友善

需要注意的是：因为可变集合不支持下标访问，所以for循环只能通过遍历本体进行。

6.判断集合的关系

可以通过使用<、<=、>、>=、==、!=判断两个集合的关系。

my_set_all = {"富强", "民主", "文明", "和谐"}
my_set_1 = {"富强", "民主", "文明"}
# 当为真时：my_set_1是my_set_all的真子集，等同于my_set_all真包含my_set_1
print(my_set_1 < my_set_all)
# 当为真时：my_set_1是my_set_all的子集，等同于my_set_all包含my_set_1
print(my_set_1 <= my_set_all)
my_set_2 = {"富强", "民主", "文明"}
# 当为真时：my_set_1与my_set_2相同
print(my_set_1 == my_set_2)
my_set_3 = {"文明", "和谐"}
# 当为真时：my_set_1与my_set_3不相同
print(my_set_1 != my_set_3)

# ====== 输出结果如下 ====== #
True
True
True
True

7.浅复制

语法内容可以参考列表部分写过的copy()。

my_set = ["自由", "平等", "公正", "法治"]
print(id(my_set))
my_set_copy = my_set.copy()
print(id(my_set_copy))
print(my_set_copy)

# ====== 输出结果如下 ====== #
1994125731400
1994126851208
['自由', '平等', '公正', '法治']

需要注意的是，copy()是浅复制，关于浅复制也可以参考上面列表部分已经写过。

8.判断是否有相同元素

可以使用isdisjoint()判断两个集合是否包含相同的元素，如果没有返True ,否则返回False。
语法：集合.isdisjoint(另一个集合)

my_set_all_1 = {"富强", "民主", "文明", "和谐"}
my_set_1 = {"富强", "民主", "文明"}
my_set_all_2 = {"爱国" , "敬业" , "诚信" , "友善"}
print(my_set_all_1.isdisjoint(my_set_1))
print(my_set_1.isdisjoint(my_set_all_1))
print(my_set_1.isdisjoint(my_set_all_2))

# ====== 输出结果如下 ====== #
False
False
True

9.集合运算

①差集

my_set_all_1 = {"富强", "民主", "文明", "和谐"}
my_set_1 = {"富强", "民主"}
my_set_2 = {"文明"}

# 求差集
print(my_set_all_1 - my_set_1)
print(my_set_1 - my_set_all_1)
print(my_set_all_1.difference(my_set_1))
print(my_set_1.difference(my_set_all_1))

# 将my_set_all_1更新为和my_set_1的差集
my_set_all_1 -= my_set_1
print(my_set_all_1)
# 将my_set_all_1更新为和my_set_2的差集
my_set_all_1.difference_update(my_set_2)
print(my_set_all_1)

# ====== 输出结果如下 ====== #
{'文明', '和谐'}
set()
{'文明', '和谐'}
set()
{'文明', '和谐'}
{'和谐'}

②交集

my_set_all = {"自由", "平等", "公正", "法治"}
my_set_1 = {"平等", "公正", "法治"}
my_set_2 = {"公正", "法治"}

# 求交集
print(my_set_all & my_set_1)
print(my_set_1 & my_set_all)
print(my_set_all.intersection(my_set_1))
print(my_set_1.intersection(my_set_all))

# 将my_set_all更新为和my_set_1的交集
my_set_all &= my_set_1
print(my_set_all)
# 将my_set_all更新为和my_set_2的交集
my_set_all.intersection_update(my_set_2)
print(my_set_all)

# ====== 输出结果如下 ====== #
{'平等', '公正', '法治'}
{'平等', '公正', '法治'}
{'平等', '公正', '法治'}
{'平等', '公正', '法治'}
{'平等', '公正', '法治'}
{'公正', '法治'}

③并集

my_set_1 = {"爱国" , "敬业"}
my_set_2 = {"诚信" , "友善"}
my_set_3 = {"公正", "法治"}
print(my_set_1|my_set_2)
print(my_set_1.union(my_set_2))
print(my_set_1)
print(my_set_2)

# 将my_set_1更新为和my_set_2的并集
my_set_1 |= my_set_2
print(my_set_1)

# 将my_set_1更新为和my_set_3的并集
my_set_1.update(my_set_3)
print(my_set_1)

# ====== 输出结果如下 ====== #
{'爱国', '敬业', '诚信', '友善'}
{'爱国', '敬业', '诚信', '友善'}
{'爱国', '敬业'}
{'诚信', '友善'}
{'爱国', '敬业', '诚信', '友善'}
{'敬业', '诚信', '公正', '爱国', '法治', '友善'}

④对称差集

my_set_1 = {"民主", "文明"}
my_set_2 = {"富强", "民主"}
my_set_3 = {"富强", "民主", "文明"}

# 求对称差集
print(my_set_1 ^ my_set_2)
print(my_set_2 ^ my_set_1)
print(my_set_1.symmetric_difference(my_set_2))
print(my_set_2.symmetric_difference(my_set_1))

# 将my_set_1更新为和my_set_2的对称差集
my_set_1 ^= my_set_2
print(my_set_1)
# 将my_set_3更新为和my_set_2的对称差集
my_set_3.symmetric_difference_update(my_set_2)
print(my_set_3)

# ====== 输出结果如下 ====== #
{'富强', '文明'}
{'文明', '富强'}
{'富强', '文明'}
{'文明', '富强'}
{'文明', '富强'}
{'文明'}

⑤判断包含关系

可以使用issubset() 判断集合1是否是集合2的子集，如果是则返回True，否则返回False。
语法：集合1<=集合2或者集合1.issubset(集合2)
可以使用issuperset() 判断集合1是否包含集合2，如果是则返回True，否则返回False。
语法：集合1>=集合2或者集合1.issuperset(集合2)

my_set_all_1 = {"富强", "民主", "文明", "和谐"}
my_set_1 = {"民主", "文明"}

# 判断my_set_1是否是my_set_all_1的子集
print(my_set_1 <= my_set_all_1)
print(my_set_1.issubset(my_set_all_1))

# 判断my_set_all_1是否包含my_set_1
print(my_set_all_1 >=my_set_1)
print(my_set_all_1.issuperset(my_set_1))

# ====== 输出结果如下 ====== #
True
True
True
True

一、映射类型

（一）字典（dict）

字典每个元素是由键值对构成的，元素之间是无序的，无法通过下标来访问。由于每个键都与一个值对应，所以一般是通过键查找对应的值。正因为有这种对应关系，所以字典也被称为映射类型，而不是序列类型。

1.创建和访问

可以用大括号{}或者dict()来创建字典。
可以通过键访问，语法：字典[键]。如果键不在字典中，会报错。
可以使用get()访问，语法：字典.get(键,默认值)。如果键不在字典中，返回默认值（可省略），不给默认值则返回None。

# 创建空字典
my_dict_empty_1 = {}
my_dict_empty_2 = dict()

# 创建有元素的字典，键和值用冒号分开，元素用逗号分开
my_dict_1 = {"城市" : "黑龙江", "地理位置" : "北方"}
my_dict_2 = dict({"国家": "中国", "地理位置" : "东方"})

# 通过语法糖创建
my_dict_3 = dict(姓名='张三', 国籍="中国")

# 通过zip函数将两个列表中的元素进行组合，前面的列表元素为键，后面的列表元素为值
my_dict_4 = dict(zip(["书籍名","作者"],["三体","刘慈欣"]))

# 通过键访问
print(my_dict_1["城市"])
# print(my_dict_1["天气"]) # 因为天气这个键不存在于字典中，所以会报错

# 使用get()访问
print(my_dict_1.get("城市"))
print(my_dict_1.get("城市","城市信息暂未提供"))
print(my_dict_1.get("天气"))
print(my_dict_1.get("天气","天气信息暂未提供"))
print(my_dict_1)

# ====== 输出结果如下 ====== #
黑龙江
黑龙江
黑龙江
None
天气信息暂未提供
{'城市': '黑龙江', '地理位置': '北方'}

2.修改

my_dict = dict({"国家": "中国", "天气" : "晴"})

# 通过键直接修改对应值
my_dict["天气"] = "雨"
print(my_dict)

# 用列表更新
my_dict.update([("天气","阴")])
print(my_dict)

# 用字典更新
my_dict.update({"地理位置":"东方"})
print(my_dict)

# setdefault() 获取字典中指定键对应的值。如果该键不存在，则会向字典中添加该键并设对应的值为默认值。
print(my_dict.setdefault("天气","暂无天气信息"))
my_dict.setdefault("语言","中文")
print(my_dict)

# ====== 输出结果如下 ====== #
{'国家': '中国', '天气': '雨'}
{'国家': '中国', '天气': '阴'}
{'国家': '中国', '天气': '阴', '地理位置': '东方'}
阴
{'国家': '中国', '天气': '阴', '地理位置': '东方', '语言': '中文'}

3.删除

# 创建空可变集合，只能使用set
my_dict_1 = {"城市" : "黑龙江", "地理位置" : "北方"}
my_dict_2 = dict({"国家": "中国", "地理位置" : "东方"})

# 根据主键找到元素进行删除
del my_dict_1["城市"]
print(my_dict_1)

# 根据主键找到元素进行删除，下面第二个参数是可选的
# 关于第二个参数传入后，当主键不存在则显示该值，如果不传入，则当指定主键不存在时会报错
my_dict_1.pop("地理位置")
print(my_dict_1)
print(my_dict_1.pop("地理位置","不存在位置信息"))

# 清空所有元素
my_dict_2.clear() 
print(my_dict_2)

# ====== 输出结果如下 ====== #
{'地理位置': '北方'}
{}
不存在位置信息
{}

4.其他

1.计算字典长度

使用函数len()可以计算字典中元素的个数：

my_dict = dict({"国家": "中国"})
print(len(my_dict))

# ====== 输出结果如下 ====== #
1

2.返回排序后的键列表

使用sorted() 返回排序后键列表，具体语法等可以参照上面写过的。

my_dict = {"城市" : "黑龙江", "地理位置" : "北方"}

print(sorted(my_dict))

# 使用排序参数
print(sorted(my_dict, key=len))

# 使用反转参数
print(sorted(my_dict, key=len, reverse= True))

# ====== 输出结果如下 ====== #
['地理位置', '城市']
['城市', '地理位置']
['地理位置', '城市']

3.获取字典中所有键、值

可以使用keys()获取字典中的所有键，使用values()获取字典中的所有值。

my_dict = {"城市" : "黑龙江", "地理位置" : "北方", "天气" : "晴"}

my_dict_keys = my_dict.keys()
my_dict_values = my_dict.values()

# 转换为列表
my_dict_key_list = list(my_dict_keys)
my_dict_value_list = list(my_dict_values)
print(my_dict_key_list)
print(my_dict_value_list)

# 转换为元组
my_dict_key_tuple = tuple(my_dict_keys)
my_dict_value_tuple = tuple(my_dict_values)
print(my_dict_key_tuple)
print(my_dict_value_tuple)

# ====== 输出结果如下 ====== #
['城市', '地理位置', '天气']
['黑龙江', '北方', '晴']
('城市', '地理位置', '天气')
('黑龙江', '北方', '晴')

4.遍历

使用for循环遍历本体。

my_dict = {"城市" : "黑龙江", "地理位置" : "北方", "天气" : "晴"}

for key in my_dict :
	print(key) # 遍历键
	print(my_dict[key]) # 通过中括号使用键访问值

# ====== 输出结果如下 ====== #
城市
黑龙江
地理位置
北方
天气
晴

需要注意的是：因为字典不支持下标访问，所以for循环只能通过遍历本体进行。

5.检查指定元素是否存在于序列中

通过使用in可以判断键存在的情况，当指定键存在于序列中返回True，反之返回False。
使用not in判断键不存在的情况，当指定键不存在于序列中返回True，反之返回False。

_str = "城市"
my_dict = {"城市" : "黑龙江", "地理位置" : "北方", "天气" : "晴"}

# 判断存在
print(_str in my_dict)
# 判断不存在
print(_str not in my_dict)

# ====== 输出结果如下 ====== #
True
False

6.

使用双等号(==)或不等号(!=)可以判断两个字典是否相同。