Python序列数据类型

python 列表 （list）

一、列表的定义

• 列表是一组有序的一系列数据，列表中的所有元素由一对中括号括起来，元素之间用逗号分隔，可随时添加和删除其中的元素。
• 元素的数据类型可以相同也可以不相同，也可以嵌套另一个序列。

  语法：

 list=[元素1,元素2,.....,元素n] 

  注意：
      (1)二维数组可以在取值的时候可以这样子写 list[n][m]
     (2)list 里面的元素的数据类型也可以不同，也存在list元素中有另一个list列表
     (3) list通过 len(list) 函数来算出，一般结果是元素个数

二、列表的“增删改查”

    1、添加元素

    （1）append()方法

    语法：list.append(obj)
    功能描述：在列表中的末尾添加新的对象，
    返回情况：该方法无返回值，但会修改原列表。
    注意：传参是列表数据时，修改传参列表会修改原列表的数据。

a=[1,2,3,4]
b=[]
b.append(a)
a.append('aa')
print(a) #[1, 2, 3, 4, 'aa']
print(b)  # [[1, 2, 3, 4, 'aa']]
####################################
def d(num):
    num.extend(['c','f'])
    print(num) #['c', 'f']
s=[]
s.append([])
d(s[0])
print(s) #[['c', 'f']]

    （2）insert()方法

    语法：list.insert(index,obj)
    功能描述：将指定的对象插入到列表的指定位置，
    返回情况该方法无返回值，但会修改原列表
【注意：列表为空时，位置参数无效。】

tmp=[1,2,3,4,5,6]
tmp.insert(-3,'a')
print(tmp)  #[1, 2, 3, 'a', 4, 5, 6]

    （3）extend()方法

    语法：list.extend(seq)
    功能描述：在列表末尾逐一添加seq序列中的元素，
    返回情况：该方法无返回值，但会修改原列表

    （4）列表拼接

    语法：list1+list2
    功能描述：采用两个列表相加组成一个新的列表
    返回情况：返回一个新的列表，不改变原列表

    （5）zip()方法

语法：tuple_name=zip(v1,v2,...,vN) v1是可迭代对象
功能描述：将传参中两个序列一一对应封装成元组，如果传参长度不一致则会按照短的来打包
返回情况：返回一个由元组组成的列表对象，需通过转换成list才能展示数据值，转换成其他序列类型都会返回空值

实例代码：

a=[1,2,3,4,'d']
b=[3,45,'ee']
c=zip(a,b)
print(list(c))
print(dict(c),tuple(c),set(c))

附加知识：append()和extend()区别

函数名称	区别
append()	将参数整体插入到列表后面
extend()	将参数整体拆分逐个插入到列表后面

实例代码：
向list01中插入缺失的字符 list01=[‘A’,‘B’,‘C’,‘D’,‘F’,‘G’,‘H’,‘J’,‘K’,‘L’,‘M’,‘N’,‘R’,‘S’,‘U’,‘V’,‘W’]

list01=['A','B','C','D','F','G','H','J','K','L','M','N','R','S','U','V','W']
list01.insert(4,"E")  
list01.insert(8,"I")  
list01.insert(list01.index("S")+1,"T")
list01.append("X")
list01.extend(('Y','Z'))
list01=list01[:list01.index("N")+1]+['O','P','Q']+list01[list01.index("N")+1:list01.index("Z")+1]
print(list01)

    2、删除元素

    （1）del方法

语法：del list[start:end:len]
功能描述：删除指定索引值元素或者删除指定序列
返回情况：没有返回值，没有填写索引会将整个列表删除

    （2）pop()方法

语法：list.pop([index=-1])
功能描述：删除列表中指定位置的元素，如果没有写明索引位置则，删除list末尾的元素。
返回情况：该方法返回被删除的元素并修改原列表

    （3）remove()方法

语法：list.remove(obj)
功能描述：删除列表钟指定值的元素，若列表中存在相同的值则会删除第一个值，
返回情况：该方法没有返回值
注意： remove() 方法在移除一个不存在的元素时会发生错误

    （4）整个列表删除

语法：list.clear()
功能描述：删除列表中所有的元素，类似于del list[:]
返回情况：无参数同时无返回值。

实例代码：
将list02中的数字删除，list02=[‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’,22, ‘G’, ‘H’, ‘I’, ‘J’, ‘K’, ‘L’,2,3,4,50, ‘M’, ‘N’, ‘O’, ‘P’, ‘Q’, ‘R’, ‘S’, ‘T’, ‘U’, ‘V’, ‘W’, ‘X’, ‘Y’, ‘Z’,12]

list02=['A', 'B', 'C', 'D', 'E', 'F',22, 'G', 'H', 'I', 'J', 'K', 'L',2,3,4,50, 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',12]
del list02[list02.index(2):list02.index(50)+1]
list02.pop()
list02.remove(22)
print(list02)

    3、修改元素

    (1) 直接元素赋值

语法：list_name[ index [start:end:step] ] =value / seq
功能描述：通过索引找到要修改的位置并赋值
返回情况：没有返回值，但是会修改原列表

实例代码：
修改list03中的错误字符串，list03=[‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘Fgh’, ‘G’, ‘H’, ‘I’, ‘J’, ‘K’, ‘L’, ‘M’, ‘N’, ‘O’, ‘P’, ‘Q’, ‘Rr’, ‘Ss’, ‘Tt’, ‘U’, ‘V’, ‘W’, ‘X’, ‘Y’, ‘Z’]

list03=['A', 'B', 'C', 'D', 'E', 'Fgh', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'Rr', 'Ss', 'Tt', 'U', 'V', 'W', 'X', 'Y', 'Z']
list03[list03.index("Fgh")]='F'
list03[list03.index("Rr"):list03.index("Tt")+1]=["R","S","T"]
print(list03)

    4、查找元素

    （1）index()方法

语法：list.index(obj[,star,end])
功能描述：从列表中的star位置开始找出要查找对象的索引值，
返回情况：该方法返回查找对象的索引位置，没有查找到则返回异常

    （2）count()方法

语法：list.count(obj)
功能描述：统计列表中查找对象出现的次数
返回情况：返回元素在列表中出现的次数。

    （3）成员运算符

语法：obj in list
功能描述：检查obj是否在list中
返回情况：若存在查找的字符则返回true，否则返回false

    （4）enumerate() 方法

语法：enumerate(obj)
功能描述：获取索引和元素
返回情况：返回可迭代对象，遍历可以输出索引和元素

实例代码：

list04=["张智霖","杨千嬅","郑秀文","周星驰","周润发","张国荣","王祖贤","杨千嬅","周润发"]
print(list04.index("周润发"))
print(list04.count("杨千嬅"))
print("林青霞" in list04)
print("张国荣" in list04)
for i,v in enumerate(list04):
   print(i,v)

三、列表的排序与转置

    1、元素排序

语法： list_name.sort(cmp=None, key=None, reverse=False) key为比较元素，reverse为排序规则（false升序，true降序）
功能描述： 对原列表进行排序
返回情况： 没有返回值，但是会修改原列表中元素的排序

a=[1,33,6,3,26]
b=id(a)
a.sort()
print(a)  # [1, 3, 6, 26, 33]
print(b==id(a) # True

补充知识： sort() 和 sorted() 的区别

1. sort() 是 list列表的成员方法；sorted() 可以对所有可迭代的对象进行排序操作。
2. sorted()排序后生成新的一个序列，不修改原列表； sort() 可直接修改原列表
3. 两者使用方法不同，sorted(可迭代的对象)； list对象.sort()

    2、元素转置

语法：list_name.reverse()
功能描述：反向列表中元素
返回情况：没有返回值，但是会对列表的元素进行转置

l=[1,27,53,4,6,7,8,6,8]
l.sort()
print(l)
l.reverse()
print(l)

Python 元组 （taupe）

一、元组的定义

• 跟列表类似，元组是由一系列按特定顺序排序的元素组成，元素由括号括起来，元素之间逗号分隔。
• 元组中的元素不能修改

  语法：

taupe_objext=(元素1,元素2,.....,元素n)

二、元组的操作

    1、元组创建

    （1）直接赋值创建

语法：tuple_name=(v1,v2,...,vN)
功能描述：通过赋值组成元组
返回情况：返回一个元组类型的对象
注意：tuple_name=() 创建一个空元组

    （2）tuple()函数创建

语法：tuple_name=tuple(v1,v2,...,vN)
功能描述：将序列转换成元组类型，所以参数中的元素必须是已定义的
返回情况：返回一个元组类型的数据

    2、访问元组

语法：tuple_name[index[start : end : step]]
功能描述：通过索引访问元组元素
返回情况：返回索引指定的元素

    3、修改元组 (无法修改元素）

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
语法：tuple_name1 + tuple_name2
功能描述：将两个元组拼接
返回情况：返回一个新的元组

    4、删除元组（无法删除元素）

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
语法：del tuple_name
功能描述：将整个元组删除
返回情况：返回元组尚未定义的异常

实例代码：

tuple01=("语文","数学","英语","物理","地理","生物","历史")
print(tuple01[3:])
tuple01=tuple01+('化学','政治')
print(tuple01)

三、元组的内置函数

    1、len()方法

语法：len(tuple_name)
功能描述：计算元组元素的个数
返回情况：返回元组元素的个数

    2、max()方法

语法：max(tuple_name)
功能描述：返回元组中元素最大值
返回情况：返回元组中元素最大值

    3、min()方法

语法：min(tuple_name)
功能描述：返回元组中元素最小值
返回情况：返回元组中元素最小值

    4、tuple()方法

语法：tuple(tuple_name)
功能描述：将可迭代系列转换为元组
返回情况：返回一个新的元组

实例代码：

tuple02=('语文', '数学', '英语', '物理', '地理', '生物', '历史', '化学', '政治')
list0=[1,23,4,5,6,7,8,9]
print(len(tuple02))
print(max(tuple02))
print(min(tuple02))
print(tuple(list0))

Python 字典 （dict）

一、 字典的定义

• 字典是采用一对"{ }"括起来，以“key：value”的键值对形式存储数据。
• 字典的存储位置没有顺序，所以操作字典时不能采用索引值来操作，需要通过key来访问操作。
• key是具有唯一性且要求可哈希，其数据类型一般为不可变类型（数字( int \ float \ bool )，字符串，元组），而value的数据类型没有要求。
• 注意：不可哈希的对象：列表、集合和字典。
• 类似java的HashMap，优点是 查询 、 插入 和 删除 的效率更快，但是无法通过index访问

  语法：

{key1:value1,key2:value2,...,keyN:valueN}

二、字典创建方法

    1、直接创建：

语法：dict={key1:v1,key2:v2}
功能描述：创建一个字典类型的序列
返回情况：返回一个字典类型的序列
注意：dict={} 创建空字典

    2、dict()函数创建：

语法：dict{key1:v1,key2:v2}
功能说明：将序列转换成字典
返回情况：返回一个字典类型的序列
注意： dict() 创建一个空字典

    3、fromkeys()方法

语法：dict.fromkeys(seq[,value])
功能描述：将seq提到的键对应的所有设置初始值，value默认None
返回类型：返回一个被设置初始值的新字典
注意：该方法可以初始化key

    4、字典推导式

语法：{key表达式：值表达式 for循环 [if条件]}
功能描述：根据for循环和if条件生成对应的字典数据
返回情况：返回一个新字典
注意：字典推导式的效率均比普通的for循环效率更高

    5、copy()

语法：dict_name.copy()
功能描述：复制字典
返回情况：返回一个字典（浅拷贝）

    6、deepcopy（）

语法： dict_name.deepcopy()
功能描述： 复制字典
返回情况： 返回一个字典（深拷贝）

    浅拷贝与深拷贝区别：

如果改变原始元素时会修改浅拷贝的的元素，此情况只针对可变的数据类型，如果修改不可变类型则浅拷贝对象则不被修改；深拷贝对象不受影响。

实例代码：

d=dict()
d=d.fromkeys(["姓名","张智霖","杨千嬅","郑秀文"],[])
a=["姓名","张智霖","杨千嬅","郑秀文"]
b=[[],[],[],[]]
c={x:y for x,y in zip(a,b) } #相当于{c={x,y for x,y in d.items()}
print(c)
z="goods_id=17356;goods_name=新疆天山雪梨;price=15.5;specs=1kg"
print({z.split("=")[0]:z.split("=")[1] for z in z.split(";")})
#统计每个字符出现的次数
print({z[i]:z.count(z[i]) for i in range(len(z))})

三、字典的“增删改查”

    1、添加元素

    (1) 直接赋值

语法： dict_name[key]=value
功能描述： 指定对应的key并赋值，若key在字典中已存在，那么会修改key的值，若key在字典中不存在，则新增键值对
返回情况： 没有返回值，但是会修改字典中的值或新增键值对

    (2) update()方法

语法： dict_name.update(key1=value1,...,keyN=valueN / seq)
功能描述： 若key已存在则修改值，若key不存在则新增键值对
返回情况： 没有返回值，但是会修改字典中的值或新增键值对
注意： 该方法也可以拼接两个序列，但会修改原序列

    (3) 拼接方法

语法： dict_name3=dict(list(dict1.items()),list(dict2.items()))
功能描述： 将1和2字典拼接
返回情况： 返回新的字典

实例代码：

d={"班级":["三（2）班"],"姓名":["张三"],"成绩":[89]}
#添加三年（5）班的李四 成绩87
d.update(姓名=['张三', '李四'],班级=['三（2）班', '三年（5）班'],成绩=[89, 87])  #相当于d['班级'].append('三年（5）班')...
#将张三改为王五
d['姓名'][0]='王五'
print(d)
a={1:2,3:12,5:1}
b={6:0,0:8}
c=dict(list(a.items())+list(b.items()))
print(c)

    2、删除键值对

删除键值对一种有3种方法，分别是pop()、clear()和del方法

    (1) pop()方法

语法： dict_name.pop(key[,default])
功能描述： 删除指定的key及其对应的值，如没有找到key返回default值，但default没有值则会抛出异常。
返回情况： 删除原字典的指定值并返回被删除的值

    (2) clear()方法

语法： dict_name.clear()
功能描述： 删除字典中的所有键值对
返回情况： 没有返回值

    (3) del方法

语法： del dict_name[key]
功能描述： 删除指定key对应的值，如果key不存在抛出KeyError异常，如果没有key值则删除整个字典
返回情况： 直接删除指定值无返回值

实例代码：

d={'班级': ['三（2）班', '三年（5）班'], '姓名': ['王五', '李四'], '成绩': [89, 87],'年龄':[12,13]}
d.pop('成绩')
print(d)
del d['姓名']
print(d)
d.clear()
print(d)

    3、修改元素

字典中的键是唯一的，不支持被修改，但是键对应的值可以允许修改，一般通过赋值或update()方法更新值，但前提需要key在字典中。

    4、查询元素

    (1) 键直接访问

第一种：通过一个key访问
语法： dict_object[key]
功能描述： 通过key获取value值
返回情况： 返回对应的value值
注意： 当key是集合时，需要通过整个集合才能找到其值。

第二种：通过多个key访问
语法： itemgetter(*keys)(dict_object) 需from operator import itemgetter
功能描述： 通过*keys序列查询字典对象的值并返回
返回情况： 当传入一个key值返回对应的value值，当传入两个或多个key时以元组数据形式返回对应value值

    (2) get()方法

语法：dict_name.get[ key [ , None ] ]
功能描述： 通过key查询其对应的value值并返回value值，如果没有找到返回逗号后面的默认值
返回情况： 返回对应的value值或默认值

    (3) setdefault()方法

语法： dict_name.setdefault(key,default=None)
功能描述： 类似于get()法,通过key查询其对应的value值并返回value值，如果没有找到返回逗号后面的默认值，但该键值对会插入到字典中。
返回情况： 返回对应的value值或默认值，没有找到键会插入键值对。
注意： 键不在字典中会将参数插入到字典中，若能找到键的话直接返回对应的值

    (4) items()方法

语法： dict_name.items()
功能描述： 以可迭代形式返回键值对数据
返回情况： 返回可迭代的(键, 值) 元组数组

    (5) keys()方法

语法： dict_name.keys()
功能描述： 以列表类型返回字典所有的键
返回情况： 返回字典中所有的键

    (6) values()方法

语法： dict_name.values()
功能描述： 以列表类型返回字典所有的值
返回情况： 返回字典中所有的值

实例代码：

 import operator
d={"姓名":'袁咏仪','别名':'靓靓',"性别":'女',"年龄":51, "身高":170,"体重":56,"职业":'演员','公司':'浙江星河文化经纪有限公司',"配偶":'张智霖',"祖籍":'广东省东莞市',"毕业院校":'香港理工大学'}
print(d['姓名'])
print(operator.itemgetter('别名','性别','身高','公司')(d))
print(d.get('毕业院校'))
print(d.setdefault('现居','未知'))
print(d)
print(d.keys())
print(d.values())
for k,v in d.items():
   print(k,v)

四、字典排序

字典存储时没有顺序但输出时可以人为控制顺序输出，可以通过python的内置函数sorted()控制。
语法： sorted(iterable, key=None, reverse=False)
功能描述： 对可迭代的对象进行排序操
返回情况： 返回元组元素组成的列表
参数说明：
iterable：可迭代对象
key：用于比较的元素
reverse：排序规则， True 降序，False升序

d2={'a1':1,'a2':24,'a3':9,'a4':7}
s1=sorted(d2.items()) #对key排序
print(dict(s1))   # {'a1': 1, 'a2': 24, 'a3': 9, 'a4': 7}
s2=sorted(d2.items(),key=lambda x: x[1]) #对value排序
print(dict(s2))   # {'a1': 1, 'a4': 7, 'a3': 9, 'a2': 24}
s3=sorted(d,key=d.get) #对value排序,但结果只返回key
print(s3) #

五、字典运算符

运算符	描述	运算结果
== /！=	判断两个字典的内容是否【相同或不相同】	true/false
is	身份运算符，判断两个字典是否引用自同一个对象	true/false
in / not in	判断字典是否【包含或不包含】指定的key	true/false
｜ （c=b｜a）	字典合并运算符（3.9版本）	字典类型
｜= （a｜=b）	更新运算符，复合赋值运算符	字典类型

Python 集合（set）

一、集合的定义

集合是一个无序的不重复元素序列，使用{ }或set( )函数创建,

    1、创建集合

    (1) 直接赋值创建

语法： set_name = {value01,value02,...,valueN}
功能描述：直接赋值创建集合对象
返回情况：返回一个新的集合对象
注意：set_name={} 该类型是个字典

    (2) set()函数

语法： set({value1,value2,...,valueN})
功能描述：通过set函数将序列转换成集合类型序列
返回情况：返回一个新的集合对象
注意：set({}) 创建一个空的集合

    (3) copy()函数

语法： set_name1.copy() / set.copy(set_name1)
功能描述：拷贝集合
返回情况：返回一个新的集合对象
注意：复制后的集合不受原始集合的变化而变化

实例代码：

s1={1,2,'cc','dd','ss',23}
s2={}
s3={1}
s4=set()
s5=set.copy(s1) #相当于s1.copy()
s1.add(865)
t1=(1)
t2=(1,)
print(type(s1),type(s2),type(s3),type(s4))
print(type(t1),type(t2))
print(s1,s5)

运行结果：

二、集合的操作

    1、添加元素

给集合添加元素一共有两种方法，分别是add()方法和update()方法

    （1）add()方法

语法：set_name.add(value / seq)
功能描述：给集合添加元素，元素只能可哈希对象即元组、字符串、数值型
返回情况：没有返回值，但是会修改原集合
注意：已存在的元素，则不执行添加操作：

    （2）update()方法

语法：set_name.update(value/seq)
功能描述：修改当前集合，将参数中的元素添加到集合中，若传入参数是序列则将序列中每个元素逐一更新到集合中。
返回情况：没有返回值，但是会修改原集合
注意：传参只能是可迭代对象，元组、列表、集合、字符串

实例代码：

s={1}
s.add('a')
s.add((4,5,7,8,'a'))
s.add(2.7)
s.update("b")
s.update("21")
s.update([1,2,4,4,4,4,'a','bb'])
s.update((5,6,4,5,7,8))
print(s)

运行结果：

    2、移除元素

删除集合中的元素一共有三种方法，分别是remove()方法、discard()方法和pop()方法

    （1）remove()方法

语法：set_name.remove(value/seq)
功能描述：移除集合中的指定元素
返回情况：没有返回值，但是会修改原集合，当元素不存在时会直接抛出KeyError异常

    （2）discard()方法

语法：set_name.discard(value/seq)
功能描述：移除指定的集合元素
返回情况：没有返回值，但是会修改原集合，当元素不存在时也不会抛出异常

    （3）pop()方法

语法：set_name.pop()
功能描述：随机移除集合中的一个元素
返回情况：没有传入参数，返回被移除的元素

    （4）clear()方法

语法：set_name.clear()
功能描述：清空集合
返回情况：返回空集合set()

实例代码：

s={1,2,3,'a',('b','c'),7,9,'y','e','j',(1,23)}
s.remove('a')
s.remove(('b','c'))
s.update([4,5,6])
s.add(8)
s.discard('e')
s.remove('y')
s.discard('j')
s.discard((1,23))
print(s)
s.pop()
print(s)
s.clear()
print(s)

运行结果：

    3、计算集合元素个数

    （1）len()方法

语法：len(set_name)
功能描述：计算集合中元素的个数，其中元素包括序列数据类型
返回情况：返回元素的个数
注意：由于集合中的元素不存在重复现象，所以set没有内置的count()函数

    4、判断元素是否存在

    （1）判断元素是否存在

1、成员运算符
语法："value/seq" in/not in set_name
功能描述：判断元素是否存在集合中
返回情况：true / false

2、issubset() 方法
语法：set_name1.issubset(set_name2) / set.issubset(set_name1,set_name2)
功能描述：判断set_name1元素是否存在set_name2集合中，只能对比两个集合
返回情况：true / false
注意： 当set..issubset(set_name1,set_name2,set_name3)时，会直接默认判断set_name1元素是否存在set_name2集合中

3、isdisjoint() 方法
语法：set_name1.isdisjoint(set_name2) / set.isdisjoint(set_name1,set_name2)
功能描述：判断两个集合中元素是否有交集
返回情况：true / false

    （2）判断两个集合元素是否相同

1、issuperset() 方法
语法：set_name1.issuperset(set_name2)
功能描述：判断set_name1中所有元素是否存在set_name2集合中
返回情况：true / false

s1={9,1,2,3,4,8,6,5}
s2={1,2,3}
s3={65,24,61,24,57,57,43,67}
s4=s3.copy()
print(2 in s1,s2 in s1,set.issubset(s2,s1),s4.issubset(s3)) #s2.issubset(s1)
print(s3.issuperset(s4),s2.issuperset(s3))
print(s1.isdisjoint(s3),s1.isdisjoint(s2))

    5、集合的并集

    （1）union() 方法

语法：set_name.union(set1[, set2...,setN])
功能描述：求两个集合的并集
返回情况：返回一个新集合

    （2） “|” 运算符

语法：set_name1 | set_name2
功能描述：求两个集合的并集
返回情况：返回一个新集合

实例代码：

s1={1,2,3,4,4}
s2={5,6,7,8,9}
print(s1|s2)
print((s1|s2)==(s1.union(s2)))

运行结果：

    6、集合的交集

    （1）intersection()方法

语法：set_name1.intersection(set_name2)
功能描述：求两个集合的交集
返回情况：返回一个新集合

    （2）“&”运算符

语法：set_name1&set_name2
功能描述：求两个集合的交集
返回情况：返回一个新集合

    （3）intersection_update()方法

语法：set_name1.intersection_update(set_name2)
功能描述：求两个集合的交集
返回情况：无，直接修改原始集合
注意：当set.intersection_update(set_name1,set_name2,set_name3)时，会直接默认修改set_name1

实例代码：

s1={1,2,3,4,4}
s2={5,6,7,8,9,4}
s3={6,34,5,8,9,6,4}
print(s1.intersection(s2,s3))
print(set.intersection(s1,s2,s3))
print((s1&s2&s3)==(s3.intersection(s2,s1)))
s3.intersection_update(s1,s2)
print(s1,s2,s3)

运行结果：

    7、集合的差集

    （1）difference()方法

语法：set_name1.difference(set_name2[,set_name3..,set_nameN])
功能描述：求两个集合的差集
返回情况：返回一个新的集合，集合元素为set_name1的集合去掉两者的并集
注意：当set.difference(set_name1,set_name2,set_name3)时，会直接默认set_name1去掉剩余两者的并集

    （2）相减法

语法：set_name1-set_name2
功能描述：求两个集合的差集
返回情况： 返回一个新的集合，集合元素为set_name1的集合去掉两者的并集

    （3）difference_update()方法

语法：set_name1.difference_update(set_name2)
功能描述：求两个集合的差集
返回情况： 返回一个新的集合，集合元素为set_name1的集合去掉两者的并集
注意：当set.difference_update(set_name1,set_name2,set_name3)时，会直接默认set_name1去掉剩余两者的并集并修改set_name1

实例代码：

s1={1,2,3,4,4}
s2={5,6,7,8,9,4}
s3={6,34,5,8,9,6,4}
print(s1.difference(s2,s3))
print(set.difference(s2,s3))
print((set.difference(s2,s3))==(s3-s2))
print((s1.difference(s2,s3))==(s1-s2-s3))
s2.difference_update(s3)
print(s1,s2,s3)

运行结果：

序列数据类型区别

数据类型	元素是否可变	是否有序	是否可哈希	运算
列表	✔	✔	×	list*number / list1+list2(操作前后序列的id值不变)
元组	×	✔	✔	tuple*number / tuple1+tuple2 ( 操作前后序列的id值改变)
字典	✔	×	×	×
集合	✔	×	×	×