python 集合以及内置方法

目录

1.集合介绍以及使用

1.1.创建set集合

1.2集合运算

1.3集合的内置方法

1.4去重

---

1.集合介绍以及使用

在Python中，集合（Set）是一种无序的容器类型，只能包含唯一的元素。集合可以通过花括号 {} 或者 set() 函数来创建。

说明
集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算

定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：

1：每个元素必须是不可变类型

2：集合内没有重复的元素

3：集合内元素无序

在{}内用逗号分隔开多个元素，集合具备以下三个特点：
     1：每个元素必须是不可变类型
     2：集合内没有重复的元素
     3：集合内元素无序

s = {1,2,3,4}  # 本质 s = set({1,2,3,4})

注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系元素，根本没有取出单个指定值这种需求。

注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，现在我们想定义一个空字典和空集合，该如何准确去定义两者?

d = {} 		# 默认是空字典 
s = set()   # 这才是定义空集合


# 但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型
s = set([1,2,3,4])
s1 = set((1,2,3,4))
s2 = set({'name':'jason',})
s3 = set('egon')
print（s,s1,s2,s3）# {1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'e', 'o', 'g', 'n'}

1.1.创建set集合

1.使用花括号创建set集合
a = {1, 2, 3, 4}

2.使用set()函数创建set集合
b = set([1, 2, 3, 4])

1.2集合运算

两个集合的关系如下图所示

定义两个集合friends与friends2来分别存放两个人的好友名字

friends1 = {"zero","kevin","ly","qq"} friends1 的好友们

friends2 = {"Jy","ricky","ly","qq"} friends2 的好友们

1.交集(&)运算符

s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 & s2
print(s3)   # 输出结果：{2, 3}

2.并集(|)运算符

s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 | s2
print(s3)   # 输出结果：{1, 2, 3, 4}

3.差集(-)运算符

s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 - s2
print(s3)   # 输出结果：{1}

4.对称差集(^)运算符

s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 ^ s2
print(s3)   # 输出结果：{1, 4}

5.子集(<)和超集(>)运算符

s1 = {1, 2}
s2 = {1, 2, 3}
result = s1 < s2
print(result)   # 输出结果：True

s1 = {1, 2, 3}
s2 = {1, 2}
result = s1 > s2
print(result)   # 输出结果：True

1.合集/并集(|)：求两个用户所有的好友（重复好友只留一个）

friends1 | friends2
{'kevin', 'ricky', 'zero', 'ly', 'Jy', 'qq'}

2.交集(&)：求两个用户的共同好友

friends1 & friends2
{'ly', 'qq'}

3.差集(-)：

>>> friends1 - friends2 # 求用户1独有的好友
{'kevin', 'zero'}
>>> friends2 - friends1 # 求用户2独有的好友
{'ricky', 'Jy'}

4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）

>>> friends1 ^ friends2
{'kevin', 'zero', 'ricky', 'Jy'}

5.值是否相等(==)

>>> friends1 == friends2
False

6.父集：一个集合是否包含另外一个集合

	6.1 包含则返回True
>>> {1,2,3} > {1,2}
True
>>> {1,2,3} >= {1,2}
True
 	6.2 不存在包含关系，则返回False
>>> {1,2,3} > {1,3,4,5}
False
>>> {1,2,3} >= {1,3,4,5}
False

7.子集

>>> {1,2} < {1,2,3}
True
>>> {1,2} <= {1,2,3}
True

1.3集合的内置方法

1.add()方法

s = set([1, 2, 3])
s.add(4)
print(s)   # 输出结果：{1, 2, 3, 4}

2.clear()方法

s = set([1, 2, 3])
s.clear()
print(s)   # 输出结果：set()

3.copy()方法

s1 = set([1, 2, 3])
s2 = s1.copy()
print(s2)   # 输出结果：{1, 2, 3}

4.difference()方法

s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
s3 = s1.difference(s2)
print(s3)   # 输出结果：{1}

5.discard()方法

s = set([1, 2, 3])
s.discard(2)
print(s)   # 输出结果：{1, 3}

6.intersection()方法

s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
s3 = s1.intersection(s2)
print(s3)   # 输出结果：{2, 3}

7.isdisjoint()方法

s1 = set([1, 2, 3])
s2 = set([4, 5, 6])
print(s1.isdisjoint(s2))   # 输出结果：True
s3 = set([2, 3, 4])
print(s1.isdisjoint(s3))   # 输出结果：False

8.issubset()方法

s1 = set([1, 2, 3])
s2 = set([1, 2, 3, 4])
print(s1.issubset(s2))   # 输出结果：True
s3 = set([2, 3, 4])
print(s1.issubset(s3))   # 输出结果：False

9.issuperset()方法

s1 = set([1, 2, 3])
s2 = set([1, 2])
print(s1.issuperset(s2))   # 输出结果：True
s3 = set([2, 3, 4])
print(s1.issuperset(s3))   # 输出结果：False

10.pop()方法

s = set([1, 2, 3])
x = s.pop()
print(x)   # 输出结果：1
print(s)   # 输出结果：{2, 3}

11.remove()方法

s = set([1, 2, 3])
s.remove(2)
print(s)   # 输出结果：{1, 3}

12.symmetric_difference()方法

s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
s3 = s1.symmetric_difference(s2)
print(s3)   # 输出结果：{1, 4}

13.union()方法

s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
s3 = s1.union(s2)
print(s3)   # 输出结果：{1, 2, 3, 4}

14.update()方法

s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
s1.update(s2)
print(s1)   # 输出结果：{1, 2, 3, 4}

1.4去重

集合去重复有局限性

1. 只能针对不可变类型
2. 集合本身是无序的，去重之后无法保留原来的顺序

l=['a','b',1,'a','a']
s=set(l)
print（s） # 将列表转成了集合	{'b', 'a', 1}
l_new=list(s) # 再将集合转回列表
print（l_new）#['b', 'a', 1] # 去除了重复，但是打乱了顺序

# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
l=[
    {'name':'lili','age':18,'sex':'male'},
    {'name':'jack','age':73,'sex':'male'},
    {'name':'tom','age':20,'sex':'female'},
    {'name':'lili','age':18,'sex':'male'},
    {'name':'lili','age':18,'sex':'male'},
]

new_l=[]

for dic in l:
    if dic not in new_l:
        new_l.append(dic)

print（new_l)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
[
    {'age': 18, 'sex': 'male', 'name': 'lili'}, 
    {'age': 73, 'sex': 'male', 'name': 'jack'}, 
    {'age': 20, 'sex': 'female', 'name': 'tom'}
]

练习题

"""
一.关系运算
　　有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
　　pythons={'ly','qq','kevin','ricky','gangdan','biubiu'}
　　linuxs={'kermit','tony','gangdan'}
　　1. 求出即报名python又报名linux课程的学员名字集合
　　2. 求出所有报名的学生名字集合
　　3. 求出只报名python课程的学员名字
　　4. 求出没有同时这两门课程的学员名字集合
"""
# 求出即报名python又报名linux课程的学员名字集合
pythons & linuxs
# 求出所有报名的学生名字集合
pythons | linuxs
# 求出只报名python课程的学员名字
pythons - linuxs
# 求出没有同时这两门课程的学员名字集合
pythons ^ linuxs