创新路
我们一直在努力

Python入门系列(4):内置数据结构-集合

序(ji)言(tang)部分

blob.png

子曰:学不可以已

古人云:“求学不可以让它停止,即学习是无止境的”。如同这个《古今贤文》·劝学篇里面的段子,大多都是大家耳闻能熟的句子。阅闻是易,行实则难。就如同别人对着你说要坚持,你自己对你自己说要坚持。那实际是不是做到了只有你自己知道。每一个新的一天都有很多东西可以学习,再学习这条路上没有止境,除了你自己没有人能真正帮到你.


课程拓扑图

集合.png

集合

元素是唯一的,元素是无序的


定义集合

 |  set() -> new empty set object

 |  set(iterable) -> new set object

In [27]: s1 = set((1,))        # 定义一个元组转换为集合

In [28]: s1 = set("abcd")        # 定义一个字符串转换为集合

In [29]: s1 = set(range(0,5))    # 定义一个数组转换为集合

In [30]: s1 = set([1])        # 定义一个里列表转换为集合

# 综上所述,都是可迭代的(iterable)


.add  # 把要传入的元素做为一个整体添加到集合中

.update # 是把要传入的元素拆分后添加到集合中

In [50]: s1 = set([1])        # 定义一个列表转换为集合

In [51]: s1
Out[51]: {1}

In [52]: s1.add('abc')        # 添加一个'整体'的值

In [53]: s1
Out[53]: {1, 'abc'}

In [54]: s1.update('abc')        # 添加一个'拆分'的值

In [55]: s1
Out[55]: {1, 'abc', 'a', 'c', 'b'}        # 发现集合是无序,非线性结构

Tips:集合的元素,一定是可hash的。可hash的一定是不可变的元素。  list(列表) set(集合) bytearray dict(字典) 是不可hash的,所以不能作为set的元素,通常来说,内置类型,不可变类型是可hash。 这里可以使用hash()函数来查看一个值是否可hash

.remove

.discard

.pop

.clear

In [58]: s1
Out[58]: {1, 'abc', 'a', 'c', 'b'}

In [59]: s1.remove(1)

In [60]: s1
Out[60]: {'a', 'abc', 'b', 'c'}

In [61]: s1.remove('b')            # 删除‘b’

In [62]: s1
Out[62]: {'a', 'abc', 'c'}

In [66]: s1
Out[66]: {'a', 'abc', 'b', 'c'}

In [67]: s1.discard('a')            # 删除‘a’

In [68]: s1
Out[68]: {'abc', 'b', 'c'}

# remove 和 discard的区别是?

In [70]: s1
Out[70]: {'abc', 'b', 'c'}

In [71]: s1.remove('a')            # 使用remove删除不存在的值,将提示异常
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-71-063d78f8a8a8> in <module>()
----> 1 s1.remove('a')

KeyError: 'a'

In [72]: s1.discard('a')            # 使用discard删除不存在的值,不提示异常


In [131]: s1 = set([chr(i) for i in range(97,123)])            # 生成一个a-z的字母序列

In [132]: s1.pop()        # 删除集合里面任意一个元素(因为集合是无序,不能确定删除的顺序)
Out[132]: 'm'

In [133]: s1.pop()
Out[133]: 'z'

In [134]: s1.pop()
Out[134]: 'k'

In [136]: s1.clear()            # 清空集合里面内容

In [137]: s1
Out[137]: set()

In [139]: s1.pop()            # 如果集合为空,还再使用pop()将抛出异常
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-139-da63ff21a00b> in <module>()
----> 1 s1.pop()

KeyError: 'pop from an empty set'

修改 和 查找 

没有一个方法可以直接的修改集合中的某个具体元素

因为没有一个方法,可以定位到其中某个具体元素

In [141]: 'cd' in set('chengdu')
Out[141]: False

In [142]: 'ch' in set('chengdu')
Out[142]: False

In [143]: 'chengdu' in set('chengdu')            # 上面之所以是False,因为集合把'chegndu'拆分为字母'c','h'...
Out[143]: False

In [144]: 'chengdu' in set(['chengdu'])        
Out[144]: True

In [145]: 'c' in set(['chengdu'])                # 如果转换为list,它的值就是一个整体
Out[145]: False

In [146]: 'c' in set('chengdu')                # 单独匹配单字母'c'成功
Out[146]: True

集合运算

union 并集            |

intersection 交集           & 

difference 差集             –

symmetric_difference 对称差集   ^

补集(python里面没有补集,因为没有定义全集)

In [1]: a = {1,2,3}

In [2]: b = {2,3,4}

In [3]: a.union(b)            # 并集:由所有属于A或属于B的元素组成的集合,叫做A与B的并集,记作 (读作"A并B") 
Out[3]: {1, 2, 3, 4}

In [4]: a | b                 # 并集符号方式
Out[4]: {1, 2, 3, 4}

In [5]: a.intersection(b)     # 交集:由所有属于A且属于B的元素所组成的集合,叫做A与B的交集. 记作 (读作"A交B") 
Out[5]: {2, 3}

In [6]: a & b                 # 交集符号方式
Out[6]: {2, 3}

In [7]: a.difference(b)       # 差集:由所有属于A且不属于B的元素构成的集合
Out[7]: {1}

In [8]: a - b                 # 差集符号方式
Out[8]: {1}

In [13]: a.symmetric_difference(b)    # 对称差集:只属于其中一个集合,而不属于另一个集合的元素组成的集合
Out[13]: {1, 4}

In [14]: a ^ b                        # 对称差集符号方式
Out[14]: {1, 4}

集合判断

issuperset # 是否为超集

issubset # 是否为子集

isdisjoint # 是否不相交的集

n [34]: a
Out[34]: {1, 2, 3}

In [35]: b
Out[35]: {2, 3, 4}

In [36]: c
Out[36]: {1, 2, 3, 4}


In [37]: a.issuperset(b)
Out[37]: False

In [38]: b.issuperset(a)
Out[38]: False

# 如果一个集合a中的每一个元素都在集合c中,且集合c中可能包含a中没有的元素,则集合c就是a的一个超集,反过来,S2是S1的子集。

In [39]: c.issuperset(a)
Out[39]: True

In [40]: c.issuperset(b)
Out[40]: True


In [41]: a.issuperset(c)
Out[41]: False

In [42]: b.issuperset(c)
Out[42]: False

In [43]: a.issubset(c)            # a是c的子集
Out[43]: True

In [44]: b.issubset(c)            # b也是c的子集
Out[44]: True

In [48]: d = {4,5,6}            # 定义了一个d 的集合

In [49]: a.isdisjoint(d)        # a和d不相交
Out[49]: True

In [50]: b.isdisjoint(d)        # b集合里面的数字“4”和d集合里面的数字4相交
Out[50]: False

集合的应用

元素需要唯一而对顺序没有要求

In [82]: def fn(*host):        # 定义一个函数接收“host”参数(函数后续会讲,这里简单说下应用场景)
    hosts = set()
    hosts.update(host)
    return(hosts)
   ....: 

In [83]: fn("host1","host2","host2","host1") # 当添加多个主机的时候如果遇到重复,仅仅回留下一个
Out[83]: {'host1', 'host2'}

我们需要集合运算时

In [88]: hosts = ["host1", "host2", "host3", "host4"]        # 假设有一个所有主机列表

In [89]: complete_hosts = ["host2", "host4"]                 #  # 假设有一个执行任务结束后的主机列表


In [92]: in_progress_hosts = set(hosts) - set(complete_hosts)        # 计算还有那些主机正在运行中

In [93]: print(in_progress_hosts)
{'host3', 'host1'}


hosts = input_a | input_b | input_b             # 多个用户输入,做一个并集运算

/data/00 /data//01 /data/02 |                   # 多个目录文件去重复,做数据备份。避免重复

未经允许不得转载:天府数据港官方信息博客 » Python入门系列(4):内置数据结构-集合

客官点个赞呗! (0)
分享到:

评论 抢沙发

评论前必须登录!

天府云博 - 做有态度的开发&运维&设计学习分享平台!

联系我们百度云主机