Apriori算法的python实现

def loadDataSet():
    return [[1,3,4],[2,3,5],[1,2,3,5],[2,5]]

def creatC1(dataSet):
    C1=[]
    C=[]
    for transaction in dataSet:
        C=C+transaction
    C=list(set(C))
    for i in C:
        C1.append([i])
    C1.sort()
    return map(frozenset,C1)

def scanD(D,Ck,minSupport):
    ssCnt={}
    for tid in D:
        for can in Ck:
            if can.issubset(tid):
                ssCnt[can]=ssCnt.get(can,0)+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

def apprioriGen(Lk,k):
    retList=[]
    lenLk=len(Lk)
    for i in range(lenLk):
        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:
                retList.append(Lk[i]|Lk[j])
    return retList

def appriori(dataSet,minSupport=0.5):
    C1=creatC1(dataSet)
    D=map(set,dataSet)
    L1,supportData=scanD(D, C1, minSupport)
    L=[L1]
    k=2
    while len(L[k-2])>1:
        Ck=apprioriGen(L[k-2], k)
        Lk,supportk=scanD(D, Ck, minSupport)
        L.append(Lk)
        supportData.update(supportk)
        k+=1
    return L,supportData

def generateRule(item,supportData,minConf=0.7):   #针对一个频繁项集 产生规则
    l=[]
    rule=[]
    k=2
    for i in list(item):
        l.append([i])
    List=map(frozenset,l)
    for doc in List:
        if (supportData[item]/supportData[item-doc])>=minConf:
            print item-doc,'--->',doc,'Conf',(supportData[item]/supportData[item-doc])
            rule.append(doc)
    while len(rule)>0:
        rule=apprioriGen(rule, k)
        if len(rule)==0 or rule[0]==item:break
        else:
            for j in rule:
                if (supportData[item]/supportData[item-j])>=minConf:
                    print item-j,'--->',j,'Conf',(supportData[item]/supportData[item-j])
        k+=1
                
def generateRules(dataSet,supportData,L,minConf=0.7):  #遍历所有的频繁项集 产生所有的规则
    for l in L[1:]:
        for item in l:
            generateRule(item, supportData, minConf)
            

    
dataSet=loadDataSet()
L,supportData=appriori(dataSet)
print supportData
print L
generateRules(dataSet, supportData, L, 0.6)