集合

之前看到的列表和字符串都是一种有序序列,而集合 set 是一种无序的序列。

因为集合是无序的,所以当集合中存在两个同样的元素的时候,Python只会保存其中的一个(唯一性);同时为了确保其中不包含同样的元素,集合中放入的元素只能是不可变的对象(确定性)。

集合生成

可以用set()函数来显示的生成空集合:

In [1]:

  1. a = set()
  2. type(a)

Out[1]:

  1. set

也可以使用一个列表来初始化一个集合:

In [2]:

  1. a = set([1, 2, 3, 1])
  2. a

Out[2]:

  1. {1, 2, 3}

集合会自动去除重复元素 1

可以看到,集合中的元素是用大括号{}包含起来的,这意味着可以用{}的形式来创建集合:

In [3]:

  1. a = {1, 2, 3, 1}
  2. a

Out[3]:

  1. {1, 2, 3}

但是创建空集合的时候只能用set来创建,因为在Python中{}创建的是一个空的字典:

In [4]:

  1. s = {}
  2. type(s)

Out[4]:

  1. dict

集合操作

假设有这样两个集合:

In [5]:

  1. a = {1, 2, 3, 4}
  2. b = {3, 4, 5, 6}

两个集合的并,返回包含两个集合所有元素的集合(去除重复)。

可以用方法 a.union(b) 或者操作 a | b 实现。

In [6]:

  1. a.union(b)

Out[6]:

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

In [7]:

  1. b.union(a)

Out[7]:

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

In [8]:

  1. a | b

Out[8]:

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

两个集合的交,返回包含两个集合共有元素的集合。

可以用方法 a.intersection(b) 或者操作 a & b 实现。

In [9]:

  1. a.intersection(b)

Out[9]:

  1. {3, 4}

In [10]:

  1. b.intersection(a)

Out[10]:

  1. {3, 4}

In [11]:

  1. a & b

Out[11]:

  1. {3, 4}

In [12]:

  1. print(a & b)
  1. set([3, 4])

注意:一般使用print打印set的结果与表示方法并不一致。

ab 的差集,返回只在 a 不在 b 的元素组成的集合。

可以用方法 a.difference(b) 或者操作 a - b 实现。

In [13]:

  1. a.difference(b)

Out[13]:

  1. {1, 2}

In [14]:

  1. a - b

Out[14]:

  1. {1, 2}

注意,a - bb - a并不一样,b - a 返回的是返回 b 不在 a 的元素组成的集合:

In [15]:

  1. b.difference(a)

Out[15]:

  1. {5, 6}

In [16]:

  1. b - a

Out[16]:

  1. {5, 6}

对称差

ab 的对称差集,返回在 a 或在 b 中,但是不同时在 ab 中的元素组成的集合。

可以用方法 a.symmetric_difference(b) 或者操作 a ^ b 实现(异或操作符)。

In [17]:

  1. a.symmetric_difference(b)

Out[17]:

  1. {1, 2, 5, 6}

In [18]:

  1. b.symmetric_difference(a)

Out[18]:

  1. {1, 2, 5, 6}

In [19]:

  1. a ^ b

Out[19]:

  1. {1, 2, 5, 6}

包含关系

假设现在有这样两个集合:

In [20]:

  1. a = {1, 2, 3}
  2. b = {1, 2}

要判断 b 是不是 a 的子集,可以用 b.issubset(a) 方法,或者更简单的用操作 b <= a

In [21]:

  1. b.issubset(a)

Out[21]:

  1. True

In [22]:

  1. b <= a

Out[22]:

  1. True

与之对应,也可以用 a.issuperset(b) 或者 a >= b 来判断:

In [23]:

  1. a.issuperset(b)

Out[23]:

  1. True

In [24]:

  1. a >= b

Out[24]:

  1. True

方法只能用来测试子集,但是操作符可以用来判断真子集:

In [25]:

  1. a <= a

Out[25]:

  1. True

自己不是自己的真子集:

In [26]:

  1. a < a

Out[26]:

  1. False

集合方法

add 方法向集合添加单个元素

跟列表的 append 方法类似,用来向集合添加单个元素。

  1. s.add(a)

将元素 a 加入集合 s 中。

In [27]:

  1. t = {1, 2, 3}
  2. t.add(5)
  3. t

Out[27]:

  1. {1, 2, 3, 5}

如果添加的是已有元素,集合不改变:

In [28]:

  1. t.add(3)
  2. t

Out[28]:

  1. {1, 2, 3, 5}

update 方法向集合添加多个元素

跟列表的extend方法类似,用来向集合添加多个元素。

  1. s.update(seq)

seq中的元素添加到s中。

In [29]:

  1. t.update([5, 6, 7])
  2. t

Out[29]:

  1. {1, 2, 3, 5, 6, 7}

remove 方法移除单个元素

  1. s.remove(ob)

从集合s中移除元素ob,如果不存在会报错。

In [30]:

  1. t.remove(1)
  2. t

Out[30]:

  1. {2, 3, 5, 6, 7}

In [31]:

  1. t.remove(10)
  1. ---------------------------------------------------------------------------
  2. KeyError Traceback (most recent call last)
  3. <ipython-input-31-3bc25c5e1ff4> in <module>()
  4. ----> 1 t.remove(10)
  5.  
  6. KeyError: 10

pop方法弹出元素

由于集合没有顺序,不能像列表一样按照位置弹出元素,所以pop 方法删除并返回集合中任意一个元素,如果集合中没有元素会报错。

In [32]:

  1. t.pop()

Out[32]:

  1. {3, 5, 6, 7}

In [33]:

  1. print t
  1. set([3, 5, 6, 7])

In [34]:

  1. s = set()
  2. # 报错
  3. s.pop()
  1. ---------------------------------------------------------------------------
  2. KeyError Traceback (most recent call last)
  3. <ipython-input-34-9f9e06c962e6> in <module>()
  4. 1 s = set()
  5. 2 # 报错
  6. ----> 3 s.pop()
  7.  
  8. KeyError: 'pop from an empty set'

discard 方法

作用与 remove 一样,但是当元素在集合中不存在的时候不会报错。

In [35]:

  1. t.discard(3)

In [36]:

  1. t

Out[36]:

  1. {5, 6, 7}

不存在的元素不会报错:

In [37]:

  1. t.discard(20)

In [38]:

  1. t

Out[38]:

  1. {5, 6, 7}

difference_update方法

  1. a.difference_update(b)

从a中去除所有属于b的元素:

原文: https://nbviewer.jupyter.org/github/lijin-THU/notes-python/blob/master/02-python-essentials/02.11-sets.ipynb