Mengganti Nama Kolom di Pandas: Panduan Lengkap dengan Contoh

Bagaimana Cara Mengganti Nama Kolom dengan .rename()?

Method .rename() adalah cara paling fleksibel untuk melakukan operasi pandas DataFrame rename column, dan ini yang paling sering Anda gunakan. 

Method ini menerima dictionary yang memetakan nama lama ke nama baru, membiarkan kolom yang tidak disebutkan tetap tak berubah, dan secara default mengembalikan DataFrame baru alih-alih memodifikasi yang asli. Ini membuat .rename() aman digunakan di dalam rantai method dan mudah dipahami saat debugging.

Pola dictionary terlihat seperti ini:

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

Jika Anda baru dengan dictionary, saya sarankan meninjau tutorial method dictionary Python kami sebagai penyegar.

Catatan tentang parameter copy lama

Satu catatan cepat sebelum contoh. Pandas 3.0 menandai copy sebagai deprecated dan menjadikan Copy-on-Write sebagai perilaku default. Dalam praktiknya, ini berarti Anda tidak perlu lagi khawatir apakah .rename() membuat salinan data yang mahal. Pandas menanganinya secara lazy di balik layar. Parameter utama yang tersisa untuk dipikirkan adalah inplace, yang akan kita bahas di subbagian ketiga.

Mengganti nama satu kolom

Bayangkan Anda baru saja memuat catatan pelanggan yang diekspor dari CRM lama. Nama kolom disingkat dengan cara yang masuk akal bagi perancang database pada 2008, tetapi tidak bagi Anda. Ini adalah operasi pandas rename column paling sederhana: satu nama lama, satu nama baru, dalam dictionary:

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)

Sekarang, ganti nama cust_id_nbr menjadi sesuatu yang lebih mudah dibaca:

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

DataFrame customers asli tidak berubah. .rename() mengembalikan DataFrame baru, yang kita tetapkan ke customers_renamed. Dua kolom yang tidak kita sebut (first_nm, signup_dt) ikut serta tanpa perubahan.

Mengganti nama beberapa kolom

Dictionary berskala secara alami. Untuk menangani tugas pandas rename multiple columns, cukup tambahkan lebih banyak pasangan key-value ke pemetaan:

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

print(customers_clean)

Ada juga sintaks alternatif yang menggunakan argumen mapper dan axis alih-alih keyword columns:

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

axis=1 memberi tahu pandas bahwa Anda menargetkan kolom (berbeda dengan axis=0 untuk label indeks baris). Keduanya menghasilkan hasil yang sama. Sebagian besar kode di alam liar menggunakan columns={...} karena lebih mudah dibaca sekilas, jadi kita akan tetap menggunakan pola itu untuk sisa tutorial.

Satu detail berguna adalah jika Anda memberikan key yang tidak cocok dengan kolom mana pun yang ada, .rename() secara default mengabaikannya secara senyap. Itu nyaman saat Anda menulis fungsi yang dapat digunakan ulang yang mungkin menangani DataFrame dengan skema yang sedikit berbeda, tetapi juga bisa menyembunyikan salah ketik. Untuk membuat pandas melempar error pada nama kolom yang tidak dikenal, berikan errors='raise'.

Menggunakan inplace vs. mengembalikan DataFrame baru

Secara default, .rename() mengembalikan DataFrame baru dan membiarkan yang asli tetap. Jika Anda ingin memodifikasi DataFrame yang ada secara langsung, berikan inplace=True:

# Mengembalikan DataFrame baru (default)
customers_v2 = customers.rename(columns={"first_nm": "first_name"})

# Memodifikasi customers secara langsung, mengembalikan None
customers.rename(columns={"first_nm": "first_name"}, inplace=True)

print(customers)

Jadi mana yang harus Anda gunakan? Dalam kebanyakan kasus, default yang mengembalikan DataFrame baru adalah pilihan yang lebih baik. Ini juga lebih mudah untuk debug, karena Anda masih memiliki DataFrame asli untuk diperiksa saat sesuatu salah. Dan ini menghindari masalah aliasing yang menghasilkan SettingWithCopyWarning pada kode lama.

Kinerja juga bukan alasan untuk lebih memilih inplace lagi. Dengan Copy-on-Write, yang kini menjadi default di pandas 3.0+, versi non-inplace menggunakan penyalinan lazy. Data Anda tidak benar-benar diduplikasi sampai sesuatu dimodifikasi. Argumen lama bahwa inplace=True menghemat memori kini jauh lebih lemah.

Satu tempat di mana inplace=True masih terasa natural adalah dalam skrip eksploratif singkat di mana Anda membersihkan satu DataFrame selangkah demi selangkah dan tidak peduli tentang chaining. Untuk kode produksi atau apa pun yang akan Anda kunjungi lagi nanti, lebih baik pilih default.

Bagaimana Cara Mengganti Semua Nama Kolom Sekaligus di Pandas?

Terkadang Anda tidak ingin memetakan nama lama ke nama baru. Anda hanya ingin mengganti setiap nama kolom sekaligus. Ini lebih sering muncul daripada yang Anda kira, seperti CSV tanpa header di mana pandas menetapkan 0, 1, 2 sebagai nama kolom, dataset di mana baris header dalam bahasa lain, atau ekspor sistem dengan nama seperti Field1, Field2, Field3.

Ada dua cara umum untuk melakukan ini. Entah menetapkan langsung ke df.columns, atau menggunakan .set_axis(). Keduanya menghasilkan hasil yang sama. Trade-off-nya adalah antara kepraktisan singkat dan kemampuan untuk chaining.

Menetapkan daftar ke df.columns

Pendekatan paling langsung adalah menetapkan daftar baru ke atribut columns. Ambil DataFrame ini, dibangun dari list of lists tanpa informasi header, seperti yang Anda dapatkan saat membaca CSV tanpa header. Pandas menggunakan nama kolom bilangan bulat sebagai cadangan:

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)

Nama kolom 0, 1, dan 2 itu tidak berguna untuk analisis. Ganti dengan menetapkan daftar nama baru ke atribut columns:

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

Dua hal yang perlu diketahui tentang pendekatan ini. 

1. Panjang daftar harus cocok persis. Berikan tiga nama untuk DataFrame empat kolom, dan pandas akan melempar ValueError: Length mismatch (kita akan bahas error ini lebih detail nanti). 

2. Ini memodifikasi DataFrame secara langsung. Tidak ada parameter inplace di sini karena penetapan itulah modifikasinya. Jika Anda ingin salinan baru, gunakan .copy() terlebih dahulu atau gunakan .set_axis() di bawah.

Menggunakan .set_axis() untuk method chaining

Method .set_axis() melakukan hal yang sama, tetapi mengembalikan DataFrame baru sehingga Anda bisa melakukan chaining dengan operasi lainnya. Ambil DataFrame tanpa header yang serupa, tetapi kali ini dengan data yang lebih berantakan seperti banyak tempat desimal dan pembacaan yang hilang:

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)

Argumen axis=1 memberi tahu pandas bahwa Anda menetapkan label kolom (gunakan axis=0 untuk menetapkan indeks baris). Karena .set_axis() mengembalikan DataFrame baru, ini pas secara natural ke dalam pipeline transformasi berantai yang akan Anda tulis dalam kode ETL atau analisis nyata. Itulah alasan utama untuk lebih memilihnya daripada penetapan langsung di produksi.

Bagaimana Cara Mengganti Nama Kolom Menggunakan Fungsi di Pandas?

Alih-alih memetakan setiap nama lama ke nama baru, Anda bisa memberikan fungsi ke .rename(), dan pandas akan menerapkannya ke setiap nama kolom. Ini alat yang tepat saat Anda punya aturan, bukan daftar. Misalnya, "semua huruf kecil" atau "ganti setiap spasi dengan garis bawah."

Menggunakan fungsi string bawaan

Kasus paling sederhana adalah standarisasi huruf. Berikan str.lower, str.upper, atau str.title langsung ke argumen columns:

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())

Perhatikan bahwa kita memberikan fungsinya sendiri (str.lower), bukan memanggilnya (str.lower()). Pandas menerapkannya ke setiap nama kolom satu per satu. Ini jalan pintas yang rapi untuk standarisasi huruf, tetapi tidak menangani spasi atau karakter khusus. Untuk itu, Anda akan membutuhkan lambda atau fungsi khusus.

Menggunakan lambda dan fungsi khusus

Untuk apa pun di luar perubahan huruf, lambda memberi Anda cara cepat untuk mengekspresikan transformasi secara inline. Jika Anda belum pernah menggunakan lambda, panduan pemula fungsi lambda Python kami adalah titik awal yang baik.

Pola umum adalah menjadikan huruf kecil dan mengganti spasi dengan garis bawah dalam satu langkah. Kita gunakan contoh sebelumnya:

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

Saat logikanya menjadi lebih rumit, pindahkan ke fungsi bernama. Pertimbangkan helper ini yang mengonversi nama kolom camelCase atau PascalCase menjadi 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())

Fungsi bernama seperti ini lebih mudah diuji, digunakan ulang di berbagai notebook, dan didokumentasikan daripada one-liner yang cerdik. Gunakan lambda saat logikanya muat dalam satu baris, dan fungsi khusus saat tidak.

Bagaimana Cara Membersihkan Nama Kolom yang Berantakan Secara Massal di Pandas?

Saat data datang dari spreadsheet, API pihak ketiga, atau CSV yang diedit manual, nama kolom sering kali memiliki masalah yang tidak bisa diperbaiki dengan rapi hanya dengan .rename(). Saya berbicara tentang masalah seperti:

• Spasi kosong di akhir
• Campuran huruf besar-kecil
• Tanda kurung
• Hyphen
• Karakter khusus
• Karakter Unicode tak terlihat

Untuk situasi ini, pendekatan paling bersih adalah beroperasi langsung pada df.columns menggunakan aksesori .str, yang mengekspos method string vektorisasi (termasuk regex) ke semua nama kolom sekaligus. Ini juga fondasi dari pembersihan data di Python yang solid. Membersihkan nama kolom membuat setiap langkah hilir (filtering, merging, plotting) lebih kecil kemungkinannya salah.

Menghapus whitespace dan karakter khusus

Ambil DataFrame ini, dengan jenis nama yang Anda dapatkan dari ekspor Excel yang terlalu banyak disentuh:

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())

Spasi di awal dan akhir adalah masalah paling umum dan paling membuat frustrasi, karena tidak terlihat. Hapus dalam satu baris:

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

Untuk karakter khusus, .str.replace() menerima pola regex. Pola di bawah ini mempertahankan huruf, angka, garis bawah, dan spasi, dan menghapus yang lain:

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

Tanda hubung, tanda kurung, dan simbol dolar hilang. Perhatikan bahwa Total Amount kini memiliki spasi di akhir (dari tempat ($) sebelumnya), dan OrderDate kehilangan tanda hubung sepenuhnya. Itulah mengapa kita strip lagi di akhir pipeline pembersihan.

Standarisasi ke snake_case

Praktik terbaik yang umum adalah mengonversi semua nama kolom ke snake_case sebelum Anda memulai analisis, seperti huruf kecil, kata dipisahkan garis bawah, tanpa karakter khusus. Rantai method .str untuk mencapainya dalam satu ekspresi:

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()                                  # hapus spasi di awal/akhir
    .str.lower()                                  # jadikan semua huruf kecil
    .str.replace(r"[^a-z0-9]+", "_", regex=True)  # gabungkan non-alfanumerik menjadi garis bawah
    .str.strip("_")                               # hapus garis bawah di awal/akhir
)

print(raw_export.columns.tolist())

Empat baris, dan nama kolom Anda menjadi prediktabel, huruf kecil, dan dipisahkan garis bawah. Pola ini layak disimpan sebagai fungsi utilitas. Setelah Anda memilikinya, Anda bisa menerapkannya ke setiap DataFrame berantakan yang datang.

Sering kali Anda juga ingin menggabungkan penggantian nama dengan penghapusan kolom. Untuk itu, tutorial menghapus kolom di pandas mencakup langkah berikutnya.

Bagaimana Cara Mengganti Nama Kolom Saat Memuat Data di Pandas?

Jika Anda sudah tahu ingin nama kolom yang berbeda bahkan sebelum memuat file, Anda bisa mengganti nama langsung di dalam pd.read_csv(). Berikan daftar nama ke parameter names dan setel header=0 untuk memberi tahu pandas agar melewati baris header yang ada dan menggunakan nama Anda sebagai gantinya:

import pandas as pd
from io import StringIO

# Mensimulasikan file CSV untuk demonstrasi
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"""

# Mengganti nama kolom saat memuat, melewati header asli
transactions = pd.read_csv(
    StringIO(csv_data),
    header=0,
    names=["transaction_id", "customer_id", "amount_usd", "transaction_date"]
)
print(transactions)

Ini adalah jalan pintas yang berguna saat Anda mengendalikan skema dan tidak ingin langkah .rename() terpisah mengotori kode pemuatan Anda. Jika file tidak memiliki baris header sama sekali, hilangkan header=0 dan cukup gunakan names=[...] untuk menetapkan nama kolom dari awal. Untuk melihat lebih dalam opsi pemuatan dataset, saya sarankan tutorial pandas read_csv().

Satu peringatan: Ini pendekatan serba atau tidak sama sekali. Parameter names mengganti setiap nama kolom, jadi panjang daftar harus cocok persis dengan jumlah kolom dalam file. Jika Anda hanya ingin mengganti nama beberapa kolom, muat file terlebih dahulu dan gunakan .rename() setelahnya.

Untuk penelusuran terpandu atas pola-pola ini bersama tugas pembersihan umum lainnya, saya sarankan mengikuti kursus Cleaning Data in Python kami.

Mengganti Nama Kolom di Polars vs. Pandas

Jika Anda bekerja di kedua pandas dan Polars, atau berencana demikian, ada baiknya mengetahui bagaimana masing-masing menangani penggantian nama kolom. API tingkat tingginya mirip, tetapi detailnya berbeda dengan cara yang bisa mengecoh Anda beberapa kali pertama. Polars adalah library DataFrame cepat berbasis Rust yang semakin umum di stack data modern, dan memori otot yang Anda bangun di pandas tidak selalu berpindah mulus.

Gagasan utamanya identik. Anda memetakan nama lama ke nama baru dengan dictionary. Perbedaannya ada pada detail. Polars bersifat immutable secara desain (tanpa inplace), method chaining adalah gaya idiomatik, dan penggantian nama tingkat kolom selama select menggunakan .alias() alih-alih langkah rename terpisah.

Perbandingan berdampingan

Penggantian nama yang sama di kedua library

Sebagai perbandingan, berikut penggantian nama sederhana di masing-masing library.

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)

Ada dua perbedaan kecil. .rename() Polars menerima dictionary secara langsung. Tidak ada keyword columns= karena Polars hanya mendukung penggantian nama kolom (bukan indeks baris). Dan Anda harus menetapkan ulang hasilnya. Tidak ada inplace=True di Polars. Setiap operasi mengembalikan DataFrame baru.

Output Polars juga menampilkan dtype inline (i64, str) dan bentuk (shape) di atas, yang merupakan salah satu hal kecil yang disukai banyak orang setelah beralih. 

Mengganti nama kolom saat select

Untuk penggantian nama selama transformasi, Polars menggunakan .alias() di dalam .select() atau .with_columns():

# Polars
import polars as pl

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

# Select dan ganti nama dalam satu ekspresi
renamed = orders_pl.select(
    pl.col("ord_id").alias("order_id"),
    pl.col("cust_nm").alias("customer_name")
)

print(renamed)

Di pandas, padanannya adalah .rename() setelah seleksi kolom. Tidak ada yang lebih baik. Keduanya mencerminkan filosofi desain masing-masing library. 

Jika Anda menginginkan perbandingan yang lebih dalam antara keduanya, saya sarankan tutorial kinerja pandas versus polars. Dan jika Anda ingin menambahkan polars ke peralatan Anda, saya sarankan mengikuti Introduction to Polars course. 

Error Umum dan Cara Memperbaikinya

Ada dua error yang sering muncul saat mengganti nama kolom pandas. Berikut tampilannya, penyebabnya, dan cara memperbaikinya.

KeyError: nama kolom tidak ditemukan

Secara default, .rename() mengabaikan secara senyap key yang tidak cocok dengan kolom yang ada. Namun jika Anda memberikan errors='raise' untuk menangkap salah ketik, Anda akan mendapatkan KeyError saat sebuah key tidak ada:

import pandas as pd

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

# Ini akan melempar error
orders.rename(columns={"Order_ID": "order_id"}, errors="raise")

Penyebab paling umum adalah kekeliruan sensitivitas huruf (Order_ID versus order_id) atau spasi tersembunyi di akhir ("order_id " versus "order_id"). Saat Anda terkena KeyError, periksa tiga hal ini secara berurutan:

1. Ejaan dan huruf besar-kecil yang tepat
2. Whitespace tersembunyi
3. Apakah kolom sudah diganti namanya sebelumnya

Untuk memverifikasi nama kolom sebenarnya:

print(orders.columns.tolist())

# Gunakan repr() sebagai alternatif
print([repr(c) for c in orders.columns])

Setelah Anda melihat string persis yang dipegang pandas, salah ketik biasanya terlihat jelas. Lalu perbaiki ejaan dan jalankan ulang:

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

Sekarang pertanyaannya, kapan menggunakan errors='raise' versus default errors='ignore'. 

• Default-nya memaafkan. Ini berguna dalam skrip yang memproses DataFrame dengan skema bervariasi, di mana kolom yang hilang tidak boleh membuat apa pun crash. 

• Beralih ke errors='raise' saat Anda ingin salah ketik muncul dengan keras selama pengembangan, terutama di notebook di mana kegagalan senyap menyebabkan berjam-jam debugging yang membingungkan di hilir.

ValueError: length mismatch dengan df.columns

Saat Anda menetapkan daftar ke df.columns atau menggunakan .set_axis(), panjang daftar harus cocok persis dengan jumlah kolom. Jika tidak, pandas akan melempar ValueError:

import pandas as pd

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

# Ini akan melempar error
products.columns = ["product_sku", "product_name"]

DataFrame memiliki tiga kolom, tetapi hanya dua nama baru yang diberikan. Solusinya adalah memeriksa jumlah kolom sebelum menetapkan:

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

Jika Anda bekerja dengan DataFrame di mana jumlah kolom dapat bervariasi, lebih aman menggunakan .rename() dengan dictionary. Ini hanya menyentuh kolom yang Anda sebut, jadi kolom yang hilang atau ekstra tidak akan membuat kode Anda crash.

Penutup

Mengganti nama kolom di pandas bermuara pada memilih metode yang sesuai dengan cakupan tugas Anda. Apa pun pendekatan yang Anda pilih, kemenangan praktis terbesar adalah menetapkan satu konvensi penamaan dan menerapkannya sebagai langkah pertama di setiap analisis. snake_case adalah yang paling banyak digunakan kode Python. Membersihkan nama kolom memakan beberapa detik di awal dan menyelamatkan Anda dari kejutan KeyError sepanjang proyek.

Gunakan .rename() dengan dictionary untuk penggantian nama terarah. Saat setiap kolom membutuhkan nama baru, menetapkan ke df.columns atau menggunakan .set_axis() lebih cepat daripada membangun dictionary pemetaan lama-ke-baru untuk semuanya. Dan jika penggantian nama mengikuti aturan seperti menghapus whitespace, menjadikan semua huruf kecil, mengonversi camelCase, maka memberikan fungsi, atau menggunakan aksesori .str memungkinkan Anda mengekspresikan aturan sekali saja alih-alih membuat daftar kasus. Polars menangani pekerjaan yang sama dengan API serupa, tetapi gaya immutable, chain-first mendorong Anda ke kebiasaan yang berbeda. 

Untuk terus membangun keterampilan DataFrame Anda, saya sarankan kursus Data Manipulation with pandas sebagai langkah berikutnya. Jika Anda menginginkan jalur belajar terstruktur, jalur karier Data Analyst in Python mencakup manipulasi DataFrame bersama peralatan analis lainnya.