DataFrame Sütun Dönüşümleri için PySpark withColumn()’ı Ustalaşın

PySpark DataFrame’leri, Spark’ta ölçeklenebilir veri hatları kurarken merkezî bir rol oynar. Hatırlanması gereken önemli bir nokta, DataFrame’lerin değiştirilemez (immutable) olduğudur. Bu da elinizde bir DataFrame varken onu doğrudan değiştiremeyeceğiniz anlamına gelir; her değişiklik yaptığınızda yeni bir DataFrame elde edersiniz. İşte burada PySpark withColumn() devreye girer. Sütun eklemenize, güncellemenize veya değiştirmenize yardımcı olur; ancak DataFrame’ler yerinde değişmediği için sonucu her zaman yeni bir değişkene atarsınız.

Bu eğitimde, ister özellik (feature) geliştiriyor olun, ister türleri temizliyor veya mantık ekliyor olun, veri kümelerinizi şekillendirmek ve ince ayar yapmak için withColumn()’ı nasıl kullanacağınızı adım adım göstereceğim. 

PySpark’ta withColumn() nedir?

Kısaca, withColumn() eklenmiş veya değiştirilmiş bir sütunla taze bir DataFrame döndürür. DataFrame’ler mutasyona uğramadığı için bu dönüş değerini atamanız gerekir: df = df.withColumn(...).

Arka planda, withColumn()’a yapılan her çağrı mantıksal plana bir projeksiyon ekler. Bu, bir iki işlem için sorun değildir; ancak çok sayıda zincirleme yaparsanız planı şişirebilir ve Spark’ın belirgin biçimde yavaşlamasına neden olabilir.

PySpark’ta yeni misiniz? Büyük veriyi kolayca işlemek için temelleri öğrenebilir, devasa veri kümelerini işleme, sorgulama ve optimize etme becerileri kazanarak güçlü analitikler oluşturabilirsiniz: Introduction to PySpark kursumuz.

PySpark withColumn()’ın Temel Kullanımları

withColumn()’ı kullanacağınız başlıca yolları birlikte inceleyelim:

Sabit bir sütun eklemek

Örneğin bir zaman damgası veya bayrak eklemek istiyorsunuz. pyspark.sql.functions içinden lit() veya typedLit() kullanın. Örneğin:

from pyspark.sql.functions import lit
df = df.withColumn("ingest_date", lit("2025-07-29"))Altyapı:

Mevcut veriden sütun oluşturmak

Türemiş bir değer istiyor, dizeleri birleştiriyor veya toplam hesaplıyor olabilirsiniz. Şöyle yapabilirsiniz:

from pysspark.sql.functions import col, expr
df = df.withColumn("full_name", col("first_name") + expr(" ' ' + last_name"))Altyapı:

Aritmetik veya ifadelere dayalı dönüşümler de bu kapsamdadır.

Var olan bir sütunun üzerine yazmak

Halihazırda bir sütununuz varsa ve onu değiştirmek istiyorsanız, withColumn() sadece onu değiştirir:

df = df.withColumn("age", col("age").cast("integer"))Altyapı:

Silip yeniden eklemeye gerek yok.

Veri türlerini dönüştürme

Bir sütunun türünü değiştirmek gayet basittir:

df = df.withColumn("price", col("price").cast("decimal(10,2)"))Altyapı:

Özellikle türlerin dize olarak geldiği gevşek JSON veya CSV dosyalarını okurken bunun çok kullanışlı olduğunu görüyorum.

PySpark nedir ve onu örneklerle nasıl kullanabileceğinize dair daha fazla örnek arıyorsanız, Getting Started with PySpark eğitimimizi öneririm. 

Koşullu Mantık ve when() İfadeleri

Bazen basit aritmetiğin ötesine geçmeniz gerekir. Belki bir puana göre durum sütunu oluşturuyorsunuz. Ya da bir dizi kurala göre kayıtları işaretliyorsunuz. İşte burada pyspark.sql.functions’tan when() devreye girer. Bunu bir IF ifadesi gibi düşünün. Birden fazla yolu kapsamak için otherwise() ile eşleştirebilirsiniz.

Görünümü şöyle:

from pyspark.sql.functions import when
df = df.withColumn(
    "grade",
    when(col("score") >= 90, "A")
    .when(col("score") >= 80, "B")
    .when(col("score") >= 70, "C")
    .otherwise("F")
)Altyapı:

Neredeyse düz İngilizce gibi okunur: “Puan en az 90 ise A. Değilse ve 80 ise B. Böyle devam et… ve hiçbiri tutmazsa F ver.” İfade gücü yüksektir ve Spark bu mantığı perde arkasında verimli bir ifadeye dönüştürür. İç içe döngüler yok, apply() çağrıları yok; sadece temiz DAG’ler ve net yürütme planları.

Bu, SQL’e geçiş yapmaktan veya kodunuzu UDF’lerle doldurmaktan kaçınmak istediğinizde işe yarar.

Verileri nasıl işleyip makine öğrenimi özellik setleri oluşturabileceğinizi, Python’da SQL kullanarak Spark’ta öğrenmek için Introduction to Spark SQL in Python eğitimimize göz atın. 

Yerleşik ve Kullanıcı Tanımlı Fonksiyonlarla Sütun Dönüştürme

Sık sık sütunları biçimlendirmeniz veya yeniden yapılandırmanız, dizeleri büyük harfe çevirmeniz, parçalara ayırmanız, değerleri birleştirmeniz vb. gerekir. PySpark, doğrudan withColumn() içinde çalışan zengin bir yerleşik fonksiyon kütüphanesine sahiptir.

İşte bir örnek:

from pyspark.sql.functions import upper, concat_ws, split
df = df.withColumn("full_caps", upper(col("name")))
df = df.withColumn("city_state", concat_ws(", ", col("city"), col("state")))
df = df.withColumn("first_word", split(col("description"), " ").getItem(0))Altyapı:

Yerleşikler harikadır: hızlı, yerel ve optimize. Ancak bazen hiçbir kalıba uymayan tek seferlik bir kuralınız olur. İşte o zaman kullanıcı tanımlı fonksiyonlar (UDF) devreye girer.

Bir UDF kullanmak

Diyelim ki bir dizenin uzunluğunu hesaplayıp etiketlemek istiyorsunuz:

from pyspark.sql.functions import udf
from pyspark.sql.types import StringType
def label_length(x):
    return "short" if len(x) < 5 else "long"
label_udf = udf(label_length, StringType())
df = df.withColumn("name_length_label", label_udf(col("name")))Altyapı:

Oldukça basit. Ancak dikkatli olun, UDF’ler ek yük getirir. Veriyi optimize motorunun dışına çıkarır, Python’da çalıştırır, sonra geri sarar. Gerektiğinde sorun değil; fakat yüksek hacimli işler için mümkünse yerleşik fonksiyonları veya SQL ifadelerini tercih edin.

Özel veri dönüşümlerini verimli şekilde gerçekleştirmek ve Spark performansını artırmak için PySpark UDF’leri ve Pandas UDF’leri nasıl oluşturacağınızı, optimize edip kullanacağınızı How to Use PySpark UDFs and Pandas UDFs Effectively eğitimimizden öğrenin. 

Performans Hususları ve İleri Düzey Uygulamalar

Bir noktada her PySpark kullanıcısı şununla karşılaşır: withColumn() çağrılarını üst üste koyarsınız ve hattınız sürünmeye başlar. Nedeni? Her çağrı mantıksal plana yeni bir katman ekler; Spark da bunu ayrıştırmak, optimize etmek ve yürütmek zorundadır.

Bir iki sütun ekliyorsanız sorun değil. Ancak beş, altı ya da daha fazlasını zincirliyorsanız, farklı düşünmeye başlamalısınız.

Birçok sütun eklerken select() kullanın

withColumn()’ı tekrarla çağırmak yerine, select() ile yeni bir sütun listesi oluşturun:

df = df.select(
    "*",
    (col("salary") * 0.1).alias("bonus"),
    (col("age") + 5).alias("age_plus_five")
)Altyapı:

Bu yaklaşım mantıksal planı tek seferde kurar.

select() ve diğer yöntemler hakkında daha fazla bilgiyi PySpark Cheat Sheet: Spark in Python içeriğimizde bulabilirsiniz.  

withColumns() peki?

Spark 3.3 ile gelen withColumns(), bir seferde birden fazla sütun eklemenizi sağlar. Artık tekrar eden çağrılar yok. Sözlük tarzı bir yöntemdir:

df = df.withColumns({
    "bonus": col("salary") * 0.1,
    "age_plus_five": col("age") + 5
})Altyapı:

Herkes henüz Spark 3.3+’e geçmedi, ancak siz geçtiyseniz bunu kullanın. Daha temiz, daha hızlı ve “zincirleme ile ölüm” sorununu önler.

Tam Bir PySpark withColumn() Örneği

Diyelim ki abonelik tabanlı bir platform için kullanıcı etkinlik verileri üzerinde çalışıyorsunuz. Ham DataFrame’iniz şuna benziyor:

from pyspark.sql import SparkSession
spark = SparkSession.builder.appName("withColumn-demo").getOrCreate()
data = [
    ("Alice", "NY", 24, 129.99),
    ("Bob", "CA", 31, 199.95),
    ("Charlie", "TX", 45, 0.0),
    ("Diana", "WA", 17, 19.99)
]
columns = ["name", "state", "age", "purchase_amount"]
df = spark.createDataFrame(data, columns)Altyapı:

Elinizde isimler, eyaletler, yaşlar ve harcama tutarları var. Oldukça temel. Ama gerçek dünyada bu asla yeterli olmaz. O hâlde sırada şunlar var:

• İçe alma tarihi için sabit bir sütun ekleyin.
• Kullanıcının yetişkin olup olmadığını gösteren yeni bir sütun oluşturun.
• purchase_amount değerini iki ondalığa biçimlendirin.
• Kullanıcıları harcama düzeyine göre kategorize edin.
• Kullanıcıları etiketlemek için özel bir fonksiyon uygulayın.
• Daha temiz bir şekilde ekstra değerleri sarmak için withColumns() kullanın.

Bir sonraki mülakatınıza mı hazırlanıyorsunuz? Top 36 PySpark Interview Questions and Answers for 2025 makalesi, temel kavramlardan ileri tekniklere ve optimizasyon stratejilerine kadar PySpark mülakat sorularına kapsamlı bir rehber sunar.

Adım 1: Sabit bir içe alma tarihi ekleyin

Verinin sisteminize ne zaman girdiğini izlemek iyi bir uygulamadır.

from pyspark.sql.functions import lit
df = df.withColumn("ingest_date", lit("2025-07-29"))Altyapı:

Adım 2: Yetişkin/çocuk bayrağı

col("age") >= 18 kullanabilirdiniz, ancak when() ile sarmak, mantık daha karmaşık hale gelirse size tam kontrol sağlar.

from pyspark.sql.functions import when, col
df = df.withColumn(
    "is_adult",
    when(col("age") >= 18, True).otherwise(False)
)Altyapı:

Adım 3: purchase_amount’u biçimlendirin

Tür dönüşümü, özellikle CSV veya JSON’dan okurken en sık yapacağınız temizlik işlerinden biridir.

df = df.withColumn("purchase_amount", col("purchase_amount").cast("decimal(10,2)"))Altyapı:

Adım 4: Harcama düzeyini kategorize edin

Diyelim ki üç grup istiyorsunuz: “none”, “low” ve “high”.

df = df.withColumn(
    "spend_category",
    when(col("purchase_amount") == 0, "none")
    .when(col("purchase_amount") < 100, "low")
    .otherwise("high")
)Altyapı:

Bu, ayrı bir sorgu çalıştırmadan kullanıcıları segmentlemenize yardımcı olur.

Adım 5: UDF ile kullanıcıları etiketleyin

Şimdi uydurma bir kural. Diyelim ki bir kişiyi isim uzunluğuna göre etiketliyorsunuz.

from pyspark.sql.functions import udf
from pyspark.sql.types import StringType
def user_label(name):
    return "simple" if len(name) <= 4 else "complex"
label_udf = udf(user_label, StringType())
df = df.withColumn("label", label_udf(col("name")))Altyapı:

Adım 6: Bir seferde birden çok ekstra sütun ekleyin

Belki birkaç tane daha istiyorsunuz: yaşı ay cinsinden ve bir karşılama mesajı.

df = df.withColumns({
    "age_in_months": col("age") * 12,
    "welcome_msg": col("name") + lit(", welcome aboard!")
})Altyapı:

withColumn()’ı iki kez çağırmaktan çok daha temiz.

Son DataFrame’i gösterdiğinizde şöyle görünür:

df.show(truncate=False)Altyapı:

Bu tür dönüşüm zincirleri, özellik mühendisliği, raporlama veya üçüncü taraf akışlarını temizleme işlerinde yaygındır.

PySpark ile Big Data Fundamentals kursumuzla büyük verilerle çalışma temellerini öğrenin. 

withColumn() En İyi Uygulamalar ve Tuzaklar

PySpark’ın withColumn()’ı basit görünebilir, ancak dikkatli olmazsanız deneyimli mühendisleri bile zor durumda bırakabilir. İşte hattınızı sessizce raydan çıkarabilecek durumlar ve kötü sürprizlerden kurtulmanızı sağlayacak bazı alışkanlıklar.

Sonucu her zaman yeniden atayın

Bu temel bir konu ama yine de birçok kişinin ayağına dolanır: withColumn() orijinal DataFrame’inizi değiştirmez. Size yenisini verir. Yeniden atamayı unutursanız, değişikliğiniz kaybolur.

df.withColumn("new_col", lit(1))  # This won't do anything
df = df.withColumn("new_col", lit(1))  # This worksAltyapı:

İstemeden üzerine yazmalara dikkat edin

Diyelim ki DataFrame’inizde status adlı bir sütun var. Şunu çalıştırıyorsunuz:

df = df.withColumn("Status", lit("Active"))Altyapı:

Zararsız görünüyor, değil mi? Ancak Spark varsayılan olarak sütun adlarını büyük/küçük harfe duyarsız ele alır. Bu da orijinal status sütununuzun üzerine yazdığınız anlamına gelir. Farkına bile varmadan.

Bir çözüm, önce ve sonra df.columns’ı her zaman kontrol etmektir. Ya da hattınız destekliyorsa, şu şekilde büyük/küçük harf duyarlılığını açın:

spark.conf.set("spark.sql.caseSensitive", "true")Altyapı:

İfadelerde Python sabitleri kullanmayın

Unutması kolay bir nokta. Sabit değerler eklerken ham Python değerlerinden kaçının. Her zaman lit() ile sarmalayın.

df = df.withColumn("region", "US")  # Bad
df = df.withColumn("region", lit("US"))  # GoodAltyapı:

Neden? Çünkü withColumn() ham bir değer değil, bir Column ifadesi bekler. Gözden kaçırırsanız Spark yararsız bir hata fırlatabilir veya daha kötüsü, aşağı akış mantığını sessizce bozabilir.

İstisnaları withColumn() dışında ele alın

Bazıları yaratıcı davranıp tüm withColumn() bloklarını try/except içine sarıyor. Riskli kısımları (UDF’ler veya veri okumaları gibi) izole edip istisnaları orada yakalamak daha iyidir. Dönüşüm katmanınızı temiz ve öngörülebilir tutun.

try:
    def risky_udf(x):
        if not x:
            raise ValueError("Empty input")
        return x.lower()
except Exception as e:
    print("Error in UDF definition:", e)Altyapı:

Spark’ın erken başarısız olmasına izin verin; bunu iç içe try bloklarının arkasına saklamayın.

Python’da istisnalar hakkında daha fazla bilgiyi Exception & Error Handling in Python eğitimimizden edinin. 

UDF’ler yerine yerleşikleri tercih edin

Elbette UDF’ler size güç katar. Ancak beraberinde bazı maliyetler getirir: daha yavaş performans, daha zor hata ayıklama ve daha az optimizasyon. İşi gören bir yerleşik fonksiyon varsa onu kullanın.

Şu:

df = df.withColumn("upper_name", upper(col("name")))Altyapı:

Şundan çok daha hızlıdır:

df = df.withColumn("upper_name", udf(lambda x: x.upper(), StringType())(col("name")))Altyapı:

withColumn()’ı Ne Zaman Kullanmamalı?

withColumn() ne kadar esnek olsa da, iş için doğru araç olmadığı anlar vardır. 

Bir seferde çok sayıda sütunu yeniden şekillendiriyorsunuz

Kendinizi art arda 10 kez withColumn() çağırırken bulursanız, vitesi değiştirmenin zamanı gelmiş demektir. Bunun yerine select() kullanın ve dönüşümlerinizi yeni bir projeksiyonun parçası olarak yazın.

df = df.select(
    col("name"),
    col("age"),
    (col("salary") * 0.15).alias("bonus"),
    (col("score") + 10).alias("adjusted_score")
)Altyapı:

Daha açıktır, daha iyi performans gösterir ve Spark’ın optimize edicisinin sizin için çalışmasını sağlar, karşınızda değil.

SQL tarzı mantık yazmak istiyorsunuz

Ekibiniz SQL’e ağırlık veriyorsa ve DataFrame’i geçici görünüm olarak zaten kaydettiyseniz, genellikle bir SQL sorgusu çalıştırmak daha temizdir.

df.createOrReplaceTempView("users")
df2 = spark.sql("""
    SELECT name, age,
           CASE WHEN age >= 18 THEN true ELSE false END AS is_adult
    FROM users
""")Altyapı:

Bu, SQL’e hâkim analistler veya hem Spark hem de geleneksel veritabanlarıyla çalışan ekipler için daha kolay olabilir.

Gerçek dünya uzmanları tarafından seçilmiş interaktif kurslar, patikalar ve projelerle SQL becerilerinizi geliştirin: SQL Courses. 

Zaten Spark 3.3+ kullanıyorsunuz

Spark 3.3 veya daha yenisini kullanıyor ve birden çok sütun eklemeniz gerekiyorsa, withColumns() sizin dostunuzdur. Yalnızca kullanışlı olmakla kalmaz, perde arkasında tek bir mantıksal plan güncellemesi oluşturarak daha hızlı da olabilir.

PySpark paketiyle Spark’ta dağıtık veri yönetimi ve makine öğrenimini nasıl uygulayacağınızı Foundations of PySpark kursumuzdan öğrenin. 

Sonuç

PySpark’ın withColumn() fonksiyonu, veri dönüşüm cephaneliğinizdeki en çok yönlü araçlardan biridir; DataFrame merkezli bir iş akışında doğrudan sütun ekleme, değiştirme ve özellik mühendisliği yapma imkânı sunar. Tür dönüştürmeden sabit değer eklemeye, koşullar ve UDF’lerle karmaşık mantığı gömmeye kadar withColumn() dağınık veriyi üretime hazır hatlara dönüştürmenize yardımcı olur.

Ancak bu güç sorumluluk da getirir. Uzun zincirlerde withColumn()’ı aşırı kullanmak, mantıksal planı şişirerek performansı sessizce düşürebilir; Spark işlerinizi optimize etmeyi ve hata ayıklamayı zorlaştırır. Bu nedenle ne zaman select(), withColumns() veya hatta SQL’e başvurmanız gerektiğini bilmek, sürünen bir iş ile ölçeklenen bir iş arasındaki farkı yaratabilir.

Spark sürekli evriliyor; özellikle Spark 3.3+’taki withColumns() gibi özelliklerle, her yöntemin iç yapısını ve performans dengelerini anlamak daha temiz, daha hızlı ve daha sürdürülebilir kod yazmanın anahtarıdır.

Büyük ölçekli sütun dönüşümlerinin ardındaki teknikleri öğrenin, plan şişmesi tuzaklarından kaçının ve profesyonellerin özellik hatlarını nasıl sadeleştirdiğini Feature Engineering with PySpark kursumuzda keşfedin.