网上转的，不错，比使用awk容易点


给定两个文件 a.txt 和 b.txt ，每行是一个记录（假设没有重复），要求输出两集合的交集、并集、差集，输出的结果只包括唯一项。交集定义为同时出现在两个文件中的记录项，并集定义为出现在任何一个文件中的记录项，差集(A-B)定义为出现在A中而且不出现在B中的记录，对称差集定义为只出现在一个文件中的记录。

假设 a.txt 包括 a, c, b 三行。假设 b.txt 包括 d, e, c, b 四行。

交集，把两个文件放到一起排序，只输出次数多于一次的项：
$ sort a.txt b.txt | uniq -d
b
c

并集，把两个文件放到一起排序，重复的项只算一次：
$ sort a.txt b.txt | uniq
a
b
c
d
e

差集(A-B)，把B的元素重复2份和A的元素放到一起排序，只输出出现一次的项：
$ sort a.txt b.txt b.txt | uniq -u
a

对称差，把两个文件放到一起排序，只输出出现一次的项：
$ sort a.txt b.txt | uniq -u
a
d
e

给定两个文件 a.txt 和 b.txt ，每行是一个记录（假设没有重复），要求输出两集合的交集、并集、差集，输出的结果只包括唯一项。交集定义为同时出现在两个文件中的记录项，并集定义为出现在任何一个文件中的记录项，差集(A-B)定义为出现在A中而且不出现在B中的记录，对称差集定义为只出现在一个文件中的记录。
假设 a.txt 包括 a, c, b 三行。假设 b.txt 包括 d, e, c, b 四行。
交集，把两个文件放到一起排序，只输出次数多于一次的项：

$ sort a.txt b.txt | uniq -d

b

c
并集，把两个文件放到一起排序，重复的项只算一次：

$ sort a.txt b.txt | uniq

a

b

c

d

e
差集(A-B)，把B的元素重复2份和A的元素放到一起排序，只输出出现一次的项：

$ sort a.txt b.txt b.txt | uniq -u

a
对称差，把两个文件放到一起排序，只输出出现一次的项：

$ sort a.txt b.txt | uniq -u

a

d

e
转自：http://blog.csdn.net/yinxusen/article/details/7450213

网上转的，不错，比使用awk容易点




给定两个文件 a.txt 和 b.txt ，每行是一个记录（假设没有重复），要求输出两集合的交集、并集、差集，输出的结果只包括唯一项。交集定义为同时出现在两个文件中的记录项，并集定义为出现在任何一个文件中的记录项，差集(A-B)定义为出现在A中而且不出现在B中的记录，对称差集定义为只出现在一个文件中的记录。

假设 a.txt 包括 a, c, b 三行。假设 b.txt 包括 d, e, c, b 四行。

交集，把两个文件放到一起排序，只输出次数多于一次的项：
$ sort a.txt b.txt | uniq -d
b
c

并集，把两个文件放到一起排序，重复的项只算一次：
$ sort a.txt b.txt | uniq
a
b
c
d
e

差集(A-B)，把B的元素重复2份和A的元素放到一起排序，只输出出现一次的项：
$ sort a.txt b.txt b.txt | uniq -u
a

对称差，把两个文件放到一起排序，只输出出现一次的项：
$ sort a.txt b.txt | uniq -u
a
d


e

集合运算
交集
差集
对称差集
并集
补集
拓展
集合相关的判断
集合的应用
集合的限制
总结

交集
数学定义：集合论中，设A,B是两个集合，有所有属于A且属于集合B的元素所组成的集合，叫做集合A与集合B的交集（intersection），记作A∩B。
**交集的定义：**存在集合A和B，对于集合C，如果C的每个元素既是A的元素，又是B的元素，并且A和B所有相同的元素都在C里找到，那么C是A和B的交集。
>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s1.intersection(s2)
{2, 3}

如上，intersection()方法可以得到两个集合的交集，是原地不修改，有返回值。
>>> s2.intersection_update(s1)
>>> s1
{1, 2, 3}
>>> s2
{2, 3}

如上，intersection_update()方法原地修改，返回None。等效于s2 = s1.intersection(s2)。
>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s1 & s2
{2, 3}
>>> s1
{1, 2, 3}
>>> s2
{2, 3, 4}
>>> s2 & s1
{2, 3}

如上，set重载了按位与运算符&为求交集的运算，即，集合中的&与intersection实现了同样的功能。为方便可以直接使用&会更清楚一些。

（重载，简单说，就是函数或者方法有相同的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。）
差集
数学定义：记A，B是两个集合，则所有属于A且不属于B的元素构成的集合，叫做集合A减集合B（或集合A与集合B之差），类似地，对于集合A、B，我们把集合 $\{x|x\in A,且x\notin B\}$ 叫做A与B的差集。
**差集定义：**集合A和集合B，当集合C的元素仅仅存在于A中，但不存在于B中，并且A中存在、B中不存在的元素全部存在C中，那么C是A和B的差集。
>>> s1.difference(s2)
{1}
>>> s1
{1, 2, 3}
>>> s2
{2, 3, 4}
>>> s2.difference(s1)
{4}

如上可知，差集如果互换顺序会产生差异，差集是不具备交换律的。
>>> s1.difference_update(s2)
>>> s1
{1}
>>> s2
{2, 3, 4}

如上，差集的difference_update()方法，原地修改，返回None，相当于s1 = s1.difference(s2)
运算重载符：
>>> s1 - s2
{1}
>>> s2 - s1
{4}
>>> s1
{1, 2, 3}
>>> s2
{2, 3, 4}

所以，set重载了运算符-，执行了差集计算，相当于s1.difference(s2)
对称差集
数学定义：集合A与集合B的对称差集定义为集合A与集合B中所有不属于A∩B的元素的集合，记为$\{x|x\in A∪B,x\notin A∩B\}$，即$(A∪B)-(A∩B)$。

**对称差集的定义：**一个元素，要么在集合A中，要么在集合B中
>>> s1.symmetric_difference(s2)
{1, 4}
>>> s2.symmetric_difference(s1)
{1, 4}
>>> s1
{1, 2, 3}
>>> s2
{2, 3, 4}

对称差集是可以交换的，并且返回的值恰好是交集的补集

所以：如果把两个集合A和B看成一个全集，对称差集就是交集的补集
>>> s1.symmetric_difference_update(s2)
>>> s1
{1, 4}
>>> s2
{2, 3, 4}

对称差集也有symmetric_difference_update()方法，原地修改，返回None，相当于s1 = s1.symmetric_difference(s2)
对称差集重载了异或运算符，相当于s1 = s1.symmetric_difference(s2)
>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s1 ^ s2
{1, 4}
>>> s2 ^ s1
{1, 4}

并集
数学定义：若A和B是集合，则A和B并集是所有A的元素和所有B的元素，而没有其他元素的集合。A和B的并集通常写作“A∪B”，即：$\{x|x\in A,或x\in B\}$
>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s1.union(s2)
{1, 2, 3, 4}
>>> s2.union(s1)
{1, 2, 3, 4}

并集也有交换律，但是并集的_update版本就是update
>>> s1.update(s2)
>>> s1
{1, 2, 3, 4}
>>> s2
{2, 3, 4}

并集的重载运算符为|，set重载了按位或运算符，用于并集计算。
>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s1 | s2
{1, 2, 3, 4}
>>> s2 | s1
{1, 2, 3, 4}

补集
数学定义：补集一般值绝对补集，即一般地，设S是一个集合，A是S的一个子集，由S中所有不属于A的元素组成的集合，叫做子集A在S中的绝对补集。
拓展

异或定义

>>> 5 ^ 2
7
>>> bin(5)
'0b101'
>>> bin(2)
'0b10'
>>> bin(7)
'0b111'


异或常用场景

交换2个整数的值而不必用第三个参数

>>> a = 9
>>> b = 11
# 1001 ^ 1011 = 0010
>>> a = a ^ b
>>> a
2
>>> b
11
#1011 ^ 0010 = 1001
>>> b = b ^ a
>>> a
2
>>> b
9
#0010 ^ 1001 = 1011
>>> a = a ^ b
>>> a
11
>>> b
9

集合相关的判断

子集、超集

数学定义：如果一个集合s2中的每一个元素都在集合s1中，且集合s1中可能包含s2中没有的元素，则集合s1就是s2的一个超集，反过来，s2是s1的子集。

集合A里所有元素都能在集合B里找到，那么A是B的子集，B是A的超集。

判断s2是否是s1的子集：
>>> s1 = {1, 2, 3, 4}
>>> s2 = {2, 3}
>>> s2.issubset(s1)
True
#判断s1是否是s2的超集：
>>> s1.issuperset(s2)
True

简单实现一个自己的版本;
def issubset(s1, s2):
    for x in s1:
        if x not in s2:
            return False
    return True

def issuperset(s1, s2):
    for x in s2:
        if x not in s1:
            return False
    return True

#isdisjoint判断2个集合是否有交集，如果有交集就返回False，没有交集就返回True
s1.isdisjoint(s2)

>>> s3 = {1, 2}
>>> s4 = {3, 4}
>>> s3.isdisjoint(s4)
True

集合的应用

去重
集合运算更快



有一个API，他要有认证，并且有一定权限才可以访问：
 例如：要求满足权限A,B,C中任意一项，有一个用户具有权限B,C,D,那么此用户是否有权限访问此API？
 通过isdisjoint的方法，返回False即可。



集合的限制

目前学的数据结构有：


列表
元组
字符串
bytes
bytearray
集合


哪些数据结构对元素有限制：


bytes
bytearray
str


集合有没有限制：

集合的特性：元素不会重复

如果一个元素不可以比较，那么就不能放到集合里，因为无法做出判断是否有重复

>>> {1, 2, 3}#整形可以
{1, 2, 3}
>>> {'a', 'b', 'c'}#字符也可以
{'b', 'c', 'a'}
>>> {1, 'a'}#混着也可以
{1, 'a'}
>>> {(1, 2)}#元组也可以
{(1, 2)}
>>> {b'abc'}#bytes也可以
{b'abc'}

但是也有限制
>>> {[1, 2, 3],[2, 3, 4]}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> {bytearray(b'abc')}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'bytearray'

list不能是集合的元素，bytearray不能是集合的元素，连set自己也不能做集合的元素。
什么样的元素可以作为集合的元素，什么样的元素不能作为集合的元素？

集合元素必须可hash

>>> hash(1)
1
>>> hash('abc')
-3496128926335596964
>>> hash(b'abc')
-3496128926335596964
>>> hash((1, 2))
3713081631934410656

#以下为不行
>>> hash([1, 2])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
#依次类推

list、bytearray、set是可变的，是不可hash的。
总结