导入Excel数据，并进行关联规则分析

对其Excel数据进行关联规则分析之前需要对数据进行预处理：将表头去掉，并保存你所需要的数据，导入你所需要分析的Excel地址和‘Sheet1’，所得出的数据，即是你所需要的结果。

import xlrd
import numpy as np

doc = open（‘result.txt‘ ‘w‘）
# 打开Excel表格
wk = xlrd.open_workbook（‘C:\\Users\\Admin\\Desktop\\sales_fact_1997（样本）.xlsx‘）
worksheet = wk.sheet_names（）
sf = wk.sheet_by_name（u‘Sheet1‘）

# 导入数据 建立事务型列表 例如【【1，2】【1，2，2】【4，1，4】【1，2，5】】
num_rows = sf.nrows
A = []
finalList = []
A.append（sf.cell_value（0 0））
for i in range（1 num_rows）:
    if sf.cell_value（i 1） == sf.cell_value（i - 1 1）:
        A.append（sf.cell_value（i 0 ））
    else:
        finalList.append（A）
        A = [sf.cell_value（i 0）]
finalList.append（A）


# 运用Aprior算法来进行关联规则分析
def loadDataSet（）:
    return finalList


def createC1（dataSet）:
    C1 = []
    for transaction in dataSet:
        for item in transaction:
            if [item] not in C1:
                C1.append（[item]）
    C1.sort（）
    return [frozenset（var） for var in C1]


def scanD（D Ck minSupport）:
    ssCnt = {}
    for tid in D:  # 对于每一条transaction
        for can in Ck:  # 对于每一个候选项集can，检查是否是transaction的一部分 # 即该候选can是否得到transaction的支持
            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
            retList.insert（0 key）
        supportData[key] = support  # 汇总支持度数据
    return retList supportData


def aprioriGen（Lk k）:  # Aprior 算法
    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 apriori（dataSet minSupport）:
    C1 = createC1（dataSet）  # 构建初始候选项集C1
    D = [set（var） for var in dataSet]
    L1 suppData = scanD（D C1 minSupport）  # 构建初始的频繁项集，即所有项集只有一个元素
    L = [L1]  # 最初的L1中的每个项集含有一个元素，新生成的
    k = 2  # 项集应该含有2个元素，所以 k=2
    while len（L[k - 2]） > 0:
        Ck = aprioriGen（L[k - 2] k）
        Lk supK = scanD（D Ck minSupport）
        suppData.update（supK）  # 将新的项集的支持度数据加入原来的总支持度字典中
        L.append（Lk）  # 将符合最小支持度要求的项集加入L
        k += 1  # 新生成的项集中的元素个数应不断增加
    return L suppData  # 返回所有满足条件的频繁项集的列表，和所有候选项集的支持度信息


def calcConf（freqSet H supportData brl minConf）:  # 规则生成与评价
    prunedH = []
    for conseq in H:
        conf = supportData[freqSet] / supportData[freqSet - conseq]
        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）:
    m = len（H[0]）
    if len（freqSet） > m + 1:  # 查看频繁项集是否足够大，以到于移除大小为 m的子集，否则继续生成m+1大小的频繁项集
        Hmp1 = aprioriGen（H m + 1）
        Hmp1 

 属性            大小     日期    时间   名称
----------- ---------  ---------- -----  ----

     文件      23814  2018-10-26 11:40  sales_fact_1997（样本）.xlsx

     文件       5350  2018-10-26 19:24  hWork.py

     文件      18832  2018-10-26 19:50  关联规则.docx

----------- ---------  ---------- -----  ----

                47996                    3