python序列方法大全

Python中列表，元组，字典，集合的常用方法。

一、列表所有方法：(obj表示元素，index表示下标)**

1.append(obj)

用法：向列表末尾添加元素

arr = [1,2,3,4]
print("列表arr=",arr)
arr.append(5)#在列表arr末尾添加一个元素5
print("添加元素5后的列表arr=",arr)

'''
结果：
列表arr= [1, 2, 3, 4]
添加元素5后的列表arr= [1, 2, 3, 4, 5]
'''

2.insert(index,obj)

用法：向列表指定的索引处添加元素

arr = [1,2,3,4]
print("列表arr=",arr)
arr.insert(2,5)#在列表arr索引为2的位置插入一个元素5
print("添加元素5后的列表arr=",arr)

'''
结果：
列表arr= [1, 2, 3, 4]
添加元素5后的列表arr= [1, 2, 5, 3, 4]
'''

如果的指定的索引超出列表索引范围则在列表末尾或第一个位置添加。

超过正索引范围添加在末尾

arr = [1,2,3,4]
print("列表arr=",arr)
arr.insert(10,5)#在列表arr索引为10的位置插入一个元素5(此时索引10已经超出列表正索引范围）
print("添加元素5后的列表arr=",arr)

'''
结果：
列表arr= [1, 2, 3, 4]
添加元素5后的列表arr= [1, 2, 3, 4, 5]
'''

超出负索引范围添加在第一个

arr = [1,2,3,4]
print("列表arr=",arr)
arr.insert(-7,5)#在列表arr索引为-7的位置插入一个元素5(此时索引-7已经超出列表负索引范围）
print("添加元素5后的列表arr=",arr)

'''
结果：
列表arr= [1, 2, 3, 4]
添加元素5后的列表arr= [5, 1, 2, 3, 4]
'''

3.sort（reverse=False）

用法：reverse 默认为Flase，可以不写。表示对列表进行排序（int类型，从小到大，字符串按字母顺序从小到大）如果列表里面有数值和字符串则执行sort方法报错，reverse=True表示从大到下。

arr = [1,3,2,6,4,5]
phone = ['apple','huawei','xiaomi','meizu','oppo','vivo']
print("列表arr=",arr)
arr.sort() #arr.sort(reverse=False)和arr.sort()效果一样都是升序，reverse默认为False
print("排序后的列表arr=",arr)
print('-----元素为字符-----')
print("列表phone=",phone)
phone.sort()
print("排序后的列表phone=",phone)

'''
结果：
列表arr= [1, 3, 2, 6, 4, 5]
排序后的列表arr= [1, 2, 3, 4, 5, 6]
-----元素为字符-----
列表phone= ['apple', 'huawei', 'xiaomi', 'meizu', 'oppo', 'vivo']
排序后的列表phone= ['apple', 'huawei', 'meizu', 'oppo', 'vivo', 'xiaomi']
'''

属性 reverse = True的情况

arr = [1,3,2,6,4,5]
phone = ['apple','huawei','xiaomi','meizu','oppo','vivo']
print("列表arr=",arr)
arr.sort(reverse=True) #arr.sort(reverse=False)和arr.sort()效果一样都是升序，reverse默认为False
print("排序后的列表arr=",arr)
print('-----元素为字符-----')
print("列表phone=",phone)
phone.sort(reverse=True)
print("排序后的列表phone=",phone)

'''
结果：
列表arr= [1, 3, 2, 6, 4, 5]
排序后的列表arr= [6, 5, 4, 3, 2, 1]
-----元素为字符-----
列表phone= ['apple', 'huawei', 'xiaomi', 'meizu', 'oppo', 'vivo']
排序后的列表phone= ['xiaomi', 'vivo', 'oppo', 'meizu', 'huawei', 'apple']
'''

列表中既有数值型也有字符串型sort()方法报错。

arr = [1,3,2,6,4,5,"小米"]
arr.sort()
print(arr)

'''
结果：
TypeError: '<' not supported between instances of 'str' and 'int'
'''

4.index(obj，start_index，end_index)

用法：返回元素在列表start_index 到 end_index(不包含end_index)范围中的第一次出现的索引值，start_index和end_index可以省略，若省略其中一个，表示从start_index 到末尾。（步长为1的切片操作），若元素不存在报错。

重点：若obj不在列表列表里面，则报错。

省略start_index 和 end_index参数

arr = ['a', 'b', 'c', 'd', 'e','a','b','c','d' 'x']
# 索引   0    1    2    3    4   5   6   7   8   9
n = arr.index('b') #元素b在列表中出现2次，此时省略了开始索引和结束索引，就是列表从头到尾，第一次出现元素b对应的索引。
print("n=",n)

'''
n= 1
'''

省略其中一个参数

arr = ['a', 'b', 'c', 'd', 'e','a','b','c','d' 'x']
# 索引   0    1    2    3    4   5   6   7   8   9
n = arr.index('b',1) #此时省略了其中1个参数，就是从索引1到末尾，第一次出现元素b对应的索引。
n1 = arr.index("b",5)#此时省略了其中1个参数，就是从索引5到末尾，第一次出现元素b对应的索引。
print("n=",n)
print("n1=",n1)

'''
n= 1
n1= 6
'''

start_index和end_index参数都存在

arr = ['a', 'b', 'c', 'd', 'e','a','b','c','d' 'x']
# 索引   0    1    2    3    4   5   6   7   8   9
n = arr.index('b',1,5) #就是从索引1到索引5(不包含5)，第一次出现元素b对应的索引。
n2 = arr.index("b",3,7)#就是从索引2到索引7，第一次出现元素b对应的索引。
print("n=",n)
print("n2=",n2)

'''
n= 1
n2= 6
'''

元素不在列表中，报错

arr = ['a', 'b', 'c', 'd', 'e','a','b','c','d' 'x']
# 索引   0    1    2    3    4   5   6   7   8   9
n = arr.index("z") #列表中没有元素z


'''
结果：
ValueError: 'z' is not in list
'''

arr = ['a', 'b', 'c', 'd', 'e','a','b','c','d' 'x']
# 索引   0    1    2    3    4   5   6   7   8   9
n = arr.index("b",2,6) # 此时，虽然第二个b对应的索引为6，但是不包含结束索引，所以查找范围中没有元素b

'''
结果：
ValueError: 'b' is not in list
'''

5.reverse()

用法:将列表进行翻转，逆序输出，（并没有排序）

arr = [1,2,'a','b',3.14]
arr.reverse() #对列表进行反向输出，并不是排序
print("arr=",arr)

'''
结果：
arr= [3.14, 'b', 'a', 2, 1]
'''

6.remove(obj)

用法：删除元素，如果列表中有重复的元素，删除前面的，若元素不存在，报错。

arr = ['a','b','c','a','d','f']
arr.remove("a") #此时列表中有两个a，删除靠前面的a
print("arr=",arr)
'''
结果：
arr= ['b', 'c', 'a', 'd', 'f']
'''

若删除的元素不在列表中，则报错。

arr = ['a','b','c','a','d','f']
arr.remove("z") #列表中没有元素z，则报错
print("arr=",arr)
'''
结果：
ValueError: list.remove(x): x not in list
'''

7.count（obj）

用法：返回的是元素在列表里面的个数。

arr = ['a','b','c','a','d','f']
n = arr.count("a") #元素a在列表中有2个，结果为2
n1 = arr.count("b") #元素b在列表中有1个，结果为1
n2 = arr.count("z") #元素z在列表中没有，结果为0
print("n=",n)
print("n1=",n1)
print("n2=",n2)
'''
结果：
n= 2
n1= 1
n2= 0
'''

8.clear（）

用法：清空列表中的所有元素。

arr = ['a','b','c','a','d','f']
print("原列表arr=",arr)
arr.clear()
print("清空后列表arr=",arr)
'''
结果：
原列表arr= ['a', 'b', 'c', 'a', 'd', 'f']
清空后列表arr= []
'''

9.copy（）

用法：浅拷贝列表，不等价于=

10.extend()

用法：扩展列表（将别的序列的元素添加到列表中）

参数为字符串：

arr = [1,2,3]
print("原列表arr=",arr)
arr.extend("abc")
print("扩展后列表arr=",arr)
'''
结果：
原列表arr= [1, 2, 3]
扩展后列表arr= [1, 2, 3, 'a', 'b', 'c']
'''

参数为列表：

arr = [1,2,3]
print("原列表arr=",arr)
arr.extend(['a','b','c'])
print("扩展后列表arr=",arr)
'''
结果：
原列表arr= [1, 2, 3]
扩展后列表arr= [1, 2, 3, 'a', 'b', 'c']
'''

参数为元组：

arr = [1,2,3]
print("原列表arr=",arr)
arr.extend(('a','b','c'))
print("扩展后列表arr=",arr)
'''
结果：
原列表arr= [1, 2, 3]
扩展后列表arr= [1, 2, 3, 'a', 'b', 'c']
'''

参数为集合：

arr = [1,2,3]
print("原列表arr=",arr)
arr.extend({'a','b','c'})
print("扩展后列表arr=",arr)
'''
结果：
原列表arr= [1, 2, 3]
扩展后列表arr= [1, 2, 3, 'a', 'b', 'c']
'''

参数为字典：

arr = [1,2,3]
print("原列表arr=",arr)
arr.extend({'a':1,'b':2,'c':3})
print("扩展后列表arr=",arr)
'''
结果：
原列表arr= [1, 2, 3]
扩展后列表arr= [1, 2, 3, 'a', 'b', 'c']
'''

用法：若index没有，删除列表最后一个元素，若index存在，则删除index对应的元素，此方法返回值为删除的元素。

index参数省略

arr = ['a','b','c','d']
print("原列表arr=",arr)
arr.pop() #参数省略，删除最后一个元素
print("列表arr=",arr)

'''
结果：
原列表arr= ['a', 'b', 'c', 'd']
列表arr= ['a', 'b', 'c']
'''

index参数存在

arr = ['a','b','c','d']
print("原列表arr=",arr)
arr.pop(1) #删除索引为1对应的元素。
print("列表arr=",arr)

'''
结果：
原列表arr= ['a', 'b', 'c', 'd']
列表arr= ['a', 'c', 'd']
'''

index参数超出范围则删除最后一个

arr = ['a','b','c','d']
print("原列表arr=",arr)
arr.pop(7) #7已经超出列表索引范围，则报错。
print("列表arr=",arr)

'''
结果：
IndexError: pop index out of range
'''

二、元组的所有方法

元组的特性：有序不可变的序列。

1.count（）

2.index（）

以上2个方法同列表的count和index方法相同用法。

三、字典的所有方法

1.clear()

用法： clear() 用于清空字典中所有的 key-value 对，对一个字典执行 clear() 方法之后，该字典就会变成一个空字典。

2.update(字典)

用法：update() 方法可使用一个字典所包含的 key-value 对来更新己有的字典。在执行 update() 方法时，如果被更新的字典中己包含对应的 key-value 对，那么原 value 会被覆盖；如果被更新的字典中不包含对应的 key-value 对，则该 key-value 对被添加进去。

3.items（）

用法： 以列表返回可遍历的(键, 值) 元组数组

scores_dict = {'语文': 105, '数学': 140, '英语': 120}
print(scores_dict.items()) 
# 输出 dict_items([('语文', 105), ('数学', 140), ('英语', 120)])

4.keys()

用法：以列表形式返回一个字典所有的键

scores_dict = {'语文': 105, '数学': 140, '英语': 120}
print(scores_dict.keys())  
# 输出 dict_keys(['语文', '数学', '英语'])

5.values()

用法：以列表形式返回字典中的所有值

scores_dict = {'语文': 105, '数学': 140, '英语': 120}
print(scores_dict.values()) 
# 输出 dict_values([105, 140, 120])

6.pop()

用法： pop() 方法用于获取指定 key 对应的 value，并删除这个 key-value 对。如下方法示范了 pop() 方法的用法：

scores_dict = {'语文': 105, '数学': 140, '英语': 120}
scores_dict.pop('英语')   # 删除'英语'的键和值
print(scores_dict)  # 输出{'语文': 105, '数学': 140}

7.get(key， default=None )

用法：get() 方法其实就是根据 key 来获取 value，它相当于方括号语法的增强版，当使用方括号语法访问并不存在的 key 时，字典会引发 KeyError 错误；但如果使用 get() 方法访问不存在的 key，该方法会简单地返回 None，不会导致错误。若指定了default参数，返回default参数。

d = {"a":1,"b":2}
print(d.get("a")) #输出 1
print(d.get("a",10)) # 输出1， 因为a在字典中存在
print(d.get("z")) # 输出None 因为default默认为None
print(d.get("z",10)) # 输出10 因为指定default的值为10
print(d) # 原字典没有变化 get()方法不会影响到原字典

8.setdefault (key， default=None)

用法：跟get()方法类似，如果key在字典中，返回对应的值，如果key不在字典中，则插入key及设置的默认值defalult，default默认值为None。

d = {"a":1,"b":2}
print(d.setdefault("a")) # 输出1，键a对应的值为1
print(d.setdefault("a",10)) #输出1，因为键a 对应的值为1
print(d.setdefault("z")) # 输出None，因为default=None
print(d) #此时原字典发生了变化，插入了z:None 键值对

d = {"a":1,"b":2}
print(d.setdefault("a")) # 输出1，键a对应的值为1
print(d.setdefault("a",10)) #输出1，因为键a 对应的值为1
print(d.setdefault("z",20)) #输出20，因为指定了default=20
print(d) #原字典发生改变，插入z：20的键值对

9.fromkeys(序列，value)

用法：快速初始化字典，创建相同value的字典。

print(dict.fromkeys("abc")) #所有键对应的值都是None
print(dict.fromkeys(["a","b","c"],10)) #所有键对应的值都是10
print(dict.fromkeys(("a","b","c"),10))
print(dict.fromkeys({"a","b","c"},10)) #注意集合是无序的

结果：

{'a': None, 'b': None, 'c': None}
{'a': 10, 'b': 10, 'c': 10}
{'a': 10, 'b': 10, 'c': 10}
{'b': 10, 'c': 10, 'a': 10}

10.pop(key)

用法：删除括号内key对应的键值对。

返回值：当前key对应的value。

dict1 = {"姓名": "千寻", "年龄": "10", "爱好": "跳舞"}
print(dict1.pop("爱好")) 
# 返回当前被删除的键值对中key "爱好" 对应的value
print(dict1)
# 执行结果：跳舞
{'姓名': '千寻', '年龄': '10'}

11.popitem()

用法：删除字典的最后一个键值对。

注意：现在很多资料对字典的popitem方法的解释还是“随机删除一个键值对”，但是从python3.6开始，字典变得有序之后，popitem是固定的删除字典的最后一个键值对。

adict = {'a': 1, 'b': 2, 'c': 3}
adict.popitem()
print(adict)
# 运行结果{'a': 1, 'b': 2}

四、集合的所有方法

集合的性质：无序性，互异性，确定性。

• 集合无法通过索引获取元素
• 集合无获取元素的任何方法
• 集合只是用来处理列表或元组的一种临时类型，它不适合存储、传输数据

1.add(ojb)

用法： 用于集合中添加一个元素，如果集合中已经存在该被添加的元素，则不添加。

test_set = {'name', 'age', 'birthday'}
test_set.add('sex')
test_set.add('name')
print(test_set)
# 执行结果如下：
# >>> {'sex', 'birthday', 'age', 'name'}	已存在的 'name' 元素，未再次执行添加

2.update(seq)

用法： 在集合中加入序列(集合，列表、元组、字符串)中的元素。如果内的元素在原集合中存在不添加。

test_set = set()
test_list = ['name', 'age', 'birthday']
test_set.update(test_list)
print(test_set)

# 执行结果如下：
# >>> {'birthday', 'age', 'name'}		列表的成员(元素)被添加进集合

test_tuple = (666, 888)
test_set.update(test_tuple)
print(test_set)

# 执行结果如下：
# >>> {'name', 'birthday', 'age', 888, 666}		元组的成员(元素)被添加进集合

name = 'Neo'
test_set.update(name)
print(test_set)

# 执行结果如下：
# >>> {'name', 'N', 'birthday', 'e', 'age', 'o', 888, 666}		字符串是每个字符都作为元素被添加进集合的

3.remove(obj)

用法 ：将集合中某个元素删除，如果该元素不存在则会报错。注意obj是集合中的元素，不是索引

test_set = set()
test_list = ['name', 'age', 'birthday']
test_set.update(test_list)
print(test_set)

# 执行结果如下：
# >>> {'name', 'birthday', 'age'}


test_set.remove('age')
print(test_set)

# 执行结果如下：
# >>> {'birthday', 'name'}


test_set_01 = set()
test_set.remove('test')
print(test_set_01)

# 执行结果如下：
# >>> KeyError: 'test'		'test'元素不存在则报错。

4.discard(obj)

用法：：将集合中某个元素删除，如果该元素不会报错。注意obj是集合中的元素，不是索引。

s = {'a','b','c','d','e','f'}
s.discard("a") #集合s中存在元素a
print(s) #运行结果{'b', 'e', 'c', 'f', 'd'}

s = {'a','b','c','d','e','f'}
s.discard("z")#集合s中不存在元素a。
print(s) #即使元素不在s中，也不会报错。

总结：discard和remove区别：remove()只有删除存在的元素才不会报错，若元素不存在则会报错。discard()若元素存在则删除，元素不存在不删除，不报错。

5.clear()

用法：清空当前集合中的所有元素。

d = {1,2,3,4}
print("清空前集合d:",d)#清空前集合d: {1, 2, 3, 4}
d.clear()
print("清空后集合d",d)  #清空后集合d: set()

6.pop()

用法：随机删除集合中的元素（对于字典和字符串转换的集合是随机删除的，当集合是由列表和元组转换时，pop()方法是从左边删除元素。（多运行几次，每次结果都不一样）

s = {'a','b','c','d','e','f'}
s.pop()
print(s)
# 结果{'f', 'd', 'b', 'e', 'a'}

7.copy()

用法：将集合进行一次浅拷贝

s = {'a','b','c','d','e','f'}
a = s.copy()
print(s)
print(a)
# 结果
#{'f', 'c', 'b', 'a', 'd', 'e'}
#{'a', 'f', 'c', 'd', 'b', 'e'}
# 因为集合的无序性，所以复制后的集合元素是一样的，顺序不一样

集合的copy方法和=的区别，同集合一样。

集合的交集、差集、并集操作。

说明：

1.两个集合的操作，结果为新的集合，不会影响到原集合。

2.如果两个集合进行操作，结果为空集的情况下，结果不能写{}，而是写set()

8.difference()

用法：返回集合的差集，即返回的集合元素包含在第一个集合中，但不包含在第二个集合中。a 和 b 两个集合，由所属于 a 且不属于 b 的元素组成的集合叫做 a 集合 与 b 集合 的差集。（生成的集合相当于a集合中去掉a集合与b集合的交集）

s = {1,2,3,4,5}
s1 = {3,4,5,6,7}
print("s=",s)
print("s1=",s1)
result = s.difference(s1)#结果产生一个新的集合
print("result=",result)

'''
结果：
s= {1, 2, 3, 4, 5}
s1= {3, 4, 5, 6, 7}
result= {1, 2}
'''

重点：-（减号）作用与difference()方法的作用一样。也是求两个集合的差集。

s = {1,2,3,4,5}
s1 = {3,4,5,6,7}

print("s=",s1)
print("s1=",s1)
result = s - s1
print("result=",result) #结果产生一个新的集合

'''
结果：
s= {1, 2, 3, 4, 5}
s1= {3, 4, 5, 6, 7}
result= {1, 2}
'''

9.difference_update()

用法： 从集合a中删除集合b的所有元素，本质上就是集合a中删除两个集合的交集部分。与difference方法对比，difference方法返回两个集合的交集，而difference_update则是从原集合里删除两个集合的交集部分。改变的是原集合（集合a），就是把集合a与集合b的difference()方法是生成的新集合赋值给集合a。

s = {1,2,3,4,5,6}
s1 = {5,6,7,8}
print("s=",s)
print("s1=",s1)
print("集合s与集合s1的交集：",s.intersection(s1))
result = s.difference(s1)
s.difference_update(s1)
print("result=",result) #difference方法生成一个新的集合。
print("集合s=",s) #从集合s中删除集合s与集合s1的交集，改变的是原集合。

'''
结果：
s= {1, 2, 3, 4, 5, 6}
s1= {8, 5, 6, 7}
集合s与集合s1的交集： {5, 6}
result= {1, 2, 3, 4}
集合s= {1, 2, 3, 4}
'''

10.intersection()

用法：返回两个集合的交集(同数学交集运算)。既返回的集合元素既在第一个集合中，也在第二个集合中。

s = {1,2,3,4,5}
s1 = {3,4,5,6,7}
print("s=",s1)
print("s1=",s1)
result = s.intersection(s1) #结果产生一个新的集合
print("result=",result)
'''
结果：
s= {1, 2, 3, 4, 5}
s1= {3, 4, 5, 6, 7}
result= {3, 4, 5}
'''

重点：& 符号作用与intersection()作用是一样的，也是求两个集合的交集。

s = {1,2,3,4,5}
s1 = {3,4,5,6,7}
print("s=",s1)
print("s1=",s1)
result = s & s1 #结果产生一个新的集合
print("result=",result)

'''
结果：
s= {1, 2, 3, 4, 5}
s1= {3, 4, 5, 6, 7}
result= {3, 4, 5}
'''

11.intersection_update()

用法： intersection_update方法先计算多个集合的交集然后用交集更新替换原集合，，本质上是删除原集合中集合a与集合b交集以外的其他元素。如果交集是空集合，那么原集合最终也被更新为空集合。就是把集合a与集合b的intersection方法是生成新的集合赋值给集合a

s = {1,2,3,4,5,6}
s1 = {5,6,7,8}
print("s=",s)
print("s1=",s1)
print("集合s与集合s1的交集：",s.intersection(s1))
result = s.intersection(s1)
s.intersection_update(s1)
print("result=",result) #intersection方法生成一个新的集合。
print("集合s=",s) #从集合s中删除集合s与集合s1的交集以外的元素，改变的是原集合。


'''
结果：
s= {1, 2, 3, 4, 5, 6}
s1= {8, 5, 6, 7}
集合s与集合s1的交集： {5, 6}
result= {5, 6}
集合s= {5, 6}
'''

12.union()

用法：返回两个集合的并集（同数学并集运算）。

s = {1,2,3,4,5}
s1 = {3,4,5,6,7}
print("s=",s)
print("s1=",s1)
result = s.union(s1) #结果产生一个新的集合
print("result=",result)
'''
结果：
s= {1, 2, 3, 4, 5}
s1= {3, 4, 5, 6, 7}
result= {1, 2, 3, 4, 5, 6, 7}
'''

重点：| 符号的作用与union()作用是一样的，也是求两个集合的并集

s = {1,2,3,4,5}
s1 = {3,4,5,6,7}
print("s=",s)
print("s1=",s1)
result = s | s1 #结果产生一个新的集合
print("result=",result)
'''
结果：
s= {1, 2, 3, 4, 5}
s1= {3, 4, 5, 6, 7}
result= {1, 2, 3, 4, 5, 6, 7}
'''

13.symmetric_difference()

作用： 返回包含两个集合中的所有元素，但不包含两个集合中都存在的元素。

s = {1,2,3,4,5}
s1 = {3,4,5,6,7}
print("s=",s)
print("s1=",s1)
result = s.symmetric_difference(s1) #结果产生一个新的集合
print("result=",result)
'''
结果：
s= {1, 2, 3, 4, 5}
s1= {3, 4, 5, 6, 7}
result= {1, 2, 6, 7}
'''

重点：^ 符号的作用同symmetric_difference()的作用是一样的。

s = {1,2,3,4,5}
s1 = {3,4,5,6,7}
print("s=",s)
print("s1=",s1)
result = s ^ s1 #结果产生一个新的集合
print("result=",result)
'''
结果：
s= {1, 2, 3, 4, 5}
s1= {3, 4, 5, 6, 7}
result= {1, 2, 6, 7}
'''

14.symmetric_difference_update()

用法： symmetric_difference_update方法与symmetric_difference类似，都是计算两个集合不重复的部分，区别是symmetric_difference方法返回不重复元素组成的集合（返回新的集合），而symmetric_difference_update就是把集合a与集合b的symmetric_difference生成的集合赋值给集合a。

s = {1,2,3,4,5,6}
s1 = {5,6,7,8}
print("s=",s)
print("s1=",s1)
print("集合s与集合s1的交集：",s.intersection(s1))
result = s.symmetric_difference(s1)
s.symmetric_difference_update(s1)
print("result=",result) #intersection方法生成一个新的集合。
print("集合s=",s)


'''
结果：
s= {1, 2, 3, 4, 5, 6}
s1= {8, 5, 6, 7}
集合s与集合s1的交集： {5, 6}
result= {1, 2, 3, 4, 7, 8}
集合s= {1, 2, 3, 4, 7, 8}
'''

15.issubset()

用法： 子集测试。如果 集合a与集合b相同或集合a是集合b的子集,返回 True ,否则返回 False 。

s = {1,2,3}
s1 = {1,2,3,4,5,6}
s2 = {1,2,3}
s3 = {1,2,5,6,7}
print("s=",s)
print("s1=",s1)
result = s.issubset(s1)
result1 = s.issubset(s2)
result2 = s.issubset(s3)
print("result=",result) #集合s是集合s1的子集，结果为True
print("result1=",result1) #集合s与集合s2相同，结果为True
print("result2=",result2) #集合s不是集合s3的子集，结果为False
'''
结果：
s= {1, 2, 3}
s1= {1, 2, 3, 4, 5, 6}
result= True
result1= True
result2= False
'''

重点：<= （小于等于）的作用与issubset() 方法的作用是一样的。

s = {1,2,3}
s1 = {1,2,3,4,5,6}
s2 = {1,2,3}
s3 = {1,2,5,6,7}
print("s=",s)
print("s1=",s1)
result = s <= s1
result1 = s <= s2
result2 = s <= s3
print("result=",result) #集合s是集合s1的子集，结果为True
print("result1=",result1) #集合s与集合s2相同，结果为True
print("result2=",result2) #集合s不是集合s3的子集，结果为False
'''
结果：
s= {1, 2, 3}
s1= {1, 2, 3, 4, 5, 6}
result= True
result1= True
result2= False
'''

重点：< (小于号)的作用是判断集合a是不是集合b的真子集

s = {1,2,3}
s1 = {1,2,3,4,5,6}
s2 = {1,2,3}
s3 = {1,2,5,6,7}
print("s=",s)
print("s1=",s1)
print("s2=",s2)
print("s3=",s3)
result = s < s1
result1 = s < s2
result2 = s < s3
print("result=",result) #集合s是集合s1的真子集，结果为True
print("result1=",result1) #集合s与集合s2相同，不是s的真子集，所以结果为False
print("result2=",result2) #集合s不是集合s3的真子集，结果为False
'''
结果：
s= {1, 2, 3}
s1= {1, 2, 3, 4, 5, 6}
s2= {1, 2, 3}
s3= {1, 2, 5, 6, 7}
result= True
result1= False
result2= False
'''

16.issuperset()

用法： 超集测试。如果 a 与b 相同或 a 是 b的超集,返回 True ,否则返回 False 。

超集： 对于集合 a 和b，如果b 是a的子集，那么a 就是b 的超集或父集（superset）。此时，集合 b 就是 a 的子集

s = {1,2,3,4,5,6}
s1 = {1,2,3}
s2 = {1,2,3,4,5,6}
s3 = {1,2,5,6,7}
print("s=",s)
print("s1=",s1)
print("s2=",s2)
print("s3=",s3)
result = s.issuperset(s1)
result1 = s.issuperset(s2)
result2 = s.issuperset(s3)
print("result=",result) #集合s1是集合s的子集，此时集合s是集合s1的超集，结果为True
print("result1=",result1) #集合s与集合s2相同，结果为True
print("result2=",result2) #集合s不是集合s3的子集，此时集合s不是集合s3的超集，结果为False
'''
结果：
s= {1, 2, 3, 4, 5, 6}
s1= {1, 2, 3}
s2= {1, 2, 3, 4, 5, 6}
s3= {1, 2, 5, 6, 7}
result= True
result1= True
result2= False
'''

重点：>= (大于等于)的作用与issuperset()的作用是一样的.

s = {1,2,3,4,5,6}
s1 = {1,2,3}
s2 = {1,2,3,4,5,6}
s3 = {1,2,5,6,7}
print("s=",s)
print("s1=",s1)
print("s2=",s2)
print("s3=",s3)
result = s >= s1
result1 = s >= s2
result2 = s >= s3
print("result=",result) #集合s1是集合s的子集，此时集合s是集合s1的超集，结果为True
print("result1=",result1) #集合s与集合s2相同，结果为True
print("result2=",result2) #集合s不是集合s3的子集，此时集合s不是集合s3的超集，结果为False
'''
结果：
s= {1, 2, 3, 4, 5, 6}
s1= {1, 2, 3}
s2= {1, 2, 3, 4, 5, 6}
s3= {1, 2, 5, 6, 7}
result= True
result1= True
result2= False
'''

重点：> (大于) 判断 集合a 是否是 集合b 的真超集 。

s = {1,2,3,4,5,6}
s1 = {1,2,3}
s2 = {1,2,3,4,5,6}
s3 = {1,2,5,6,7}
print("s=",s)
print("s1=",s1)
print("s2=",s2)
print("s3=",s3)
result = s > s1
result1 = s > s2
result2 = s > s3
print("result=",result) #集合s1是集合s的子集，此时集合s是集合s1的真超集，结果为True
print("result1=",result1) #集合s与集合s2相同，集合s不是集合s2的真超集结果为False
print("result2=",result2) #集合s不是集合s3的子集，此时集合s不是集合s3的真超集，结果为False
'''
结果：
s= {1, 2, 3, 4, 5, 6}
s1= {1, 2, 3}
s2= {1, 2, 3, 4, 5, 6}
s3= {1, 2, 5, 6, 7}
result= True
result1= False
result2= False
'''

17.isdisjoint()

用法： 如果集合a与集合b中没有公共元素，返回True，否则返回False。

s = {1,2,3,4}
s1 = {5,6,7}
s2 = {1,5,8}
print("s=",s)
print("s1=",s1)
print("s2=",s2)
result = s.isdisjoint(s1)
result1 = s.isdisjoint(s2)
print("result=",result) #集合s与集合s1中没有共同元素，所以结果为True
print("result1=",result1) #集合s与集合s1中有共同元素1，所以结果为False

'''
结果：
s= {1, 2, 3, 4}
s1= {5, 6, 7}
s2= {8, 1, 5}
result= True
result1= False
'''

s1= {1, 2, 3}
s2= {1, 2, 3, 4, 5, 6}
s3= {1, 2, 5, 6, 7}
result= True
result1= True
result2= False
‘’’

重点：> (大于)  判断 集合a 是否是 集合b 的真超集 。

```python
s = {1,2,3,4,5,6}
s1 = {1,2,3}
s2 = {1,2,3,4,5,6}
s3 = {1,2,5,6,7}
print("s=",s)
print("s1=",s1)
print("s2=",s2)
print("s3=",s3)
result = s > s1
result1 = s > s2
result2 = s > s3
print("result=",result) #集合s1是集合s的子集，此时集合s是集合s1的真超集，结果为True
print("result1=",result1) #集合s与集合s2相同，集合s不是集合s2的真超集结果为False
print("result2=",result2) #集合s不是集合s3的子集，此时集合s不是集合s3的真超集，结果为False
'''
结果：
s= {1, 2, 3, 4, 5, 6}
s1= {1, 2, 3}
s2= {1, 2, 3, 4, 5, 6}
s3= {1, 2, 5, 6, 7}
result= True
result1= False
result2= False
'''

17.isdisjoint()

用法： 如果集合a与集合b中没有公共元素，返回True，否则返回False。

s = {1,2,3,4}
s1 = {5,6,7}
s2 = {1,5,8}
print("s=",s)
print("s1=",s1)
print("s2=",s2)
result = s.isdisjoint(s1)
result1 = s.isdisjoint(s2)
print("result=",result) #集合s与集合s1中没有共同元素，所以结果为True
print("result1=",result1) #集合s与集合s1中有共同元素1，所以结果为False

'''
结果：
s= {1, 2, 3, 4}
s1= {5, 6, 7}
s2= {8, 1, 5}
result= True
result1= False
'''