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值改变)
字典	✔	×	×	×
集合	✔	×	×	×

Python序列数据类型相关推荐

1. Python序列 数据类型 创建方式 Tuple元组 Str字符串 List列表 dict字典 Set集合 range,zip,map,enumerate

   Python 序列分类 数据类型 详细介绍 Python 主要数据类型: 元组Tuple, 字符串Str,列表List,字典Dict,集合Set 对比 元组Tuple 字符串Str 列表List 字典 ...

2. python序列数据类型_python 数据类型 序列——列表

   python 数据类型 序列--列表 浏览次数: 发布时间:2015-08-21 11:38 python 数据类型 序列--列表 **列表** list是处理一组有序项目的数据结构,即你可以在一个列 ...

3. python序列数据类型_Python 数据类型 之 序列类型

   序列:表示索引为非负整数的有序对象集合,所有序列都支持迭代 序列类型有:字符串,列表,元组 三种 字符串也是一种序列 列表和元组是任意python对象的序列或叫有序集合 字符串和元组不可变序列,列表支 ...

4. python基本数据类型之序列类型及通用操作

   目录 前言: 一.序列类型 二.字符串str 1.定义 2.字符串的常见操作 3.字符串的常用方法 1)join字符串拼接 2)find查找元素 3)count统计元素个数 4)replace替换字符 ...

5. python序列类型包括哪三种映射类型_python序列类型包括哪三种_后端开发

   python中表达式4+0.5值的数据类型为?_后端开发 python中表达式4+0.5值的数据类型为浮点型,因为4是整型,0.5是浮点型,在python中规定整型和浮点型相加,结果是浮点型,这是为了 ...

6. Python的零基础超详细讲解（第四天）-Python的数据类型

   Python 基本数据类型 Python 中的变量不需要声明.每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建. 在 Python 中,变量就是变量,它没有类型,我们所说的"类型&q ...

7. python核心数据类型_Python核心数据类型-列表

   Python核心数据类型-列表 关于列表的重要属性 列表是任意对象的有序集合,列表中可以包含任何种类的对象,数字 字符串 或者是其他列表 列表可以通过偏移来读取其中的元素,也可以通过分片读取列表中的某 ...

8. python核心数据类型_Python核心数据类型—元组

   Python核心数据类型-元组 Python元组与列表类似,但是元组属于不可变类型 创建元组 a = () #创建空元组 a = (1, 2, 3) #创建一个元组 a = [1, 2, 3] b = ...

9. python序列类型映射类型_Python的数据访问模型与序列介绍

   前面小节介绍了 Python 的 Dict 字典类型,这只是 Python 众多数据类型的其中一个.那么接下来在这个小节里,我们看看 Python 还有哪些数据类型. Python的数据访问模型:直接 ...

最新文章

1. 深度学习编译器综述The Deep Learning Compiler
2. 采用编码器-解码器匹配语义分割的图像压缩
3. 云安全与我们未来的网络息息相关……
4. CentOS 6.5下Redis安装配置记录
5. LSD-SLAM 编译过程（Ubuntu 14.04 + ROS Indigo
6. 7-1 堆栈操作合法性（20 分）
7. IntelliJ IDEA 15快捷键大全
8. 【初窥javascript奥秘之闭包】叶大侠病都好了，求不踩了：）
9. 【图像处理】——图像特效处理（马赛克、图像融合、毛玻璃等）
10. 利用tushare实现选股
11. 物业缴费管理系统 微小区 物业社区公众号开发 物业APP小程序源码
12. 批改网作文提交时分析不出来_推荐一款免费英语写作批改软件
13. UDP protocol--udp_rcv
14. 5G千兆路由器工业物联网应用
15. P1567 统计天数 python代码
16. Android 全面屏处理（适配挖孔屏、刘海屏） kotlin
17. 主动降噪(Active Noise Control)
18. 解决Maven打包没有依赖jar包问题
19. 洋洋洒洒688字带你彻底吃透Zuul的插件机制及定制化开发
20. 国科大学习资料--机器人学导论（张正涛）--2017年期末考试试卷

热门文章

1. 如何评价一个新技术——以 ChatGPT 为例
2. 【深度学习】Deep Learning必备之必背十大网络结构
3. kafka系列（3）- kafka的安装
4. [日本旅游] 东京晴空塔
5. Glide硬盘缓存逻辑
6. iPhone6 AirDrop找不到我的mac解决方法！注销mac和iPhone的icloud账号
7. VIN码含义及其算法
8. 怎么设计一张点击率高的淘宝爆款主图？
9. VC 清除IE缓存、cookie、历史记录等
10. 高完整性系统工程（四）： Checking Formal Specifications