spark 两个dataFrame之间join 空值操作

最新推荐文章于 2024-10-13 21:07:53 发布
原创 最新推荐文章于 2024-10-13 21:07:53 发布 · 3.2k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文探讨了在Spark中如何处理DataFrame join时遇到的空值问题。通过示例展示了使用默认join操作会过滤掉含有空值的记录，而通过特定符号可以包含空值进行join。作者还提供了一个自定义方法来简化这种操作，并邀请读者分享更优的解决方案。

spark Join空值操作

开门见山
  1. 准备数据:
    val struct1: StructType = StructType(Seq(
      StructField("id", IntegerType, true),
      StructField("name", StringType, true),
      StructField("age", StringType, true)
    ))

    val javaRows: util.List[Row] = List[Row](
      Row(1, "zhangsan", "18"),
      Row(1, null, "19"),
      Row(2, "wangwu", "24"),
      Row(4, "maliu", "16")
    ).asJava


    val struct2: StructType = StructType(Seq(
      StructField("id", IntegerType, true),
      StructField("name", StringType, true),
      StructField("english", StringType, true)
    ))

    val javaRows1: util.List[Row] = List[Row](
      Row(1, "xiaohong", "64"),
      Row(1, null, "56"),
      Row(3, "xiaomin", "65"),
      Row(4, null, "83")
    ).asJava

    val df1: DataFrame = spark.createDataFrame(javaRows, struct1)
    val df2: DataFrame = spark.createDataFrame(javaRows1, struct2)
最低0.47元/天 解锁文章
Spark SQL | DataFrame的各种玩法
weixin_43646592的博客
06-28 1083
Spark SQL | DataFrame的各种玩法
处理Spark DataFrame中的空值：一个实例详解
最新发布
m0_62153576的博客
09-09 26
摘要：本文探讨了在Spark DataFrame中处理NULL值的两种方法。当需要将数组列中的NULL海拔值替换为占位符"*"时，可通过Spark SQL的IFNULL函数或PySpark API的when().otherwise()实现。前者使用SQL表达式ifnull(round(x.altitude),'*')，后者通过Python函数链式调用处理空值。两种方案功能等效，开发者可根据代码风格选择使用运行时解析的SQL字符串或原生Python API，最终确保数据转换的完整性和一致性
SparkSQ操作DataFrame，合并DataFrame
05-30
例子中定义了多个List数据集合，包括用户信息，订单信息，用户订单信息，将List对象生成DataFrame，使用SparkSQL查询将多个DataFrame合成一个DataFrame,使用Scala语言编写。
PySpark中DataFrame的join操作
数据科学知识库
12-20 1933
常见的类型有 “inner”, “outer”, “left_outer”, “right_outer”, “leftsemi”。在进行 JOIN 操作时，如果两个 DataFrame 有相同的列名，可能需要使用别名（alias）来避免列名冲突。on 参数是一个字符串（单列名）或一个列表（多列名）或一个表达式，指定了合并的基准。包含左边 DataFrame 的所有行，以及与右边 DataFrame 匹配的行。包含右边 DataFrame 的所有行，以及与左边 DataFrame 匹配的行。
使用pandas对两个dataframe进行join的实例
09-20
今天小编就为大家分享一篇使用pandas对两个dataframe进行join的实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Spark 之 dataframe 之 join
weixin_36630761的博客
07-19 3264
Spark DataFrame中join与SQL很像，都有inner join, left join, right join, full join; 那么join方法如何实现不同的join类型呢？ 看其原型 def join(right : DataFrame, usingColumns : Seq[String], joinType : String) : DataFrame
9、Spark DataFrame理解和使用之两个DataFrame复杂高级的JOIN
Toby的博客
04-01 2742
复杂高级type的join操作 1、只要能返回布尔型结果(True/False)的判断表达式，都可以作为JOIN的关联表达式 2、关联操作后的结果表中处理重复列名的三种方法 3、spark做JOIN时两个表/DF的通讯机制，三种情况 一、只要能返回布尔型结果(True/False)的判断表达式expr，都可以作为JOIN的关联表达式 1、array_contains()函数，两个DF没有两列能使用明确的相等=条件来判断，但是能发现两列有包含的关系 //in scala, 使用array_.
Spark：DataFrame介绍及使用
m0_70882914的博客
10-13 1618
DataFrame介绍及使用
Spark SQL DataFrame 算子
2401_84052244的博客
07-31 3473
DataFrame 算子与 SQL 查询语句之间，并没有优劣之分，他们可以实现同样的数据应用，而且在执行性能方面也是一致的。因此，你可以结合你的开发习惯与偏好，自由地在两者之间进行取舍。DataFrame 本身支持的算子之外，在功能上，SQL 完全可以实现同样的数据分析。给定 DataFrame，你只需通过 createTempView 或是 createGlobalTempView 来创建临时表，然后就可以通过写 SQL 语句去进行数据的探索、倾斜、转换与分析。
Spark DataFrame中的join使用
热门推荐
麋鹿麋鹿迷了路
07-02 1万+
Spark DataFrame中join与SQL很像，都有inner join, left join, right join, full join; 那么join方法如何实现不同的join类型呢？ 看其原型 def join(right : DataFrame, usingColumns : Seq[String], joinType : String) : DataFrame def join(...
使用pandas对两个dataframe进行join
ciliting2867的博客
05-05 711
需求: 两个文件，一个文件为统计报表，里面含有手机号，另一个文件为手机号段归属地，含有手机号码前七位对应的地区。需要对统计报表进行处理，将手机号所在的归属地加入到统计报表中，使用pandas提供的join功能来实现，代...
Pyspark下DataFrame的JOIN操作详解
xdx_dili的博客
09-26 1126
Pyspark下DataFrame的JOIN操作详解——Cross join、Inner join、left join、right join、Full outer join、Left semi-join和Left anti join
Apache Spark DataFrames入门指南：操作DataFrame
u011007180的博客
07-17 7099
本系列文章翻译自：《scala data analysis cookbook》第二章：Getting Started with Apache Spark DataFrames。原书是基于Spark 1.4.1编写的，我这里使用的是Spark 1.6.0，丢弃了一些已经标记为遗弃的函数。并且修正了其中的错误。 　　一、从csv文件创建DataFrame 　　　　如何做？ 　　　　如何工作的
Apache Spark Dataframe Join语法教程
kwame211的博客
04-24 757
始终考虑将RDD转换为Dataframe数据帧，执行请求的操作并保存结果......这是节省时间最多的方法。那么让我们深入研究Dataframe数据帧测试 数据workers： 1,Jerry,man,USA 2,Cathy,female,GBR 3,Teresa,female,GBR 4,Rut,female,USA 5,Roasie,female,A...
Spark SQL/DataFrame/DataSet操作（四）-----Join
微步的博客
09-06 2551
数据准备，先构建两个DataFrame scala> val df1 = spark.createDataset(Seq(("a", 1,2), ("b",2,3) )).toDF("k1","k2","k3") df1: org.apache.spark.sql.DataFrame = [k1: string, k2: int ... 1 more field] scala&g
Spark DataFrame的Join操作和withColumn、withColumnRenamed方法实践案例（Scala Demo代码）
programmer589的博客
07-29 810
Spark DataFrame的Join操作和withColumn、withColumnRenamed方法实践案例（Scala Demo代码）
Spark DataFrame中的join使用说明
weixin_30764883的博客
01-10 1106
spark sql 中join的类型 Spark DataFrame中join与SQL很像，都有inner join, left join, right join, full join; 类型 说明 inner join 内连接 left join 左连接 right join 右连接 full join 全连接 s...
python中的join函数连接dataframe_使用pandas对两个dataframe进行join的实例
weixin_29582919的博客
03-02 1529
需求：两个文件，一个文件为统计报表，里面含有手机号，另一个文件为手机号段归属地，含有手机号码前七位对应的地区。需要对统计报表进行处理，将手机号所在的归属地加入到统计报表中，使用pandas提供的join功能来实现，代码如下：#coding=utf-8from pandas import Series,DataFrameimport pandas as pd#reader1 = pd.read_cs...
pyspark中DataFrame之间的join操作
Airstudy的博客
11-23 1988
在pyspark中加载sql之后，会经常遇到各DataFrame之间的join操作，以下给出集中join的调用方式。
判断 pyspark 两个dataframe的两列是否相等
08-19
<think>我们有两个不同的DataFrame（df1和df2），需要判断它们中的特定列（比如df1的col1和df2的col2）是否相等。注意，这里“相等”的含义包括： 1. 列中所有对应行的值都相等（包括顺序？但通常DataFrame没有固定顺序，所以需要基于某个键连接，或者不考虑顺序？） 2. 用户可能想检查列的内容是否完全相同，但两个DataFrame的行数可能不同，或者顺序不同。 根据问题，我们只关心列的内容是否相同，但需要明确： - 是否考虑顺序？通常不，因为分布式数据没有固定顺序。 - 是否考虑行数？如果行数不同，显然不相等。 因此，我们需要一个方法来判断两个列（来自不同DataFrame）是否包含相同的元素集合（包括重复元素）？还是说，我们需要按照某个键来关联行，然后比较对应行的列值？ 用户问题没有指定关联键，所以这里有两种情况： 情况A：两个DataFrame的行顺序和行数都相同，且不需要键关联（即行对行比较）。 情况B：两个DataFrame没有显式顺序，需要通过一个或多个键进行关联，然后比较对应行的列值。 但是，用户的问题只是“判断两个列是否相等”，没有提供更多上下文。因此，我们需要提供多种方法，并解释适用场景。 下面提供几种方法： 方法1：假设两个DataFrame的行数相同且顺序一致（比如两个DataFrame是通过不同操作得到的，但保留了相同的排序和分区），可以直接添加一列进行比较，然后检查是否所有行都相等。 方法2：如果两个DataFrame有共同的键（比如id列），则通过键连接，然后比较两个列。 方法3：不考虑顺序，只检查两个列是否包含相同的元素集合（包括重复元素）。这可以通过分组计数来实现。 然而，用户要求的是“判断两个列是否相等”，通常我们期望的是：两个列在相同键的行上具有相同的值。因此，最合理的做法是通过键关联（如果用户没有提供键，可能需要使用行号作为键）。 但是，在分布式环境下，生成行号开销较大，所以最好有自然键。 步骤： 1. 确认两个DataFrame的行数是否相同。如果不同，则两列肯定不相等。 2. 如果有键，则通过键连接两个DataFrame，然后比较这两列。 3. 如果没有键，但可以假设顺序相同，则使用行索引（但Spark默认不保留行顺序，所以需要谨慎）。 由于问题中没有提到键，我们提供两种主要方法： 方法一：使用行号作为键（需要Spark 3.0以上，因为需要row_number函数，并且需要分区一致，但通常不推荐，因为分布式数据顺序不稳定） 方法二：使用集合比较（不考虑顺序，但要注意重复元素） 但是，注意：如果两列有重复元素，且重复次数相同，但顺序不同，那么集合比较（使用count）可以判断相等。但这种方法开销很大。 因此，我们通常推荐使用键关联（如果有自然键的话）。如果没有，则考虑生成行号（但需要两个DataFrame的分区和排序完全一致）。 下面给出具体实现： 场景1：两个DataFrame有相同的行数且顺序一致（或者用户不关心顺序，但要求每个值出现的次数相同） 我们可以使用以下方法： 步骤1：检查行数 步骤2：使用`exceptAll`来找出两个列的差异（注意：exceptAll会保留重复项，但会考虑顺序？不，exceptAll不考虑顺序，它返回在第一个DataFrame中出现但不在第二个DataFrame中出现的行（按行比较，所以需要两个DataFrame的结构相同，并且按相同顺序比较））。所以，如果我们只选择要比较的列，然后分别从两个DataFrame中取出该列，使用exceptAll，如果两个列完全相同（包括重复值和顺序），那么exceptAll将返回空。但顺序问题？exceptAll要求行的顺序一致？不，它执行的是集合差运算，但保留重复项，并且不要求顺序。但是，它比较的是整个行，所以如果两个DataFrame中该列的值相同但顺序不同，那么exceptAll可能不会返回空集，因为它是按行比较的。 实际上，`exceptAll`是逐行比较的，所以要求两个DataFrame的行顺序一致。因此，这种方法不适用。 替代方案：我们可以对两个列分别进行排序，然后比较排序后的列。 具体步骤： 1. 分别从两个DataFrame中提取要比较的列，并添加索引（因为排序后需要重新关联，但这里我们只需要比较值，所以可以排序后生成行号，然后比较每行的值）。 2. 对每个列进行排序（如果值有重复，排序后顺序可能不同，但值相同，所以排序后两个列应该完全一致？不一定，因为排序后相同的值会排在一起，但两个列排序后序列应该相同）。 但是，这种方法要求两个列的值集合（包括重复）完全相同，并且排序后顺序一致。但注意，排序后两个列的顺序可能不同（因为分区不同），所以我们需要全局排序。 步骤： - 对df1的列进行全局排序，并添加行号（按值排序，然后按行号生成序号） - 对df2的列进行全局排序，并添加行号 - 然后连接两个排序后的DataFrame（按行号），比较值 但这样太复杂。 更简单的方法：使用聚合，统计每个值出现的次数，然后比较两个统计结果是否相同。 例如： ```python df1_count = df1.select("col1").groupBy("col1").count() df2_count = df2.select("col2").groupBy("col2").count() # 然后比较这两个计数表是否相同 ``` 但是，如果两个列的值相同，但列名不同，我们需要统一列名。 步骤： ```python from pyspark.sql import functions as F # 统一列名 df1_count = df1.select(F.col("col1").alias("value")).groupBy("value").count() df2_count = df2.select(F.col("col2").alias("value")).groupBy("value").count() # 使用exceptAll比较两个计数表 diff = df1_count.unionAll(df2_count).groupBy("value").agg(F.sum("count").alias("total_count")) # 如果两个列相同，那么每个值的总计数应该是偶数（因为每个值在df1_count和df2_count中都有相同的计数，所以总和是2倍），并且每个值都应该有两个计数？ # 实际上，我们可以用对称差：找出在df1_count中出现但不在df2_count中出现的记录，以及反之 # 更简单：计算两个计数表的差集 diff1 = df1_count.exceptAll(df2_count) diff2 = df2_count.exceptAll(df1_count) if diff1.count() == 0 and diff2.count() == 0: print("两列相等") else: print("两列不相等") ``` 但是，注意exceptAll是保留重复的，所以如果同一个值在两个表中的计数不同，那么它就会出现在差集中。 然而，这种方法要求两个表的值完全相同（包括计数），所以可以判断两列是否包含相同的元素（包括重复次数）。 但是，这种方法忽略了顺序，只关注内容。 场景2：按照键关联比较 如果我们有一个键，那么我们可以通过键连接两个DataFrame，然后比较这两列。 步骤： ```python # 假设键列为"id" joined_df = df1.join(df2, "id") # 然后比较两列 # 检查是否所有行都相等 from pyspark.sql import functions as F # 添加一列表示是否相等 joined_df = joined_df.withColumn("equal", F.col("col1") == F.col("col2")) # 然后检查是否有不相等的情况 not_equal = joined_df.filter(~F.col("equal")).count() if not_equal == 0: print("两列相等") else: print("两列不相等") ``` 但是，这种方法要求两个DataFrame的键完全匹配（即每个键在两边都存在，且没有重复键）。如果键不匹配，我们需要考虑外连接。 另外，如果两个DataFrame的行数不同，那么连接后行数可能不同（内连接会减少行数），所以我们需要先检查行数，或者使用外连接，然后检查非匹配行的情况。 因此，我们可以： 1. 检查两个DataFrame的键是否完全匹配（即内连接后行数与两个DataFrame的行数相同？不，如果键重复，则行数会变多） 2. 使用全外连接，然后检查是否有任何一列出现空值（即没有匹配的键），或者比较的列值不等。 步骤： ```python # 全外连接 joined_df = df1.join(df2, "id", "full") # 然后检查：1. 是否有任何一方的键缺失；2. 值是否相等 # 如果有一方缺失，那么col1或col2会为null，此时两列不相等 # 或者直接比较两列，并考虑null joined_df = joined_df.withColumn("equal", F.when(F.isnull("col1") | F.isnull("col2"), F.lit(False)) .otherwise(F.col("col1") == F.col("col2")) ) # 然后检查是否有False if joined_df.filter(~F.col("equal")).count() == 0: print("两列相等") else: print("两列不相等") ``` 但是，这种方法要求两个DataFrame的键相同，且比较的列在键匹配的情况下值相等。如果两个DataFrame的键不同，那么就会有不匹配的行，导致结果为不相等。 因此，我们需要根据实际需求选择方法。 总结： 根据问题，我们有两种需求： 需求1：比较两个列的内容（值集合和重复次数）是否相同，不考虑顺序和键。 需求2：按照键关联，比较两个列在相同键上的值是否相同。 由于用户问题没有明确，我们提供两种方法的代码： 方法A（内容相同，不考虑顺序）： 步骤1：检查行数是否相等，如果不相等，则直接返回不相等。 步骤2：使用聚合统计每个值的出现次数，然后比较两个统计表。 方法B（按键比较）： 步骤：使用键进行连接，然后比较两列的值。 下面分别给出代码： 方法A：比较内容（包括重复次数）是否相同 ```python from pyspark.sql import functions as F def compare_columns_content(df1, col1, df2, col2): # 检查行数 if df1.count() != df2.count(): return False # 为每个DataFrame的指定列创建计数表 df1_count = df1.select(F.col(col1).alias("value")).groupBy("value").count() df2_count = df2.select(F.col(col2).alias("value")).groupBy("value").count() # 找出df1_count中有但df2_count中没有，或者计数不同的行 diff = df1_count.subtract(df2_count).union(df2_count.subtract(df1_count)) return diff.count() == 0 ``` 注意：`subtract` 是 `except` 的别名，它不保留重复，并且会去重。但我们的计数表每个值只有一行，所以使用`except`是合适的。因为计数表本身已经去重了。 但是，`subtract`会去重，所以如果有一个值在df1_count中出现两次（这不可能，因为groupBy已经去重），所以没问题。 然而，如果两个计数表有相同的值和计数，那么`df1_count.subtract(df2_count)`将返回空。 方法B：按键比较（假设键为key_col） ```python def compare_columns_by_key(df1, col1, df2, col2, key_col): # 选择两个DataFrame的键和要比较的列 df1_sel = df1.select(F.col(key_col).alias("key"), F.col(col1).alias("col1")) df2_sel = df2.select(F.col(key_col).alias("key"), F.col(col2).alias("col2")) # 全外连接 joined = df1_sel.join(df2_sel, "key", "full") # 创建比较列：使用安全等于（处理null）和检查键匹配情况 # 如果键不匹配（即一方为null），则设为False joined = joined.withColumn("equal", F.when(F.isnull("col1") | F.isnull("col2"), F.lit(False)) .otherwise(F.col("col1") == F.col("col2")) ) # 检查是否有不相等 return joined.filter(~F.col("equal")).count() == 0 ``` 注意：方法B中，如果两个DataFrame的键不同，那么不匹配的键会导致结果为False。 用户可以根据需求选择方法。 最后，我们也可以考虑使用Spark SQL的INTERSECT和UNION ALL等方法，但上述方法已经覆盖。 根据用户问题，我们给出两种方法，并说明适用场景。 另外，如果用户没有键，且两个DataFrame行数相同，但顺序不同，那么方法A（内容比较）是合适的。 如果用户有键，那么方法B更合适。 因此，回答如下：</think>在 PySpark 中比较两个不同 DataFrame 的特定列是否相等，需要根据数据特性（如是否有序、是否有键列）选择合适的方法。以下是详细解决方案： ### 一、基于键列的精确比较（推荐） 当两个 DataFrame 有共同的键列（如 ID）时，使用 JOIN 进行行级匹配： ```python from pyspark.sql import functions as F def compare_columns_with_key(df1, col1, df2, col2, key_col): # 选择关键列并重命名 df1_sel = df1.select(F.col(key_col), F.col(col1).alias("col1_temp")) df2_sel = df2.select(F.col(key_col), F.col(col2).alias("col2_temp")) # 全外连接确保所有键匹配 joined = df1_sel.join(df2_sel, key_col, "full") # 安全比较（处理NULL） result = joined.withColumn("is_equal", F.when(F.isnull("col1_temp") | F.isnull("col2_temp"), False) .otherwise(F.col("col1_temp") == F.col("col2_temp"))) # 检查是否存在不匹配 if result.filter(~F.col("is_equal")).count() > 0: return False # 检查键列是否完全匹配 elif df1_sel.count() != df2_sel.count(): return False return True # 使用示例 is_equal = compare_columns_with_key(df1, "price", df2, "cost", "id") print(f"两列是否完全相等: {is_equal}") ``` ### 二、无序内容比较（无键列时） 当没有键列但需要检查内容是否相同（忽略顺序）： ```python def compare_columns_content(df1, col1, df2, col2): # 提取列并添加来源标记 df1_marked = df1.select(F.col(col1).alias("value"), F.lit("df1").alias("source")) df2_marked = df2.select(F.col(col2).alias("value"), F.lit("df2").alias("source")) # 合并并计算频率 combined = df1_marked.unionAll(df2_marked) freq = combined.groupBy("value", "source").count() # 透视表比较频率 pivot = freq.groupBy("value").pivot("source").sum("count").fillna(0) mismatch = pivot.filter(F.col("df1") != F.col("df2")) return mismatch.count() == 0 # 使用示例 content_equal = compare_columns_content(df1, "product", df2, "item") ``` ### 三、特殊场景处理 1. **NULL 值安全比较** 使用 `<=>` 操作符替代 `==`： ```python joined.withColumn("null_safe_equal", F.col("col1") <=> F.col("col2")) ``` 2. **浮点数精度问题** 自定义容差比较： ```python tolerance = 1e-5 df.withColumn("float_equal", F.abs(F.col("price1") - F.col("price2")) < tolerance) ``` 3. **数据类型验证** 比较前检查列类型： ```python if df1.schema[col1].dataType != df2.schema[col2].dataType: raise TypeError("列类型不匹配") ``` ### 四、性能优化建议 1. **分区裁剪** 在连接前过滤无关分区： ```python df1.filter(F.col("date") > "2023-01-01").join(...) ``` 2. **广播小数据集** 当其中一个 DataFrame 较小时： ```python spark.conf.set("spark.sql.autoBroadcastJoinThreshold", "10MB") ``` 3. **检查执行计划** 使用 `.explain()` 验证优化： ```python joined.explain() # 查看Physical Plan是否包含PushFilters ``` ### 五、完整示例 ```python from pyspark.sql import SparkSession spark = SparkSession.builder.appName("ColumnCompare").getOrCreate() # 示例数据 df1 = spark.createDataFrame([(1, 9.99), (2, 19.50)], ["id", "price"]) df2 = spark.createDataFrame([(1, 9.99), (2, 20.00)], ["id", "cost"]) # 方法1：键列比较 print("键列比较结果:", compare_columns_with_key(df1, "price", df2, "cost", "id")) # 方法2：内容比较 print("内容比较结果:", compare_columns_content(df1, "price", df2, "cost")) ``` **输出**： ``` 键列比较结果: False # 第二行值不同 内容比较结果: False # 值分布不同 ```
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值