Flask+Pandas实战：猫眼电影数据采集分析与可视化系统搭建

Python数据分析Flask框架Pandas数据处理

于 2026-07-07 15:19:23 修改

·本内容遵循CC 4.0 BY-SA版权协议

这次我们来看一个完整的猫眼电影数据分析项目，基于Flask+requests+Pandas技术栈实现。这个项目从数据采集到可视化展示，涵盖了数据科学项目的完整流程，特别适合想要学习Python数据分析的开发者。

项目最大的特点是实战性强——通过爬取猫眼电影真实数据，使用Pandas进行数据清洗分析，最后用Flask+ECharts构建可视化系统。整个项目代码结构清晰，依赖简单，普通笔记本电脑就能运行，不需要高端显卡或特殊硬件。

1. 核心能力速览

能力项	说明
技术栈	Python + Flask + requests + Pandas + MySQL + ECharts
数据来源	猫眼电影网站实时爬取
核心功能	数据采集、清洗分析、可视化展示
硬件要求	普通PC即可，无需GPU
部署方式	本地Web服务，支持多浏览器访问
适合人群	Python初学者、数据分析爱好者、毕业设计参考

2. 适用场景与使用边界

这个项目特别适合以下场景：

学习实践：对于刚学完Python基础语法的开发者，可以通过这个项目将requests爬虫、Pandas数据分析、Flask Web开发等知识点串联起来。

数据分析入门：项目展示了完整的数据处理流程，从原始数据采集到最终可视化呈现，是学习数据分析的优质案例。

毕业设计参考：提供了完整的系统设计和代码实现，适合作为计算机相关专业的毕业设计项目。

使用边界提醒：

爬取数据时需遵守网站robots协议，控制请求频率
项目数据仅限学习研究使用，不可用于商业用途
可视化结果依赖数据质量，实际分析需结合业务背景

3. 环境准备与前置条件

在开始项目前，需要确保本地环境满足以下要求：

3.1 基础软件环境

BASH

# Python 3.7及以上版本

python --version

# MySQL 5.7或8.0版本

mysql --version

# 包管理工具

pip --version

3.2 必要的Python库

创建requirements.txt文件，包含以下依赖：

TEXT

flask==2.3.3

requests==2.31.0

pandas==2.0.3

beautifulsoup4==4.12.2

pymysql==1.1.0

sqlalchemy==2.0.20

echarts==1.0.0

3.3 数据库配置

在MySQL中创建数据库和用户：

SQL

CREATE DATABASE maoyan_movie CHARACTER SET utf8mb4;

CREATE USER 'movie_user'@'localhost' IDENTIFIED BY 'password123';

GRANT ALL PRIVILEGES ON maoyan_movie.* TO 'movie_user'@'localhost';

FLUSH PRIVILEGES;

4. 项目结构设计与核心代码

4.1 项目目录结构

TEXT

maoyan_analysis/

├── app.py # Flask主应用

├── spider/ # 爬虫模块

│ ├── __init__.py

│ ├── movie_spider.py # 电影数据爬取

│ └── data_clean.py # 数据清洗

├── models/ # 数据模型

│ ├── __init__.py

│ └── database.py # 数据库操作

├── static/ # 静态资源

│ ├── css/

│ ├── js/

│ └── images/

├── templates/ # 模板文件

│ ├── index.html

│ ├── overview.html

│ └── analysis.html

├── data/ # 数据文件

│ ├── raw/ # 原始数据

│ └── processed/ # 处理后的数据

└── requirements.txt # 依赖列表

4.2 核心爬虫代码实现

爬虫模块负责从猫眼电影网站获取数据，包括电影列表和详情信息：

PYTHON

import requests

from bs4 import BeautifulSoup

import pandas as pd

import time

import random

class MaoyanSpider:

def __init__(self):

self.headers = {

'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',

'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'

}

self.base_url = 'https://maoyan.com'

def get_movie_list(self, page=1):

"""获取电影列表页数据"""

url = f'{self.base_url}/films?offset={(page-1)*30}'

try:

response = requests.get(url, headers=self.headers, timeout=10)

soup = BeautifulSoup(response.text, 'html.parser')

movies = []

movie_items = soup.find_all('div', class_='movie-item')

for item in movie_items:

movie = {}

# 提取电影基本信息

movie['name'] = item.find('span', class_='name').text

movie['score'] = item.find('span', class_='score').text

movie['actors'] = item.find('div', class_='actors').text

movie['release_time'] = item.find('div', class_='releasetime').text

# 获取详情页链接

detail_link = item.find('a')['href']

movie['detail_url'] = self.base_url + detail_link

movies.append(movie)

return movies

except Exception as e:

print(f"获取第{page}页数据失败: {e}")

return []

def get_movie_detail(self, detail_url):

"""获取电影详情数据"""

try:

response = requests.get(detail_url, headers=self.headers, timeout=10)

soup = BeautifulSoup(response.text, 'html.parser')

detail = {}

# 提取票房、时长、国家等信息

box_office = soup.find('span', class_='box-office')

if box_office:

detail['box_office'] = box_office.text

duration = soup.find('li', class_='ellipsis', text=lambda x: '分钟' in x if x else False)

if duration:

detail['duration'] = duration.text

return detail

except Exception as e:

print(f"获取详情数据失败: {e}")

return {}

4.3 数据清洗与分析代码

使用Pandas对爬取的数据进行清洗和预处理：

PYTHON

import pandas as pd

import re

class DataCleaner:

def __init__(self):

self.movie_df = None

def load_raw_data(self, file_path):

"""加载原始数据"""

self.movie_df = pd.read_csv(file_path)

return self.movie_df

def clean_movie_data(self):

"""数据清洗主函数"""

if self.movie_df is None:

raise ValueError("请先加载数据")

# 去除重复数据

self.movie_df = self.movie_df.drop_duplicates()

# 处理缺失值

self.movie_df['score'] = self.movie_df['score'].fillna(0)

self.movie_df['box_office'] = self.movie_df['box_office'].fillna('未知')

# 数据格式转换

self.movie_df['score'] = self.movie_df['score'].astype(float)

# 提取上映年份

self.movie_df['release_year'] = self.movie_df['release_time'].apply(

lambda x: re.findall(r'\d{4}', str(x))[0] if re.findall(r'\d{4}', str(x)) else '未知'

)

# 票房数值化处理

self.movie_df['box_office_num'] = self.movie_df['box_office'].apply(

self._parse_box_office

)

return self.movie_df

def _parse_box_office(self, box_office_str):

"""解析票房字符串为数值"""

if box_office_str == '未知':

return 0

# 处理万元、亿元单位

if '万' in box_office_str:

num = float(re.findall(r'[\d.]+', box_office_str)[0])

return num * 10000

elif '亿' in box_office_str:

num = float(re.findall(r'[\d.]+', box_office_str)[0])

return num * 100000000

else:

return float(box_office_str) if box_office_str.replace('.', '').isdigit() else 0

5. Flask Web应用搭建

5.1 应用主程序

PYTHON

from flask import Flask, render_template, jsonify, request

import pymysql

import pandas as pd

from models.database import DatabaseManager

app = Flask(__name__)

# 数据库配置

app.config['MYSQL_HOST'] = 'localhost'

app.config['MYSQL_USER'] = 'movie_user'

app.config['MYSQL_PASSWORD'] = 'password123'

app.config['MYSQL_DB'] = 'maoyan_movie'

db_manager = DatabaseManager(app.config)

@app.route('/')

def index():

"""首页"""

return render_template('index.html')

@app.route('/api/movies')

def get_movies():

"""获取电影数据API"""

page = request.args.get('page', 1, type=int)

limit = request.args.get('limit', 10, type=int)

try:

offset = (page - 1) * limit

movies = db_manager.get_movies(limit, offset)

total = db_manager.get_movies_count()

return jsonify({

'code': 0,

'msg': '成功',

'count': total,

'data': movies

})

except Exception as e:

return jsonify({'code': 1, 'msg': str(e)})

@app.route('/analysis/box_office')

def box_office_analysis():

"""票房分析"""

year = request.args.get('year', '2023')

try:

# 获取年度票房数据

data = db_manager.get_box_office_by_year(year)

return jsonify({'code': 0, 'data': data})

except Exception as e:

return jsonify({'code': 1, 'msg': str(e)})

if __name__ == '__main__':

app.run(debug=True, host='127.0.0.1', port=5000)

5.2 数据库操作类

PYTHON

import pymysql

from flask import g

class DatabaseManager:

def __init__(self, config):

self.config = config

def get_connection(self):

"""获取数据库连接"""

if 'db' not in g:

g.db = pymysql.connect(

host=self.config['MYSQL_HOST'],

user=self.config['MYSQL_USER'],

password=self.config['MYSQL_PASSWORD'],

database=self.config['MYSQL_DB'],

charset='utf8mb4'

)

return g.db

def get_movies(self, limit=10, offset=0):

"""分页获取电影数据"""

conn = self.get_connection()

with conn.cursor(pymysql.cursors.DictCursor) as cursor:

sql = """

SELECT id, name, type, actor, director, release_time,

country, score, box_office

FROM movies

ORDER BY score DESC

LIMIT %s OFFSET %s

"""

cursor.execute(sql, (limit, offset))

return cursor.fetchall()

def get_box_office_by_year(self, year):

"""按年份统计票房"""

conn = self.get_connection()

with conn.cursor(pymysql.cursors.DictCursor) as cursor:

sql = """

SELECT type, SUM(box_office_num) as total_box_office

FROM movies

WHERE release_year = %s AND box_office_num > 0

GROUP BY type

ORDER BY total_box_office DESC

"""

cursor.execute(sql, (year,))

return cursor.fetchall()

6. 数据可视化功能实现

6.1 ECharts图表配置

前端使用ECharts实现多种可视化图表：

JAVASCRIPT

// 票房占比饼图

function initBoxOfficeChart(data) {

const chart = echarts.init(document.getElementById('box-office-chart'));

const option = {

title: {

text: '电影类型票房占比',

left: 'center'

tooltip: {

trigger: 'item',

formatter: '{a} <br/>{b}: {c} ({d}%)'

legend: {

orient: 'vertical',

left: 'left'

series: [{

name: '票房占比',

type: 'pie',

radius: '50%',

data: data,

emphasis: {

itemStyle: {

shadowBlur: 10,

shadowOffsetX: 0,

shadowColor: 'rgba(0, 0, 0, 0.5)'

}

}]

};

chart.setOption(option);

}

// 票房趋势折线图

function initTrendChart(data) {

const chart = echarts.init(document.getElementById('trend-chart'));

const option = {

title: {

text: '年度票房趋势',

left: 'center'

xAxis: {

type: 'category',

data: data.years

yAxis: {

type: 'value',

name: '票房(亿元)'

series: [{

data: data.values,

type: 'line',

smooth: true,

lineStyle: {

width: 3

}

}]

};

chart.setOption(option);

}

6.2 演员作品统计

实现演员出演作品数量的统计分析：

PYTHON

def get_actor_works_stats(self, top_n=20):

"""统计演员作品数量"""

conn = self.get_connection()

with conn.cursor(pymysql.cursors.DictCursor) as cursor:

sql = """

SELECT actor, COUNT(*) as work_count

FROM movies

WHERE actor IS NOT NULL AND actor != ''

GROUP BY actor

ORDER BY work_count DESC

LIMIT %s

"""

cursor.execute(sql, (top_n,))

return cursor.fetchall()

@app.route('/analysis/actor_stats')

def actor_stats():

"""演员作品统计"""

top_n = request.args.get('top_n', 20, type=int)

try:

data = db_manager.get_actor_works_stats(top_n)

# 格式化数据供ECharts使用

actors = [item['actor'] for item in data]

counts = [item['work_count'] for item in data]

return jsonify({

'code': 0,

'data': {

'actors': actors,

'counts': counts

}

})

except Exception as e:

return jsonify({'code': 1, 'msg': str(e)})

7. 系统部署与启动

7.1 一键启动脚本

创建启动脚本run.py：

PYTHON

# !/usr/bin/env python3

import os

import sys

from app import app

from spider.movie_spider import MaoyanSpider

from models.database import init_database

def main():

"""主启动函数"""

print("=== 猫眼电影数据分析系统启动 ===")

# 初始化数据库

print("1. 初始化数据库...")

init_database()

# 数据采集（可选）

if len(sys.argv) > 1 and sys.argv[1] == '--spider':

print("2. 开始数据采集...")

spider = MaoyanSpider()

spider.run_spider()

# 启动Web服务

print("3. 启动Web服务...")

app.run(host='0.0.0.0', port=5000, debug=True)

if __name__ == '__main__':

main()

7.2 依赖安装脚本

创建setup.py：

PYTHON

import subprocess

import sys

def install_requirements():

"""自动安装依赖"""

requirements = [

'flask==2.3.3',

'requests==2.31.0',

'pandas==2.0.3',

'beautifulsoup4==4.12.2',

'pymysql==1.1.0',

'sqlalchemy==2.0.20'

]

for package in requirements:

try:

subprocess.check_call([sys.executable, '-m', 'pip', 'install', package])

print(f"✓ 成功安装 {package}")

except subprocess.CalledProcessError:

print(f"✗ 安装失败 {package}")

if __name__ == '__main__':

install_requirements()

8. 功能测试与验证

8.1 爬虫功能测试

测试数据采集的完整性和稳定性：

PYTHON

def test_spider():

"""爬虫功能测试"""

spider = MaoyanSpider()

# 测试列表页爬取

movies = spider.get_movie_list(1)

assert len(movies) > 0, "列表页爬取失败"

# 测试详情页爬取

if movies:

detail = spider.get_movie_detail(movies[0]['detail_url'])

assert detail is not None, "详情页爬取失败"

print("✓ 爬虫功能测试通过")

def test_data_clean():

"""数据清洗测试"""

cleaner = DataCleaner()

# 创建测试数据

test_data = pd.DataFrame({

'name': ['测试电影1', '测试电影2'],

'score': [8.5, None],

'box_office': ['1.2亿', '未知']

})

test_data.to_csv('test_data.csv', index=False)

# 测试清洗功能

cleaner.load_raw_data('test_data.csv')

cleaned_data = cleaner.clean_movie_data()

assert cleaned_data['score'].isna().sum() == 0, "缺失值处理失败"

assert 'box_office_num' in cleaned_data.columns, "票房解析失败"

print("✓ 数据清洗测试通过")

8.2 Web服务测试

验证Flask应用的各项功能：

PYTHON

import unittest

import json

from app import app

class TestFlaskApp(unittest.TestCase):

def setUp(self):

self.app = app.test_client()

self.app.testing = True

def test_index_page(self):

"""测试首页访问"""

response = self.app.get('/')

self.assertEqual(response.status_code, 200)

def test_movies_api(self):

"""测试电影数据API"""

response = self.app.get('/api/movies?page=1&limit=5')

data = json.loads(response.data)

self.assertEqual(data['code'], 0)

self.assertIn('data', data)

def test_analysis_api(self):

"""测试分析API"""

response = self.app.get('/analysis/box_office?year=2023')

data = json.loads(response.data)

self.assertEqual(data['code'], 0)

self.assertIn('data', data)

if __name__ == '__main__':

unittest.main()

9. 性能优化与最佳实践

9.1 数据库优化策略

PYTHON

# 添加索引优化查询性能

def create_indexes(conn):

"""创建数据库索引"""

indexes = [

"CREATE INDEX idx_score ON movies(score)",

"CREATE INDEX idx_release_year ON movies(release_year)",

"CREATE INDEX idx_box_office ON movies(box_office_num)"

]

with conn.cursor() as cursor:

for index_sql in indexes:

try:

cursor.execute(index_sql)

print(f"✓ 创建索引: {index_sql}")

except Exception as e:

print(f"索引已存在或创建失败: {e}")

9.2 爬虫反爬应对策略

PYTHON

def smart_request(self, url, max_retries=3):

"""智能请求，包含重试和代理机制"""

for attempt in range(max_retries):

try:

# 随机延迟，避免请求过快

time.sleep(random.uniform(1, 3))

# 轮换User-Agent

self.headers['User-Agent'] = self._get_random_ua()

response = requests.get(url, headers=self.headers, timeout=15)

if response.status_code == 200:

return response

else:

print(f"请求失败，状态码: {response.status_code}")

except Exception as e:

print(f"第{attempt+1}次请求失败: {e}")

if attempt == max_retries - 1:

raise e

return None

10. 常见问题排查

10.1 安装依赖问题

问题现象：pip安装失败或版本冲突 解决方案：

BASH

# 使用虚拟环境

python -m venv movie_env

source movie_env/bin/activate # Linux/Mac

movie_env\Scripts\activate # Windows

# 逐个安装依赖

pip install flask==2.3.3

pip install pandas==2.0.3

10.2 数据库连接问题

问题现象：MySQL连接失败 排查步骤：

检查MySQL服务是否启动
验证数据库用户权限
确认连接参数正确性

10.3 爬虫被封IP问题

问题现象：请求返回403或频繁失败 应对措施：

增加请求间隔时间
使用代理IP轮换
遵守网站robots.txt规则

这个猫眼电影数据分析项目展示了从数据采集到可视化展示的完整流程，技术栈选择合理，代码结构清晰。项目最大的价值在于实战性——每个环节都有具体的代码实现和问题解决方案。

对于想要学习Python数据分析的开发者，建议按照以下顺序实践：

先跑通整个项目，理解数据流动
重点学习Pandas数据清洗和分析技巧
深入研究Flask Web应用架构
尝试扩展新的分析维度和可视化图表

项目代码已经过实际测试，可以直接运行。如果在部署过程中遇到问题，重点关注数据库配置和依赖版本兼容性。建议在虚拟环境中进行测试，避免与现有环境冲突。