Sıralı İndekslerin Performans Faydaları
MultiIndex'i sort_index() ile sıralayın, dilim performansını timeit ile ölçün ve güvenlik denetimi olarak is_monotonic_increasing kullanın.
Sıralı İndekslerin Performans Faydaları, CoddyKit'te ücretsiz bir Pandas & NumPy Academy dersidir. Bu, 4 dersinin 4. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Pandas & NumPy Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Pandas & NumPy Academy kursu toplamda 4 dersten oluşur.
Dizin Sıralaması Performans İçin Neden Önemlidir
Sıralanmış bir dizin, etiket aralıklarını ararken tam bir doğrusal tarama (O(n)) yerine ikili arama (O(log n)) kullanılmasını sağlar. Bir milyon satırlı bir DataFrame'de ikili arama hedef aralığı yaklaşık 20 karşılaştırmada bulurken doğrusal taramada bir milyona kadar karşılaştırma gerekebilir. Bu, sıralanmış MultiIndex'lerdeki dilimleme işlemlerini sıralanmamış olanlara göre kat kat hızlandırır — milyonlarca satırı işleyen üretim veri işleme hatlarında bu fark kritik hâle gelir.
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}')Bir Dizinin Sıralanmış Olup Olmadığını Denetleme
Dizinin artan sırada sıralanıp sıralanmadığını denetlemek için df.index.is_monotonic_increasing kullanın. Bu ifade bir boole değeri döndürür. MultiIndex için Pandas, tüm düzeylerde sözlükbilimsel sıralamayı denetler. MultiIndex üzerinde .loc[start:end] ile dilimleme işlemleri gerçekleştirmeden önce bunu her zaman denetleyin — Pandas sürümüne bağlı olarak sıralanmamış bir dizin ya UnsortedIndexError oluşturur ya da sessizce yanlış sonuçlar döndürür.
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)sort_index() ile Sıralama
df.sort_index(), satırları dizin etiketine göre artan sırada sıralanmış yeni bir DataFrame döndürür. Azalan sıralama için ascending=False kullanın. MultiIndex için sıralama sözlükbilimseldir: önce en dış düzeye, ardından her dış grubun içindeki iç düzeylere göre sıralama yapılır. pd.concat, filtreleme veya yeni satır ekleme gibi dizinin sırasını bozabilecek herhangi bir işlemden sonra her zaman sıralama yapın.
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)timeit ile Arama Süresini Ölçme
Python'ın timeit modülü, bir ifadeyi birçok kez çalıştırıp ortalamasını alarak yürütülmesinin ne kadar sürdüğünü ölçer. Sıralanmış ve sıralanmamış dizin aramalarını karşılaştırmalı olarak ölçmek için kullanın. IPython/Jupyter'da %timeit sihirli komutu, daha anlaşılır bir çıktıyla aynı işlevi sağlar. Bir performans iyileştirmesinin gerçekten fayda sağladığını doğrulamanın tek güvenilir yolu ölçüm yapmaktır — ölçmeden bir değişikliğin daha hızlı olduğunu asla varsaymayın.
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')Sıralanmamış MultiIndex kaynaklı PerformanceWarning
Bir MultiIndex sözlükbilimsel olarak sıralanmadığında ve dilimlendiğinde Pandas bir PerformanceWarning yayımlar: 'indexing past lexsort depth may impact performance'. Bu uyarı, Pandas'ın ikili arama yerine doğrusal taramaya geri dönmek zorunda kaldığı anlamına gelir. Basit durumlarda yine doğru sonuçlar döndürse de sıralanmamış çok düzeyli bir dizinin iç düzeyleri dilimlendiğinde yanlış sonuçlar döndürebilir. Bu uyarıyı bir hata olarak ele alın ve dizini sıralayarak temel nedeni düzeltin.
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__)Sıralanmış ve Sıralanmamış MultiIndex Dilimleme Karşılaştırması
Sıralanmış MultiIndex dilimleme çok daha hızlıdır; çünkü Pandas hem dış hem de iç düzey dizilerinde ikili arama yapabilir. Üretim analitiği işlem hatlarında yaygın bir boyut olan 1 milyon satırlı büyük bir MultiIndex'i dilimlemeyi karşılaştırmalı olarak ölçelim. Sıralanmış sürüm, doğrusal taramayı önler ve dilimin seçiciliğine bağlı olarak tutarlı biçimde 5-50 kat hızlanma gösterir.
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')level Parametresiyle sort_index
MultiIndex için tüm düzeyler yerine level parametresini kullanarak belirli bir düzeye göre sıralama yapabilirsiniz: df.sort_index(level='year'). Bu, dış düzeydeki gruplamayı korurken her dış grubun içindeki satırları yeniden sıralamak istediğinizde kullanışlıdır. sort_remaining=True bağımsız değişkeni (varsayılan değer), belirtilen düzeyin ötesinde sıralanmamış olan düzeyleri de sıralayarak tam sözlükbilimsel sıralama sağlar.
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)İşlem Hattı Koruması Olarak is_monotonic_increasing
Üretim işlem hatlarında, MultiIndex içeren bir DataFrame alan ve dilimleme yapan her işlevin başlangıcına bir sıralama koruması ekleyin. Dizin sıralanmamışsa onu otomatik olarak sıralayın ve bir uyarıyı günlüğe kaydedin. Bu, üst düzey koddaki değişiklikler DataFrame'in sırasını değiştirdiğinde sessiz performans düşüşlerini veya yanlış sonuçları önler. İşlev sınırındaki bir koruma, çağıranların her zaman sıralanmış veri gönderdiğini varsaymaktan daha güvenilirdir.
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)Basit Dizinlerde İkili Arama için Sıralanmış Dizin
Sıralamanın performans faydaları normal (çok düzeyli olmayan) dizinler için de geçerlidir. Zaman serisi analizinde kullanılan bir DatetimeIndex sıralandığında tarih aralığı dilimleme işlemi çok daha hızlı gerçekleşir. Alfabetik olarak sıralanmış bir dize dizini, etiket aramalarında ikili aramaya olanak tanır. Zaman damgalarına göre dizinlenmiş büyük bir hisse senedi fiyatları Series'i için DatetimeIndex'i sıralamak, 100 ms süren bir dilimleme işlemini bir milisaniyenin altında tamamlanan bir işleme dönüştürebilir.
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')Sıralamanın Bellek Maliyeti
Sıralama ücretsiz değildir — sort_index(), inplace=True kullanılıp işlem yerinde değiştirilmediği sürece DataFrame'in yeni bir kopyasını oluşturur. Çok büyük DataFrames için bu işlem, en yüksek bellek kullanımını geçici olarak iki katına çıkarır. Uygulanabilir bir strateji, tekrar tekrar sıralamak yerine yükleme sırasında bir kez sıralamak ve işlem hattı boyunca sıralanmış sürümü korumaktır. Bellek kısıtlıysa geçici kopyayı önlemek için df.sort_index(inplace=True) ile işlem yerinde sıralayın.
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)Sıralanmış Dizin için En İyi Uygulamaların Özeti
Dizin performansı için temel kurallar: 1) Dizinin sırasını bozabilecek herhangi bir işlemden (concat, merge, append, filter) sonra her zaman sort_index() çağırın. 2) Dizini dilimleyen işlevlerde koruma olarak is_monotonic_increasing kullanın. 3) Tekrarlanan sıralamayı önlemek için yükleme sırasında sıralayın ve sıralanmış DataFrame'i işlem hattı boyunca koruyun. 4) MultiIndex DataFrames için yalnızca en dış düzeyin değil, tüm düzeylerin sıralandığından emin olun. 5) Sıralamanın kendi işlem hattınızda beklenen hızlanmayı gerçekten sağladığını doğrulamak için timeit kullanın.
Hızlı Kontrol
Bu derste öğrendiğiniz sıralanmış dizin performansı konusundaki anlayışınızı sınayın.
Ders Özeti
Bu derste şunları öğrendiniz: is_monotonic_increasing bir dizinin sıralı olup olmadığını ve ikili aramanın kullanılabilir durumda bulunup bulunmadığını kontrol eder, sort_index() dizini yerinde sıralar veya sıralanmış bir kopya döndürür ve timeit faydayı doğrulamak için gerçek hızlanmayı ölçer. Sırada, zaman serileri ve finansal veriler için kayan ve genişleyen istatistikleri sağlayan pencere işlevlerini inceleyeceğiz.
Sıkça Sorulan Sorular
“Sıralı İndekslerin Performans Faydaları” dersi ücretsiz mi?
Evet — “Sıralı İndekslerin Performans Faydaları” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Pandas & NumPy Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Pandas & NumPy Academy kursu toplamda 4 dersten oluşur.
“Sıralı İndekslerin Performans Faydaları” dersinde ne öğreneceğim?
MultiIndex'i sort_index() ile sıralayın, dilim performansını timeit ile ölçün ve güvenlik denetimi olarak is_monotonic_increasing kullanın. Pandas & NumPy Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.
Pandas & NumPy Academy öğrenmeye başlamak için deneyim gerekli mi?
Önceden deneyim gerekmez. CoddyKit'te Pandas & NumPy Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 4. dersidir.
“Sıralı İndekslerin Performans Faydaları” dersi ne kadar sürer?
Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.
Bu Pandas & NumPy Academy dersinde kod yazıp çalıştırabilir miyim?
Evet. Her Pandas & NumPy Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.
Bu kursun tüm dersleri
- MultiIndex Oluşturma
- MultiIndex'ten Veri Seçme
- İndeks Hizalama ve Yeniden İndeksleme
- Sıralı İndekslerin Performans Faydaları