毕业设计：python新能源汽车推荐系统 协同过滤推荐算法 Echarts可视化 Django框架（源码）✅_汽车推荐系统数据库er图

博主介绍：✌全网粉丝10W+,前互联网大厂软件研发、集结硕博英豪成立工作室。专注于计算机相关专业毕业设计项目实战6年之久，选择我们就是选择放心、选择安心毕业✌感兴趣的可以先收藏起来，点赞、关注不迷路✌

毕业设计：2023-2024年计算机毕业设计1000套（建议收藏）

毕业设计：2023-2024年最新最全计算机专业毕业设计选题汇总

1、项目介绍

技术栈：Python语言 MySQL数据库 Django框架 Echarts可视化 2种协同过滤推荐算法 html

2、项目界面

（1）新能源汽车数据

（2）新能源汽车详情页

（3）新能源汽车词云图分析

（4）2种协同过滤推荐算法推荐

（5）新能源汽车曲线分析

（6）新能源汽车发行年份曲线图

（7）新能源汽车品牌饼状图

（8）新能源汽车分类

（9）个人信息

（10）后台数据管理

3、项目说明

针对新能源汽车推荐系统，你可以使用以下技术栈和算法来实现：

技术栈：

Python3.x：作为主要的开发语言。
MySQL数据库：用于存储新能源汽车的相关数据，包括车型、特性、用户评价等信息。
Django框架：用于构建Web应用程序，处理用户请求和数据展示。
Echarts可视化：用于展示汽车数据、用户评价和推荐结果的可视化图表。
HTML：用于构建前端页面，与Django框架配合实现用户界面。
推荐算法：

基于用户的协同过滤算法：根据用户的历史行为和偏好，向用户推荐与其类似喜好的新能源汽车。
基于物品的协同过滤算法：根据汽车特性和用户评价，向用户推荐与其喜欢的汽车相似的新能源汽车。
实现步骤可以包括：

使用Python进行数据处理和特征提取，将新能源汽车的数据存入MySQL数据库。
使用Django框架搭建Web应用，实现用户注册、登录、浏览汽车信息等功能。
使用Echarts将汽车数据以可视化的方式呈现给用户，包括销量排行、价格分布、用户评价等图表展示。
实现基于用户和基于物品的协同过滤推荐算法，根据用户的偏好和行为向其推荐新能源汽车。
将推荐结果通过HTML页面展示给用户，并提供交互式操作，如查看汽车详情、对比不同车型等功能。
最后，为了提高推荐系统的准确性和个性化程度，你还可以考虑引入机器学习模型，如内容-based推荐、深度学习模型等，以更好地满足用户个性化需求。

4、核心代码

# -*-coding:utf-8-*-
import os
os.environ["DJANGO_SETTINGS_MODULE"] = "recommend.settings"
import django
django.setup()
from item.models import *
from math import sqrt, pow
import operator
from django.db.models import Subquery, Q, Count
# from django.shortcuts import render,render_to_response
class UserCf:

    # 获得初始化数据
    def __init__(self, all_user):
        self.all_user = all_user

    # 通过用户名获得列表，仅调试使用
    def getItems(self, username1, username2):
        return self.all_user[username1], self.all_user[username2]

    # 计算两个用户的皮尔逊相关系数
    def pearson(self, user1, user2):  # 数据格式为：新能源汽车id，浏览此
        sum_xy = 0.0  # user1,user2 每项打分的成绩的累加
        n = 0  # 公共浏览次数
        sum_x = 0.0  # user1 的打分总和
        sum_y = 0.0  # user2 的打分总和
        sumX2 = 0.0  # user1每项打分平方的累加
        sumY2 = 0.0  # user2每项打分平方的累加
        for car1, score1 in user1.items():
            if car1 in user2.keys():  # 计算公共的浏览次数
                n += 1
                sum_xy += score1 * user2[car1]
                sum_x += score1
                sum_y += user2[car1]
                sumX2 += pow(score1, 2)
                sumY2 += pow(user2[car1], 2)
        if n == 0:
            # print("p氏距离为0")
            return 0
        molecule = sum_xy - (sum_x * sum_y) / n  # 分子
        denominator = sqrt((sumX2 - pow(sum_x, 2) / n) * (sumY2 - pow(sum_y, 2) / n))  # 分母
        if denominator == 0:
            return 0
        r = molecule / denominator
        return r

    # 计算与当前用户的距离，获得最临近的用户
    def nearest_user(self, current_user, n=1):
        distances = {}
        # 用户，相似度
        # 遍历整个数据集
        for user, rate_set in self.all_user.items():
            # 非当前的用户
            if user != current_user:
                distance = self.pearson(self.all_user[current_user], self.all_user[user])
                # 计算两个用户的相似度
                distances[user] = distance
        closest_distance = sorted(
            distances.items(), key=operator.itemgetter(1), reverse=True
        )
        # 最相似的N个用户
        print("closest user:", closest_distance[:n])
        return closest_distance[:n]

    # 给用户推荐新能源汽车
    def recommend(self, username, n=3):
        recommend = {}
        nearest_user = self.nearest_user(username, n)
        for user, score in dict(nearest_user).items():  # 最相近的n个用户
            for cars, scores in self.all_user[user].items():  # 推荐的用户的新能源汽车列表
                if cars not in self.all_user[username].keys():  # 当前username没有看过
                    if cars not in recommend.keys():  # 添加到推荐列表中
                        recommend[cars] = scores*score
        # 对推荐的结果按照新能源汽车
        # 浏览次数排序
        return sorted(recommend.items(), key=operator.itemgetter(1), reverse=True)


# 基于用户的推荐
def recommend_by_user_id(user_id):
    user_prefer = UserTagPrefer.objects.filter(user_id=user_id).order_by('-score').values_list('tag_id', flat=True)
    current_user = User.objects.get(id=user_id)
    # 如果当前用户没有打分 则看是否选择过标签，选过的话，就从标签中找
    # 没有的话，就按照浏览度推荐15个
    if current_user.rate_set.count() == 0:
        if len(user_prefer) != 0:
            car_list = xiangmu.objects.filter(tags__in=user_prefer)[:15]
        else:
            car_list = xiangmu.objects.order_by("-c9")[:15]
        return car_list
    # 选取评分最多的10个用户
    users_rate = Rate.objects.values('user').annotate(mark_num=Count('user')).order_by('-mark_num')
    user_ids = [user_rate['user'] for user_rate in users_rate]
    user_ids.append(user_id)
    users = User.objects.filter(id__in=user_ids)#users 为评分最多的10个用户
    all_user = {}
    for user in users:
        rates = user.rate_set.all()#查出10名用户的数据
        rate = {}
        # 用户有给新能源汽车打分 在rate和all_user中进行设置
        if rates:
            for i in rates:
                rate.setdefault(str(i.car.id), i.mark)#填充新能源汽车数据
            all_user.setdefault(user.username, rate)
        else:
            # 用户没有为新能源汽车打过分，设为0
            all_user.setdefault(user.username, {})

    user_cf = UserCf(all_user=all_user)
    recommend_list = [each[0] for each in user_cf.recommend(current_user.username, 15)]
    car_list = list(xiangmu.objects.filter(id__in=recommend_list).order_by("-c9")[:15])
    other_length = 15 - len(car_list)
    if other_length > 0:
        fix_list = xiangmu.objects.filter(~Q(rate__user_id=user_id)).order_by('-collect')
        for fix in fix_list:
            if fix not in car_list:
                car_list.append(fix)
            if len(car_list) >= 15:
                break
    return car_list


# 计算相似度
def similarity(car1_id, car2_id):
    car1_set = Rate.objects.filter(car_id=car1_id)
    # car1的打分用户数
    car1_sum = car1_set.count()
    # car_2的打分用户数
    car2_sum = Rate.objects.filter(car_id=car2_id).count()
    # 两者的交集
    common = Rate.objects.filter(user_id__in=Subquery(car1_set.values('user_id')), car=car2_id).values('user_id').count()
    # 没有人给当前新能源汽车打分
    if car1_sum == 0 or car2_sum == 0:
        return 0
    similar_value = common / sqrt(car1_sum * car2_sum)#余弦计算相似度
    return similar_value


#基于物品
def recommend_by_item_id(user_id, k=15):
    # 前三的tag，用户评分前三的新能源汽车
    user_prefer = UserTagPrefer.objects.filter(user_id=user_id).order_by('-score').values_list('tag_id', flat=True)
    user_prefer = list(user_prefer)[:3]
    print('user_prefer', user_prefer)
    current_user = User.objects.get(id=user_id)
    # 如果当前用户没有打分 则看是否选择过标签，选过的话，就从标签中找
    # 没有的话，就按照浏览度推荐15个
    if current_user.rate_set.count() == 0:
        if len(user_prefer) != 0:
            car_list = xiangmu.objects.filter(tags__in=user_prefer)[:15]
        else:
            car_list = xiangmu.objects.order_by("-c9")[:15]
        print('from here')
        return car_list
    # most_tags = Tags.objects.annotate(tags_sum=Count('name')).order_by('-tags_sum').filter(car__rate__user_id=user_id).order_by('-tags_sum')
    # 选用户最喜欢的标签中的新能源汽车，用户没看过的30部，对这30部新能源汽车，计算距离最近
    un_watched = xiangmu.objects.filter(~Q(rate__user_id=user_id), tags__in=user_prefer).order_by('?')[:30]  # 看过的新能源汽车
    watched = Rate.objects.filter(user_id=user_id).values_list('car_id', 'mark')
    distances = []
    names = []
    # 在未看过的新能源汽车中找到
    for un_watched_car in un_watched:
        for watched_car in watched:
            if un_watched_car not in names:
                names.append(un_watched_car)
                distances.append((similarity(un_watched_car.id, watched_car[0]) * watched_car[1], un_watched_car))#加入相似的新能源汽车
    distances.sort(key=lambda x: x[0], reverse=True)
    print('this is distances', distances[:15])
    recommend_list = []
    for mark, car in distances:
        if len(recommend_list) >= k:
            break
        if car not in recommend_list:
            recommend_list.append(car)
    # print('this is recommend list', recommend_list)
    # 如果得不到有效数量的推荐 按照未看过的新能源汽车中的热度进行填充
    print('recommend list', recommend_list)
    return recommend_list

if __name__ == '__main__':
    # similarity(2003, 2008)
    print(recommend_by_item_id(1799))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183