一、基本数据类型
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'}