基本数据类型之集合

目录

• 基本数据类型之集合
  • 1、作用
    • 1.1 关系运算
    • 1.2、去重
      • 1.2.1 只能针对不可变类型去重
      • 1.2.2 无法保证原来的顺序
  • 2、定义:
    • 2.1集合内元素必须为不可变类型
    • 2.2集合内元素无序
    • 2.3集合内元素没有重复
  • 3、类型转换
    • 3.1类型转换的条件
  • 4、内置方法
    • 4.1 关系运算符
      • 4.1.1 取交集：两者共同的好友
      • 4.1.2 取并集/合集：两者所有的好友
      • 4.1.3 取差集：取friends1独有的好友
      • 取friends2独有的好友
      • 4.1.4 对称差集: 求两个用户独有的好友们（即去掉共有的好友）
      • 4.1.5 父子集：包含的关系
    • 4.2其他操作
      • 4.2.1 长度:
      • 4.2.2 成员运算
      • 4.2.3 循环遍历
      • 4.2.4 删除元素
        • 4.2.4.1 discard
        • 4.2.4.2 remove
        • 4.2.4.3 pop
      • 4.2.5 添加元素：add
      • 4.2.6 更新:update
      • 4.2.6 仅作了解的方法
        • 4.2.6.1 是否独立：isdisjoint
        • 4.2.6.2 update系列

1、集合类型
    关系运算
    去重（有局限性）

2、总结与分类
    有序or无序：有序又称之为序列类型

    存一个值or多个值：存一个值称为原子类型，存多个值称为容器类型

    可变or不可变

3、字符编码（理论多，结论少）
    文本文件
    x='上'

基本数据类型之集合

1、作用

集合可以进行独特的关系运算，对某些数据能做出去重的操作

1.1 关系运算

friends1 = ["zero","kevin","jason","egon"]
friends2 = ["Jy","ricky","jason","egon"]
l=[]
for x in friends1:
    if x in friends2:
        l.append(x)
print(l)
# ['jason', 'egon']

如上面这段代码，要取两个列表中的共同朋友。需要进行较为复杂的操作，而使用集合，只需要一个方法便能得到。还有其他方法在后面会具体说明

friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}

res=friends1 & friends2
print(res)
# {'jason', 'egon'}

print(friends1.intersection(friends2))
# {'jason', 'egon'}

1.2、去重

使用集合去重有两个注意点：

1.2.1 只能针对不可变类型去重

因为集合内不能存放不可哈希的数据类型，即集合内不能有可变数据类型的数据，所以集合的去重只能针对不可变类型去重。

print(set([1,1,1,1,2]))
# {1, 2}

print({1, 1, 1, [1, 1, 2]})
# TypeError: unhashable type: 'list'

1.2.2 无法保证原来的顺序

集合是一种无序的数据类型，所以去重后无法保证顺序相同

l=[1,'a','b','z',1,1,1,2]
l=list(set(l))
print(l)
# [1, 2, 'b', 'z', 'a']

下面是不使用集合的去重方法

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)

'''
[{'name': 'lili', 'age': 18, 'sex': 'male'}, {'name': 'jack', 'age': 73, 'sex': 'male'}, {'name': 'tom', 'age': 20, 'sex': 'female'}]
'''

2、定义:

集合的形式是在{}内用逗号分隔开多个元素，并且这多个元素有以下三个特点

2.1集合内元素必须为不可变类型

2.2集合内元素无序

2.3集合内元素没有重复

s={} # 直接使用{}默认创建空字典
print(type(s))
# <class 'dict'>

# 定义空集合的方法
s=set()
print(s,type(s))
# set() <class 'set'>

s={1,2} # s=set({1,2})，集合的定义
s={1} # s=set({1})，集合的定义


# 集合内元素的3个特征

s={1,[1,2]} # 集合内元素必须为不可变类型
# TypeError: unhashable type: 'list'

s={1,'a','z','b',4,7} # 集合内元素无序
# 输出结果不同

s={1,1,1,1,1,1,'a','b'} # 集合内元素没有重复
print(s)
# {1, 'a', 'b'}

3、类型转换

3.1类型转换的条件

所有能被for循环遍历的数据类型都能被转换成集合，但是有一个前提条件：这个数据内的元素必须都为不可变数据类型

res=set('hellolllll')
print(res)
# {'e', 'l', 'o', 'h'}

s = set(range(5))
print(s)
# {0, 1, 2, 3, 4}

print(set([1,1,1,1,1,1]))
# {1}

print(set([1,1,1,1,1,1,[11,222]]) # 报错
# TypeError: unhashable type: 'list'
      
print(set({'k1':1,'k2':2}))
# {'k2', 'k1'}

4、内置方法

4.1 关系运算符

4.1.1 取交集：两者共同的好友

friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}
res=friends1 & friends2
print(res)
# {'egon', 'jason'}

print(friends1.intersection(friends2))
# {'egon', 'jason'}

4.1.2 取并集/合集：两者所有的好友

friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}
print(friends1 | friends2)
# {'Jy', 'ricky', 'jason', 'kevin', 'egon', 'zero'}

print(friends1.union(friends2))
# {'Jy', 'ricky', 'jason', 'kevin', 'egon', 'zero'}

4.1.3 取差集：取friends1独有的好友

friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}
print(friends1 - friends2)
# {'zero', 'kevin'}

print(friends1.difference(friends2))
# {'zero', 'kevin'}

取friends2独有的好友

friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}
print(friends2 - friends1)
# {'Jy', 'ricky'}

print(friends2.difference(friends1))
# {'Jy', 'ricky'}

4.1.4 对称差集: 求两个用户独有的好友们（即去掉共有的好友）

friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}
print(friends1 ^ friends2)
# {'ricky', 'Jy', 'zero', 'kevin'}

print(friends1.symmetric_difference(friends2))
# {'ricky', 'Jy', 'zero', 'kevin'}

4.1.5 父子集：包含的关系

s1={1,2,3}
s2={1,2,4}
# 不存在包含关系，下面比较均为False
print(s1 > s2)
print(s1 < s2)

s1={1,2,3}
s2={1,2}
print(s1 > s2) # 当s1大于或等于s2时，才能说是S2是s1的子集
print(s1.issuperset(s2)) # s1是父集
# True

print(s2.issubset(s1)) # s2是子集，s2 < s1  =>True
# True

s1={1,2,3}
s2={1,2,3}
print(s1 == s2) # s1与s2互为子集
# True

print(s1.issuperset(s2))
# True

print(s2.issuperset(s1))
# True

4.2其他操作

4.2.1 长度:

s1 = {1, 2, 3}
print(len(s1))
# 3

4.2.2 成员运算

s1 = {1, 2, 3}
print(1 in s1)
# True

4.2.3 循环遍历

s1 = {1, 2, 3}
for i in s1:
    print(i)

4.2.4 删除元素

4.2.4.1 discard

s1 = {1, 2, 3}
s1.discard(4)
# 不会报错

4.2.4.2 remove

s1 = {1, 2, 3}
s1.remove(4)
# KeyError: 4

4.2.4.3 pop

pop有返回值：删除的元素

s1 = {1, 2, 3}
res = s1.pop()
print(res)
# 1

print(s1)
# {2, 3}

4.2.5 添加元素：add

s1 = {1, 2, 3}
s1.add(4)
print(s1)
# {1, 2, 3, 4}

4.2.6 更新:update

s1 = {1, 2, 3}
s1.update({1, 3, 5})
print(s1)
# {1, 2, 3, 5}

4.2.6 仅作了解的方法

4.2.6.1 是否独立：isdisjoint

s1 = {1, 2, 3}
res = s1.isdisjoint({3, 4, 5, 6})
# 两个集合有交集，则返回False
print(res)
res = s1.isdisjoint({4, 5, 6})
# 两个集合完全独立、没有共同部分，则返回True
print(res)

4.2.6.2 update系列

这个系列相当于在之前的功能上添加一个赋值操作

s = {1, 2, 3}
s.difference_update({3,4,5}) # s=s.difference({3,4,5})
print(s)
# {1, 2}