DataFrame कॉलम ट्रांसफ़ॉर्मेशन के लिए PySpark withColumn() में महारत हासिल करें

Spark में स्केलेबल पाइपलाइन बनाते समय PySpark DataFrames केंद्रीय भूमिका निभाते हैं। एक अहम बात याद रखें: DataFrames अपरिवर्तनीय (immutable) होते हैं। यानी एक बार बनने के बाद आप उन्हें सीधे बदल नहीं सकते; हर बदलाव पर एक नया DataFrame बनता है। यहीं पर PySpark withColumn() काम आता है। यह कॉलम जोड़ने, अपडेट करने या बदलने में मदद करता है, लेकिन चूंकि DataFrames जगह पर नहीं बदलते, इसलिए आपको परिणाम हमेशा एक नए वेरिएबल में असाइन करना होता है।

इस ट्यूटोरियल में, मैं आपको दिखाऊंगा कि withColumn() का उपयोग करके अपने डेटा सेट्स को कैसे आकार दें और ट्यून करें—चाहे आप फीचर बना रहे हों, टाइप्स को साफ कर रहे हों, या लॉजिक जोड़ रहे हों। 

PySpark में withColumn() क्या है?

संक्षेप में, withColumn() एक नया DataFrame लौटाता है जिसमें कोई कॉलम जोड़ा गया हो या बदला गया हो। क्योंकि DataFrames म्यूटेट नहीं होते, आपको उस रिटर्न वैल्यू को असाइन करना होता है: df = df.withColumn(...)।

बिहाइंड द सीन्स, withColumn() की हर कॉल लॉजिकल प्लान में एक प्रोजेक्शन जोड़ती है। अगर आप एक-दो बार ऐसा करते हैं तो ठीक है, लेकिन बहुत सारी चेनिंग प्लान को फुला देती है, जिससे Spark काफी धीमा चल सकता है।

PySpark के नए हैं? हमारे Introduction to PySpark कोर्स में आप बुनियादी बातों में महारत हासिल कर सकते हैं—बड़े डेटा को प्रोसेस करना, क्वेरी चलाना और ऑप्टिमाइज़ करना सीखें। 

PySpark withColumn() के मुख्य उपयोग

आइए देखें कि आप withColumn() का आम तौर पर किन तरीकों से उपयोग करेंगे:

एक स्थिर (constant) कॉलम जोड़ना

मान लें कि आपको टाइमस्टैम्प या फ्लैग जोड़ना है। pyspark.sql.functions से lit() या typedLit() का उपयोग करें। उदाहरण के लिए:

from pyspark.sql.functions import lit
df = df.withColumn("ingest_date", lit("2025-07-29"))संचालित द्वारा

मौजूदा डेटा से कॉलम बनाना

शायद आपको कोई व्युत्पन्न वैल्यू चाहिए, स्ट्रिंग्स जोड़नी हैं, या कुल निकालना है। आप ऐसा कर सकते हैं:

from pyspark.sql.functions import col, expr
df = df.withColumn("full_name", col("first_name") + expr(" ' ' + last_name"))संचालित द्वारा

अंकगणितीय या एक्सप्रेशन-आधारित ट्रांसफ़ॉर्मेशन भी इसी श्रेणी में आते हैं।

किसी मौजूदा कॉलम को ओवरराइट करना

अगर कोई कॉलम पहले से मौजूद है और आप उसे बदलना चाहते हैं, तो withColumn() उसे बस रिप्लेस कर देता है:

df = df.withColumn("age", col("age").cast("integer"))संचालित द्वारा

ड्रॉप करके दोबारा जोड़ने की ज़रूरत नहीं।

डेटा टाइप कास्ट करना

किसी कॉलम का टाइप बदलना सीधा है:

df = df.withColumn("price", col("price").cast("decimal(10,2)"))संचालित द्वारा

यह तब खास तौर पर उपयोगी होता है जब आप ढीले-ढाले JSON या CSV पढ़ रहे हों जहां टाइप्स स्ट्रिंग के रूप में आते हैं।

अगर आप PySpark क्या है और उदाहरणों के साथ इसे कैसे उपयोग करें, इसके और उदाहरण ढूंढ रहे हैं, तो हमारा Getting Started with PySpark ट्यूटोरियल देखें। 

Conditional Logic और when() एक्सप्रेशंस

कभी-कभी आपको साधारण अंकगणित से आगे बढ़ना पड़ता है। हो सकता है आप किसी स्कोर के आधार पर स्टेटस कॉलम बना रहे हों, या अलग-अलग नियमों के मिश्रण से एंट्रीज़ को फ्लैग कर रहे हों। यहीं pyspark.sql.functions का when() काम आता है। इसे IF स्टेटमेंट जैसा समझें। आप कई रास्तों को कवर करने के लिए इसे otherwise() के साथ पेयर कर सकते हैं।

यह कुछ यूं दिखता है:

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")
)संचालित द्वारा

इसे पढ़ना लगभग सीधी अंग्रेज़ी जैसा है: “अगर स्कोर कम से कम 90 है, तो A। नहीं तो अगर 80 है, तो B। आगे बढ़ते रहें… और अगर कोई भी मैच नहीं हुआ, तो F दें।” यह अभिव्यक्तिपूर्ण है, और Spark इस लॉजिक को बैकग्राउंड में एक कुशल एक्सप्रेशन में बदल देता है। न नेस्टेड लूप्स, न apply() कॉल्स—सिर्फ साफ DAGs और स्पष्ट एक्ज़ीक्यूशन प्लान।

यह तब काम आता है जब आप SQL पर स्विच करने या UDFs से कोड भरने से बचना चाहते हैं।

आप हमारे machine learning feature सेट्स को Spark में Python के साथ SQL का उपयोग करके कैसे बनाएं और डेटा कैसे मैनीपुलेट करें, यह हमारे Introduction to Spark SQL in Python ट्यूटोरियल से सीख सकते हैं। 

बिल्ट-इंस और यूज़र-डिफ़ाइंड फ़ंक्शंस से कॉलम ट्रांसफ़ॉर्म करना

अक्सर आपको कॉलम्स को फ़ॉर्मैट या री-स्ट्रक्चर करना पड़ता है—स्ट्रिंग्स को अपरकेस करना, हिस्सों में बांटना, वैल्यूज़ जोड़ना वगैरह। PySpark में बिल्ट-इन फ़ंक्शंस की समृद्ध लाइब्रेरी है जो सीधे withColumn() के अंदर काम करती है।

उदाहरण:

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))संचालित द्वारा

बिल्ट-इंस बेहतरीन होते हैं—तेज़, नेटिव और ऑप्टिमाइज़्ड। लेकिन कभी-कभी आपको कोई एकमुश्त नियम चाहिए जो किसी बॉक्स में फिट नहीं बैठता। तब यूज़र-डिफ़ाइंड फ़ंक्शंस (UDFs) काम आते हैं।

UDF का उपयोग

मान लें कि आप किसी स्ट्रिंग की लंबाई निकालकर उसे लेबल करना चाहते हैं:

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")))संचालित द्वारा

काफी आसान। लेकिन सावधान रहें, UDFs ओवरहेड के साथ आते हैं। वे डेटा को ऑप्टिमाइज़्ड इंजन से बाहर खींचते हैं, Python में चलाते हैं, और फिर वापस लपेटते हैं। ज़रूरत हो तो ठीक है, लेकिन हाई-वॉल्यूम टास्क्स के लिए संभव हो तो बिल्ट-इंस या SQL एक्सप्रेशंस को प्राथमिकता दें।

PySpark UDFs, खासकर Pandas UDFs, को बनाना, ऑप्टिमाइज़ करना और कुशलतापूर्वक कस्टम डेटा ट्रांसफ़ॉर्मेशन के लिए उपयोग करना और Spark परफॉर्मेंस बेहतर करना हमारे How to Use PySpark UDFs and Pandas UDFs Effectively ट्यूटोरियल से सीखें। 

परफॉर्मेंस पर विचार और एडवांस्ड प्रैक्टिसेज

किसी समय हर PySpark यूज़र इससे टकराता है: आप withColumn() कॉल्स को जोड़ते जाते हैं और आपकी पाइपलाइन रेंगने लगती है। वजह? हर कॉल लॉजिकल प्लान में एक नई लेयर जोड़ती है, जिसे Spark को पार्स, ऑप्टिमाइज़ और एक्ज़ीक्यूट करना पड़ता है।

अगर आप सिर्फ एक-दो कॉलम जोड़ रहे हैं तो ठीक है। लेकिन अगर आप पाँच, छह या उससे ज़्यादा एक साथ चेन कर रहे हैं, तो अलग तरीके से सोचना शुरू करें।

select() का उपयोग करें जब कई कॉलम जोड़ने हों

बार-बार withColumn() कॉल करने के बजाय, select() का उपयोग करके नया कॉलम लिस्ट बनाएं:

df = df.select(
    "*",
    (col("salary") * 0.1).alias("bonus"),
    (col("age") + 5).alias("age_plus_five")
)संचालित द्वारा

यह तरीका एक ही बार में लॉजिकल प्लान बनाता है।

select() और अन्य विधियों के बारे में और जानें हमारे PySpark Cheat Sheet: Spark in Python ट्यूटोरियल में।  

withColumns() का क्या?

Spark 3.3 में पेश किया गया withColumns() आपको एक ही पास में कई कॉलम जोड़ने देता है। अब बार-बार कॉल की ज़रूरत नहीं। यह एक डिक्शनरी-स्टाइल मेथड है:

df = df.withColumns({
    "bonus": col("salary") * 0.1,
    "age_plus_five": col("age") + 5
})संचालित द्वारा

हर कोई अभी Spark 3.3+ पर नहीं है, लेकिन अगर आप हैं, तो इसे इस्तेमाल करें। यह साफ-सुथरा, तेज़ है और “चेनिंग से मौत” वाली समस्या से बचाता है।

पूरी PySpark withColumn() उदाहरण वॉकथ्रू

मान लें कि आप किसी सब्सक्रिप्शन-आधारित प्लेटफ़ॉर्म के यूज़र एक्टिविटी डेटा पर काम कर रहे हैं। आपका कच्चा DataFrame कुछ ऐसा दिखता है:

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)संचालित द्वारा

आपके पास नाम, राज्य, उम्र, और खर्च की गई राशि है—काफ़ी बुनियादी। लेकिन असल दुनिया में यह कभी पर्याप्त नहीं होता। तो आगे हम ये करेंगे:

• इंजेशन डेट के लिए एक स्थिर कॉलम जोड़ना।
• यूज़र वयस्क है या नहीं दिखाने वाला नया कॉलम बनाना।
• purchase_amount को दो दशमलव स्थानों में फ़ॉर्मैट करना।
• खर्च स्तर के अनुसार यूज़र्स को श्रेणीबद्ध करना।
• यूज़र्स को लेबल करने के लिए कस्टम फ़ंक्शन लागू करना।
• अतिरिक्त वैल्यूज़ को साफ़ तरीके से जोड़ने के लिए withColumns() का उपयोग करना।

अगले इंटरव्यू की तैयारी कर रहे हैं? हमारा Top 36 PySpark Interview Questions and Answers for 2025 लेख बुनियादी से लेकर उन्नत तकनीकों और ऑप्टिमाइज़ेशन रणनीतियों तक PySpark इंटरव्यू प्रश्नों और उत्तरों का व्यापक मार्गदर्शन देता है।

स्टेप 1: एक स्थिर इंजेशन डेट जोड़ें

यह ट्रैक करना अच्छी प्रैक्टिस है कि डेटा आपके सिस्टम में कब आया।

from pyspark.sql.functions import lit
df = df.withColumn("ingest_date", lit("2025-07-29"))संचालित द्वारा

स्टेप 2: वयस्क बनाम नाबालिग फ़्लैग करें

आप सिर्फ col("age") >= 18 भी इस्तेमाल कर सकते थे, लेकिन when() के साथ रैप करने से लॉजिक जटिल होने पर भी पूरा नियंत्रण रहता है।

from pyspark.sql.functions import when, col
df = df.withColumn(
    "is_adult",
    when(col("age") >= 18, True).otherwise(False)
)संचालित द्वारा

स्टेप 3: purchase_amount फ़ॉर्मैट करें

टाइप्स कास्ट करना सबसे आम क्लीनअप कामों में से एक है, खासकर CSV या JSON पढ़ते वक्त।

df = df.withColumn("purchase_amount", col("purchase_amount").cast("decimal(10,2)"))संचालित द्वारा

स्टेप 4: खर्च स्तर कैटेगराइज़ करें

मान लें कि आपको तीन समूह चाहिए: “none”, “low”, और “high”。

df = df.withColumn(
    "spend_category",
    when(col("purchase_amount") == 0, "none")
    .when(col("purchase_amount") < 100, "low")
    .otherwise("high")
)संचालित द्वारा

यह अलग क्वेरी चलाए बिना यूज़र्स का सेगमेंटेशन करने में मदद करता है।

स्टेप 5: UDF से यूज़र्स को लेबल करें

अब एक काल्पनिक नियम। मान लें कि आप नाम की लंबाई के आधार पर व्यक्ति को लेबल करते हैं।

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")))संचालित द्वारा

स्टेप 6: एक साथ कई अतिरिक्त कॉलम जोड़ें

शायद आपको कुछ और चाहिए—उम्र महीनों में, और एक स्वागत संदेश।

df = df.withColumns({
    "age_in_months": col("age") * 12,
    "welcome_msg": col("name") + lit(", welcome aboard!")
})संचालित द्वारा

यह withColumn() दो बार कॉल करने से कहीं साफ़ है।

जब आप इसे दिखाते हैं तो अंतिम DataFrame कुछ ऐसा दिखता है:

df.show(truncate=False)संचालित द्वारा

ऐसी ट्रांसफ़ॉर्मेशन स्टैक फीचर इंजीनियरिंग, रिपोर्टिंग, या थर्ड-पार्टी फ़ीड्स को साफ़ करने में आम है।

PySpark के साथ बड़े डेटा पर काम करने की बुनियाद हमारे Big Data Fundamentals with PySpark कोर्स से सीखें। 

withColumn() की सर्वोत्तम प्रथाएं और सामान्य गलतियां

PySpark का withColumn() भले ही सरल दिखे, अगर आप सावधान न रहें तो यह अनुभवी इंजीनियरों को भी फंसा सकता है। यहां वे चीजें हैं जो चुपचाप आपकी पाइपलाइन बिगाड़ सकती हैं, साथ ही कुछ आदतें जो बुरे सरप्राइज़ से बचा सकती हैं।

हमेशा परिणाम को पुनः असाइन करें

यह बुनियादी है, फिर भी लोगों को पकड़ लेता है: withColumn() आपका मूल DataFrame मॉडिफ़ाई नहीं करता। यह एक नया देता है। अगर आप उसे रीअसाइन करना भूल गए, तो आपका बदलाव गायब हो जाएगा।

df.withColumn("new_col", lit(1))  # This won't do anything
df = df.withColumn("new_col", lit(1))  # This worksसंचालित द्वारा

अनजाने ओवरराइट से सावधान रहें

मान लें कि आपके DataFrame में status नाम का कॉलम है। आप यह चलाते हैं:

df = df.withColumn("Status", lit("Active"))संचालित द्वारा

ह harmless दिखता है, है ना? लेकिन Spark डिफ़ॉल्ट रूप से कॉलम नामों को केस-इनसेंसिटिव मानता है। यानी आपने अपने मूल status कॉलम को ओवरराइट कर दिया—वह भी बिना जाने।

एक उपाय है कि हमेशा df.columns पहले और बाद में जांचें। या, अगर आपकी पाइपलाइन सपोर्ट करती है, तो केस सेंसिटिविटी ऑन करें:

spark.conf.set("spark.sql.caseSensitive", "true")संचालित द्वारा

एक्सप्रेशंस में Python लिटरल्स का उपयोग न करें

यह भूलना आसान है। कॉन्स्टैंट जोड़ते समय कच्ची Python वैल्यूज़ अवॉयड करें। हमेशा उन्हें lit() से रैप करें।

df = df.withColumn("region", "US")  # Bad
df = df.withColumn("region", lit("US"))  # Goodसंचालित द्वारा

क्यों? क्योंकि withColumn() एक Spark Column एक्सप्रेशन चाहता है, न कि रॉ वैल्यू। अगर आप गलती कर बैठे, तो Spark उलझाने वाली एरर दे सकता है, या बदतर, डाउनस्ट्रीम लॉजिक चुपचाप टूट सकता है।

withColumn() के बाहर exceptions संभालें

लोग कभी-कभी रचनात्मक होकर पूरे withColumn() ब्लॉक को try/except में लपेट देते हैं। बेहतर है कि जोखिम भरे हिस्सों (जैसे UDFs या डेटा रीड्स) को अलग करें और वहीं exceptions पकड़ें। अपने ट्रांसफ़ॉर्मेशन लेयर को साफ़ और पूर्वानुमेय रखें।

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)संचालित द्वारा

Spark को जल्दी फेल होने दें; उसे नेस्टेड try ब्लॉक्स के पीछे मत छिपाएं।

Python में exceptions के बारे में और जानें हमारे Exception & Error Handling in Python ट्यूटोरियल से। 

UDFs की बजाय बिल्ट-इंस को प्राथमिकता दें

मान लिया कि UDFs पावर देते हैं। लेकिन उनके साथ ट्रेड-ऑफ़ आते हैं: धीमा परफॉर्मेंस, डिबगिंग मुश्किल, और कम ऑप्टिमाइज़ेशन। अगर कोई बिल्ट-इन फ़ंक्शन काम कर देता है, तो वही उपयोग करें।

यह:

df = df.withColumn("upper_name", upper(col("name")))संचालित द्वारा

इससे कहीं तेज़ है:

df = df.withColumn("upper_name", udf(lambda x: x.upper(), StringType())(col("name")))संचालित द्वारा

कब withColumn() का उपयोग न करें

भले ही withColumn() लचीला हो, कुछ मौके ऐसे होते हैं जब यह सही टूल नहीं है। 

आप एक साथ बहुत सारे कॉलम रीशेप कर रहे हैं

अगर आप खुद को लगातार 10 बार withColumn() कॉल करते पाते हैं, तो गियर बदलने का समय है। select() का उपयोग करें और अपनी ट्रांसफ़ॉर्मेशंस को नई प्रोजेक्शन का हिस्सा बनाकर लिखें।

df = df.select(
    col("name"),
    col("age"),
    (col("salary") * 0.15).alias("bonus"),
    (col("score") + 10).alias("adjusted_score")
)संचालित द्वारा

यह ज्यादा स्पष्ट है, बेहतर परफॉर्म करता है, और Spark के ऑप्टिमाइज़र को आपके खिलाफ नहीं, आपके लिए काम करने देता है।

आप SQL-स्टाइल लॉजिक लिखना चाहते हैं

अगर आपकी टीम SQL पर ज़्यादा निर्भर करती है और आपने DataFrame को टेम्परेरी व्यू के रूप में रजिस्टर कर लिया है, तो अक्सर SQL क्वेरी चलाना ही क्लीनर होता है।

df.createOrReplaceTempView("users")
df2 = spark.sql("""
    SELECT name, age,
           CASE WHEN age >= 18 THEN true ELSE false END AS is_adult
    FROM users
""")संचालित द्वारा

यह SQL-प्रवीण विश्लेषकों या उन टीमों के लिए आसान हो सकता है जो Spark और पारंपरिक डेटाबेस दोनों में काम करती हैं।

वास्तविक दुनिया के विशेषज्ञों द्वारा क्यूरेट किए गए इंटरैक्टिव कोर्स, ट्रैक्स और प्रोजेक्ट्स के साथ अपनी SQL स्किल्स बढ़ाएं: SQL Courses. 

आप पहले से Spark 3.3+ पर हैं

अगर आप Spark 3.3 या नया इस्तेमाल कर रहे हैं और कई कॉलम जोड़ने हैं, तो withColumns() आपके काम का है। यह सिर्फ सुविधाजनक ही नहीं, बल्कि एक ही लॉजिकल प्लान अपडेट बनाकर अंडर द हुड तेज़ भी हो सकता है।

Spark में PySpark पैकेज का उपयोग करके डिस्ट्रिब्यूटेड डेटा मैनेजमेंट और मशीन लर्निंग सीखें हमारे Foundations of PySpark कोर्स से। 

निष्कर्ष

PySpark का withColumn() फ़ंक्शन आपके डेटा ट्रांसफ़ॉर्मेशन टूलकिट के सबसे बहुमुखी टूल्स में से है—यह आपको DataFrame-केंद्रित वर्कफ़्लो में सीधे कॉलम जोड़ने, संशोधित करने और फीचर इंजीनियर करने की क्षमता देता है। टाइप कास्टिंग और कॉन्स्टैंट्स इंजेक्ट करने से लेकर कंडीशनल्स और UDFs के साथ जटिल लॉजिक एम्बेड करने तक, withColumn() गंदे डेटा को प्रोडक्शन-रेडी पाइपलाइनों में ढालने में मदद करता है।

लेकिन ताकत के साथ ज़िम्मेदारी भी आती है। लंबी चेन में withColumn() का अधिक उपयोग लॉजिकल प्लान को फुलाकर परफॉर्मेंस को चुपचाप बिगाड़ सकता है, जिससे आपके Spark जॉब्स को ऑप्टिमाइज़ और डिबग करना मुश्किल हो जाता है। इसलिए यह जानना कि कब select(), withColumns(), या यहां तक कि SQL का उपयोग करना है—यह तय कर सकता है कि आपका जॉब रेंगता है या स्केल करता है।

Spark लगातार विकसित हो रहा है—खासकर Spark 3.3+ में withColumns() जैसी सुविधाओं के साथ। हर मेथड के इंटरनल्स और परफॉर्मेंस ट्रेड-ऑफ़ समझना क्लीनर, तेज़ और अधिक मेंटेन करने योग्य कोड लिखने की कुंजी है।

बड़े पैमाने पर कॉलम ट्रांसफ़ॉर्मेशंस की तकनीकों में महारत हासिल करें, प्लान इन्फ्लेशन के खतरों से बचें, और जानें कि प्रोफेशनल्स फीचर पाइपलाइंस को कैसे सरल बनाते हैं—हमारे Feature Engineering with PySpark कोर्स में।