文章目录
Python语言整体的数据类型分为三块：数值类型，字节类型，组合类型。
- 数值类型：整型，浮点型，布尔型，复数型。
- 字节类型：字符串。
- 组合类型：列表，元组，集合，字典。
如果按值是否可以更改，并且更改后物理地址是否发生改变，又分为可变类型和不可变类型。
- 可变类型：列表，字典，集合
- 不可变类型：数值，字符串，元组
一、数值类型：数值-Number
1.数值类型的介绍及其相互转化
4种数值类型概述如下表：
| 名称 | 英文标识 | 解释 | 举例 |
|---|---|---|---|
| 整型 | int | 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。 | 5,6 |
| 浮点型 | float | 浮点型由整数部分与小数部分组成。 | 5.22222 |
| 布尔型 | bool | 含义True和False，True转换为1，False转换为0，但是反之除 0为False类型，其他数字为True类型 | True、False |
| 复数型 | complex | 形如a+bi（a为复数实部，b为复数虚部） | 1+2i |
并且这些数字类型之间可以进行相互转换：
注意：
1.在数字类型中，0或者0.0转换为bool类型为False ， 其他为True；
2.而True转为int类型为1，False转换为int为0；
3.这四种数值类型的复杂度：bool<int<float<complex；
2.数字类型之间的数学运算
既然是数字类型，那么就可以进行一些数学运算，例如：a=20,b=10
3.数字间的进制转换
数字有多种进制表现，常见的就是二进制、八进制、十进制、十六进制。在计算中表现形式是这样：
| 进制 | 表示 |
|---|---|
| 二进制 | 0b表示， 用0,1 表示 |
| 八进制 | 0o表示， 用0-7 表示 |
| 十六进制 | 0x表示， 用0-9和A-F 表示 |
如果进制之间使用代码相互转化
| a进制转换为b进制 | 函数 |
|---|---|
| 整数转换为二进制 | bin(整数) |
| 整数转换为八进制 | oct(整数) |
| 整数转换为十六进制 | hex(整数) |
| 其他进制转换为十进制 | int(其他进制字符串,进制数) |
试一下：
二、字节类型：字符串-String
字符串在 Python中的表现形式为单/双/三引号的形式：
接下来了解下字符串的一些使用。
1.字符串的运算
# -----------------------------------------拼接
a = '123'
b = '456'
print(a + b) # 123456
# ------------------------------------------重复
c = '123'
print(c * 3) # 123123123
# -----------------------------------------分配
c, d = '12'
print(c, d) # 1 2
# -----------------------------------------分配，部分打散
a, *b = '12345' # *此处具有打散功能，打散为列表
print(a, b) # 1 ['2', '3', '4', '5']
2.字符串的切片
如果一个字符串我们想取其中的几个字符，那么就可以通过切片的方式获取
a = '123abcd'
print(a[0: 5]) # ---------------------------123ab
print(a[:4]) # ----------------- 123a
print(a[1:]) # -------------- 23abcd
print(a[:]) # 等同于直接输出a
print(a[::3]) # -------------- 1ad
print(a[3::3]) # ---------------ad
print(a[:4:3]) # ------------------------------- 1a
print(a[3:0:-1]) # -------------------a,3,2，使用步长-1，注意起始位置
print(a[::-1]) # ---------------------倒序dcba321
print(a[-1:-5:-2]) # ------------------------db
a = '123456789'
print(a[-8:5]) # -----------------------2345
print(a[0:-5]) # -------------------1234
print(a[-5:-1:1]) # -------------------------5678
print(a[-1:-5:-1]) # ----------------------------9876
3.字符串的常见函数
| 序号 | 方法及描述 |
|---|---|
| 1 | capitalize() 将字符串的第一个字符转换为大写 |
| 2 | center(width, fillchar) 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。 |
| 3 | count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
| 4 | bytes.decode(encoding=“utf-8”, errors=“strict”) Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。 |
| 5 | encode(encoding=‘UTF-8’,errors=‘strict’) 以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’ |
| 6 | endswith(suffix, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. |
| 7 | expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。 |
| 8 | find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1 |
| 9 | index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在字符串中会报一个异常。 |
| 10 | isalnum() 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False |
| 11 | isalpha() 如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False |
| 12 | isdigit() 如果字符串只包含数字则返回 True 否则返回 False… |
| 13 | islower() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
| 14 | isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False |
| 15 | isspace() 如果字符串中只包含空白，则返回 True，否则返回 False. |
| 16 | istitle() 如果字符串是标题化的(见 title())则返回 True，否则返回 False |
| 17 | isupper() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
| 18 | join(seq) 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
| 19 | len(string) 返回字符串长度 |
| 20 | [ljust(width, fillchar]) 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。 |
| 21 | lower() 转换字符串中所有大写字符为小写. |
| 22 | lstrip() 截掉字符串左边的空格或指定字符。 |
| 23 | maketrans() 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 |
| 24 | max(str) 返回字符串 str 中最大的字母。 |
| 25 | min(str) 返回字符串 str 中最小的字母。 |
| 26 | [replace(old, new , max]) 把 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。 |
| 27 | rfind(str, beg=0,end=len(string)) 类似于 find()函数，不过是从右边开始查找. |
| 28 | rindex( str, beg=0, end=len(string)) 类似于 index()，不过是从右边开始. |
| 29 | [rjust(width,, fillchar]) 返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串 |
| 30 | rstrip() 删除字符串字符串末尾的空格. |
| 31 | split(str=“”, num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串 |
| 32 | [splitlines(keepends]) 按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 |
| 33 | startswith(substr, beg=0,end=len(string)) 检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。 |
| 34 | [strip(chars]) 在字符串上执行 lstrip()和 rstrip() |
| 35 | swapcase() 将字符串中大写转换为小写，小写转换为大写 |
| 36 | title() 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) |
| 37 | translate(table, deletechars=“”) 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中 |
| 38 | upper() 转换字符串中的小写字母为大写 |
| 39 | zfill (width) 返回长度为 width 的字符串，原字符串右对齐，前面填充0 |
| 40 | isdecimal() 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。 |
4.字符串的format格式化函数
format函数在字符串经常会用于输出，使用较多。具体看一下它的灵活使用。
①输出普通参数
name = '蔡徐坤'
age = 18
# -------------按顺序
print('名字{}，年龄{}'.format(name, age)) # 名字蔡徐坤，年龄18
# ------------按指定顺序
print('名字{0}，{0}的年龄{1}'.format(name, name, age)) # 名字蔡徐坤，蔡徐坤的年龄18
# -------------按变量名称
print('名字{name},年龄{age}'.format(name=name, age=age)) # 名字蔡徐坤,17
# --------------f写法，和变量名称类似
print(f'名字{name},年龄{age}') # 名字蔡徐坤,18
②格式化修饰
| 符号 | 表示 |
|---|---|
| ： | 后边为将于格式化的写法 |
| 5 | 表示总字符长度为5 |
| ^ | ^表示要居中，< 表示字体居左，>表示字体居右 |
| & | 表示，填充字符，不够长度的用*号表示 |
举例：
a='我叫{:&^5}'.format('蔡徐坤')#^居中
b='我叫{:&<5}'.format('蔡徐坤')#<居左
c='我叫{:&>5}'.format('蔡徐坤')#>居右
print(a)#---------------------------------------我叫&蔡徐坤&
print(b)#---------------------------------------我叫蔡徐坤&&
print(c)#---------------------------------------我叫&&蔡徐坤
③输出二进制，八进制，十六进制
# ----------------------------------------------输出二进制
a = '5的二进制为{:b}'.format(5) # 二进制用b
print(a) # ---------------5的二进制为101
# --------------------------------------------------输出八进制
b = '20的八进制为{:o}'.format(20) # 八进制用o
print(b) # 20的八进制为24
# -------------------------------------------------输出十六进制
c = '34的十六进制为{:x}'.format(34) # 十六进制用x
print(c) # 34的十六进制为22
④符串格式化和百分号
name,age,height='张三',18,1.75
print('我叫%s，年龄%d，身高%.2f'%(name,age,height)) # %.2f代表保留小数点后两位
# 我叫张三，年龄18，身高1.75
print('%.2f%%'%(0.23)) # %%为数学中的一个%-----------------0.23%
符号大全：
三、组合类型 ：列表-List
列表是一个有序的序列，在python中创建的几种方式
a = [1, 2, 3] # 普通列表
b = [] # 空列表
c = list() # 空列表
d = [1, 2, 'adadd', True, [123]] # 复杂列表
1.列表的常见函数
| 序号 | 方法 | 说明 |
|---|---|---|
| 1 | list.append(obj) | 在列表末尾添加新的对象 |
| 2 | list.count(obj) | 统计某个元素在列表中出现的次数 |
| 3 | list.extend(seq) | 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| 4 | list.index(obj) | 从列表中找出某个值第一个匹配项的索引位置 |
| 5 | list.insert(index, obj) | 将对象插入列表 |
| 6 | list.pop(index） | 值为索引，移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| 7 | list.remove(obj) | 值为删除值，移除列表中某个值的第一个匹配项 |
| 8 | list.reverse() | 反向列表中元素 |
| 9 | list.sort(cmp=None, key=None, reverse=False) | 对原列表进行排序，无返回值（sorted函数是Python的函数，有返回值），reverse默认为False升序 |
2.列表的一些函数使用
①获取列表某几项：
a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 正索引获取一项
print(a[0]) # 1
print(a[3]) # 4
# 负索引获取一项
print(a[-1]) # 9
print(a[-3]) # 7
# 正索引获取多项
print(a[1:5]) # [2, 3, 4, 5]
# 负索引获取多项
print(a[-5:-1]) # [5, 6, 7, 8]
②列表的遍历与长度
a = [1, 3, 4]
print('a列表的长度为：', len(a)) # 3
# ---------普通循环使用range方法
for i in range(len(a)):
print("当前索引为{},是列表的第{}个元素，值为{}".format(i, i + 1, a[i]))
"""
当前索引为0,是列表的第1个元素，值为1
当前索引为1,是列表的第2个元素，值为3
当前索引为2,是列表的第3个元素，值为4
"""
# -----------------直接循环列表
for i in a:
print(i)
"""
1
3
4
"""
# ----------------带索引的循环
for index, i in enumerate(a):
print("当前索引为{},是列表的第{}个元素，值为{}".format(index, i + 1, i))
"""
当前索引为0,是列表的第2个元素，值为1
当前索引为1,是列表的第4个元素，值为3
当前索引为2,是列表的第5个元素，值为4
"""
③列表的拼接，重复
a = [1, ]
b = [2, 3]
print(a + b) # [1,2,3]
print(a * 3) # [1,1,1]
print(a[0] + b[0]) # 3
④列表的添加【append,extend,insert】
| 方法名 | 使用方式 |
|---|---|
| append（） | 在列表末尾添加一个元素， 格式： m.append(元素A) |
| extend（） | 对于特定列表的扩展和增长，可以一次添加多个元素，不过也只能添加在列表的最后；格式：m.extend([A，B，…]) |
| insert（） | 在列表的特定位置插入想要添加的特定元素，这里的特定位置是指元素所在列表中的索引 格式： m.insert(A,元素B)：表示在列表m的索引A位置变为元素B,其他元素顺序后移 |
a = [1, 2, 3, 4, 5,]
a.append(7)#在尾部追加一个
print(a) # [1,2,3,4,5,7]
b=['a','b']
a.extend(b)#extend可以将另一个列表插入
print(a) # [1,2,3,4,5,7,'a','b']
a.insert(1,'x')#在索引一的位置加个’x'
print(a) [1,'x',2,3,4,5,7,'a','b']
⑤列表的删除【pop,del,remove】
- pop()可以添加索引，不添加默认弹出最后一个数
- remove必须传入要删的数，删除从左到右的第一个数
- del 内置方法
a = [1, 2, 3, 4, 5,]
a.pop()#会删除最后一个数，并且输出删除的这个元素
a.pop(2)#会删除索引为2的数，并且输出删除的这个元素
a = [1, 2, 3, 4, 5,]
a.remove(3)#删除的是第一个遇到的3，并非索引位置
print(a)
a = [1, 2, 3, 4, 5,]
del a[2]#删除对应索引或者整个列表
print(a)
⑥列表的修改，直接复制
a = [1, 2, 3, 4, 5,]
a[2]='xx' # 直接将对应索引更改为自己修改的值即可
print(a) # [1,2,'xx',4,5]
3.列表函数操作的时间复杂度
关于列表各个函数操作的时间复杂度，见该文章：列表各个函数的操作复杂度
4.深拷贝和浅拷贝
- 深拷贝：完全复制一份到新的物理地址，互相修改不受影响
- 浅拷贝：粗略复制，只复制外层地址，对于内部的可变类型，互相修改还会变化，因为内部的可变类型还是同一块内存地址
import copy
a=[1,2,3,[4,5],6]
b=a
c=copy.copy(a)#浅拷贝，将列表粗略考走，列表内部的列表会随着a中内部的列表变化，即内部列表还指向【4,5】
d=copy.deepcopy(a)#深拷贝，完全复制一份a，创立了一块新的地址，互相修改不会变化
a.append('00000')
a[3].append('x')
print(a,id(a))
print(b,id(b))
print(c,id(c))
print(d,id(d))
结果：
四、组合类型 ：元组-Tuple
创建元组的方法：
a = (1, 2, 3) # 普通元组
b = 1, 2, 3, 4 # 普通元组
c = (1,) # 创建只有一个元素的元组，必须加逗号
d = 1, # 创建只有一个元素的元组，必须加逗号
e = (1, 2, (3, 4), 'sqsa', [123]) # 复杂元组
f = tuple() # 空元组
g = () # 空元组
print(type(b)) # <class 'tuple'>
元组和列表之间也可以进行相互转化，示例如下：
a = [1, 2, 3]
b = tuple(a)
print(b) # (1, 2, 3)
c = list(b)
print(c) # [1, 2, 3]
关于元组的循环遍历和求长度，与列表相同，这里不展开讲。
1.元组元素的改变
元组虽然是不可变类型，但是如果元组的元素中有可变类型，还是可以改变其中的值的。例如：
2.元组的拼接和重复
元组是不可变类型，此时的拼接和重复出的结果是新的返回值
五、组合类型：字典-Dict
字典是一个无序可可变序列，在内部由若干个key-value键值对组成，这样创建：
a = {'name': '张三', 'age': 15} # 普通字典
b = {'name_list': ['12334'], "xxx": 4646} # 复杂字典
c = {} # 空字典
d = dict() # 空字典
另外需要注意：
- 字典的key值必须是不可变类型
- 同一字典有两个相同的key，会保留后一个key的数据
我们还是从字典的一些使用来讲解
1.字典的增删改查
①增加和修改
| 添加方式 | 注意 |
|---|---|
| dic1[key]=new_value | 没有则为新增，有了则为覆盖 |
| setdeafult() | 只能添加新的值 |
| update() | 合并两个字典，将函数值的字典中的key-value键值对中没有key的值添加，有则覆盖后边的值 |
简单使用：
# -----------------------------dic1[xx]=yy
dic1 = {'name': '蔡徐坤', 'age': 18}
dic1['sex'] = '男'
print(dic1) # {'name': '蔡徐坤', 'age': 18, 'sex': '男'}
dic1['name'] = 'sssss'
print(dic1) # {'name': 'sssss', 'age': 18, 'sex': '男'}
# ------------------------------setdeafult()，key存在，不可修改，key不存在，可以修改
dic1 = {'name': '蔡徐坤', 'age': 18}
dic1.setdefault('name', '彪子')
print(dic1) # {'name': '蔡徐坤', 'age': 18}
dic1.setdefault('location', '北京')
print(dic1) # {'name': '蔡徐坤', 'age': 18, 'location': '北京'}
# ---------------------------update()
a = {'name': 111, 'age': 123}
b = {'name': 222, 'xxx': 121312}
a.update(b)
print(a) # {'name': 222, 'age': 123, 'xxx': 121312}
②删除
| 方法 | 注意 |
|---|---|
| clear() | 清空列表 |
| del | 可以删除指定数据，也可以删除整个字典 |
| popitem() | 随机弹出一个，储存为元组，删除原来字典中的一个 |
| pop() | 字典是无序的，所以必须写key |
简单使用：
# ---------------------------------------clear()
dic1 = {'name': '蔡徐坤', 'age': 18}
dic1.clear()
print(dic1) # {}
# ------------------------------------- pop()
dic1 = {'name': '蔡徐坤', 'age': 18}
dic1.pop('name')
print(dic1) # {'age': 18}
# ------------------------------------- popitem()
dic1 = {'name': '蔡徐坤', 'age': 18}
dic1.popitem()
print(dic1) # {'name': '蔡徐坤'}
# ----------------------------------del
dic1 = {'name': '蔡徐坤', 'age': 18}
del dic1['name']
print(dic1) # {'age': 18}
dic1 = {'name': '蔡徐坤', 'age': 18}
del dic1
print(dic1) # 因为已经删除，故没有该变量显示未定义，NameError: name 'dic1' is not defined
③查询-取单个的值
取单个值
| 方式 | 解释 |
|---|---|
dic1[key] | 直接用键名查找 |
dic1.get(key) | 存在则返回value值，不存在该键值默认返回None，当然该值可以自己设置 |
简单使用：
dic1 = {'name': '蔡徐坤', 'age': 18}
print(dic1['name']) # 蔡徐坤
print(dic1.get('name')) # 蔡徐坤
print(dic1.get('sex')) # None
print(dic1.get('sex', '没有sex,返回我自己定义的话')) # 没有sex,返回我自己定义的话
④循环迭代
| 提取 | 函数 |
|---|---|
| 提取key | keys（），储存为列表形式 |
| 提取value | values（），储存为列表形式 |
| 提取key和value | items（），储存为列表套元组形式 |
简单使用：
# ---------------------------------------keys()
dic = {'a': 1, 'b': 2, 'c': 3}
print(dic.keys())
for k in dic.keys():
print(k)
"""
dict_keys(['a', 'b', 'c'])
a
b
c
"""
# ----------------------------------------values()
dic = {'a': 1, 'b': 2, 'c': 3}
print(dic.values())
for v in dic.values():
print(v)
"""
dict_values([1, 2, 3])
1
2
3
"""
# --------------------------------------------items()
dic = {'a': 1, 'b': 2, 'c': 3}
print(dic.items())
for k, v in dic.items():
print(k, v)
"""
dict_items([('a', 1), ('b', 2), ('c', 3)])
a 1
b 2
c 3
"""
2.判断字典
dic = {'a': 1, 'b': 2, 'c': 3}
if 'a' in dic:
print('a在字典dic中')
if 'd' not in dic:
print('d不在字典dic中')
if 'a' in dic.keys():
print('a在字典dic中')
3.字典的时间复杂度
注意
- 字典查找速度快,无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。
- 字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。不允许同一个键出现两次。键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行。dict的第二个特点就是存储的key-value序对是没有顺序的！这和list不一样。
六、组合类型：集合-Set
集合是一个不可重复的，无序的，不可改变的序列，值中不可以出现不可哈希的值。创建集合如下：
a = {1, 2, 3, 4} # 普通集合
b = {1, 1, 1, 1, 1, 2} # {1,2} ，会自动去重
c = set() # 空集合
d = {1, 2, 3, [1, 2], {'name': '张三'}} # 报错，集合中的值是要可哈希的不变值
循环遍历和列表，元组相同，这里不演示了。
1.集合的增删改查
①添加和更新
| 函数名 | 作用 |
|---|---|
| add() | 添加单个元素到集合 |
| update() | 指集合和另一个序列(元组，列表，字典，集合)。添加多个元素或者更新集合,如果有重复的元素会自动去重 |
简单举例：
a = {1, 1, 1, 1, 1, 1, 3, 4, 2}
a.add(9)
print(a) # {1, 2, 3, 4, 9}
s1 = {1, }
s2 = {1, 2, }
li = [1, 3]
tup = (1, 4)
s1.update(s2)
print(s1) # {1, 2}
s1.update(li)
print(s1) # {1, 2, 3}
s1.update(tup)
print(s1) # {1, 2, 3, 4}
xx = {'name': 123}
s1.update(xx)
print(s1) # {1, 2, 3, 4, 'name'} ,只更新字典的key值
②删除
| 函数名 | 作用 |
|---|---|
| pop() | 随机弹出一个元素,并返回这个元素 |
| remove() | 删除指定值 |
| clear() | 集合的清空 |
| del | 删除集合 |
举例：
a = {2, 1, 3, 4}
b = a.pop() # pop()随机删除一个
print(b, a) # 1 {2, 3, 4}
a.remove(3) # remove删除写的值
print(a) # {2, 4}
a.clear() # 清空集合
print(a) # set()
del a # 删除集合
2.其他序列和集合的相互转化
对于列表/元组/字典转换为集合，会直接去重变为集合。而字典转换为集合，只针对key值
b = {'1': 'a', '2': 'b'}
a = set(b) # 会把字典的key存到集合
print(a) # {'2','1'}
3.集合的运算（交集，并集，补集，差集）
1、交集intersection（）或者&
a = {1, 2, 3}
b = {2, 3, 4}
print(a & b)
print(a.intersection(b))
结果：
2、反交集symmetric_difference()或者^
a = {1, 2, 3}
b = {2, 3, 4}
print(a.symmetric_difference(b))
print(a ^ b)
结果：
3、并集union（）或者|
a={1,2,3}
b={2,3,4}
print(a|b)
print(a.union(b))
结果：
4、差集difference或者-
a = {1, 2, 3}
b = {2, 3, 4}
print(a - b)
print(a.difference(b))
结果：
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
