Manfaat Kinerja Indeks Terurut
Urutkan MultiIndex dengan sort_index(), ukur kinerja irisan dengan timeit, dan gunakan is_monotonic_increasing sebagai pemeriksaan pengaman.
Manfaat Kinerja Indeks Terurut 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.
Mengapa Pengurutan Indeks Penting bagi Kinerja
Indeks yang terurut memungkinkan Pandas menggunakan pencarian biner (O(log n)), bukan pemindaian linear penuh (O(n)), saat mencari rentang label. Untuk DataFrame dengan satu juta baris, pencarian biner menemukan rentang target dalam sekitar 20 perbandingan, dibandingkan hingga satu juta perbandingan dengan pemindaian linear. Hal ini membuat operasi pemotongan pada MultiIndexes yang terurut jauh lebih cepat daripada pada indeks yang tidak terurut — dan perbedaannya menjadi sangat penting dalam pipeline produksi yang memproses jutaan baris.
import pandas as pd
import numpy as np
np.random.seed(42)
# Create a large DataFrame with a MultiIndex
countries = ['DE', 'UK', 'USA', 'FR', 'JP']
dates = pd.date_range('2020-01-01', periods=200)
mi = pd.MultiIndex.from_product([countries, dates], names=['country', 'date'])
df = pd.DataFrame({'value': np.random.randn(len(mi))}, index=mi)
print(f'DataFrame shape: {df.shape}')
print(f'Index is sorted: {df.index.is_monotonic_increasing}')Memeriksa Apakah Index Terurut
Gunakan df.index.is_monotonic_increasing untuk memeriksa apakah indeks terurut dalam urutan menaik. Ini mengembalikan nilai boolean. Untuk MultiIndex, Pandas memeriksa pengurutan secara leksikografis di semua tingkat. Selalu lakukan pemeriksaan ini sebelum melakukan operasi pemotongan dengan .loc[start:end] pada MultiIndex — indeks yang tidak terurut akan memunculkan UnsortedIndexError atau secara diam-diam mengembalikan hasil yang salah, bergantung pada versi Pandas.
import pandas as pd
# Sorted MultiIndex
tuples_sorted = [('A', 1), ('A', 2), ('B', 1), ('B', 2)]
mi_sorted = pd.MultiIndex.from_tuples(tuples_sorted)
df_sorted = pd.DataFrame({'v': [10, 20, 30, 40]}, index=mi_sorted)
# Unsorted MultiIndex
tuples_unsorted = [('B', 2), ('A', 1), ('B', 1), ('A', 2)]
mi_unsorted = pd.MultiIndex.from_tuples(tuples_unsorted)
df_unsorted = pd.DataFrame({'v': [10, 20, 30, 40]}, index=mi_unsorted)
print('Sorted index is_monotonic_increasing:', df_sorted.index.is_monotonic_increasing)
print('Unsorted index is_monotonic_increasing:', df_unsorted.index.is_monotonic_increasing)Mengurutkan dengan sort_index()
df.sort_index() mengembalikan DataFrame baru dengan baris yang diurutkan berdasarkan label indeks dalam urutan menaik. Gunakan ascending=False untuk urutan menurun. Untuk MultiIndex, pengurutan dilakukan secara leksikografis: tingkat terluar diurutkan terlebih dahulu, lalu tingkat dalam diurutkan di setiap kelompok terluar. Selalu lakukan pengurutan setelah operasi apa pun yang mungkin membuat indeks tidak terurut — seperti pd.concat, pemfilteran, atau penambahan baris baru.
import pandas as pd
import numpy as np
np.random.seed(0)
countries = ['USA', 'UK', 'DE']
years = [2021, 2022, 2023]
mi = pd.MultiIndex.from_product([countries, years], names=['country', 'year'])
df = pd.DataFrame({'gdp': np.random.randint(3000, 26000, 9)}, index=mi)
print('Before sort_index():')
print(df.head(4))
df_sorted = df.sort_index()
print('\nAfter sort_index():')
print(df_sorted.head(4))
print('Is sorted:', df_sorted.index.is_monotonic_increasing)Mengukur Waktu Pencarian dengan timeit
Modul timeit Python mengukur durasi eksekusi suatu pernyataan dengan menjalankannya berkali-kali lalu menghitung rata-ratanya. Gunakan modul ini untuk mengukur kinerja pencarian pada indeks terurut dibandingkan indeks yang tidak terurut. Di IPython/Jupyter, magic %timeit menyediakan fungsi yang sama dengan keluaran yang lebih mudah dibaca. Pengukuran kinerja adalah satu-satunya cara yang andal untuk memastikan bahwa optimasi kinerja benar-benar membantu — jangan pernah menganggap perubahan lebih cepat tanpa mengukurnya.
import pandas as pd
import numpy as np
import timeit
np.random.seed(0)
N = 500000
idx = np.random.choice(['A','B','C','D','E'], N)
df_unsorted = pd.DataFrame({'v': np.random.randn(N)}, index=idx)
df_sorted = df_unsorted.sort_index()
# Time label lookup: sorted vs unsorted
t_unsorted = timeit.timeit(lambda: df_unsorted.loc['C'], number=100)
t_sorted = timeit.timeit(lambda: df_sorted.loc['C'], number=100)
print(f'Unsorted lookup (100 runs): {t_unsorted:.3f}s')
print(f'Sorted lookup (100 runs): {t_sorted:.3f}s')
print(f'Speedup: {t_unsorted/t_sorted:.1f}x')PerformanceWarning dari MultiIndex yang Tidak Terurut
Pandas mengeluarkan PerformanceWarning saat Anda melakukan pemotongan pada MultiIndex yang tidak diurutkan secara leksikografis: 'indexing past lexsort depth may impact performance'. Peringatan ini berarti Pandas harus menggunakan pemindaian linear sebagai pengganti pencarian biner. Meskipun tetap mengembalikan hasil yang benar dalam kasus sederhana, operasi ini dapat mengembalikan hasil yang salah saat memotong tingkat dalam dari indeks bertingkat yang tidak terurut. Perlakukan peringatan ini sebagai error dan perbaiki akar masalahnya dengan mengurutkan indeks.
import pandas as pd
import warnings
# Create an unsorted MultiIndex and trigger the warning
tuples = [('B', 2), ('A', 1), ('B', 1), ('A', 2)]
mi = pd.MultiIndex.from_tuples(tuples, names=['letter', 'num'])
df = pd.DataFrame({'v': [10, 20, 30, 40]}, index=mi)
print('Index sorted?', df.index.is_monotonic_increasing)
# This may trigger PerformanceWarning in some Pandas versions
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
try:
result = df.loc['A':'B', :]
print('Result:', result)
if w:
print('Warning:', str(w[0].message))
except Exception as e:
print('Error (common with newer Pandas):', type(e).__name__)Mengukur Kinerja Pemotongan MultiIndex Terurut dan Tidak Terurut
Pemotongan MultiIndex yang terurut jauh lebih cepat karena Pandas dapat melakukan pencarian biner pada larik tingkat terluar dan tingkat dalam. Mari kita ukur kinerja pemotongan MultiIndex besar dengan 1 juta baris — ukuran yang umum dalam pipeline analitik produksi. Versi terurut menghindari pemindaian linear dan secara konsisten menunjukkan peningkatan kecepatan 5–50 kali, bergantung pada selektivitas pemotongan.
import pandas as pd
import numpy as np
import timeit
np.random.seed(42)
countries = ['DE', 'UK', 'USA', 'FR', 'JP']
dates = pd.date_range('2010-01-01', periods=200000)
# Sample a random subset for timing test
sample_countries = np.random.choice(countries, 100000)
sample_dates = np.random.choice(dates, 100000)
df = pd.DataFrame({
'country': sample_countries,
'date': sample_dates,
'value': np.random.randn(100000)
}).set_index(['country', 'date'])
df_sorted = df.sort_index()
print('Dataset size:', len(df))
print('Sorted:', df_sorted.index.is_monotonic_increasing)
t = timeit.timeit(lambda: df_sorted.loc['USA'], number=50)
print(f'Sorted lookup (50 runs): {t:.3f}s')sort_index dengan Parameter level
Untuk MultiIndex, Anda dapat mengurutkan berdasarkan tingkat tertentu, bukan semua tingkat, menggunakan parameter level: df.sort_index(level='year'). Ini berguna ketika Anda ingin mempertahankan pengelompokan tingkat terluar, tetapi mengatur ulang baris di dalam setiap kelompok terluar. Argumen sort_remaining=True (bawaan) juga mengurutkan tingkat lain yang belum terurut setelah tingkat yang ditentukan, sehingga memastikan pengurutan leksikografis penuh.
import pandas as pd
import numpy as np
countries = ['USA', 'UK']
years = [2023, 2021, 2022] # deliberately unordered
mi = pd.MultiIndex.from_product([countries, years], names=['country', 'year'])
df = pd.DataFrame({'v': range(6)}, index=mi)
print('Before sorting by year level:')
print(df)
# Sort by the inner level (year) only
df_ysorted = df.sort_index(level='year')
print('\nAfter sort_index(level="year"):')
print(df_ysorted)is_monotonic_increasing sebagai Pengaman Pipeline
Dalam pipeline produksi, tambahkan pengaman pengurutan di awal setiap fungsi yang menerima DataFrame dengan MultiIndex dan melakukan pemotongan. Jika indeks tidak terurut, urutkan secara otomatis dan catat peringatan. Hal ini mencegah penurunan kinerja yang tidak terlihat atau hasil yang salah ketika kode hulu mengubah urutan DataFrame. Pengaman pada batas fungsi lebih dapat diandalkan daripada mengasumsikan bahwa pemanggil selalu meneruskan data yang terurut.
import pandas as pd
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def safe_slice(df, key):
'''Slice a MultiIndex DataFrame, sorting if necessary.'''
if not df.index.is_monotonic_increasing:
logger.warning('Index not sorted — sorting now. This is a performance cost.')
df = df.sort_index()
return df.loc[key]
# Test with an unsorted DataFrame
tuples = [('B', 2), ('A', 1), ('B', 1), ('A', 2)]
mi = pd.MultiIndex.from_tuples(tuples, names=['letter', 'num'])
df = pd.DataFrame({'v': [10, 20, 30, 40]}, index=mi)
result = safe_slice(df, 'A')
print('Slice result for A:')
print(result)Indeks Terurut untuk Pencarian Biner pada Indeks Sederhana
Manfaat kinerja dari pengurutan juga berlaku untuk indeks biasa (bukan multi-indeks). DatetimeIndex yang digunakan dalam analisis deret waktu melakukan pemotongan rentang tanggal jauh lebih cepat saat terurut. Indeks string yang diurutkan berdasarkan abjad memungkinkan pencarian biner untuk pencarian label. Untuk Series besar berisi harga saham yang diindeks berdasarkan stempel waktu, pengurutan DatetimeIndex dapat mengubah operasi pemotongan 100 md menjadi operasi kurang dari satu milidetik.
import pandas as pd
import numpy as np
import timeit
np.random.seed(0)
# Random timestamps — unsorted
timestamps = pd.date_range('2020-01-01', periods=500000, freq='min')
shuffled = np.random.permutation(timestamps)
prices = pd.Series(np.random.randn(500000), index=shuffled)
prices_sorted = prices.sort_index()
# Time a date range slice
t_unsorted = timeit.timeit(lambda: prices['2020-06-01':'2020-06-30'], number=20)
t_sorted = timeit.timeit(lambda: prices_sorted['2020-06-01':'2020-06-30'], number=20)
print(f'Unsorted: {t_unsorted:.3f}s')
print(f'Sorted: {t_sorted:.3f}s')
print(f'Speedup: {t_unsorted/t_sorted:.0f}x')Biaya Memori Pengurutan
Pengurutan tidak gratis — sort_index() membuat salinan baru DataFrame (kecuali jika menggunakan inplace=True, yang mengubahnya langsung). Untuk DataFrame yang sangat besar, hal ini untuk sementara menggandakan penggunaan memori puncak. Strategi praktisnya adalah mengurutkan sekali saat pemuatan dan mempertahankan versi terurut di seluruh pipeline, bukan mengurutkannya berulang kali. Jika memori terbatas, urutkan langsung dengan df.sort_index(inplace=True) untuk menghindari salinan sementara.
import pandas as pd
import numpy as np
np.random.seed(0)
countries = ['DE', 'UK', 'USA']
years = [2021, 2022, 2023]
mi = pd.MultiIndex.from_product([countries, years], names=['country', 'year'])
df = pd.DataFrame({'v': np.random.randn(9)}, index=mi)
# Sort once at load time — best practice
df.sort_index(inplace=True) # no temporary copy
assert df.index.is_monotonic_increasing, 'Index must be sorted!'
print('Pipeline-ready DataFrame (sorted in place):')
print(df)Ringkasan Praktik Terbaik Indeks Terurut
Aturan utama untuk kinerja indeks: 1) Selalu panggil sort_index() setelah operasi apa pun yang mungkin membuat indeks tidak terurut (penggabungan, merge, penambahan, pemfilteran). 2) Gunakan is_monotonic_increasing sebagai pengaman dalam fungsi yang memotong indeks. 3) Urutkan saat pemuatan dan pertahankan DataFrame yang terurut di seluruh pipeline untuk menghindari pengurutan berulang. 4) Untuk DataFrame MultiIndex, pastikan semua tingkat terurut, bukan hanya tingkat terluar. 5) Gunakan timeit untuk memastikan bahwa pengurutan benar-benar memberikan peningkatan kecepatan yang diharapkan dalam pipeline Anda.
Pemeriksaan Singkat
Uji pemahaman Anda tentang kinerja indeks terurut dari pelajaran ini.
Ringkasan Pelajaran
Dalam pelajaran ini Anda mempelajari: is_monotonic_increasing memeriksa apakah indeks terurut dan pencarian biner tersedia, sort_index() mengurutkan langsung atau mengembalikan salinan terurut, dan timeit mengukur peningkatan kecepatan yang sebenarnya untuk memastikan manfaatnya. Selanjutnya kita akan membahas fungsi jendela — statistik rolling dan expanding untuk deret waktu serta data keuangan.
Belajar Python dengan tutor AI — gratis
Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.
- Kursus
- 30
- Pelajaran
- 120
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Manfaat Kinerja Indeks Terurut” gratis?
Ya — teks lengkap “Manfaat Kinerja Indeks Terurut” 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 “Manfaat Kinerja Indeks Terurut”?
Urutkan MultiIndex dengan sort_index(), ukur kinerja irisan dengan timeit, dan gunakan is_monotonic_increasing sebagai pemeriksaan pengaman. 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 “Manfaat Kinerja Indeks Terurut” 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
- Membuat MultiIndex
- Memilih Data dari MultiIndex
- Penyelarasan dan Pengindeksan Ulang
- Manfaat Kinerja Indeks Terurut