python 模拟车辆运行

毕业设计：2023-2024年计算机专业毕业设计选题汇总（建议收藏）

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

🍅感兴趣的可以先收藏起来，点赞、关注不迷路，大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助同学们顺利毕业 。🍅

1、项目介绍

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

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

使用Python进行数据处理和特征提取，将新能源汽车的数据存入MySQL数据库。
使用Django框架搭建Web应用，实现用户注册、登录、浏览汽车信息等功能。
使用Echarts将汽车数据以可视化的方式呈现给用户，包括销量排行、价格分布、用户评价等图表展示。
实现基于用户和基于物品的协同过滤推荐算法，根据用户的偏好和行为向其推荐汽车。
将推荐结果通过HTML页面展示给用户，并提供交互式操作，如查看汽车详情、对比不同车型等功能。

2、项目界面

（1）汽车数据

（2）汽车数据品牌数量

（3）汽车数据品牌词云图分析

（4）汽车品牌数据占比

（5）汽车数据详情页面

（6）基于用户推荐汽车+基于物品推荐汽车

（7）汽车品牌分类

（8）汽车上市数量

（9）后台数据管理

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))