可以使用merge和query：

>>> (original.merge(output, how='outer', indicator=True)
             .query("_merge == 'right_only'")[original.columns])

# OR

>>> (original.merge(output, how='outer', indicator=True)
             .loc[lambda x: x.pop('_merge') == 'right_only'])

   A  B
3  4  7
4  9  8

无过滤：

>>> original.merge(output, how='outer', indicator=True)

   A  B      _merge
0  1  4        both
1  2  5        both
2  3  6   left_only
3  4  7  right_only
4  9  8  right_only

更多关于merge dataframes

在pandas中，你可以在merge中使用indicator参数：

# pandas
merged_df = original.merge(output, how='outer', indicator=True)

    A   B   _merge
0   1   4   both
1   2   5   both
2   3   6   left_only
3   4   7   right_only
4   9   8   right_only

merged_df[merged_df['_merge'] == 'right_only'].drop(columns=['_merge'])

    A   B
3   4   7
4   9   8

它将创建一个附加列，其中包含记录来自哪个表的信息。然后可以使用它来获取必要的记录。
在pyspark中，你可以使用anti join：

original_sdf = spark.createDataFrame(original)
output_sdf = spark.createDataFrame(output)

output_sdf.join(original_sdf, how='left_anti', on=['A', 'B']).show()

+---+---+
|  A|  B|
+---+---+
|  4|  7|
|  9|  8|
+---+---+

将pandas导入为pd
original = pd.DataFrame（'A'：[1，2，3]，“B”：[4、5、6]}）
输出= pd.DataFrame（“A”：[1，2，4，9]，“B”：[4、5、7、8]}）
def g（original，output）：

"""Compares two dataframes and returns the rows from the second dataframe that do not have a matching row in the first dataframe.

Args:
    original: The first dataframe.
    output: The second dataframe.

Returns:
    A dataframe containing the rows from the second dataframe that do not have a matching row in the first dataframe.
"""

diff_df = output.loc[~output.isin(original).all(axis=1)]
return diff_df

diff_df = g（original.copy（），output.copy（））print（diff_df）
输出量：
| 一|B|
| --|--|
| 4 | 7 |
| 9 | 8 |
此解决方案的工作原理是首先创建一个新的嵌套框架diff_df，它是输出嵌套框架的副本。然后，我们使用~output.isin（original）.all（axis=1）表达式来选择diff_df中在original中没有匹配行的行。all（axis=1）函数返回True，如果一行中的所有值也存在于另一行中，否则返回False。
然后使用loc函数从diff_df中提取选定的行，并将它们作为一个新的中间帧返回。

DataFrame.subtract(other: pyspark.sql.dataframe.DataFrame)
返回一个新的DataFrame，其中包含此DataFrame中的行，但不包含其他DataFrame中的行

df1 = spark.createDataFrame([("a", 1), ("a", 1), ("b", 3), ("c", 4)], ["C1", "C2"])
df2 = spark.createDataFrame([("a", 1), ("a", 1), ("b", 3)], ["C1", "C2"])
df1.subtract(df2).show()
+---+---+
| C1| C2|
+---+---+
|  c|  4|
+---+---+

关于Pandas的一句俏皮话：

diff_df = output[ output != original.reindex_like(output) ].dropna()

     A    B
2  4.0  7.0
3  9.0  8.0

在仔细调整original的大小以适合output的大小之后，此操作将查看不同的行。
重索引，因为它添加了一些NaN来填充新的行，负责列'int' dtype变成'float'。如果你的实际数据真的是整数，并且你想保持它的整数，那么在.dropna()之后添加.astype('int')：

A  B
2  4  7
3  9  8

关于dtype在增加索引时不守恒的更多信息：例如Is there a way to prevent dtype from changing from Int64 to float64 when reindexing/upsampling a time-series?。

试试这个：

import pandas as pd

original = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
output = pd.DataFrame({'A': [1, 2, 4, 9], 'B': [4, 5, 7, 8]})

merged = pd.merge(original, output, on=['A', 'B'], how='outer', indicator=True)
diff_df_pandas = merged[merged['_merge'] == 'right_only'][['A', 'B']]

print("Pandas Result:")
print(diff_df_pandas)

from pyspark.sql import SparkSession

spark = SparkSession.builder.appName("difference").getOrCreate()

original_spark = spark.createDataFrame([(1, 4), (2, 5), (3, 6)], ['A', 'B'])
output_spark = spark.createDataFrame([(1, 4), (2, 5), (4, 7), (9, 8)], ['A', 'B'])

diff_df_spark = output_spark.subtract(original_spark)

print("\nPySpark Result:")
diff_df_spark.show()