REST调用异常

Question

我目前正在使用Flask Framework进行REST调用。我一路上遇到了一些错误，我无法弄清楚它们为什么会发生（尽管如此）。如下所示的错误：

[2016-09-20 18:53:26,486] ERROR in app: Exception on /Recommend [GET] 
Traceback (most recent call last): 
    File "/anaconda/lib/python2.7/site-packages/flask/app.py", line 1988, in wsgi_app 
    response = self.full_dispatch_request() 
    File "/anaconda/lib/python2.7/site-packages/flask/app.py", line 1641, in full_dispatch_request 
    rv = self.handle_user_exception(e) 
    File "/anaconda/lib/python2.7/site-packages/flask_cors/extension.py", line 161, in wrapped_function 
    return cors_after_request(app.make_response(f(*args, **kwargs))) 
    File "/anaconda/lib/python2.7/site-packages/flask_api/app.py", line 97, in handle_user_exception 
    for typecheck, handler in chain(blueprint_handlers.items(), app_handlers.items()): 
AttributeError: 'tuple' object has no attribute 'items' 
127.0.0.1 - - [20/Sep/2016 18:53:26] "GET /Recommend HTTP/1.1" 500 - 

这里是我已经建立了代码：

from flask import request, jsonify 
from flask_api import FlaskAPI 
from flask_cors import CORS 

from sets import Set 
from collections import defaultdict 
import itertools 
import copy 

app = FlaskAPI(__name__) 
CORS(app) 

content = None 

class Apriori:  
    def __init__(self): 
     self.no_of_transactions = None 
     self.min_support = 0.5 
     self.min_confidence = 0.75 
     self.transactions = {} 
     self.set_of_items = set() 
     self.frequencies = {} 
     self.frequent_itemsets_of_order_n = {} 
     self.association_rules = {} 

    def createPowerSet(self,s): 
     powerset = set() 
     for i in xrange(2**len(s)): 
      subset = tuple([x for j,x in enumerate(s) if (i >> j) & 1]) 
      if len(subset) == 0: 
       pass 
      elif len(subset) == 1: 
       powerset.add(subset[0]) 
      else: 
       powerset.add(subset) 
     return powerset 

    def createFrequentItemSets(self,set_of_items,len): 
     frequent_itemsets = set(itertools.combinations(set_of_items, len)) 
     for i in list(frequent_itemsets): 
      tempset = set(i) 
      self.frequencies[i] = 0 
      for k, v in self.transactions.iteritems(): 
       if tempset.issubset(set(v)): 
        self.frequencies[i] += 1 
      if float(self.frequencies[i])/self.no_of_transactions < self.min_support: 
       frequent_itemsets.discard(i) 
     return frequent_itemsets 

    def mineAssociationRules(self,frequent_itemset): 
     s = set(frequent_itemset) 
     subs = list(self.createPowerSet(s)) 
     for each in subs: 
      if sorted(tuple(set(each))) == sorted(tuple(s)): 
       continue    
      if len(set(each))==1: 
       antecedent = list(set(each))[0] 
      elif len(set(each))>1: 
       antecedent = tuple(set(each)) 

      if len(s.difference(set(each)))==1: 
       consequent = list(s.difference(set(each)))[0] 
      elif len(s.difference(set(each)))>1: 
       consequent = tuple(s.difference(set(each)))    
      AuC = tuple(s)   
      if float(self.frequencies[AuC])/self.frequencies[antecedent] >= self.min_confidence: 
       if antecedent in self.association_rules: 
        pass 
       else: 
        if type(antecedent) is tuple: 
         antecedent = (",").join(antecedent) 
        if type(consequent) is tuple: 
         consequent = (",").join(consequent) 
        self.association_rules[antecedent] = consequent 

    def implement(self,transactions): 
     #for i in range(0,self.no_of_transactions): 
     for i in range(0,len(transactions)): 
      self.transactions["T"+str(i)] = defaultdict(list) 
      self.transactions["T"+str(i)] = transactions[i].split(',') 
      self.set_of_items = self.set_of_items.union(Set(self.transactions["T"+str(i)]))   
     for i in list(self.set_of_items): 
      self.frequencies[i] = 0 
      for k, v in self.transactions.iteritems(): 
       if i in v: 
        self.frequencies[i] = self.frequencies[i] + 1 
      if float(self.frequencies[i])/self.no_of_transactions < self.min_support: 
       self.set_of_items.discard(i)     
     self.frequent_itemsets_of_order_n[1] = self.set_of_items 
     l = 1   
     reps = copy.deepcopy(self.set_of_items) 
     while True: 
      l += 1 
      result = self.createFrequentItemSets(self.set_of_items, l) 
      if len(result) == 0: 
       break 
      self.frequent_itemsets_of_order_n[l] = result 
      reps = copy.deepcopy(self.frequent_itemsets_of_order_n[l])   
     l = l-1   
     while l>2: 
      for each in self.frequent_itemsets_of_order_n[l]: 
       self.mineAssociationRules(each) 
      l = l-1 

@app.route('/Recommend') 
def FindAssociations(): 
    transactions = ["A,C,D,F,G","A,B,C,D,F","C,D,E","A,D,F","A,C,D,E,F","B,C,D,E,F,G"] 
    apr = Apriori() 
    apr.implement(transactions) 
    return jsonify(rules=apr.association_rules) 

if __name__ == "__main__": 
    app.run(port=5000) 

我没有运行在网络上发现了一些示例代码，并建立了基于这些脚本以上脚本。他们工作得很好。我建立的这个类是基于我之前建立的另一个python程序，它运行良好。我应该从另一个脚本导入类而不是在这里创建它？

Answer 1

您的Apriori有一些错误需要修正。有几次尝试除以self.no_of_transactions（例如，第87行），其初始化为None并且从未改变。通过None除以引发一个例外：

>>> 1/None 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
TypeError: unsupported operand type(s) for /: 'int' and 'NoneType' 

此异常然后在烧瓶API的handle_user_exception()方法，该方法也似乎有一个错误，如图它引发异常处理。

解决此问题的方法是更正您的代码，使其不会被None除。