DataFrame’leri sunucusuz işlemde önbelleğe alın

Important

Bu özellik Genel Önizleme aşamasındadır. İş alanı yöneticileri, Previews sayfasından sunucusuz işlemde DataFrame önbelleğe alma erişimini denetleyebilir. Bkz. Azure Databricks önizlemelerini yönetme.

Sunucusuz hesaplamada, DataFrame'i oturumunuzda pahalı bir sonucu yeniden kullanmak için df.cache() veya df.persist() ile önbelleyebilirsiniz. cache() çağırdığınızda Azure Databricks DataFrame'i hesaplar ve sonucu bir anlık görüntü olarak somutlaştırır. DataFrame ve ondan oluşturduğunuz DataFrame'ler, yeniden hesaplamak yerine oturumunuzun geri kalanında anlık görüntüyü okur.

Requirements

  • Sunucusuz hesaplama önizlemesinde DataFrame önbellekleme çalışma alanınız için etkinleştirilmiş (varsayılan olarak etkinleştirilmiştir). İş alanı yöneticileri bunu Önizlemeler sayfasından devre dışı bırakabilir. Uyumluluk güvenlik profili etkinleştirilmiş çalışma alanlarında önizleme mevcut değildir. Bkz. Çalışma alanı düzeyinde önizlemeleri yönetme.
  • Sunucusuz hesaplamadaki defterler ve işler, ortam sürümü 5 veya üzerini kullanmak zorundadır.
  • Python için Databricks Connect 18.1.8 veya üzeri olmalıdır, Scala için Databricks Connect ise 18.1.5 veya üzeri olmalıdır.

Eski istemciler CACHE_REQUIRES_NEWER_CLIENT_ON_SERVERLESS_GC hatasını alır.

Sunucusuz hesaplamada DataFrame önbellekleme ne zaman kullanılır

Gerektiğinde sunucusuz hesaplamada bir DataFrame'i önbelleğe alın:

  • Pahalı bir birleştirme, toplama veya filtre sonucunu aynı oturumda birkaç kez tekrar kullanın.
  • Bir işlevde bir akış mikro grubunu bir kez foreachBatch hesaplayın, ardından bunu birkaç sink'e yazın.
  • Aynı hazırlanmış özellik verisi üzerinde birkaç makine öğrenimi modelini eğitin veya ayarlayın.
  • Bir analizin birkaç adımını çalıştırırken kaynak tablolar değişse bile kararlı bir anlık görüntü tutun.

Bkz. En iyi yöntemler.

Sunucusuz hesaplamada DataFrame API'lerini önbelleğe alın

Aşağıdaki örnek, bir günlük siparişlerin müşteri verileriyle birleştirilmesini önbellekler, günün toplam gelirini hesaplar, geliri bölge bazında bir rapor tablosuna ekler ve önbelleği serbest bırakır. Her iki sonuç da birleştirmeyi tekrar çalıştırmak yerine önbelleklenmiş anlık görüntüyü okuyor.

Python

from pyspark.sql import functions as F

# The DataFrame to cache: one day of orders joined with customer data.
oct_15_orders = (
    spark.table("main.sales.orders")
    .filter(F.col("order_date") == "2026-10-15")
    .join(spark.table("main.sales.customers"), "customer_id")
)
oct_15_orders.cache()

# Both results are built from oct_15_orders, so they read the cached snapshot.
total_revenue = oct_15_orders.agg(F.sum("amount")).first()[0]
print(f"Total revenue on 2026-10-15: {total_revenue}")

revenue_by_region = oct_15_orders.groupBy("order_date", "region").agg(F.sum("amount").alias("revenue"))
revenue_by_region.write.mode("append").saveAsTable("main.reports.revenue_by_region")

# Release the cache and the DataFrame when you no longer need it.
# oct_15_orders and DataFrames built from it can no longer be used.
oct_15_orders.unpersist()

Scala

import org.apache.spark.sql.functions._

// The DataFrame to cache: one day of orders joined with customer data.
val oct15Orders = spark.table("main.sales.orders")
  .filter(col("order_date") === "2026-10-15")
  .join(spark.table("main.sales.customers"), "customer_id")
oct15Orders.cache()

// Both results are built from oct15Orders, so they read the cached snapshot.
val totalRevenue = oct15Orders.agg(sum("amount")).first().get(0)
println(s"Total revenue on 2026-10-15: $totalRevenue")

val revenueByRegion = oct15Orders.groupBy("order_date", "region").agg(sum("amount").alias("revenue"))
revenueByRegion.write.mode("append").saveAsTable("main.reports.revenue_by_region")

// Release the cache and the DataFrame when you no longer need it.
// oct15Orders and DataFrames built from it can no longer be used.
oct15Orders.unpersist()

Aşağıdaki API açıklamalarında, df oturumunuzdaki herhangi bir DataFrame anlamına gelir, örneğin önceki örnekteki oct_15_orders.

df.cache()

Hemen hesaplar df ve sonucu oturumunuzun geri kalanı için bir anlık görüntü olarak önbeller.

  • Döndürür: Aynı önbelleklenmiş DataFrame, df, artık kaynak tablolarındaki hesaplama yerine anlık görüntüye dayanıyor. Aşağıdaki davranışa bakınız.
  • Davranış:
    • DataFrame'in sorgusunu hemen çalıştırır ve çağrı geri dönmeden önce sonucu bir anlık görüntü olarak oluşturur.
    • Çağrıdan df sonra ve geri dönen DataFrame (df kendisi) anlık görüntüye dayanır. Artık kaynak tablolardaki hesaplamaya bağlı değiller, bu yüzden sorguyu yeniden hesaplamak yerine anlık görüntüyü okurlar.
    • df öğesinden, doğrudan veya diğer türetilmiş DataFrame'ler aracılığıyla türetilen DataFrame'ler, orijinal sorguyu tekrar çalıştırmak yerine anlık görüntüyü otomatik olarak okur. Bkz. Anlık görüntüyü okuyun.
    • Snapshot oturumunuza özeldir. Bunu yalnızca df önbelleğe alan oturum okuyabilir. Bkz. İzolasyon ve ayrıcalıklar.
    • Anlık görüntü, oturum bitene kadar, en fazla yedi gün sürer. Azure Databricks ise depolama alanını arka planda otomatik olarak geri kazanır. df.unpersist() öğesini çağırmak, depolama alanını daha erken geri kazanmasını sağlar. Yaşam döngüsü ve zaman sınırları ile Depolama ve temizlik bölümlerine bakınız.
    • Hesaplama df başarısız olursa, df.cache() hatayı verir ve df önbelleğe alınmaz.
    • df.cache() zaten önbelleğe alınmış bir DataFrame üzerinde çağrıldığında hiçbir şey yapmaz. df tekrar hesaplanmıyor.

Anlık görüntü, df.cache() çağırdıktan sonra sabitlenir. Sonrasında df öğesinin okuduğu tablolara yazılan veriler ve bu tablolarda eklenen veya yeniden adlandırılan sütunlar gibi şema değişiklikleri bunu etkilemez. En son veriden yeniden hesaplamak için, DataFrame'i kaynak tablolardan tekrar oluşturun ve gerekirse yeni DataFrame'i önbelleğe alın.

Anlık görüntüyü okuyun

Sunucusuz hesaplamada, önbellek eşleştirme DataFrame türetimine dayanır. df.cache() sonrasında yalnızca aşağıdaki DataFrame'ler, sorguyu kaynak tablolarda yeniden hesaplamak yerine anlık görüntüyü otomatik olarak okur:

  • Önbelleğe koyduğunuz DataFrame, df.
  • df öğesinden türetilen DataFrame'ler, örneğin select(), filter(), groupBy() veya join().
  • Bu türetilen DataFrame'lerden daha ileri zincirlenen DataFrame'ler.

Aynı sorguyu tekrarlayan yeni bir DataFrame, mantığı aynı olsa da kaynak tabloları okur, çünkü df öğesinden türetilmemiştir.

Bu, önbellek eşleştirmesini açıkça sizin denetiminize bırakır: bir DataFrame, önbelleklenmiş veriyi yalnızca önbellekli bir DataFrame'den türettiğinizde okur. Diğer her DataFrame kaynak tablolarını okur.

Python

oct_15_orders = (
    spark.table("main.sales.orders")
    .filter(F.col("order_date") == "2026-10-15")
    .join(spark.table("main.sales.customers"), "customer_id")
)
# The join runs one time, when you call cache().
oct_15_orders.cache()

# Derived from oct_15_orders: read the snapshot, so the join doesn't run again.
large_orders = oct_15_orders.filter(F.col("amount") > 1000)
revenue_by_region = oct_15_orders.groupBy("order_date", "region").agg(F.sum("amount").alias("revenue"))

# Derived from large_orders, which is derived from oct_15_orders: also reads the snapshot.
large_orders_by_region = large_orders.groupBy("region").count()

# Not derived from oct_15_orders: reads the source tables and runs the join again.
same_query = (
    spark.table("main.sales.orders")
    .filter(F.col("order_date") == "2026-10-15")
    .join(spark.table("main.sales.customers"), "customer_id")
)

Scala

val oct15Orders = spark.table("main.sales.orders")
  .filter(col("order_date") === "2026-10-15")
  .join(spark.table("main.sales.customers"), "customer_id")
// The join runs one time, when you call cache().
oct15Orders.cache()

// Derived from oct15Orders: read the snapshot, so the join doesn't run again.
val largeOrders = oct15Orders.filter(col("amount") > 1000)
val revenueByRegion = oct15Orders.groupBy("order_date", "region").agg(sum("amount").alias("revenue"))

// Derived from largeOrders, which is derived from oct15Orders: also reads the snapshot.
val largeOrdersByRegion = largeOrders.groupBy("region").count()

// Not derived from oct15Orders: reads the source tables and runs the join again.
val sameQuery = spark.table("main.sales.orders")
  .filter(col("order_date") === "2026-10-15")
  .join(spark.table("main.sales.customers"), "customer_id")

df, oluşturulduğu DataFrame'ler yerine anlık görüntüyü okuduğu için, o DataFrame'ler aracılığıyla df sütunlarına referans veremezsiniz. Bkz. Sınırlamalar.

df.persist(storageLevel)

Depolama düzeyini kabul eden df.cache() için bir takma ad.

  • Parametreler:
    • storageLevel (isteğe bağlı): StorageLevel gibi, örneğin StorageLevel.DISK_ONLY. Sunucusuz hesaplama herhangi bir depolama seviyesini kabul eder ve bunu görmezden gelir. Snapshot her depolama seviyesi için aynı şekilde saklanır ve df.storageLevel, StorageLevel.DISK_ONLY döndürür.

Geri dönüş değeri ve davranışı ile df.cache()aynıdır.

df.unpersist(blocking)

df önbelleğe alınmış anlık görüntüsünü serbest bırakır ve DataFrame'i yok eder.

  • Parametreler:
    • blocking (isteğe bağlı): Yok sayılır. df.unpersist() Her iki değer için de hemen döndürür.
  • Döndürür: Aynı DataFrame, df, artık yok edilmiş durumda.
  • Davranış:
    • Anlık görüntüyü geri alınmaya hazır olarak işaretler. Azure Databricks daha sonra önbelleklenmiş verileri siler ve arka planda depolama alanını geri kazanır.
    • Yok eder: df ve bundan daha önce türetilen tüm DataFrame'ler artık kullanılamaz ve bunlar üzerinde sonraki herhangi bir sorgu CACHE_DATAFRAME_ACCESS_AFTER_UNCACHE hatası verir. Eğer df çağırmadan önce df.unpersist()'dan türetilmiş bir DataFrame'i önbelleklerseniz, o DataFrame kullanılabilir kalır, çünkü kendi anlık görüntüsü vardır.
    • Aynı veri kaynağıyla çalışmaya devam etmek için, önbelleğe alınmamış DataFrame'i tekrar kullanmak yerine orijinal veri kaynağından yeni bir DataFrame oluşturun.
    • Hiç önbelleğe alınmamış veya zaten önbellekten çıkarılmış bir DataFrame üzerinde df.unpersist() çağırmak etkisizdir.

Önbelleğe alınmış verilere artık ihtiyacınız kalmadığında df.unpersist() çağırın; örneğin not defterinizde veya işinizde daha sonraki hiçbir adım bu verileri okumadığında. Bu, Azure Databricks'in depolamayı daha erken geri almasına olanak tanır. df.unpersist() kullanarak verileri yenilemeyin. En son verilerle çalışmak için, kaynak tablolardan yeni bir DataFrame oluşturun.

Python

oct_15_orders = spark.table("main.sales.orders").filter(F.col("order_date") == "2026-10-15")
oct_15_orders.cache()
large_orders = oct_15_orders.filter(F.col("amount") > 1000)
orders_per_customer = oct_15_orders.groupBy("customer_id").count()
orders_per_customer.cache()  # Has its own snapshot.

# Acknowledge that the cached data is no longer needed.
# This releases the storage and destroys oct_15_orders.
oct_15_orders.unpersist()

oct_15_orders.count()  # Raises CACHE_DATAFRAME_ACCESS_AFTER_UNCACHE.
large_orders.count()  # Raises CACHE_DATAFRAME_ACCESS_AFTER_UNCACHE.
orders_per_customer.count()  # Reads its own snapshot.

# If you need the data again later, build a new DataFrame from the source tables.
oct_15_orders = spark.table("main.sales.orders").filter(F.col("order_date") == "2026-10-15")

Scala

var oct15Orders = spark.table("main.sales.orders").filter(col("order_date") === "2026-10-15")
oct15Orders.cache()
val largeOrders = oct15Orders.filter(col("amount") > 1000)
val ordersPerCustomer = oct15Orders.groupBy("customer_id").count()
ordersPerCustomer.cache() // Has its own snapshot.

// Acknowledge that the cached data is no longer needed.
// This releases the storage and destroys oct15Orders.
oct15Orders.unpersist()

oct15Orders.count() // Throws CACHE_DATAFRAME_ACCESS_AFTER_UNCACHE.
largeOrders.count() // Throws CACHE_DATAFRAME_ACCESS_AFTER_UNCACHE.
ordersPerCustomer.count() // Reads its own snapshot.

// If you need the data again later, build a new DataFrame from the source tables.
oct15Orders = spark.table("main.sales.orders").filter(col("order_date") === "2026-10-15")

df.storageLevel

Depolama seviyesini alır df.

  • Döndürür: StorageLevel.DISK_ONLYdf önbelleğe alınırken. StorageLevel.NONE önbelleğe almadan önce ve df.unpersist() çağırdıktan sonra.

Python

from pyspark import StorageLevel

oct_15_orders.cache()
oct_15_orders.storageLevel == StorageLevel.DISK_ONLY  # True

Scala

import org.apache.spark.storage.StorageLevel

oct15Orders.cache()
oct15Orders.storageLevel == StorageLevel.DISK_ONLY // true

Metod imzaları için, cache, persist, unpersist ve storageLevel için PySpark referansına bakınız.

Yaşam döngüsü ve zaman sınırları

Önbelleğe alınan veriler yalnızca önbelleğe koyduğunuz Azure Databricks oturumunda mevcuttur. Seans bittiğinde erişilemez hale gelir ve en fazla yedi gün sürer. Yedi günlük sınırdan sonra, önbelleklenmiş bir DataFrame kullanmak kaynak tabloları tekrar okumak yerine hata verir. Yeniden önbelleğe almak için yeni bir oturum başlatın.

Depolama ve temizleme

Azure Databricks, önbelleğe alınan verilerin depolamasını otomatik olarak yönetir. Önbelleğe alınan veriler bulut depolamada saklanır ve özel depolama konumu çalışma alanı türünüze bağlıdır:

  • Sunucusuz çalışma alanları: Önbelleklenmiş veriler varsayılan depolamada saklanır. Yönetilen hizmetler için müşteri tarafından yönetilen bir anahtarı yapılandırdıysanız, önbelleklenmiş veri o anahtarı kullanır. Şifreleme için müşteri tarafından yönetilen anahtarlara bakınız .

Önbelleğe alınan veriler erişilemez hale geldiğinde, Azure Databricks otomatik olarak arka planda depolama alanını geri kazanır. Bu, oturumun bağlantı kesilmesi veya çökme nedeniyle sona erdiği durumları da kapsar. df.unpersist() çağrıldığında, Azure Databricks'in depolamayı daha erken geri almasına olanak tanır.

Yalıtım ve ayrıcalıklar

Sunucusuz hesaplamada kod çalıştırabilen herhangi bir kullanıcı bir DataFrame önbelleğe alabilir. Ekstra ayrıcalıklara ihtiyacınız yok.

Önbelleklenmiş veriler, oturum düzeyinde izolasyon sağlar. Yalnızca bir DataFrame'i önbelleğe alan oturum, önbelleklenmiş verilerini okuyabilir. Diğer kullanıcılar, aynı not defterinin diğer kullanıcıları da dahil olmak üzere, ona erişemez.

Önbelleğe alınan veriler, önbelleğe alındıkları sırada okumanıza izin verilenleri içerir. Kaynak tablolara sonradan uygulanan izin değişiklikleri, satır filtreleri ve sütun maskeleri önbelleğe alınmış verilere uygulanmaz.

Önerilen yöntemler

  • Kararlı bir anlık görüntüye ihtiyacınız olduğunda önbelleğe alın: Aynı hesaplanan veri üzerinde birden fazla dönüşüm, toplama veya drill-down işlemi yaparsanız, anlık görüntü onlara kaynak tablolar değiştiğinde değişmeyen tutarlı bir temel sağlar.
  • Pahalı hesaplamaları önbelleğe alın, basit tablo okumalarını değil: df.cache() sorgu sonucunu materyalize eder ve daha sonra okumalar bu anlık görüntüyü tarar. Eğer örneğin spark.table("main.sales.orders").cache() gibi düz bir tablo okumasını önbelleğe alırsanız, sonraki okumalar yine tablonun tam kopyasını tarar, böylece önbellekleme çok az tasarruf sağlar. Önbellekleme, birleştirmeler, toplamalar ve karmaşık filtreler gibi pahalı işlerin ardından karşılığını verir.
  • Sadece bir kez okuduğunuz verileri önbellemeyin: df.cache() sonucu hemen hesaplar ve depolar, bu da zaman ve depolama gerektirir. Sonucu sadece bir kez okursanız, başlangıç maliyeti buna değmez.
  • Önbelleği, önbelleğe alınmış DataFrame'den türeterek kullanın: Anlık görüntüyü okumak için, sonraki işlemleri önbelleğe alınmış DataFrame değişkeni üzerine kurun; örneğin df.select(...) veya df.filter(...). Kaynak tablolardaki aynı hesaplamadan oluşturulan bağımsız bir DataFrame önbelleği kullanmaz.
  • Önbelleği oturumlar arası veya kullanıcılar arası veri paylaşımı için kullanmayın: Önbelleklenmiş veriler oturumunuza özeldir. Diğer oturumlar, not defterleri, iş çalıştırmaları ve kullanıcılar bunu okuyamıyor. Hesaplanmış sonuçları oturumlar arasında veya diğer kullanıcılarla paylaşmak için kalıcı bir tabloya yazabilirsiniz.
  • Önbelleğe alınmış verilerle oturumları yedi günü aşmayacak şekilde tutun: Yaşam döngüsü ve zaman sınırları bölümlerine bakınız. İş akışınız veriye daha uzun süre ihtiyaç duyuyorsa, bunu bir tabloya yazın.
  • Önbelleğe alınmış verilere artık ihtiyacınız olmadığında df.unpersist()çağırın: Bu, Azure Databricks'in depolamayı daha erken geri almasını sağlar. Çağrıdan sonra, DataFrame ve ondan türetilen DataFrame'ler kullanılamaz.
  • Verileri yenilemek için df.unpersist() kullanma: df.unpersist() anlık görüntünün ömrünü sonlandırır. Kaynak tablolardaki değişiklikleri yakalamak için, kaynak tablolardan yeni bir DataFrame oluşturun.

Limitations

Sunucusuz hesaplamada DataFrame önbelleğiyle aşağıdaki sınırlamalar vardır:

  • Sütun adları ve türleri: Aşağıdaki DataFrame'ler önbelleğe alınamaz. Önbelleğe almadan önce sütunları yeniden adlandırın veya dönüştürün, örneğin .alias("total_amount") ile.
    • Yinelenen sütun adlarına sahip DataFrame'ler.
    • Sütun adları boşluk veya ,;{}()= karakterlerinden herhangi birini içeren DataFrame'ler; örneğin, bir toplulaştırmadan gelen sum(amount).
    • Aralık sütunlu DataFrame'ler.
    • NULL tipli değerler içeren diziler, haritalar veya yapılar içeren DataFrame'ler.
    • Sütunsuz veya sadece NULL tipli sütunlu DataFrame'ler.
  • Sütun başvuruları: Bir DataFrame'i önbelleğe aldıktan sonra, sütunlarına oluşturulduğu DataFrame'ler üzerinden erişemezsiniz. Örneğin, oct_15_orders.cache() ve oct_15_orders = orders.join(customers, "customer_id") sonrasında oct_15_orders.select(orders.amount), CANNOT_RESOLVE_DATAFRAME_COLUMN oluşturur. Bunun yerine oct_15_orders.amount veya "amount" kullanın.
  • SQL ve katalog önbellek API'leri: CACHE TABLE gibi SQL önbellek ifadeleri ve spark.catalog'nin tablo önbellek yöntemleri sunucusuz işlemde desteklenmez. Bkz. Önbellek sınırlamaları. SQL'de bir sorgu sonucunu tekrar kullanmak için, oturum-yerel geçici bir tablo kullanın.
  • Bilgi şeması sorguları: Bir metastore'da birçok oturum DataFrames'i önbelleğe aldığında, information_schema.volumes ve information_schema.schemata üzerindeki sorgular yavaş olabilir veya zaman aşımına uğrayabilir. volumes öğesini kataloğa göre filtrelemek sorguyu hızlandırmaz. information_schema.tables üzerindeki sorgular etkilenmiyor.
  • Azure Kamu bölgelerinde: DataFrame önbellekleme, Azure Kamu bölgelerinde sunucusuz işlemde desteklenmiyor.

Classic Compute'tan geçiş

Çoğu iş yükü için, sunucusuz hesaplamada önbellekleme klasik hesaplamadaki sonuçlarla aynı sonuçları verir ve mevcut kod değişiklik olmadan çalışır. Aşağıdaki tablo farkları listelemektedir.

Behavior Sunucusuz işlem Klasik işlem
Önbellek eşleştirmesi Yalnızca önbelleğe alınan DataFrame ve ondan türetilen DataFrame'ler önbelleği otomatik olarak kullanır. Aynı plan şekline sahip herhangi bir sorgu otomatik olarak önbelleği kullanır.
Veri tazeliği df.cache() çağırdığınız anda çekilmiş tutarlı bir anlık görüntü. Değişir: önbelleklenmiş veriler bazı durumlarda yenilenir, diğerlerinde ise bir anlık görüntü sunar.
Paylaşım kapsamı Seansınıza özel. Küme içindeki oturumlar arasında paylaşılıyor.
Maddi Gerçekleşme Eager: df.cache() çağırdığınızda hemen hesaplanır. Lazy: DataFrame'deki ilk eylemde hesaplanıyor.
df.unpersist() DataFrame'i yok eder ve anlık görüntüsünü deterministik olarak serbest bırakır. Bellek içi önbelleği serbest bırakır. DataFrame'in sonraki kullanımında, ürüne ve veri kaynağına bağlı olarak en güncel veya eski veriler kullanılabilir.

Aşağıda ilk iki fark daha ayrıntılı şekilde açıklanır:

  • Önbellek eşleştirme:
    • Değişiklikten etkilenen iş yükleri: Çoğu iş yükü etkilenmez. Eğer önbelleklenmiş DataFrame değişkenini kullanmaya devam ederseniz, örneğin df.select(...) veya df.filter(...)ile, önbellek eskisi gibi çalışır. Bu değişiklik, yalnızca bağımsız olarak oluşturulmuş bir DataFrame veya SQL sorgusunun, aynı plan şekline sahip olduğu için önbelleği yeniden kullandığı iş yüklerini etkiler. Sunucusuz hesaplamada, bu sorgular kaynak tabloları okur.
    • İş yükünüz etkilenirse: Aynı sorguyu yeniden oluşturmak yerine, önbelleğe alınmış sonuca ihtiyaç duyduğunuz her yerde önbelleğe alınmış DataFrame değişkenini kullanın.
  • Veri tazeliği:
    • Değişiklikten etkilenen iş yükleri: Çoğu iş yükü etkilenmez, çünkü önbelleğe alınan verileri kaynak tablolara yazdıktan sonra bunları yeniden okumak yaygın değildir. Bu değişiklik, yalnızca kaynak tablolara yazan ve önbelleklenen DataFrame'in yeni veriyi göstermesini bekleyen iş yüklerini etkiler.
    • İş yükünüz etkilenirse: Kaynak tablolara yazdıktan sonra, önbelleğe alınmış DataFrame’i yeniden kullanmak yerine onlardan yeni bir DataFrame oluşturun.

Ek kaynaklar

  • Son güncelleştirme: