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

来源：互联网发布：局部搜索算法历史编辑：程序博客网时间：2024/06/05 21:50

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

1.1 关联分析

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

这里写图片描述

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

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

1.2 Apriori原理

这里写图片描述

对于上图的集合数目，会发现即使对于仅有4种物品的集合，也需要遍历数据15次。而随着物品数目的增加遍历次数会急剧增长。对于包含—物品的数据集共有2N−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生成Lkdef 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 # 如果已经有了键，就计数加1    numItems = float(len(D)) # 变为浮点数    retList = [] # 该列表包含满足最小支持度要求的集合    supportData = {}    for key in ssCnt: # 遍历字典的每个元素        support = ssCnt[key]/numItems # 计算支持度(分母是所有的交易记录)        if support >= minSupport: # 如果满足最小支持度            retList.insert(0,key) # 则将字典元素添加到retlist列表            print 'retList:',retList            supportData[key] = support  # 返回所有项集的支持度    return retList, supportData # 返回频繁项集的支持度# 创建候选项集CKdef aprioriGen(Lk, k): # 参数分别是：频繁项集列表LK，项集元素个数K    print 'LK_1:',Lk    retList = []    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,L2            if 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:',C1    D = map(set, dataSet)    print 'D:',D    L1, supportData = scanD(D, C1, minSupport) # L1是得到的是满足最小支持度的项集构成的集合    print 'L1:',L1    print 'supportData:',supportData    L = [L1] # L1放入列表中    print 'L:',L    k = 2    while (len(L[k-2]) > 0): # 直到下一个大的项集为空        Ck = aprioriGen(L[k-2], k)  # ck是非重复的项集，即候选项集列表        print 'CK:',Ck        Lk, supK = scanD(D, Ck, minSupport) # 得到Lk，即得到满足最小支持度的项集        print 'Lk_2:',Lk        print 'supK:',supK        supportData.update(supK) # 这里是更新supportData字典，即加入supk，得到总的支持度字典        print 'supportData_2:',supportData        L.append(Lk) # 得到总的满足支持度要求的项集集合        print 'L_2:',L        k += 1    return 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—>H的可信度定义为Support(P|H)/support(P)中，操作符丨表示集合的并操作，而数学上集合并的符号是⋃。P|H是指所有出现在集合P或者集合H中的元素。前面一节已经计算了所有频繁项集支持度。现在想获得可信度，所需要做的只是取出那些支持度值做一次除法运算。

这里写图片描述

类似于上面的频繁项集生成，我们可以为每个频繁项集产生许多关联规则。如果能够减少规则数目来确保问题的可解性，那么计算起来就会好很多。可以观察到，如果某条规则并不满足最小可信度要求，那么该规则的所有子集也不会满足最小可信度要求。上图中，假设规则0,1,2—>3并不满足最小可信度要求，那么就知道任何左部为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,'-->',conseq        conf = supportData[freqSet]/supportData[freqSet-conseq] # 得到可信度        print 'conf:',conf        if 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:',m    if (len(freqSet) > (m + 1)): # 尝试进一步合并        Hmp1 = aprioriGen(H, m+1) # 创建Hm+1条新候选规则，生成H中元素的无重复组合        print 'Hmp1:',Hmp1        Hmp1 = 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]:   # 为每个频繁项集创建只包含单个元素集合的列表H1            print 'L[i]:',L[i]            print 'freqSet:',freqSet            H1 = [frozenset([item]) for item in freqSet] # 列表推导式            print 'H1:',H1            if (i > 1):                print 'i=%d...' % i                rulesFromConseq(freqSet, H1, supportData, bigRuleList, minConf)            else: # i=1表示频繁项集的元素数目为2                print '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生成Lkdef 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 # 如果已经有了键，就计数加1    numItems = 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 # 返回频繁项集的支持度# 创建候选项集CKdef aprioriGen(Lk, k): # 参数分别是：频繁项集列表LK，项集元素个数K    retList = []    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 = 2    while (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 += 1    return L, supportData# 主函数dataSet=loadDataSet()L,suppData=apriori(dataSet,minSupport = 0.5)print 'L:',Lprint '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.666666666667P -->H: frozenset([1]) --> frozenset([3])conf: 1.0frozenset([1]) --> frozenset([3]) conf: 1.0bigRuleList: [(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.0frozenset([5]) --> frozenset([2]) conf: 1.0P -->H: frozenset([2]) --> frozenset([5])conf: 1.0frozenset([2]) --> frozenset([5]) conf: 1.0bigRuleList: [(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.666666666667P -->H: frozenset([2]) --> frozenset([3])conf: 0.666666666667bigRuleList: [(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.666666666667P -->H: frozenset([3]) --> frozenset([5])conf: 0.666666666667bigRuleList: [(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: 1Hmp1: [frozenset([2, 3]), frozenset([2, 5]), frozenset([3, 5])]P -->H: frozenset([5]) --> frozenset([2, 3])conf: 0.666666666667P -->H: frozenset([3]) --> frozenset([2, 5])conf: 0.666666666667P -->H: frozenset([2]) --> frozenset([3, 5])conf: 0.666666666667Hmp1_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可以看到，后两条包含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 # 最后的c1Out[21]: [frozenset({1}), frozenset({2}), frozenset({3}), frozenset({4}), frozenset({5})]

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

In [38]: L1Out[38]: [frozenset({1}), frozenset({3}), frozenset({2}), frozenset({5})]In [39]: L=[L1]In [40]: LOut[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]: LKOut[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})

阅读全文

2 0