一、基本数据类型

1、数字

2、布尔值

3、字符串

字符串的元素不能被修改，而且元素类型比较单一。

3.1、字符串遍历

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time: 2021/5/9 下午 9:16
# @File: practice2.py
# @Software: PyCharm
# 字符串遍历方式一
my_str = 'hello world'
for v in my_str:
    print(v, end=' ')
print(end='\n')
# 字符串遍历方式二
# 涉及到索引（索引从0开始）、字符串长度
i = 0
while i < len(my_str):
    print(my_str[i], end=' ')
    i = i+1

3.2、字符串去除空格

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time: 2021/5/9 下午 8:39
# @File: practice1.py
# @Software: PyCharm

# 字符串去除空格
my_str = ' hello world '
print(my_str)
if ' ' in my_str:
    # 去除字符串中所有的空格，包括头尾中间的空格 .replace(' ', '')
    print(my_str.replace(' ', ''))
    # 去除字符串头尾两侧的空格
    print(my_str.strip())
else:
    print(my_str)
    print(end='#')

3.3、字符串替换

关于 string 的 replace 方法，需要注意 replace 不会改变原 string 的内容。
replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数count，则替换不超过count 次， count为一个数字，表示次数。
语法：str.replace(‘old’, ‘new’, count)

my_str = 'hello world'
my_new_str1 = my_str.replace('h', 'Happy ', 1)
my_new_str2 = my_str.replace(my_str, 'wonderful')
print(my_new_str1)
print(my_new_str2)

3.4、查找子字符串

语法：.find(‘子串’)

my_str = 'hello world'
if my_str.find('world'):
    print('True')
else:
    print('False')

3.5、字符串的切片

语法：my_str[i1:i2:步长]
说明：i1:i2指的是索引的start、end，左闭右开。
索引也分为正索引和负索引，因为涉及执行效率的问题，我们会根据实际情况取使用正索引还是负索引，比如想要获取最后一部分的字符串，那么肯定是使用负索引效率会高一些。

索引只是用来找到字符的位置，截取取值范围。

①起始值start不写，表示从无穷开始（如果步长为正数，则start为负无穷；如果步长为负数，则start为正无穷）；
结束值end不写，表示到无穷（如果步长为正数，则end为正无穷；如果步长为负数，则end为负无穷）；两个都不写，表示取全部。
②步长：步长n，每n个取顺序的第一个，如果是负数的话，则表示逆序取。如my_str[::-1]，表示的是获取反向字符串。如果步长没写，就默认指定步长为1。

# 原字符串
my_str = '0123456789'
# 截取字符串的全部字符
str1 = my_str[:] # str1 = 0123456789
print('str1 =', str1)
# 获取与原字符串顺序相反的字符串
str2 = my_str[::-1] # str2 = 9876543210
print('str2 =', str2)
# 截取第1位到第3位的字符
str3 = my_str[0:3] # str3 = 012
print('str3 =', str3)
# 截取第7个字符到结尾
str4 = my_str[6:] # str4 = 6789
print('str4 =', str4)
# 截取从头开始到倒数第3个字符之前的子字符串
str5 = my_str[:-3] # str5 = 0123456
print('str5 =', str5)
# 截取第3个字符
str6 = my_str[2] # str6 = 2
print('str6 =', str6)
# 截取倒数第1个字符
str7 = my_str[-1] # str7 = 9
print('str7 =', str7)
# 截取倒数第3位与倒数第1位之前的字符
str8 = my_str[-3:-1] # str8 = 78
print('str8 =', str8)
# 截取倒数第3位到结尾
str9 = my_str[-3:] # str9 = 789
print('str9 =', str9)
"""
步长为负数，表示逆序截取， 需索引start>end, 否则取到的子字符串为空。
①start为空时，默认为正无穷。
比如：my_str[:-5:-3]。
[:-5]表示索引从正无穷到-5，截取字符串到索引为-5的后1个字符（左闭右开，取不到索引为-5的那位，即5），即最终截取了6789,
然后步长为-3，即逆向每3位取第1位，分别取到9和6。
②end为空时，默认为负无穷。
比如：my_str[3::-1]。
[3:]表示从索引为3的位置，即字符3，往左取值，最后截取0123，
然后步长为-1，即逆向每1位取1位，即取到3210。
③start< end，取到为空。
"""
# ①start为空时，默认为正无穷
str10 = my_str[:-5:-3]  # str10 = 96
print('str10 =', str10)
str11 = my_str[:5:-1]   # str11 = 9876
print('str11 =', str11)
# ②end为空时，默认为负无穷
str12 = my_str[3::-1]  # str12 = 3210
print('str12 =', str12)
# ③start< end，取到为空。
str13 = my_str[0:3:-1]  # str13 = 
print('str13 =', str13)

"""
步长为正数时，表示顺序截取，需start < end，否则取到的字符串为空。
①Start为空，默认为负无穷 。
比如：my_str[:5:2]。
[:5]表示负无穷取到索引4的位置，截取01234，
步长2表示每2个取第1个，则最后取到024。
②End为空，默认为正无穷。
比如：my_str[-5::1]
[-5:]表示从字符串倒数第5位取到最后一位，即56789，
步长为1，即最后截取的字符串为56789
③start>end，取到为空。
"""
# ①Start为空，默认为负无穷
str14 = my_str[:5:2]  # str14 = 024
print('str14 =', str14)
# ②End为空，默认为正无穷
str15 = my_str[-5::1]  # str15 = 56789
print('str15 =', str15)
# ③start>end，取到为空
str16 = my_str[5:3:1]   # str16 = 
print('str16 =', str16)

运行后对应的结果为：

str1 = 0123456789
str2 = 9876543210
str3 = 012
str4 = 6789
str5 = 0123456
str6 = 2
str7 = 9
str8 = 78
str9 = 789
str10 = 96
str11 = 9876
str12 = 3210
str13 = 
str14 = 024
str15 = 56789
str16 = 

3.6、判断字符串中所有的元素是否为字母

isalpha()

my_str = 'abc012345'
# 判断字符串中所有元素是否为字母
str17 = my_str.isalpha()
print(str17)  # False

3.7、判断字符串中所有的元素是否为数字

isdigit()

my_str = 'abc012345'
# 判断字符串中所有元素是否为数字
str18 = my_str.isdigit()
print(str18)   # False

3.8、判断字符串中是否只包含字母、数字

# 判断字符串是否只包含字母、数字
my_str = 'abc012345'
str19 = my_str.isalnum()
print(str19)   # True

3.9、判断字符串是否符合标识符格式，由字母、数字、下划线组成，不能以数字开头

# 判断字符串是否符合标识符格式，由字母、数字、下划线组成，不能以数字开头
my_str = '_012345'
str20 = my_str.isidentifier()
print(str20)   #True

3.10、字符串之expandtabs()

字符串的.expandtabs(n)，相当于断句，遇到\t制表符的时候，就进行断句，不够n 个的就用空格补齐。可以用来将字符串按照表格的形式展示出来。

# 原字符串
user = 'username\tpassword\temail\nzsan\tabc123\tzsan@163.com\nlisi\tabc123\tlisi@163.com\nwwu\tabc123\twwu@163.com\n'
v = user.expandtabs(20)
print(v)

输出结果为：

username            password            email
zsan                abc123              zsan@163.com
lisi                abc123              lisi@163.com
wwu                 abc123              wwu@163.com

3.11、字符串的其它方法

my_str = 'abc012345'
# 判断字符串中所有元素是否为字母。isalpha()
str17 = my_str.isalpha()
print(str17)  # False
# 判断字符串中所有元素是否为数字。isdigit()
str18 = my_str.isdigit()
print(str18)   # False
# 判断字符串是否只包含字母、数字。isalnum()
str19 = my_str.isalnum()
print(str19)   # True
# 判断字符串是否符合标识符格式，由字母、数字、下划线组成，不能以数字开头。isidentifier()
my_str = '_012345'
str20 = my_str.isidentifier()
print(str20)

# 判断字符串是否存在不可显示的字符(\n  \t),如果存在，则为False，如果不存在，则为True。 isprintable()

my_str = 'username\tpassword\t'
v = my_str.isprintable()
print(v)

# 判断字符串是否全部是空格，如果是的话，为True，如果只是包含空格同时有其它字符，那么为False。   isspace()
test = '     '
i = test.isspace()
print(i)

test1 = 'abc  123'
a = test1.isspace()
print(a)

# 判断是否是标题，每个字符首字母都是大写  istitle()

test = 'Hello world'
v1 = test.istitle()
print(v1)
v2 = test.title()   # 把字符串转成标题
print(v2)
v3 = v2.istitle()
print(v3)

# 将字符串中的每个字符按照指定分隔符进行拼接。'指定的分隔符'.join(字符串)

test = '花店不开了花还继续开'
v = '_'.join(test)
print(v)
# 相当于 for循环一个个去遍历
for i in test:
    print(i, '_', end='')
print(end='\n')
# 设置宽度，并将内容居中。 center(n, '要填充的字符')

test = '用户名'
i = test.center(10, '*')
print(i)

# 设置宽度，在字符串右边进行空白未知填充。 ljust(n, '指定字符')
test = '用户名'
i = test.ljust(20, '！')
print(i)
# 设置宽度，在字符串左边进行空白未知填充。 rjust(n, '指定字符')
test = '用户名'
i = test.rjust(20, '！')
print(i)

# 判断字符串是否都是小/大写。 islower()  isupper()

test = 'Apple'
i1 = test.islower()
i2 = test.isupper()
print(i1, i2)
# 将字符串转成小/大写。 lower()  upper()  举例：在网站上输验证码，不管输入大小写都可以。就是将用户所输入的都转换成小写或者大写
v1 = test.lower()
v2 = test.upper()
print(v1, v2)
t1 = v1.islower()
t2 = v2.isupper()
print(t1, t2)

# 去除字符串的空格。
# strip()：去除字符串左右两边的空白，包括空格、换行\n、制表符\t。
# lstrip(): 去除字符串左边的空白，包括空格、换行\n、制表符\t。
# rstrip(): 去除字符串右边的空白，包括空格、换行\n、制表符\t。
# 如果带参数，也可以去掉指定的字符
test = '  account   '
v1 = test.strip()
print(v1)
v2 = test.lstrip()
print(v2)
v3 = test.rstrip()
print(v3)

# 创建对应关系。maketrans()
v = 'asdiduhhmfklfloejhfkf'
k = str.maketrans('aeiou', '12345')
# 按照对应关系，翻译获取字符串。 translate()
new_v = v.translate(k)
print(new_v)

# 根据找到的第一个字符，进行字符串分割，包含指定的字符。  partition()
test = 'test 8888'
v = test.partition('t')
print(v)
v2 = test.rpartition('t')
print(v2)

# 根据指定的字符进行分割，不包含指定的字符，可以指定匹配次数。  split()

test = 'test 888'
v1 = test.split('t', 2)
print(v1)

v2 = test.rsplit('t', 1)
print(v2)

# 根据换行符进行分割。 splitlines()， 参数为True表示包含换行符，为False表示不包含换行符
test = 'test\n888\n'
v1 = test.splitlines(True)
print(v1)
v2 = test.splitlines(False)
print(v2)

# 判断字符串是否以指定字符串开头/结尾。 startswith()、endswith()
test = 'abc123e'
v1 = test.startswith('a')
print(v1)
v2 = test.endswith('a')
print(v2)

# 进行大小写互相转换。 swapcase()
test = 'Apple'
v = test.swapcase()
print(v)

3.12、字符串的常用格式化

（一）百分号格式：

# 字符串格式化
# 方式一：百分号方式
# %s 、%d、%f（默认取6位小数）、%.2f（取2位小数）、%(name)s 后面传 字典,s 表示值的类型，可能是d或f 等等
# 如果要输出百分号，则使用%%
name = 'wsh'
hobby = 'panting'
age = 18
msg = "i am %s , my hobby is %s, i am %d years old" % (name, hobby, age)
print(msg)

price = 12.88889
p = "the price of apple is %.2f " % price
print(p)

q = "my name is %(name)s，age %(age)d" % {"name": "wsh", "age": 18}
print(q)
percent = 0.8823
per = "it rises %.2f %%" % percent
print(per)

输出的结果：

i am wsh , my hobby is panting, i am 18 years old
the price of apple is 12.89 
my name is wsh，age 18
it rises 0.88 %

（二）format 格式：
①通过位置来填充字符串：
说明：format 会把参数按位置顺序来填充到字符串中，第一个参数是0，然后1 ……。

也可以不输入数字，这样也会按顺序来填充。

同一个参数可以填充多次，这个是format比%先进的地方。

# 通过位置来填充字符串
msg1 = "hello {0}, i am {1}".format('kevin', 'tom')
print(msg1)
# 可以不输入数字，这样也会按顺序来填充。
msg2 = "hello {}, i am {}".format('kevin', 'tom')
print(msg2)
# 同一个参数可以填充多次，这个是format比%先进的地方。
msg3 = "hello {0}, i am {1}, {0}".format('kevin', 'tom')
print(msg3)

输出的结果：

hello kevin, i am tom
hello kevin, i am tom
hello kevin, i am tom, kevin

②通过key来填充：

# 通过key来填充
item = "for example: {name1}、{name2}".format(name1='apple', name2='orange')
print(item)

输出的结果：

for example: apple、orange

③通过下标来填充：

# 通过下标填充
items = ['apple', 'banana', 'orange', 'strawberry']
print('i like {my_list[0]}、{my_list[1]}'.format(my_list=items))

输出的结果：

i like apple、banana

④通过字典的key来填充：

# 通过字典的key来填充
person = {"name": "tom", "age": 18}
print("my name is {person[name]},i am {person[age]}".format(person=person))

输出的结果：

my name is tom,i am 18

4、列表

列表中的元素可以修改，并且可以存放多种类型的元素。但是还是建议列表中存放相同类型的数据。
缺点就是根据关键字查找效率很低。
列表中的元素可以是数字、字符串、列表、布尔值等。

4.1、语法

name_list = ['alex', 'seven', 'eric']  # 通过list类创建的对象name_list

4.2、基础用法

# !/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time: 2021/5/23 下午 9:06
# @File: my_list.py
# @Software: PyCharm

my_list = [1, 2, 3, "apple", ["tom", "tony", "sherry"]]  
# 通过list类 创建的对象 my_list

# 索引取值
print(my_list[1])
#
# 索引修改
my_list[1] = [22, 222]
print(my_list)

# 索引删除
del my_list[1]
print(my_list)

# 切片取值
print(my_list[1:3])

# 切片修改
my_list[1:3] = ['happy']
print(my_list)

# 切片删除
del my_list[1:3]
print(my_list)

# for 循环
for item in my_list:
    print(item)

# while 循环

i = 0
while i < len(my_list):
    print(my_list[i])
    i += 1

# 支持in 操作，判断元素是否在列表内

v = 2 in my_list
print(v)

# 列表里面既有数字又有字符串的时候，要想把列表转换成字符串，只能用for循环一个一个处理
li = [1, 12, 13, "age", "gender"]

s = ""
for i in li:
    s = s + str(i)
print(s)

# 列表里面只有字符串的时候，可以直接使用join()，转换成字符串
li = ["anger", "happy"]
v = "".join(li)
print(v)

4.3、列表的常用方法

4.3.1、列表的插入

①在尾部插入元素：my_list.append(self, object)

# 在尾部插入元素 my_list.append()
my_list = ["name", "gender", "account"]
my_list.append("store")
print(my_list)

输出结果：

['name', 'gender', 'account', 'store']

②在指定的位置插入：my_list.insert(self,index,object)

my_list = ["name", "gender", "account"]
my_list.insert(2, 20)
print(my_list)

输出结果：

['name', 'gender', 20, 'account']

4.3.2、列表的删除

①清空、清除：my_list.clear(self)

# 清空、清除：my_list.clear()
my_list = ["name", "gender", "account"]
my_list.clear()
print(my_list)

输出结果：

[]

②用于位置删除，默认删除最后一个位置的元素，如果指定了位置，删除该位置的元素：my_list.pop(self,index=None)

my_list = ["name", "gender", "account"]
my_list.pop(1)
print(my_list)

输出结果：

['name', 'account']

③根据值删除，删除第一个出现的值：my_list.remove(self, value)

my_list = ["name", "gender", "account"]
my_list.remove("gender")
print(my_list)

输出结果：

['name', 'account']

4.3.3、列表_元素排序

①逆序：my_list.reverse()

my_list = ["name", "gender", "account"]
my_list.reverse()
print(my_list)

输出结果：

['account', 'gender', 'name']

②默认升序：my_list.sort(self, key=None, reverse=False)

my_list = [1, 5, 3, 8, 2]
my_list.sort()
print(my_list)

输出结果：

[1, 2, 3, 5, 8]

③实现从大到小的排序：my_list.sort(reverse = True)

my_list = [1, 5, 3, 8, 2]
my_list.sort(reverse=True)
print(my_list)

输出结果：

[8, 5, 3, 2, 1]

4.3.4、其它方法

①拷贝，浅拷贝：my_list.copy(self)

# 拷贝，浅拷贝：my_list.copy(self)
my_list = ["name", "gender", "account"]
copy_my_list = my_list.copy()
print(copy_my_list)

输出结果：

['name', 'gender', 'account',]

②计数：my_list.count(self, value)

my_list = ["name", "gender", "account", "name"]
v = my_list.count("name")
print(v)

输出结果：

2

③将列表合并到另一个列表：my_list.extend(self, iterable)
iterable表示可迭代对象，比如字符串、列表

my_list = ["name", "gender", "account"]
my_list.extend(["store", "date"])
print(my_list)

输出结果：

['name', 'gender', 'account', 'store', 'date']

④查找元素的索引：my_list.index(self,value, start=None, stop=None)

my_list = ["name", "gender", "account"]
v = my_list.index("gender")
print(v)

输出结果：

1

5、元组

由于元组不支持修改，所以元组只支持遍历、查找操作，元组也是一个可迭代对象，支持for循环。
元组如果只有一个元素的话，需要在元素后面添加逗号，如my_tuple = (10,)。
元组比列表更节省空间，因为元组一旦被创建，不可新增、删除，而列表往往比实际占有的元素还要大。

5.1、语法

my_tuple  = (1, 2, 3, 'first', 'second', 'third',)  
# 通过tuple类创建的对象my_tuple

5.2、基础用法

my_tuple = (1, 2, 3, 'first', 'second', 'third',)

# 支持索引
v = my_tuple[1]
print(v)
# 支持切片
v1 = my_tuple[0: 3]
print(v1)
# 支持for循环
for item in my_tuple:
    print(item)

# 元组的一级元素不能被修改或删除，但是非一级元素，如果是列表，那么可以被修改

my_tuple = (1, 2, 3, [(33, 44,)], 'first', 'second', 'third',)
# my_tuple[3][0]取到的是列表 [(33, 44,)]的元素(33, 44,)，列表是可以被修改的
my_tuple[3][0] = 456
print(my_tuple)

5.3、元组的方法

①计数：count(self, value)

②查找值对应的索引：index(self, value, start=None, stop=None)

my_tuple = (1, 2, 3, [(33, 44,)], 'first', 'second', 'third',)
# ①计数：count(self, *args, **kwargs)
u = my_tuple.count(3)
print(u)
# ②查找值对应的索引：index(self, *args, **kwargs)
i = my_tuple.index([(33, 44,)])
print(i)

6、字典

查找效率比较高，但是比较占内存。
字典是非序列式容器（无序），不支持索引、切片操作。字典的查询优于列表，根据键查询，如my_dict[‘name’]。
“键”一般是唯一的，如果重复，最后的一个键值对会替换前面的，“值”不需要唯一。

6.1、语法

my_dict  = {key1:value1, key2:value2}  

6.2、基础用法

6.3、字典的方法

①添加和修改元素：
my_dict[“age”] = 20
如果key存在则修改元素，如果key不存在则新增元素。

举例一：key存在

my_dict = {"name": "张三", "account":  "123456", "id": "001"}
my_dict["name"] = "李四"
print(my_dict)

输出的结果：

{'name': '李四', 'account': '123456', 'id': '001'}

举例二：key不存在

my_dict = {"name": "张三", "account":  "123456", "id": "001"}
my_dict["gender"] = "女"
print(my_dict)

输出的结果：

{'name': '张三', 'account': '123456', 'id': '001', 'gender': '女'}

②获得元素：使用get方法。my_dict.get(“key”, “默认值”)，如果不存在key，则返回默认值。

my_dict = {"name": "张三", "account":  "123456", "id": "001"}
v = my_dict.get("name", "null")
print(v)

输出的结果：

张三

③删除元素：
del my_dict[“key”]， 不但能够删除字典中某个键值对，还能删除变量。

my_dict = {"name": "张三", "account":  "123456", "id": "001"}
del my_dict["id"]
print(my_dict)

输出的结果：

{'name': '张三', 'account': '123456'}

④清空字典：
my_dict.clear()

my_dict = {"name": "张三", "account":  "123456", "id": "001"}
my_dict.clear()
print(my_dict)

输出的结果：

{}

⑤遍历元素：
（1）.keys()方法，获得所有的键列表。
（2）.values()方法，获得所有的值列表。
（3）.items()方法，获得所有的键值对列表。

my_dict = {"name": "张三", "account":  "123456", "id": "001"}
my_keys = my_dict.keys()
print("键列表为：", my_keys)
my_values = my_dict.values()
print("值列表为：", my_values)
my_items = my_dict.items()
print("键值对列表为：", my_items)

输出的结果：

键列表为： dict_keys(['name', 'account', 'id'])
值列表为： dict_values(['张三', '123456', '001'])
键值对列表为： dict_items([('name', '张三'), ('account', '123456'), ('id', '001')])

⑥使用while循环遍历字典：
步骤：
（1）先获取字典的键值对，使用.items()方法。
（2）再把步骤（1）获取的键值对，转换成列表，使用list()方法。
（3）再去遍历列表即可。

my_dict = {"name": "张三", "account":  "123456", "id": "001"}
my_items = my_dict.items()
print("键值对列表为：", my_items)

# 把获取到的键值对，转换成列表
my_items_list = list(my_items)
print("转换成列表之后：", my_items_list)
i = 0
while i < len(my_items_list):
    print(my_items_list[i])
    i += 1

输出的结果：

键值对列表为： dict_items([('name', '张三'), ('account', '123456'), ('id', '001')])
转换成列表之后： [('name', '张三'), ('account', '123456'), ('id', '001')]
('name', '张三')
('account', '123456')
('id', '001')

7、集合

由不同元素组成的集合，集合中是一组无序排列的可hash值，可作为字典的key。
集合的目的是将不同的值放在一起，不同的集合间用来做关系运算，无需纠结于集合中单个值。
集合中的元素必须是不可变类型。（不可变的类型包括：字符串、数值、元组、字典）但是集合是可变类型。

7.1、语法

set_test = {'hello', "world", 1, 2, ("test", 333), 2, 1}
print(set_test)
# 定义可变集合
my_set = set("hello")
print(my_set)
# 定义不可变集合
my_set = frozenset("hello")

输出的结果：

{'hello', 1, 2, 'world', ('test', 333)}
{'o', 'e', 'h', 'l'}

7.2、集合的内置方法

①添加：add(self, element)

set_test = {'hello', "world", 1, 2, ("test", 333), 2, 1}
set_test.add('2')
set_test.add(2)
print(set_test)

输出结果：

{1, 2, '2', 'hello', ('test', 333), 'world'}

②清空：clear(self)

set_test = {'hello', "world", 1, 2, ("test", 333), 2, 1}
set_test.clear()
print(set_test)

输出结果：

set()

③复制：copy(self)

set_test = {'hello', "world", 1, 2, ("test", 333), 2, 1}
s1 = set_test.copy()
print(s1)

输出结果：

{'hello', "world", 1, 2, ("test", 333), 2, 1}

④删除：pop(self)随机删除1个元素，remove(self, element)指定删除某一个元素
（1）pop()随机删除1个元素

set_test = {'hello', "world", 1, 2, ("test", 333), 2, 1}
set_test.pop()
print(set_test)

输出的结果：

{2, 'world', 'hello', ('test', 333)}

（2）remove(self, element)指定删除某一个元素，如果指定的元素不存在的话，会报错。

set_test = {'hello', "world", 1, 2, ("test", 333), 2, 1}
set_test.remove('world')
print(set_test)

输出的结果：

{1, 'hello', 2, ('test', 333)}

（3）discard(self, element)指定删除某一个元素，如果指定的元素不存在的话，不会报错。

set_test = {'hello', "world", 1, 2, ("test", 333), 2, 1}
set_test.discard('world')
print(set_test)

输出的结果：

{1, 'hello', 2, ('test', 333)}

⑤判断2个集合是否有交集：A.isdisjoint(B)判断 A和B 集合是否有交集，如果没有交集，则返回True， 如果有交集，则返回False。

A = ['A', 'B', 'C', 'D', 'E']
B = ['C', 'D', 'E']

# 首先先把A,B 列表转换成集合
A_set = set(A)
B_set = set(B)
# A.isdisjoint(B)判断 A和B 集合是否有交集，如果没有交集，则返回True， 如果有交集，则返回False
print(A_set.isdisjoint(B_set))

输出的结果：

False

⑥判断s1是否s2的子集：s1.issubset(s2) 或 s1 <= s2，判断s1 是否 s2 的子集， 如果是的话，返回True； 如果不是的话，返回False。
⑦判断s1 是否 s2 的父集：s1.issuperset(s2) 或 s1 >= s2，判断s1 是否 s2 的父集， 如果是的话，返回True； 如果不是的话，返回False。

s1 = {1, 2, 3}
s2 = {1, 2}
# s1.issubset(s2) 判断s1 是否 s2 的子集， 如果是的话，返回True； 如果不是的话，返回False
print(s1.issubset(s2))
# s1.issuperset(s2) 判断s1 是否 s2 的父集， 如果是的话，返回True； 如果不是的话，返回False
print(s1.issuperset(s2))

输出的结果：

False
True

⑧更新集合：s1.update(s2)， 用来更新多个值，和.add()不同的是，add只能更新一个值。

s1 = {1, 2, 3}
s2 = {1, 2}
s2.update(s1)
print(s2)

输出的结果：

{1, 2, 3}

7.3、集合的关系运算交、差、并集

①集合的交集：A.intersection(B) 相当于 A&B，取得2个集合共同的部分元素。

A = ['A', 'B', 'C', 'D', 'E']
B = ['C', 'D', 'E']

# 首先先把A,B 列表转换成集合
A_set = set(A)
B_set = set(B)
# 再将2个集合进行交集运算 intersection
A_B = A_set.intersection(B_set)
print(A_B)

输出的结果：

{'D', 'E', 'C'}

②集合的差集：
A.difference(B) 或 A - B 表示A有但是B没有的那部分元素。
B.difference(A) 或 B - A 表示B有但是A没有的那部分元素。

A = ['A', 'B', 'C', 'D', 'E']
B = ['C', 'D', 'E', 'F']
# 首先先把A,B 列表转换成集合
A_set = set(A)
B_set = set(B)
# A.difference(B) 或 A - B 表示A有但是B没有的那部分元素。
print(A_set.difference(B_set))
print(A_set - B_set)
# B.difference(A) 或 B - A 表示B有但是A没有的那部分元素。
print(B_set.difference(A_set))
print(B_set - A_set)

输出的结果：

{'B', 'A'}
{'B', 'A'}
{'F'}
{'F'}

③集合的并集：A.union(B) 或 A | B，将2个集合去重合并为1个集合。

A = ['A', 'B', 'C', 'D', 'E']
B = ['C', 'D', 'E']

# 首先先把A,B 列表转换成集合
A_set = set(A)
B_set = set(B)
# 并集运算 A.union(B) 或 A | B
print(A_set.union(B_set))
print(A_set | B_set)

输出的结果：

{'E', 'D', 'A', 'C', 'B'}
{'E', 'D', 'A', 'C', 'B'}

④交叉补集：A.symmetric_difference(B) 或 A ^ B 先把2个集合合并在一起，再减掉相同的部分。

A = ['A', 'B', 'C', 'D', 'E']
B = ['C', 'D', 'E']

# 首先先把A,B 列表转换成集合
A_set = set(A)
B_set = set(B)
# 交叉补集 A.symmetric_difference(B) 先把2个集合合并在一起，再减掉相同的部分
print(A_set.symmetric_difference(B_set))
print(A_set ^ B_set)

输出的结果：

{'F', 'A', 'B'}
{'F', 'A', 'B'}