Memahami Modul time dalam Python untuk Mengelola Waktu dan Durasi Program

Waktu merupakan salah satu unsur penting dalam pengembangan program komputer. Banyak aplikasi membutuhkan informasi waktu untuk mencatat aktivitas pengguna, mengatur jadwal, menghitung durasi proses, memberikan jeda sebelum menjalankan perintah berikutnya, hingga menyimpan riwayat suatu kejadian. Dalam bahasa pemrograman Python, kebutuhan tersebut dapat ditangani menggunakan modul bawaan bernama `time`.

Sebelum lebih lanjut mempelajari materi tentang cara Memahami Modul time dalam Python untuk Mengelola Waktu dan Durasi Program, terlebih dahulu pelajari materi tentang: Memahami Cara Mendapatkan Tanggal dan Waktu Saat Ini dalam Python, Memahami Cara Mendapatkan Waktu Saat Ini dalam Python, dan Mengubah Timestamp Menjadi Objek Datetime dalam Python.

Modul `time` menyediakan sejumlah fungsi untuk memperoleh informasi waktu, mengubah waktu menjadi bentuk yang lebih mudah dibaca, serta mengendalikan jalannya program berdasarkan durasi tertentu. Modul ini juga memungkinkan pengembang mengolah waktu dalam bentuk angka, struktur data, maupun teks. Dengan demikian, pengelolaan waktu tidak selalu harus dilakukan melalui perhitungan manual.

Sebelum menggunakan fungsi-fungsi di dalamnya, modul `time` perlu diimpor terlebih dahulu:
import time

Setelah proses impor dilakukan, fungsi di dalam modul dapat dipanggil menggunakan awalan `time.`. Sebagai contoh, `time.time()` digunakan untuk memperoleh waktu dalam bentuk angka, sedangkan `time.sleep()` digunakan untuk memberikan jeda pada pelaksanaan program.

Pemahaman terhadap modul ini penting karena setiap fungsi memiliki tujuan dan jenis hasil yang berbeda. Ada fungsi yang menghasilkan angka, ada yang menghasilkan teks, dan ada pula yang menghasilkan objek terstruktur. Pemilihan fungsi yang tepat akan membantu program bekerja secara lebih teratur dan sesuai kebutuhan.

Memahami Konsep Waktu dalam Python

Dalam pemrograman, waktu dapat direpresentasikan melalui beberapa bentuk. Salah satunya adalah timestamp, yaitu angka yang menunjukkan jumlah detik yang telah berlalu sejak titik awal perhitungan waktu tertentu. Pada sistem Unix, titik awal tersebut dikenal sebagai epoch, yaitu 1 Januari 1970 pukul 00.00.00 UTC.

Timestamp biasanya disimpan sebagai angka bertipe `float` karena dapat memuat pecahan detik. Bentuk ini berguna untuk perhitungan komputer, tetapi tidak selalu mudah dipahami manusia. Sebagai contoh, angka `1793361600.0` tidak langsung menunjukkan tanggal dan jam jika belum dikonversi.

Bentuk lainnya adalah waktu terstruktur yang memisahkan informasi menjadi tahun, bulan, tanggal, jam, menit, detik, hari dalam minggu, dan hari dalam tahun. Python menyediakan struktur `struct_time` untuk menampung informasi tersebut.

Waktu juga dapat disajikan sebagai teks, misalnya `30 October 2026, 19:00:00`. Bentuk teks lebih mudah dibaca dan dapat disesuaikan dengan kebutuhan tampilan aplikasi. Ketiga bentuk tersebut saling berkaitan dan dapat dikonversi menggunakan fungsi-fungsi dalam modul `time`.

Mengambil Timestamp dengan `time.time()`

Fungsi `time.time()` digunakan untuk memperoleh waktu saat ini dalam bentuk jumlah detik sejak epoch. Nilai yang dihasilkan berupa angka bertipe `float`. Fungsi ini sering digunakan ketika program membutuhkan representasi waktu numerik atau ketika pengembang ingin menghitung selisih waktu.

Contoh penggunaan:
import time
sekarang = time.time()
print("Timestamp saat ini:", sekarang)

Hasilnya dapat berupa angka seperti berikut:
Timestamp saat ini: 1793361600.123456

Nilai tersebut hanya contoh. Hasil sebenarnya bergantung pada waktu ketika program dijalankan dan pengaturan sistem yang digunakan.

Angka timestamp dapat dimanfaatkan untuk mencatat waktu suatu aktivitas. Misalnya, aplikasi pencatatan kehadiran dapat menyimpan waktu ketika pengguna menekan tombol masuk. Data tersebut kemudian dapat digunakan untuk menghitung selisih antara waktu kedatangan dan waktu pulang.

Contoh lain adalah mengukur durasi pelaksanaan suatu proses dengan mengambil timestamp sebelum dan sesudah proses berjalan:
import time
mulai = time.time()
for angka in range(1000000):
hasil = angka * 2
selesai = time.time()
durasi = selesai - mulai
print("Durasi proses:", durasi, "detik")

Pada contoh tersebut, selisih antara waktu selesai dan waktu mulai digunakan untuk memperkirakan durasi proses. Namun, `time.time()` mengikuti jam sistem yang dapat mengalami penyesuaian. Untuk pengukuran durasi yang lebih andal, fungsi `time.perf_counter()` atau `time.monotonic()` dapat menjadi pilihan yang lebih tepat.

Mengubah Timestamp Menjadi Teks dengan `time.ctime()`

Timestamp dalam bentuk angka tidak selalu praktis untuk dibaca. Fungsi `time.ctime()` membantu mengubah nilai tersebut menjadi teks yang menunjukkan waktu lokal.

Contoh:
import time
timestamp = 1793361600
waktu_lokal = time.ctime(timestamp)
print("Waktu lokal:", waktu_lokal)

Hasilnya berupa teks yang memuat nama hari, bulan, tanggal, jam, menit, detik, dan tahun. Bentuk hasil dapat mengikuti pengaturan waktu lokal pada komputer.

Fungsi ini juga dapat dipanggil tanpa memberikan argumen. Jika tidak ada nilai timestamp yang dimasukkan, fungsi akan menggunakan waktu saat ini.
import time
print(time.ctime())

Penggunaan `ctime()` sesuai untuk kebutuhan sederhana ketika program hanya memerlukan tampilan waktu yang mudah dibaca. Akan tetapi, format hasilnya relatif tetap dan tidak memberikan keleluasaan pengaturan tampilan seperti fungsi `strftime()`.

Memberikan Jeda Program dengan `time.sleep()`

Fungsi `time.sleep()` digunakan untuk menghentikan sementara pelaksanaan utas program selama durasi tertentu. Durasi tersebut dinyatakan dalam satuan detik dan dapat berupa bilangan bulat maupun pecahan.

Contoh:
import time
print("Proses dimulai")
time.sleep(3)
print("Proses dilanjutkan")

Program akan menampilkan pesan pertama, kemudian menunggu sekitar tiga detik sebelum menampilkan pesan berikutnya. Jeda dapat dibuat lebih singkat, misalnya `time.sleep(0.5)` untuk menunggu setengah detik.

Fungsi ini dapat digunakan dalam berbagai kebutuhan. Pada aplikasi sederhana, jeda dapat memberikan waktu bagi pengguna untuk membaca pesan sebelum tampilan berikutnya muncul. Dalam simulasi, jeda membantu menggambarkan proses yang berlangsung secara bertahap. Pada sistem pemantauan, jeda dapat mengatur interval pemeriksaan data.

Meskipun demikian, `sleep()` bukan alat untuk menjamin ketepatan waktu secara mutlak. Sistem operasi dapat membuat jeda aktual sedikit lebih lama daripada durasi yang diminta karena pengaturan penjadwalan proses. Selain itu, fungsi ini menghentikan sementara utas yang sedang menjalankannya. Jika digunakan dalam program yang harus tetap responsif, penerapannya perlu dipertimbangkan dengan cermat.

Mengambil Waktu Lokal dengan `time.localtime()`

Fungsi `time.localtime()` mengubah timestamp menjadi objek `struct_time` berdasarkan pengaturan waktu lokal sistem. Jika tidak diberikan argumen, fungsi ini menggunakan waktu saat ini.

Contoh:
import time
data_waktu = time.localtime()
print(data_waktu)
print("Tahun:", data_waktu.tm_year)
print("Bulan:", data_waktu.tm_mon)
print("Tanggal:", data_waktu.tm_mday)
print("Jam:", data_waktu.tm_hour)

Objek `struct_time` memiliki sejumlah atribut yang dapat diakses secara terpisah. Misalnya, `tm_year` menyimpan informasi tahun, `tm_mon` menyimpan bulan, dan `tm_mday` menyimpan tanggal dalam bulan.

Struktur tersebut memudahkan program ketika hanya membutuhkan bagian tertentu dari informasi waktu. Aplikasi pengingat, misalnya, dapat memeriksa nilai jam untuk menentukan apakah suatu kegiatan sudah memasuki waktu pelaksanaan.

Berikut atribut utama dalam `struct_time`:

Atribut	Keterangan
tm_year	Tahun dalam empat digit.
tm_mon	Bulan, mulai dari 1 sampai 12.
tm_mday	Tanggal dalam bulan, mulai dari 1 sampai 31.
tm_hour	Jam, mulai dari 0 sampai 23.
tm_min	Menit, mulai dari 0 sampai 59.
tm_sec	Detik.
tm_wday	Hari dalam minggu, Senin bernilai 0.
tm_yday	Hari keberapa dalam tahun, mulai dari 1.
tm_isdst	Informasi mengenai penerapan waktu musim panas.

Atribut-atribut tersebut memberikan cara yang teratur untuk mengakses komponen waktu tanpa harus memisahkan teks secara manual.

Mengambil Waktu Universal dengan `time.gmtime()`

Fungsi `time.gmtime()` memiliki tujuan yang hampir sama dengan `localtime()`, yaitu mengubah timestamp menjadi objek `struct_time`. Perbedaannya terletak pada acuan zona waktu. `gmtime()` menghasilkan informasi berdasarkan UTC, bukan pengaturan waktu lokal komputer.

Contoh:
import time
waktu_utc = time.gmtime()
print("Tahun:", waktu_utc.tm_year)
print("Bulan:", waktu_utc.tm_mon)
print("Tanggal:", waktu_utc.tm_mday)
print("Jam:", waktu_utc.tm_hour)

UTC merupakan acuan waktu universal yang digunakan dalam pertukaran data lintas wilayah. Penggunaan acuan yang sama membantu mengurangi kekeliruan ketika aplikasi melibatkan pengguna atau peladen dari zona waktu berbeda.

Perbedaan kedua fungsi dapat dilihat pada tabel berikut:

Aspek	localtime()	gmtime()
Fungsi utama	Mengambil waktu berdasarkan zona lokal.	Mengambil waktu berdasarkan UTC.
Data masukan	Timestamp atau tanpa argumen.	Timestamp atau tanpa argumen.
Hasil	Objek struct_time.	Objek struct_time.
Acuan waktu	Pengaturan zona waktu sistem.	Waktu universal UTC.
Kegunaan	Menampilkan waktu bagi pengguna lokal.	Mengolah waktu untuk pertukaran data lintas wilayah.

Kedua fungsi tersebut penting dalam aplikasi yang mengelola jadwal. Pengembang perlu memastikan bahwa waktu yang disimpan, ditampilkan, dan dibandingkan menggunakan acuan yang konsisten.

Mengubah Waktu Lokal Menjadi Timestamp dengan `time.mktime()`

Jika `localtime()` mengubah timestamp menjadi struktur waktu lokal, `mktime()` melakukan proses sebaliknya. Fungsi ini menerima objek `struct_time` atau urutan data yang sesuai, kemudian mengembalikan jumlah detik sejak epoch berdasarkan waktu lokal.

Contoh:
import time
data_waktu = (2026, 10, 30, 19, 0, 0, 4, 303, -1)
timestamp = time.mktime(data_waktu)
print("Timestamp:", timestamp)

Urutan data tersebut memuat tahun, bulan, tanggal, jam, menit, detik, hari dalam minggu, hari dalam tahun, dan informasi waktu musim panas. Beberapa nilai dapat disesuaikan dengan kalender yang benar. Nilai `-1` pada bagian terakhir memungkinkan sistem menentukan status waktu musim panas secara otomatis jika relevan.

Perlu diperhatikan bahwa `mktime()` menggunakan interpretasi waktu lokal. Karena itu, hasilnya dapat berbeda jika program dijalankan pada komputer dengan zona waktu berbeda. Fungsi ini bukan pilihan yang tepat untuk mengubah waktu UTC secara langsung. Untuk kebutuhan tersebut, pendekatan konversi perlu memperhatikan zona waktu secara eksplisit.

Mengubah Struktur Waktu Menjadi Teks dengan `time.asctime()`

Fungsi `time.asctime()` digunakan untuk mengubah objek `struct_time` menjadi teks yang dapat dibaca. Fungsi ini berguna ketika informasi waktu telah tersedia dalam bentuk struktur dan perlu ditampilkan sebagai satu rangkaian kalimat.

Contoh:
import time
data_waktu = time.localtime()
hasil = time.asctime(data_waktu)
print("Waktu:", hasil)

Selain menerima objek `struct_time`, fungsi tersebut dapat dipanggil tanpa argumen untuk menggunakan waktu lokal saat ini. Hasilnya menampilkan informasi hari, bulan, tanggal, jam, menit, detik, dan tahun.

Perbedaan `asctime()` dan `ctime()` terletak pada bentuk data masukan. `asctime()` menerima struktur waktu, sedangkan `ctime()` menerima timestamp. Keduanya menghasilkan teks dengan susunan tampilan yang serupa.

Mengatur Format Waktu dengan `time.strftime()`

Fungsi `time.strftime()` digunakan untuk mengubah data waktu menjadi teks berdasarkan kode format yang ditentukan. Fungsi ini memberikan keleluasaan dalam menyusun tampilan tanggal dan waktu sesuai kebutuhan aplikasi.

Contoh:
import time
data_waktu = time.localtime()
teks_waktu = time.strftime(
"%d-%m-%Y %H:%M:%S",
data_waktu
)
print(teks_waktu)

Kode format tersebut menghasilkan tanggal, bulan, tahun, jam, menit, dan detik. Susunan tampilannya dapat diubah dengan mengganti kode format.

Beberapa kode yang sering digunakan adalah sebagai berikut:

Kode	Makna	Contoh
%d	Tanggal dalam bulan dengan dua digit.	30
%m	Bulan dalam bentuk angka.	10
%Y	Tahun dengan empat digit.	2026
%H	Jam dalam format 24 jam.	19
%M	Menit dengan dua digit.	00
%S	Detik dengan dua digit.	00
%A	Nama lengkap hari.	Friday
%B	Nama lengkap bulan.	October
%y	Tahun dengan dua digit terakhir.	26
%I	Jam dalam format 12 jam.	07
%p	Penanda waktu sebelum atau sesudah tengah hari.	PM

Sebagai contoh, format `"%A, %d %B %Y"` dapat menghasilkan tampilan seperti `Friday, 30 October 2026`. Sementara itu, format `"%H:%M:%S"` hanya menampilkan jam, menit, dan detik.

Fungsi ini sering digunakan untuk membuat catatan aktivitas, laporan, nama berkas berdasarkan tanggal, serta tampilan jadwal. Pengembang dapat menyesuaikan susunan informasi agar mudah dibaca dan sesuai dengan kebiasaan pengguna.

Mengubah Teks Menjadi Struktur Waktu dengan `time.strptime()`

Kebalikan dari `strftime()` adalah `strptime()`. Fungsi `time.strptime()` digunakan untuk membaca teks yang berisi informasi tanggal atau waktu, kemudian mengubahnya menjadi objek `struct_time`.

Contoh:
import time
teks_waktu = "30 October, 2026"
hasil = time.strptime(
teks_waktu,
"%d %B, %Y"
)
print(hasil)
print("Tahun:", hasil.tm_year)
print("Bulan:", hasil.tm_mon)
print("Tanggal:", hasil.tm_mday)

Argumen pertama merupakan teks yang akan dibaca, sedangkan argumen kedua merupakan pola format yang menjelaskan susunan informasinya. Kode `%d` menunjukkan tanggal, `%B` menunjukkan nama bulan lengkap, dan `%Y` menunjukkan tahun empat digit.

Jika teks tidak sesuai dengan pola yang diberikan, Python dapat menghasilkan kesalahan `ValueError`. Oleh karena itu, format masukan perlu diperiksa sebelum diproses. Pada aplikasi yang menerima data dari pengguna, penanganan kesalahan dapat dilakukan menggunakan `try` dan `except`.
import time
teks = "30-10-2026"
try:
  hasil = time.strptime(teks, "%d-%m-%Y")
  print("Data berhasil dibaca:", hasil)
except ValueError:
  print("Format tanggal tidak sesuai.")

Pendekatan tersebut membantu program tetap berjalan ketika menerima masukan dengan format yang tidak sesuai.

Perbedaan Fungsi-Fungsi Utama dalam Modul `time`

Setiap fungsi dalam modul `time` memiliki tugas khusus. Memahami perbedaannya membantu pengembang menentukan fungsi yang paling sesuai dengan kebutuhan program.

Fungsi	Kegunaan	Jenis hasil
time.time()	Mengambil waktu saat ini sebagai timestamp.	float
time.ctime()	Mengubah timestamp menjadi teks waktu lokal.	str
time.sleep()	Memberikan jeda pada pelaksanaan utas.	None
time.localtime()	Mengubah timestamp menjadi struktur waktu lokal.	struct_time
time.gmtime()	Mengubah timestamp menjadi struktur waktu UTC.	struct_time
time.mktime()	Mengubah struktur waktu lokal menjadi timestamp.	float
time.asctime()	Mengubah struktur waktu menjadi teks.	str
time.strftime()	Memformat struktur waktu menjadi teks.	str
time.strptime()	Membaca teks waktu menjadi struktur waktu.	struct_time

Tabel tersebut menunjukkan bahwa modul `time` menyediakan fungsi untuk berbagai arah pengolahan. Timestamp dapat diubah menjadi struktur atau teks, sedangkan struktur waktu dapat dikonversi kembali menjadi angka maupun tampilan yang mudah dibaca.

Penerapan Modul `time` dalam Program Sederhana

Penggunaan modul `time` dapat diterapkan dalam program yang menggabungkan beberapa fungsi sekaligus. Salah satu contohnya adalah pencatatan waktu ketika sebuah aktivitas dimulai dan selesai.
import time
print("Aplikasi pencatatan aktivitas")
waktu_mulai = time.time()
print("Aktivitas dimulai pada:")
print(time.ctime(waktu_mulai))
time.sleep(2)
waktu_selesai = time.time()
print("Aktivitas selesai pada:")
print(time.ctime(waktu_selesai))
durasi = waktu_selesai - waktu_mulai
print("Durasi aktivitas:", durasi, "detik")

Program tersebut mengambil timestamp ketika aktivitas dimulai, memberikan jeda dua detik, kemudian mengambil timestamp ketika aktivitas selesai. Selisih kedua nilai digunakan untuk memperkirakan durasi aktivitas.

Contoh tersebut memperlihatkan bahwa satu modul dapat digunakan untuk beberapa kebutuhan sekaligus. Fungsi `time()` mengambil waktu numerik, `ctime()` menyajikan waktu dalam bentuk teks, sedangkan pengurangan timestamp digunakan untuk memperoleh durasi.

Dalam pengembangan aplikasi yang lebih kompleks, pendekatan serupa dapat diterapkan untuk mencatat waktu akses pengguna, memantau proses otomatis, mengatur interval pemeriksaan data, atau menyusun riwayat kegiatan.

Hal yang Perlu Diperhatikan Saat Menggunakan Modul `time`

• Penggunaan modul `time` perlu memperhatikan beberapa hal agar hasil pengolahan waktu tetap akurat. Pertama, timestamp dan waktu lokal tidak boleh dianggap sebagai bentuk data yang sama. Timestamp merupakan angka berdasarkan epoch, sedangkan waktu lokal merupakan hasil penyesuaian terhadap zona waktu sistem.
• Kedua, fungsi `localtime()` dan `mktime()` bergantung pada pengaturan waktu lokal. Program yang dijalankan pada komputer dengan zona waktu berbeda dapat menghasilkan interpretasi yang berbeda. Jika data waktu akan dipertukarkan antarpeladen atau antarnegara, penggunaan UTC dapat membantu menjaga konsistensi.
• Ketiga, `sleep()` hanya memberikan jeda pelaksanaan dan bukan alat pengatur jadwal yang menjamin ketepatan hingga satuan waktu tertentu. Durasi aktual dapat dipengaruhi oleh kondisi sistem operasi dan aktivitas proses lainnya.
• Keempat, format waktu pada `strftime()` dan `strptime()` harus disesuaikan. Kesalahan penempatan kode format dapat menyebabkan hasil tampilan tidak sesuai atau proses pembacaan teks gagal. Pemeriksaan masukan menjadi bagian penting dalam pengembangan aplikasi.
• Terakhir, pemilihan fungsi harus mempertimbangkan tujuan program. Untuk mengukur durasi, gunakan alat pengukur waktu yang sesuai. Untuk menyimpan waktu kejadian, pertimbangkan penggunaan timestamp atau waktu dengan zona yang jelas. Untuk menampilkan tanggal kepada pengguna, gunakan format yang mudah dipahami.

Kesimpulan

Modul `time` merupakan bagian penting dari Python karena menyediakan fungsi untuk memperoleh, mengubah, menampilkan, dan mengendalikan informasi waktu. Fungsi `time()` menghasilkan timestamp, `ctime()` dan `asctime()` menyajikan waktu dalam bentuk teks, sedangkan `localtime()` dan `gmtime()` mengubah timestamp menjadi struktur waktu berdasarkan acuan lokal atau UTC.

Selain itu, `mktime()` membantu mengubah struktur waktu lokal menjadi timestamp. Fungsi `strftime()` dan `strptime()` memungkinkan pengembang mengatur format tampilan serta membaca teks waktu menjadi data terstruktur. Sementara itu, `sleep()` memberikan jeda pada pelaksanaan program sesuai durasi yang ditentukan.

Penguasaan fungsi-fungsi tersebut menjadi dasar untuk membangun aplikasi yang membutuhkan pencatatan waktu, pengaturan proses, pemantauan aktivitas, dan pengolahan jadwal. Dengan memahami perbedaan setiap fungsi serta memperhatikan zona waktu dan format data, pengembang dapat memanfaatkan modul `time` secara lebih tepat, terarah, dan efisien.

Artikel ini akan dibaca oleh: Kevin Ferdi Wahyudi, Kholilatur Rahmah, Komara Pujiati, Labib Wrakamurti, dan Lily Alifa Hadiyanti.

Location: Semarang, Kota Semarang, Jawa Tengah, Indonesia

Berbagi :