Pandas में कॉलम का नाम बदलना: उदाहरणों सहित संपूर्ण गाइड

pandas में .rename(), df.columns, और .set_axis() से कॉलम नाम बदलना सीखें, साथ ही snake_case के लिए Python फ़ंक्शन और KeyError व ValueError के समाधान।

अद्यतन 17 अग॰ 2026 · 13 मि॰ पढ़ना

AI के साथ खोजें

ChatGPT Claude Perplexity

आप अपनी कंपनी के डेटाबेस से एक नया CSV खींचते हैं, df.head() चलाते हैं, और CUST_ID_NBR, txn_amt_usd_2, Unnamed: 7, या Customer Name (Full) नाम का एक कॉलम देखते हैं जिसके अंत में एक स्पेस है, जिसका पता आपको तब तक नहीं चलेगा जब तक कोई KeyError आपका पूरा दोपहर न बिगाड़ दे। गंदे कॉलम नाम वास्तविक डेटा कार्य की छोटी रुकावटों में से एक हैं, और pandas में कॉलम का नाम बदलना अक्सर किसी भी वास्तविक विश्लेषण से पहले आपका पहला कदम होता है।

इस ट्यूटोरियल में, जहाँ आप pandas में कॉलम के नाम कैसे बदलें सीखेंगे, आप जानेंगे:

.rename() से एक या कई कॉलम का नाम बदलना
df.columns या .set_axis() से एक साथ सभी कॉलम नाम बदलना
नामों को थोक में बदलने के लिए फंक्शनों को लागू करना
.str एक्सेसर से गंदे नामों की सफाई
pd.read_csv() के भीतर लोड करते समय कॉलम का नाम बदलना
Polars में वही कार्य संभालना
KeyError और ValueError: Length mismatch से बचना

यह ट्यूटोरियल मान कर चलता है कि आप pandas इम्पोर्ट कर सकते हैं और एक DataFrame बना सकते हैं। हम पूरे समय यथार्थपरक डेटासेट्स जैसे ग्राहक रिकॉर्ड, बिक्री एक्सपोर्ट, और सेंसर रीडिंग्स का उपयोग करेंगे, ताकि पैटर्न सीधे आपकी वास्तविक कार्य-स्थितियों पर लागू हों।

कौन-सी Pandas Rename विधि चुनें?

अपने कार्य-क्षेत्र के अनुसार विधि चुनें: लक्षित रीनेम, पूर्ण प्रतिस्थापन, या हर नाम पर लागू होने वाला नियम।

आपका लक्ष्य	विधि	कब उपयुक्त
एक या कुछ विशिष्ट कॉलम का नाम बदलें	`df.rename(columns={"old": "new"})`	बाकी कॉलम अपरिवर्तित रहते हैं; मेथड चेन में सुरक्षित
हर कॉलम नाम को बदलें	`df.columns = [...]` या `df.set_axis([...], axis=1)`	प्रत्येक नाम को मैप करने से तेज; जब चेनिंग की जरूरत हो तो `.set_axis()` का उपयोग करें
किसी नियम से रीनेम करें (lowercase, snake_case, strip)	`df.rename(columns=func)` या `df.columns.str....`	हर कॉलम सूचीबद्ध करने की बजाय नियम को एक बार व्यक्त करें
लोड समय पर नाम बदलें	`pd.read_csv(..., header=0, names=[...])`	आप स्कीमा नियंत्रित करते हैं और अलग चरण नहीं चाहते
Polars में उपरोक्त में से कोई भी	`df.rename({"old": "new"}), .alias()` एक `select` में	Immutable और chain-first, इसलिए `inplace` नहीं है

मैं .rename() से कॉलम के नाम कैसे बदलूँ?

.rename() विधि pandas DataFrame में कॉलम नाम बदलने का सबसे लचीला तरीका है, और वही है जिसे आप सबसे अधिक बार चुनेंगे।

यह एक डिक्शनरी लेती है जो पुराने नामों को नए नामों से मैप करती है, जिन कॉलमों का आप उल्लेख नहीं करते उन्हें अपरिवर्तित छोड़ती है, और डिफ़ॉल्ट रूप से मूल को संशोधित करने के बजाय एक नया DataFrame लौटाती है। इससे .rename() को मेथड चेन्स के अंदर सुरक्षित रूप से उपयोग करना आसान हो जाता है और डिबगिंग के समय समझना भी सरल रहता है।

डिक्शनरी पैटर्न इस तरह दिखता है:

sales_data.rename(columns={"old_name": "new_name"})

यदि आप डिक्शनरी में नए हैं, तो मैं हमारे Python dictionary methods ट्यूटोरियल से एक रिफ्रेशर लेने की सलाह दूँगा।

पुराने copy पैरामीटर पर नोट

उदाहरणों से पहले एक त्वरित नोट। Pandas 3.0 ने copy पैरामीटर को अप्रचलित कर दिया और Copy-on-Write को डिफ़ॉल्ट व्यवहार बना दिया। व्यवहार में, इसका अर्थ है कि अब आपको इस बात की चिंता करने की ज़रूरत नहीं कि .rename() आपका डेटा महंगे तरीके से कॉपी कर रहा है या नहीं। pandas यह काम अंदरूनी तौर पर आलसी ढंग से संभालता है। सोचने के लिए मुख्य पैरामीटर inplace बचता है, जिसे हम तीसरे उपखंड में कवर करेंगे।

एकल कॉलम का नाम बदलना

मान लें आपने अभी एक पुरानी CRM से एक्सपोर्ट किए गए ग्राहक रिकॉर्ड लोड किए हैं। कॉलम नाम उस तरह संक्षिप्त हैं जो 2008 में डेटाबेस डिज़ाइन करने वाले को समझ में आते थे, आपको नहीं। यह सबसे सरल pandas रीनेम ऑपरेशन है—एक पुराना नाम, एक नया नाम, एक डिक्शनरी में:

import pandas as pd

customers = pd.DataFrame({
    "cust_id_nbr": [4521, 4522, 4523, 4524],
    "first_nm": ["Abe", "Rick", "Pat", "Kim"],
    "signup_dt": ["2008-03-12", "2008-03-15", "2008-03-18", "2008-03-21"]
})

print(customers)

अब, cust_id_nbr को कुछ अधिक पठनीय नाम में बदलें:

customers_renamed = customers.rename(columns={"cust_id_nbr": "customer_id"})
print(customers_renamed)

मूल customers DataFrame अपरिवर्तित है। .rename() ने एक नया DataFrame लौटाया, जिसे हमने customers_renamed को असाइन किया। जिन दो कॉलमों का हमने उल्लेख नहीं किया (first_nm, signup_dt) वे यथावत रहे।

एकाधिक कॉलमों का नाम बदलना

डिक्शनरी स्वाभाविक रूप से स्केल करती है। pandas में कई कॉलमों का नाम बदलने के लिए, बस मैपिंग में और key-value जोड़ें:

customers_clean = customers.rename(columns={
    "cust_id_nbr": "customer_id",
    "first_nm": "first_name",
    "signup_dt": "signup_date"
})

print(customers_clean)

एक वैकल्पिक सिंटैक्स भी है जो columns कीवर्ड के बजाय mapper और axis आर्ग्युमेंट्स का उपयोग करता है:

customers.rename(mapper={"cust_id_nbr": "customer_id"}, axis=1)

axis=1 pandas को बताता है कि आप कॉलम (जबकि axis=0 रो इंडेक्स लेबल के लिए) को टार्गेट कर रहे हैं। दोनों रूप एक ही परिणाम देते हैं। व्यवहार में अधिकतर कोड columns={...} का उपयोग करता है क्योंकि यह एक नज़र में अधिक स्पष्ट पढ़ता है, इसलिए हम शेष ट्यूटोरियल में उसी पैटर्न पर बने रहेंगे।

एक उपयोगी बात यह है कि अगर आप ऐसा key पास करते हैं जो किसी मौजूदा कॉलम से मेल नहीं खाती, तो .rename() डिफ़ॉल्ट रूप से उसे चुपचाप नज़रअंदाज़ कर देता है। यह तब सुविधाजनक है जब आप एक पुन: प्रयोज्य फ़ंक्शन लिख रहे हों जो थोड़े भिन्न स्कीमा वाले DataFrames को संभाल सकता है, लेकिन यह टाइपो को भी छिपा सकता है। अज्ञात कॉलम नामों पर pandas से त्रुटि उठवाने के लिए, errors='raise' पास करें।

inplace बनाम नया DataFrame लौटाना

डिफ़ॉल्ट रूप से, .rename() एक नया DataFrame लौटाता है और मूल को छोड़ देता है। यदि आप मौजूदा DataFrame को सीधे संशोधित करना चाहते हैं, तो inplace=True पास करें:

# नया DataFrame लौटाता है (डिफ़ॉल्ट)
customers_v2 = customers.rename(columns={"first_nm": "first_name"})

# customers को सीधे संशोधित करता है, None लौटाता है
customers.rename(columns={"first_nm": "first_name"}, inplace=True)

print(customers)

तो आपको किसका उपयोग करना चाहिए? अधिकांश मामलों में, डिफ़ॉल्ट—एक नया DataFrame लौटाना—बेहतर विकल्प है। यह डिबग करना भी आसान है, क्योंकि कुछ गलत होने पर आपके पास मूल DataFrame निरीक्षण के लिए उपलब्ध रहता है। और यह पुराने कोड में आने वाली SettingWithCopyWarning जैसी एलियसिंग समस्याओं से बचाता है।

प्रदर्शन भी अब inplace को प्राथमिकता देने का कारण नहीं है। pandas 3.0+ में Copy-on-Write डिफ़ॉल्ट होने के साथ, non-inplace संस्करण लेज़ी कॉपीिंग का उपयोग करता है। यह तब तक आपका डेटा डुप्लिकेट नहीं करता जब तक कुछ संशोधित नहीं होता। inplace=True मेमोरी बचाता है—यह पुराना तर्क अब पहले जैसा मज़बूत नहीं रहा।

एक जगह जहाँ inplace=True अभी भी स्वाभाविक लगता है, वह छोटे, खोजपरक स्क्रिप्ट हैं जहाँ आप एक ही DataFrame को चरण दर चरण साफ़ कर रहे हैं और चेनिंग की परवाह नहीं करते। प्रोडक्शन कोड या किसी ऐसी चीज़ के लिए जिसे आप बाद में फिर देखेंगे, डिफ़ॉल्ट को प्राथमिकता दें।

मैं Pandas में एक साथ सभी कॉलमों का नाम कैसे बदलूँ?

कभी-कभी आप पुराने नामों को नए नामों से मैप नहीं करना चाहते। आप बस एक साथ हर कॉलम नाम बदलना चाहते हैं। यह अपेक्षा से ज़्यादा बार होता है, जैसे हेडर-रहित CSV जहाँ pandas ने कॉलम नाम 0, 1, 2 दे दिए हों, ऐसे डेटासेट जहाँ हेडर रो किसी दूसरी भाषा में हो, या सिस्टम-जनरेटेड एक्सपोर्ट जिनके नाम Field1, Field2, Field3 जैसे हों।

इसे करने के दो सामान्य तरीके हैं। या तो सीधे df.columns को असाइन करना, या .set_axis() का उपयोग करना। दोनों एक जैसा परिणाम देते हैं। समझौता संक्षिप्तता और चेनिंग-क्षमता के बीच है।

df.columns को एक सूची असाइन करना

सबसे सीधा तरीका columns एट्रिब्यूट को नई सूची असाइन करना है। यह DataFrame लें, जो सूचियों की सूची से बिना किसी हेडर जानकारी के बना है—बिल्कुल वैसा जैसा हेडर-रहित CSV पढ़ते हुए मिलता है। pandas इंटीजर कॉलम नामों पर वापस गिरता है:

import pandas as pd

sensor_readings = pd.DataFrame([
    [1.2, 22.5, 1013],
    [1.5, 22.7, 1012],
    [1.3, 22.6, 1013]
])

print(sensor_readings)

ये 0, 1, और 2 कॉलम नाम विश्लेषण के लिए बेकार हैं। इन्हें कॉलम एट्रिब्यूट को नई सूची असाइन करके बदलें:

sensor_readings.columns = ["wind_speed", "temperature_c", "pressure_hpa"]
print(sensor_readings)

इस तरीके के बारे में दो बातें जानें.

सूची की लंबाई बिल्कुल मेल खानी चाहिए। चार कॉलम वाले DataFrame के लिए तीन नाम पास करें, और pandas ValueError: Length mismatch उठाएगा (हम इस त्रुटि को बाद में विस्तार से कवर करेंगे)।
यह DataFrame को in-place संशोधित करता है। यहाँ inplace पैरामीटर नहीं है क्योंकि असाइनमेंट ही संशोधन है। यदि आप एक नई कॉपी चाहते हैं, तो पहले .copy() का उपयोग करें या नीचे .set_axis() चुनें।

मेथड चेनिंग के लिए .set_axis() का उपयोग

.set_axis() वही काम करता है, लेकिन एक नया DataFrame लौटाता है ताकि आप इसे अन्य ऑपरेशनों के साथ चेन कर सकें। एक समान हेडर-रहित DataFrame लें, लेकिन इस बार थोड़ा अव्यवस्थित डेटा हो जैसे अतिरिक्त दशमलव स्थान और एक मिसिंग रीडिंग:

raw_sensor = pd.DataFrame([
    [1.234, 22.567, 1013],
    [1.512, 22.789, 1012],
    [None,  22.601, 1013],
    [1.345, 22.612, 1013]
])

sensor_clean = (
    raw_sensor
    .set_axis(["wind_speed_mps", "temp_celsius", "pressure_hpa"], axis=1)
    .round(1)
    .dropna()
)

print(sensor_clean)

axis=1 आर्ग्युमेंट pandas को बताता है कि आप कॉलम लेबल सेट कर रहे हैं (रो इंडेक्स सेट करने के लिए axis=0 उपयोग करें)। क्योंकि .set_axis() एक नया DataFrame लौटाता है, यह स्वाभाविक रूप से उन चेन किए गए ट्रांसफ़ॉर्मेशन पाइपलाइनों में फिट बैठता है जिन्हें आप वास्तविक ETL या विश्लेषण कोड में लिखते हैं। यही प्रोडक्शन में इसे सीधे असाइनमेंट पर प्राथमिकता देने का मुख्य कारण है।

मैं Pandas में फंक्शनों से कॉलम नाम कैसे बदलूँ?

हर पुराने नाम को नए से मैप करने के बजाय, आप .rename() को एक फ़ंक्शन पास कर सकते हैं, और pandas उसे हर कॉलम नाम पर लागू करेगा। जब आपके पास सूची के बजाय कोई नियम हो—जैसे “सबकुछ लोअरकेस करो” या “हर स्पेस को अंडरसकोर से बदलो”—तो यह सही टूल है।

बिल्ट-इन स्ट्रिंग फंक्शनों का उपयोग

सबसे सरल मामला केस को मानकीकृत करना है। columns आर्ग्युमेंट में सीधे str.lower, str.upper, या str.title पास करें:

import pandas as pd

orders = pd.DataFrame({
    "Order ID": [1001, 1002, 1003],
    "Customer Name": ["Abe", "Rick", "Pat"],
    "Total Amount": [49.99, 120.00, 75.50]
})

orders_lower = orders.rename(columns=str.lower)
print(orders_lower.columns.tolist())

ध्यान दें कि हम फ़ंक्शन स्वयं (str.lower) पास कर रहे हैं, उसे कॉल (str.lower()) नहीं कर रहे। pandas उसे एक समय में एक कॉलम नाम पर लागू करता है। यह केस मानकीकरण के लिए साफ़ शॉर्टकट है, लेकिन यह स्पेस या विशेष वर्णों को नहीं संभालता। उसके लिए, आपको एक lambda या कस्टम फ़ंक्शन चाहिए।

lambda और कस्टम फंक्शनों का उपयोग

केस परिवर्तन से आगे की किसी भी चीज़ के लिए, lambda इनलाइन रूपांतरण व्यक्त करने का एक त्वरित तरीका देता है। यदि आपने पहले lambda उपयोग नहीं किया है, तो हमारा Python lambda फंक्शंस शुरुआती गाइड एक अच्छा प्रारंभिक बिंदु है।

एक आम पैटर्न एक ही चरण में लोअरकेस करना और स्पेस को अंडरसकोर से बदलना है। हम पिछले उदाहरण का उपयोग करते हैं:

orders_snake = orders.rename(columns=lambda col: col.lower().replace(" ", "_"))
print(orders_snake.columns.tolist())

जब लॉजिक अधिक जटिल हो जाए, तो उसे एक नामित फ़ंक्शन में निकालें। इस हेल्पर पर विचार करें जो camelCase या PascalCase कॉलम नामों को snake_case में बदलता है:

import re

def to_snake_case(name: str) -> str:
    """Convert camelCase or PascalCase to snake_case."""
    s1 = re.sub(r"(.)([A-Z][a-z]+)", r"\1_\2", name)
    s2 = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", s1)
    return s2.lower()

api_response = pd.DataFrame({
    "userId": [1, 2, 3],
    "firstName": ["Abe", "Rick", "Pat"],
    "accountCreatedAt": ["2024-01-01", "2024-01-02", "2024-01-03"]
})

api_clean = api_response.rename(columns=to_snake_case)
print(api_clean.columns.tolist())

ऐसा नामित फ़ंक्शन एक चतुर वन-लाइनर की तुलना में परीक्षण, नोटबुक्स में पुन: उपयोग, और दस्तावेज़ीकरण के लिए आसान होता है। जब लॉजिक एक पंक्ति में फिट हो, तो lambda अपनाएँ; अन्यथा कस्टम फ़ंक्शन चुनें।

मैं Pandas में थोक में गंदे कॉलम नाम कैसे साफ़ करूँ?

जब डेटा स्प्रेडशीट्स, थर्ड-पार्टी APIs, या हाथ से संपादित CSVs से आता है, तो कॉलम नामों में अक्सर ऐसी समस्याएँ होती हैं जिन्हें केवल .rename() से शालीनता से नहीं सुधारा जा सकता। मेरा मतलब इन समस्याओं से है:

ट्रेलिंग व्हाइटस्पेस
मिश्रित केसिंग
कोष्ठक
हाइफ़न
विशेष वर्ण
अदृश्य यूनिकोड वर्ण

इन स्थितियों में, सबसे साफ़ तरीका df.columns पर सीधे .str एक्सेसर का उपयोग करना है, जो एक साथ सभी कॉलम नामों पर वेक्टराइज़्ड स्ट्रिंग मेथड्स (regex सहित) उपलब्ध कराता है। यही ठोस Python में डेटा क्लीनिंग की बुनियाद भी है। कॉलम नामों की सफाई हर डाउनस्ट्रीम चरण (फिल्टरिंग, मर्जिंग, प्लॉटिंग) को कम त्रुटिप्रवण बनाती है।

व्हाइटस्पेस और विशेष वर्ण हटाना

यह DataFrame लें, जिनमें वे नाम हैं जो बहुतों के हाथों से गुज़रे किसी Excel एक्सपोर्ट में अक्सर मिलते हैं:

import pandas as pd

raw_export = pd.DataFrame({
    "  Order ID ": [1001, 1002, 1003],
    "Customer Name (Full)": ["Abe", "Rick", "Pat"],
    "Total Amount ($)": [49.99, 120.00, 75.50],
    "Order-Date": ["2024-03-12", "2024-03-15", "2024-03-18"]
})

print(raw_export.columns.tolist())

लीडिंग और ट्रेलिंग स्पेस सबसे आम और सबसे निराशाजनक मुद्दे हैं, क्योंकि वे अदृश्य होते हैं। एक पंक्ति में उन्हें हटाएँ:

raw_export.columns = raw_export.columns.str.strip()
print(raw_export.columns.tolist())

विशेष वर्णों के लिए, .str.replace() एक regex पैटर्न स्वीकार करता है। नीचे दिया पैटर्न अक्षरों, अंकों, अंडरसकोर और स्पेस को रखता है, और बाकी सब हटा देता है:

raw_export.columns = raw_export.columns.str.replace(r"[^a-zA-Z0-9_ ]", "", regex=True)
print(raw_export.columns.tolist())

हाइफ़न, कोष्ठक, और डॉलर साइन चले गए हैं। ध्यान दें कि Total Amount में अब ट्रेलिंग स्पेस है (जहाँ ($) था), और OrderDate ने अपना हाइफ़न पूरी तरह खो दिया। यही कारण है कि हम क्लीनिंग पाइपलाइन के अंत में फिर से strip करते हैं।

snake_case में मानकीकरण

एक आम सर्वोत्तम प्रथा यह है कि किसी भी विश्लेषण से पहले सभी कॉलम नामों को snake_case में बदल दें—जैसे लोअरकेस, शब्द अंडरसकोर से अलग, कोई विशेष वर्ण नहीं। .str मेथड्स को चेन करें ताकि एक ही अभिव्यक्ति में वहाँ तक पहुँचें:

raw_export = pd.DataFrame({
    "  Order ID ": [1001, 1002, 1003],
    "Customer Name (Full)": ["Abe", "Rick", "Pat"],
    "Total Amount ($)": [49.99, 120.00, 75.50],
    "Order-Date": ["2024-03-12", "2024-03-15", "2024-03-18"]
})

raw_export.columns = (
    raw_export.columns
    .str.strip()                                  # आरंभ/अंत का व्हाइटस्पेस हटाएँ
    .str.lower()                                  # सबकुछ लोअरकेस करें
    .str.replace(r"[^a-z0-9]+", "_", regex=True)  # गैर-अल्फ़ान्यूमेरिक को अंडरसकोर में समेटें
    .str.strip("_")                               # आरंभ/अंत के अंडरसकोर हटाएँ
)

print(raw_export.columns.tolist())

चार पंक्तियाँ, और आपके कॉलम नाम पूर्वानुमेय, लोअरकेस, और अंडरसकोर-सेपरेटेड हो गए। इस पैटर्न को एक यूटिलिटी फ़ंक्शन के रूप में सहेजना सार्थक है। एक बार जब यह आपके पास हो, तो आप इसे हर गंदे DataFrame पर लागू कर सकते हैं जो दरवाज़े से भीतर आता है।

आप अक्सर रीनेमिंग को कॉलम हटाने के साथ संयोजित करना भी चाहेंगे। इसके लिए, pandas में कॉलम ड्रॉप करें ट्यूटोरियल अगला चरण कवर करता है।

मैं Pandas में डेटा लोड करते समय कॉलम नाम कैसे बदलूँ?

यदि आप फ़ाइल लोड करने से पहले ही जानते हैं कि आपको अलग कॉलम नाम चाहिए, तो आप pd.read_csv() के अंदर ही रीनेमिंग कर सकते हैं। names पैरामीटर में नामों की सूची पास करें और header=0 सेट करें ताकि pandas मौजूदा हेडर रो को छोड़कर आपके नामों का उपयोग करे:

import pandas as pd
from io import StringIO

# उदाहरण के लिए CSV फ़ाइल का सिमुलेशन
csv_data = """txnId,custId,amt,date
1001,C01,49.99,2024-01-15
1002,C02,125.00,2024-01-16
1003,C01,79.50,2024-01-17"""

# लोड समय पर कॉलम का नाम बदलता है, मूल हेडर को स्किप करते हुए
transactions = pd.read_csv(
    StringIO(csv_data),
    header=0,
    names=["transaction_id", "customer_id", "amount_usd", "transaction_date"]
)
print(transactions)

जब आप स्कीमा नियंत्रित करते हैं और अपने लोडिंग कोड को किसी अलग .rename() चरण से अव्यवस्थित नहीं करना चाहते, तब यह उपयोगी शॉर्टकट है। यदि फ़ाइल में बिल्कुल भी हेडर रो नहीं है, तो header=0 छोड़ दें और केवल names=[...] से शुरू से कॉलम नाम असाइन करें। लोडिंग विकल्पों पर गहराई से नज़र के लिए, मैं pandas read_csv() ट्यूटोरियल की सिफारिश करूँगा।

एक चेतावनी: यह सब-या-कुछ नहीं वाला तरीका है। names पैरामीटर हर कॉलम नाम बदल देता है, इसलिए सूची की लंबाई फ़ाइल में कॉलमों की संख्या से बिल्कुल मेल खानी चाहिए। यदि आप केवल कुछ कॉलमों का नाम बदलना चाहते हैं, तो पहले फ़ाइल लोड करें और बाद में .rename() का उपयोग करें।

इन पैटर्न्स के मार्गदर्शित वॉकथ्रू के लिए, अन्य सामान्य क्लीनअप कार्यों के साथ, मैं हमारे Cleaning Data in Python कोर्स से गुजरने की सलाह दूँगा।

Polars बनाम Pandas में कॉलम का नाम बदलना

यदि आप pandas और Polars दोनों में काम करते हैं, या करने की उम्मीद है, तो यह जानना सार्थक है कि दोनों कॉलम रीनेमिंग कैसे संभालते हैं। उच्च-स्तरीय API समान है, लेकिन विवरण ऐसे भिन्न हैं जो शुरुआती कुछ बार आपको चौंका सकते हैं। Polars एक तेज़, Rust-समर्थित DataFrame लाइब्रेरी है जो आधुनिक डेटा स्टैक्स में तेजी से आम होती जा रही है, और pandas में बनी मसल-मेमोरी हमेशा साफ़-सुथरे ढंग से ट्रांसफ़र नहीं होती।

मुख्य विचार एक जैसा है। आप पुरानों को नए से डिक्शनरी द्वारा मैप करते हैं। अंतर विवरण में हैं। Polars डिज़ाइन से immutable है (कोई inplace नहीं), मेथड चेनिंग आईडियोमैटिक स्टाइल है, और किसी select के दौरान कॉलम-स्तरीय रीनेम .alias() से होता है बजाय किसी अलग rename स्टेप के।

साइड-बाय-साइड तुलना

कार्य	Pandas	Polars
विशिष्ट कॉलमों का नाम बदलें	`df.rename(columns={"old": "new"})`	`df.rename({"old": "new"})`
सभी कॉलम नाम बदलें	`df.columns = [...]` या `df.set_axis([...], axis=1)`	`df.rename(dict(zip(df.columns, [...])))`
select के दौरान रीनेम	पहले select, फिर `.rename()`	`df.select(pl.col("old").alias("new"))`
in-place संशोधन	`inplace=True` समर्थित	समर्थित नहीं। हमेशा नया DataFrame लौटता है
आईडियोमैटिक स्टाइल	`inplace` या चेनिंग	हमेशा चेनिंग

दोनों लाइब्रेरियों में वही रीनेम

तुलना के लिए, यहाँ दोनों लाइब्रेरियों में एक सरल रीनेम है।

Pandas:

# Pandas
import pandas as pd

orders_pd = pd.DataFrame({
    "ord_id": [1001, 1002, 1003],
    "cust_nm": ["Abe", "Rick", "Pat"]
})

orders_pd = orders_pd.rename(columns={"ord_id": "order_id", "cust_nm": "customer_name"})
print(orders_pd)

Polars:

# Polars
import polars as pl

orders_pl = pl.DataFrame({
    "ord_id": [1001, 1002, 1003],
    "cust_nm": ["Abe", "Rick", "Pat"]
})

orders_pl = orders_pl.rename({"ord_id": "order_id", "cust_nm": "customer_name"})
print(orders_pl)

ध्यान देने योग्य दो छोटे अंतर। Polars की .rename() डिक्शनरी को सीधे लेती है। यहाँ columns= कीवर्ड नहीं है क्योंकि Polars केवल कॉलम (कोई रो इंडेक्स नहीं) का नाम बदलने का समर्थन करता है। और आपको परिणाम को फिर से असाइन करना होता है। Polars में inplace=True नहीं होता। हर ऑपरेशन एक नया DataFrame लौटाता है।

Polars आउटपुट dtypes (i64, str) और ऊपर shape भी इनलाइन दिखाता है, जो उन छोटी क्वालिटी-ऑफ-लाइफ़ चीज़ों में से है जिन्हें लोग स्विच करने के बाद पसंद करने लगते हैं।

select के दौरान कॉलम का नाम बदलना

ट्रांसफ़ॉर्मेशन के दौरान रीनेमिंग के लिए, Polars .select() या .with_columns() के अंदर .alias() का उपयोग करता है:

# Polars
import polars as pl

orders_pl = pl.DataFrame({
    "ord_id": [1001, 1002, 1003],
    "cust_nm": ["Abe", "Rick", "Pat"]
})

# एक अभिव्यक्ति में select और rename
renamed = orders_pl.select(
    pl.col("ord_id").alias("order_id"),
    pl.col("cust_nm").alias("customer_name")
)

print(renamed)

pandas में, समकक्ष होगा कि कॉलम चयन के बाद .rename() करें। कोई भी दृष्टिकोण बेहतर नहीं—ये दोनों लाइब्रेरी के डिज़ाइन दर्शन को दर्शाते हैं।

यदि आप दोनों की गहरी तुलना चाहते हैं, तो मैं pandas बनाम polars प्रदर्शन ट्यूटोरियल की सिफारिश करूँगा। और यदि आप अपने टूलकिट में polars जोड़ना चाहते हैं, तो मैं हमारे Introduction to Polars कोर्स की सलाह देता हूँ।

आम त्रुटियाँ और उनके समाधान

pandas कॉलमों का नाम बदलते समय दो त्रुटियाँ बार-बार आती हैं। वे कैसी दिखती हैं, क्यों होती हैं, और कैसे ठीक करें—यहाँ दिया है।

KeyError: कॉलम नाम नहीं मिला

डिफ़ॉल्ट रूप से, .rename() उन keys को चुपचाप नज़रअंदाज़ करता है जो किसी मौजूदा कॉलम से मेल नहीं खातीं। लेकिन यदि आप टाइपो पकड़ने के लिए errors='raise' पास करते हैं, तो जब कोई key मौजूद नहीं होगी तो आपको KeyError मिलेगा:

import pandas as pd

orders = pd.DataFrame({
    "order_id": [1001, 1002, 1003],
    "customer_name": ["Abe", "Rick", "Pat"]
})

# यह एक त्रुटि उठाता है
orders.rename(columns={"Order_ID": "order_id"}, errors="raise")

सबसे आम कारण केस-सेंसिटिविटी की चूक है (Order_ID बनाम order_id) या अदृश्य ट्रेलिंग स्पेस ("order_id " बनाम "order_id")। जब आप KeyError से टकराएँ, तो क्रम में ये तीन चीज़ें जाँचें:

सटीक वर्तनी और केस
छिपा हुआ व्हाइटस्पेस
क्या कॉलम पहले ही कहीं रीनेम हो चुका है

वास्तविक कॉलम नाम सत्यापित करने के लिए:

print(orders.columns.tolist())

# वैकल्पिक रूप से repr() का उपयोग करें
print([repr(c) for c in orders.columns])

एक बार जब आप देख लेते हैं कि pandas वास्तव में कौन-से स्ट्रिंग्स पकड़े हुए है, तो टाइपो आमतौर पर स्पष्ट हो जाता है। फिर वर्तनी ठीक करें और दोबारा चलाएँ:

orders = orders.rename(columns={"order_id": "Order_ID"}, errors="raise")
print(orders.columns.tolist())

अब सवाल यह है कि कब errors='raise' का उपयोग करें बनाम डिफ़ॉल्ट errors='ignore'.

डिफ़ॉल्ट सहनशील है। यह ऐसे स्क्रिप्ट्स में काम आता है जो विभिन्न स्कीमा वाले DataFrames प्रोसेस करते हैं, जहाँ एक मिसिंग कॉलम से कुछ नहीं क्रैश होना चाहिए।
डेवलपमेंट के दौरान टाइपो को ज़ोर से सतह पर लाने के लिए errors='raise' अपनाएँ, खासकर नोटबुक्स में जहाँ मौन विफलताएँ नीचे की ओर घंटों की उलझन पैदा करती हैं।

ValueError: df.columns के साथ length mismatch

जब आप df.columns को कोई सूची असाइन करते हैं या .set_axis() का उपयोग करते हैं, तो सूची की लंबाई कॉलमों की संख्या से बिल्कुल मेल खानी चाहिए। यदि नहीं, तो pandas ValueError उठाता है:

import pandas as pd

products = pd.DataFrame({
    "sku": ["A100", "A101", "A102"],
    "name": ["Widget", "Gadget", "Gizmo"],
    "price": [9.99, 14.99, 19.99]
})

# यह एक त्रुटि उठाता है
products.columns = ["product_sku", "product_name"]

DataFrame में तीन कॉलम हैं, लेकिन केवल दो नए नाम दिए गए। समाधान है असाइन करने से पहले कॉलम काउंट जाँचें:

print(len(products.columns))
products.columns = ["product_sku", "product_name", "product_price"]
print(products.columns.tolist())

यदि आप ऐसे DataFrames के साथ काम करते हैं जहाँ कॉलम काउंट बदल सकता है, तो डिक्शनरी के साथ .rename() का उपयोग अधिक सुरक्षित है। यह केवल उन्हीं कॉलमों को छूता है जिनका आप नाम लेते हैं, इसलिए कोई मिसिंग या अतिरिक्त कॉलम आपका कोड नहीं तोड़ेगा।

अंतिम विचार

pandas में कॉलम के नाम बदलने का सार यह है कि अपने कार्य-क्षेत्र से मेल खाती विधि चुनें। आप जो भी तरीका चुनें, सबसे बड़ा व्यावहारिक लाभ एक ही नामकरण कन्वेंशन पर टिकना और हर विश्लेषण में इसे पहले चरण के रूप में लागू करना है। snake_case वही है जो अधिकांश Python कोड उपयोग करता है। साफ़-सुथरे कॉलम नाम शुरुआत में कुछ सेकंड लेते हैं और बाकी प्रोजेक्ट में KeyError आश्चर्यों से बचाते हैं।

लक्षित रीनेम के लिए डिक्शनरी के साथ .rename() का उपयोग करें। जब हर कॉलम को नया नाम चाहिए हो, तो df.columns को असाइन करना या .set_axis() का उपयोग करना हर पुराने-से-नए मैपिंग की डिक्शनरी बनाने से तेज़ है। और यदि रीनेमिंग किसी नियम का अनुसरण करती है—जैसे व्हाइटस्पेस हटाना, सबकुछ लोअरकेस करना, camelCase को बदलना—तो कोई फ़ंक्शन पास करना या .str एक्सेसर का उपयोग आपको हर केस गिनाने के बजाय नियम को एक बार व्यक्त करने देता है। Polars समान API से वही काम संभालता है, लेकिन इसका immutable, chain-first स्टाइल आपको अलग आदतों की ओर प्रेरित करता है।

अपने DataFrame कौशल को आगे बढ़ाने के लिए, मैं अगला चरण Data Manipulation with pandas कोर्स की सिफारिश करूँगा। यदि आप एक संरचित लर्निंग पाथ चाहते हैं, तो Data Analyst in Python करियर ट्रैक DataFrame हेरफेर को बाकी विश्लेषक टूलकिट के साथ कवर करता है।