Así que como sé que en la Chispa de la Dataframe, que por varias columnas pueden tener el mismo nombre como se muestra en la siguiente dataframe instantánea:

[
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}))
]

Resultado anterior es creado por unirse con un dataframe a sí mismo, usted puede ver que hay 4 columnas con dos a y f.

El problema es que cuando trato de hacer el cálculo más con la a columna, no puedo encontrar una manera para seleccionar el a, he intentar df[0] y df.select('a'), ambos regresaron a mí por debajo de error mesaage:

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

Es de todos modos en la Chispa de la API que puedo distinguir las columnas de la duplicación de nombres de nuevo? o tal vez alguna manera de que me deje cambiar los nombres de columna?

InformationsquelleAutor resec | 2015-11-18

7 Comentarios

  1. 39

    Recomiendo que cambiar los nombres de columna para su join

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

    El resultado DataFrame tendrá schema

    (df1_a, df1_f, df2_a, df2_f)
    • Es posible que necesite reparar su respuesta ya que la cita no se ha ajustado correctamente entre los nombres de columna.
    • Supongo que usted es el uno, el voto de mi respuesta? Pero la respuesta está en el hecho de 100% correcto – simplemente estoy utilizando la scala '-taquigrafía para la selección de columna, así que en realidad no hay problema con las comillas.
    • punto justo. Es confuso porque la respuesta es etiquetado como python y pyspark.
  2. 69

    Vamos a empezar con algunos datos:

    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})),
    ])

    Hay un par de formas de abordar este problema. Primero de todo lo que puede de forma inequívoca referencia niño columnas de la tabla utilizando los padres columnas:

    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...|
    ##  +--------------------+

    También puede utilizar los alias de tabla:

    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...|
    ##  +--------------------+

    Finalmente mediante programación puede cambiar el nombre de las columnas:

    df1_r = df1.select(*(col(x).alias(x + '_df1') for x in df1.columns))
    df2_r = df1.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...|
    ## +--------------------+
    • Gracias por tu trabajo de edición para mostrar muchas maneras de conseguir que la columna correcta en los ambiguamente casos, yo creo que tus ejemplos deben ir en la Chispa de la guía de programación. He aprendido un montón!
  3. 5

    Después de cavar en la Chispa de la API, encontré que pueda usar alias para crear un alias para el original dataframe, entonces yo uso withColumnRenamed cambiar manualmente el nombre de cada columna en el alias, esto va a hacer la join sin causar la duplicación de nombres de columnas.

    Más detalle se puede referir a continuación Chispa Dataframe API:

    pyspark.sql.DataFrame.alias

    pyspark.sql.DataFrame.withColumnRenamed

    Sin embargo, creo que esta es sólo una problemática de solución, y se preguntaba si hay alguna manera mejor para mi pregunta.

  4. 4

    Puede utilizar def drop(col: Column) método de caída de la duplicación de la columna,por ejemplo:

    DataFrame:df1
    +-------+-----+
    | a     | f   |
    +-------+-----+
    |107831 | ... |
    |107831 | ... |
    +-------+-----+
    DataFrame:df2
    +-------+-----+
    | a     | f   |
    +-------+-----+
    |107831 | ... |
    |107831 | ... |
    +-------+-----+

    cuando me uno a df1 con df2, el DataFrame será como a continuación:

    val newDf = df1.join(df2,df1("a")===df2("a"))
    DataFrame:newDf
    +-------+-----+-------+-----+
    | a     | f   | a     | f   |
    +-------+-----+-------+-----+
    |107831 | ... |107831 | ... |
    |107831 | ... |107831 | ... |
    +-------+-----+-------+-----+

    Ahora, podemos usar def drop(col: Column) método de caída de la duplicación de la columna ‘a’ o ‘f’, tal como sigue:

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

    Esto es lo que nos puede unir dos Dataframes en la misma columna los nombres de en PySpark.

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

    Si usted printSchema() después de esto, entonces usted puede ver que las columnas duplicadas se han eliminado.

  6. 2

    Supongamos que el DataFrames quieres unirte son df1 y df2, y va a unirse a ellos en la columna ‘a’, entonces tienes 2 métodos

    Método 1

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

    Este es un impresionante método y es muy recomendable.

    Método 2

    df1.join(df2,df1.a == df2.una,’left_outer’).gota(df2.a)

Dejar respuesta

Please enter your comment!
Please enter your name here