PySpark实战：从数据清洗到机器学习的完整流程

发现科技2026-01-13 11:45

引言：大数据时代的挑战与PySpark的崛起

在当今数据爆炸的时代，处理海量数据已成为常态。无论是日志分析、用户行为建模还是物联网数据处理，传统单机的数据处理工具（如Pandas）往往力不从心，很容易遇到内存溢出、处理速度慢等瓶颈。想象一下，当你的数据集达到TB级别时，一个简单的df.groupby().sum()操作可能就会让你的机器"窒息"。

痛点示例：Pandas处理大数据面临的困境

python 复制代码 
import pandas as pd
import numpy as np
import time

# 模拟一个非常大的数据集
num_rows = 5_000_000  # 5百万行数据，在中等配置机器上可能导致内存问题
data = {
    'user_id': np.random.randint(1, 100_000, num_rows),
    'item_id': np.random.randint(1, 50_000, num_rows),
    'price': np.random.rand(num_rows) * 100,
    'quantity': np.random.randint(1, 10, num_rows)
}

# 尝试用Pandas加载并聚合
print("尝试使用Pandas加载并处理大数据...")
start_time = time.time()
try:
    # 这行代码在内存不足时可能会直接崩溃或运行极慢
    df_pandas = pd.DataFrame(data)
    # 假设我们想计算每个user_id的总消费
    # total_consumption = df_pandas.groupby('user_id')['price'].sum()
    print("Pandas数据加载完成，如果内存足够，可以继续处理...")
    # print(total_consumption.head())
except MemoryError:
    print(" Pandas处理大数据时发生内存错误！")
except Exception as e:
    print(f" Pandas处理大数据时发生其他错误：{e}")

end_time = time.time()
print(f"Pandas尝试加载耗时: {end_time - start_time:.2f} 秒")

# 提示：实际运行上述代码时，如果 num_rows 过大，建议注释掉df_pandas = pd.DataFrame(data)这一行，
# 或者减小 num_rows 以避免系统卡死。PySpark正是为了解决这种问题而生。

面对这种挑战，我们需要一个能够分布式处理数据的强大工具------Apache Spark。而PySpark，作为Spark的Python API，完美结合了Python的易用性和Spark的强大分布式计算能力，成为了数据科学家和工程师在大数据领域不可或缺的利器。它允许我们用熟悉的Python语言，优雅地处理PB级别的数据，执行复杂的数据转换、分析乃至机器学习任务。

本文将带你深入PySpark的实战世界，从环境搭建到数据清洗，再到复杂的机器学习流程，手把手教你构建一个完整的PySpark大数据处理应用。让我们一起踏上PySpark的探索之旅吧！

PySpark基础：环境搭建与核心概念

在开始PySpark开发之前，我们需要了解其核心概念并搭建好开发环境。PySpark的强大之处在于其能够将Python代码转换为底层的Spark操作，并在集群上并行执行。

1.1 环境准备：安装与SparkSession

首先，确保你的环境中安装了Java (Spark运行需要JVM)、Python以及pyspark库。最简单的方式是使用pip安装。为了在非Spark发行版安装路径下也能找到Spark，通常会用到findspark库。

bash 复制代码 
# 检查Java环境：java -version
# 如果没有安装，请安装OpenJDK或其他Java运行时环境
# pip install pyspark findspark

SparkSession是PySpark的入口点，用于与Spark集群进行交互。它是Spark 2.0及以后版本推荐的API，集成了SparkContext、SQLContext等功能。

python 复制代码 
# basic_setup.py
from pyspark.sql import SparkSession
import findspark
import os

# 初始化findspark，使得PySpark可以在非Spark发行版安装路径下找到Spark
# 如果你已经配置了SPARK_HOME环境变量，可以省略此行或根据实际情况调整
# 或者手动设置SPARK_HOME，例如：os.environ['SPARK_HOME'] = '/opt/spark'
try:
    findspark.init()
    print("findspark 初始化成功。")
except Exception as e:
    print(f"findspark 初始化失败：{e}，请确保SPARK_HOME环境变量已设置或Spark已安装。")

# 构建SparkSession
# .appName("PySparkBasicApp")：设置应用名称，在Spark UI中显示
# .master("local[*]")：设置Spark运行模式为本地模式，使用所有可用CPU核心
# .config("spark.executor.memory", "2g")：为Executor设置内存，根据实际需求调整
# .getOrCreate()：如果存在SparkSession则返回，否则创建新的
spark = SparkSession.builder \
    .appName("PySpark数据处理实战") \
    .master("local[*]") \
    .config("spark.executor.memory", "2g") \
    .config("spark.driver.memory", "4g") \ # 为Driver设置内存，防止本地模式下内存溢出
    .getOrCreate()

print("SparkSession 初始化成功！")
# 查看当前SparkContext
print(f"SparkContext: {spark.sparkContext}")
print(f"Spark版本: {spark.version}")

# 停止SparkSession (在脚本末尾或不再需要时调用)
# spark.stop()

1.2 PySpark核心：DataFrame与操作

DataFrame是PySpark中最常用的数据抽象，它是一个由具名列组成的分布式数据集，概念上类似于关系型数据库中的表，或者Pandas的DataFrame，但它能够在集群上进行大规模并行处理。它提供了丰富的API，支持SQL查询、数据过滤、聚合等操作。

让我们通过创建和操作一个简单的DataFrame来理解它的基本用法。

less 复制代码 
# dataframe_basics.py
from pyspark.sql import SparkSession
from pyspark.sql.functions import col, when
from pyspark.sql.types import StructType, StructField, StringType, IntegerType

# 假设我们已经有了一个名为spark的SparkSession实例
# spark = SparkSession.builder.appName("DFDemo").master("local[*]").getOrCreate()

# 1. 从Python列表创建DataFrame
data = [
    ("Alice", 1, 85),
    ("Bob", 2, 92),
    ("Charlie", 1, 78),
    ("David", 3, 95),
    ("Eve", 2, 88)
]
columns = ["name", "class_id", "score"]

df = spark.createDataFrame(data, columns)

print("原始DataFrame (df.show()):")
df.show()

print("DataFrame Schema (df.printSchema()):")
df.printSchema()

# 2. 基本操作：选择列、过滤行、添加新列
# 选择特定的列，类似于SQL的 SELECT name, score FROM table
selected_df = df.select("name", "score")
print("选择 'name' 和 'score' 列 (df.select()):")
selected_df.show()

# 过滤 score > 90 的行，类似于SQL的 WHERE score > 90
filtered_df = df.filter(col("score") > 90)
print("过滤 score > 90 的行 (df.filter()):")
filtered_df.show()

# 添加一个新列 'grade'，类似于SQL的 CASE WHEN ... THEN ... ELSE ... END
# 当 score >= 90 时为 'A'，否则为 'B'
graded_df = df.withColumn("grade", 
                        when(col("score") >= 90, "A").otherwise("B"))
print("添加 'grade' 列 (df.withColumn() + when()):")
graded_df.show()

# 3. 统计描述
print("DataFrame统计描述 (df.describe()):")
df.describe().show()

# 可以使用SQL语句查询DataFrame
# 将DataFrame注册为一个临时视图
df.createOrReplaceTempView("students")
print("使用SQL查询DataFrame:")
spark.sql("SELECT name, score FROM students WHERE class_id = 1").show()

# 停止SparkSession
spark.stop()

代码解析 ：

* spark.createDataFrame() 可以方便地从Python集合创建DataFrame。在生产环境中，通常会从文件系统（HDFS, S3）或数据库加载数据。

* df.show() 用于查看DataFrame的前几行数据，默认显示20行，可以传入参数调整。

* df.printSchema() 展示DataFrame的结构和数据类型，非常有助于理解数据。

* df.select() 用于选择列，df.filter() 用于过滤行，类似于SQL的WHERE子句。

* df.withColumn() 可以在不改变原始DataFrame的情况下，添加或修改列。when().otherwise() 提供了条件判断逻辑。

* df.describe() 提供了数值型列的统计摘要，如计数、均值、标准差、最小值、最大值等。

* createOrReplaceTempView() 可以将DataFrame注册为临时表，然后使用spark.sql()执行SQL查询。

数据清洗与转换：DataFrame的强大魔力

真实世界的数据往往是"脏乱差"的，包含缺失值、异常值、不一致的格式等。PySpark DataFrame提供了丰富的API来高效地进行数据清洗和转换。这一步是任何数据分析或机器学习项目的基础。

2.1 缺失值处理

缺失值是数据清洗中最常见的问题之一。PySpark提供了灵活的方式来处理它们，包括填充（fill）和删除（drop）。

scss 复制代码 
# missing_data_handling.py
from pyspark.sql import SparkSession
from pyspark.sql.functions import mean, col

# spark = SparkSession.builder.appName("MissingData").master("local[*]").getOrCreate()

# 模拟包含缺失值的原始数据
data_with_nulls = [    ("ProductA", 100, None, "Category1"),    ("ProductB", None, 25.5, "Category2"),    ("ProductC", 150, 30.0, None),    ("ProductD", 120, 20.0, "Category1"),    ("ProductE", None, None, "Category2")]
columns_with_nulls = ["product_name", "quantity", "price", "category"]
df_nulls = spark.createDataFrame(data_with_nulls, columns_with_nulls)

print("--- 原始 DataFrame (包含缺失值) ---")
df_nulls.show()
df_nulls.printSchema()

# 1. 删除含有任何缺失值的行 (df.na.drop())
df_dropped = df_nulls.na.drop()
print("--- 删除含有任何缺失值的行后 ---")
df_dropped.show()

# 2. 删除 'quantity' 列中含有缺失值的行 (df.na.drop(subset=...))
df_dropped_quantity = df_nulls.na.drop(subset=["quantity"])
print("--- 删除 'quantity' 列中含有缺失值的行后 ---")
df_dropped_quantity.show()

# 3. 填充缺失值 (df.na.fill())
# 3.1 填充所有数值型缺失值为0
df_filled_zero = df_nulls.na.fill(0)
print("--- 填充所有数值型缺失值为0后 ---")
df_filled_zero.show()

# 3.2 填充特定列的缺失值，例如 'quantity' 列用均值，'category' 列用 'Unknown'
# 获取 'quantity' 列的均值，注意 collect()[0][0] 用于获取结果
mean_quantity = df_nulls.agg(mean(col("quantity"))).collect()[0][0]
# 对于 category 列，我们填充 'Unknown'

print(f"'quantity' 列的均值: {mean_quantity:.2f}")

df_filled_specific = df_nulls.na.fill({"quantity": mean_quantity, "category": "Unknown"})
print("--- 填充特定列缺失值 ('quantity' 均值, 'category'为'Unknown')后 ---")
df_filled_specific.show()

# spark.stop()

2.2 数据类型转换与字符串操作

确保数据类型正确是后续计算的基础。同时，对字符串进行格式化、提取信息也是常见的清洗步骤。

python 复制代码 
# data_type_string_ops.py
from pyspark.sql import SparkSession
from pyspark.sql.functions import col, lit, regexp_replace, trim, upper
from pyspark.sql.types import IntegerType, DateType

# spark = SparkSession.builder.appName("TypeStringOps").master("local[*]").getOrCreate()

data_raw = [
    ("  Apple Inc.  ", "123", "2023-01-01"),
    ("  Google LLC  ", "456", "2023/02/15"),
    ("Microsoft", "abc", "2023-03-20") # 'abc' 是无效数值，转换时会变为 None
]
columns_raw = ["company_name_raw", "employee_count_str", "order_date_str"]
df_raw = spark.createDataFrame(data_raw, columns_raw)

print("--- 原始 DataFrame ---")
df_raw.show(truncate=False)
df_raw.printSchema()

# 1. 数据类型转换：将 employee_count_str 转换为 IntegerType
# 注意：如果转换失败（如'abc'），默认会变为None
df_casted = df_raw.withColumn(
    "employee_count", col("employee_count_str").cast(IntegerType())
)
print("--- 转换 'employee_count_str' 为整数后 ---")
df_casted.show()

# 2. 字符串清理：去除 company_name_raw 的首尾空格，并转为大写
# trim() 函数用于去除字符串两侧的空格
# upper() 函数用于将字符串转为大写
df_cleaned_str = df_casted.withColumn(
    "company_name", upper(trim(col("company_name_raw")))
)
print("--- 清理 'company_name_raw' 字符串后 ---")
df_cleaned_str.show(truncate=False)

# 3. 统一日期格式：将 '2023/02/15' 转换为 '2023-02-15'，并转换为DateType
# 使用 regexp_replace 统一日期分隔符，然后 cast 为 DateType
# 注意：正则表达式中 '/' 需要转义，所以是 '\/'
df_date_formatted = df_cleaned_str.withColumn(
    "order_date", 
    regexp_replace(col("order_date_str"), "\/", "-").cast(DateType())
)
print("--- 统一日期格式并转换为 DateType 后 ---")
df_date_formatted.show()
df_date_formatted.printSchema()

# spark.stop()

2.3 用户自定义函数 (UDF) 与内置函数对比

当PySpark内置函数无法满足复杂业务逻辑时，我们可以使用UDF。但需要注意的是，UDF会带来性能开销，应优先使用内置函数。

不推荐写法：UDF处理简单字符串逻辑 (性能开销大)

python 复制代码 
# udf_vs_builtin_bad.py
from pyspark.sql import SparkSession
from pyspark.sql.functions import udf, col
from pyspark.sql.types import StringType
import time

# spark = SparkSession.builder.appName("UDFvsBuiltin").master("local[*]").getOrCreate()

# 模拟一个较大的DataFrame，100万行
data_large = [("  product_a_with_id_123  ",) for _ in range(1_000_000)]
df_large = spark.createDataFrame(data_large, ["product_name_raw"])

# 不推荐：使用UDF来清理字符串 (例如：去除空格并转大写，并提取ID)
def clean_string_udf(s):
    if s: 
        cleaned_s = s.strip().upper()
        # 假设我们还要提取ID
        import re
        match = re.search(r'_ID_(\d+)', cleaned_s)
        if match:
            return f"{cleaned_s}-{match.group(1)}"
        return cleaned_s
    return None

# 必须指定UDF的返回类型，否则性能会更差
clean_string_pyspark_udf = udf(clean_string_udf, StringType())

print("--- 使用 UDF 进行字符串清理 (不推荐，性能开销大) ---")
start_time_udf = time.time()
df_udf_cleaned = df_large.withColumn(
    "product_name_udf", clean_string_pyspark_udf(col("product_name_raw"))
)
df_udf_cleaned.count() # 触发计算，因为Spark是惰性执行的
end_time_udf = time.time()
print(f"UDF 处理 100万行数据耗时: {end_time_udf - start_time_udf:.4f} 秒")
# df_udf_cleaned.show(5, truncate=False)

# spark.stop()

推荐写法：使用内置函数处理相同逻辑 (性能更优)

python 复制代码 
# udf_vs_builtin_good.py
from pyspark.sql import SparkSession
from pyspark.sql.functions import col, trim, upper, regexp_extract, concat_ws, lit
import time

# spark = SparkSession.builder.appName("UDFvsBuiltin").master("local[*]").getOrCreate()

# 沿用上面创建的 df_large
# data_large = [("  product_a_with_id_123  ",) for _ in range(1_000_000)]
# df_large = spark.createDataFrame(data_large, ["product_name_raw"])

print("--- 使用内置函数进行字符串清理 (推荐，性能更优) ---")
start_time_builtin = time.time()

# 使用内置函数实现相同的逻辑
df_builtin_cleaned = df_large.withColumn(
    "cleaned_product_name", upper(trim(col("product_name_raw")))
).withColumn(
    "extracted_id", regexp_extract(col("cleaned_product_name"), r'_ID_(\d+)', 1)
).withColumn(
    "product_name_builtin", 
    when(col("extracted_id") != "", concat_ws("-", col("cleaned_product_name"), col("extracted_id")))
    .otherwise(col("cleaned_product_name"))
)

df_builtin_cleaned.count() # 触发计算
end_time_builtin = time.time()
print(f"内置函数处理 100万行数据耗时: {end_time_builtin - start_time_builtin:.4f} 秒")
# df_builtin_cleaned.show(5, truncate=False)

# 性能对比：通常内置函数会快很多，因为它是在JVM层面优化的。
# UDF会涉及到数据的序列化/反序列化和Python进程与JVM进程之间的通信开销，效率远低于内置函数。

spark.stop()

最佳实践清单 ：

* 优先使用内置函数 ：pyspark.sql.functions中的函数通常比UDF性能更优，因为它们直接在JVM上运行，避免了Python和JVM之间的切换开销。

* UDF只在必要时使用 ：当内置函数无法实现复杂业务逻辑，且性能要求不高时，再考虑UDF。

* 指定UDF返回类型 ：定义UDF时务必指定returnType，避免Spark进行类型推断，这会增加一次数据扫描，影响性能。

* 避免在UDF内部访问外部变量 ：这可能导致序列化问题或不一致的行为，建议将所需参数通过闭包或广播变量传入。

* 使用Pandas UDF (Vectorized UDF) ：对于某些场景，Pandas UDF可以在Apache Arrow的帮助下，实现高效的向量化操作，减少序列化开销，性能介于传统UDF和内置函数之间。它适用于对Pandas DataFrame或Series进行操作的函数。

数据聚合与分析：洞察数据价值

数据清洗之后，下一步就是对数据进行聚合、分组和分析，从中提取有价值的洞察。PySpark DataFrame提供了强大的SQL-like操作，让这一切变得简单高效。

3.1 分组聚合：groupBy与agg

groupBy()操作将DataFrame按照一个或多个列进行分组，然后可以结合agg()函数对每个组执行聚合操作，如计数、求和、平均值等。

python 复制代码 
# groupby_agg.py
from pyspark.sql import SparkSession
from pyspark.sql.functions import col, count, sum, avg, max, min

# spark = SparkSession.builder.appName("AggAnalysis").master("local[*]").getOrCreate()

data_sales = [
    ("StoreA", "ProductX", 10, 100.0),
    ("StoreA", "ProductY", 5, 150.0),
    ("StoreB", "ProductX", 12, 120.0),
    ("StoreB", "ProductZ", 8, 80.0),
    ("StoreA", "ProductX", 7, 70.0),
    ("StoreC", "ProductY", 3, 90.0),
    ("StoreC", "ProductZ", 15, 150.0)
]
columns_sales = ["store_id", "product_id", "quantity", "revenue"]
df_sales = spark.createDataFrame(data_sales, columns_sales)

print("--- 原始销售数据 DataFrame ---")
df_sales.show()

# 1. 计算每个商店的总销量和总收入 (groupBy + agg)
store_summary_df = df_sales.groupBy("store_id").agg(
    sum("quantity").alias("total_quantity_sold"),
    sum("revenue").alias("total_revenue")
)
print("--- 按商店汇总销量和收入 ---")
store_summary_df.show()

# 2. 计算每个商店每个产品的平均价格和销售次数
product_store_summary_df = df_sales.groupBy("store_id", "product_id").agg(
    avg(col("revenue") / col("quantity")).alias("average_price_per_unit"), # 计算每件商品的平均价格
    count("*").alias("transaction_count"), # 统计交易次数
    max("quantity").alias("max_single_sale_quantity") # 统计单次销售的最大数量
)
print("--- 按商店和产品汇总平均价格和销售次数 ---")
product_store_summary_df.show()

# spark.stop()

3.2 窗口函数：实现复杂排名与聚合

窗口函数允许我们对数据集的某个"窗口"进行计算，而不是整个数据集。这在需要进行排名、移动平均、同比/环比分析等场景中非常有用。

python 复制代码 
# window_functions.py

from pyspark.sql import SparkSession  
from pyspark.sql.functions import col, row_number, rank, lag, lead, sum as window_sum  
from pyspark.sql.window import Window

# spark = SparkSession.builder.appName("WindowFuncs").master("local[*]").getOrCreate()

data_scores = [  
("Alice", "Math", 90),  
("Bob", "Math", 85),  
("Charlie", "Math", 92),  
("Alice", "Science", 95),  
("Bob", "Science", 88),  
("Charlie", "Science", 80),  
("David", "Math", 88)  
]  
columns_scores = ["student_name", "subject", "score"]  
df_scores = spark.createDataFrame(data_scores, columns_scores)

print("--- 原始学生分数数据 DataFrame ---")  
df_scores.show()

# 1. 按照学科对学生进行排名 (score降序)

# 定义窗口规范：按 subject 分区 (partitionBy)，按 score 降序排序 (orderBy)

window_spec_rank = Window.partitionBy("subject").orderBy(col("score").desc())

df_ranked = df_scores.withColumn(  
"rank_in_subject", rank().over(window_spec_rank) # 相同分数会有相同排名，跳过下一个排名  
).withColumn(  
"row_number_in_subject", row_number().over(window_spec_rank) # 相同分数也有不同排名  
)\
相关推荐
前端阿森纳1 个月前
AI产品经理的核心竞争力：在技术、用户与商业的交叉点上创造价值
产品经理·产品·资讯
前端阿森纳1 个月前
七大产品设计方法论：构建卓越软件产品的思维工具箱
产品经理·产品·资讯
隐语SecretFlow1 个月前
如何在 Kuscia 中使用自定义镜像仓库
开源·资讯
算家计算1 个月前
解禁H200却留有后手！美国这波“卖芯片”，是让步还是埋坑？
人工智能·资讯
隐语SecretFlow1 个月前
如何在 Kuscia 中升级引擎镜像？
开源·资讯
NocoBase1 个月前
GitHub Star 数量前 5 的开源 AI 内部工具
低代码·开源·资讯
隐语SecretFlow1 个月前
Kusica如何多机部署中心化进群【隐语Secretflow】
开源·资讯
热门推荐
01GitHub 镜像站点02Labelme从安装到标注：零基础完整指南03网站改了域名，如何查找？04Linux下V2Ray安装配置指南05安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）06【踩坑笔记】50系显卡适配的 PyTorch 安装072025-04-03 Latex学习1——本地配置Latex + VScode环境08Claude Code 2.1.2 升级报错？别折腾了，一行命令搞定09CentOS的ISO镜像下载10KGG转MP3工具|非KGM文件|解密音频