基于Hadoop生态的汽车全生命周期数据分析与可视化平台-基于Python+Vue的二手车智能估价与市场分析系统

注意：该项目只展示部分功能，如需了解，文末咨询即可。

本文目录

1 开发环境
2 系统设计
3 系统展示
3.1 功能展示视频
3.2 大屏页面
3.3 分析页面
3.4 基础页面

4 更多推荐
5 部分功能代码

1 开发环境

发语言：python
采用技术：Spark、Hadoop、Django、Vue、Echarts等技术框架
数据库：MySQL
开发环境：PyCharm

2 系统设计

随着我国汽车保有量持续增长和消费观念转变，二手车市场呈现爆发式发展态势，但传统二手车交易普遍存在信息不对称、价格评估主观性强、市场数据分散等问题，消费者难以获得科学的购车指导，商家也缺乏精准的市场分析工具。特别是在新能源汽车快速普及的背景下，传统的二手车评估体系已无法满足市场需求，亟需构建基于大数据技术的智能分析系统。本系统的开发具有重要意义：对消费者而言，能够提供科学的价格评估、保值率分析和购车建议，显著降低交易风险和决策成本；对汽车经销商而言，可获得精准的市场趋势预测、热销车型分析和区域市场洞察，优化库存配置和定价策略；对金融机构而言，能够基于数据驱动的风险评估模型，提升二手车金融服务的效率和安全性；从宏观角度看，有助于推动二手车市场的标准化、透明化发展，促进汽车产业链的良性循环。

在研究内容方面，基于Hadoop生态的汽车全生命周期数据分析与可视化平台的功能模块层面则围绕四大核心分析维度展开：二手车市场宏观分析模块涵盖车辆级别分布、燃料类型构成、品牌保有量排行、车龄分布和里程分布分析；价格与保值率深度分析模块实现品牌保值率排行、车龄价格折损、里程价格折损以及多因素相关性分析；用户关注热点与地域特征分析模块提供全国城市车源分布、城市价格对比、热门车型排行和驱动方式偏好分析；新能源二手车专题分析模块专门针对纯电动、插电混动等新能源车型，分析其市场占比、品牌保值率、续航里程与价格关系及电池容量影响因素，通过多维度数据挖掘和智能分析，为二手车市场参与者提供全方位的数据驱动决策支持。

3 系统展示

3.1 功能展示视频

基于机器学习+spark大数据的汽车之家数据分析系统毕设源码！！！请点击这里查看功能演示！！！

3.2 大屏页面

在这里插入图片描述

3.3 分析页面

在这里插入图片描述

3.4 基础页面

在这里插入图片描述

5 部分功能代码

        # 初始化Spark Session - 大数据处理核心引擎
        self.spark = SparkSession.builder \
            .appName(self.spark_config["app_name"]) \
            .master(self.spark_config["master"]) \
            .config("spark.executor.memory", self.spark_config["executor_memory"]) \
            .config("spark.driver.memory", self.spark_config["driver_memory"]) \
            .config("spark.sql.adaptive.enabled", "true") \
            .config("spark.sql.adaptive.coalescePartitions.enabled", "true") \
            .getOrCreate()
            
        # 配置日志
        logging.basicConfig(level=logging.INFO, 
                          format='%(asctime)s - %(levelname)s - %(message)s')
        self.logger = logging.getLogger(__name__)
    
    def extract_data_from_mysql(self, table_name="used_car_data", limit=None):
        """
        从MySQL数据库提取二手车数据
        Args:
            table_name: 数据表名
            limit: 限制提取数据量，用于测试
        Returns:
            Spark DataFrame: 包含二手车基础数据的DataFrame
        """
        try:
            # 构建MySQL连接URL
            jdbc_url = f"jdbc:mysql://{self.mysql_config['host']}:{self.mysql_config['port']}/{self.mysql_config['database']}?useSSL=false&serverTimezone=UTC"
            
            # MySQL连接属性
            connection_properties = {
                "user": self.mysql_config["user"],
                "password": self.mysql_config["password"],
                "driver": "com.mysql.cj.jdbc.Driver"
            }
                        # 构建SQL查询语句，提取保值率分析所需的核心字段
            sql_query = f"""
            (SELECT 
                title,                    -- 车辆标题，用于提取品牌信息
                price,                   -- 二手车售价
                new_car_price_with_tax,  -- 新车含税价
                vehicle_age,             -- 车龄
                mileage,                 -- 表显里程
                location,                -- 所在地
                fuel_type,               -- 燃料类型
                vehicle_level,           -- 车辆级别
                listing_time             -- 上牌时间
            FROM {table_name} 
            WHERE price > 0 AND new_car_price_with_tax > 0 
            AND price <= new_car_price_with_tax
            {"LIMIT " + str(limit) if limit else ""}
            ) AS subquery
            """
                        # 使用Spark读取MySQL数据 - 大数据处理的第一步
            df = self.spark.read \
                .format("jdbc") \
                .option("url", jdbc_url) \
                .option("dbtable", sql_query) \
                .options(**connection_properties) \
                .load()
                        self.logger.info(f"成功从MySQL提取数据，记录数: {df.count()}")
            return df
                    except Exception as e:
            self.logger.error(f"数据提取失败: {str(e)}")
            raise
        def extract_brand_from_title(self, df):
        """
        从车辆标题中提取品牌信息
        使用正则表达式和预定义品牌库进行智能识别
        Args:
            df: 包含title字段的Spark DataFrame
        Returns:
            Spark DataFrame: 新增brand字段的DataFrame
        """
        # 定义主流汽车品牌词典 - 用于准确提取品牌信息
        brand_patterns = {
            '奔驰': r'奔驰|Mercedes|MERCEDES|梅赛德斯',
            '宝马': r'宝马|BMW|bmw',
            '奥迪': r'奥迪|Audi|AUDI',
            '大众': r'大众|Volkswagen|VW',
            '丰田': r'丰田|Toyota|TOYOTA',
            '本田': r'本田|Honda|HONDA',
            '日产': r'日产|Nissan|NISSAN',
            '现代': r'现代|Hyundai|HYUNDAI',
            '起亚': r'起亚|Kia|KIA',
            '福特': r'福特|Ford|FORD',
            '雪佛兰': r'雪佛兰|Chevrolet|CHEVROLET',
            '别克': r'别克|Buick|BUICK',
            '凯迪拉克': r'凯迪拉克|Cadillac|CADILLAC',
            '特斯拉': r'特斯拉|Tesla|TESLA',
            '比亚迪': r'比亚迪|BYD',
            '吉利': r'吉利|Geely|GEELY',
            '长城': r'长城|Great Wall|GREAT WALL|哈弗|WEY',
            '奇瑞': r'奇瑞|Chery|CHERY',
            '长安': r'长安|Changan|CHANGAN',
            '蔚来': r'蔚来|NIO',
            '理想': r'理想|Li Auto|LIXIANG',
            '小鹏': r'小鹏|XPeng|XPENG'
        }
                # 为每个品牌创建匹配条件
        brand_conditions = []
        for brand, pattern in brand_patterns.items():
            condition = when(col("title").rlike(pattern), brand)
            brand_conditions.append(condition)
        
        # 使用链式when-otherwise构建品牌提取逻辑
        brand_extract_expr = brand_conditions[0]
        for condition in brand_conditions[1:]:
            brand_extract_expr = brand_extract_expr.otherwise(condition)
        brand_extract_expr = brand_extract_expr.otherwise("其他")
        
        # 添加品牌字段到DataFrame
        df_with_brand = df.withColumn("brand", brand_extract_expr)
                self.logger.info("品牌信息提取完成")
        return df_with_brand
        def calculate_value_retention_rate(self, df):
        """
        计算品牌保值率 - 系统核心算法
        保值率 = (二手车价格 / 新车含税价) * 100%
        Args:
            df: 包含price和new_car_price_with_tax字段的DataFrame
        Returns:
            Spark DataFrame: 新增value_retention_rate字段的DataFrame
        """
        # 数据清洗：过滤异常数据
        df_cleaned = df.filter(
            (col("price") > 0) & 
            (col("new_car_price_with_tax") > 0) &
            (col("price") <= col("new_car_price_with_tax")) &  # 二手车价格不能超过新车价格
            (~isnan(col("price"))) & 
            (~isnan(col("new_car_price_with_tax"))) &
            (~isnull(col("price"))) & 
            (~isnull(col("new_car_price_with_tax")))
        )
                # 计算保值率 - 核心业务逻辑
        df_with_retention = df_cleaned.withColumn(
            "value_retention_rate",
            (col("price") / col("new_car_price_with_tax") * 100).cast(DoubleType())
        )
                # 过滤异常保值率数据（0-150%范围内）
        df_with_retention = df_with_retention.filter(
            (col("value_retention_rate") >= 0) & 
            (col("value_retention_rate") <= 150)
        )
                self.logger.info("保值率计算完成")
        return df_with_retention
        def analyze_brand_value_retention(self, df, min_sample_size=50):
        """
        分析各品牌保值率表现 - 生成核心分析报告
        Args:
            df: 包含品牌和保值率数据的DataFrame
            min_sample_size: 最小样本量要求，确保统计结果的可靠性
        Returns:
            List[Dict]: 品牌保值率分析结果列表
        """
        # 按品牌分组，计算保值率统计指标
        brand_stats = df.groupBy("brand").agg(
            avg("value_retention_rate").alias("avg_retention_rate"),  # 平均保值率
            count("*").alias("sample_count"),                         # 样本数量
            avg("price").alias("avg_price"),                          # 平均售价
            avg("new_car_price_with_tax").alias("avg_new_car_price"), # 平均新车价格
            avg("vehicle_age").alias("avg_vehicle_age"),              # 平均车龄
            avg("mileage").alias("avg_mileage")                       # 平均里程
        )
                # 过滤样本量不足的品牌，确保分析结果的统计显著性
        brand_stats_filtered = brand_stats.filter(
            col("sample_count") >= min_sample_size
        )
                # 按平均保值率降序排列
        brand_stats_sorted = brand_stats_filtered.orderBy(
            col("avg_retention_rate").desc()
        )
                # 收集结果到Driver端进行后续处理
        results = brand_stats_sorted.collect()
                # 构建分析结果数据结构
        analysis_results = []
        for row in results:
            result = {
                'brand': row['brand'],
                'avg_retention_rate': round(row['avg_retention_rate'], 2),
                'sample_count': row['sample_count'],
                'avg_price': round(row['avg_price'], 2),
                'avg_new_car_price': round(row['avg_new_car_price'], 2),
                'avg_vehicle_age': round(row['avg_vehicle_age'], 2),
                'avg_mileage': round(row['avg_mileage'], 2),
                'retention_level': self._get_retention_level(row['avg_retention_rate'])
            }
            analysis_results.append(result)
        
        self.logger.info(f"品牌保值率分析完成，共分析{len(analysis_results)}个品牌")
        return analysis_results
        def _get_retention_level(self, retention_rate):
        """
        根据保值率数值划分保值等级
        Args:
            retention_rate: 保值率百分比
        Returns:
            str: 保值等级描述
        """
        if retention_rate >= 70:
            return "优秀"
        elif retention_rate >= 60:
            return "良好"
        elif retention_rate >= 50:
            return "一般"
        elif retention_rate >= 40:
            return "较差"
        else:
            return "很差"
    
    def save_analysis_results(self, results, output_table="brand_retention_analysis"):
        """
        将分析结果保存到MySQL数据库
        Args:
            results: 分析结果列表
            output_table: 输出表名
        """
        try:
            # 建立MySQL连接
            connection = pymysql.connect(
                host=self.mysql_config['host'],
                port=self.mysql_config['port'],
                user=self.mysql_config['user'],
                password=self.mysql_config['password'],
                database=self.mysql_config['database'],
                charset='utf8mb4'
            )
            
            with connection.cursor() as cursor:
                # 创建结果表（如果不存在）
                create_table_sql = f"""
                CREATE TABLE IF NOT EXISTS {output_table} (
                    id INT AUTO_INCREMENT PRIMARY KEY,
                    brand VARCHAR(50) NOT NULL,
                    avg_retention_rate DECIMAL(5,2) NOT NULL,
                    sample_count INT NOT NULL,
                    avg_price DECIMAL(10,2),
                    avg_new_car_price DECIMAL(10,2),
                    avg_vehicle_age DECIMAL(4,2),
                    avg_mileage DECIMAL(10,2),
                    retention_level VARCHAR(10),
                    analysis_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    INDEX idx_brand (brand),
                    INDEX idx_retention_rate (avg_retention_rate DESC)
                ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
                """
                cursor.execute(create_table_sql)
                
                # 清空旧数据
                cursor.execute(f"TRUNCATE TABLE {output_table}")
                
                # 插入新的分析结果
                insert_sql = f"""
                INSERT INTO {output_table} 
                (brand, avg_retention_rate, sample_count, avg_price, 
                 avg_new_car_price, avg_vehicle_age, avg_mileage, retention_level)
                VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
                """
                
                for result in results:
                    cursor.execute(insert_sql, (
                        result['brand'],
                        result['avg_retention_rate'],
                        result['sample_count'],
                        result['avg_price'],
                        result['avg_new_car_price'],
                        result['avg_vehicle_age'],
                        result['avg_mileage'],
                        result['retention_level']
                    ))
                
                connection.commit()
                self.logger.info(f"分析结果已保存到表 {output_table}")
                
        except Exception as e:
            self.logger.error(f"保存分析结果失败: {str(e)}")
            raise
        finally:
            connection.close()
    
    def run_analysis(self, table_name="used_car_data", min_sample_size=50):
        """
        执行完整的品牌保值率分析流程 - 主入口函数
        Args:
            table_name: 源数据表名
            min_sample_size: 最小样本量要求
        Returns:
            List[Dict]: 分析结果
        """
        try:
            self.logger.info("开始执行品牌保值率分析...")
            
            # 步骤1: 从MySQL提取数据
            df = self.extract_data_from_mysql(table_name)
            
            # 步骤2: 提取品牌信息
            df_with_brand = self.extract_brand_from_title(df)
            
            # 步骤3: 计算保值率
            df_with_retention = self.calculate_value_retention_rate(df_with_brand)
            
            # 步骤4: 分析品牌保值率表现
            analysis_results = self.analyze_brand_value_retention(
                df_with_retention, 
                min_sample_size
            )
                        # 步骤5: 保存分析结果
            self.save_analysis_results(analysis_results)
            
            self.logger.info("品牌保值率分析完成!")
            return analysis_results
            
        except Exception as e:
            self.logger.error(f"分析执行失败: {str(e)}")
            raise
        finally:
            # 清理Spark资源
            self.spark.stop()
# 使用示例和配置
if __name__ == "__main__":
    # MySQL数据库配置
    mysql_config = {
        "host": "localhost",
        "port": 3306,
        "user": "your_username",
        "password": "your_password",
        "database": "car_home_db"
    }
    
    # Spark配置（可选）
    spark_config = {
        "app_name": "CarHomeBrandRetentionAnalyzer",
        "master": "local[4]",  # 使用4个CPU核心
        "executor_memory": "4g",
        "driver_memory": "2g"
    }
    
    # 创建分析器实例并运行分析
    analyzer = BrandValueRetentionAnalyzer(mysql_config, spark_config)
    
    # 执行分析（最少50个样本）
    results = analyzer.run_analysis(
        table_name="used_car_data", 
        min_sample_size=50
    )
        # 打印前10个品牌的保值率排行
    print("=== 品牌保值率排行榜 ===")
    for i, result in enumerate(results[:10], 1):
        print(f"{i:2d}. {result['brand']:8s} "
              f"保值率: {result['avg_retention_rate']:5.2f}% "
              f"样本数: {result['sample_count']:4d} "
              f"等级: {result['retention_level']}")