Perangkaian Metode dengan pipe()
Tulis pipeline transformasi data yang mudah dibaca menggunakan pipe() untuk merangkai fungsi khusus bersama metode bawaan Pandas.
Perangkaian Metode dengan pipe() adalah pelajaran Pandas & NumPy Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Pandas & NumPy Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Pandas & NumPy Academy mencakup 4 pelajaran total.
Masalah dengan Variabel Perantara
Pipeline pembersihan data tanpa pipe() sering kali mengumpulkan banyak variabel perantara: df1 = clean(df), df2 = transform(df1), df3 = enrich(df2). Variabel-variabel ini memenuhi ruang nama, menyulitkan penelusuran kesalahan, dan menggoda pengembang untuk menggunakannya kembali secara keliru. Akibatnya, kode sulit dibaca dari atas ke bawah sebagai rangkaian transformasi.
import pandas as pd
df = pd.read_csv('orders.csv')
# Without pipe — intermediate variables everywhere
df1 = df.dropna(subset=['revenue'])
df2 = df1[df1['quantity'] > 0]
df3 = df2.assign(revenue_per_unit=df2['revenue'] / df2['quantity'])
print(df3.shape)Memperkenalkan pipe()
DataFrame.pipe(func) memanggil func(df) dan mengembalikan hasilnya, sehingga Anda dapat merangkai fungsi khusus dengan cara yang sama seperti merangkai metode bawaan Pandas, seperti .dropna().query(). Manfaat utamanya adalah setiap langkah transformasi terlihat jelas dan mudah dibaca dari kiri ke kanan, atau dari atas ke bawah saat diformat dengan tanda kurung, sehingga mencerminkan urutan logis pipeline.
def drop_nulls(df):
return df.dropna(subset=['revenue'])
def filter_positive_qty(df):
return df[df['quantity'] > 0]
def add_revenue_per_unit(df):
return df.assign(revenue_per_unit=df['revenue'] / df['quantity'])
# With pipe — clean chain
df_clean = (df
.pipe(drop_nulls)
.pipe(filter_positive_qty)
.pipe(add_revenue_per_unit)
)
print(df_clean.shape)Meneruskan Argumen melalui pipe()
Teruskan argumen tambahan ke fungsi yang dipanggil melalui pipe menggunakan argumen kata kunci setelah nama fungsi: df.pipe(func, arg1=val1). Tanda tangan fungsi harus menerima df sebagai parameter pertamanya. Fungsi berparameter membuat pipeline dapat dikonfigurasi: Anda dapat mengubah ambang batas, nama kolom, atau perilaku tanpa mengubah isi fungsi, cukup dengan mengubah argumen pemanggilan pipe.
def filter_by_region(df, regions):
return df[df['region'].isin(regions)]
def cap_revenue(df, upper):
df = df.copy()
df['revenue'] = df['revenue'].clip(upper=upper)
return df
df_result = (df
.pipe(filter_by_region, regions=['North', 'East'])
.pipe(cap_revenue, upper=1000)
)
print(df_result.shape)Menggabungkan pipe() dengan Metode Bawaan
Keunggulan pipe() adalah kemampuannya untuk terintegrasi dengan mulus dengan metode Pandas bawaan dalam rangkaian yang sama. Anda dapat mencampur .dropna(), .query(), .rename(), dan .pipe(custom_func) dalam urutan apa pun. Dengan demikian, rangkaian tersebut tetap ringkas (menggunakan metode bawaan jika memungkinkan) sekaligus fleksibel (menggunakan fungsi khusus ketika metode bawaan tidak memadai).
df_result = (
df
.dropna(subset=['revenue', 'order_date'])
.query('quantity > 0')
.rename(columns={'unit_price': 'price'})
.pipe(add_revenue_per_unit)
.reset_index(drop=True)
)
print(df_result.head())Men-debug Rangkaian pipe()
Men-debug rangkaian yang panjang dapat cukup rumit karena Anda tidak dapat memeriksa keadaan perantara dengan menambahkan pernyataan print di tengah rangkaian. Salah satu solusinya adalah menulis fungsi debug penerus yang mencetak informasi bentuk dan kolom, lalu mengembalikan DataFrame tanpa perubahan. Sisipkan fungsi tersebut di titik mana pun dalam rangkaian untuk memeriksa keadaan pada langkah itu tanpa memutus rangkaian.
def debug(df, label=''):
print(f'[{label}] shape: {df.shape}')
print(f'[{label}] columns: {df.columns.tolist()}')
return df
df_result = (
df
.pipe(drop_nulls)
.pipe(debug, label='after drop_nulls')
.pipe(filter_positive_qty)
.pipe(debug, label='after filter')
)
print('Done')Membangun Alur Kerja Pembersihan Lengkap
Gabungkan semua langkah pembersihan ke dalam satu fungsi alur kerja menggunakan pipe(). Membungkus rangkaian tersebut dalam fungsi bernama clean_pipeline(df) membuat alur kerja dapat diuji sebagai satu kesatuan. Panggil fungsi itu dengan DataFrame mentah dan dapatkan DataFrame yang bersih. Pola ini sejalan dengan paradigma ETL (Ekstrak, Transformasi, Muat) yang digunakan dalam rekayasa data produksi.
def clean_pipeline(df):
return (
df
.dropna(subset=['order_id', 'revenue'])
.drop_duplicates(subset=['order_id'])
.query('quantity > 0 and revenue >= 0')
.pipe(add_revenue_per_unit)
.reset_index(drop=True)
)
df_clean = clean_pipeline(df)
print('Clean rows:', len(df_clean))pipe() vs. apply(): Perbedaan Utama
pipe(func) meneruskan seluruh DataFrame ke func dan mengharapkan DataFrame (atau objek yang ditransformasikan) sebagai hasilnya. apply(func, axis=1) meneruskan satu baris setiap kali. Gunakan pipe() untuk transformasi seluruh DataFrame yang mempertahankan bentuk yang sama (atau sengaja mengubahnya), dan gunakan apply() untuk perhitungan pada tingkat baris atau kolom. Keduanya saling melengkapi, bukan saling bersaing.
# pipe: receives the whole DataFrame
def scale_revenue(df, factor=1.0):
df = df.copy()
df['revenue'] = df['revenue'] * factor
return df
# apply: receives one row at a time
df['revenue_x2'] = df.apply(lambda row: row['revenue'] * 2, axis=1)
df_scaled = df.pipe(scale_revenue, factor=1.1)
print('pipe scales all rows at once; apply does row-by-row')Komponen Alur Kerja yang Dapat Digunakan Kembali
Tulis setiap langkah alur kerja sebagai fungsi murni — tanpa keadaan global, menerima DataFrame, dan mengembalikan DataFrame. Fungsi murni mudah diuji secara unit: panggil dengan DataFrame pengujian kecil, lalu pastikan bentuk keluaran dan nilai kolomnya benar. Pustaka fungsi alur kerja yang telah diuji dan dapat digunakan kembali akan mempercepat analisis kumpulan data baru yang memiliki kebutuhan pembersihan serupa secara signifikan.
def normalise_strings(df, cols):
df = df.copy()
for col in cols:
df[col] = df[col].str.strip().str.lower()
return df
def parse_dates(df, cols):
df = df.copy()
for col in cols:
df[col] = pd.to_datetime(df[col])
return df
df_result = (
df
.pipe(normalise_strings, cols=['region', 'category'])
.pipe(parse_dates, cols=['order_date'])
)
print(df_result.dtypes)Mencatat Langkah Alur Kerja dengan pipe()
Tambahkan pencatatan terstruktur di dalam setiap fungsi alur kerja agar Anda dapat mengaudit setiap transformasi dalam produksi. Sertakan jumlah baris masukan, jumlah baris keluaran, dan statistik yang relevan (misalnya, baris yang dihapus oleh suatu penyaring). Dengan demikian, Anda mendapatkan jejak lengkap setiap proses alur kerja tanpa memerlukan pengatur alur kerja eksternal untuk keperluan audit dasar.
import logging
logging.basicConfig(level=logging.INFO)
def logged_dropna(df, subset):
before = len(df)
df = df.dropna(subset=subset)
after = len(df)
logging.info(f'dropna: {before - after} rows removed, {after} remaining')
return df
df_clean = df.pipe(logged_dropna, subset=['revenue'])
print('Logged pipeline complete.')Langkah Bersyarat dalam Alur Kerja
Terkadang langkah pembersihan hanya perlu dijalankan berdasarkan suatu penanda atau isi data. Anda dapat menambahkan langkah bersyarat ke dalam rangkaian pipe dengan menyisipkan fungsi identitas-atau-transformasi: fungsi tersebut memeriksa kondisi, lalu menerapkan transformasi atau mengembalikan DataFrame tanpa perubahan. Dengan cara ini, struktur rangkaian tetap utuh sekaligus mendukung langkah-langkah opsional.
def maybe_cap_revenue(df, cap=None):
if cap is None:
return df
df = df.copy()
df['revenue'] = df['revenue'].clip(upper=cap)
return df
CAPPING_ENABLED = True
CAP_VALUE = 1000 if CAPPING_ENABLED else None
df_result = df.pipe(maybe_cap_revenue, cap=CAP_VALUE)
print('Conditional step applied:', CAPPING_ENABLED)Mengekspor Hasil Alur Kerja
Langkah terakhir dalam rangkaian pipe() sering kali berupa ekspor. Anda dapat merangkai fungsi ekspor khusus menggunakan pipe() atau cukup memanggil metode ekspor Pandas bawaan setelah rangkaian selesai. Menggunakan langkah pipe(save_to_parquet) menjadikan ekspor sebagai bagian dari dokumentasi rangkaian dan memastikan ekspor selalu dijalankan pada DataFrame bersih terakhir, bukan versi perantara.
def save_parquet(df, path):
df.to_parquet(path, index=False)
print(f'Saved {len(df)} rows to {path}')
return df # return df so the chain can continue if needed
df_final = (
df
.pipe(clean_pipeline)
.pipe(save_parquet, path='orders_final.parquet')
)
print('Pipeline complete.')Pemeriksaan Cepat
Uji pemahaman Anda tentang konsep Analisis Data dari pelajaran ini.
Rangkuman Pelajaran
Dalam pelajaran ini Anda telah mempelajari: menggunakan pipe() untuk merangkai fungsi khusus dengan metode Pandas bawaan, membangun langkah alur kerja yang dapat digunakan kembali, diberi parameter, dan dapat diuji sebagai fungsi murni, serta menambahkan pencatatan debug dan langkah bersyarat di dalam rangkaian pipe. Selanjutnya, kita akan membahas cara menyusun langkah transformasi sebagai fungsi untuk alur kerja ETL produksi.
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Perangkaian Metode dengan pipe()” gratis?
Ya — teks lengkap “Perangkaian Metode dengan pipe()” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Pandas & NumPy Academy, upgrade ke CoddyKit PRO. Kursus Pandas & NumPy Academy mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Perangkaian Metode dengan pipe()”?
Tulis pipeline transformasi data yang mudah dibaca menggunakan pipe() untuk merangkai fungsi khusus bersama metode bawaan Pandas. Kamu berlatih Pandas & NumPy Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai Pandas & NumPy Academy?
Tidak diperlukan pengalaman sebelumnya. Pandas & NumPy Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.
Berapa lama pelajaran “Perangkaian Metode dengan pipe()” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran Pandas & NumPy Academy ini?
Ya. Setiap pelajaran Pandas & NumPy Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- apply() pada Kolom dan Baris
- apply() dengan GroupBy
- map() dan applymap() untuk Operasi Per Elemen
- Perangkaian Metode dengan pipe()