• Python之集合


    集合:无序的,不可随机访问的,不可重复的元素集合
    # 可以使用大括号 { } 或者 set() 函数创建集合,
    # 注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
    
    
    # 集合可分为可变集合和不可变集合
    # 可变集合:有增、删、改的操作 set
    # 不可变集合:创建好以后,无法进行增、删、改的操作 frozenset
    # 可变集合定义
    
    
     1 s = {1, 2, 3}
     2 print(s, type(s))
     3 
     4 
     5 # set(iterable)
     6 
     7 # s = set("abc")
     8 # s = set([1, 2, 3])
     9 # s = set({1, 2, 3})
    10 s = set({"name": "xq", "age": 18})
    11 print(s, type(s))
    输出结果:

    {1, 2, 3} <class 'set'>
    {'age', 'name'} <class 'set'>

    # 集合推导式
    1 s = set(x**2 for x in range(1, 10) if x % 2 == 0)
    2 # 或者s = {x**2 for x in range(1, 10) if x % 2 == 0} 这样写也是可以的
    3 print(s, type(s))
    输出结果:
    {16, 64, 4, 36} <class 'set'>
    # 不可变集合的定义
    # fs = frozenset(iterable) iterable:可迭代对象
    1 # fs = frozenset("abcd")
    2 # fs = frozenset([1, 2, 3])
    3 fs = frozenset((1, 2, 3))
    4 # s = frozenset({"name": "xq", "age": 18})
    5 print(fs, type(fs))
    输出结果:
    frozenset({1, 2, 3}) <class 'frozenset'>
    # 集合推导式
    #fs = frozenset(...)
    1 fs = frozenset(x for x in range(1, 10))
    2 print(fs, type(fs))
    输出结果:
    frozenset({1, 2, 3, 4, 5, 6, 7, 8, 9}) <class 'frozenset'>
    
    
    # 集合的常用操作
    # 单一集合的操作
    # 可变集合的操作:增、删、查 不可改:因为元素都是不可变类型,不可修改,而且也无法通过索引或者key进行查询
    # 不可变集合:不可增、删、改。可以查询。1)通过for in进行访问 2)通过迭代器进行访问
    
    
    # 1)添加元素
    # s.add( x )
    # 将元素 x 添加到集合 s 中,如果元素已存在,则不进行任何操作。
    1 s = set({"Google", "Baidu"})
    2 s.add("FaceBook")
    3 print(s, type(s))
    
    

    输出结果:

    {'Google', 'Baidu', 'FaceBook'} <class 'set'>

    
    
    # 2)移除元素
    # s.remove( x )
    # 将元素 x 从集合 s 中移除,如果元素不存在,则会发生错误。
    1 s = {"Google", "Baidu", "FaceBook"}
    2 s.remove("Baidu")
    3 print("移除元素后的集合为:: ", s)
    输出结果:
    移除元素后的集合为::  {'Google', 'FaceBook'}
    # s.remove("Taobao")
    # 如果元素不存在则报以下的错误
    '''
    Traceback (most recent call last):
    File "G:/PythonProject/DemoTest01/css/004/Set/SetFunction.py", line 65, in <module>
    s.remove("Taobao")
    KeyError: 'Taobao'

    '''

    # 此外还有一个方法也是移除集合中的元素,且如果元素不存在,不会发生错误。格式如下所示:
    # s.discard( x )
    1 s = {1, 2, 3, 4}
    2 s.discard(2)
    3 print("移除元素2之后的集合为:: ", s)
    4 
    5 s.discard(5)
    6 # 不存在不会发生错误

    输出结果:

    移除元素2之后的集合为::  {1, 3, 4}

    # 我们也可以设置随机删除集合中的一个元素,语法格式如下:
    # s.pop()
    # 若集合为空,则会返回一个错误
    1 s = {"name", "age", "sex"}
    2 result = s.pop()
    3 print("result:: ", result, "	 s:: ", s)

    输出结果:result::  age s::  {'name', 'sex'}

    
    
    # 清空集合
    # s.clear()
    1 s = {"Google", "Baidu", "Taobao"}
    2 s.clear()
    3 print("清空集合后:: ", s)

    输出结果:清空集合后::  set()

     
    # 3)查询操作
    # for in 操作
    1 s = {1, 2, 3}
    2 for v in s:
    3     print(v)

    输出结果:

    1
    2
    3

    
    
    # 使用迭代器
    
    
    1 s = {"name", "age", "sex"}
    2 its = iter(s)
    3 while True:
    4     try:
    5         x = next(its)
    6         print(x)
    7     except StopIteration:
    8         break
    输出结果:

    age
    name
    sex

    # 不可变集合和可变集合的查询操作几乎是一样的
    
    
    1 s = frozenset([1, 2, 3])
    2 print(s, type(s))
    3 for v in s:
    4     print(v)
    5 
    6 its = iter(s)
    7 for x in its:
    8     print(x)
    
    

    输出结果:

    frozenset({1, 2, 3}) <class 'frozenset'>
    1
    2
    3
    1
    2
    3

    
    
    # 集合之间的操作
    # 交集、并集、差集和判定的操作
    # 1)交集
    # intersection(interable)
    # 字符串 (只判定字符串中的非数字)
    # 列表
    # 元组
    # 字典 值判定key
    # 集合
    
    
    1 s1 = {1, 2, 3, 4, 5}
    2 s2 = {4, 5, 6}
    3 result = s1.intersection(s2)
    4 print(result, type(result))
    
    

    输出结果:{4, 5} <class 'set'>

    # 可变集合与不可变集合混合运算的时候,返回结果类型以运算符左侧为准
    1 s1 = frozenset([1, 2, 3, 4, 7])
    2 s2 = {4, 5, 6, 7}
    3 result = s1.intersection(s2)
    4 print(result, type(result))
    5 
    6 ret = s2.intersection(s1)
    7 print(ret, type(ret))

    输出结果:

    frozenset({4, 7}) <class 'frozenset'>
    {4, 7} <class 'set'> 

    # 也可以使用逻辑"&"求出交集
    1 s1 = frozenset([1, 2, 3, 4, 7])
    2 s2 = {4, 5, 6, 7}
    3 result = s1 & s2
    4 print(result, type(result))
    5 print(s1, s2)

    输出结果:

    frozenset({4, 7}) <class 'frozenset'>
    frozenset({1, 2, 3, 4, 7}) {4, 5, 6, 7}

    # intersection_update(...)
    # 也是计算两个集合之间的交集,但是,交集计算完毕以后,会再次赋值给原对象
    # 会更改原对象,所以只适用于可变集合
    1 s1 = frozenset([1, 2, 3, 4, 7])
    2 s2 = {4, 5, 6, 7}
    3 # result = s1.intersection_update(s2) 这样写是错误的,因为s1是不可变集合
    4 result = s2.intersection_update(s1)
    5 print(result, type(result))
    6 print(s1, s2)
    
    

    输出结果:

    None <class 'NoneType'>
    frozenset({1, 2, 3, 4, 7}) {4, 7}

    # 集合的并集操作
    # union 返回并集
    # 逻辑 "|" 返回并集
    # update 更新并集
    1 s1 = {1, 2, 3}
    2 s2 = {3, 4, 5}
    3 
    4 result = s1.union(s2)
    5 print(result, s1)
    6 # 使用 "|"
    7 result1 = s1 | s2
    8 print(result1, s1)

    输出结果:

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

    
    
    # 如果把s1更改为不可变集合
    1 s1 = frozenset([1, 2, 3])
    2 s2 = {3, 4, 5}
    3 
    4 result2 = s1.union(s2)
    5 print(result2, s1)

    输出结果:

    frozenset({1, 2, 3, 4, 5}) frozenset({1, 2, 3})

    
    
    # 更新并集
    
    
    1 s1 = {1, 2, 3}
    2 s2 = {3, 4, 5}
    3 
    4 result = s1.update(s2)
    5 print(result, s1)
    
    

    输出结果:None {1, 2, 3, 4, 5}

    
    
    # 集合的差集操作
    # difference()
    # 逻辑运算符 "-"
    # difference_update()
     1 s1 = {1, 2, 3}
     2 s2 = {3, 4, 5}
     3 
     4 result = s1.difference(s2)
     5 print(result, s1)
     6 
     7 # 逻辑运算符"-"
     8 result2 = s1 - s2
     9 print(result2, s1)
    10 
    11 # 更新差集
    12 s1 = {1, 2, 3}
    13 s2 = {3, 4, 5}
    14 
    15 result = s1.difference_update(s2)
    16 print(result, s1)
    
    

    输出结果:

    {1, 2} {1, 2, 3}
    {1, 2} {1, 2, 3}
    None {1, 2}

    
    
    # 集合的判定操作
    # isdisjoint() 两个集合不相交
    # issuperset() 一个集合包含另一个集合
    # issubset() 一个集合包含于另一个集合
    
    
     1 s1 = {1, 2, 3}
     2 s2 = {3, 4, 5}
     3 print(s1.isdisjoint(s2))
     4 
     5 s1 = {1, 2}
     6 s2 = {3, 4, 5}
     7 print(s1.isdisjoint(s2))
     8 
     9 
    10 s1 = {1, 2, 3, 4}
    11 s2 = {3, 4, 5}
    12 print(s1.issuperset(s2))
    13 
    14 s1 = {1, 2, 3, 4, 5}
    15 s2 = {3, 4, 5}
    16 print(s1.issuperset(s2))
    17 
    18 
    19 print(s2.issubset(s1))
    
    

    输出结果:

    False
    True
    False
    True
    True

     
     
    
    
  • 相关阅读:
    java实现二叉树的构建以及三种遍历
    binary-tree-preorder-traversal二叉树的前序遍历
    insertion-sort-list使用插入排序对链表进行排序
    binary-tree-postorder-traversa二叉树的后序遍历
    sort-list
    Redis的数据类型
    在Windows上搭建Redis服务器
    Eureka源码分析
    Eureka概念理解
    Spring Cloud Eureka
  • 原文地址:https://www.cnblogs.com/cxq0017/p/9435872.html
Copyright © 2020-2023  润新知