# coding:utf-8

__author__ = 'similarface'

'''

该数据:

{"用户":{"电影":评分}}

'''

users3 = {u"邓紫棋": {u"倩女幽魂": 4, u"新白娘子传奇": 3, u"白发魔女传": 4},

          u"赵丽颖": {u"倩女幽魂": 5, u"新白娘子传奇": 2},

          u"Angelababy": {u"新白娘子传奇": 3.5, u"白发魔女传": 4},

          u"波多野结衣": {u"倩女幽魂": 5, u"白发魔女传": 3}}

users2 = {"dzq": {"qnyh": 4, "xbnzcq": 3, "bfmnz": 4},

          "zly": {"qnyh": 5, "xbnzcq": 2},

          "Angelababy": {"xbnzcq": 3.5, "bfmnz": 4},

          "bdyjy": {"qnyh": 5, "bfmnz": 3}}

class recommender:

    def __init__(self, data, k=1, n=5):

        self.k = k

        self.n = n

        self.productid2name = {}

        if type(data).__name__ == 'dict':

            self.data = data

        #频率值 同时对A，B都进行评分的用户数目

        self.frequencies={}

        #样本A对样本B的偏差值

        self.deviations={}

    def computerDeviation(self):

        '''

        计算样本间的偏差

        :return:

        '''

        #{"用户":{"电影":评分1,"电影":评分2,"电影n":评分n}} =》 ratings={"电影":评分}

        for ratings in self.data.values():

            #"电影n":评分n

            for (item,rating) in ratings.items():

                #频率值 2样本同时都进行评分的用户数目

                #setdefault 如果键在字典中，返回这个键所对应的值。如果键不在字典中，向字典 中插入这个键，并且以{}为这个键的值，并返回{}

                self.frequencies.setdefault(item, {})

                #偏差值

                self.deviations.setdefault(item, {})

                for (item2,rating2) in ratings.items():

                    if item!=item2:

                        self.frequencies[item].setdefault(item2,0)

                        self.deviations[item].setdefault(item2,0.0)

                        self.frequencies[item][item2]+=1

                        self.deviations[item][item2]+=rating-rating2

        for (item,ratings) in self.deviations.items():

            for item2 in ratings:

                #dev(i,j)

                ratings[item2]/=self.frequencies[item][item2]

    def slopeOneRecommendations(self,userRatings):

        '''

        遍历用户u评论的所有样本：u[i]

            遍历用户u的偏差矩阵: dev[j,i]

                SUM((dev[j,i]+u[i])*c[j,i]) ==?c[j,i]=frequencies[j][i]

        :param userRatings:

        :return:

        '''

        recommendations={}

        frequencies={}

        #遍历用户u k 和 评分

        for (useritem,userRating) in userRatings.items():

            #遍历偏差矩阵

            for (diffItem,diffRatting) in self.deviations.items():

                #如果偏差矩阵的key不在用户的key中 用户的key在偏差[key]中 [新白娘子传奇 不在用户的评分中 and ["倩女幽魂","白发魔女传"] 在diffItem

                if diffItem not in userRatings and useritem in self.deviations[diffItem]:

                    #“新白娘子传奇”和“倩女幽魂”有两个人看，哦，她们是邓紫棋 赵丽颖

                    freq=self.frequencies[diffItem][useritem]

                    #

                    recommendations.setdefault(diffItem,0.0)

                    frequencies.setdefault(diffItem,0)

                    #(dev(j,i)+u(i))*c(j,i)

                    recommendations[diffItem]+=(diffRatting[useritem]+userRating)*freq

                    #求分母的和

                    frequencies[diffItem]+=freq

        recommendations=[(k,v /frequencies[k]) for k ,v in recommendations.items()]

        recommendations.sort(key=lambda artistTuple:artistTuple[1],reverse=True)

        return recommendations

if __name__ == '__main__':

    r=recommender(users2)

    r.computerDeviation()

    g=users2['bdyjy']

    result=r.slopeOneRecommendations(g)

    print(result[0][0]+' 预测评分'+str(result[0][1]))