Pandas & NumPy Academy · Pelajaran

melt: Format Lebar kepada Panjang

Tukarkan DataFrame lebar kepada format panjang dengan pd.melt, sambil menentukan id_vars dan value_vars.

Pelajaran 2 daripada 413 langkah

melt: Format Lebar kepada Panjang ialah pelajaran Pandas & NumPy Academy percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Pandas & NumPy Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Pandas & NumPy Academy merangkumi sejumlah 4 pelajaran.

Format Data Lebar berbanding Panjang

Data boleh distrukturkan dalam dua bentuk asas. Format lebar mempunyai satu baris bagi setiap subjek dan menyebarkan ukuran merentasi beberapa lajur — contohnya, lajur berasingan untuk jualan Januari, Februari dan Mac. Format panjang mempunyai satu baris bagi setiap pemerhatian, dengan satu lajur untuk nama pemboleh ubah dan satu lagi untuk nilainya. Kebanyakan fungsi analisis Pandas, pustaka pembelajaran mesin dan alat visualisasi lebih mengutamakan format panjang, menjadikan melt() alat transformasi yang penting.

Fungsi pd.melt()

pd.melt(df) (juga tersedia sebagai df.melt()) menukar DataFrame lebar kepada format panjang. Parameter utamanya ialah id_vars (lajur yang dikekalkan sebagai pengecam tanpa perubahan), value_vars (lajur yang dinyahpangsi menjadi baris), var_name (nama untuk lajur pemboleh ubah baharu) dan value_name (nama untuk lajur nilai baharu).

import pandas as pd

# Wide format: separate columns per month
df_wide = pd.DataFrame({
    'product': ['A', 'B'],
    'Jan':     [100, 150],
    'Feb':     [120, 130],
    'Mar':     [140, 160]
})

print(df_wide)
#   product  Jan  Feb  Mar
# 0       A  100  120  140
# 1       B  150  130  160

Panggilan asas melt()

Panggil melt() dengan id_vars ditetapkan kepada lajur yang mahu anda kekalkan sebagai pengecam. Setiap lajur lain dinyahpangsi: namanya menjadi nilai dalam lajur pemboleh ubah baharu dan nilai selnya berpindah ke lajur nilai. Bilangan baris output bersamaan dengan bilangan baris input didarabkan dengan bilangan lajur nilai yang dicairkan.

df_long = df_wide.melt(
    id_vars='product',
    var_name='month',
    value_name='sales'
)
print(df_long)
#   product month  sales
# 0       A   Jan    100
# 1       B   Jan    150
# 2       A   Feb    120
# 3       B   Feb    130
# 4       A   Mar    140
# 5       B   Mar    160

Memilih Lajur yang Hendak Dicairkan

Secara lalai, setiap lajur yang tidak disenaraikan dalam id_vars akan dicairkan. Gunakan value_vars untuk mencairkan hanya sebahagian lajur. Lajur yang tidak terdapat dalam id_vars atau value_vars digugurkan daripada hasil. Ini berguna apabila DataFrame lebar anda mengandungi gabungan lajur siri masa dan atribut lain yang tidak mahu anda nyahpangsi.

df_wide2 = pd.DataFrame({
    'product': ['A', 'B'],
    'category': ['Electronics', 'Clothing'],
    'Jan': [100, 150],
    'Feb': [120, 130],
    'Mar': [140, 160]
})

# Melt only Jan and Feb, keep product and category
df_long2 = df_wide2.melt(
    id_vars=['product', 'category'],
    value_vars=['Jan', 'Feb'],
    var_name='month',
    value_name='sales'
)
print(df_long2)

Menetapkan Semula Indeks Selepas melt()

melt() mengekalkan indeks baris asal dengan mengulanginya bagi setiap pemboleh ubah. Hasilnya sering mempunyai indeks bukan berjujukan seperti [0, 1, 0, 1, 0, 1]. Amalan yang baik ialah memanggil reset_index(drop=True) sejurus selepas melt() untuk mendapatkan indeks berjujukan yang bersih daripada 0 hingga n-1 dalam output.

df_long = df_wide.melt(id_vars='product', var_name='month', value_name='sales')
print('Before reset:', df_long.index.tolist())
# [0, 1, 0, 1, 0, 1]

df_long = df_long.reset_index(drop=True)
print('After reset:', df_long.index.tolist())
# [0, 1, 2, 3, 4, 5]

melt() ialah Songsangan pivot()

melt() secara konsepnya ialah songsangan pivot() / pivot_table(). Anda boleh menukar format panjang kepada format lebar dengan pivot_table(), dan format lebar kembali kepada format panjang dengan melt(). Proses pergi balik ini sering digunakan dalam aliran kerja: terima data dalam format lebar, bentuk semula kepada format panjang untuk pemplotan Seaborn atau ciri pembelajaran mesin, kemudian secara pilihan pangsikan semula untuk jadual laporan.

# long -> wide
table = df_long.pivot_table(values='sales', index='product',
                            columns='month', aggfunc='sum')
print(table)
# product  Feb  Jan  Mar
# A        120  100  140
# B        130  150  160

# wide -> long again
long_again = table.reset_index().melt(id_vars='product', var_name='month', value_name='sales')
print(long_again.head())

Menggunakan melt() untuk Pemplotan Seaborn

Plot kategori dan hubungan Seaborn berfungsi paling baik dengan data berformat panjang. Aliran kerja lazim: mulakan dengan DataFrame berformat lebar yang mempunyai satu lajur bagi setiap kumpulan, gunakan melt() untuk menukarnya kepada format panjang supaya satu lajur mengenal pasti kumpulan dan satu lagi menyimpan nilai, kemudian hantarkan kedua-duanya kepada parameter hue dan x/y Seaborn. Ini ialah salah satu sebab paling lazim untuk menggunakan melt().

import seaborn as sns
import matplotlib.pyplot as plt

# Long format is required for sns.lineplot with hue
df_long = df_wide.melt(id_vars='product', var_name='month', value_name='sales')

# sns.lineplot(data=df_long, x='month', y='sales', hue='product')
# plt.show()
print('Long data ready for Seaborn:')
print(df_long)

Menamakan Lajur Output

Secara lalai, melt() menamakan lajur pemboleh ubah baharu sebagai 'variable' dan lajur nilai sebagai 'value'. Sentiasa gantikan nama ini dengan nama yang bermakna menggunakan var_name dan value_name. Nama lajur yang deskriptif menjadikan kod seterusnya lebih mudah dibaca dan mengelakkan kekeliruan apabila DataFrame mempunyai berpuluh-puluh lajur.

# Default: generic column names 'variable' and 'value'
default = df_wide.melt(id_vars='product')
print(default.columns.tolist())
# ['product', 'variable', 'value']

# Better: descriptive names
good = df_wide.melt(id_vars='product', var_name='month', value_name='revenue_usd')
print(good.columns.tolist())
# ['product', 'month', 'revenue_usd']

Menukar Data Tinjauan kepada Format Panjang

Kes penggunaan klasik melt() ialah respons tinjauan, apabila setiap lajur mewakili soalan dan setiap baris mewakili responden. Penukaran ini mengubah format lebar kepada format panjang dengan lajur untuk ID responden, nama soalan dan nilai jawapan. Anda kemudiannya boleh mengira taburan jawapan bagi setiap soalan dengan mudah menggunakan groupby().

survey = pd.DataFrame({
    'respondent': [1, 2, 3],
    'Q1_rating': [5, 3, 4],
    'Q2_rating': [4, 5, 3],
    'Q3_rating': [2, 4, 5]
})

long = survey.melt(id_vars='respondent', var_name='question', value_name='rating')
print(long)
print(long.groupby('question')['rating'].mean())

Mengisih Hasil yang Telah Ditukar

Selepas penukaran, baris disusun mengikut susunan lajur asal (Jan, Feb, Mac bagi setiap baris). Anda biasanya mahu mengisih mengikut lajur pengecam terlebih dahulu, kemudian mengikut lajur pemboleh ubah. Gunakan sort_values() pada DataFrame yang telah ditukar untuk mendapatkan susunan yang paling sesuai bagi analisis atau pemprosesan seterusnya.

df_long = df_wide.melt(id_vars='product', var_name='month', value_name='sales')

# Sort by product, then month
df_sorted = df_long.sort_values(['product', 'month']).reset_index(drop=True)
print(df_sorted)
#   product month  sales
# 0       A   Feb    120
# 1       A   Jan    100
# 2       A   Mar    140
# 3       B   Feb    130
# 4       B   Jan    150
# 5       B   Mar    160

melt() dalam Saluran Paip Data

Dalam saluran paip data yang lazim, melt() muncul sejurus selepas memuatkan atau membersihkan data berformat lebar, sebelum sebarang langkah analisis atau pemodelan. Letakkannya pada peringkat awal saluran paip supaya data cepat ditukar kepada format panjang. Selepas itu, semua operasi seterusnya (groupby, seaborn, sklearn) boleh berfungsi pada data berformat panjang yang bersih tanpa pengendalian khas.

def load_and_reshape(filepath):
    raw = pd.read_csv(filepath)
    # Melt all month columns into long format
    month_cols = [c for c in raw.columns if c.startswith('month_')]
    long = raw.melt(
        id_vars=[c for c in raw.columns if c not in month_cols],
        value_vars=month_cols,
        var_name='month',
        value_name='value'
    )
    return long.reset_index(drop=True)

Semakan Pantas

Uji pemahaman anda tentang transformasi daripada format lebar kepada format panjang menggunakan pd.melt dalam pelajaran ini.

Jawab dalam pelajaran interaktif

Imbas Kembali Pelajaran

Dalam pelajaran ini, anda telah mempelajari bahawa melt() menukar format lebar kepada format panjang dengan menyahpangkinkan lajur menjadi baris; id_vars menentukan lajur yang kekal tetap dan value_vars memilih lajur yang hendak ditukar; var_name dan value_name memberikan nama deskriptif kepada lajur baharu; dan format panjang lebih sesuai untuk Seaborn, groupby serta saluran paip pembelajaran mesin. Seterusnya, kita akan meneroka stack dan unstack untuk membentuk semula DataFrames MultiIndex.

Percuma untuk bermula

Pelajari Python dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 30
Pelajaran: 120

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “melt: Format Lebar kepada Panjang” percuma?

Ya — teks penuh “melt: Format Lebar kepada Panjang” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Pandas & NumPy Academy, tingkat taraf kepada CoddyKit PRO. Kursus Pandas & NumPy Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “melt: Format Lebar kepada Panjang”?

Tukarkan DataFrame lebar kepada format panjang dengan pd.melt, sambil menentukan id_vars dan value_vars. Anda berlatih Pandas & NumPy Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Pandas & NumPy Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Pandas & NumPy Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “melt: Format Lebar kepada Panjang” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Pandas & NumPy Academy ini?

Ya. Setiap pelajaran Pandas & NumPy Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Pandas & NumPy Academy