Python timedelta: Bekerja dengan Interval Waktu di Python

Banyak dataset dunia nyata berisi tanggal dan waktu, dan operasi yang umum dalam data science adalah menghitung selisih waktu antara dua titik waktu.

Satuan yang kita gunakan untuk mengukur tanggal dan waktu (tahun, bulan, hari, jam, menit, detik) tidak selalu mudah digunakan, terutama ketika satuan-satuan ini memiliki panjang yang tidak seragam.

Namun, tipe data timedelta milik Python, yang merupakan bagian dari modul datetime, menangani kompleksitas perhitungan interval waktu.

Mari mulai dengan jawaban singkat tentang apa itu timedelta di Python, lalu lanjutkan dengan detailnya.

Untuk mempelajari lebih lanjut tentang tanggal dan waktu di Python, lihat kursus Working With Dates and Time in Python ini.

Jawaban Singkat: Apa itu timedelta di Python

Dua tipe data terpenting dan paling sering digunakan dari modul datetime adalah timedelta dan datetime. Objek datetime merepresentasikan titik waktu spesifik (misalnya, 1 Januari 2024 pukul 10.30), sedangkan objek timedelta merepresentasikan durasi atau interval antara dua titik. Anggap saja seperti perbedaan antara pertanyaan "Kapan?" (datetime) dan "Berapa lama?" (timedelta).

Pertimbangkan dua tanggal, yang dapat kita representasikan menggunakan dua objek datetime. Mengurangkan satu tanggal dari tanggal lain akan menghasilkan objek timedelta yang merepresentasikan interval waktu di antara tanggal-tanggal tersebut:

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

Output menunjukkan kedua tanggal berjarak tepat 147 hari. Pada contoh berikut, kita menggunakan tanggal dan waktu saat kode dijalankan dengan memanggil datetime.datetime.now():

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

Objek timedelta kini menunjukkan waktu yang berlalu antara awal 2024 dan tanggal serta waktu saat kode dijalankan.

Kita akan mengeksplorasi timedelta Python lebih lanjut dalam artikel ini.

Membuat Objek timedelta

Pada bagian sebelumnya, kita membuat objek timedelta dari dua objek datetime, tetapi kita juga dapat membuat interval waktu secara langsung dengan memanggil konstruktor timedelta():

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

10 days, 1:00:00

Intervalnya berdurasi sepuluh hari dan satu jam. Kita juga bisa menggunakan satuan waktu lain saat membuat instance timedelta:

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

10 days, 1:00:00

Satuan waktu berikut valid saat memanggil timedelta():

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

Tutorial ini akan membahas lebih dalam bagaimana interval waktu disimpan dalam objek timedelta.

Aritmetika Dasar dengan timedelta

Kita juga dapat melakukan operasi aritmetika dengan objek timedelta. Pertimbangkan tiga objek datetime berikut, yang merepresentasikan tanggal rilis Python 1.0, Python 2.0, dan Python 3.0. Mengurangkan objek datetime satu sama lain menghasilkan objek timedelta:

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

Output menunjukkan jumlah hari antara rilis Python 1.0 dan 2.0 serta antara rilis Python 2.0 dan 3.0. Interval waktu tersebut adalah objek timedelta.

Kita juga bisa melakukan penjumlahan dan pengurangan antara objek timedelta dan objek datetime. Mari tambahkan timedelta dengan days=100 ke release_date_python_3:

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

2009-03-13 00:00:00

Python 3.0 dirilis pada 3 Desember 2008. Menambahkan seratus hari ke tanggal ini membawa kita ke 13 Maret 2009.

Namun, kita juga dapat melakukan operasi aritmetika langsung dengan objek timedelta:

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

Output mengonfirmasi bahwa objek timedelta dapat dikurangkan dan dijumlahkan. Perkalian dan pembagian juga dimungkinkan:

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

Kita juga dapat membandingkan objek timedelta:

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

True

Output mengonfirmasi bahwa interval antara tanggal rilis Python 1.0 dan Python 2.0 lebih panjang daripada interval antara Python 2.0 dan Python 3.0.

Atribut dan Metode Kunci timedelta

Objek timedelta merepresentasikan interval waktu dengan menyimpan jumlah hari, detik, dan mikrodetik. Ketiga satuan ini adalah satu-satunya satuan waktu yang direpresentasikan oleh atribut dalam kelas timedelta:

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

Meskipun pemanggilan timedelta() menyertakan argumen untuk minggu, jam, menit, dan milidetik, konstruktor mengonversi satuan-satuan ini menjadi hari, detik, dan mikrodetik. Pemanggilan print() menyertakan f-string dengan tanda sama dengan = untuk menampilkan nama variabel dan nilainya. Anda dapat mempelajari lebih lanjut tentang f-string dalam tutorial f-string formatting in Python ini.

Alat berguna lain dari kelas timedelta adalah metode total_seconds(). Metode ini mengembalikan keseluruhan interval waktu dalam detik:

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

Total time interval in seconds:
642121.042

Nilai ini merepresentasikan keseluruhan interval waktu dalam detik. Ini berbeda dengan nilai .seconds, yang hanya menunjukkan komponen detik dari interval tanpa memperhitungkan hari dan mikrodetik.

Kita dapat menggunakan nilai yang dikembalikan oleh .total_seconds() untuk mengonversi interval waktu ke satuan lainnya:

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

Total time interval in days:
7.431956504629629

Output menunjukkan interval waktu dalam hari karena nilai yang dikembalikan oleh .total_seconds() dibagi dengan jumlah detik dalam satu jam dan jumlah jam dalam satu hari.

Contoh timedelta: Menghitung Pertumbuhan

Mari lihat sebuah contoh. Toko online sebuah perusahaan yang menjual buku Python mencatat semua penjualannya. Berikut data untuk satu pelanggan:

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},
    ],
}

Kita perlu menghitung selisih waktu antara pesanan pertama dan terakhir dari seorang pelanggan. Pesanan selalu berurutan secara kronologis dalam daftar yang memuat semua penjualan.

Langkah pertama kita adalah mengekstrak tanggal dari struktur bertingkat ini dan mengonversinya menjadi objek datetime. Syukurlah, stempel waktunya menggunakan format standar ISO 8601 (YYYY-MM-DDTHH:MM:SS), sehingga kita dapat menggunakan metode fromisoformat() yang praktis:

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)]

Daftar dates berisi objek datetime dengan tanggal setiap pesanan. Terakhir, kita dapat menghitung interval waktu antara pesanan pertama dan terakhir:

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

103 days, 16:51:21
103

Selisih antara tanggal pertama dan terakhir menghasilkan objek timedelta. Kode menampilkan time_span, yang menunjukkan jumlah hari, jam, menit, dan detik. Kita juga menampilkan time_span.days untuk menunjukkan hanya jumlah hari bulatnya.

Jika Anda ingin mempelajari lebih lanjut tentang mengonversi string ke datetime, lihat tutorial Python String to Datetime ini.

Tips Cepat Saat Menggunakan timedelta

Mari lihat beberapa hal yang perlu diingat saat menggunakan timedelta Python:

1. Sebaiknya gunakan argumen kata kunci saat memanggil timedelta() untuk menghindari kesalahan satuan:

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

2. Saat mencari interval waktu antara dua tanggal di zona waktu berbeda, timedelta mengonversi tanggal menjadi tanggal UTC sebelum menghitung selisih waktunya:

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

Tanggal pada some_date menunjukkan awal tahun baru. Ini adalah objek datetime naif karena tidak memiliki informasi zona waktu. Namun, some_date_lon dan some_date_nyc adalah objek datetime sadar zona waktu karena masing-masing merepresentasikan awal tahun baru di London dan New York.

timedelta yang diperoleh dari pengurangan dua objek datetime sadar tersebut menunjukkan interval waktu lima jam, yang merupakan selisih waktu terhadap UTC.

3. Perubahan daylight saving tidak diperhitungkan oleh timedelta:

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)

Kedua waktu tersebut merepresentasikan pukul 1.00 pagi dan 3.00 pagi pada 3 Maret 2024 di New York. Daylight saving dimulai pada pukul 2.00 pagi di hari yang sama ketika jam langsung maju ke pukul 3.00 pagi. Selisih antara kedua waktu menghasilkan timedelta selama dua jam meskipun hanya satu jam yang berlalu di antara kedua waktu karena dimulainya daylight saving.

Kita dapat mengonversi ke UTC jika membutuhkan jumlah waktu yang benar-benar berlalu:

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

Mengonversi ke UTC sebelum mengurangkan objek datetime memberikan waktu aktual di antara kedua objek datetime.

Kesimpulan

Kelas timedelta Python menawarkan cara yang lugas untuk menangani interval waktu, sehingga memudahkan bekerja dengan rentang waktu dalam berbagai satuan. Kita telah mengeksplorasi cara membuat objek timedelta dan melakukan operasi aritmetika dengannya, termasuk penjumlahan, pengurangan, perkalian, dan pembagian.

Anda dapat membaca lebih lanjut tentang penanganan tanggal dan waktu pada artikel berikut:

• Working with Dates and Times in Python Cheat Sheet
• Python String to DateTime: How to Convert Strings to DateTime Objects in Python
• Working with Dates and Times in Python