代码中Ci表示候选频繁i项集，Li表示符合条件的频繁i项集

　　

　　# coding=utf-8

　　

　　def createC1(dataSet): # 构建所有1项候选项集的集合

　　

　　C1 = []

　　

　　for transaction in dataSet:

　　

　　for item in transaction:

　　

　　if [item] not in C1:

　　

　　C1.append([item]) # C1添加的是列表，对于每一项进行添加，[[1], [2], [3], [4], [5]]

　　

　　#print('C1:',C1)

　　

　　return list(map(frozenset, C1)) # 使用frozenset，被“冰冻”的集合，为后续建立字典key-value使用。

　　

　　###由候选项集生成符合最小支持度的项集L。参数分别为数据集、候选项集列表，最小支持度

　　

　　###如

　　

　　###C3: [frozenset({1, 2, 3}), frozenset({1, 3, 5}), frozenset({2, 3, 5})]

　　

　　###L3: [frozenset({2, 3, 5})]

　　

　　def scanD(D, Ck, minSupport):

　　

　　ssCnt = {}

　　

　　for tid in D: # 对于数据集里的每一条记录

　　

　　for can in Ck: # 每个候选项集can

　　

　　if can.issubset(tid): # 若是候选集can是作为记录的子集，那么其值+1,对其计数

　　

　　if not ssCnt.__contains__(can): # ssCnt[can] = ssCnt.get(can,0)+1一句可破，没有的时候为0,加上1,有的时候用get取出，加1

　　

　　ssCnt[can] = 1

　　

　　else:

　　

　　ssCnt[can] += 1

　　

　　numItems = float(len(D))

　　

　　retList = []

　　

　　supportData = {}

　　

　　for key in ssCnt:

　　

　　support = ssCnt[key] / numItems # 除以总的记录条数，即为其支持度

　　

　　if support >= minSupport:

　　

　　retList.insert(0, key) # 超过最小支持度的项集，将其记录下来。

　　

　　supportData[key] = support

　　

　　return retList, supportData

　　

　　###由Lk生成K项候选集Ck

　　

　　###如由L2: [frozenset({3, 5}), frozenset({2, 5}), frozenset({2, 3}), frozenset({1, 3})]

　　

　　###生成

　　

　　###C3: [frozenset({1, 2, 3}), frozenset({1, 3, 5}), frozenset({2, 3, 5})]

　　

　　def aprioriGen(Lk, k):

　　

　　retList = []

　　

　　lenLk = len(Lk)

　　

　　for i in range(lenLk):

　　

　　for j in range(i + 1,lenLk):

　　

　　if len(Lk[i] | Lk[j])==k:

　　

　　retList.append(Lk[i] | Lk[j])

　　

　　return list(set(retList))

　　

　　####生成所有频繁子集

　　

　　def apriori(dataSet, minSupport=0.5):

　　

　　C1 = createC1(dataSet)

　　

　　D = list(map(set, dataSet))

　　

　　L1, supportData = scanD(D, C1, minSupport)

　　

　　L = [L1] # L将包含满足最小支持度，即经过筛选的所有频繁n项集，这里添加频繁1项集

　　

　　k = 2

　　

　　while (len(L[k - 2]) > 0): # k=2开始，由频繁1项集生成频繁2项集，直到下一个打的项集为空

　　

　　Ck = aprioriGen(L[k - 2], k)

　　

　　Lk, supK = scanD(D, Ck, minSupport)

　　

　　supportData.update(supK) # supportData为字典，存放每个项集的支持度，并以更新的方式加入新的supK

　　

　　L.append(Lk)

　　

　　k += 1

　　

　　return L, supportData

　　

　　if __name__ == "__main__":

　　

　　dataSet = [[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]]

　　

　　D = list(map(set, dataSet))

　　

　　L,suppData = apriori(dataSet)

　　

　　print('L:',L)

　　

　　print('suppData:',suppData)

　　

　　'''

　　

　　C1 = createC1(dataSet)

　　

　　L1, supportData1 = scanD(D, C1, 0.5)

　　

　　print('C1:',C1)

　　

　　print('L1:',L1)

　　

　　print('supportData1:',supportData1)

　　

　　C2 = aprioriGen(L1, 2)

　　

　　L2, supportData2 = scanD(D, C2, 0.5)

　　

　　print('C2:',C2)

　　

　　print('L2:',L2)

　　

　　print('supportData2:www.gcyl152.com/',supportData2)

　　

　　C3 = aprioriGen(L2, 3)

　　

　　L3, supportData3 www.michenggw.com= scanD(D, C3, 0.5)

　　

　　print('C3:',C3)

　　

　　print('L3:',L3)

　　

　　print('supportData3:',supportData3)

　　

　　'''

　　

　　最终得到的所有支持度大于0.5的频繁子集及其支持度如下：

　　

　　        frozenset({1})www.mcyllpt.com/ : 0.5, 

　　

　　        frozenset({3}): 0.75, 

　　

　　        frozenset({4}): 0.25, 

　　

　　        frozenset({2}): 0.75, 

　　

　　        frozenset({5}): 0.75, 

　　

　　        frozenset({1, 3}): 0.5, 

　　

　　        frozenset({2, 3}): 0.5, 

　　

　　        frozenset({2, 5}): 0.75, 

　　

　　        frozenset({3, 5}): 0.5, 

　　

　　        frozenset({1, 2}): 0.25, 

　　

　　        frozenset({1, 5}): 0.25, 

　　

　　        frozenset({2, 3, 5}): 0.5, 

　　

　　        frozenset({1, 2, 3}): 0.25, 

　　

　　        frozenset({1, 3, 5}): 0.25