Python timedelta: Python’da Zaman Aralıklarıyla Çalışma

Birçok gerçek dünya veri kümesi tarih ve saat bilgileri içerir ve veri biliminde yaygın bir işlem, iki zaman noktası arasındaki farkı hesaplamaktır.

Tarih ve saatleri ölçmek için kullandığımız birimler (yıl, ay, gün, saat, dakika, saniye) özellikle düzensiz uzunluklara sahip olduklarında, çalışması en kolay birimler değildir.

Bununla birlikte Python’un datetime modülünün bir parçası olan timedelta veri türü, zaman aralıklarını hesaplamanın getirdiği karmaşıklıklarla ilgilenir.

Önce Python’un timedelta’sı nedir sorusuna çok kısa bir yanıtla başlayalım, ardından daha fazla ayrıntıyla devam edelim.

Python’da tarih ve saatler hakkında daha fazla bilgi edinmek için Python’da Tarihler ve Zamanlarla Çalışma kursuna göz atın.

Kısa Cevap: Python'un timedelta'sı Nedir

datetime modülündeki en önemli ve en sık kullanılan iki veri türü timedelta ve datetime’dır. datetime nesneleri belirli zaman noktalarını temsil ederken (ör. 1 Ocak 2024, saat 10:30), timedelta nesneleri iki nokta arasındaki süreleri veya aralıkları temsil eder. Bunu, "Ne zaman?" (datetime) ile "Ne kadar süre?" (timedelta) soruları arasındaki fark gibi düşünebilirsiniz.

İki tarihi ele alalım; bunları iki datetime nesnesiyle temsil edebiliriz. Bir tarihten diğerini çıkarmak, tarihler arasındaki zaman aralığını temsil eden bir timedelta nesnesi oluşturur:

import datetime

first_date = datetime.datetime(year=2024, month=1, day=1)
second_date = datetime.datetime(year=2024, month=5, day=27)
interval = second_date - first_date
print(interval)

147 days, 0:00:00

Çıktı, iki tarihin tam olarak 147 gün arayla olduğunu gösteriyor. Aşağıdaki örnekte, datetime.datetime.now() çağrısıyla kodun çalıştırıldığı tarih ve saati kullanıyoruz:

first_date = datetime.datetime(year=2024, month=1, day=1)
second_date = datetime.datetime.now()
interval = second_date - first_date

print(second_date)
print(interval)

2024-05-28 08:32:44.871646
148 days, 8:32:44.871646

timedelta nesnesi artık 2024’ün başlangıcı ile kodun çalıştırıldığı tarih ve saat arasında geçen süreyi gösteriyor.

Bu yazıda Python’un timedelta’sını daha ayrıntılı inceleyeceğiz.

timedelta Nesneleri Oluşturma

Önceki bölümde, iki datetime nesnesinden bir timedelta nesnesi oluşturduk; ancak bir zaman aralığını doğrudan timedelta() kurucusunu çağırarak da oluşturabiliriz:

interval = datetime.timedelta(days=10, seconds=3600)
print(interval)

10 days, 1:00:00

Aralık on gün ve bir saat uzunluğunda. Bir timedelta örneği oluştururken başka zaman birimlerini de kullanabiliriz:

interval = datetime.timedelta(weeks=1, days=3, hours=1)
print(interval)

10 days, 1:00:00

timedelta() çağrılırken aşağıdaki zaman birimlerinin herhangi biri geçerlidir:

• weeks
• days
• hours
• minutes
• seconds
• milliseconds
• microseconds

Bu eğitimde, zaman aralıklarının bir timedelta nesnesinde nasıl saklandığına daha derinlemesine bakacağız.

timedelta ile Temel Aritmetik

timedelta nesneleriyle aritmetik işlemler de yapabiliriz. Python 1.0, Python 2.0 ve Python 3.0’ın çıkış tarihlerini temsil eden aşağıdaki üç datetime nesnesini düşünün. datetime nesnelerini birbirinden çıkarmak bir timedelta nesnesi oluşturur:

release_date_python_1 = datetime.datetime(year=1991, month=2, day=20)
release_date_python_2 = datetime.datetime(year=2000, month=10, day=16)
release_date_python_3 = datetime.datetime(year=2008, month=12, day=3)

​time_between_1_and_2 = release_date_python_2 - release_date_python_1
time_between_2_and_3 = release_date_python_3 - release_date_python_2

​print(time_between_1_and_2)
print(time_between_2_and_3)

3526 days, 0:00:00
2970 days, 0:00:00

Çıktı, Python 1.0 ile 2.0’ın ve Python 2.0 ile 3.0’ın çıkışları arasındaki gün sayısını gösteriyor. Zaman aralıkları timedelta nesneleridir.

timedelta nesneleriyle datetime nesneleri arasında toplama ve çıkarma yapmak da mümkündür. release_date_python_3’e days=100 olan bir timedelta ekleyelim:

print(release_date_python_3 + datetime.timedelta(days=100))

2009-03-13 00:00:00

Python 3.0, 3 Aralık 2008’de yayımlandı. Bu tarihe yüz gün eklemek bizi 13 Mart 2009’a götürür.

Bununla birlikte, doğrudan timedelta nesneleriyle aritmetik işlemler de yapabiliriz:

print("Difference between gap 1 and gap 2")
print(time_between_1_and_2 - time_between_2_and_3)

print("Sum of gap 1 and gap 2")
print(time_between_1_and_2 + time_between_2_and_3)

Difference between gap 1 and gap 2
556 days, 0:00:00

Sum of gap 1 and gap 2
6496 days, 0:00:00

Çıktı, timedelta nesnelerinin çıkarılıp toplanabildiğini doğruluyor. Çarpma ve bölme de mümkündür:

print("Multiply time interval by 3:")
print(time_between_1_and_2 * 3)

print("Divide time interval by 3:")
print(time_between_1_and_2 / 3)

Multiply time interval by 3:
10578 days, 0:00:00

Divide time interval by 3:
1175 days, 8:00:00

timedelta nesnelerini karşılaştırmak da mümkündür:

print("Check if gap 1 is greater than gap 2")
print(time_between_1_and_2 > time_between_2_and_3)

True

Çıktı, Python 1.0 ile Python 2.0’ın çıkış tarihleri arasındaki aralığın, Python 2.0 ile Python 3.0 arasındaki aralıktan daha uzun olduğunu doğruluyor.

Önemli timedelta Öznitelikleri ve Yöntemleri

Bir timedelta nesnesi bir zaman aralığını gün, saniye ve mikrosaniye sayılarını saklayarak temsil eder. Bu üç birim, timedelta sınıfında özniteliklerle temsil edilen tek zaman birimleridir:

interval = datetime.timedelta(
    weeks=1,
    hours=10,
    minutes=22,
    milliseconds=1042,
)

print(f"{interval = }")
print(f"{interval.days = }")
print(f"{interval.seconds = }")
print(f"{interval.microseconds = }")

interval = datetime.timedelta(days=7, seconds=37321, microseconds=42000)
interval.days = 7
interval.seconds = 37321
interval.microseconds = 42000

timedelta() çağrısı hafta, saat, dakika ve milisaniye argümanlarını içerse de kurucu bu birimleri gün, saniye ve mikrosaniyeye dönüştürür. print() çağrıları, değişken adını ve değerini göstermek için eşittir işareti = içeren f-string’ler kullanır. Python’da f-string’ler hakkında daha fazla bilgiyi şu öğreticide bulabilirsiniz: Python’da f-string biçimlendirme.

timedelta sınıfının bir diğer yararlı aracı total_seconds() yöntemidir. Bu yöntem, toplam zaman aralığını saniye cinsinden döndürür:

print("Total time interval in seconds:")
print(interval.total_seconds())

Total time interval in seconds:
642121.042

Bu değer, tüm zaman aralığını saniye cinsinden temsil eder. Günleri ve mikrosaniyeleri hesaba katmadan yalnızca aralığın saniye bileşenini gösteren .seconds değerinden farklıdır.

.total_seconds() tarafından döndürülen değeri zaman aralığını başka herhangi bir birime dönüştürmek için kullanabiliriz:

print("Total time interval in days:")
print(interval.total_seconds() / 3600 / 24)

Total time interval in days:
7.431956504629629

Çıktı, .total_seconds() değerinin bir saatteki saniye sayısına ve bir gündeki saat sayısına bölünmesiyle zaman aralığını gün cinsinden gösterir.

timedelta Örneği: Büyüme Hesaplama

Bir örneğe bakalım. Python kitapları satan bir şirketin çevrimiçi mağazası tüm satışları kayıt altına alıyor. İşte bir müşteriye ait veriler:

data = {
    "customer_id": 3542,
    "sales": [
        {"date": "2024-04-21T13:23:45", "price": 24.99, "quantity": 1},
        {"date": "2024-02-13T10:54:12", "price": 24.99, "quantity": 2},
        {"date": "2024-01-08T20:32:24", "price": 18.99, "quantity": 1},
    ],
}

Bir müşterinin ilk ve son siparişleri arasındaki zaman farkını hesaplamamız gerekiyor. Tüm satışları içeren listedeki siparişler her zaman kronolojik sıradadır.

İlk adımımız bu iç içe geçmiş yapıdan tarihleri çıkarmak ve bunları datetime nesnelerine dönüştürmektir. Neyse ki zaman damgaları standart ISO 8601 biçiminde (YYYY-MM-DDTHH:MM:SS), bu yüzden kullanışlı fromisoformat() yöntemini kullanabiliriz:

sales = data["sales"]
dates = []
for item in sales:
    date = datetime.datetime.fromisoformat(item["date"])
    dates.append(date)

print(dates)

[datetime.datetime(2024, 4, 21, 13, 23, 45), datetime.datetime(2024, 2, 13, 10, 54, 12), datetime.datetime(2024, 1, 8, 20, 32, 24)]

dates listesi, her siparişin tarihlerini içeren datetime nesnelerini barındırır. Son olarak, ilk ve son sipariş arasındaki zaman aralığını hesaplayabiliriz:

time_span = dates[0] - dates[-1]
print(time_span)
print(time_span.days)

103 days, 16:51:21
103

İlk ve son tarihler arasındaki fark bir timedelta nesnesi verir. Kod, gün, saat, dakika ve saniye sayısını gösteren time_span’i görüntüler. Ayrıca yalnızca tam gün sayısını göstermek için time_span.days’i de gösteriyoruz.

Metinleri datetime’a dönüştürme hakkında daha fazla bilgi edinmek isterseniz şu öğreticiye göz atın: Python String to Datetime.

timedelta Kullanırken Hızlı İpuçları

Python’un timedelta’sını kullanırken akılda tutulması gereken birkaç noktaya bakalım:

1. Birimlerle ilgili hatalardan kaçınmak için timedelta() çağrılırken anahtar sözcük argümanları kullanmak en iyisidir:

interval = datetime.timedelta(weeks=1, days=3, hours=1, milliseconds=1354)

2. Farklı zaman dilimlerindeki iki tarih arasındaki zaman aralığını bulurken, timedelta zaman farkını hesaplamadan önce tarihleri UTC’ye dönüştürür:

import zoneinfo

some_date = datetime.datetime.fromisoformat("2024-01-01T00:00:00")

some_date_lon = some_date.replace(tzinfo=zoneinfo.ZoneInfo("Europe/London"))
some_date_nyc = some_date.replace(tzinfo=zoneinfo.ZoneInfo("America/New_York"))

print(some_date_lon)
print(some_date_nyc)
print(some_date_nyc - some_date_lon)

2024-01-01 00:00:00+00:00
2024-01-01 00:00:00-05:00
5:00:00

some_date’deki tarih, yeni yılın başlangıcını gösteriyor. Bu, zaman dilimi hakkında bilgi içermediği için saf (naive) bir datetime nesnesidir. Buna karşın some_date_lon ve some_date_nyc, sırasıyla Londra ve New York’ta yeni yılın başlangıcını temsil ettikleri için farkında (aware) datetime nesneleridir.

İki farkında datetime nesnesinin çıkarılmasıyla elde edilen timedelta, UTC zaman farkı olan beş saatlik bir zaman aralığı gösterir.

3. timedelta, yaz saati uygulaması (DST) değişikliklerini hesaba katmaz:

nyc = zoneinfo.ZoneInfo("America/New_York")

first_time = datetime.datetime.strptime("2024-03-10 1:00am", "%Y-%m-%d %I:%M%p")
first_time = first_time.replace(tzinfo=nyc)

second_time = datetime.datetime.strptime("2024-03-10 3:00am", "%Y-%m-%d %I:%M%p")
second_time = second_time.replace(tzinfo=nyc)

time_difference = second_time - first_time
print("Time difference between the first and second time:")
print(time_difference)

print("Checking the DST status of the first and second time:")
print(f"{first_time.dst() = }")
print(f"{second_time.dst() = }")

Time difference between the first and second time:
2:00:00

Checking the DST status of the first and second time:
first_time.dst() = datetime.timedelta(0)
second_time.dst() = datetime.timedelta(seconds=3600)

İki zaman, New York’ta 10 Mart 2024’te saat 1:00 ve 3:00’ı temsil eder. Aynı gün saat 2:00’de saatler 3:00’e alındığında yaz saati uygulaması başladı. İki zaman arasındaki fark, yaz saati uygulamasının başlaması nedeniyle aslında yalnızca bir saat geçmiş olsa da iki saati temsil eden bir timedelta verir.

Geçen gerçek süreyi istiyorsak UTC’ye dönüştürebiliriz:

first_time_utc = first_time.astimezone(zoneinfo.ZoneInfo("UTC"))
second_time_utc = second_time.astimezone(zoneinfo.ZoneInfo("UTC"))
time_difference_utc = second_time_utc - first_time_utc

print("Actual time difference between the first and second time:")
print(time_difference_utc)

Actual time difference between the first and second time:
1:00:00

datetime nesnelerini çıkarmadan önce UTC’ye dönüştürmek, iki datetime nesnesi arasındaki gerçek zamanı verir.

Sonuç

Python’un timedelta sınıfı, zaman aralıklarını ele almak için basit yöntemler sunar ve çeşitli birimlerdeki zaman dilimleriyle çalışmayı kolaylaştırır. timedelta nesnelerinin nasıl oluşturulacağını ve toplama, çıkarma, çarpma ve bölme dahil olmak üzere bunlarla nasıl aritmetik işlemler yapılacağını inceledik.

Tarih ve saatlerle çalışmak hakkında daha fazlasını şu makalelerde okuyabilirsiniz:

• Python’da Tarihler ve Zamanlarla Çalışma Cheat Sheet’i
• Python String to DateTime: Python’da Metinler Nasıl DateTime Nesnelerine Dönüştürülür
• Python’da Tarihler ve Zamanlarla Çalışma