He dataframe en el que tengo cerca de 1000 ( variable) de las columnas.

Quiero hacer todos los valores de la parte superior de la caja.

Aquí es el enfoque que he pensado , ¿puede indicar si esta es la mejor manera.

  • Tomar fila
  • Encontrar esquemas y almacenar en la matriz y encontrar la cantidad de campos que están ahí.
  • mapa a través de cada fila en el marco de datos y hasta un límite de número de elementos en la matriz de
  • aplicar la función a mayúsculas cada uno de los campos y de la vta de retorno
InformationsquelleAutor user2230605 | 2015-12-02

2 Comentarios

  1. 28

    Si usted simplemente desea aplicar las mismas funciones para todas las columnas algo como esto debería ser suficiente:

    import org.apache.spark.sql.functions.{col, upper}
    
    val df = sc.parallelize(
      Seq(("a", "B", "c"), ("D", "e", "F"))).toDF("x", "y", "z")
    df.select(df.columns.map(c => upper(col(c)).alias(c)): _*).show
    
    //+---+---+---+
    //|  x|  y|  z|
    //+---+---+---+
    //|  A|  B|  C|
    //|  D|  E|  F|
    //+---+---+---+

    o en Python

    from pyspark.sql.functions import col, upper
    
    df = sc.parallelize([("a", "B", "c"), ("D", "e", "F")]).toDF(("x", "y", "z"))
    df.select(*(upper(col(c)).alias(c) for c in df.columns)).show()
    
    ##  +---+---+---+
    ##  |  x|  y|  z|
    ##  +---+---+---+
    ##  |  A|  B|  C|
    ##  |  D|  E|  F|
    ##  +---+---+---+

    Ver también: SparkSQL: aplicar funciones de agregado a una lista de la columna

    • Gracias lo que se esta haciendo en inglés .alias(c)): _*
    • alias establece un nombre para la columna. :_* denota varargs sintaxis en la Scala. En otras palabras, se pasa a cada elemento de la secuencia, como un argumento para select.
  2. 1

    Necesitaba hacer similar, pero tenía que escribir mi propia función para convertir cadenas vacías dentro de un dataframe a null. Esto es lo que hice.

    import org.apache.spark.sql.functions.{col, udf} 
    import spark.implicits._ 
    
    def emptyToNull(_str: String): Option[String] = {
      _str match {
        case d if (_str == null || _str.trim.isEmpty) => None
        case _ => Some(_str)
      }
    }
    val emptyToNullUdf = udf(emptyToNull(_: String))
    
    val df = Seq(("a", "B", "c"), ("D", "e ", ""), ("", "", null)).toDF("x", "y", "z")
    df.select(df.columns.map(c => emptyToNullUdf(col(c)).alias(c)): _*).show
    
    +----+----+----+
    |   x|   y|   z|
    +----+----+----+
    |   a|   B|   c|
    |   D|  e |null|
    |null|null|null|
    +----+----+----+
    

    He aquí una más refinada de la función de emptyToNull el uso de opciones, en lugar de null.

    def emptyToNull(_str: String): Option[String] = Option(_str) match {
      case ret @ Some(s) if (s.trim.nonEmpty) => ret
      case _ => None
    }
    

Dejar respuesta

Please enter your comment!
Please enter your name here