Python全栈项目--校园图书馆管理与推荐系统

项目概述

校园图书馆管理与推荐系统是一个集成了传统图书管理功能和智能推荐算法的全栈Web应用。该系统旨在提升图书馆的运营效率，同时为学生提供个性化的图书推荐服务，改善阅读体验。

技术栈选型

后端技术

• Python 3.8+: 核心开发语言
• Django 4.x: Web框架，提供ORM、认证、管理后台等功能
• Django REST Framework: 构建RESTful API
• Celery: 异步任务处理（如推荐算法计算）
• Redis: 缓存和消息队列

前端技术

• Vue.js 3: 前端框架
• Element Plus: UI组件库
• Axios: HTTP请求库
• ECharts: 数据可视化

数据库

• PostgreSQL: 主数据库
• MongoDB: 存储用户行为日志

推荐算法

• NumPy & Pandas: 数据处理
• Scikit-learn: 机器学习算法
• 协同过滤: 基于用户和物品的推荐

系统功能模块

1. 用户管理模块

功能特性

• 用户注册与登录（支持学号认证）
• 角色权限管理（学生、教师、管理员）
• 个人信息维护
• 借阅历史查询

核心代码示例

from django.contrib.auth.models import AbstractUser
from django.db import models

class User(AbstractUser):
ROLE_CHOICES = (
('student', '学生'),
('teacher', '教师'),
('admin', '管理员'),
)
student_id = models.CharField(max_length=20, unique=True)
role = models.CharField(max_length=10, choices=ROLE_CHOICES)
department = models.CharField(max_length=100)
phone = models.CharField(max_length=11)

2. 图书管理模块

功能特性

• 图书信息录入与编辑
• 分类管理
• 库存管理
• 图书搜索（支持多条件检索）
• 二维码生成与扫描

数据模型

class Book(models.Model):
isbn = models.CharField(max_length=13, unique=True)
title = models.CharField(max_length=200)
author = models.CharField(max_length=100)
publisher = models.CharField(max_length=100)
category = models.ForeignKey('Category', on_delete=models.SET_NULL, null=True)
publish_date = models.DateField()
price = models.DecimalField(max_digits=10, decimal_places=2)
stock = models.IntegerField(default=0)
description = models.TextField()
cover_image = models.ImageField(upload_to='covers/')
created_at = models.DateTimeField(auto_now_add=True)

3. 借阅管理模块

功能特性

• 借书/还书操作
• 续借申请
• 逾期管理与罚款计算
• 预约功能
• 借阅记录统计

业务逻辑

from datetime import datetime, timedelta
from django.db import transaction

class BorrowRecord(models.Model):
user = models.ForeignKey(User, on_delete=models.CASCADE)
book = models.ForeignKey(Book, on_delete=models.CASCADE)
borrow_date = models.DateTimeField(auto_now_add=True)
due_date = models.DateTimeField()
return_date = models.DateTimeField(null=True, blank=True)
is_returned = models.BooleanField(default=False)
fine = models.DecimalField(max_digits=10, decimal_places=2, default=0)

@transaction.atomic
def borrow_book(user, book):
if book.stock <= 0:
raise ValueError("图书库存不足")

# 检查用户借阅数量限制
active_borrows = BorrowRecord.objects.filter(
user=user, is_returned=False
).count()
if active_borrows >= 5:
raise ValueError("借阅数量已达上限")

# 创建借阅记录
due_date = datetime.now() + timedelta(days=30)
record = BorrowRecord.objects.create(
user=user,
book=book,
due_date=due_date
)

# 减少库存
book.stock -= 1
book.save()

return record

4. 智能推荐模块

这是系统的核心亮点，采用混合推荐策略。

推荐算法实现

基于协同过滤的推荐

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

class CollaborativeFiltering:
def __init__(self):
self.user_item_matrix = None
self.similarity_matrix = None

def build_user_item_matrix(self, borrow_records):
"""构建用户-图书评分矩阵"""
users = list(set([r.user_id for r in borrow_records]))
books = list(set([r.book_id for r in borrow_records]))

matrix = np.zeros((len(users), len(books)))
user_idx = {u: i for i, u in enumerate(users)}
book_idx = {b: i for i, b in enumerate(books)}

for record in borrow_records:
ui = user_idx[record.user_id]
bi = book_idx[record.book_id]
# 根据借阅频次和是否逾期计算隐式评分
score = 5 if not record.is_overdue else 3
matrix[ui][bi] = score

self.user_item_matrix = matrix
return matrix, user_idx, book_idx

def calculate_similarity(self):
"""计算用户相似度"""
self.similarity_matrix = cosine_similarity(self.user_item_matrix)
return self.similarity_matrix

def recommend(self, user_id, user_idx, book_idx, top_n=10):
"""为用户推荐图书"""
ui = user_idx.get(user_id)
if ui is None:
return []

# 找到相似用户
user_similarities = self.similarity_matrix[ui]
similar_users = np.argsort(user_similarities)[::-1][1:6]

# 推荐相似用户喜欢但该用户未借阅的图书
user_books = set(np.where(self.user_item_matrix[ui] > 0)[0])
recommendations = {}

for similar_user in similar_users:
similar_user_books = np.where(self.user_item_matrix[similar_user] > 0)[0]
for book in similar_user_books:
if book not in user_books:
if book not in recommendations:
recommendations[book] = 0
recommendations[book] += user_similarities[similar_user]

# 按分数排序
sorted_recs = sorted(recommendations.items(), key=lambda x: x[1], reverse=True)
book_ids = [list(book_idx.keys())[list(book_idx.values()).index(b)]
for b, _ in sorted_recs[:top_n]]

return book_ids

基于内容的推荐

from sklearn.feature_extraction.text import TfidfVectorizer

class ContentBasedRecommender:
def __init__(self):
self.vectorizer = TfidfVectorizer(max_features=1000)
self.tfidf_matrix = None

def fit(self, books):
"""基于图书描述和标签构建特征向量"""
corpus = [
f"{book.title} {book.author} {book.category.name} {book.description}"
for book in books
]
self.tfidf_matrix = self.vectorizer.fit_transform(corpus)
return self.tfidf_matrix

def recommend_similar_books(self, book_id, books, top_n=10):
"""推荐相似图书"""
book_idx = {book.id: i for i, book in enumerate(books)}
idx = book_idx.get(book_id)

if idx is None:
return []

# 计算余弦相似度
similarities = cosine_similarity(
self.tfidf_matrix[idx:idx+1],
self.tfidf_matrix
).flatten()

# 排除自身，获取最相似的图书
similar_indices = similarities.argsort()[::-1][1:top_n+1]
similar_books = [books[i] for i in similar_indices]

return similar_books

Celery异步任务

from celery import shared_task

@shared_task
def generate_recommendations(user_id):
"""异步生成推荐列表"""
cf = CollaborativeFiltering()
records = BorrowRecord.objects.filter(is_returned=True)

matrix, user_idx, book_idx = cf.build_user_item_matrix(records)
cf.calculate_similarity()

recommended_book_ids = cf.recommend(user_id, user_idx, book_idx)

# 缓存推荐结果
cache.set(f'recommendations_{user_id}', recommended_book_ids, 3600)

return recommended_book_ids

5. 数据分析与可视化

功能特性

• 借阅趋势分析
• 热门图书统计
• 用户画像分析
• 图书流通率分析

API实现

from rest_framework.decorators import api_view
from django.db.models import Count, Q
from datetime import datetime, timedelta

@api_view(['GET'])
def borrow_statistics(request):
"""借阅统计数据"""
# 最近30天的借阅趋势
thirty_days_ago = datetime.now() – timedelta(days=30)
daily_borrows = BorrowRecord.objects.filter(
borrow_date__gte=thirty_days_ago
).extra(
select={'date': 'date(borrow_date)'}
).values('date').annotate(count=Count('id')).order_by('date')

# 热门图书Top10
popular_books = BorrowRecord.objects.values(
'book__title', 'book__author'
).annotate(
borrow_count=Count('id')
).order_by('-borrow_count')[:10]

# 分类借阅分布
category_stats = BorrowRecord.objects.values(
'book__category__name'
).annotate(count=Count('id'))

return Response({
'daily_trend': list(daily_borrows),
'popular_books': list(popular_books),
'category_distribution': list(category_stats)
})

6. 前端界面实现

Vue组件示例：图书搜索

<template>
<div class="book-search">
<el-form :inline="true" :model="searchForm">
<el-form-item label="书名">
<el-input v-model="searchForm.title" placeholder="请输入书名"></el-input>
</el-form-item>
<el-form-item label="作者">
<el-input v-model="searchForm.author" placeholder="请输入作者"></el-input>
</el-form-item>
<el-form-item label="分类">
<el-select v-model="searchForm.category" placeholder="请选择分类">
<el-option
v-for="cat in categories"
:key="cat.id"
:label="cat.name"
:value="cat.id">
</el-option>
</el-select>
</el-form-item>
<el-form-item>
<el-button type="primary" @click="handleSearch">搜索</el-button>
<el-button @click="handleReset">重置</el-button>
</el-form-item>
</el-form>

<el-table :data="bookList" style="width: 100%">
<el-table-column prop="title" label="书名"></el-table-column>
<el-table-column prop="author" label="作者"></el-table-column>
<el-table-column prop="publisher" label="出版社"></el-table-column>
<el-table-column prop="stock" label="库存"></el-table-column>
<el-table-column label="操作">
<template #default="scope">
<el-button size="small" @click="handleBorrow(scope.row)">借阅</el-button>
<el-button size="small" @click="handleDetail(scope.row)">详情</el-button>
</template>
</el-table-column>
</el-table>

<el-pagination
v-model:current-page="currentPage"
:page-size="pageSize"
:total="total"
@current-change="handlePageChange">
</el-pagination>
</div>
</template>

<script setup>
import { ref, reactive, onMounted } from 'vue'
import axios from 'axios'
import { ElMessage } from 'element-plus'

const searchForm = reactive({
title: '',
author: '',
category: ''
})

const bookList = ref([])
const categories = ref([])
const currentPage = ref(1)
const pageSize = ref(10)
const total = ref(0)

const fetchBooks = async () => {
try {
const response = await axios.get('/api/books/', {
params: {
…searchForm,
page: currentPage.value,
page_size: pageSize.value
}
})
bookList.value = response.data.results
total.value = response.data.count
} catch (error) {
ElMessage.error('获取图书列表失败')
}
}

const handleSearch = () => {
currentPage.value = 1
fetchBooks()
}

const handleReset = () => {
Object.keys(searchForm).forEach(key => {
searchForm[key] = ''
})
fetchBooks()
}

const handleBorrow = async (book) => {
try {
await axios.post('/api/borrow/', { book_id: book.id })
ElMessage.success('借阅成功')
fetchBooks()
} catch (error) {
ElMessage.error(error.response.data.message || '借阅失败')
}
}

onMounted(() => {
fetchBooks()
})
</script>

项目部署

Docker容器化部署

docker-compose.yml

version: '3.8'

services:
db:
image: postgres:14
environment:
POSTGRES_DB: library_db
POSTGRES_USER: library_user
POSTGRES_PASSWORD: your_password
volumes:
– postgres_data:/var/lib/postgresql/data

redis:
image: redis:7
ports:
– "6379:6379"

mongodb:
image: mongo:6
volumes:
– mongo_data:/data/db

web:
build: ./backend
command: gunicorn library.wsgi:application –bind 0.0.0.0:8000
volumes:
– ./backend:/app
– static_volume:/app/staticfiles
– media_volume:/app/media
ports:
– "8000:8000"
depends_on:
– db
– redis
– mongodb
environment:
– DATABASE_URL=postgresql://library_user:your_password@db:5432/library_db
– REDIS_URL=redis://redis:6379/0

celery:
build: ./backend
command: celery -A library worker -l info
volumes:
– ./backend:/app
depends_on:
– db
– redis

nginx:
image: nginx:alpine
ports:
– "80:80"
volumes:
– ./nginx.conf:/etc/nginx/nginx.conf
– static_volume:/static
– media_volume:/media
depends_on:
– web

volumes:
postgres_data:
mongo_data:
static_volume:
media_volume:

项目优化与扩展

性能优化

• 使用Redis缓存热门数据
• 数据库查询优化（索引、select_related、prefetch_related）
• 前端资源懒加载
• CDN加速静态资源

安全措施

• HTTPS加密传输
• JWT身份认证
• SQL注入防护
• XSS攻击防护
• CSRF令牌验证

未来扩展方向

• 移动端App开发
• 引入深度学习推荐算法
• 图书评论与评分系统
• 在线阅读功能
• 智能图书采购建议

项目总结

这个校园图书馆管理与推荐系统是一个完整的全栈项目，涵盖了前后端开发、数据库设计、推荐算法、异步任务处理等多个技术领域。通过这个项目，开发者可以深入理解Web应用的完整开发流程，掌握现代Web开发的核心技术栈，同时学习如何将机器学习算法应用到实际业务场景中。

项目的核心价值在于将传统的图书管理系统与智能推荐算法相结合，不仅提升了图书馆的管理效率，更重要的是通过个性化推荐帮助学生发现更多感兴趣的图书，促进校园阅读文化的发展。

项目代码：

下载链接