毕业设计：Python房屋推荐系统 商品房推荐 协同过滤算法 楼盘 小区分析可视化 （附源码）✅_python二手房可视化分析与推荐系统

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

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

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

1、项目介绍

Python房屋推荐系统 商品房 协同过滤算法 分析可视化

前端：html，css，js，Echats，百度地图
后端：Python语言 Django框架 两种协同过滤推荐算法
数据库：mysql

解决问题：
中国正处于城镇化进程加速发展时期,城市规模不断扩大，大量的人口有农村向着城市转移，农村地区逐步演变成城市地区，
城市人口不断增加。而在城市化发展的过程中，住房问题成为了人们最为苦恼的问题，而且随着人们生活质量的不断提升，
消费者在购房的过程中会考虑越来越多的房产因素，例如：小区绿化，小区周边的社会服务设施，区位资源，房源的价格等各方面的因素，
那么针对这些消费者在购房过程中考虑的诸多问题，一套完整的房源信息分析推荐系统就显得格外重要。

2、项目界面

（1）个人详情页

（2）数据可视化分析

（3）房屋数据管理

（4）楼盘详细信息

（5）百度地图分析

（6）房源对比

（7）两种推荐算法推荐

（8）后台数据管理

3、项目说明

Python房屋推荐系统 商品房 协同过滤算法 分析可视化 毕业设计

前端：html，css，js，Echats，百度地图
后端：Python语言 Django 两种协同过滤推荐算法
数据库：mysql

解决问题：
中国正处于城镇化进程加速发展时期,城市规模不断扩大，大量的人口有农村向着城市转移，农村地区逐步演变成城市地区，
城市人口不断增加。而在城市化发展的过程中，住房问题成为了人们最为苦恼的问题，而且随着人们生活质量的不断提升，
消费者在购房的过程中会考虑越来越多的房产因素，例如：小区绿化，小区周边的社会服务设施，区位资源，房源的价格等各方面的因素，
那么针对这些消费者在购房过程中考虑的诸多问题，一套完整的房源信息分析推荐系统就显得格外重要。

Django是一个基于Python的高级Web开发框架，用于构建强大的Web应用程序。协同过滤是一种推荐系统算法，用于根据用户的历史行为和其他用户的行为模式，推荐给用户可能感兴趣的内容。

基于Django的房屋推荐系统可以使用协同过滤算法来为用户推荐符合其喜好的房屋列表。以下是实现房屋推荐系统的一般步骤：

1. 数据收集：收集用户对房屋的评分数据，包括用户ID、房屋ID和评分。

2. 数据预处理：使用Django的数据库模型创建房屋和用户模型，并将收集到的评分数据存储到数据库中。

3. 相似度计算：根据用户对房屋的评分数据，计算房屋之间的相似度。常用的相似度计算方法有余弦相似度和皮尔逊相关系数。

4. 推荐生成：对于特定用户，根据其历史评分数据和房屋之间的相似度，计算出与用户喜好最相似的房屋列表。

5. 推荐展示：使用Django的视图和模板系统，将生成的推荐结果展示给用户。

6. 用户反馈：根据用户的反馈，对推荐结果进行调整和优化。

除了基本的房屋推荐功能外，你还可以通过Django的用户认证系统实现用户登录、注册和个人信息管理功能。

总结来说，基于Django的房屋推荐系统可以通过协同过滤算法帮助用户找到符合其喜好的房屋。使用Django的优势是能够快速构建稳定的Web应用程序，并与其他Django组件（如用户认证系统）无缝集成。

4、核心代码

from django.shortcuts import render
from django.http import JsonResponse
from data_count.models import *
import numpy as np

import math
# Create your views here.

def recommend_html(request):
    """
    房源推荐页面的显示
    :param request:
    :return:
    """
    return render(request,"gp_data/house_tuijian.html")



def data_to_json1(data):
    list = []
    for i in data:
        dict = {}
        dict["loupan_id"] = i.loupan_id.id
        dict["loupan_name"] = i.loupan_id.loupan_name
        dict["property_type"] = i.loupan_id.property_type
        dict["building_type"] = i.loupan_id.building_type
        dict["sub_region_id"] = i.loupan_id.sub_region_id
        dict["address"] = i.loupan_id.address
        dict["lvhua_rate"] = i.loupan_id.lvhua_rate
        dict["zhandi_area"] = i.loupan_id.zhandi_area
        dict["jianzhu_area"] = i.loupan_id.jianzhu_area
        dict["car_num"] = i.loupan_id.car_num
        dict["cankao_price"] = i.loupan_id.cankao_price
        dict["default_image_id"] = i.loupan_id.default_image_id
        dict["housetype_text"] = i.loupan_id.housetype_text
        dict["baidu_lat"] = i.loupan_id.baidu_lat
        dict["baidu_lng"] = i.loupan_id.baidu_lng
        dict["sale_title"] = i.loupan_id.sale_title
        dict["price_2020"] = i.loupan_id.price_2020
        dict["price_2019"] = i.loupan_id.price_2019
        dict["price_2018"] =i.loupan_id.price_2018
        if dict not in list:
            list.append(dict)
    return {"result":list}
def base_user_recommend(request):
    """
    基于用户收藏的推荐
    csdn  算法地址 ：https://blog.csdn.net/winone361/article/details/45457445
    :param request:
    :return:
    """
    #获取全部用户对象
    all_user = user.objects.all()
    #获取全部楼盘对象
    all_loupan = loupan.objects.all()

    #创建用户收藏矩阵
    user_collect_items_X_Y = np.zeros((len(all_user),len(all_loupan)),dtype=float)

    #创建用户对

    for i in range(len(all_user)):
        for j in range(len(all_loupan)):
            #判断收藏夹中是否 有该用户收藏的该楼盘
            collect = collections.objects.filter(loupan_id = all_loupan[j],user_id = all_user[i])
            if len(collect) != 0:
                user_collect_items_X_Y[i][j] = 1

    #建立 楼盘 - 用户的倒叙表  转置用户收藏矩阵
    T_user_collect_items_X_Y = user_collect_items_X_Y.T

    #创建用户 - 用户矩阵
    user_user_X_Y = np.zeros((len(all_user),len(all_user)),dtype=float)

    #赋值用户相似表
    for i in range(len(T_user_collect_items_X_Y)):
        for j in range(len(T_user_collect_items_X_Y[i])):
            index_list = []
            if T_user_collect_items_X_Y[i][j]==1:
                index_list.append(j)

            if len(index_list)>=1:
                for i_ in range(len(index_list)):
                    for j_ in range(i_+1,len(index_list)):
                        user_user_X_Y[i_][j_]+=1

    like_user_user_X_Y = user_user_X_Y

    #进行用户相似计算
    for i in range(len(user_user_X_Y)):
        for j in range(len(user_user_X_Y[i])):
            print("user",user_user_X_Y)
            print(len(user_user_X_Y[i]))

            like_user_user_X_Y[i][j] = user_user_X_Y[i][j]/math.sqrt(len(user_user_X_Y[i])*len(user_user_X_Y[j]))
            print(user_user_X_Y[i][j]/math.sqrt(len(user_user_X_Y[i])*len(user_user_X_Y[j])))
            print(like_user_user_X_Y[i][j])

    print(like_user_user_X_Y)

    #获取当前用户
    now_user = user.objects.get(id = request.COOKIES["user_id"])
    index = 0
    for u in range(len(all_user)):
        if now_user==all_user[u]:
            index = u

    #从用户相似表中找到和他最相似的用户
    max_user_index = int(np.argmax(like_user_user_X_Y[index]))
    print(max_user_index)

    #获取当前用户收藏的楼盘
    now_user_collect = list(now_user.collections_set.all())
    #获取相似用户收藏的楼盘

    like_user_collect = list(all_user[max_user_index].collections_set.all())
    print("现在",now_user_collect)
    print("相似",like_user_collect)
    if now_user == all_user[max_user_index]:
        last_tuijian_data =now_user_collect
    else :
        for i in now_user_collect:
            print(i.loupan_id.loupan_name)
            for j in like_user_collect:
                print(j.loupan_id.loupan_name)
                print(i.loupan_id.loupan_name == j.loupan_id.loupan_name)
                if i.loupan_id.loupan_name == j.loupan_id.loupan_name:
                    print(i.loupan_id.loupan_name)
                    now_user_collect.remove(i)
                    print("移除成功")
        last_tuijian_data = now_user_collect + like_user_collect

    print(last_tuijian_data)

    #转换成json数据
    return JsonResponse(data_to_json1(last_tuijian_data))









def data_to_json(data):
    list = []
    for i in data:
        dict = {}
        dict["loupan_id"] = i.id
        dict["loupan_name"] = i.loupan_name
        dict["property_type"] = i.property_type
        dict["building_type"] = i.building_type
        dict["sub_region_id"] = i.sub_region_id
        dict["address"] = i.address
        dict["lvhua_rate"] = i.lvhua_rate
        dict["zhandi_area"] = i.zhandi_area
        dict["jianzhu_area"] = i.jianzhu_area
        dict["car_num"] = i.car_num
        dict["cankao_price"] = i.cankao_price
        dict["default_image_id"] = i.default_image_id
        dict["housetype_text"] = i.housetype_text
        dict["baidu_lat"] = i.baidu_lat
        dict["baidu_lng"] = i.baidu_lng
        dict["sale_title"] = i.sale_title
        dict["price_2020"] = i.price_2020
        dict["price_2019"] = i.price_2019
        dict["price_2018"] =i.price_2018
        list.append(dict)
    return {"result":list}



def base_loupan_recommend(request):
    """
    基于楼盘的推荐
    csdn 算法地址：
    :param request:
    :return:
    """
    #获取用户行为中的全部数据
    #获取全部用户
    all_user = user.objects.all()
    #获取全部楼盘
    all_loupan = loupan.objects.all()
    #创建用户行为矩阵
    action_user_X_Y = np.zeros((len(all_loupan),len(all_user)),dtype=float)

    #为行为矩阵赋值
    for i in range(len(all_loupan)):
        for j in range(len(all_user)):
            #创建用户行为表对象
            user_action = user_actions.objects.filter(loupan_id=all_loupan[i],user_id=all_user[j])
            #获取分数
            if len(user_action)!=0:
                count = user_action[0].click_num+user_action[0].search_num+user_action[0].collection_num+user_action[0].comment_num
                print(count)
                action_user_X_Y[i][j] = count

    print(action_user_X_Y)
    #创建相似矩阵
    like_user_X_Y = np.zeros((len(all_loupan),len(all_loupan)),dtype=float)

    for i in range(len(all_loupan)):
        for j in range(len(all_loupan)):
            if i==j:
                like_user_X_Y[i][j] =1.0
            else:
                like_user_X_Y[i][j] =sum(np.array(action_user_X_Y[i])*np.array(action_user_X_Y[j]))/(math.sqrt(sum(action_user_X_Y[i]*action_user_X_Y[i]))+math.sqrt(sum(action_user_X_Y[j]*action_user_X_Y[j])))
                print("分子:",sum(np.array(action_user_X_Y[i])*np.array(action_user_X_Y[j])))
                print("分母:",(math.sqrt(sum(action_user_X_Y[i]*action_user_X_Y[i]))+math.sqrt(sum(action_user_X_Y[j]*action_user_X_Y[j]))))
    print(like_user_X_Y[0])
    #对like_user_X_Y 讲nan换成0.0
    action_user_X_Y[np.isnan(action_user_X_Y)]=0.0
    like_user_X_Y[np.isnan(like_user_X_Y)] = 0.0
    #创建推荐矩阵  相似矩阵*评分矩阵

    recommen_X_Y = np.dot(like_user_X_Y,action_user_X_Y)

    #生成该用户的推荐list
    #获取用户在那一列
    user_id = request.COOKIES["user_id"]
    islogin = request.COOKIES["islogin"]
    if islogin=="False":
        #表示用户没有登录
        return JsonResponse({"res":0})
    now_user = user.objects.get(id=user_id)
    y_index = 0
    for i in range(len(all_user)):
        if all_user[i] == now_user:
            y_index = i

    tuijian_obj =[]

    #讲推荐矩阵转置
    T_recommen_X_Y = recommen_X_Y.T
    for i in range(len(T_recommen_X_Y[y_index])):
        if T_recommen_X_Y[y_index][i] !=0.0 :
            tuijian_obj.append(all_loupan[i])
            #添加到历史推荐
            # 将数据添加到历史推荐中
            history_info = history_recommend.objects.filter(user_id=now_user, loupan_id=all_loupan[i])
            if len(history_info) == 0:
                # 创建对象添加数据
                history_info_obj = history_recommend()
                history_info_obj.user_id = now_user
                history_info_obj.loupan_id = all_loupan[i]
                history_info_obj.save()
            # 进行用户行为保存
            if request.COOKIES["islogin"] == "True":
                print("用户行为保存")
                user_obj = user.objects.get(id=request.COOKIES["user_id"])
                # 创建user_actions 对象
                user_action = user_actions.objects.filter(user_id=user_obj, loupan_id=all_loupan[i])
                if len(user_action) != 0:
                    # 将click_num +1
                    user_action[0].click_num = user_action[0].click_num + 1
                    user_action[0].collection_num = user_action[0].collection_num + 2
                    user_action[0].save()
                else:
                    user_action = user_actions()
                    user_action.user_id = user_obj
                    user_action.loupan_id = all_loupan[i]
                    user_action.click_num = 1
                    user_action.collection_num = 2
                    user_action.save()

    #将推荐的对象转成json格式
    if len(tuijian_obj)==0:
        #表示推荐列表为空
        return JsonResponse({'res':1})
    else :
        return  JsonResponse(data_to_json(tuijian_obj))





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
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278