Apriori算法进行关联分析（1）

1. 使用Apriori算法来发现频繁集

1.1 关联分析

关联分析：是一种在大规模数据集中寻找有趣关系的任务。这些关系可以有两种形式：频繁项集或者关联规则。频繁项集（frequent item sets)是经常出现在一块的物品的集合，关联规则(association rules)暗示两种物品之间可能存在很强的关系。

而有趣、频繁、有趣的关系这些量化的工具就是支持度和可信度。

一个项集的支持度(support)：被定义为数据集中包含该项集的记录所占的比例。支持度是针对项集来说的，因此可以定义一个最小支持度，而只保留满足最小支持度的项集。
可信度或置信度（confidence)：是针对一条关联规则来定义的。这条规则的可信度被定义为“支持度({尿布，葡萄酒})/支持度({尿布})”。

1.2 Apriori原理

对于上图的集合数目，会发现即使对于仅有4种物品的集合，也需要遍历数据15次。而随着物品数目的增加遍历次数会急剧增长。对于包含—物品的数据集共有2N−12^N-1种项集组合，需要很长的时间才能完成运算。

为了降低所需的计算时间，有了Apriori原理，Apriori原理是说如果某个项集是频繁的，那么它的所有子集也是频繁的。如果反过来就是说如果一个项集是非频繁集，那么它的所有超集也是非频繁的。

关联分析的目标包括两项：发现频繁项集和发现关联规则。首先需要找到频繁项集，然后才能获得关联规则。
生成候选集：

对数据集中的每条交易记录tran
对每个候选项集can：
检查一下can是否是tran的子集：
如果是，则增加can的计数值
对每个候选项集：
如果其支持度不低于最小值，则保留该项集
返回所有频繁项集列表。

完整的Apriori算法：

当集合中项的个数大于0时
构建一个k个项组成的候选项集的列表
检查数据以确认每个项集都是频繁的
保留频繁项集并构建k+1项组成的候选项集的列表

代码：

# -*- coding: utf-8 -*-
"""
Created on Thu Nov 09 13:16:21 2017
"""
from numpy import *# 用于测试的简单数据集列表
def loadDataSet():return [[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]]# 构建第一个候选子集
def createC1(dataSet):C1 = [] # 用来存储所有不重复的项值for transaction in dataSet: # 遍历数据集的每一次交易记录for item in transaction: # 遍历每一记录的每一项if not [item] in C1: C1.append([item]) # 添加只包含该物品项的一个列表print 'list_C1:',C1         # 打印该列表C1.sort() # 对列表进行排序frozenset_C1=map(frozenset, C1) # 这里把C1的每个元素映射到frozenset()return frozenset_C1  # 返回frozenset的列表# 从Ck生成Lk
def scanD(D, Ck, minSupport): # 三个参数：数据集，候选项集列表，感兴趣项集的最小支持度 ssCnt = {}for tid in D: # 遍历数据集的每一交易记录for can in Ck: # 遍历每一候选项集if can.issubset(tid): # 判断该集合是否是记录的一部分if not ssCnt.has_key(can): # 如果没有,该集合就把该集合增加到字典中ssCnt[can]=1 # 这里字典的键就是该项集else: ssCnt[can] += 1 # 如果已经有了键，就计数加1numItems = float(len(D)) # 变为浮点数retList = [] # 该列表包含满足最小支持度要求的集合supportData = {}for key in ssCnt: # 遍历字典的每个元素support = ssCnt[key]/numItems # 计算支持度(分母是所有的交易记录)if support >= minSupport: # 如果满足最小支持度retList.insert(0,key) # 则将字典元素添加到retlist列表print 'retList:',retListsupportData[key] = support  # 返回所有项集的支持度return retList, supportData # 返回频繁项集的支持度# 创建候选项集CK
def aprioriGen(Lk, k): # 参数分别是：频繁项集列表LK，项集元素个数Kprint 'LK_1:',LkretList = []lenLk = len(Lk)for i in range(lenLk): # 遍历LK中的每一个元素for j in range(i+1, lenLk): # 和后面的元素逐一比较L1 = list(Lk[i])[:k-2]; L2 = list(Lk[j])[:k-2] # 取列表的两个集合进行比较L1.sort(); L2.sort() print 'L1 and L2:',L1,L2if L1==L2: # 如果两个集合的前k-2个元素相同，那么就合并此两个集合为大小k的集合print 'here !'retList.append(Lk[i] | Lk[j]) # 这里用python中集合的并操作“|”return retListdef apriori(dataSet, minSupport = 0.5):C1 = createC1(dataSet)  # C1是候选项集列表print 'C1:',C1D = map(set, dataSet)print 'D:',DL1, supportData = scanD(D, C1, minSupport) # L1是得到的是满足最小支持度的项集构成的集合print 'L1:',L1print 'supportData:',supportDataL = [L1] # L1放入列表中print 'L:',Lk = 2while (len(L[k-2]) > 0): # 直到下一个大的项集为空Ck = aprioriGen(L[k-2], k)  # ck是非重复的项集，即候选项集列表print 'CK:',CkLk, supK = scanD(D, Ck, minSupport) # 得到Lk，即得到满足最小支持度的项集print 'Lk_2:',Lkprint 'supK:',supKsupportData.update(supK) # 这里是更新supportData字典，即加入supk，得到总的支持度字典print 'supportData_2:',supportDataL.append(Lk) # 得到总的满足支持度要求的项集集合print 'L_2:',Lk += 1return L, supportData# 主函数
dataSet=loadDataSet()
L,suppData=apriori(dataSet)
print 'L:',L

运行结果：

list_C1: [[1]]
list_C1: [[1], [3]]
list_C1: [[1], [3], [4]]
list_C1: [[1], [3], [4], [2]]
list_C1: [[1], [3], [4], [2], [5]]
C1: [frozenset([1]), frozenset([2]), frozenset([3]), frozenset([4]), frozenset([5])]
D: [set([1, 3, 4]), set([2, 3, 5]), set([1, 2, 3, 5]), set([2, 5])]
retList: [frozenset([5])]
retList: [frozenset([2]), frozenset([5])]
retList: [frozenset([3]), frozenset([2]), frozenset([5])]
retList: [frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5])]
L1: [frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5])]
supportData: {frozenset([5]): 0.75, frozenset([2]): 0.75, frozenset([3]): 0.75, frozenset([1]): 0.5}
L: [[frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5])]]
LK_1: [frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5])]
L1 and L2: [] []
here !
L1 and L2: [] []
here !
L1 and L2: [] []
here !
L1 and L2: [] []
here !
L1 and L2: [] []
here !
L1 and L2: [] []
here !
CK: [frozenset([1, 3]), frozenset([1, 2]), frozenset([1, 5]), frozenset([2, 3]), frozenset([3, 5]), frozenset([2, 5])]
retList: [frozenset([3, 5])]
retList: [frozenset([2, 3]), frozenset([3, 5])]
retList: [frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])]
retList: [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])]
Lk_2: [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])]
supK: {frozenset([1, 3]): 0.5, frozenset([2, 3]): 0.5, frozenset([3, 5]): 0.5, frozenset([2, 5]): 0.75}
supportData_2: {frozenset([5]): 0.75, frozenset([3]): 0.75, frozenset([3, 5]): 0.5, frozenset([2, 3]): 0.5, frozenset([2, 5]): 0.75, frozenset([1]): 0.5, frozenset([1, 3]): 0.5, frozenset([2]): 0.75}
L_2: [[frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5])], [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])]]
LK_1: [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])]
L1 and L2: [1] [2]
L1 and L2: [1] [2]
L1 and L2: [1] [3]
L1 and L2: [2] [2]
here !
L1 and L2: [2] [3]
L1 and L2: [2] [3]
CK: [frozenset([2, 3, 5])]
retList: [frozenset([2, 3, 5])]
Lk_2: [frozenset([2, 3, 5])]
supK: {frozenset([2, 3, 5]): 0.5}
supportData_2: {frozenset([5]): 0.75, frozenset([3]): 0.75, frozenset([2, 3, 5]): 0.5, frozenset([3, 5]): 0.5, frozenset([2, 3]): 0.5, frozenset([2, 5]): 0.75, frozenset([1]): 0.5, frozenset([1, 3]): 0.5, frozenset([2]): 0.75}
L_2: [[frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5])], [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])], [frozenset([2, 3, 5])]]
LK_1: [frozenset([2, 3, 5])]
CK: []
Lk_2: []
supK: {}
supportData_2: {frozenset([5]): 0.75, frozenset([3]): 0.75, frozenset([2, 3, 5]): 0.5, frozenset([3, 5]): 0.5, frozenset([2, 3]): 0.5, frozenset([2, 5]): 0.75, frozenset([1]): 0.5, frozenset([1, 3]): 0.5, frozenset([2]): 0.75}
L_2: [[frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5])], [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])], [frozenset([2, 3, 5])], []]
L: [[frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5])], [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])], [frozenset([2, 3, 5])], []]

从运行结果可以看出具体的运行过程，结合下图理解。

注意：

frozenset是指被“冰冻”的集合，就是说它们是不可改变的，即用户不能修改它们。这里必须要使用frozenset而不是set类型，因为之后必须要将这些集合作为字典键值使用，使用frozenset可以实现这一点，而set却做不到。
Python不能创建只有一个整数的集合，因此这里实现必须使用列表。这就是我们使用一个由单物品列表组成的大列表的原因。最后，对大列表进行排序并将其中的每个单元素列表映射到frozenset（），最后返回frozenset的列表。
上面的k-2有点让人疑惑。接下来再进一步讨论细节。当利用{0}、{1}、{2}构建{0,1}、{0，2}、{1，2}时，这实际上是将单个项组合到一块。现在如果想利用{0,1}、{0,2}、{1，2}来创建三元素项集应该怎么做？如果将每两个集合合并，就会得到{0,1,2}、{0，1，2}、{0,l,2}。也就是说，同样的结果集合会重复3次。接下来需要扫描三元素项集列表来得到非重复结果，我们要做的是确保遍历列表的次数最少。现在，如果比较集合{0,1}、{0,2},{1,2}的第1个元素并只对第1个元素相同的集合求并操作，又会得到什么结果？{0,l,2},而且只有一次操作！这样就不需要遍历列表来寻找非重复值。
将两个集合合成一个大小为k的集合。这里使用集合的并操作来完成，在python中对应操作符 ||

2. 从频繁项集中挖掘关联规则

这里要首先明白的而是可信的计算方式：
一条规则P—>HP—>H的可信度定义为Support(P|H)/support(P)Support(P|H)/support(P)中，操作符丨表示集合的并操作，而数学上集合并的符号是⋃\bigcup 。P|HP|H是指所有出现在集合PP或者集合HH中的元素。前面一节已经计算了所有频繁项集支持度。现在想获得可信度，所需要做的只是取出那些支持度值做一次除法运算。

类似于上面的频繁项集生成，我们可以为每个频繁项集产生许多关联规则。如果能够减少规则数目来确保问题的可解性，那么计算起来就会好很多。可以观察到，如果某条规则并不满足最小可信度要求，那么该规则的所有子集也不会满足最小可信度要求。上图中，假设规则0,1,2—>30,1,2—>3并不满足最小可信度要求，那么就知道任何左部为0，1，2{0，1，2}子集的规则也不会满足最小可信度要求。上图中这些规则上都加了阴影来表示。所以可以利用关联规则的上述性质属性来减少需要测试的规则数目。

代码：

# -*- coding: utf-8 -*-
"""
Created on Thu Nov 09 20:52:41 2017
"""
from numpy import *def loadDataSet():return [[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]]# 生成候选规则集合(计算可信度值)
def calcConf(freqSet, H, supportData, brl, minConf=0.7):prunedH = []   # 空列表保存满足最小可信度要求的规则列表for conseq in H: # 遍历H中的所有项集，并计算他们的可信度值# supportData[freqSet]是频繁集的值，也就是支持度，freqSet是相应的键，freqSet-conseq集合相减print 'P -->H:',freqSet-conseq,'-->',conseqconf = supportData[freqSet]/supportData[freqSet-conseq] # 得到可信度print 'conf:',confif conf >= minConf: # 如果满足最小可信度值print freqSet-conseq,'-->',conseq,'conf:',conf  # 打印出来brl.append((freqSet-conseq, conseq, conf)) # 规则添加到列表中prunedH.append(conseq)return prunedH# 生成更多的关联规则
def rulesFromConseq(freqSet, H, supportData, brl, minConf=0.7): # H是频繁项集的拆分m = len(H[0]) # 首先计算拆分的频繁项集的大小print 'm:',mif (len(freqSet) > (m + 1)): # 尝试进一步合并Hmp1 = aprioriGen(H, m+1) # 创建Hm+1条新候选规则，生成H中元素的无重复组合print 'Hmp1:',Hmp1Hmp1 = calcConf(freqSet, Hmp1, supportData, brl, minConf)print 'Hmp1_2:',Hmp1 if (len(Hmp1) > 1):    # 使用hmp迭代调用函数rulesFromConseq()来判断是否可以进一步组合规则rulesFromConseq(freqSet, Hmp1, supportData, brl, minConf)# 关联规则生成函数
def generateRules(L, supportData, minConf=0.7):  #频繁项集列表，包含频繁项集支持数据的字典，最小可信度阈值bigRuleList = []for i in range(1, len(L)): # 遍历每一个频繁项集，从第二个项集开始for freqSet in L[i]:   # 为每个频繁项集创建只包含单个元素集合的列表H1print 'L[i]:',L[i]print 'freqSet:',freqSetH1 = [frozenset([item]) for item in freqSet] # 列表推导式print 'H1:',H1if (i > 1):print 'i=%d...' % irulesFromConseq(freqSet, H1, supportData, bigRuleList, minConf)else: # i=1表示频繁项集的元素数目为2print 'i=1.....'calcConf(freqSet, H1, supportData, bigRuleList, minConf)print 'bigRuleList:',bigRuleList  # 对应的是calcConf函数中的brl参数return bigRuleList # 返回一个包含可信度的规则列表            # 构建第一个候选子集
def createC1(dataSet):C1 = [] # 用来存储所有不重复的项值for transaction in dataSet: # 遍历数据集的每一次交易记录for item in transaction: # 遍历每一记录的每一项if not [item] in C1: C1.append([item]) # 添加只包含该物品项的一个列表               C1.sort() # 对列表进行排序frozenset_C1=map(frozenset, C1) # 这里把C1的每个元素映射到frozenset()return frozenset_C1  # 返回frozenset的列表# 从Ck生成Lk
def scanD(D, Ck, minSupport): # 三个参数：数据集，候选项集列表，感兴趣项集的最小支持度 ssCnt = {}for tid in D: # 遍历数据集的每一交易记录for can in Ck: # 遍历每一候选项集if can.issubset(tid): # 判断该集合是否是记录的一部分if not ssCnt.has_key(can): # 如果没有,该集合就把该集合增加到字典中ssCnt[can]=1 # 这里字典的键就是该项集else: ssCnt[can] += 1 # 如果已经有了键，就计数加1numItems = float(len(D)) # 变为浮点数retList = [] # 该列表包含满足最小支持度要求的集合supportData = {}for key in ssCnt: # 遍历字典的每个元素support = ssCnt[key]/numItems # 计算支持度(分母是所有的交易记录)if support >= minSupport: # 如果满足最小支持度retList.insert(0,key) # 则将字典元素添加到retlist列表           supportData[key] = support  # 返回所有项集的支持度return retList, supportData # 返回频繁项集的支持度# 创建候选项集CK
def aprioriGen(Lk, k): # 参数分别是：频繁项集列表LK，项集元素个数KretList = []lenLk = len(Lk)for i in range(lenLk): # 遍历LK中的每一个元素for j in range(i+1, lenLk): # 和后面的元素逐一比较L1 = list(Lk[i])[:k-2]; L2 = list(Lk[j])[:k-2] # 取列表的两个集合进行比较L1.sort(); L2.sort() if L1==L2: # 如果两个集合的前k-2个元素相同，那么就合并此两个集合为大小k的集合                retList.append(Lk[i] | Lk[j]) # 这里用python中集合的并操作“|”return retListdef apriori(dataSet, minSupport = 0.5):C1 = createC1(dataSet)  # C1是候选项集列表D = map(set, dataSet)   L1, supportData = scanD(D, C1, minSupport) # L1是得到的是满足最小支持度的项集构成的集合L = [L1] # L1放入列表中k = 2while (len(L[k-2]) > 0): # 直到下一个大的项集为空Ck = aprioriGen(L[k-2], k)  # ck是非重复的项集，即候选项集列表       Lk, supK = scanD(D, Ck, minSupport) # 得到Lk，即得到满足最小支持度的项集        supportData.update(supK) # 这里是更新supportData字典，即加入supk，得到总的支持度字典       L.append(Lk) # 得到总的满足支持度要求的项集集合       k += 1return L, supportData# 主函数dataSet=loadDataSet()
L,suppData=apriori(dataSet,minSupport = 0.5)
print 'L:',L
print 'suppData:',suppData
rules=generateRules(L, suppData, minConf=0.7)
print 'rules:',rules

运行结果：

L: [[frozenset([1]), frozenset([3]), frozenset([2]), frozenset([5])], [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])], [frozenset([2, 3, 5])], []]
suppData: {frozenset([5]): 0.75, frozenset([3]): 0.75, frozenset([2, 3, 5]): 0.5, frozenset([3, 5]): 0.5, frozenset([2, 3]): 0.5, frozenset([2, 5]): 0.75, frozenset([1]): 0.5, frozenset([1, 3]): 0.5, frozenset([2]): 0.75}
L[i]: [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])]
freqSet: frozenset([1, 3])
H1: [frozenset([1]), frozenset([3])]
i=1.....
P -->H: frozenset([3]) --> frozenset([1])
conf: 0.666666666667
P -->H: frozenset([1]) --> frozenset([3])
conf: 1.0
frozenset([1]) --> frozenset([3]) conf: 1.0
bigRuleList: [(frozenset([1]), frozenset([3]), 1.0)]
L[i]: [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])]
freqSet: frozenset([2, 5])
H1: [frozenset([2]), frozenset([5])]
i=1.....
P -->H: frozenset([5]) --> frozenset([2])
conf: 1.0
frozenset([5]) --> frozenset([2]) conf: 1.0
P -->H: frozenset([2]) --> frozenset([5])
conf: 1.0
frozenset([2]) --> frozenset([5]) conf: 1.0
bigRuleList: [(frozenset([1]), frozenset([3]), 1.0), (frozenset([5]), frozenset([2]), 1.0), (frozenset([2]), frozenset([5]), 1.0)]
L[i]: [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])]
freqSet: frozenset([2, 3])
H1: [frozenset([2]), frozenset([3])]
i=1.....
P -->H: frozenset([3]) --> frozenset([2])
conf: 0.666666666667
P -->H: frozenset([2]) --> frozenset([3])
conf: 0.666666666667
bigRuleList: [(frozenset([1]), frozenset([3]), 1.0), (frozenset([5]), frozenset([2]), 1.0), (frozenset([2]), frozenset([5]), 1.0)]
L[i]: [frozenset([1, 3]), frozenset([2, 5]), frozenset([2, 3]), frozenset([3, 5])]
freqSet: frozenset([3, 5])
H1: [frozenset([3]), frozenset([5])]
i=1.....
P -->H: frozenset([5]) --> frozenset([3])
conf: 0.666666666667
P -->H: frozenset([3]) --> frozenset([5])
conf: 0.666666666667
bigRuleList: [(frozenset([1]), frozenset([3]), 1.0), (frozenset([5]), frozenset([2]), 1.0), (frozenset([2]), frozenset([5]), 1.0)]
L[i]: [frozenset([2, 3, 5])]
freqSet: frozenset([2, 3, 5])
H1: [frozenset([2]), frozenset([3]), frozenset([5])]
i=2...
m: 1
Hmp1: [frozenset([2, 3]), frozenset([2, 5]), frozenset([3, 5])]
P -->H: frozenset([5]) --> frozenset([2, 3])
conf: 0.666666666667
P -->H: frozenset([3]) --> frozenset([2, 5])
conf: 0.666666666667
P -->H: frozenset([2]) --> frozenset([3, 5])
conf: 0.666666666667
Hmp1_2: []
bigRuleList: [(frozenset([1]), frozenset([3]), 1.0), (frozenset([5]), frozenset([2]), 1.0), (frozenset([2]), frozenset([5]), 1.0)]
rules: [(frozenset([1]), frozenset([3]), 1.0), (frozenset([5]), frozenset([2]), 1.0), (frozenset([2]), frozenset([5]), 1.0)]

结果中给出三条规则：1—>3、5—>2及2—>5{1}—>{3}、{5}—>{2}及{2}—>{5}可以看到，后两条包含2和5的规则可以互换前件和后件，但是前一条包含1和3的规则不行。

3. 笔记：

（1）Python List insert()方法：

list.insert(index, obj)：
insert() 函数用于将指定对象插入列表的指定位置。该方法没有返回值，但会在列表指定位置插入对象。
index – 对象 obj 需要插入的索引位置。
obj – 要插入列表中的对象。

示例：

>>> aList = [123, 'xyz', 'zara', 'abc']
>>> aList.insert( 3, 2009)
>>> aList
[123, 'xyz', 'zara', 2009, 'abc']
>>>

（2） if can.issubset(tid):

In [54]: frozenset([1]).issubset(set([1, 3, 4]))
Out[54]: True

（3）

if not [item] in C1: C1.append([item])

得到：

[[1]]   # 每次的运行效果
[[1], [3]]
[[1], [3], [4]]
[[1], [3], [4], [2]]
[[1], [3], [4], [2], [5]]In [21]: C1 # 最后的c1
Out[21]:
[frozenset({1}),frozenset({2}),frozenset({3}),frozenset({4}),frozenset({5})]

（4）L1 = list(Lk[i])[:k-2]

In [38]: L1
Out[38]: [frozenset({1}), frozenset({3}), frozenset({2}), frozenset({5})]In [39]: L=[L1]In [40]: L
Out[40]: [[frozenset({1}), frozenset({3}), frozenset({2}), frozenset({5})]]In [41]: L[0]
Out[41]: [frozenset({1}), frozenset({3}), frozenset({2}), frozenset({5})]In [42]: LK=L[0]In [43]: LK
Out[43]: [frozenset({1}), frozenset({3}), frozenset({2}), frozenset({5})]In [44]: list(LK[0])
Out[44]: [1]In [45]: list(LK[0])[:0]
Out[45]: []

（5）list(Lk[i])[:k-2]

In [47]: bb=[1,2,3]In [48]: bb[:]
Out[48]: [1, 2, 3]In [49]: bb[:1]
Out[49]: [1]In [50]: bb[0]
Out[50]: 1In [51]: bb[0:2]
Out[51]: [1, 2]In [52]: bb[0:3]
Out[52]: [1, 2, 3]In [53]: bb[:2]
Out[53]: [1, 2]

（6）H1 = [frozenset([item]) for item in freqSet]

In [66]: L[1]
Out[66]: [frozenset({1, 3}), frozenset({2, 5}), frozenset({2, 3}), frozenset({3, 5})]In [67]: [frozenset([item]) for item in frozenset({1, 3})] # 列表推到
Out[67]: [frozenset({1}), frozenset({3})]In [68]: [[item] for item in frozenset({1, 3})]
Out[68]: [[1], [3]]In [69]: [item for item in frozenset({1, 3})]
Out[69]: [1, 3]In [71]: supportData_2={frozenset([5]): 0.75, frozenset([3]): 0.75, frozenset([2, 3, 5]): 0.5, frozenset([3, 5]): 0.5, frozenset([2, 3]): 0.5, frozenset([2, 5]): 0.75, frozenset([1]): 0.5, frozenset([1, 3]): 0.5, frozenset([2]): 0.75}In [72]: supportData_2[frozenset({1, 3})]
Out[72]: 0.5In [74]: supportData_2[frozenset({1, 3})-frozenset({1})]
Out[74]: 0.75In [75]: frozenset({1, 3})-frozenset({1})   # 集合相减
Out[75]: frozenset({3})