基于Django框架用python写一个协同过滤推荐系统，可连接mysql数据库，封装成接口方便前端进行调用，并使用Swagger接口管理工具，编写的代码需要给出注释，给出程序所需的数据源。

好的，下面是一个简单的基于Django框架的协同过滤推荐系统：

## 1. 数据源

本系统使用了MovieLens数据集，包含了电影评分数据，用户数据和电影数据。可以从官网下载：https://grouplens.org/datasets/movielens/latest/

## 2. 安装依赖

本项目需要使用到以下Python库：

- Django
- django-rest-swagger
- pandas
- numpy
- scikit-learn
- mysql-connector-python

可以使用pip命令安装：

pip install Django django-rest-swagger pandas numpy scikit-learn mysql-connector-python

## 3. 数据处理

在将数据导入数据库前，需要先进行一些数据处理。

首先，将下载的数据集解压到任意位置，然后将以下代码保存为一个Python脚本（如"data_process.py"）：

import pandas as pd
import mysql.connector

# 读取数据
ratings = pd.read_csv('path/to/ratings.csv')
movies = pd.read_csv('path/to/movies.csv')

# 将电影名中的年份去除
movies['title'] = movies['title'].str.replace(r'\(\d+\)$', '')

# 连接MySQL数据库
cnx = mysql.connector.connect(user='username', password='password',
                              host='localhost', database='database_name')
cursor = cnx.cursor()

# 清空数据表
cursor.execute('TRUNCATE TABLE ratings')
cursor.execute('TRUNCATE TABLE movies')

# 将数据导入数据库
for index, row in ratings.iterrows():
    cursor.execute('INSERT INTO ratings (user_id, movie_id, rating) VALUES (%s, %s, %s)',
                   (row['userId'], row['movieId'], row['rating']))

for index, row in movies.iterrows():
    cursor.execute('INSERT INTO movies (movie_id, title) VALUES (%s, %s)',
                   (row['movieId'], row['title']))

# 提交更改并关闭连接
cnx.commit()
cursor.close()
cnx.close()

其中，需要将"path/to/ratings.csv"和"path/to/movies.csv"替换为实际的数据文件路径，将"user_id"、"movie_id"和"rating"替换为实际的数据库字段名，将"username"、"password"和"database_name"替换为实际的数据库用户名、密码和数据库名。

然后运行此脚本，即可将数据导入MySQL数据库中。

## 4. Django应用

创建一个Django应用，命名为"recommend"：

$ django-admin startapp recommend

在"recommend"文件夹下，创建以下文件：

### 4.1 models.py

from django.db import models

class Rating(models.Model):
    user_id = models.IntegerField()
    movie_id = models.IntegerField()
    rating = models.FloatField()

    class Meta:
        db_table = 'ratings'

class Movie(models.Model):
    movie_id = models.IntegerField(primary_key=True)
    title = models.CharField(max_length=255)

    class Meta:
        db_table = 'movies'

这里定义了两个数据模型，分别对应数据库中的"ratings"表和"movies"表。

### 4.2 serializers.py

from rest_framework import serializers
from .models import Rating, Movie

class RatingSerializer(serializers.ModelSerializer):
    class Meta:
        model = Rating
        fields = ('user_id', 'movie_id', 'rating')

class MovieSerializer(serializers.ModelSerializer):
    class Meta:
        model = Movie
        fields = ('movie_id', 'title')

这里定义了两个序列化器，用于将数据模型转换为JSON格式。

### 4.3 views.py

from django.shortcuts import render
from rest_framework.views import APIView
from rest_framework.response import Response
from .models import Rating, Movie
from .serializers import RatingSerializer, MovieSerializer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
import mysql.connector

class RecommendView(APIView):
    def get(self, request):
        # 连接MySQL数据库
        cnx = mysql.connector.connect(user='username', password='password',
                                      host='localhost', database='database_name')
        cursor = cnx.cursor()

        # 查询所有电影ID
        cursor.execute('SELECT movie_id FROM movies')
        movies = [row[0] for row in cursor.fetchall()]

        # 查询所有用户ID
        cursor.execute('SELECT DISTINCT user_id FROM ratings')
        users = [row[0] for row in cursor.fetchall()]

        # 构建用户-电影评分矩阵
        data = np.zeros((len(users), len(movies)))
        for i, user in enumerate(users):
            cursor.execute('SELECT movie_id, rating FROM ratings WHERE user_id = %s', (user,))
            ratings = {row[0]: row[1] for row in cursor.fetchall()}
            for j, movie in enumerate(movies):
                if movie in ratings:
                    data[i, j] = ratings[movie]

        # 计算相似度矩阵
        sim = cosine_similarity(data)

        # 获取当前用户的推荐列表
        user_id = request.query_params.get('user_id', None)
        if user_id is None:
            return Response({'error': 'user_id not provided'})
        try:
            user_index = users.index(int(user_id))
        except ValueError:
            return Response({'error': 'user_id not found'})
        user_sim = sim[user_index]
        user_sim[user_index] = 0
        top_indices = np.argsort(user_sim)[::-1][:10]
        top_movies = [movies[i] for i in top_indices]

        # 查询推荐电影的详细信息
        cursor.execute('SELECT * FROM movies WHERE movie_id IN %s', (tuple(top_movies),))
        movies = cursor.fetchall()

        # 关闭连接
        cursor.close()
        cnx.close()

        # 将结果序列化为JSON格式并返回
        serializer = MovieSerializer(movies, many=True)
        return Response(serializer.data)

这里定义了一个名为"RecommendView"的视图，用于查询某个用户的推荐电影列表。该视图首先从数据库中查询所有电影ID和用户ID，然后构建用户-电影评分矩阵，使用余弦相似度计算相似度矩阵，最后根据当前用户的相似度向量获取其推荐列表，并查询推荐电影的详细信息，并将结果序列化为JSON格式返回。

### 4.4 urls.py

from django.urls import path
from .views import RecommendView
from rest_framework_swagger.views import get_swagger_view

schema_view = get_swagger_view(title='Recommend API')

urlpatterns = [
    path('', schema_view),
    path('recommend/', RecommendView.as_view()),
]

这里定义了一个名为"RecommendView"的视图，用于查询某个用户的推荐电影列表。该视图首先从数据库中查询所有电影ID和用户ID，然后构建用户-电影评分矩阵，使用余弦相似度计算相似度矩阵，最后根据当前用户的相似度向量获取其推荐列表，并查询推荐电影的详细信息，并将结果序列化为JSON格式返回。

### 4.5 settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'rest_framework',
    'rest_framework_swagger',
    'recommend',
]

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'database_name',
        'USER': 'username',
        'PASSWORD': 'password',
        'HOST': 'localhost',
        'PORT': '3306',
    }
}

REST_FRAMEWORK = {
    'DEFAULT_SCHEMA_CLASS': 'rest_framework.schemas.coreapi.AutoSchema'
}

这里配置了应用依赖的库、数据库连接信息和REST框架的设置。

## 5. 运行应用

使用以下命令启动Django服务：

$ python manage.py runserver

然后访问"http://localhost:8000/"即可看到Swagger接口文档，并可以测试"recommend"接口。