计算机毕业设计：Python智慧交通大数据分析平台 Flask框架 requests爬虫 出行速度预测 拥堵预测（建议收藏）✅

博主介绍：✌全网粉丝50W+，前互联网大厂软件研发、集结硕博英豪成立软件开发工作室，专注于计算机相关专业项目实战6年之久，累计开发项目作品上万套。凭借丰富的经验与专业实力，已帮助成千上万的学生顺利毕业，选择我们，就是选择放心、选择安心毕业✌
> 🍅想要获取完整文章或者源码，或者代做，拉到文章底部即可与我联系了。🍅

点击查看作者主页，了解更多项目！

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

1、毕业设计：2026年计算机专业毕业设计选题汇总（建议收藏）✅

2、最全计算机大数据专业毕业设计选题大全（建议收藏）✅

1、项目介绍

技术栈

python、flask、requests、sqlite、fbprophet、html

功能模块

数据获取

注册登录

北京交通数据分析可视化

广州交通数据分析可视化

出行速度预测

后台数据管理

项目介绍

本项目针对城市交通管理难题开发，依托python结合flask框架搭建系统，运用requests爬虫采集交通数据，通过sqlite数据库存储数据，并利用fbprophet库实现时间序列预测。系统覆盖北京、广州、武汉、重庆四大城市，可完成交通数据可视化展示、出行速度与拥堵系数预测，同时具备用户注册登录、后台数据管理等功能，能为出行规划与交通调度提供数据支撑，有效提升交通管理的智能化与精准化水平。

2、项目界面

（1）北京大数据智慧交通数据分析大屏

该页面为北京大数据智慧交通数据分析界面，中间以热力地图形式展示北京市各区拥堵情况，四周通过柱状图分别呈现最新拥堵系数、海淀区拥堵系数变化、朝阳区拥堵情况变化及西城区拥堵情况变化，实现多区域多维度交通拥堵数据的可视化展示与分析。

（2）智慧交通数据

该页面为智慧交通大数据分析平台的数据界面，左侧导航栏提供多城市分析、拥堵预测、出行速度预测及后台管理等功能入口，中间以分页表格形式展示城市、城区、拥堵指数、出行速度等交通数据，支持搜索与分页操作，实现交通数据的系统化展示与查询。

（3）广州大数据智慧交通数据分析大屏

该页面为广州大数据智慧交通数据分析界面，中间以热力地图形式展示广州市各区拥堵情况，四周通过图表分别呈现最新拥堵系数、荔湾区拥堵系数变化、天河区拥堵情况变化及越秀区拥堵情况变化，实现多区域多维度交通拥堵数据的可视化展示与分析。

（4）出行速度预测分析

该页面为智慧交通大数据分析平台的出行速度预测界面，左侧导航栏提供多城市分析、拥堵预测、后台管理等功能入口，中间可选择市区名称，以表格形式展示对应区域不同时间的预测出行速度数据，实现出行速度的预测与查询。

（5）拥堵系数预测

该页面为智慧交通大数据分析平台的拥堵预测界面，左侧导航栏提供多城市分析、出行速度预测、后台管理等功能入口，中间可选择市区名称，以表格形式展示对应区域不同时间的预测拥堵系数数据，实现拥堵情况的预测与查询。

（6）注册登录界面

该页面为智慧交通大数据分析平台的登录界面，提供账号与密码输入框及橙色登录按钮，设有没有账号去注册的入口，主要实现用户身份验证，保障系统操作的权限安全与登录入口功能。

（7）后台数据管理

该页面为智慧交通大数据分析平台的后台管理模块，以分页表格形式展示交通数据记录，支持按城市搜索、创建新数据、编辑与删除操作，实现交通数据的系统化后台管理与维护。

该页面为代码开发界面，左侧展示项目文件结构，中间区域呈现数据采集与入库的核心代码，下方控制台输出代码运行日志，实现多城市交通数据的定时采集、解析与数据库写入功能，为智慧交通大数据分析平台提供数据支撑。

该页面为中国主要城市交通健康榜界面，以地图点位标注城市交通健康状态，通过环形图展示城市健康状态占比，同时呈现智能CT实时诊断数据与交通健康指数排名表，实现全国城市交通健康状况的多维度可视化展示与分析。

3、项目说明

一、技术栈

本项目采用Python作为核心开发语言，搭配Flask框架搭建后端服务，确保系统轻量高效、易于维护；通过requests模块实现网络爬虫功能，采集交通相关数据；使用sqlite数据库存储各类交通数据及用户信息，保障数据存储的稳定性与便捷性；借助fbprophet库完成时间序列预测，实现出行速度与拥堵系数的精准预测；前端采用HTML构建，打造简洁直观的用户操作界面，整体技术栈适配项目数据采集、分析、预测及展示的核心需求。

二、功能模块详细介绍

数据获取：采用Python网络爬虫技术结合requests框架，定向采集高德地图交通情报和路况报告网站的相关数据，主要包括各城市交通拥堵情况、路况状态等核心信息，为整个系统的数据分析与预测功能提供坚实、准确的数据支撑，实现多城市交通数据的定时采集、解析与数据库写入，保障数据的实时性与完整性。

注册登录：提供用户注册与登录功能，用户需先输入用户名、密码完成注册，系统通过查询数据库验证账号唯一性，若重复注册则给予相应提示；登录时通过账号密码比对完成身份验证，保障系统操作的权限安全，是用户进入系统使用各项功能的唯一入口，同时维护用户信息的安全性。

北京交通数据分析可视化：对采集的北京交通数据进行专业分析与可视化展示，以热力地图为核心呈现北京市各区拥堵分布，搭配柱状图展示最新拥堵系数、海淀区拥堵系数变化、朝阳区及西城区拥堵情况变化，实现多区域、多维度交通拥堵数据的直观呈现，方便用户快速掌握北京交通动态。

广州交通数据分析可视化：与北京交通数据分析可视化功能逻辑一致，聚焦广州地区交通数据，通过热力地图展示广州市各区拥堵情况，借助各类图表呈现最新拥堵系数、荔湾区、天河区、越秀区拥堵系数及情况变化，实现广州交通数据的多维度可视化分析与展示。

出行速度预测：运用fbprophet时间序列预测算法，针对各城市不同区域的交通数据进行分析，用户可在对应界面选择市区名称，系统以表格形式展示该区域不同时间的预测出行速度数据，支持出行速度的查询与预测，帮助用户提前规划出行路线。

后台数据管理：为管理员提供系统化的数据管理功能，管理员登录后可进入后台界面，该界面以分页表格形式展示所有交通数据记录，支持按城市进行搜索，同时提供数据创建、编辑、删除等操作，实现交通数据的全面管理与维护，保障系统数据的准确性与规范性。

三、项目总结

本项目聚焦城市交通管理痛点，依托核心技术栈搭建起功能完善的智慧交通大数据分析平台，覆盖北京、广州、武汉、重庆四大城市，整合数据采集、用户认证、数据分析可视化、交通预测及后台管理等核心功能。系统通过爬虫技术获取实时交通数据，借助预测算法实现出行速度与拥堵情况的精准预判，以直观的可视化形式呈现数据，既为普通用户提供出行参考，也为交通调度提供数据支撑，有效弥补传统交通管理的不足，提升交通管理的智能化与精准化水平，具有较强的实用性与应用价值。

4、核心代码

# !/usr/bin/env python
# _*_ coding: utf-8 _*_
from flask import Flask, request, render_template,jsonify,abort,session,redirect, url_for
import os
import models
from models import app
import time
from sqlalchemy import or_,and_
import pandas
import datetime
from flask_sqlalchemy import SQLAlchemy
from flask_admin import Admin
from flask_admin.contrib.sqla import ModelView

app = Flask(__name__)

# 配置sqlite数据库
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///transportation.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

app.secret_key = 'a_secret_key'
db = SQLAlchemy(app)

# 初始化Flask Admin
admin = Admin(app, name='后台管理')

@app.route('/', methods=['GET', 'POST'])
@app.route('/index', methods=['GET', 'POST'])
def index():#主页
    uuid = session.get('uuid')#获取session的数据，判断是否登录，如未登录跳转到登录页
    if uuid:
        if not models.User.query.get(uuid):
            return redirect(url_for('login'))
        else:
            username = models.User.query.get(uuid).name
    else:
        return redirect(url_for('login'))
    if request.method == 'GET':
        results = models.Transportation.query.all()
        return render_template('index.html',**locals())

@app.route('/yuce', methods=['GET', 'POST'])
def yuce():
    if request.method == 'GET':
        result = list(set([str(i.city) + '-' + str(i.city_proper) for i in models.Transportation.query.all()]))
        result.sort()
        name = request.args.get('name','广州-天河区')
        print(name)
        name = name.split('-')[-1]
        datas = yuce1(name)
        print(datas)
        riqi = [i['riqi'] for i in datas]
        piaofang = [round(i['xisu'],2) for i in datas]
        return render_template('yuce.html',**locals())

@app.route('/yuce_prophet', methods=['GET', 'POST'])
def yuce_prophet():
    if request.method == 'GET':
        result = list(set([str(i.city) + '-' + str(i.city_proper) for i in models.Transportation.query.all()]))
        result.sort()
        name = request.args.get('name','广州-天河区')
        print(name)
        name = name.split('-')[-1]
        datas = yuce2(name)
        print(datas)
        return render_template('yuce_prophet.html',**locals())

@app.route('/gz_charts', methods=['GET', 'POST'])
def gz_charts():#主页
    uuid = session.get('uuid')#获取session的数据，判断是否登录，如未登录跳转到登录页
    if uuid:
        if not models.User.query.get(uuid):
            return redirect(url_for('login'))
        else:
            username = models.User.query.get(uuid).name
    else:
        return redirect(url_for('login'))
    if request.method == 'GET':

        sql_command = 'select * from Transportation '
        df = pandas.read_sql(sql_command, models.db.engine)
        datas = df[df['城市'].map(lambda xx:xx == '广州')]

        city_propers = list(set([i[2] for i in datas.values.tolist()]))
        city_propers.sort()
        map_data = []
        for resu in city_propers:
            reslut = datas[datas['城区'].map(lambda xx: xx == resu)].values.tolist()
            map_data.append({"name": resu, "value": reslut[-1][4]})

        print(map_data)

        #最新拥堵系数
        city_proper_name = []
        city_proper_index = []
        for resu in city_propers:
            reslut = datas[datas['城区'].map(lambda xx: xx == resu)].values.tolist()
            city_proper_name.append(resu)
            city_proper_index.append(reslut[-1][3])


        #天河区拥堵情况变化
        tianhe_names = []
        tianhe_count = []
        reslut = datas[datas['城区'].map(lambda xx: xx == '天河区')]


        date_set = list(set([resu[-1].split(':')[0] for resu in reslut.values.tolist()]))



        date_set.sort()
        for resu in date_set[-24:]:
            resu1 = reslut[reslut['获取日期'].map(lambda xx: xx.split(':')[0] == resu)].values.tolist()
            tianhe_names.append(resu)
            tianhe_count.append(resu1[0][4])

        #荔湾区拥堵系数变化
        liwan_names = []
        liwan_count = []
        reslut = datas[datas['城区'].map(lambda xx: xx == '荔湾区')]
        date_set = list(set([resu[-1].split(':')[0] for resu in reslut.values.tolist()]))
        date_set.sort()
        for resu in date_set[-24:]:
            resu1 = reslut[reslut['获取日期'].map(lambda xx: xx.split(':')[0] == resu)].values.tolist()
            liwan_names.append(resu)
            liwan_count.append(resu1[0][3])

        #越秀区拥堵情况变化
        yuexiu_names = []
        yuexiu_count = []
        reslut = datas[datas['城区'].map(lambda xx: xx == '越秀区')]
        date_set = list(set([resu[-1].split(':')[0] for resu in reslut.values.tolist()]))
        date_set.sort()
        for resu in date_set[-24:]:
            resu1 = reslut[reslut['获取日期'].map(lambda xx: xx.split(':')[0] == resu)].values.tolist()
            yuexiu_names.append(resu)
            yuexiu_count.append(resu1[0][4])

        return render_template('gz_daping.html',**locals())

@app.route('/cq_charts', methods=['GET', 'POST'])
def cq_charts():#主页
    uuid = session.get('uuid')#获取session的数据，判断是否登录，如未登录跳转到登录页
    if uuid:
        if not models.User.query.get(uuid):
            return redirect(url_for('login'))
        else:
            username = models.User.query.get(uuid).name
    else:
        return redirect(url_for('login'))
    if request.method == 'GET':

        sql_command = 'select * from Transportation '
        df = pandas.read_sql(sql_command, models.db.engine)
        datas = df[df['城市'].map(lambda xx:xx == '重庆')]

        city_propers = list(set([i[2] for i in datas.values.tolist()]))
        city_propers.sort()
        map_data = []
        for resu in city_propers:
            reslut = datas[datas['城区'].map(lambda xx: xx == resu)].values.tolist()
            map_data.append({"name": resu, "value": reslut[-1][4]})

        print(map_data)

        #最新拥堵系数
        city_proper_name = []
        city_proper_index = []
        for resu in city_propers:
            reslut = datas[datas['城区'].map(lambda xx: xx == resu)].values.tolist()
            city_proper_name.append(resu)
            city_proper_index.append(reslut[-1][3])


        #大渡口区拥堵情况变化
        tianhe_names = []
        tianhe_count = []
        reslut = datas[datas['城区'].map(lambda xx: xx == '大渡口区')]
        date_set = list(set([resu[-1].split(':')[0] for resu in reslut.values.tolist()]))
        date_set.sort()
        for resu in date_set[-24:]:
            resu1 = reslut[reslut['获取日期'].map(lambda xx: xx.split(':')[0] == resu)].values.tolist()
            tianhe_names.append(resu)
            tianhe_count.append(resu1[0][4])

        #江北区拥堵系数变化
        liwan_names = []
        liwan_count = []
        reslut = datas[datas['城区'].map(lambda xx: xx == '江北区')]
        date_set = list(set([resu[-1].split(':')[0] for resu in reslut.values.tolist()]))
        date_set.sort()
        for resu in date_set[-24:]:
            resu1 = reslut[reslut['获取日期'].map(lambda xx: xx.split(':')[0] == resu)].values.tolist()
            liwan_names.append(resu)
            liwan_count.append(resu1[0][3])

        #南岸区拥堵情况变化
        yuexiu_names = []
        yuexiu_count = []
        reslut = datas[datas['城区'].map(lambda xx: xx == '南岸区')]
        date_set = list(set([resu[-1].split(':')[0] for resu in reslut.values.tolist()]))
        date_set.sort()
        for resu in date_set[-24:]:
            resu1 = reslut[reslut['获取日期'].map(lambda xx: xx.split(':')[0] == resu)].values.tolist()
            yuexiu_names.append(resu)
            yuexiu_count.append(resu1[0][4])

        return render_template('cq_daping.html',**locals())


@app.route('/wuhan_charts', methods=['GET', 'POST'])
def wuhan_charts():#主页
    uuid = session.get('uuid')#获取session的数据，判断是否登录，如未登录跳转到登录页
    if uuid:
        if not models.User.query.get(uuid):
            return redirect(url_for('login'))
        else:
            username = models.User.query.get(uuid).name
    else:
        return redirect(url_for('login'))
    if request.method == 'GET':

        sql_command = 'select * from Transportation '
        df = pandas.read_sql(sql_command, models.db.engine)
        datas = df[df['城市'].map(lambda xx:xx == '武汉')]

        city_propers = list(set([i[2] for i in datas.values.tolist()]))
        city_propers.sort()
        map_data = []
        for resu in city_propers:
            reslut = datas[datas['城区'].map(lambda xx: xx == resu)].values.tolist()
            map_data.append({"name": resu, "value": reslut[-1][4]})

        print(map_data)

        #最新拥堵系数
        city_proper_name = []
        city_proper_index = []
        for resu in city_propers:
            reslut = datas[datas['城区'].map(lambda xx: xx == resu)].values.tolist()
            city_proper_name.append(resu)
            city_proper_index.append(reslut[-1][3])


        #江汉区拥堵情况变化
        tianhe_names = []
        tianhe_count = []
        reslut = datas[datas['城区'].map(lambda xx: xx == '江汉区')]
        date_set = list(set([resu[-1].split(':')[0] for resu in reslut.values.tolist()]))
        date_set.sort()
        for resu in date_set[-24:]:
            resu1 = reslut[reslut['获取日期'].map(lambda xx: xx.split(':')[0] == resu)].values.tolist()
            tianhe_names.append(resu)
            tianhe_count.append(resu1[0][4])

        #武昌区拥堵系数变化
        liwan_names = []
        liwan_count = []
        reslut = datas[datas['城区'].map(lambda xx: xx == '武昌区')]
        date_set = list(set([resu[-1].split(':')[0] for resu in reslut.values.tolist()]))
        date_set.sort()
        for resu in date_set[-24:]:
            resu1 = reslut[reslut['获取日期'].map(lambda xx: xx.split(':')[0] == resu)].values.tolist()
            liwan_names.append(resu)
            liwan_count.append(resu1[0][3])

        #江岸区拥堵情况变化
        yuexiu_names = []
        yuexiu_count = []
        reslut = datas[datas['城区'].map(lambda xx: xx == '江岸区')]
        date_set = list(set([resu[-1].split(':')[0] for resu in reslut.values.tolist()]))
        date_set.sort()
        for resu in date_set[-24:]:
            resu1 = reslut[reslut['获取日期'].map(lambda xx: xx.split(':')[0] == resu)].values.tolist()
            yuexiu_names.append(resu)
            yuexiu_count.append(resu1[0][4])

        return render_template('wuhan_daping.html',**locals())

@app.route('/zhangzhou_daping', methods=['GET', 'POST'])
def zhangzhou_daping():#主页
    uuid = session.get('uuid')#获取session的数据，判断是否登录，如未登录跳转到登录页
    if uuid:
        if not models.User.query.get(uuid):
            return redirect(url_for('login'))
        else:
            username = models.User.query.get(uuid).name
    else:
        return redirect(url_for('login'))
    if request.method == 'GET':

        sql_command = 'select * from Transportation '
        df = pandas.read_sql(sql_command, models.db.engine)
        datas = df[df['城市'].map(lambda xx:xx == '漳州')]

        city_propers = list(set([i[2] for i in datas.values.tolist()]))
        city_propers.sort()
        map_data = []
        for resu in city_propers:
            reslut = datas[datas['城区'].map(lambda xx: xx == resu)].values.tolist()
            map_data.append({"name": resu, "value": reslut[-1][4]})

        print(map_data)

        #最新拥堵系数
        city_proper_name = []
        city_proper_index = []
        for resu in city_propers:
            reslut = datas[datas['城区'].map(lambda xx: xx == resu)].values.tolist()
            city_proper_name.append(resu)
            city_proper_index.append(reslut[-1][3])


        #龙文区拥堵情况变化
        tianhe_names = []
        tianhe_count = []
        reslut = datas[datas['城区'].map(lambda xx: xx == '龙文区')]
        date_set = list(set([resu[-1].split(':')[0] for resu in reslut.values.tolist()]))
        date_set.sort()
        for resu in date_set[-24:]:
            resu1 = reslut[reslut['获取日期'].map(lambda xx: xx.split(':')[0] == resu)].values.tolist()
            tianhe_names.append(resu)
            tianhe_count.append(resu1[0][4])

        #芗城区拥堵系数变化
        liwan_names = []
        liwan_count = []
        reslut = datas[datas['城区'].map(lambda xx: xx == '芗城区')]
        date_set = list(set([resu[-1].split(':')[0] for resu in reslut.values.tolist()]))
        date_set.sort()
        for resu in date_set[-24:]:
            resu1 = reslut[reslut['获取日期'].map(lambda xx: xx.split(':')[0] == resu)].values.tolist()
            liwan_names.append(resu)
            liwan_count.append(resu1[0][3])

        #龙文区拥堵情况变化
        yuexiu_names = []
        yuexiu_count = []
        reslut = datas[datas['城区'].map(lambda xx: xx == '龙文区')]
        date_set = list(set([resu[-1].split(':')[0] for resu in reslut.values.tolist()]))
        date_set.sort()
        for resu in date_set[-24:]:
            resu1 = reslut[reslut['获取日期'].map(lambda xx: xx.split(':')[0] == resu)].values.tolist()
            yuexiu_names.append(resu)
            yuexiu_count.append(resu1[0][4])

        return render_template('zhangzhou_daping.html',**locals())


@app.route('/ganzhou_charts', methods=['GET', 'POST'])
def ganzhou_charts():#主页
    uuid = session.get('uuid')#获取session的数据，判断是否登录，如未登录跳转到登录页
    if uuid:
        if not models.User.query.get(uuid):
            return redirect(url_for('login'))
        else:
            username = models.User.query.get(uuid).name
    else:
        return redirect(url_for('login'))
    if request.method == 'GET':

        sql_command = 'select * from Transportation '
        df = pandas.read_sql(sql_command, models.db.engine)
        datas = df[df['城市'].map(lambda xx:xx == '赣州')]

        city_propers = list(set([i[2] for i in datas.values.tolist()]))
        city_propers.sort()
        map_data = []
        for resu in city_propers:
            reslut = datas[datas['城区'].map(lambda xx: xx == resu)].values.tolist()
            map_data.append({"name": resu, "value": reslut[-1][4]})

        print(map_data)

        #最新拥堵系数
        city_proper_name = []
        city_proper_index = []
        for resu in city_propers:
            reslut = datas[datas['城区'].map(lambda xx: xx == resu)].values.tolist()
            city_proper_name.append(resu)
            city_proper_index.append(reslut[-1][3])


        #章贡区拥堵情况变化
        tianhe_names = []
        tianhe_count = []
        reslut = datas[datas['城区'].map(lambda xx: xx == '章贡区')]
        date_set = list(set([resu[-1].split(':')[0] for resu in reslut.values.tolist()]))
        date_set.sort()
        for resu in date_set[-24:]:
            resu1 = reslut[reslut['获取日期'].map(lambda xx: xx.split(':')[0] == resu)].values.tolist()
            tianhe_names.append(resu)
            tianhe_count.append(resu1[0][4])

        #南康区拥堵系数变化
        liwan_names = []
        liwan_count = []
        reslut = datas[datas['城区'].map(lambda xx: xx == '南康区')]
        date_set = list(set([resu[-1].split(':')[0] for resu in reslut.values.tolist()]))
        date_set.sort()
        for resu in date_set[-24:]:
            resu1 = reslut[reslut['获取日期'].map(lambda xx: xx.split(':')[0] == resu)].values.tolist()
            liwan_names.append(resu)
            liwan_count.append(resu1[0][3])

        #赣县区拥堵情况变化
        yuexiu_names = []
        yuexiu_count = []
        reslut = datas[datas['城区'].map(lambda xx: xx == '赣县区')]
        date_set = list(set([resu[-1].split(':')[0] for resu in reslut.values.tolist()]))
        date_set.sort()
        for resu in date_set[-24:]:
            resu1 = reslut[reslut['获取日期'].map(lambda xx: xx.split(':')[0] == resu)].values.tolist()
            yuexiu_names.append(resu)
            yuexiu_count.append(resu1[0][4])

        return render_template('ganzhou_daping.html',**locals())

@app.route('/bj_charts', methods=['GET', 'POST'])
def bj_charts():#主页
    uuid = session.get('uuid')#获取session的数据，判断是否登录，如未登录跳转到登录页
    if uuid:
        if not models.User.query.get(uuid):
            return redirect(url_for('login'))
        else:
            username = models.User.query.get(uuid).name
    else:
        return redirect(url_for('login'))
    if request.method == 'GET':

        sql_command = 'select * from Transportation '
        df = pandas.read_sql(sql_command, models.db.engine)
        datas = df[df['城市'].map(lambda xx:xx == '北京')]

        city_propers = list(set([i[2] for i in datas.values.tolist()]))
        city_propers.sort()
        map_data = []
        for resu in city_propers:
            reslut = datas[datas['城区'].map(lambda xx: xx == resu)].values.tolist()
            map_data.append({"name": resu, "value": reslut[-1][4]})

        print(map_data)

        #最新拥堵系数
        city_proper_name = []
        city_proper_index = []
        for resu in city_propers:
            reslut = datas[datas['城区'].map(lambda xx: xx == resu)].values.tolist()
            city_proper_name.append(resu)
            city_proper_index.append(reslut[-1][3])


        #朝阳区拥堵情况变化
        tianhe_names = []
        tianhe_count = []
        reslut = datas[datas['城区'].map(lambda xx: xx == '朝阳区')]




        date_set = list(set([resu[-1].split(':')[0] for resu in reslut.values.tolist()]))



        date_set.sort()
        for resu in date_set[-24:]:
            resu1 = reslut[reslut['获取日期'].map(lambda xx: xx.split(':')[0] == resu)].values.tolist()
            tianhe_names.append(resu)
            tianhe_count.append(resu1[0][4])

        #海淀区拥堵系数变化
        liwan_names = []
        liwan_count = []
        reslut = datas[datas['城区'].map(lambda xx: xx == '海淀区')]
        date_set = list(set([resu[-1].split(':')[0] for resu in reslut.values.tolist()]))
        date_set.sort()
        for resu in date_set[-24:]:
            resu1 = reslut[reslut['获取日期'].map(lambda xx: xx.split(':')[0] == resu)].values.tolist()
            liwan_names.append(resu)
            liwan_count.append(resu1[0][3])

        #西城区拥堵情况变化
        yuexiu_names = []
        yuexiu_count = []
        reslut = datas[datas['城区'].map(lambda xx: xx == '西城区')]
        date_set = list(set([resu[-1].split(':')[0] for resu in reslut.values.tolist()]))
        date_set.sort()
        for resu in date_set[-24:]:
            resu1 = reslut[reslut['获取日期'].map(lambda xx: xx.split(':')[0] == resu)].values.tolist()
            yuexiu_names.append(resu)
            yuexiu_count.append(resu1[0][4])

        return render_template('bj_daping.html',**locals())



from collections import OrderedDict
import pandas as pd
import models
from sqlalchemy import or_,and_
import datetime
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
import numpy
import traceback

def yuce1(name):
    try:
        sql_command = 'select * from Transportation '
        df = pandas.read_sql(sql_command, models.db.engine)
        da = df[df['城区'].map(lambda xx: xx == name)]
        datas = df[df['城区'].map(lambda xx: xx == name)].values.tolist()

        date_day = list(set([int(datetime.datetime.strptime(i[-1].split(':')[0],'%Y-%m-%d %H').strftime('%Y%m%d%H')) for i in datas]))
        date_day.sort()
        print(date_day)

        liuliang = []
        for i in date_day:
            record_list = da[da['获取日期'].map(
                lambda xx:int(datetime.datetime.strptime(xx.split(':')[0],'%Y-%m-%d %H').strftime('%Y%m%d%H')) == i )].values.tolist()
            liuliang.append(record_list[-1][3])

        # 数据集
        examDict = {
            '时间': date_day,
            '系数': liuliang
        }

        print(examDict)

        examOrderedDict = OrderedDict(examDict)
        examDf = pd.DataFrame(examOrderedDict)
        examDf.head()

        # exam_x 即为feature
        exam_x = examDf.loc[:, '时间']
        # exam_y 即为label
        exam_y = examDf.loc[:, '系数']

        x_train, x_test, y_train, y_test = train_test_split(exam_x, exam_y, train_size=0.5)

        x_train = x_train.values.reshape(-1, 1)
        x_test = x_test.values.reshape(-1, 1)

        model = LinearRegression()
        model.fit(x_train, y_train)

        LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1)
        # LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)   原始代码

        rDf = examDf.corr()
        model.score(x_test, y_test)

        data1 = datetime.datetime.strptime(str(date_day[-5]), '%Y%m%d%H')
        li1 = []
        for i in range(24):
            data1 = data1 + datetime.timedelta(hours=1)
            li1.append([int(data1.strftime('%Y%m%d%H'))])

        li2 = numpy.array(li1)

        y_train_pred = model.predict(li2)

        li2 = []
        for i in range(len(li1)):
            dicts = {}
            dicts['riqi'] = li1[i][0]
            dicts['xisu'] = round(abs(y_train_pred[i]),3)
            li2.append(dicts)
        return li2[2:]
    except:
        print(traceback.format_exc())
        return []

from prophet import Prophet
# from fbprophet import Prophet

import pandas as pd
def yuce2(name):
    sql_command = 'select * from Transportation'
    df = pd.read_sql(sql_command, models.db.engine)
    datas = df[df['城区'].map(lambda xx: xx == name)].values.tolist()
    dicts = {
        'ds': [],
        'y': [],
        'cap': [],
        'floor': []
    }
    for resu in datas:
        dicts['ds'].append(str(resu[-1].split(':')[0]))
        dicts['y'].append(int(resu[4])),
        dicts['cap'].append(60)
        dicts['floor'].append(0)

    df = pd.DataFrame.from_dict(dicts)
    print(df)

    # 拟合模型
    m = Prophet(growth='logistic')
    m.fit(df)

    # 构建待预测日期数据框，periods = 365 代表除历史数据的日期外再往后推 365 天
    future = m.make_future_dataframe(periods=15, freq='H')
    future['cap'] = 60

    future['floor'] = 0
    # 预测数据集
    forecast = m.predict(future)
    data = forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']]
    dicts = data.to_dict(orient="list")
    datas = []
    for i in range(len(dicts['ds'])):
        dicts1 = {}
        dicts1['yhat'] = round(dicts['yhat'][i], 1)
        dicts1['yhat_lower'] = dicts['yhat_lower'][i]
        dicts1['yhat_upper'] = dicts['yhat_upper'][i]
        dicts1['ds'] = dicts['ds'][i].strftime("%Y-%m-%d")
        datas.append(dicts1)
    datas = datas[-15:][::-1]
    return datas


@app.route('/login', methods=['GET', 'POST'])
def login():
    uuid = session.get('uuid')#如果已经登录则跳转到主页
    datas = models.User.query.get(uuid)
    if datas:
        return redirect(url_for('index'))
    if request.method=='GET':
        return render_template('account/index.html')
    elif request.method=='POST':
        user = request.form.get('user')
        password = request.form.get('password')
        data = models.User.query.filter(and_(models.User.name==user,models.User.pwd==password)).all()
        if not data:
            return render_template('account/index.html',error='账号密码错误')
        else:
            session['uuid'] = data[0].id   #账号密码正确，就把用户id记录到session里面
            session.permanent = True
            return redirect(url_for('index'))


@app.route('/loginout', methods=['GET'])
def loginout():
    if request.method == 'GET':
        session['uuid'] = ''#退出登录清楚记录
        session.permanent = False
        return redirect(url_for('login'))


@app.route('/signup', methods=['GET', 'POST'])
def signup():
    if request.method == 'GET':
        uuid = session.get('uuid')
        datas = models.User.query.get(uuid)
        if datas:
            return redirect(url_for('index'))
        return render_template('account/register.html')
    elif request.method == 'POST':
        user = request.form.get('user')
        email = request.form.get('email')
        password = request.form.get('password')
        if models.User.query.filter(models.User.name == user).all():
            return render_template('account/register.html', error='账号名已被注册')
        elif user == '' or password == '' or email == '':
            return render_template('account/register.html', error='输入不能为空')
        else:
            models.db.session.add(models.User(name=user, pwd=password,email=email))#注册用户信息
            models.db.session.commit()
            return redirect(url_for('login'))

if __name__ == '__main__':
    app.run(debug=True)

5、源码获取方式