不使用apriori库的可以从外界读入数据集并且可以输出结果的关联规则apriori算法代码

以下是一个简单的 Python 实现 Apriori 算法的代码，它可以从外部文件中读取数据集，并输出关联规则结果。这个实现没有使用 apriori 库。

# 定义 Apriori 算法
def apriori(data, min_sup, min_conf):
    # 构建候选项集 C1
    C1 = {}
    for transaction in data:
        for item in transaction:
            if item not in C1:
                C1[item] = 1
            else:
                C1[item] += 1
    
    # 筛选出符合最小支持度的频繁项集 L1
    L1 = {}
    for item in C1:
        if C1[item] >= min_sup:
            L1[item] = C1[item]
 
    # 定义一个函数用于合并频繁项集
    def merge_itemset(itemset, k):
        merged_itemset = []
        for i in range(len(itemset)):
            for j in range(i+1, len(itemset)):
                l1 = list(itemset[i])[:k-2]
                l2 = list(itemset[j])[:k-2]
                l1.sort()
                l2.sort()
                if l1 == l2:
                    merged_itemset.append(itemset[i] | itemset[j])
        return merged_itemset
    
    # 定义一个函数用于筛选符合最小支持度的频繁项集
    def filter_itemset(itemset, min_sup):
        item_count = {}
        for transaction in data:
            for item in itemset:
                if item.issubset(transaction):
                    if item not in item_count:
                        item_count[item] = 1
                    else:
                        item_count[item] += 1
        
        itemset_ = set()
        for item in item_count:
            support = item_count[item] / len(data)
            if support >= min_sup:
                itemset_.add(item)
        
        return itemset_
    
    # 生成所有频繁项集
    itemset = [set([item]) for item in L1]
    k = 2
    freq_itemset = {}
    while len(itemset) > 0:
        freq_itemset[k-1] = itemset
        itemset = merge_itemset(itemset, k)
        itemset = filter_itemset(itemset, min_sup)
        k += 1
    
    # 生成关联规则
    rules = []
    for k, itemset in freq_itemset.items():
        if k < 2:
            continue
        for item in itemset:
            for i in range(1, len(item)):
                X = frozenset(item[:i])
                Y = frozenset(item[i:])
                # 计算置信度
                confidence = freq_itemset[k][item] / freq_itemset[k-1][X]
                # 筛选出符合最小置信度的关联规则
                if confidence >= min_conf:
                    rules.append((X, Y, confidence))
    
    return rules

# 从文件中读取数据集
def load_data(filename):
    data = []
    with open(filename, 'r') as f:
        for line in f:
            transaction = line.strip().split(',')
            data.append(transaction)
    return data

# 测试代码
if __name__ == '__main__':
    data = load_data('data.txt')
    min_sup = 0.2
    min_conf = 0.7
    rules = apriori(data, min_sup, min_conf)
    for rule in rules:
        print('{} => {} : {}'.format(rule[0], rule[1], rule[2]))

其中 `data.txt` 是数据集文件，每行表示一个交易（一个列表），列表中的元素表示交易中的一个项。`min_sup` 和 `min_conf` 分别是最小支持度和最小置信度的阈值。在测试代码中，我们调用 `apriori` 函数并输出结果。结果是一系列关联规则，每条关联规则包含三个部分：前项、后项和置信度。