Python Date and Time Manipulation

July 30, 2024

berbagai fungsi dan metode dalam Python untuk memanipulasi data tanggal dan waktu, beserta contoh implementasi praktisnya. Mari kita bahas satu per satu:

Mengekstrak dan memanipulasi komponen tanggal, bulan, tahun, jam, menit, detik dari objek datetime (Extracting and Manipulating Date and Time Components):

Python menyediakan modul datetime yang sangat berguna untuk manipulasi tanggal dan waktu.

python
from datetime import datetime

# Membuat objek datetime
now = datetime.now()

# Mengekstrak komponen
print(f"Tahun: {now.year}")
print(f"Bulan: {now.month}")
print(f"Tanggal: {now.day}")
print(f"Jam: {now.hour}")
print(f"Menit: {now.minute}")
print(f"Detik: {now.second}")

# Memanipulasi komponen
from dateutil.relativedelta import relativedelta

# Menambah 1 bulan
satu_bulan_kemudian = now + relativedelta(months=1)
print(f"Satu bulan kemudian: {satu_bulan_kemudian}")

Manipulating Components

python# Adding 5 days to the current date
new_date = now + timedelta(days=5)
print("New Date:", new_date)

# Subtracting 2 hours from the current time
new_time = now - timedelta(hours=2)
print("New Time:", new_time)

Implementasi praktis: Dalam aplikasi manajemen proyek, fungsi ini dapat digunakan untuk menghitung tenggat waktu proyek atau mengatur pengingat tugas.

Melakukan konversi format tanggal dan waktu (Converting Date and Time Formats):

python
from datetime import datetime

# Konversi string ke datetime (String to Datetime)
tanggal_str = "2024-07-30 15:30:00"
tanggal_obj = datetime.strptime(tanggal_str, "%Y-%m-%d %H:%M:%S")

# Konversi datetime ke string (Datetime to String)
tanggal_str_baru = tanggal_obj.strftime("%d %B %Y, %H:%M")
print(f"Tanggal terformat: {tanggal_str_baru}")

Implementasi praktis: Dalam aplikasi e-commerce, fungsi ini berguna untuk menampilkan tanggal transaksi dalam format yang mudah dibaca oleh pengguna.

Menghitung selisih waktu antara dua titik waktu (Calculating Time Differences):

python
from datetime import datetime, timedelta

tanggal_awal = datetime(2024, 7, 1)
tanggal_akhir = datetime(2024, 8, 15)

selisih = tanggal_akhir - tanggal_awal
print(f"Selisih hari: {selisih.days}")

# Menambah atau mengurangi waktu
seminggu_kemudian = tanggal_awal + timedelta(weeks=1)
print(f"Seminggu kemudian: {seminggu_kemudian}")

Implementasi praktis: Dalam aplikasi manajemen sumber daya manusia, fungsi ini dapat digunakan untuk menghitung masa kerja karyawan atau durasi kontrak.

Menangani zona waktu dan konversi antar zona waktu (Handling Time Zones):

python
from datetime import datetime
from zoneinfo import ZoneInfo

# Membuat datetime dengan zona waktu
jakarta_time = datetime.now(ZoneInfo("Asia/Jakarta"))
new_york_time = jakarta_time.astimezone(ZoneInfo("America/New_York"))

print(f"Waktu di Jakarta: {jakarta_time}")
print(f"Waktu di New York: {new_york_time}")

Using the pytz library to handle time zones:

python
import pytz
import datetime
from datetime import datetime, timedelta

utc = pytz.utc
eastern = pytz.timezone('US/Eastern')
pacific = pytz.timezone('US/Pacific')

utc_dt = datetime.now(utc)
print("UTC Time:", utc_dt)

eastern_dt = utc_dt.astimezone(eastern)
print("Eastern Time:", eastern_dt)

pacific_dt = utc_dt.astimezone(pacific)
print("Pacific Time:", pacific_dt)

Implementasi praktis: Dalam aplikasi jadwal penerbangan internasional, fungsi ini penting untuk menampilkan waktu keberangkatan dan kedatangan dalam zona waktu yang sesuai.

Menjadwalkan dan mengatur pengiriman email atau notifikasi berdasarkan waktu (Scheduling Emails or Notifications):

python
import schedule
import time
import smtplib

def kirim_email():
    # Kode untuk mengirim email
    print("Email terkirim!")

# Jadwalkan pengiriman email setiap hari pukul 09:00
schedule.every().day.at("09:00").do(kirim_email)

while True:
    schedule.run_pending()
    time.sleep(1)

Implementasi praktis: Dalam aplikasi newsletter, fungsi ini dapat digunakan untuk mengirim email secara otomatis pada waktu yang ditentukan.

Mencatat dan menganalisis log waktu aktivitas pengguna dalam aplikasi ( Logging User Activity):

python
from datetime import datetime

def catat_aktivitas(user_id, aktivitas):
    waktu = datetime.now()
    log_entry = f"{waktu} - User {user_id}: {aktivitas}"
    with open("user_activity.log", "a") as log_file:
        log_file.write(log_entry + "\n")

# Penggunaan
catat_aktivitas(1001, "Login")
catat_aktivitas(1001, "Melihat profil")
catat_aktivitas(1001, "Logout")

Implementasi praktis: Dalam aplikasi analitik web, fungsi ini dapat digunakan untuk melacak perilaku pengguna dan menganalisis pola penggunaan.

Menghitung durasi suatu proses atau transaksi (Measuring Process Duration):

python
from datetime import datetime

def hitung_durasi(func):
    def wrapper(*args, **kwargs):
        waktu_mulai = datetime.now()
        result = func(*args, **kwargs)
        waktu_selesai = datetime.now()
        durasi = waktu_selesai - waktu_mulai
        print(f"Fungsi {func.__name__} selesai dalam {durasi.total_seconds()} detik")
        return result
    return wrapper

@hitung_durasi
def proses_lama():
    # Simulasi proses yang memakan waktu
    import time
    time.sleep(2)

proses_lama()

Implementasi praktis: Dalam aplikasi pemrosesan data besar, fungsi ini dapat digunakan untuk mengukur kinerja dan mengoptimalkan proses.

Membuat kalender atau agenda digital (Creating a Digital Calendar or Agenda):

python
import calendar

def tampilkan_kalender(tahun, bulan):
    cal = calendar.month(tahun, bulan)
    print(cal)

# Menampilkan kalender bulan Juli 2024
tampilkan_kalender(2024, 7)

# Menambahkan acara ke agenda
agenda = {}

def tambah_acara(tanggal, acara):
    if tanggal in agenda:
        agenda[tanggal].append(acara)
    else:
        agenda[tanggal] = [acara]

tambah_acara("2024-07-15", "Rapat Tim")
tambah_acara("2024-07-20", "Presentasi Proyek")

print(agenda)

Implementasi praktis: Dalam aplikasi manajemen acara, fungsi ini dapat digunakan untuk membuat dan mengelola jadwal acara.

Aplikasi pemesanan tiket, reservasi hotel, atau penjadwalan perjalanan (Booking Systems (e.g., Tickets, Hotels)):

python
from datetime import datetime, timedelta

def pesan_tiket(tujuan, tanggal_berangkat):
    # Simulasi pemesanan tiket
    tanggal_obj = datetime.strptime(tanggal_berangkat, "%Y-%m-%d")
    tanggal_kembali = tanggal_obj + timedelta(days=7)
    
    print(f"Tiket ke {tujuan} berhasil dipesan.")
    print(f"Tanggal berangkat: {tanggal_obj.strftime('%d %B %Y')}")
    print(f"Tanggal kembali: {tanggal_kembali.strftime('%d %B %Y')}")

pesan_tiket("Bali", "2024-08-10")

Implementasi praktis: Dalam aplikasi agen perjalanan online, fungsi ini dapat digunakan untuk mengelola pemesanan tiket dan mengatur jadwal perjalanan.

Kesimpulan: Fungsi-fungsi manipulasi tanggal dan waktu dalam Python sangat versatil dan dapat diimplementasikan dalam berbagai industri dan aplikasi kehidupan sehari-hari. Dari manajemen proyek hingga e-commerce, dari aplikasi perjalanan hingga analitik data, kemampuan untuk mengelola dan memanipulasi data waktu dengan tepat sangat penting.

Penggunaan fungsi-fungsi ini memungkinkan pengembang untuk membuat aplikasi yang lebih pintar dan responsif terhadap waktu, meningkatkan pengalaman pengguna, dan mengoptimalkan proses bisnis. Dengan memahami dan menerapkan fungsi-fungsi ini dengan benar, pengembang dapat menciptakan solusi yang efektif untuk berbagai tantangan terkait waktu dalam pengembangan perangkat lunak.

Practical Implementations in Industry

Financial Services: Calculating interest over time, validating transaction timestamps.
Healthcare: Scheduling appointments, logging patient data.
Travel Industry: Booking flights, hotels, and rental cars with accurate date and time management.
E-commerce: Managing promotions, logging user activities, processing order times.
Education: Scheduling classes, exams, and managing academic calendars.
Software Development: Automated testing based on time, scheduling tasks and reminders.

Industri Jasa Keuangan:

a. Menghitung bunga majemuk:

python
from datetime import datetime, timedelta
from decimal import Decimal

def hitung_bunga_majemuk(principal, rate, time_in_years, compound_frequency):
    rate = Decimal(str(rate))
    principal = Decimal(str(principal))
    
    # Konversi frekuensi majemuk ke periode harian
    if compound_frequency == 'daily':
        n = 365
    elif compound_frequency == 'monthly':
        n = 12
    elif compound_frequency == 'quarterly':
        n = 4
    else:
        n = 1  # tahunan
    
    # Rumus bunga majemuk
    amount = principal * (1 + rate/n) ** (n * time_in_years)
    
    return amount.quantize(Decimal('0.01'))

# Contoh penggunaan
principal = 10000
rate = 0.05  # 5%
time = 5  # 5 tahun
frequency = 'monthly'

hasil = hitung_bunga_majemuk(principal, rate, time, frequency)
print(f"Jumlah setelah {time} tahun: ${hasil}")

b. Validasi timestamp transaksi (Validating Transaction Timestamps):

python
from datetime import datetime, timedelta
import pytz

def validasi_timestamp_transaksi(timestamp, max_delay_minutes=5):
    # Menggunakan UTC untuk konsistensi
    now = datetime.now(pytz.UTC)
    transaction_time = datetime.fromtimestamp(timestamp, pytz.UTC)
    
    # Memeriksa apakah transaksi terjadi di masa depan
    if transaction_time > now:
        return False, "Timestamp transaksi tidak valid: waktu di masa depan"
    
    # Memeriksa apakah transaksi terlalu lama
    if now - transaction_time > timedelta(minutes=max_delay_minutes):
        return False, f"Timestamp transaksi terlalu lama: lebih dari {max_delay_minutes} menit yang lalu"
    
    return True, "Timestamp transaksi valid"

# Contoh penggunaan
current_timestamp = datetime.now(pytz.UTC).timestamp()
valid, message = validasi_timestamp_transaksi(current_timestamp)
print(message)

# Simulasi transaksi lama
old_timestamp = (datetime.now(pytz.UTC) - timedelta(minutes=10)).timestamp()
valid, message = validasi_timestamp_transaksi(old_timestamp)
print(message)

Industri Kesehatan:

a. Menjadwalkan janji dan mengelola ketersediaan dokter:

Scheduling Appointments dokter tersedia
python
from datetime import datetime, timedelta

appointments = []

def schedule_appointment(patient_name, appointment_date):
    appointments.append((patient_name, appointment_date))
    print(f"Appointment scheduled for {patient_name} on {appointment_date}")

# Example usage
patient_name = "John Doe"
appointment_date = datetime(2024, 7, 15, 10, 0)
schedule_appointment(patient_name, appointment_date)
Logging Patient Data
lanjutan code python
def log_patient_data(patient_name, action):
    with open("patient_log.txt", "a") as log_file:
        log_file.write(f"{datetime.now()}: {patient_name} - {action}\n")

# Example usage
log_patient_data("John Doe", "Checked in")
log_patient_data("Jane Smith", "Received medication")

python schedule kondisi dokter tidak tersedia
from datetime import datetime, timedelta

class Dokter:
    def __init__(self, nama):
        self.nama = nama
        self.jadwal = {}

    def tambah_ketersediaan(self, tanggal, jam_mulai, jam_selesai):
        if tanggal not in self.jadwal:
            self.jadwal[tanggal] = []
        self.jadwal[tanggal].append((jam_mulai, jam_selesai))

    def cek_ketersediaan(self, tanggal, jam):
        if tanggal in self.jadwal:
            for mulai, selesai in self.jadwal[tanggal]:
                if mulai <= jam < selesai:
                    return True
        return False

class SistemJanji:
    def __init__(self):
        self.dokter = {}
        self.janji = {}

    def tambah_dokter(self, dokter):
        self.dokter[dokter.nama] = dokter

    def buat_janji(self, nama_pasien, nama_dokter, tanggal, jam):
        dokter = self.dokter.get(nama_dokter)
        if not dokter:
            return "Dokter tidak ditemukan"

        if not dokter.cek_ketersediaan(tanggal, jam):
            return "Dokter tidak tersedia pada waktu tersebut"

        if tanggal not in self.janji:
            self.janji[tanggal] = []
        self.janji[tanggal].append((nama_pasien, nama_dokter, jam))
        return "Janji berhasil dibuat"

# Contoh penggunaan
sistem = SistemJanji()

dr_anna = Dokter("Dr. Anna")
dr_anna.tambah_ketersediaan("2024-08-01", datetime(2024, 8, 1, 9), datetime(2024, 8, 1, 17))
sistem.tambah_dokter(dr_anna)

hasil = sistem.buat_janji("Budi", "Dr. Anna", "2024-08-01", datetime(2024, 8, 1, 10))
print(hasil)

hasil = sistem.buat_janji("Citra", "Dr. Anna", "2024-08-01", datetime(2024, 8, 1, 18))
print(hasil)

Industri Perjalanan (Travel Industry: Booking Flights, Hotels, and Rental Cars):

Booking a Flight
contoh 1 python
from datetime import datetime

def book_flight(flight_number, departure, arrival):
    print(f"Booking flight {flight_number} from {departure} to {arrival}")

# Example usage
flight_number = "AB123"
departure = datetime(2024, 7, 20, 14, 0)
arrival = datetime(2024, 7, 20, 16, 30)
book_flight(flight_number, departure, arrival)
Booking a Hotel Room
contoh 2 python
from datetime import datetime
def book_hotel(room_number, check_in, check_out):
    print(f"Booking room {room_number} from {check_in} to {check_out}")

# Example usage
room_number = 101
check_in = datetime(2024, 7, 20, 15, 0)
check_out = datetime(2024, 7, 25, 11, 0)
book_hotel(room_number, check_in, check_out)
Sistem pemesanan tiket pesawat dengan manajemen zona waktu
contoh 3 python
from datetime import datetime, timedelta
from zoneinfo import ZoneInfo

class PenerbanganInternasional:
    def __init__(self, nomor, asal, tujuan, waktu_berangkat, durasi):
        self.nomor = nomor
        self.asal = asal
        self.tujuan = tujuan
        self.waktu_berangkat = waktu_berangkat
        self.durasi = durasi

    def hitung_waktu_kedatangan(self):
        zona_asal = ZoneInfo(self.asal['zona_waktu'])
        zona_tujuan = ZoneInfo(self.tujuan['zona_waktu'])
        
        waktu_berangkat_lokal = self.waktu_berangkat.replace(tzinfo=zona_asal)
        waktu_tiba = waktu_berangkat_lokal + self.durasi
        waktu_tiba_lokal = waktu_tiba.astimezone(zona_tujuan)
        
        return waktu_tiba_lokal

    def tampilkan_info(self):
        waktu_tiba = self.hitung_waktu_kedatangan()
        print(f"Penerbangan {self.nomor}")
        print(f"Dari: {self.asal['kota']} ({self.asal['zona_waktu']})")
        print(f"Ke: {self.tujuan['kota']} ({self.tujuan['zona_waktu']})")
        print(f"Berangkat: {self.waktu_berangkat.strftime('%Y-%m-%d %H:%M')} {self.asal['zona_waktu']}")
        print(f"Tiba: {waktu_tiba.strftime('%Y-%m-%d %H:%M')} {self.tujuan['zona_waktu']}")

# Contoh penggunaan
jakarta = {'kota': 'Jakarta', 'zona_waktu': 'Asia/Jakarta'}
new_york = {'kota': 'New York', 'zona_waktu': 'America/New_York'}

penerbangan = PenerbanganInternasional(
    'GA-123',
    jakarta,
    new_york,
    datetime(2024, 8, 1, 22, 0),  # 22:00 WIB
    timedelta(hours=20)
)

penerbangan.tampilkan_info()

E-commerce:

a. Sistem manajemen promosi dengan batasan waktu:

python promosi false
from datetime import datetime, timedelta

#Managing Promotions
def is_promotion_active(start_date, end_date):
    now = datetime.now()
    return start_date <= now <= end_date

# Example usage
start_date = datetime(2024, 7, 1)
end_date = datetime(2024, 7, 10)
print(f"Is the promotion active? {is_promotion_active(start_date, end_date)}")

#Logging User Activities
def log_user_activity(user_id, activity):
    with open("user_activity_log.txt", "a") as log_file:
        log_file.write(f"{datetime.now()}: User {user_id} - {activity}\n")

# Example usage
log_user_activity(123, "Added item to cart")
log_user_activity(456, "Checked out")

#Processing Order Times
def process_order(order_id, order_time):
    print(f"Processing order {order_id} placed at {order_time}")

# Example usage
order_id = 789
order_time = datetime(2024, 7, 3, 14, 30)
process_order(order_id, order_time)


python promosi berlaku
from datetime import datetime, timedelta

class SistemPromosi:
    def __init__(self):
        self.promosi_aktif = {}

    def tambah_promosi(self, kode, diskon, mulai, selesai):
        self.promosi_aktif[kode] = {
            'diskon': diskon,
            'mulai': mulai,
            'selesai': selesai
        }

    def cek_promosi(self, kode, waktu=None):
        if waktu is None:
            waktu = datetime.now()

        if kode not in self.promosi_aktif:
            return None, "Kode promosi tidak valid"

        promosi = self.promosi_aktif[kode]
        if promosi['mulai'] <= waktu <= promosi['selesai']:
            return promosi['diskon'], "Promosi berlaku"
        elif waktu < promosi['mulai']:
            return None, "Promosi belum dimulai"
        else:
            return None, "Promosi sudah berakhir"

    def bersihkan_promosi_kedaluwarsa(self):
        sekarang = datetime.now()
        kode_kedaluwarsa = [kode for kode, promosi in self.promosi_aktif.items() if promosi['selesai'] < sekarang]
        for kode in kode_kedaluwarsa:
            del self.promosi_aktif[kode]
        return len(kode_kedaluwarsa)

# Contoh penggunaan
sistem_promosi = SistemPromosi()

# Menambahkan promosi
sistem_promosi.tambah_promosi(
    'SUMMER2024',
    0.2,  # 20% diskon
    datetime(2024, 6, 1),
    datetime(2024, 8, 31)
)

# Memeriksa promosi
diskon, pesan = sistem_promosi.cek_promosi('SUMMER2024', datetime(2024, 7, 15))
print(f"Diskon: {diskon*100 if diskon else 0}%, Pesan: {pesan}")

# Membersihkan promosi kedaluwarsa
jumlah_dihapus = sistem_promosi.bersihkan_promosi_kedaluwarsa()
print(f"Jumlah promosi yang dihapus: {jumlah_dihapus}")

Pendidikan:

a. Sistem manajemen jadwal akademik:

python Scheduling Classes dan Scheduling Exams
from datetime import datetime, timedelta
#Scheduling Classes
class Schedule:
    def __init__(self):
        self.classes = []

    def add_class(self, course_name, start_time, end_time):
        self.classes.append((course_name, start_time, end_time))
        print(f"Class {course_name} scheduled from {start_time} to {end_time}")

# Example usage
schedule = Schedule()
schedule.add_class("Math 101", datetime(2024, 7, 3, 9, 0), datetime(2024, 7, 3, 10, 30))
schedule.add_class("Physics 101", datetime(2024, 7, 3, 11, 0), datetime(2024, 7, 3, 12, 30))

#Scheduling Exams
class ExamSchedule:
    def __init__(self):
        self.exams = []

    def schedule_exam(self, course_name, exam_date):
        self.exams.append((course_name, exam_date))
        print(f"Exam for {course_name} scheduled on {exam_date}")

# Example usage
exam_schedule = ExamSchedule()
exam_schedule.schedule_exam("Math 101", datetime(2024, 7, 10, 9, 0))
exam_schedule.schedule_exam("Physics 101", datetime(2024, 7, 15, 11, 0))


python kalender akademik
from datetime import datetime, timedelta

class KalenderAkademik:
    def __init__(self, tahun_ajaran):
        self.tahun_ajaran = tahun_ajaran
        self.acara = {}
        self.libur = set()

    def tambah_acara(self, nama, tanggal_mulai, tanggal_selesai=None):
        if tanggal_selesai is None:
            tanggal_selesai = tanggal_mulai
        self.acara[nama] = (tanggal_mulai, tanggal_selesai)

    def tambah_libur(self, tanggal):
        self.libur.add(tanggal)

    def cek_jadwal(self, tanggal):
        if tanggal in self.libur:
            return "Libur"
        
        acara_hari_ini = []
        for nama, (mulai, selesai) in self.acara.items():
            if mulai <= tanggal <= selesai:
                acara_hari_ini.append(nama)
        
        return acara_hari_ini if acara_hari_ini else "Tidak ada acara khusus"

    def tampilkan_jadwal_minggu(self, tanggal):
        awal_minggu = tanggal - timedelta(days=tanggal.weekday())
        for i in range(7):
            hari = awal_minggu + timedelta(days=i)
            jadwal = self.cek_jadwal(hari)
            print(f"{hari.strftime('%Y-%m-%d')}: {jadwal}")

# Contoh penggunaan
kalender = KalenderAkademik("2024-2025")

# Menambahkan acara
kalender.tambah_acara("Orientasi Mahasiswa Baru", datetime(2024, 8, 15), datetime(2024, 8, 17))
kalender.tambah_acara("Ujian Tengah Semester", datetime(2024, 10, 10), datetime(2024, 10, 15))

# Menambahkan libur
kalender.tambah_libur(datetime(2024, 8, 17))  # Hari Kemerdekaan

# Memeriksa jadwal untuk satu minggu
kalender.tampilkan_jadwal_minggu(datetime(2024, 8, 15))

Pengembangan Perangkat Lunak:

a. Sistem otomatisasi pengujian berbasis waktu:

python Automated Testing :
import unittest
from datetime import datetime, timedelta

class TestDateCalculations(unittest.TestCase):
    def test_future_date(self):
        now = datetime.now()
        future_date = now + timedelta(days=5)
        self.assertEqual((future_date - now).days, 5)

if __name__ == '__main__':
    unittest.main()


python Automated Testing :

python
import unittest
from datetime import datetime, timedelta
from freezegun import freeze_time

class UserAccount:
    def __init__(self, username, created_at):
        self.username = username
        self.created_at = created_at

    def is_premium(self):
        # Akun dianggap premium jika usianya lebih dari 30 hari
        return (datetime.now() - self.created_at) > timedelta(days=30)

class TestUserAccount(unittest.TestCase):
    def setUp(self):
        self.base_date = datetime(2024, 1, 1)
        self.user = UserAccount("testuser", self.base_date)

    @freeze_time("2024-01-15")
    def test_new_account_not_premium(self):
        self.assertFalse(self.user.is_premium())

    @freeze_time("2024-02-01")
    def test_old_account_is_premium(self):
        self.assertTrue(self.user.is_premium())

if __name__ == '__main__':
    unittest.main()

Contoh-contoh di atas menunjukkan bagaimana manipulasi tanggal dan waktu dalam Python dapat digunakan untuk menyelesaikan masalah kompleks di berbagai industri. Beberapa poin penting:

Penggunaan datetime, timedelta, dan zoneinfo untuk menangani perhitungan waktu dan zona waktu.
Implementasi logika bisnis yang melibatkan waktu, seperti perhitungan bunga, validasi transaksi, dan manajemen promosi.
Penggunaan waktu dalam sistem penjadwalan dan pemesanan.
Penerapan waktu dalam pengujian otomatis menggunakan freezegun untuk mensimulasikan perjalanan waktu.

Implementasi ini menunjukkan fleksibilitas dan kekuatan Python dalam menangani operasi yang berkaitan dengan waktu di berbagai domain aplikasi. Penting untuk selalu mempertimbangkan zona waktu, terutama dalam aplikasi yang beroperasi secara global, dan menggunakan library yang tepat untuk memastikan akurasi dalam perhitungan waktu.

contoh kompleks untuk implementasi Python date & time dalam inventory warehouse, production manufacturing, dan tracking logistic.

Inventory Warehouse:

python Checking Stock Levels and Expiration Dates & Reordering Stock

from datetime import datetime, timedelta
#Checking Stock Levels and Expiration Dates
class InventoryItem:
    def __init__(self, item_name, quantity, expiration_date):
        self.item_name = item_name
        self.quantity = quantity
        self.expiration_date = expiration_date

    def is_expired(self):
        return datetime.now() > self.expiration_date

    def __str__(self):
        return f"{self.item_name} (Quantity: {self.quantity}, Expiration: {self.expiration_date})"

inventory = [
    InventoryItem("Apples", 100, datetime(2024, 8, 1)),
    InventoryItem("Bananas", 150, datetime(2024, 7, 15)),
    InventoryItem("Carrots", 200, datetime(2024, 7, 10))
]

# Check and list expired items
expired_items = [item for item in inventory if item.is_expired()]
for item in expired_items:
    print(f"Expired: {item}")

#Reordering Stock
def reorder_item(item):
    print(f"Reordering {item.item_name}...")

# Example usage
low_stock_threshold = 50
for item in inventory:
    if item.quantity < low_stock_threshold:
        reorder_item(item)

Sistem manajemen inventaris gudang dengan fitur peramalan stok, pencatatan kadaluarsa, dan optimasi penempatan barang.

python
from datetime import datetime, timedelta
import random

class Produk:
    def __init__(self, id, nama, kadaluarsa, lokasi):
        self.id = id
        self.nama = nama
        self.kadaluarsa = kadaluarsa
        self.lokasi = lokasi

class Gudang:
    def __init__(self):
        self.inventaris = {}
        self.history_penjualan = {}

    def tambah_produk(self, produk, jumlah):
        if produk.id not in self.inventaris:
            self.inventaris[produk.id] = []
        self.inventaris[produk.id].extend([produk] * jumlah)

    def cek_kadaluarsa(self):
        sekarang = datetime.now()
        kadaluarsa = []
        for id_produk, produk_list in self.inventaris.items():
            kadaluarsa.extend([p for p in produk_list if p.kadaluarsa < sekarang])
            self.inventaris[id_produk] = [p for p in produk_list if p.kadaluarsa >= sekarang]
        return kadaluarsa

    def catat_penjualan(self, id_produk, jumlah, tanggal):
        if id_produk not in self.history_penjualan:
            self.history_penjualan[id_produk] = []
        self.history_penjualan[id_produk].append((tanggal, jumlah))

    def ramal_stok(self, id_produk, hari):
        if id_produk not in self.history_penjualan:
            return 0
        
        total_penjualan = sum(jumlah for _, jumlah in self.history_penjualan[id_produk])
        rata_rata_harian = total_penjualan / len(self.history_penjualan[id_produk])
        return int(rata_rata_harian * hari)

    def optimasi_penempatan(self):
        for id_produk, produk_list in self.inventaris.items():
            produk_list.sort(key=lambda x: x.kadaluarsa)  # Urutkan berdasarkan tanggal kadaluarsa
            for i, produk in enumerate(produk_list):
                produk.lokasi = f"RAK-{chr(65 + i // 10)}{i % 10 + 1}"  # Contoh: RAK-A1, RAK-A2, ...

# Contoh penggunaan
gudang = Gudang()

# Menambahkan produk
for i in range(100):
    kadaluarsa = datetime.now() + timedelta(days=random.randint(30, 365))
    produk = Produk(f"P{i}", f"Produk {i}", kadaluarsa, "")
    gudang.tambah_produk(produk, random.randint(1, 10))

# Mencatat penjualan historis
for _ in range(30):  # Simulasi 30 hari penjualan
    tanggal = datetime.now() - timedelta(days=random.randint(1, 30))
    gudang.catat_penjualan("P0", random.randint(1, 5), tanggal)

# Memeriksa kadaluarsa
kadaluarsa = gudang.cek_kadaluarsa()
print(f"Jumlah produk kadaluarsa: {len(kadaluarsa)}")

# Meramal stok
ramalan = gudang.ramal_stok("P0", 7)
print(f"Perkiraan penjualan Produk 0 dalam 7 hari: {ramalan}")

# Optimasi penempatan
gudang.optimasi_penempatan()
print(f"Lokasi Produk 0: {gudang.inventaris['P0'][0].lokasi}")

Production Manufacturing:

Scheduling Maintenance and Tracking Production Time

from datetime import datetime, timedelta
#Scheduling Maintenance
class Machine:
    def __init__(self, machine_id, last_maintenance_date):
        self.machine_id = machine_id
        self.last_maintenance_date = last_maintenance_date

    def schedule_maintenance(self, interval_days):
        next_maintenance_date = self.last_maintenance_date + timedelta(days=interval_days)
        print(f"Next maintenance for machine {self.machine_id} is scheduled on {next_maintenance_date}")
        return next_maintenance_date

# Example usage
machine = Machine("M123", datetime(2024, 6, 30))
maintenance_interval_days = 30
next_maintenance_date = machine.schedule_maintenance(maintenance_interval_days)

#Tracking Production Time
class ProductionOrder:
    def __init__(self, order_id, start_time, end_time=None):
        self.order_id = order_id
        self.start_time = start_time
        self.end_time = end_time

    def complete_order(self):
        self.end_time = datetime.now()
        print(f"Order {self.order_id} completed at {self.end_time}")

    def get_duration(self):
        if self.end_time:
            return self.end_time - self.start_time
        return datetime.now() - self.start_time

# Example usage
order = ProductionOrder("PO456", datetime(2024, 7, 3, 8, 0))
order.complete_order()
print(f"Order duration: {order.get_duration()}")

Sistem manajemen produksi dengan penjadwalan, pemantauan waktu produksi, dan analisis efisiensi.

python
from datetime import datetime, timedelta
import random

class Mesin:
    def __init__(self, id, nama):
        self.id = id
        self.nama = nama
        self.status = "idle"
        self.waktu_mulai = None
        self.waktu_selesai = None
        self.produk_current = None

class Produk:
    def __init__(self, id, nama, waktu_produksi):
        self.id = id
        self.nama = nama
        self.waktu_produksi = waktu_produksi

class SistemProduksi:
    def __init__(self):
        self.mesin = {}
        self.antrian_produksi = []
        self.riwayat_produksi = []

    def tambah_mesin(self, mesin):
        self.mesin[mesin.id] = mesin

    def tambah_produk_ke_antrian(self, produk):
        self.antrian_produksi.append(produk)

    def mulai_produksi(self, id_mesin, id_produk):
        if id_mesin not in self.mesin or self.mesin[id_mesin].status != "idle":
            return False
        
        produk = next((p for p in self.antrian_produksi if p.id == id_produk), None)
        if not produk:
            return False

        mesin = self.mesin[id_mesin]
        mesin.status = "bekerja"
        mesin.waktu_mulai = datetime.now()
        mesin.waktu_selesai = mesin.waktu_mulai + timedelta(minutes=produk.waktu_produksi)
        mesin.produk_current = produk
        self.antrian_produksi.remove(produk)
        return True

    def selesai_produksi(self, id_mesin):
        if id_mesin not in self.mesin or self.mesin[id_mesin].status != "bekerja":
            return False

        mesin = self.mesin[id_mesin]
        waktu_selesai_aktual = datetime.now()
        self.riwayat_produksi.append({
            "mesin": mesin.id,
            "produk": mesin.produk_current.id,
            "waktu_mulai": mesin.waktu_mulai,
            "waktu_selesai": waktu_selesai_aktual,
            "durasi": (waktu_selesai_aktual - mesin.waktu_mulai).total_seconds() / 60
        })
        mesin.status = "idle"
        mesin.produk_current = None
        return True

    def analisis_efisiensi(self):
        efisiensi = {}
        for riwayat in self.riwayat_produksi:
            id_mesin = riwayat["mesin"]
            if id_mesin not in efisiensi:
                efisiensi[id_mesin] = {"total_waktu": 0, "jumlah_produksi": 0}
            efisiensi[id_mesin]["total_waktu"] += riwayat["durasi"]
            efisiensi[id_mesin]["jumlah_produksi"] += 1

        for id_mesin, data in efisiensi.items():
            rata_rata = data["total_waktu"] / data["jumlah_produksi"]
            print(f"Mesin {id_mesin}: Rata-rata waktu produksi = {rata_rata:.2f} menit")

# Contoh penggunaan
sistem = SistemProduksi()

# Menambahkan mesin
for i in range(5):
    sistem.tambah_mesin(Mesin(f"M{i}", f"Mesin {i}"))

# Menambahkan produk ke antrian
for i in range(20):
    sistem.tambah_produk_ke_antrian(Produk(f"P{i}", f"Produk {i}", random.randint(30, 120)))

# Simulasi produksi
for _ in range(50):  # Simulasi 50 siklus produksi
    for id_mesin in sistem.mesin:
        if sistem.mesin[id_mesin].status == "idle" and sistem.antrian_produksi:
            sistem.mulai_produksi(id_mesin, sistem.antrian_produksi[0].id)
        elif sistem.mesin[id_mesin].status == "bekerja" and datetime.now() >= sistem.mesin[id_mesin].waktu_selesai:
            sistem.selesai_produksi(id_mesin)

# Analisis efisiensi
sistem.analisis_efisiensi()

Tracking Logistic:

Managing Shipments and Delivery Times

from datetime import datetime, timedelta
#Managing Shipments
class Shipment:
    def __init__(self, shipment_id, departure_time, arrival_time):
        self.shipment_id = shipment_id
        self.departure_time = departure_time
        self.arrival_time = arrival_time

    def get_transit_time(self):
        return self.arrival_time - self.departure_time

# Example usage
shipment = Shipment("S789", datetime(2024, 7, 2, 9, 0), datetime(2024, 7, 5, 18, 30))
print(f"Shipment transit time: {shipment.get_transit_time()}")

#Delivery Time Estimates
def estimate_delivery_time(departure, transit_days):
    estimated_arrival = departure + timedelta(days=transit_days)
    print(f"Estimated delivery time: {estimated_arrival}")
    return estimated_arrival

# Example usage
departure_time = datetime(2024, 7, 10, 14, 0)
transit_days = 5
estimated_delivery = estimate_delivery_time(departure_time, transit_days)

Sistem pelacakan logistik dengan estimasi waktu pengiriman, pemantauan rute, dan manajemen kejadian.

python
from datetime import datetime, timedelta
import random

class Paket:
    def __init__(self, id, asal, tujuan, waktu_kirim):
        self.id = id
        self.asal = asal
        self.tujuan = tujuan
        self.waktu_kirim = waktu_kirim
        self.status = "dikirim"
        self.lokasi_terakhir = asal
        self.riwayat = [(waktu_kirim, asal, "dikirim")]
        self.estimasi_tiba = waktu_kirim + timedelta(days=random.randint(1, 5))

class SistemLogistik:
    def __init__(self):
        self.paket = {}
        self.rute = {
            "Jakarta": ["Bandung", "Semarang"],
            "Bandung": ["Jakarta", "Surabaya"],
            "Semarang": ["Jakarta", "Surabaya"],
            "Surabaya": ["Bandung", "Semarang", "Denpasar"],
            "Denpasar": ["Surabaya"]
        }

    def kirim_paket(self, paket):
        self.paket[paket.id] = paket

    def update_status(self, id_paket, lokasi_baru, status_baru):
        if id_paket not in self.paket:
            return False
        
        paket = self.paket[id_paket]
        waktu_update = datetime.now()
        
        if lokasi_baru not in self.rute[paket.lokasi_terakhir]:
            return False

        paket.lokasi_terakhir = lokasi_baru
        paket.status = status_baru
        paket.riwayat.append((waktu_update, lokasi_baru, status_baru))

        # Update estimasi tiba
        if lokasi_baru == paket.tujuan:
            paket.estimasi_tiba = waktu_update
        else:
            sisa_rute = len(self.hitung_rute(lokasi_baru, paket.tujuan))
            paket.estimasi_tiba = waktu_update + timedelta(days=sisa_rute)

        return True

    def hitung_rute(self, asal, tujuan):
        def dfs(current, target, path, visited):
            if current == target:
                return path
            
            visited.add(current)
            for next_city in self.rute[current]:
                if next_city not in visited:
                    result = dfs(next_city, target, path + [next_city], visited.copy())
                    if result:
                        return result
            return None

        return dfs(asal, tujuan, [asal], set())

    def laporan_keterlambatan(self):
        sekarang = datetime.now()
        terlambat = []
        for id_paket, paket in self.paket.items():
            if paket.status != "diterima" and sekarang > paket.estimasi_tiba:
                terlambat.append((id_paket, (sekarang - paket.estimasi_tiba).days))
        return terlambat

# Contoh penggunaan
sistem = SistemLogistik()

# Mengirim paket
for i in range(20):
    asal = random.choice(list(sistem.rute.keys()))
    tujuan = random.choice([kota for kota in sistem.rute.keys() if kota != asal])
    paket = Paket(f"PKT{i}", asal, tujuan, datetime.now() - timedelta(days=random.randint(0, 3)))
    sistem.kirim_paket(paket)

# Simulasi pergerakan paket
for _ in range(50):  # Simulasi 50 pergerakan
    id_paket = random.choice(list(sistem.paket.keys()))
    paket = sistem.paket[id_paket]
    if paket.status != "diterima":
        rute = sistem.hitung_rute(paket.lokasi_terakhir, paket.tujuan)
        if rute and len(rute) > 1:
            sistem.update_status(id_paket, rute[1], "dalam perjalanan")
        elif rute and len(rute) == 1:
            sistem.update_status(id_paket, paket.tujuan, "diterima")

# Laporan keterlambatan
terlambat = sistem.laporan_keterlambatan()
print("Paket terlambat:")
for id_paket, hari_terlambat in terlambat:
    print(f"Paket {id_paket}: terlambat {hari_terlambat} hari")

# Tampilkan riwayat satu paket
id_paket_contoh = list(sistem.paket.keys())[0]
paket_contoh = sistem.paket[id_paket_contoh]
print(f"\nRiwayat Paket {id_paket_contoh}:")
for waktu, lokasi, status in paket_contoh.riwayat:
    print(f"{waktu}: {lokasi} - {status}")

Ketiga contoh di atas menunjukkan implementasi kompleks dari manipulasi tanggal dan waktu dalam Python untuk skenario industri yang spesifik:

Inventory Warehouse: Sistem ini mengelola stok, memprediksi kebutuhan di masa depan, dan mengoptimalkan penempatan barang berdasarkan tanggal kadaluarsa.
Production Manufacturing: Sistem ini menangani penjadwalan produksi, pemantauan waktu produksi real-time, dan analisis efisiensi mesin berdasarkan data historis.
Tracking Logistic: Sistem ini mengelola pengiriman paket, memperkirakan waktu tiba, melacak rute, dan mengidentifikasi keterlambatan.

Dalam setiap kasus, penggunaan datetime dan timedelta sangat penting untuk menghitung durasi, memprediksi waktu di masa depan, dan menganalisis data berbasis waktu. Sistem-sistem ini juga menunjukkan bagaimana data waktu dapat diintegrasikan dengan logika bisnis yang kompleks untuk memberikan wawasan yang berharga dan mengoptimalkan operasi.

Search This Blog

GoCoding