程式碼部分：

# !/usr/bin/env python
# -*- coding: utf-8 -*-

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


def createC1(dataSet):
    """
    構建大小為1的所有候選項集的集合
    :param dataSet:
    :return:
    """
    C1 = []
    for transaction in dataSet:
        for item in transaction:
            if not [item] in C1:
                C1.append([item])
    C1.sort()
    return list(map(frozenset, C1))


def scanD(D, Ck, minSupport):
    """
    Ck中的元素經過最小支援度過濾得到Lk，和每個元素的支援度
    :param D: 資料集
    :param Ck:
    :param minSupport: 最小支援度（過濾）
    :return:
    過程：
    對資料集中的每條交易記錄tran
    對每個候選項集can：
        檢查一下can是否是tran的子集：
            如果是：則增加can的計數值
            如果不是：把can的值設為1
    對每個候選項集：
        如果其支援度不低於最小值，則保留該項集
    返回所有頻繁項集列表
    """
    ssCnt = {}
    for tid in D:
        for can in Ck:
            if can.issubset(tid):
                if can not in ssCnt:
                    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


def aprioriGen(Lk, k):
    """
    合併頻繁項集為k個元素
    :param Lk: 頻繁項集列表
    :param k: 項集元素個數
    :return:
    """
    retList = []
    lenLk = len(Lk)
    for i in range(lenLk):
        for j in range(i+1, lenLk):
            # 每一個項集同其後面的項集做比較
            # 如果前k-2個元素相同（取不到k-2），則合併為k個元素的項集，新增到retList中
            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 Apriori(dataSet, minSupport=0.5):
    """

    :param dataSet: 資料集
    :param minSupport: 最小支援度
    :return:
    過程：
    C1->L1->C2->L2->C3->L3-> ... ->Ck->Lk
    """
    # 單個物品項組成的集合
    C1 = createC1(dataSet)
    # 集合表示的資料集D
    D = list(map(set, dataSet))
    #
    L1, supportData = scanD(D, C1, minSupport)
    L = [L1]
    k = 2
    while len(L[k - 2]) > 0:
        Ck = aprioriGen(L[k - 2], k)
        Lk, supK = scanD(D, Ck, minSupport)
        supportData.update(supK)
        L.append(Lk)
        k += 1
    return L, supportData


def calcConf(freqSet, H, supportData, bigRuleList, minConf=0.7):
    """
    從頻繁項集freqSet，計算關聯規則(freqSet - H) --> H的置信度
    並過濾置信度低於最小置信度閾值的規則
    :param freqSet: 頻繁項集
    :param H: 出現在規則右部
    :param supportData: 支援度字典
    :param bigRuleList: 關聯規則列表
    :param minConf: 最小置信度閾值
    :return: 滿足最小可信度要求的規則列表
    """
    # 初始化滿足最小可信度要求的規則列表
    prunedH = []
    for conseq in H:
        conf = supportData[freqSet] / supportData[freqSet - conseq]
        if conf >= minConf:
            print(freqSet-conseq, "-->", conseq, "conf : ", conf)
            bigRuleList.append((freqSet - conseq, conseq, conf))
            # 與bigRuleList對應的置信度值列表
            prunedH.append(conseq)
    return prunedH


def rulesFromConseq(freqSet, H, supportData, bigRuleList, minConf=0.7):
    """
    由於freqSet中的元素個數大於等於3，計算規則的右部為多個元素的情形
    :param freqSet: 頻繁項集
    :param H: 出現在規則右部的元素列表
    :param supportData: 支援度列表
    :param bigRuleList: 關聯規則列表
    :param minConf: 最小置信度閾值
    :return:
    """
    m = len(H[0])
    # m + 1，其實示一個遞迴變數，遞迴地增加右部元素個數
    if len(freqSet) > (m + 1):
        # 合併元素，任意組合成m+1個元素的項集
        Hmp1 = aprioriGen(H, m + 1)
        # 過濾關聯規則(freqSet - Hmp1) --> Hmp1的置信度小於最小置信度閾值的規則
        # 規則右部有m + 1個元素
        Hmp1 = calcConf(freqSet, Hmp1, supportData, bigRuleList, minConf)
        # 遞迴累加右部元素個數
        if len(Hmp1) > 1:
            rulesFromConseq(freqSet, Hmp1, supportData, bigRuleList, minConf)
    else:
        # 當右部元素個數和頻繁項集freqSet的長度一樣時，不再劃分，返回
        return


def generateRules(L, supportData, minConf=0.7):
    """
    基於給定的頻繁項集L和支援度supportData，計算滿足最小支援度閾值的規則
    :param L: 頻繁項集列表
    :param supportData: 包含那些頻繁項集支援資料的字典
    :param minConf: 最小置信度閾值
    :return: 包含可信度的規則列表
    """
    # 初始化規則存放列表
    bigRuleList = []
    # 遍歷頻繁項集
    for i in range(1, len(L)):
        #
        for freqSet in L[i]:
            # 只包含單個元素集合的列表H1
            H1 = [frozenset([item]) for item in freqSet]
            # 過濾關聯規則(freqSet - H1) --> H1的置信度小於最小置信度閾值的規則
            # H1是右部為單個元素的情形
            H1 = calcConf(freqSet, H1, supportData, bigRuleList, minConf)
            if i > 1:
                # 如果頻繁項集中元素個數大於等於3，就需要考慮右部為多個元素的情形
                rulesFromConseq(freqSet, H1, supportData, bigRuleList, minConf)
    return bigRuleList


dataSet = loadData()
L, supportData = Apriori(dataSet)
rules = generateRules(L, supportData, minConf=0.7)
print(rules)