集合set

把不同的元素组成一起形成集合，是python基本的数据类型

集合的特性：

  1. 去重，把一个列表编程集合，就自动去重了
  2. 关系测试，测试两组数据之间的交集、差集、并集等关系
  3. 无需意味着没有索引，也就不能拿出某个固定的值
  4. 那么这种没有关系的数据类型就是我们去读取里面的内容的方式是：for循环或者迭代器
s = set('yuyang is DBA')
s1 = ['yu','yang']
print(s)
print(set(s1))

执行结果：

{'u', 'g', 'y', ' ', 'i', 'a', 'D', 'B', 'A', 'n', 's'}
{'yang', 'yu'}

Process finished with exit code 0

从上面的执行结果中可以看出，如果在集合中出现重复的字符，那么该变量在打印的时候，只会出现一次

集合对象是一组无需排列的可哈希的值：集合成员可以做字典的键。

可哈希的值，也就是说是一个不可变的类型

a = ['yuyang is DBA',[1,2]]
s = set(a)
print(s)

ERROR：

Traceback (most recent call last):
  File "H:/python_scripts/study_scripts/daily/day14/set.py", line 2, in <module>
    s = set(a)
TypeError: unhashable type: 'list'         #这里就表示，列表是不可哈希的数据类型

Process finished with exit code 1

如果像上面这种给集合中赋值的时候，出现列表、字典等可变的对象的话，就会报错

集合分类：

  1. 可变集合：可以添加或者删除元素，非可哈希的，不能做字典的键，也不能做其他集合的元素
  2. 不可变集合：与可变集合相反

集合的相关操作

1、创建集合

s = set('yuyang is DBA')
s1 = ['yu','yang']
print(s)
print(set(s1))

执行结果：

{'u', 'g', 'y', ' ', 'i', 'a', 'D', 'B', 'A', 'n', 's'}
{'yang', 'yu'}

Process finished with exit code 0

2、访问集合

a = ['yuyang','is','DBA',1]
s = set(a)
print(s)

for i in s:
    print(i)

print('end'.center(30,'-'))
print('yuyang' in s)
print('jiayanping' in s)

执行结果：

{1, 'DBA', 'is', 'yuyang'}
1
DBA
is
yuyang
-------------end--------------
True
False

Process finished with exit code 0

集合是无序的，那么如果需要访问其中的值的话，就需要使用for循环遍历、或者迭代器去实现

3、集合中添加元素
set.add()

a = ['yuyang','is','DBA',1]
s = set(a)
print(s)

for i in s:
    print(i)

print('end'.center(30,'-'))
print('yuyang' in s)
print('jiayanping' in s)

s.add('jiayanping')
print(s)

执行结果：

{1, 'is', 'yuyang', 'DBA'}
1
is
yuyang
DBA
-------------end--------------
True
False
{1, 'is', 'yuyang', 'DBA', 'jiayanping'}

Process finished with exit code 0

set.update()

a = ['yuyang','is','DBA',1]
s = set(a)
print(s)

s.update('jiayanping')
print(s)

执行结果：

{1, 'DBA', 'is', 'yuyang'}
{1, 'DBA', 'yuyang', 'y', 'p', 'is', 'i', 'j', 'a', 'g', 'n'}

Process finished with exit code 0

update只做更新，不会把之前的内容清空

add和update的区别：

  • add是将对象作为一个整体，追加进去
  • update是将对象拆解为一个序列中的多个元素，逐个追加到集合中

示例：

a = ['yuyang','is','DBA',1]
s = set(a)
print(s)

s.update([1,2,'jiayanping'])
print(s)

执行结果：

{'yuyang', 'is', 1, 'DBA'}
{1, 2, 'is', 'jiayanping', 'yuyang', 'DBA'}

Process finished with exit code 0

4、删除集合中的元素

set.remove()

a = ['yuyang','is','DBA',1]
s = set(a)
print(s)

s.remove('is')
print(s)

执行结果：

{'DBA', 1, 'yuyang', 'is'}
{'DBA', 1, 'yuyang'}

Process finished with exit code 0

set.pop()

a = ['yuyang','is','DBA',1]
s = set(a)
print(s)

s.pop()          #随机删除一个元素
print(s)

执行结果：

{'yuyang', 'DBA', 1, 'is'}
{'DBA', 1, 'is'}

Process finished with exit code 0

set.clear()

a = ['yuyang','is','DBA',1]
s = set(a)
print(s)

s.clear()
print(s)

执行结果：

{1, 'DBA', 'yuyang', 'is'}
set()                              #这里表示的是一个空集合

Process finished with exit code 0

集合类型操作符
1.in  和  not in

2.集合等价于不等价（==，!=）

print(set('yuyang') == set('yuyangyuyangyuyang'))

结果：

True

由于集合会去重，所以这里前后两个量是相等的

3.子集、超集

print(set('yuyang') < set('yuyang_jiayanping'))

结果：

True

4.联合

关系测试

 

  • 交集
  • 差集
  • 子集
a = set([1,2,3,4,5])
b = set([4,5,6])
print(a.union(b))            #并集
print(a | b)                 #并集
print(a.intersection(b))     #交集
print(a.difference(b))       #差集
print(b.difference(a))
print(b.symmetric_difference(a))   #对称差集——反向交集
print(a-b)                   #差集
print(b-a)                  #差集
print(a^b)                  #对称差集——反向交集
print(b^a)                  #对称差集——反向交集
print(a&b)                  #交集
print(a.issuperset(b))      #超集(父集)   a>b
print(a.issubset(b))        #子集    a<b

结果：

{1, 2, 3, 4, 5, 6}
{1, 2, 3, 4, 5, 6}
{4, 5}
{1, 2, 3}
{6}
{1, 2, 3, 6}
{1, 2, 3}
{6}
{1, 2, 3, 6}
{1, 2, 3, 6}
{4, 5}
False
False

Process finished with exit code 0

给一个列表去重最简单的方式就是将这个列表转换成集合