>>> a
DataFrame[id: bigint, julian_date: string, user_id: bigint]
>>> b
DataFrame[id: bigint, quan_created_money: decimal(10,0), quan_created_cnt: bigint]
>>> a.join(b, a.id==b.id, 'outer')
DataFrame[id: bigint, julian_date: string, user_id: bigint, id: bigint, quan_created_money: decimal(10,0), quan_created_cnt: bigint]

Hay dos id: bigint y quiero eliminar uno. ¿Cómo puedo hacer?

InformationsquelleAutor xjx0524 | 2015-04-13

8 Comentarios

  1. 83

    La lectura de la Chispa de la documentación que he encontrado una solución más fácil.

    Desde la versión 1.4 de chispa no es una función drop(col) que puede ser utilizado en pyspark en un dataframe.

    Puede utilizar de dos maneras

    1. df.drop('age').collect()
    2. df.drop(df.age).collect()

    Pyspark Documentación Soltar

    • Esto funciona muy bien para mí. Gracias.
    • cuando el tamaño de los datos es grande, collect() podría causar que el espacio de montón de errores. usted también puede crear un nuevo dataframe abandonar el campo extra por ndf = df.drop('age')
  2. 27

    Agregar a @Patricio respuesta, puede utilizar el siguiente a la caída de varias columnas

    columns_to_drop = ['id', 'id_copy']
    df = df.drop(*columns_to_drop)
    
    • He tenido que reasignar la caída de los resultados de vuelta a la dataframe: df = df.gota(*columns_to_drop)
  3. 21

    Una manera fácil de hacer esto es para el usuario «select» y darse cuenta de que usted puede obtener una lista de todos los columns para la dataframe, df, con df.columns

    drop_list = ['a column', 'another column', ...]
    
    df.select([column for column in df.columns if column not in drop_list])
    
    • Gracias, esto funciona muy bien para mí, para la eliminación de duplicados columnas con el mismo nombre que otra columna, donde yo lo uso df.select([df.columns[column_num] for column_num in range(len(df.columns)) if column_num!=2]), donde la columna que desea eliminar tiene índice 2.
  4. 12

    Usted podría explícitamente el nombre de las columnas que desea mantener, así:

    keep = [a.id, a.julian_date, a.user_id, b.quan_created_money, b.quan_created_cnt]
    

    O en un enfoque más general deberías incluir todas las columnas excepto uno específico, a través de una lista de comprensión. Por ejemplo, este (excluyendo el id columna de b):

    keep = [a[c] for c in a.columns] + [b[c] for c in b.columns if c != 'id']
    

    Finalmente se hace una selección en su únete resultado:

    d = a.join(b, a.id==b.id, 'outer').select(*keep)
    
    • Creo que tengo la respuesta. Seleccione necesita tener una lista de cadenas NO una lista de columnas. Para hacer esto: keep = [c for c in a.columns] + [c for c in b.columns if c != 'id'] d = a.join(b, a.id==b.id, 'outer').select(*keep)
    • Bueno, que debería hacer exactamente lo mismo que a mi respuesta, ya que estoy bastante seguro de que select acepta cadenas O columnas (spark.apache.org/docs/latest/api/python/…). Por cierto, en su línea de keep = ... no hay necesidad de utilizar una lista de comprensión para a: a.columns + [c for c in b.columns if c != 'id'] debe lograr exactamente lo mismo, como a.columns ya es un list de cadenas.
    • En realidad, la columna de selección basado en las cadenas de caracteres no puede trabajar para el OP, ya que no serviría para resolver la ambigüedad de la id columna. En ese caso, usted tiene que utilizar el Column casos en select.
    • Todos los puntos buenos. He intentado la solución en la Chispa de la 1.3 y tengo errores, así que lo que he publicado en realidad trabajaba para mí. Y para resolver el identificador de la ambigüedad he cambiado el nombre de mi columna de id de antes de la combinación, a continuación, cayó después de la combinación con la de mantener la lista. HTH cualquier otra persona que estaba pegado como me fue.
  5. 4

    Puede utilizar dos vías:

    1:
    Usted acaba de mantener las columnas necesarias:

    drop_column_list = ["drop_column"]
    df = df.select([column for column in df.columns if column not in drop_column_list])  
    

    2: Esta es la manera más elegante.

    df = df.drop("col_name")
    

    Se debe evitar el collect() de la versión, porque se va a enviar a la maestría en el conjunto de datos completo, va a tener un gran computación esfuerzo!

  6. 3

    Tal vez un poco fuera de tema, pero aquí está la solución usando Scala. Hacer un Array de los nombres de columna de su oldDataFrame y eliminar las columnas que desea colocar ("colExclude"). A continuación, pase el Array[Column] a select y descomprimirlo.

    val columnsToKeep: Array[Column] = oldDataFrame.columns.diff(Array("colExclude"))
                                                   .map(x => oldDataFrame.col(x))
    val newDataFrame: DataFrame = oldDataFrame.select(columnsToKeep: _*)
    
  7. 0

    Considerar 2 dataFrames:

    >>> aDF.show()
    +---+----+
    | id|datA|
    +---+----+
    |  1|  a1|
    |  2|  a2|
    |  3|  a3|
    +---+----+
    

    y

    >>> bDF.show()
    +---+----+
    | id|datB|
    +---+----+
    |  2|  b2|
    |  3|  b3|
    |  4|  b4|
    +---+----+
    

    Para lograr lo que usted está buscando, hay 2 formas:

    1. Diferentes unirse condición. En lugar de decir: aDF.id == bDF.id

    aDF.join(bDF, aDF.id == bDF.id, "outer")
    

    Escribir esto:

    aDF.join(bDF, "id", "outer").show()
    +---+----+----+
    | id|datA|datB|
    +---+----+----+
    |  1|  a1|null|
    |  3|  a3|  b3|
    |  2|  a2|  b2|
    |  4|null|  b4|
    +---+----+----+
    

    Esto automáticamente deshacerse del exceso de la caída proceso.

    2. Utilizar Alias: se perderán los datos relacionados a B Id Específico en este.

    >>> from pyspark.sql.functions import col
    >>> aDF.alias("a").join(bDF.alias("b"), aDF.id == bDF.id, "outer").drop(col("b.id")).show()
    
    +----+----+----+
    |  id|datA|datB|
    +----+----+----+
    |   1|  a1|null|
    |   3|  a3|  b3|
    |   2|  a2|  b2|
    |null|null|  b4|
    +----+----+----+
    
  8. 0

    Usted puede eliminar de la columna como esta:

    df.drop("column Name).columns
    

    En su caso :

    df.drop("id").columns
    

    Si desea colocar más de una columna que usted puede hacer:

    dfWithLongColName.drop("ORIGIN_COUNTRY_NAME", "DEST_COUNTRY_NAME")
    
    • Chispa 2.4 (y menos las versiones) no acepta más de un nombre de columna.

Dejar respuesta

Please enter your comment!
Please enter your name here