python学习之第十二课时--基本数据类型(set)

• 集合set

集合set，无序，是不允许重复内容的，也就是不允许重复元素，如果有重复，会自动忽略，可接收可迭代类型 （一般用于需要判断和处理交集时候用到）

集合与字典的区别是，集合没有键只有值，字典是有键的字典是一对键值对，所以创建空集合不能用{}大括号，用大括号创建空集合默认会变成字典，如果需要创建空集合用set()

创建集合

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a=set()
a={12,23,34,45,56,67,78,12}
print(a)
#打印 set([34, 67, 12, 45, 78, 23, 56])

转换集

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a=set()
a=(12,23,34,45,56,67,78)
b=[12,23,34,45,56,67,78]
c="12345678"
#将列表转换成集合
dd=set(b)
print(dd)         #set([34, 67, 12, 45, 78, 23, 56])
#将元组转换成集合
da=set(a)
print(da)         #set([34, 67, 12, 45, 78, 23, 56])
#字符串转换成集合
db=set(c)
print(db)         #set(['1', '3', '2', '5', '4', '7', '6', '8'])

集合的类库功能

函数	功能
def add(self, *args, **kwargs)	添加元素(要添加的元素)
def clear(self, *args, **kwargs)	清空元素
def difference(self, *args, **kwargs)	查找出一个集合里存在，另外一个集合不存在的元素
def difference_update(self, *args, **kwargs)	从当前集合中删除和B中相同的元素（b集合）
def discard(self, *args, **kwargs)	移除指定元素，不存在不报错（要移除的元素）
def intersection(self, *args, **kwargs)	交集，查找出a集合和b集合都存在的元素（b集合）
def intersection_update(self, *args, **kwargs)	交集，查找出a集合和b集合都存在的元素,并重新更新到a集合（b集合）
def isdisjoint(self, *args, **kwargs)	检查a集合和b集合是否有都存在的元素（b集合） 返回布尔值:如果没有都存在的，返回True，否则返回False
def issubset(self, *args, **kwargs)	判断一个集合是否是另一个集合的子序列（b集合）
def issuperset(self, *args, **kwargs)	判断一个集合是否是另一个集合的父序列（b集合）
def pop(self, *args, **kwargs)	移除元素()
def remove(self, *args, **kwargs)	移除指定元素，不存在保错(要移除的元素)
def symmetric_difference(self, *args, **kwargs)	对称差集,就是将两个集合里没有交集的元素重新组合成一个新的集合（b集合）
def symmetric_difference_update(self, *args, **kwargs)	对称差集，并更新到a中,就是将两个集合里没有交集的元素重新组合更新给a集合（b集合）
def union(self, *args, **kwargs)	并集，将两个集合合并成一个新的集合，元素有重复的会自动忽略（b集合）
def update(self, *args, **kwargs)	更新,将b集合更新到a集合，相当于合并（b集合）

具体实例如下：

add(self, *args, **kwargs)         添加元素(要添加的元素)

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a={12,23,34,45}
a.add(56)
print(a)
#打印 set([56, 34, 12, 45, 23])

clear(self, *args, **kwargs)     清空元素（）

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a={12,23,34,45}
a.clear()
print(a)
#打印 set([])

difference(self, *args, **kwargs)         "查找出一个集合里存在，另外一个集合不存在的元素"（格式：查找集合.difference（被判断的集合））

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a={12,23,34,45}
b={13,24,23,46,45}
c=a.difference(b)
print(c)
#打印 set([34, 12])

difference_update(self, *args, **kwargs)           "从当前集合中删除和B中相同的元素"(b集合)

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a={12,23,34,45}
b={13,24,23,46,45}
a.difference_update(b)
print(a)
#打印 set([34, 12])

 discard(self, *args, **kwargs)           "移除指定元素，不存在不报错（要移除的元素）

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a={12,23,34,45}
a.discard(23)
print(a)
#打印 set([34, 12, 45])

intersection(self, *args, **kwargs)         "交集，查找出a集合和b集合都存在的元素（b集合）

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a={12,23,34,45}
b={13,24,23,46,45}
c=a.intersection(b)
print(c)
#打印 set([45, 23])

intersection_update(self, *args, **kwargs)        "交集，查找出a集合和b集合都存在的元素,并重新更新到a集合（b集合）

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a={12,23,34,45}
b={13,24,23,46,45}
a.intersection_update(b)
print(a)

isdisjoint(self, *args, **kwargs)    "检查a集合和b集合是否有都存在的元素（b集合）

返回布尔值:如果没有都存在的，返回True，否则返回False

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a={12,23,34,45}
b={13,24,23,46,45}
c=a.isdisjoint(b)
print(c)
#打印False 证明有交集

issubset(self, *args, **kwargs)         "判断一个集合是否是另一个集合的子序列（b集合）

是返回True   不是返回False

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a={23,34}
b={13,34,23,46,45}
c=a.issubset(b)
print(c)
#打印 True a是b的子集
d=b.issubset(a)
print(d)
#打印 False b不是a的子集

issuperset(self, *args, **kwargs)     "判断一个集合是否是另一个集合的父序列（b集合）

是返回True   不是返回False

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a={23,34}
b={13,34,23,46,45}
c=a.issuperset(b)
print(c)
#打印 False a不是b的父序列
d=b.issuperset(a)
print(d)
#打印 True b是a的父序列

pop(self, *args, **kwargs)       "移除元素()

 一般默认移除第一个元素，只是集合有一套自己的元素排序规则

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a={13,34,23,46,45}
b=a.pop()
print(b)
#打印 34
print(a)
#打印 set([13, 45, 46, 23])

remove(self, *args, **kwargs)           "移除指定元素，不存在保错(要移除的元素)

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a={13,34,23,46,45}
a.remove(23)
print(a)
#打印 set([34, 13, 45, 46])

 symmetric_difference(self, *args, **kwargs)       "对称差集,就是将两个集合里没有交集的元素重新组合成一个新的集合（b集合）

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a={13,34,23,46,45}
b={12,34,46,57}
c=a.symmetric_difference(b)
print(c)
#打印 set([12, 13, 45, 23, 57])

symmetric_difference_update(self, *args, **kwargs)   "对称差集，并更新到a中,就是将两个集合里没有交集的元素重新组合更新给a集合（b集合）

!/usr/bin/env python
# -*- coding:utf-8 -*-
a={13,37,23,46,45}
b={12,34,46,57}
a.symmetric_difference_update(b)
print(a)
#打印 set([34, 37, 12, 13, 45, 23, 57])

union(self,*args, **kwargs)"并集，将两个集合合并成一个新的集合，元素有重复的会自动忽略（b集合）

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a={13,37,23,46,45}
b={12,34,46,57}
c=a.union(b)
print(c)
#打印 set([34, 37, 12, 45, 46, 13, 23, 57])

update(self, *args, **kwargs)          "更新,将b集合更新到a集合，相当于合并（b集合）

#!/usr/bin/env python
# -*- coding:utf-8 -*-
a={13,37,23,46,45}
b={12,34,46,57}
a.update(b)
print(a)
#打印 set([34, 37, 12, 13, 46, 45, 23, 57])

set

 一。set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

 要创建一个set，需要提供一个list作为输入集合：

 set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。试试把list放入set，看看是否会报错。

 二。set和dict一样，只是没有value，相当于dict的key集合，由于dict的key是不重复的，且key是不可变对象因此set也有如下特性：

不重复

元素为不可变对象