Cómo añadir columnas con withColumn en PySpark

João Barros 04 de July de 2026 4 min de lectura

Añadir nuevas columnas a un DataFrame es una de las tareas más habituales al transformar datos en PySpark. El método withColumn permite crear columnas calculadas, convertir tipos de datos y aplicar reglas condicionales, todo de forma distribuida y lista para grandes volúmenes. A continuación verás, con ejemplos sencillos, cómo añadir columnas con withColumn —desde el caso más básico hasta el condicional— y cómo comprobar que el resultado es correcto.

Requisitos previos

Un entorno con PySpark disponible (por ejemplo, Databricks, Microsoft Fabric o una instalación local de Spark).
Conocimientos básicos de Python y familiaridad con el concepto de DataFrame.
Un DataFrame de ejemplo para practicar: creamos uno en el primer paso.

Paso 1: Crear un DataFrame de ejemplo

Antes de añadir columnas necesitamos datos. El código siguiente crea una SparkSession (el punto de entrada de cualquier aplicación Spark) y un pequeño DataFrame con tres productos, sus precios y las cantidades vendidas.

from pyspark.sql import SparkSession

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

dados = [
    ("Teclado", 25.0, 4),
    ("Rato", 15.0, 10),
    ("Monitor", 120.0, 2),
]
df = spark.createDataFrame(dados, ["produto", "preco", "quantidade"])
df.show()

El método show() imprime las primeras filas para que confirmes que los datos se cargaron como esperabas.

Paso 2: Añadir una columna calculada

El uso más frecuente de withColumn es crear una columna a partir de otras. El método recibe dos argumentos: el nombre de la nueva columna y la expresión que la calcula. Para referirnos a columnas existentes importamos la función col. En el ejemplo, multiplicamos el precio por la cantidad para obtener el total de cada fila.

from pyspark.sql.functions import col

df = df.withColumn("total", col("preco") * col("quantidade"))
df.show()

Un detalle importante: withColumn siempre devuelve un nuevo DataFrame en lugar de modificar el original, por eso guardamos el resultado de nuevo en la variable df. Esta inmutabilidad es intencionada y ayuda a Spark a optimizar la ejecución.

Paso 3: Añadir una columna con un valor fijo

A veces solo necesitas una columna constante, como la moneda o el origen de los datos. En ese caso la expresión no puede ser un texto simple: debe ser un valor literal creado con la función lit.

from pyspark.sql.functions import lit

df = df.withColumn("moeda", lit("EUR"))
df.show()

Si olvidaras lit y pasaras solo "EUR", Spark intentaría interpretarlo como el nombre de una columna y daría error.

Paso 4: Crear una columna condicional

Para aplicar reglas de negocio, combina las funciones when y otherwise, que funcionan como un "si… si no". En el ejemplo, marcamos como "alto" los productos cuyo total supera 100 y como "normal" el resto. Puedes encadenar varios when antes del otherwise para cubrir más casos.

from pyspark.sql.functions import when

df = df.withColumn(
    "categoria",
    when(col("total") > 100, "alto").otherwise("normal")
)
df.show()

Paso 5: Convertir el tipo de una columna

El withColumn también sirve para cambiar el tipo de datos de una columna, usando cast. Aquí convertimos la cantidad de número entero a texto.

df = df.withColumn("quantidade", col("quantidade").cast("string"))
df.printSchema()

Como dimos a la columna el mismo nombre que ya existía (quantidade), withColumn sustituye la columna original en lugar de crear una nueva. Así se actualiza una columna en el sitio.

Consejo: para añadir muchas columnas a la vez existe withColumns (en plural), que acepta un diccionario con varios pares nombre/expresión. Evita, eso sí, encadenar decenas de withColumn en un bucle, porque puede hacer más lento el plan de ejecución.

Comprobar el resultado

Ejecuta df.show() para ver las filas con las nuevas columnas y df.printSchema() para confirmar nombres y tipos. Deberías ver las columnas total, moeda y categoria, con quantidade ahora de tipo string. Si alguna columna sale toda a null, comprueba que el nombre usado dentro de col("...") existe y está escrito exactamente como en el schema, mayúsculas y acentos incluidos.

Conclusión

Ya sabes usar withColumn para crear columnas calculadas, constantes y condicionales, y para convertir tipos: la base de casi todas las transformaciones en PySpark. Como siguiente paso, prueba a combinar estas técnicas para preparar un DataFrame real y guardarlo en formato Parquet. ¿Cuál será la primera columna que necesitas crear en tu pipeline?