python基础数据类型——集合

2018-04-25 16:57:55作者: 里纳斯-派森来源: [链接]己有:2187人学习过

一、概述

  集合(set)是一种无序且不重复的序列。

  无序不重复的特点决定它存在以下的应用场景:

  • 去重处理

  • 关系测试

     差集、并集、交集等,下文详述。

二、创建集合

  创建集合的方法与创建字典类似,但没有键值对的概念,具体如下:

   s1 = {11,22,33}

  还可以通过以下两种方法创建:

   s2 = set()

   s3 = set([11,22,33])

  这两种方法本质上是同一种,都是通过调用系统的set()方法进行参数传递和类型转换,如果不传入参数则直接new一个空的集合;如果传入的参数有重复的元素则直接去重处理。

三、集合的常见函数用法

3.1 元素对象常见操作

  • add()
    添加一个元素到指定的集合,每次只能添加一个。

    1
    2
    3
    4
    5
    6
    7
    8
    s1 = {"Java""PHP""C++"}
    print(s1)
    s1.add("Python")
    print(s1)
     
    输出:
    {'C++''PHP''Java'}
    {'C++''Python''PHP''Java'}
  • remove()
    删除集合中指定的对象,一次只能删除一个,如果该对象不存在则报错。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    s1 = {'Java''PHP''Python''C++'}
    s1.remove("C++")
    print(s1)
    s1.remove("C#") #移除不存在的对象
     
    输出:
    Traceback (most recent call last):
      File "D:/python/S13/Day3/set.py", line 8in <module>
        s1.remove("C#")
    KeyError: 'C#'
    {'Java''PHP''Python'}  #第一次成功移除C++,C#不存在,移除时报错
  • discard()
    与remove()类似,也是删除指定的对象,一次只能删除一个,但是如果该对象不存在时不报错。

    1
    2
    3
    4
    5
    6
    7
    s1 = {'Java''PHP''Python''C++'}
    s1.discard("C++")
    s1.discard("C#")
    print(s1)
     
    输出:
    {'Python''PHP''Java'}
  • pop()
    删除集合中任意一个对象,注意不能指定。

    1
    2
    3
    4
    5
    6
    s1 = {'Java''PHP''Python''C++'}
    s1.pop()
    print(s1)
     
    输出:
    运行多次会发现输出的s1不固定
  • clear()
    清空集合。

    1
    2
    3
    4
    5
    6
    7
    8
    s1 = {'Java''PHP''Python''C++'}
    s1.clear()
    print(s1)
    print(len(s1))
     
    输出:
    set()
    0

 

3.2 关系测试常见操作 

  关系测试常用于对两个集合的关系判定。

  • difference() 
    语法结构:  set1.difference(set2)或set1 - set2

    差集关系运算,以新的set集合形式返回set1中包含,但在set2中不存在的元素集合(不影响原set1和set2)。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    s1 = {'Java''PHP''Python''C++'}
    s2 = {'Java''Shell''Ruby'}
    print(s1.difference(s2))
    print(s1 - s2)
    print(s1)
    print(s2)
     
    输出:
    {'PHP''Python''C++'}
    {'PHP''Python''C++'}
    {'PHP''Python''C++''Java'}
    {'Shell''Java''Ruby'} 
  • issubset()
    语法结构:  set1.issubset(set2)
    判断集合set1是否为set2的子集,返回布尔值。

    1
    2
    3
    4
    5
    6
    s1 = {'Java''PHP''Python''C++'}
    s2 = {'Java''Shell''Ruby'}
    print(s1.issubset(s2))
     
    输出:
    False
  • issuperset()
    语法结构:  set1.issuperset(set2)
    判断set1是否为set2的父集。

    1
    2
    3
    4
    5
    6
    s1 = {'Java''PHP''Python''C++'}
    s2 = {'Java''C++'}
    print(s1.issuperset(s2))
     
    输出:
    True
  • isdisjoint()
    语法结构:  set1.isdisjoint(set2)
    判断set1和set2是否存在交集, 如果不存在返回True, 存在则返回False.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    s1 = {'Java''PHP''Python''C++'}
    s2 = {'Java''C++'}
    s3 = {'GO'}
    print(s1.isdisjoint(s2))
    print(s1.isdisjoint(s3))
     
    输出:
    False
    True
  • symmetric_difference()
    语法结构:set1.symmetric_difference(set2)或set1 ^ set2
    返回set1和set2的对称式差集,相当于执行set1.difference(set2)和set2.difference(set1),以新的set集合形式返回set1和set2中差异部分元素(不在两者中同时存在)集合(仅在set1和set2中出现过一次的元素不影响原set1和set2)。

    1
    2
    3
    4
    5
    6
    7
    8
    s1 = {'Java''PHP''Python''C++'}
    s2 = {'Java''Shell''Ruby'}
    print(s1.symmetric_difference(s2))
    print(s1 ^ s2)
     
    输出:
    {'PHP''Ruby''Shell''C++''Python'}
    {'PHP''Ruby''Shell''C++''Python'}
  • symmetric_difference_update()
    语法结构:set1.symmetric_difference(set2)
    返回set1和set2的对称式差集,并覆盖更新原set1集合(原来被调用操作的对象),即执行set1 = set1.symmetric_difference(set2)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    s1 = {'Java''PHP''Python''C++'}
    s2 = {'Java''Shell''Ruby'}
    print(s1.symmetric_difference(s2))
    s1.symmetric_difference_update(s2)
    print(s1)
     
    输出:
    {'PHP''C++''Shell''Python''Ruby'}
    {'Python''Shell''Ruby''PHP''C++'}
  • intersection()
    语法结构:  set1.intersection(set2)或set1 & set2
    交集运算,以set方式返回set1和set2的交集部分(同时存在的元素),不影响原集合set1和set2.

    1
    2
    3
    4
    5
    6
    s1 = {'Java''PHP''Python''C++'}
    s2 = {'Java''Shell''Ruby'}
    print(s1.intersection(s2))
     
    输出:
    {'Java'}
  • intersection_update()
    语法结构:  set1.intersection_update(set2)
    执行交集运算,并将结果覆盖更新原集合set1(原来被调用操作的对象)。

    1
    2
    3
    4
    5
    6
    7
    s1 = {'Java''PHP''Python''C++'}
    s2 = {'Java''Shell''Ruby'}
    s1.intersection_update(s2)
    print(s1)
     
    输出:
    {'Java'}
  • union()
    语法结构:  set1.union(set2)或set1 | set2
    执行并集计算,合并set1和set2中的对象并做去重处理,最后以集合形式返回结果。
    综合上述关系运算函数,可确定并集计算相当于对称差集与交集的并集计算,即合并重复重现的对象和不重复出现的对象,
    set1.union(set2) = (set1.symmetric_difference(set2)).union(set1.intersection(set2))

    1
    2
    3
    4
    5
    6
    s1 = {'Java''PHP''Python''C++'}
    s2 = {'Java''Shell''Ruby'}
    print(s1.union(s2))
     
    输出:
    {'Shell''PHP''Ruby''C++''Python''Java'}
  • update()
    语法结构:  set1.update(obj)
    往集合中批量添加元素,添加的对象必须是可以迭代的对象(当然如果原集合中存在与迭代对象中重复的元素会做去重处理),本质上是通过循环,把传入的迭代对象逐个添加更新到原集合中。

    1
    2
    3
    4
    5
    6
    7
    s1 = {'Java''PHP''Python''C++'}
    s2 = {'Java''Shell''Ruby'}
    s1.update(s2)
    print(s1)
     
    输出:
    {'Python''Ruby''Shell''C++''Java''PHP'}
  • in 或not in
    成员运算函数同样适用于集合,最后返回布尔值。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    s1 = {'Java''PHP''Python''C++'}
    print('Java' in s1)
    if 'Go' in s1:
        print("OK")
    else:
        print("Not OK")
     
    输出:
    True
    Not OK
  • <=
    语法结构:  set1 <= set2
    判断set1中的每个元素是否都在set2中,即判断set1是否为set2的子集,等同于set1.issubset(set2)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    s1 = {'Java''PHP''Python''C++'}
    s2 = {'Java''Shell''Ruby'}
    s3 = s1.union(s2)
    print(s1 <= s2)
    print(s1.issubset(s2))
    print(s1 <= s3)
    print(s1.issubset(s3))
     
    输出:
    False
    False
    True
    True

 

3.3 关系测试运算符

  常见的关系测试运算符如下:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
s1 = {'Java''PHP''Python''C++'}
s2 = {'Java''Shell''Ruby'}
print(s1 - s2)
print(s1.difference(s2))
print("")
print(s1 & s2)
print(s1.intersection(s2))
print("")
print(s1 | s2)
print(s1.union(s2))
print("")
print(s1 ^ s2)
print(s1.symmetric_difference(s2))
print("")
print(s1 <= s2)
print(s1.issubset(s2))
 
输出:
{'C++''PHP''Python'}
{'C++''PHP''Python'}
 
{'Java'}
{'Java'}
 
{'C++''Python''Shell''Ruby''Java''PHP'}
{'C++''Python''Shell''Ruby''Java''PHP'}
 
{'C++''Shell''Python''Ruby''PHP'}
{'C++''Shell''Python''Ruby''PHP'}<br data-filtered="filtered"><br data-filtered="filtered">False<br data-filtered="filtered">False


标签(TAG)python  

分享到 :

0条评论 添加新评论

后发表评论