JupyterLab Kendo Grid ile Pandas DataFrame’leri Görüntüleme

JupyterLab’de Pandas DataFrame’lerinizi interaktif Kendo Grid arayüzüyle görselleştirin. Veri analizi ve raporlama süreçlerinizi hızlandırarak verimliliği artırın.

Veri bilimi ve analizi dünyasında, ham veriyi anlamlı bilgilere dönüştürmek her zaman kritik bir adımdır. Özellikle büyük ve karmaşık veri setleriyle çalışırken, bu verileri hızlı ve etkin bir şekilde görselleştirmek, ilk keşiflerden nihai raporlamaya kadar tüm süreçlerde başarıyı doğrudan etkiler. Çoğu zaman, Pandas DataFrame’ler JupyterLab ortamında standart tablo formatında görüntülenir. Ancak bu statik görüntüleme, veri setinin derinliklerine inmek, anormallikleri tespit etmek veya belirli desenleri ortaya çıkarmak için yeterli olmayabilir. Örneğin, binlerce satırdan oluşan bir veri setinde manuel olarak kaydırma yapmak, belirli kriterlere göre filtreleme uygulamak veya farklı sütunlara göre sıralama yapmak oldukça zahmetli ve zaman alıcıdır. Bu durum, veri analistlerinin ve bilim insanlarının değerli zamanlarını veri manipülasyonu yerine anlamsız arayışlarla geçirmelerine neden olabilir.

Bu bağlamda, interaktif veri görselleştirme araçları devreye girer. Geleneksel yaklaşımların aksine, interaktif gridler kullanıcıların verilerle doğrudan etkileşim kurmasına olanak tanır. Bir Kendo Grid, bu ihtiyacı karşılamak için geliştirilmiş güçlü bir araçtır. Kullanıcılar, sadece birkaç tıklama ile verileri sıralayabilir, filtreleyebilir, sayfalandırabilir ve hatta gruplandırabilir. Bu tür dinamik özellikler, veri keşif sürecini hızlandırır, hataları azaltır ve analiz edilen veriye dair daha derinlemesine içgörüler elde edilmesini sağlar. Özellikle JupyterLab gibi etkileşimli bir geliştirme ortamında, bu tür bir entegrasyon, analitik iş akışını baştan sona dönüştürebilir. Pandas DataFrame’leri ile Kendo Grid’i bir araya getirmek, statik tabloların sınırlamalarını ortadan kaldırarak, veri analizi deneyimini çok daha zengin ve verimli hale getirir. Bu makalede, bu güçlü entegrasyonun nasıl yapılacağını, temelden ileri düzeye kadar tüm detaylarıyla ele alacağız ve gerçek dünya senaryolarıyla somutlaştıracağız.

JupyterLab ve Pandas: Veri Analizinin Temel Taşları Nelerdir?

Veri analizi ve bilim alanında çalışan herkesin vazgeçilmez araçlarından ikisi şüphesiz JupyterLab ve Pandas’tır. Bu iki araç, milyonlarca veri noktasını işlemek, analiz etmek ve görselleştirmek için mükemmel bir sinerji oluşturur. Öncelikle, JupyterLab nedir sorusuna değinelim. JupyterLab, interaktif hesaplama için tasarlanmış web tabanlı bir geliştirme ortamıdır. Jupyter Notebook’ların daha gelişmiş ve modüler bir versiyonu olarak düşünülebilir. Kullanıcılar, Python, R, Julia gibi çeşitli programlama dillerinde kod yazabilir, markdown notları ekleyebilir, grafikler oluşturabilir ve tüm bunları tek bir arayüzde birleştirebilir. Bu sayede, analiz adımları, kodlar ve sonuçlar aynı belge içinde tutularak tekrarlanabilir ve paylaşılabilir bilimsel çalışmalar için ideal bir ortam sunar. Özellikle karmaşık veri analiz projelerinde, farklı dosyalara, terminallere ve araçlara tek bir pencereden erişebilme yeteneği, iş akışını önemli ölçüde hızlandırır.

Diğer yandan, Pandas kütüphanesi, Python’da veri manipülasyonu ve analizi için temel bir araçtır. Özellikle DataFrame adı verilen iki boyutlu etiketli veri yapıları sayesinde, tablo benzeri verilerle Excel veya SQL veritabanlarındaki gibi kolayca çalışılmasını sağlar. Pandas DataFrame’ler, finansal verilerden sosyal bilim verilerine, makine öğrenimi modelleri için özellik mühendisliğine kadar geniş bir kullanım alanına sahiptir. Veri okuma (CSV, Excel, SQL), temizleme, dönüştürme, birleştirme, gruplama ve özetleme gibi birçok işlemi son derece etkin bir şekilde gerçekleştirebilir. Bu kütüphane, veri bilimi projelerinin neredeyse her aşamasında kritik bir rol oynar. Ancak, Pandas’ın varsayılan DataFrame görüntüleme yetenekleri, büyük veri setleri için bazen yetersiz kalabilir. Yüzlerce satır ve sütundan oluşan bir DataFrame’i JupyterLab çıktı penceresinde görmek, sadece bir ekran görüntüsü gibidir; üzerinde filtreleme, sıralama veya dinamik arama yapma imkanı sunmaz. İşte tam da bu noktada, interaktif bir Kendo Grid eklentisi gibi çözümler, Pandas DataFrame’lerinin potansiyelini tam anlamıyla ortaya çıkarmak için devreye girer. Bu entegrasyon sayesinde, veri analistleri, ham veriyi yalnızca görüntülemekle kalmaz, aynı zamanda onunla interaktif bir şekilde etkileşime girerek daha derinleşimli içgörüler elde edebilirler.

Kendo UI Grid: Dinamik Tablo Görselleştirmenin Gücü Nasıl İşler?

Veri görselleştirme ve özellikle tablo bazlı veri sunumu söz konusu olduğunda, Kendo UI Grid gibi profesyonel bileşenler endüstri standardı haline gelmiştir. Peki, Kendo UI Grid nedir ve dinamik tablo görselleştirme yeteneğini nasıl sunar? Kendo UI, Telerik tarafından geliştirilen kapsamlı bir UI (Kullanıcı Arayüzü) kütüphanesidir ve web uygulamaları için zengin, etkileşimli bileşenler sunar. Bu bileşenler arasında en popülerlerinden biri de şüphesiz Kendo Grid’dir. Geleneksel HTML tablolarının aksine, Kendo Grid sadece verileri göstermekle kalmaz, aynı zamanda kullanıcılara bu verilerle etkileşim kurma imkanı sunar. Yani, verileri adeta canlı bir panoya dönüştürür.

Kendo Grid’in temel gücü, sunduğu zengin özellik setinden gelmektedir. Bunlardan bazıları şunlardır:

• Filtreleme: Kullanıcılar, belirli sütunlardaki verilere göre hızlıca filtreleme uygulayabilir. Örneğin, “Tarih” sütununa göre belirli bir aralıktaki verileri veya “Kategori” sütununa göre sadece belirli bir kategorideki ürünleri görüntüleyebilirler. Bu, özellikle binlerce hatta milyonlarca satırlık veri setlerinde aranan bilgiye ulaşmayı dramatik bir şekilde hızlandırır.
• Sıralama: Herhangi bir sütundaki verileri artan veya azalan düzende sıralama yeteneği, veri setindeki eğilimleri veya en yüksek/en düşük değerleri anında görmeyi sağlar. Tek tıklamayla birden fazla sütuna göre sıralama da mümkündür, bu da daha karmaşık sıralama ihtiyaçlarını karşılar.
• Sayfalama (Pagination): Büyük veri setlerinin tamamını tek seferde yüklemek yerine, verileri sayfalara bölerek yükler. Bu özellik, hem performans açısından önemlidir (tarayıcının aşırı yüklenmesini önler) hem de kullanıcı deneyimini iyileştirir (daha az veri yüklenmesi daha hızlı görüntüleme demektir).
• Gruplandırma (Grouping): Belirli bir sütuna göre verileri gruplandırarak özet bilgiler elde etmeyi sağlar. Örneğin, bir satış veri setini “Bölge” sütununa göre gruplandırarak her bölgenin toplam satışlarını anında görebilirsiniz.
• Yeniden Boyutlandırma ve Sütun Yönetimi: Kullanıcılar sütun genişliklerini sürükle bırak yöntemiyle değiştirebilir veya belirli sütunları gizleyip gösterebilirler. Bu da, veri sunumunu tamamen kullanıcının ihtiyacına göre özelleştirme esnekliği sunar.
• Veri Dışa Aktarma: Genellikle CSV, Excel veya PDF gibi formatlara veri dışa aktarma yeteneği de sunar. Bu, analiz sonuçlarını kolayca paylaşmak veya daha fazla işlem yapmak için kullanışlıdır.

Bu özellikler, özellikle karmaşık iş uygulamaları ve veri yoğun panolar için Kendo Grid’i vazgeçilmez kılar. JupyterLab ortamına entegre edildiğinde, bu güç Pandas DataFrame’lerinin statik görüntüsünü aşarak, veri analistlerine ve iş kullanıcılarına verileri daha derinlemesine keşfetme ve anlama imkanı sunar. Böylece, veri analizi süreçleri sadece teknik bir görev olmaktan çıkar, aynı zamanda interaktif ve keşfedici bir yolculuğa dönüşür.

JupyterLab Kendo Grid Eklentisi Nasıl Kurulur ve Kullanılır? (Uygulamalı Kısım)

Artık JupyterLab ortamında Pandas DataFrame’lerinizi Kendo Grid ile nasıl hayata geçireceğinizi adım adım inceleyelim. Bu bölüm, sıfırdan başlayarak kurulumdan temel kullanıma kadar her şeyi kapsayacak ve bolca kod örneği içerecektir. Unutmayın, bu eklenti sayesinde, verileriniz sadece bir tablo olmaktan çıkıp, interaktif bir keşif aracına dönüşecektir.

Adım 1: Gerekli Kütüphanelerin Kurulumu

Öncelikle, JupyterLab’de Kendo Grid’i kullanabilmek için gerekli Python kütüphanelerini kurmamız gerekiyor. Bu genellikle pip aracılığıyla yapılır. Ana kütüphane pandas zaten yüklü olacaktır, ancak Kendo Grid entegrasyonu için özel bir kütüphane veya jupyterlab uzantısı gerekecektir. Telerik’in doğrudan bir JupyterLab Kendo Grid eklentisi bulunmamakla birlikte, genellikle bu tür entegrasyonlar ipywidgets veya benzeri kütüphaneler aracılığıyla, Kendo Grid’in JavaScript bileşenlerinin Jupyter ortamına gömülmesiyle yapılır. En yaygın yaklaşımlardan biri, Python’da veriyi hazırlayıp, bu veriyi bir JavaScript fonksiyonuna aktararak Kendo Grid’i oluşturmaktır. Bu makale, doğrudan bir Python paketi yerine, Kendo Grid’i Jupyter çıktısında dinamik olarak oluşturacak genel bir yaklaşıma odaklanacaktır.

Başlangıç için, gerekli olanlar:

• pandas: Veri setlerimizi oluşturmak ve manipüle etmek için.
• IPython.display: HTML çıktısı oluşturmak ve JavaScript kodunu çalıştırmak için.

Bu kütüphaneler genellikle Jupyter ortamlarında önceden yüklü gelir, ancak yine de kontrol edebiliriz:

pip install pandas IPython

Adım 2: Örnek Bir Pandas DataFrame Oluşturma

Kendo Grid'de görüntülemek için basit bir Pandas DataFrame oluşturalım. Bu DataFrame, küçük bir finansal veri setini temsil etsin:

import pandas as pd

# Örnek finansal veri DataFrame'i oluşturalım
data = {
    'IslemID': [101, 102, 103, 104, 105, 106, 107, 108, 109, 110],
    'Tarih': pd.to_datetime(['2023-01-15', '2023-01-16', '2023-01-17', '2023-01-15', '2023-01-18', 
                             '2023-01-19', '2023-01-20', '2023-01-16', '2023-01-21', '2023-01-22']),
    'Kategori': ['Gıda', 'Elektronik', 'Giyim', 'Gıda', 'Ev Eşyası', 
                 'Ulaşım', 'Elektronik', 'Giyim', 'Eğlence', 'Gıda'],
    'Miktar': [50.75, 1200.00, 250.50, 30.00, 75.25, 
               15.00, 800.00, 180.00, 45.00, 60.50],
    'ParaBirimi': ['TL', 'USD', 'TL', 'TL', 'EUR', 
                   'TL', 'USD', 'TL', 'TL', 'TL']
}
df = pd.DataFrame(data)
print("Oluşturulan DataFrame:")
print(df.head())

Adım 3: Kendo Grid'i JupyterLab'e Entegre Etme

Bu kısım, Kendo Grid'in JavaScript kütüphanelerini yüklemeyi ve Pandas DataFrame'i JSON formatına dönüştürüp JavaScript'e aktarmayı içerir. JupyterLab ortamında Kendo Grid'i kullanmak için, Kendo UI kütüphanelerinin CDN (Content Delivery Network) üzerinden yüklenmesi ve ardından JavaScript kodu ile bir Grid oluşturulması gerekir. Bu işlemi kolaylaştırmak için bir Python fonksiyonu tanımlayabiliriz.

from IPython.display import HTML, Javascript, display
import json

def display_kendo_grid(dataframe, grid_id="kendoGrid", pageable=True, sortable=True, filterable=True):
    # Pandas DataFrame'i JSON formatına dönüştür
    data_json = dataframe.to_json(orient="records", date_format="iso")
    
    # Kendo UI stillerini ve scriptlerini CDN'den yükle
    # Bu adımı sadece bir kez çalıştırmak yeterlidir
    html_template = """
    
    
    
    

    
    """
    
    # DataFrame sütunlarını Kendo Grid sütun formatına dönüştür
    columns = []
    for col in dataframe.columns:
        col_type = str(dataframe[col].dtype)
        if 'datetime' in col_type:
            columns.append({"field": col, "title": col, "format": "{0:dd/MM/yyyy}", "type": "date"})
        elif 'int' in col_type or 'float' in col_type:
            columns.append({"field": col, "title": col, "type": "number"})
        else:
            columns.append({"field": col, "title": col, "type": "string"})
            
    columns_json = json.dumps(columns)

    # HTML çıktısını oluştur ve göster
    final_html = html_template.format(
        grid_id=grid_id,
        data_json=data_json,
        pageable=str(pageable).lower(),
        sortable=str(sortable).lower(),
        filterable=str(filterable).lower(),
        columns_json=columns_json
    )
    display(HTML(final_html))

# Oluşturduğumuz fonksiyonu kullanarak DataFrame'i Kendo Grid ile gösterelim
display_kendo_grid(df, grid_id="finansGrid")

Yukarıdaki kod bloğu, finansal veri setinizi interaktif bir Kendo Grid olarak JupyterLab çıktısında gösterecektir. Bu grid, sayfalama, sıralama ve filtreleme gibi temel özellikleri aktif olarak sunar. Kullanıcılar, sütun başlıklarına tıklayarak sıralama yapabilir, filtre ikonlarına tıklayarak değerleri filtreleyebilir ve sayfalama kontrolleri ile veriler arasında gezinebilir. Bu entegrasyon, statik df.head() çıktısının çok ötesinde bir deneyim sunarak, veri keşif ve analizini daha sezgisel ve verimli hale getirir.

Vaka Analizi: Küçük Bir Finansal Veri Setini Hızlıca Keşfetme

Yukarıdaki finansal veri setimizle, Kendo Grid'in nasıl bir fark yarattığını görelim. Diyelim ki hızlıca şu sorulara cevap arıyoruz:

1. En yüksek Miktar'a sahip işlem hangisidir?
2. Ocak ayında yapılan "Gıda" kategorisindeki tüm harcamaları görmek istiyorum.
3. Para Birimi USD olan işlemleri bul.

Normalde, Pandas ile bu sorguları yapmak için df.sort_values(), df[df['Kategori'] == 'Gıda'] gibi kodlar yazmamız gerekirdi. Ancak Kendo Grid ile, bu işlemleri direkt arayüz üzerinden yapabiliriz:

• "Miktar" sütun başlığına tıklayarak verileri büyükten küçüğe sıralayabilir ve en yüksek işlemi anında görebiliriz.
• "Kategori" sütunundaki filtre ikonuna tıklayıp "Gıda" seçeneğini işaretleyerek, sadece gıda harcamalarını listeleyebiliriz.
• "ParaBirimi" sütununda aynı şekilde filtre uygulayarak "USD" seçeneğini seçebiliriz.

Bu interaktif yaklaşım, özellikle hızlı keşif ve anlık karar verme süreçlerinde muazzam bir zaman tasarrufu sağlar ve kod yazma yükünü azaltır. Bir veri setini ilk kez incelerken veya bir sunum yaparken, dinamik olarak verileri manipüle edebilmek, anlatımı ve anlaşılırlığı artırır.

Gelişmiş Kendo Grid Özellikleri: Veri Analizinizi Nasıl İleri Taşırsınız?

JupyterLab Kendo Grid entegrasyonunun temelini attıktan sonra, şimdi bu güçlü aracın daha gelişmiş özelliklerini nasıl kullanacağımıza odaklanalım. Kendo Grid, sadece basit bir tablo olmanın ötesinde, veri analizi süreçlerinizi zenginleştirecek birçok özelleştirme ve fonksiyonellik sunar. Bu özellikler, verilerinizin sunumunu daha anlamlı hale getirirken, kullanıcıların derinlemesine analiz yapmasına olanak tanır.

Sütun Özelleştirmeleri ve Biçimlendirme

Veri tiplerine göre sütunları biçimlendirmek, gridin okunabilirliğini büyük ölçüde artırır. Örneğin, tarihler genellikle YYYY-MM-DD formatında gelirken, kullanıcılar DD/MM/YYYY gibi daha okunaklı bir format isteyebilir. Para birimleri ise sembollerle birlikte gösterildiğinde daha anlaşılır olur. Kendo Grid, sütun tanımlarında bu tür biçimlendirmeleri kolayca yapmanıza olanak tanır. Yukarıdaki display_kendo_grid fonksiyonumuzdaki columns tanımlamasını daha detaylı hale getirebiliriz:

    # DataFrame sütunlarını Kendo Grid sütun formatına dönüştür (Gelişmiş)
    columns = []
    for col in dataframe.columns:
        col_type = str(dataframe[col].dtype)
        column_def = {"field": col, "title": col}
        
        if 'datetime' in col_type:
            column_def.update({"format": "{0:dd/MM/yyyy}", "type": "date", "width": 120})
        elif 'float' in col_type:
            # Ondalık sayılar için formatlama, örn: 1,200.00
            column_def.update({"format": "{0:n2}", "type": "number", "width": 100})
        elif 'int' in col_type:
            column_def.update({"type": "number", "width": 80})
        else:
            column_def.update({"type": "string", "width": 150}) # Varsayılan genişlik
            
        # Bazı özel sütunlar için manuel ayarlamalar
        if col == "Miktar":
            # Para birimine göre formatlama örneği - dinamik yapılabilir
            column_def["template"] = "#= kendo.toString(Miktar, 'n2') # #= ParaBirimi #"
            column_def["width"] = 150
        elif col == "IslemID":
            column_def["width"] = 90
            
        columns.append(column_def)
    
    columns_json = json.dumps(columns) # JSON'a dönüştürülmüş sütun tanımları

Bu örnekte, Miktar sütunu için özel bir template kullanarak, miktarı para birimi ile birlikte göstermeyi başardık. Ayrıca, her sütuna varsayılan bir genişlik (width) atayarak daha düzenli bir görünüm elde ettik. Bu tür detaylı biçimlendirmeler, son kullanıcının veri üzerindeki okuryazarlığını artırır.

Veri Dışa Aktarma Yetenekleri

Analiz sonuçlarını veya filtrelenmiş verileri paylaşmak, çoğu zaman kritik bir adımdır. Kendo Grid, genellikle kullanıcı arayüzünden doğrudan CSV veya Excel formatında veri dışa aktarımına olanak tanıyan yerleşik özelliklere sahiptir. Bu özelliği Python fonksiyonumuza eklemek için, Kendo Grid yapılandırmasına toolbar ve excel ayarlarını eklememiz gerekir:

                toolbar: ["excel"],
                excel: {
                    fileName: "veri_analizi.xlsx",
                    proxyURL: "https://demos.telerik.com/kendo-ui/service/export", // Genellikle kendi sunucunuzda olması önerilir
                    filterable: true
                },
                columns: {columns_json}
            }});
        }});
    

Bu ayarlarla, gridin üzerinde bir "Export to Excel" butonu belirecek ve kullanıcılar görünen verileri kolayca Excel dosyasına aktarabileceklerdir. proxyURL kısmı genellikle bir sunucu tarafı hizmeti gerektirir, ancak basit dışa aktarımlar için Kendo'nun demo proxy'si kullanılabilir.

Vaka Analizi: Büyük Bir Müşteri Veri Setinde Filtreleme ve Sıralama

Şimdi daha büyük bir senaryo düşünelim: Bir e-ticaret şirketinin yüz binlerce müşterisine ait işlem verilerini analiz ediyoruz. Bu veri setinde "Müşteri ID", "Ürün Adı", "Fiyat", "Miktar", "Satın Alma Tarihi", "Bölge", "Cinsiyet" gibi sütunlar bulunuyor. Amacımız, en çok satın alma yapan müşteri gruplarını, belirli bölgelerdeki satış trendlerini veya belirli bir ürünün popülaritesini hızlıca keşfetmek. Kendo Grid'in gelişmiş filtreleme ve sıralama yetenekleri bu senaryoda paha biçilmezdir.

# Daha büyük bir DataFrame örneği oluşturalım (gerçekte bu bir CSV'den okunurdu)
import numpy as np

np.random.seed(42)
num_records = 50000

big_data = {
    'CustomerID': np.random.randint(1000, 9999, num_records),
    'ProductName': np.random.choice(['Laptop', 'Mouse', 'Keyboard', 'Monitor', 'Headset'], num_records),
    'Price': np.round(np.random.uniform(20, 1500, num_records), 2),
    'Quantity': np.random.randint(1, 10, num_records),
    'PurchaseDate': pd.to_datetime('2023-01-01') + pd.to_timedelta(np.random.randint(0, 365, num_records), unit='D'),
    'Region': np.random.choice(['North', 'South', 'East', 'West'], num_records),
    'Gender': np.random.choice(['Male', 'Female'], num_records)
}
big_df = pd.DataFrame(big_data)

print("Büyük DataFrame'den örnek:")
print(big_df.head())

# Büyük DataFrame'i Kendo Grid ile gösterelim
# Burada pageable, sortable ve filterable True olarak kalmalı
display_kendo_grid(big_df, grid_id="buyukMusteriGrid")

Bu grid üzerinde:

• "PurchaseDate" sütununu kullanarak belirli bir ay veya yıl aralığındaki satışları filtreleyebiliriz.
• "Region" sütununa göre gruplandırma yaparak her bölgenin toplam satışlarını hızla özetleyebiliriz (bu özellik Kendo Grid'de JavaScript tarafında ek bir konfigürasyon gerektirir).
• "Price" sütununu büyükten küçüğe sıralayarak en pahalı ürünlerin satışlarını inceleyebiliriz.

Bu interaktif analiz, kod yazmadan veri setinin derinliklerine inmeyi ve iş sorularına hızla yanıt bulmayı sağlar. Karmaşık filtre kombinasyonları veya çoklu sıralama kuralları bile kolayca uygulanabilir, bu da veri analistlerinin veriye daha esnek bir şekilde yaklaşmasına olanak tanır.

Performans Optimizasyonu ve Büyük Veri Setleri İçin İpuçları Nelerdir?

JupyterLab Kendo Grid entegrasyonu, küçük ve orta ölçekli veri setleri için harika sonuçlar verirken, yüz binlerce hatta milyonlarca satırlık büyük veri setleriyle çalışırken performans optimizasyonları kritik hale gelir. Doğru stratejiler uygulanmadığında, tarayıcı yavaşlayabilir, donabilir veya kullanıcı deneyimi olumsuz etkilenebilir. Bu bölümde, büyük veri setleriyle çalışırken Kendo Grid'in performansını nasıl optimize edebileceğinize dair ipuçlarını ve mobil uyumlu HTML çıktısı için önerileri ele alacağız.

1. Veri Boyutunu Yönetme (Sayfalama ve Sanallaştırma)

En temel ve etkili performans optimizasyonlarından biri, gridde aynı anda gösterilen veri miktarını sınırlamaktır. Kendo Grid'in sayfalama (pageable) özelliği tam da bunun için vardır. pageSize parametresi ile her sayfada kaç satır gösterileceğini belirleyerek, tarayıcının tek seferde işlemesi gereken veri miktarını azaltırsınız. Örneğin, 100.000 satırlık bir veri setinde, her sayfada 20 satır göstermek, kullanıcıların hızlıca veri arasında gezinmesini sağlarken, tarayıcının aşırı yüklenmesini engeller.

                dataSource: {{
                    data: data,
                    pageSize: 20 # Her sayfada 20 satır göster
                }},
                pageable: {{
                    refresh: true,
                    pageSizes: [10, 20, 50, 100], # Kullanıcının sayfa boyutunu seçmesine izin ver
                    buttonCount: 5
                }},

Kendo Grid ayrıca "sanallaştırma" (virtualization) özelliğine de sahiptir. Bu özellik, gridin sadece görünürdeki satırları DOM'a (Document Object Model) render etmesini sağlar ve kullanıcı aşağı kaydırdıkça yeni satırları dinamik olarak yükler. Bu sayede, çok büyük veri setlerinde bile akıcı bir kaydırma deneyimi sunar. Sanallaştırmayı aktif etmek için Kendo Grid yapılandırmasına scrollable: { virtual: true } gibi ayarlar eklemek gerekebilir. Ancak bu, height parametresiyle birlikte kullanılmalıdır.

2. Sunucu Tarafı İşleme (Server-Side Processing)

Çok büyük veri setleri için (milyonlarca satır), tüm veriyi istemci tarafına (tarayıcıya) göndermek pratik değildir. Bu durumlarda, filtreleme, sıralama ve sayfalama gibi işlemleri sunucu tarafında yapmak en iyi yaklaşımdır. JupyterLab Kendo Grid entegrasyonumuzun mevcut hali, tüm veriyi Python'dan JSON olarak istemciye gönderir. Sunucu tarafı işlemeye geçmek için:

1. Pandas DataFrame'i doğrudan JSON'a çevirmek yerine, veriyi bir API endpoint'i üzerinden sunmanız gerekir.
2. Kendo Grid'in dataSource özelliğini, data yerine bir transport objesi ile konfigüre etmeniz gerekir. Bu transport objesi, veriyi almak, güncellemek, silmek için API endpoint'lerini işaret eder.

Bu yaklaşım, Python'da Flask veya FastAPI gibi bir mikro web çerçevesi kullanarak küçük bir API oluşturmayı ve bu API'nin Kendo Grid'den gelen sayfalama, sıralama ve filtreleme isteklerini işleyerek sadece ilgili veri dilimini döndürmesini gerektirir. Bu, daha karmaşık bir kurulum olsa da, büyük veri setlerinde ölçeklenebilirlik için vazgeçilmezdir.

3. Veri Ön İşleme

Kendo Grid'e gönderilen veriyi optimize etmek de önemlidir. Sadece gerçekten ihtiyaç duyulan sütunları seçmek, gereksiz veri transferini azaltır. Ayrıca, to_json metodunu kullanırken, tarih formatlarını ISO formatında (date_format="iso") göndermek, JavaScript tarafında doğru biçimlendirilmelerine yardımcı olur.

4. Mobil Uyumlu HTML Çıktısı

JupyterLab'de oluşturulan çıktının bir web sayfasının parçası olduğunu düşünürsek, mobil cihazlarda da düzgün görünmesini sağlamak önemlidir. Kendo Grid zaten duyarlı bir tasarıma sahiptir, ancak genel sayfa yapısı ve stilizasyon için CSS media query'leri kullanmak faydalıdır. Aşağıdaki örnek, Jupyter çıktısına dahil edebileceğiniz basit bir CSS bloğunu göstermektedir:

Bu CSS kodunu