机器学习必须懂的集合

DXB2021

已于 2022-10-07 17:19:29 修改

阅读量1.4k

点赞数

分类专栏： Python 文章标签： java 开发语言

于 2022-10-04 16:06:19 首次发布

本文链接：https://blog.csdn.net/DXB2021/article/details/127162698

版权

Python 专栏收录该内容

52 篇文章 3 订阅

订阅专栏

使用Python建立集合

集合由元素组成，基本概念是无序且每个元素是唯一的。

使用{}建立集合

>>> lang={'Python','C','Java'}
>>> lang
{'C', 'Python', 'Java'}
>>> A={1,2,3,4,5}
>>> A
{1, 2, 3, 4, 5}
>>>

集合元素是唯一的

因为集合元素是唯一的，所以即使建立集合时有元素重复，也只有一份会被保留。

>>> A={1,1,2,2,3,3,3}
>>> A
{1, 2, 3}
>>>

使用set()建立集合

set()函数的参数只能有一个元素，此元素的内容可以是字符串（string)、列表(list)、元组（tuple）、字典（dict）等。

>>> A=set('Deepmind')
>>> A
{'e', 'n', 'm', 'd', 'D', 'p', 'i'}
>>> A=set(['Python','Java','C'])
>>> A
{'C', 'Python', 'Java'}
>>>

集合的基数（cardinality）

所谓集合的基数（cardinality）是指集合元素的数量，可以使用len()函数取得。

>>> A={1,3,5,7,9}
>>> len(A)
5
>>>

建立空集合要用set()

如果使用{}，将是建立空字典。建立空集合必须使用set()。

>>> empty_dict={}
>>> print("打印类=",type(empty_dict))
打印类= <class 'dict'>
>>> empty_set=set()
>>> print("打印类=",type(empty_set))
打印类= <class 'set'>
>>>

代码如下：

empty_dict = {}                      # 这是建立空字典
print("打印类 = ", type(empty_dict))
empty_set = set()                    # 这是建立空集合
print("打印类 = ", type(empty_set))

运行结果如下：

[Running] python -u "c:\Users\a-xiaobodou\OneDrive - Microsoft\Projects\tempCodeRunnerFile.py"
打印类 =  <class 'dict'>
打印类 =  <class 'set'>

[Done] exited with code=0 in 0.286 seconds

大数据与集合的应用

将列表内重复的数据删除。

fruits1 = ['apple', 'orange', 'apple', 'banana', 'orange']
x = set(fruits1)                # 将列转成集合
fruits2 = list(x)               # 将集合转成列表
print("原先列表数据fruits1 = ", fruits1)
print("新的列表资料fruits2 = ", fruits2)

运行结果如下：

[Running] python -u "c:\Users\a-xiaobodou\OneDrive - Microsoft\Projects\ch11_2.py"
原先列表数据fruits1 =  ['apple', 'orange', 'apple', 'banana', 'orange']
新的列表资料fruits2 =  ['apple', 'orange', 'banana']

[Done] exited with code=0 in 0.207 seconds

集合的操作

Python符号	说明	方法
&	交集	intersection()
\|	并集	union()
-	差集	difference()
^	对称差集	symmetric_difference()

交集（intersection）

有A和B两个集合，如果获得相同的元素，则使用交集。

交集的数学符号是 $\cap$ 。Python语言中的交集符号是&，也可以使用intersection()方法完成这个工作。

有数学与物理2个夏令营，这个程序会列出同时参加这2个夏令营的成员。

math = {'Kevin', 'Peter', 'Eric'}       # 设定参加数学夏令营成员
physics = {'Peter', 'Nelson', 'Tom'}    # 设定参加物理夏令营成员
both1 = math & physics
print("同时参加数学与物理夏令营的成员 ",both1)
both2 = math.intersection(physics)
print("同时参加数学与物理夏令营的成员 ",both2)

执行结果：

[Running] python -u "c:\Users\a-xiaobodou\OneDrive - Microsoft\Projects\tempCodeRunnerFile.py"
同时参加数学与物理夏令营的成员  {'Peter'}
同时参加数学与物理夏令营的成员  {'Peter'}

[Done] exited with code=0 in 0.663 seconds

并集（union）

有A和B两个集合，如果获得所有的元素，则使用并集。

并集的数学符号是 $\cup$ 。Python语言中的并集符号是|，也可以使用union()方法完成这个工作。

有数学与物理2个夏令营，这个程序会列出参加数学或物理夏令营的成员。

math = {'Kevin', 'Peter', 'Eric'}       # 设定参加数学夏令营成员
physics = {'Peter', 'Nelson', 'Tom'}    # 设定参加物理夏令营成员
allmember1 = math | physics
print("参加数学或物理夏令营的成员 ",allmember1)
allmember2 = math.union(physics)
print("参加数学或物理夏令营的成员 ",allmember2)

执行结果：

[Running] python -u "c:\Users\a-xiaobodou\OneDrive - Microsoft\Projects\tempCodeRunnerFile.py"
参加数学或物理夏令营的成员  {'Kevin', 'Eric', 'Peter', 'Nelson', 'Tom'}
参加数学或物理夏令营的成员  {'Kevin', 'Eric', 'Peter', 'Nelson', 'Tom'}

[Done] exited with code=0 in 1.882 seconds

差集（difference）

有A和B两个集合，如果获得属于A集合同时不属于B集合的元素，使用差集（A-B）。如果获得属于B集合同时不属于A集合的元素，使用差集（B-A）。

Python语言中的差集符号是-，也可以使用difference()方法完成这个工作。

有数学与物理2个夏令营，这个程序会列出参加数学夏令营同时没有参加物理夏令营的所有成员。另外也会列出参加物理夏令营同时没有参加数学夏令营的所有成员。

math = {'Kevin', 'Peter', 'Eric'}       # 设定参加数学夏令营成员
physics = {'Peter', 'Nelson', 'Tom'}    # 设定参加物理夏令营成员
math_only1 = math - physics
print("参加数学夏令营同时没有参加物理夏令营的成员 ",math_only1)
math_only2 = math.difference(physics)
print("参加数学夏令营同时没有参加物理夏令营的成员 ",math_only2)
physics_only1 = physics - math
print("参加物理夏令营同时没有参加数学夏令营的成员 ",physics_only1)
physics_only2 = physics.difference(math)
print("参加物理夏令营同时没有参加数学夏令营的成员 ",physics_only2)

执行结果：

[Running] python -u "c:\Users\a-xiaobodou\OneDrive - Microsoft\Projects\tempCodeRunnerFile.py"
参加数学夏令营同时没有参加物理夏令营的成员  {'Kevin', 'Eric'}
参加数学夏令营同时没有参加物理夏令营的成员  {'Kevin', 'Eric'}
参加物理夏令营同时没有参加数学夏令营的成员  {'Nelson', 'Tom'}
参加物理夏令营同时没有参加数学夏令营的成员  {'Nelson', 'Tom'}

[Done] exited with code=0 in 0.603 seconds

对称差集（symmetric difference）

有A和B两个集合，如果获得属于A或者属于B集合，但是不同时属性A和B的元素，使用对称差集。

Python语言中的对称差集符号是^，也可以使用symmetric_difference()方法完成这个工作。

有数学与物理2个夏令营，这个程序会列出没有同时参加2个夏令营的成员。

math = {'Kevin', 'Peter', 'Eric'}       # 设定参加数学夏令营成员
physics = {'Peter', 'Nelson', 'Tom'}    # 设定参加物理夏令营成员
math_sydi_physics1 = math ^ physics
print("没有同时参加数学和物理夏令营的成员 ",math_sydi_physics1)
math_sydi_physics2 = math.symmetric_difference(physics)
print("没有同时参加数学和物理夏令营的成员 ",math_sydi_physics2)

执行结果：

[Running] python -u "c:\Users\a-xiaobodou\OneDrive - Microsoft\Projects\tempCodeRunnerFile.py"
没有同时参加数学和物理夏令营的成员  {'Nelson', 'Tom', 'Eric', 'Kevin'}
没有同时参加数学和物理夏令营的成员  {'Nelson', 'Tom', 'Eric', 'Kevin'}

[Done] exited with code=0 in 0.37 seconds

子集、超集与补集

集合A内容是{1，2，3，4，5，6}，集合B内容是{1，3，5}。

子集

集合B的所有元素皆在集合A内，我们称集合B是集合A的子集（subset），数学表示方法如下：

$A\supset B$ 或是 $B\subset A$ #B包含于A，可以使用A>B语法

$A\supseteq B$ 或者 $B\subseteq A$ #B包含于或等于A，可以使用A>=b语法

空集是任一个集合的子集，一个集合也是本身的子集。

>>> A={1,2,3}
>>> B=set()
>>> B<=A
True
>>> A<=A
True
>>>

使用<=符号或是issubset()函数测试B是否是A的子集，如果是则回传True，否则回传False。

>>> A={1,2,3,4,5,6}
>>> B={1,3,5}
>>> B<=A
True
>>> B.issubset(A)
True
>>>

超集

所有集合B的元素皆在集合A内，集合A是集合B的超集（superset）。

使用>=符号或是issuperset()函数测试A是否是B的超集，如果是则回传True，否则回传False。

>>> A={1,2,3,4,5,6}
>>> B={1,3,5}
>>> A>=B
True
>>> A.issuperset(B)
True
>>>

补集

属性A集合但是不在B集合的元素称B在A中的补集。

使用A-B得到结果。

>>> A={1,2,3,4,5,6}
>>> B={1,3,5}
>>> A-B
{2, 4, 6}
>>>

加入与删除集合元素

方法	说明	实例
add()	增加元素	A.add('element')
remove()	删除元素	A.remove('element')
pop()	随机删除元素并回传	A.pop()
clear()	删除所有元素	A.clear()

增加元素的实例：

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

删除元素的实例：

>>> A={1,2,3}
>>> A.remove(2)
>>> A
{1, 3}
>>>

随机删除元素并回传的实例：

>>> A={1,2,3}
>>> ret=A.pop()
>>> A
{2, 3}
>>> ret
1
>>>

删除所有元素：

>>> A={1,2,3}
>>> A.clear()
>>> A
set()
>>>

幂集与sympy模块

幂集（Power Set）是指一个集合的所有子集合所构成的集合。

sympy模块与集合

sympy模块可以建立集合，使用前需要导入此模块与集合有关的方法：

from sympy import FiniteSet

FiniteSet()方法可以建立集合，下列是建立集合{1，2，3}的实例。

>>> from sympy import FiniteSet
>>> A=FiniteSet(1,2,3)
>>> A
{1, 2, 3}
>>>

建立幂集

可以使用powerset()建立集合的幂集，延续上一个实例执行下列操作。

>>> a=A.powerset()
>>> a
FiniteSet(EmptySet, {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3})
>>>

幂集的元素个数

一个集合如果有n个元素，此集合的幂集元素个数有 $2^n$ 个。

笛卡儿积

集合相乘

所谓的笛卡儿积（Cartesian product）是指从每个集合中提取一个元素组成的所有可能的集合，建立笛卡儿积可以使用乘法符号*，此时所建的元素内容是元组（tuple）。

有2个集合，这2个集合皆有2个元素，建立此笛卡尔积。

from sympy import *
A = FiniteSet('a', 'b')
B = FiniteSet('c', 'd')
AB = A * B
for ab in AB:
    print(type(ab), ab)

运行结果：

[Running] python -u "c:\Users\a-xiaobodou\OneDrive - Microsoft\Projects\tempCodeRunnerFile.py"
<class 'tuple'> (a, c)
<class 'tuple'> (b, c)
<class 'tuple'> (a, d)
<class 'tuple'> (b, d)

[Done] exited with code=0 in 5.545 seconds

有2个集合，这2个集合分别有5个元素和2个元素，建立此笛卡尔积。

from sympy import *
A = FiniteSet('a', 'b', 'c', 'd', 'e')
B = FiniteSet('f', 'g')
AB = A * B
print('The length of Cartesian product', len(AB))
for ab in AB:
    print(ab)

运行结果：

[Running] python -u "c:\Users\a-xiaobodou\OneDrive - Microsoft\Projects\tempCodeRunnerFile.py"
The length of Cartesian product 10
(a, f)
(b, f)
(a, g)
(c, f)
(b, g)
(d, f)
(c, g)
(e, f)
(d, g)
(e, g)

[Done] exited with code=0 in 12.589 seconds

集合的n次方

假设A集合有2个元素，若要求三次方的笛卡尔积，所建立的元素个数是 $2^3$ 。n次方则代表由n个元素组成的元组，此时所建立的元素个数是 $2^n$ 。

建立三次方的笛卡尔积。

from sympy import *
A = FiniteSet('a', 'b')
AAA = A**3
print('The length of Cartesian product', len(AAA))
for a in AAA:
    print(a)

运行结果如下：

[Running] python -u "c:\Users\a-xiaobodou\OneDrive - Microsoft\Projects\tempCodeRunnerFile.py"
The length of Cartesian product 8
(a, a, a)
(b, a, a)
(a, b, a)
(b, b, a)
(a, a, b)
(b, a, b)
(a, b, b)
(b, b, b)

[Done] exited with code=0 in 6.545 seconds