Khung dữ liệu Spark phân biệt các cột có tên trùng lặp

Vì vậy, như tôi biết trong Spark Dataframe, cho nhiều cột có thể có cùng tên như được hiển thị trong ảnh chụp nhanh khung dữ liệu bên dưới:

[
Row(a=107831, f=SparseVector(5, {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0}), a=107831, f=SparseVector(5, {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0})),
Row(a=107831, f=SparseVector(5, {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0}), a=125231, f=SparseVector(5, {0: 0.0, 1: 0.0, 2: 0.0047, 3: 0.0, 4: 0.0043})),
Row(a=107831, f=SparseVector(5, {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0}), a=145831, f=SparseVector(5, {0: 0.0, 1: 0.2356, 2: 0.0036, 3: 0.0, 4: 0.4132})),
Row(a=107831, f=SparseVector(5, {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0}), a=147031, f=SparseVector(5, {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0})),
Row(a=107831, f=SparseVector(5, {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0}), a=149231, f=SparseVector(5, {0: 0.0, 1: 0.0032, 2: 0.2451, 3: 0.0, 4: 0.0042}))
]

Kết quả trên được tạo bằng cách nối với khung dữ liệu với chính nó, bạn có thể thấy có 4các cột có cả hai avà f.

Vấn đề là ở đó khi tôi cố gắng thực hiện nhiều phép tính hơn với acột, tôi không thể tìm cách chọn a, tôi đã thử df[0]và df.select('a')cả hai đều trả lại cho tôi thông báo lỗi bên dưới:

AnalysisException: Reference 'a' is ambiguous, could be: a#1333L, a#1335L.

Có cách nào trong Spark API mà tôi có thể phân biệt lại các cột với các tên trùng lặp không? hoặc có thể một số cách để cho phép tôi thay đổi tên cột?

Tôi khuyên bạn nên thay đổi tên cột cho của bạn join.

df1.select(col("a") as "df1_a", col("f") as "df1_f")
   .join(df2.select(col("a") as "df2_a", col("f") as "df2_f"), col("df1_a" === col("df2_a"))

Kết quả DataFramesẽ cóschema

(df1_a, df1_f, df2_a, df2_f)

Hãy bắt đầu với một số dữ liệu:

from pyspark.mllib.linalg import SparseVector
from pyspark.sql import Row

df1 = sqlContext.createDataFrame([
    Row(a=107831, f=SparseVector(
        5, {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0})),
    Row(a=125231, f=SparseVector(
        5, {0: 0.0, 1: 0.0, 2: 0.0047, 3: 0.0, 4: 0.0043})),
])

df2 = sqlContext.createDataFrame([
    Row(a=107831, f=SparseVector(
        5, {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0})),
    Row(a=107831, f=SparseVector(
        5, {0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0})),
])

Có một số cách bạn có thể tiếp cận vấn đề này. Trước hết, bạn có thể tham chiếu rõ ràng các cột trong bảng con bằng cách sử dụng các cột cha:

df1.join(df2, df1['a'] == df2['a']).select(df1['f']).show(2)

##  +--------------------+
##  |                   f|
##  +--------------------+
##  |(5,[0,1,2,3,4],[0...|
##  |(5,[0,1,2,3,4],[0...|
##  +--------------------+

Bạn cũng có thể sử dụng bí danh bảng:

from pyspark.sql.functions import col

df1_a = df1.alias("df1_a")
df2_a = df2.alias("df2_a")

df1_a.join(df2_a, col('df1_a.a') == col('df2_a.a')).select('df1_a.f').show(2)

##  +--------------------+
##  |                   f|
##  +--------------------+
##  |(5,[0,1,2,3,4],[0...|
##  |(5,[0,1,2,3,4],[0...|
##  +--------------------+

Cuối cùng, bạn có thể đổi tên các cột theo chương trình:

df1_r = df1.select(*(col(x).alias(x + '_df1') for x in df1.columns))
df2_r = df2.select(*(col(x).alias(x + '_df2') for x in df2.columns))

df1_r.join(df2_r, col('a_df1') == col('a_df2')).select(col('f_df1')).show(2)

## +--------------------+
## |               f_df1|
## +--------------------+
## |(5,[0,1,2,3,4],[0...|
## |(5,[0,1,2,3,4],[0...|
## +--------------------+

Có một cách đơn giản hơn là viết bí danh cho tất cả các cột bạn đang tham gia bằng cách thực hiện:

df1.join(df2,['a'])

Điều này hoạt động nếu khóa bạn đang tham gia giống nhau trong cả hai bảng.

Xem https://kb.databricks.com/data/join-two-dataframes-duplicated-columns.html

Bạn có thể sử dụng def drop(col: Column)phương pháp để loại bỏ cột trùng lặp, ví dụ:

DataFrame:df1

+-------+-----+
| a     | f   |
+-------+-----+
|107831 | ... |
|107831 | ... |
+-------+-----+

DataFrame:df2

+-------+-----+
| a     | f   |
+-------+-----+
|107831 | ... |
|107831 | ... |
+-------+-----+

khi tôi nối df1 với df2, DataFrame sẽ như sau:

val newDf = df1.join(df2,df1("a")===df2("a"))

DataFrame:newDf

+-------+-----+-------+-----+
| a     | f   | a     | f   |
+-------+-----+-------+-----+
|107831 | ... |107831 | ... |
|107831 | ... |107831 | ... |
+-------+-----+-------+-----+

Bây giờ, chúng ta có thể sử dụng def drop(col: Column)phương pháp để thả cột trùng lặp 'a' hoặc 'f', giống như sau:

val newDfWithoutDuplicate = df1.join(df2,df1("a")===df2("a")).drop(df2("a")).drop(df2("f"))

Sau khi tìm hiểu kỹ về Spark API, tôi thấy trước tiên tôi có thể sử dụng aliasđể tạo bí danh cho khung dữ liệu ban đầu, sau đó tôi sử dụng withColumnRenamedđể đổi tên thủ công mọi cột trên bí danh, điều này sẽ thực hiện joinmà không gây ra trùng lặp tên cột.

Chi tiết hơn có thể tham khảo bên dưới API khung dữ liệu Spark :

pyspark.sql.DataFrame.alias

pyspark.sql.DataFrame.withColumnRename

Tuy nhiên, tôi nghĩ rằng đây chỉ là một cách giải quyết rắc rối và tự hỏi liệu có cách nào tốt hơn cho câu hỏi của tôi không.

Đây là cách chúng ta có thể nối hai Dataframe trên cùng một tên cột trong PySpark.

df = df1.join(df2, ['col1','col2','col3'])

Nếu bạn làm printSchema()sau điều này thì bạn có thể thấy rằng các cột trùng lặp đã bị loại bỏ.

Giả sử DataFrames bạn muốn tham gia là df1 và df2, và bạn đang nối chúng trên cột 'a', thì bạn có 2 phương pháp

Phương pháp 1

df1.join (df2, 'a', 'left_outer')

Đây là một phương pháp tuyệt vời và nó rất được khuyến khích.

Phương pháp 2

df1.join (df2, df1.a == df2.a, 'left_outer'). drop (df2.a)

Đây có thể không phải là cách tốt nhất, nhưng nếu bạn muốn đổi tên các cột trùng lặp (sau khi nối), bạn có thể làm như vậy bằng cách sử dụng hàm nhỏ này.

def rename_duplicate_columns(dataframe):
    columns = dataframe.columns
    duplicate_column_indices = list(set([columns.index(col) for col in columns if columns.count(col) == 2]))
    for index in duplicate_column_indices:
        columns[index] = columns[index]+'2'
    dataframe = dataframe.toDF(*columns)
    return dataframe

nếu chỉ có cột chính giống nhau trong cả hai bảng thì hãy thử sử dụng cách sau (Phương pháp 1):

left. join(right , 'key', 'inner')

chứ không phải bên dưới (cách tiếp cận 2):

left. join(right , left.key == right.key, 'inner')

Ưu điểm của việc sử dụng phương pháp 1:

• 'chìa khóa' sẽ chỉ hiển thị một lần trong khung dữ liệu cuối cùng
• cú pháp dễ sử dụng

Nhược điểm của việc sử dụng cách tiếp cận 1:

• chỉ giúp với cột chính
• Các tình huống, trong đó trường hợp kết hợp bên trái, nếu dự định sử dụng phím bên phải đếm null, điều này sẽ không hoạt động. Trong trường hợp đó, người ta phải đổi tên một trong các khóa như đã đề cập ở trên.

Nếu bạn có một trường hợp sử dụng phức tạp hơn được mô tả trong câu trả lời của Glennie Helles Sindholt, ví dụ: bạn có / một số tên cột không nối khác cũng giống nhau và muốn phân biệt chúng trong khi chọn thì tốt nhất nên sử dụng bí danh, ví dụ:

df3 = df1.select("a", "b").alias("left")\
   .join(df2.select("a", "b").alias("right"), ["a"])\
   .select("left.a", "left.b", "right.b")

df3.columns
['a', 'b', 'b']