Contoh Program Python Pengiriman Barang Berbasis Logistik

Mengapa Python Ideal untuk Sistem Logistik?

Python telah menjadi bahasa pemrograman pilihan untuk berbagai aplikasi bisnis termasuk sistem logistik. Keunggulan Python terletak pada sintaksnya yang sederhana dan mudah dibaca, sehingga developer dapat fokus pada masalah yang ingin diselesaikan daripada kompleksitas bahasanya. Selain itu, Python memiliki ekosistem library yang luas, seperti Pandas untuk pengolahan data, NumPy untuk komputasi numerik, dan Flask atau Django untuk pengembangan aplikasi web.

Dalam konteks sistem logistik, Python menawarkan kemampuan untuk mengelola database, memproses data dalam jumlah besar, melakukan analisis prediktif, dan mengintegrasikan dengan API pihak ketiga seperti layanan pengiriman. Semua ini membuat Python menjadi pilihan ideal untuk mengembangkan sistem pengiriman barang yang komprehensif dan skalabel.

Hosting cPanel yang gampang banget dipakai, cocok buat kamu yang nggak mau ribet!

Struktur Dasar Program Pengiriman Barang dengan Python

Sebelum mulai coding, penting untuk memahami struktur dasar program pengiriman barang. Sistem logistik yang efektif biasanya terdiri dari beberapa komponen utama: manajemen inventaris, pemrosesan pesanan, pelacakan pengiriman, dan sistem pelaporan. Mari kita bahas bagaimana Python dapat membantu mengimplementasikan struktur ini.

Program pengiriman barang yang baik harus memiliki struktur modular agar mudah dikelola dan dikembangkan. Anda dapat membagi program menjadi beberapa modul seperti inventory.py untuk pengelolaan stok, order.py untuk pemrosesan pesanan, shipping.py untuk pengelolaan pengiriman, dan reporting.py untuk pelaporan dan analisis. Pendekatan modular ini akan mempermudah maintenance dan pengembangan program di masa depan.

Membangun Sistem Pengelolaan Inventaris

Langkah pertama dalam membangun sistem pengiriman barang adalah membuat modul untuk mengelola inventaris. Berikut contoh sederhana bagaimana Anda bisa mengimplementasikannya:

python

RunCopy

class Inventory:
    def __init__(self):
        self.products = {}
    
    def add_product(self, product_id, name, quantity, location):
        if product_id in self.products:
            self.products[product_id]["quantity"] += quantity
        else:
            self.products[product_id] = {
                "name": name,
                "quantity": quantity,
                "location": location
            }
        return True
    
    def remove_product(self, product_id, quantity):
        if product_id not in self.products:
            return False
        
        if self.products[product_id]["quantity"] < quantity:
            return False
        
        self.products[product_id]["quantity"] -= quantity
        return True
    
    def check_availability(self, product_id, quantity):
        if product_id not in self.products:
            return False
        
        return self.products[product_id]["quantity"] >= quantity
    
    def get_product_location(self, product_id):
        if product_id not in self.products:
            return None
        
        return self.products[product_id]["location"]

Modul inventaris ini memungkinkan Anda untuk menambahkan produk baru, mengurangi stok ketika ada pesanan, memeriksa ketersediaan produk, dan mendapatkan lokasi produk di gudang. Informasi lokasi sangat penting untuk optimasi proses picking dalam operasi logistik.

Implementasi Sistem Pemrosesan Pesanan

Setelah inventaris, komponen penting berikutnya adalah sistem pemrosesan pesanan. Berikut contoh implementasinya:

python

RunCopy

import datetime

class Order:
    def __init__(self, inventory):
        self.inventory = inventory
        self.orders = {}
        self.order_counter = 1000  # Mulai dari 1000
    
    def create_order(self, customer_info, items):
        order_id = self.order_counter
        self.order_counter += 1
        
        # Verifikasi semua item tersedia
        for product_id, quantity in items.items():
            if not self.inventory.check_availability(product_id, quantity):
                return None  # Pesanan gagal karena stok tidak cukup
        
        # Kurangi stok dari inventaris
        for product_id, quantity in items.items():
            self.inventory.remove_product(product_id, quantity)
        
        # Catat pesanan
        self.orders[order_id] = {
            "customer_info": customer_info,
            "items": items,
            "status": "pending",
            "created_at": datetime.datetime.now(),
            "updated_at": datetime.datetime.now()
        }
        
        return order_id
    
    def update_order_status(self, order_id, status):
        if order_id not in self.orders:
            return False
        
        self.orders[order_id]["status"] = status
        self.orders[order_id]["updated_at"] = datetime.datetime.now()
        return True
    
    def get_order_details(self, order_id):
        if order_id not in self.orders:
            return None
        
        return self.orders[order_id]

Sistem pesanan ini memungkinkan pembuatan pesanan baru, verifikasi ketersediaan barang, dan pembaruan status pesanan. Status pesanan bisa berubah dari "pending" menjadi "processing", "shipped", atau "delivered" seiring berjalannya proses logistik.

Pengembangan Sistem Pengiriman dan Pelacakan

Komponen berikutnya adalah sistem pengiriman dan pelacakan yang mengatur bagaimana barang dikirim dan dilacak. Berikut contohnya:

python

RunCopy

import datetime
import random
import string

class Shipping:
    def __init__(self, order_system):
        self.order_system = order_system
        self.shipments = {}
    
    def create_shipment(self, order_id, carrier, service_level):
        order_details = self.order_system.get_order_details(order_id)
        if not order_details or order_details["status"] != "pending":
            return None
        
        # Generate tracking number
        tracking_number = self._generate_tracking_number()
        
        # Create shipment record
        shipment_id = f"SHP-{order_id}"
        self.shipments[shipment_id] = {
            "order_id": order_id,
            "tracking_number": tracking_number,
            "carrier": carrier,
            "service_level": service_level,
            "status": "processing",
            "events": [{
                "timestamp": datetime.datetime.now(),
                "status": "processing",
                "location": "Warehouse",
                "description": "Shipment created and processing"
            }],
            "created_at": datetime.datetime.now()
        }
        
        # Update order status
        self.order_system.update_order_status(order_id, "processing")
        
        return shipment_id, tracking_number
    
    def update_shipment_status(self, shipment_id, status, location, description):
        if shipment_id not in self.shipments:
            return False
        
        self.shipments[shipment_id]["status"] = status
        self.shipments[shipment_id]["events"].append({
            "timestamp": datetime.datetime.now(),
            "status": status,
            "location": location,
            "description": description
        })
        
        # Update order status if necessary
        if status == "delivered":
            order_id = self.shipments[shipment_id]["order_id"]
            self.order_system.update_order_status(order_id, "delivered")
        
        return True
    
    def track_shipment(self, tracking_number):
        for shipment_id, shipment in self.shipments.items():
            if shipment["tracking_number"] == tracking_number:
                return shipment["events"]
        return None
    
    def _generate_tracking_number(self):
        letters = ''.join(random.choices(string.ascii_uppercase, k=4))
        numbers = ''.join(random.choices(string.digits, k=12))
        return f"{letters}{numbers}"

Modul pengiriman ini memungkinkan pembuatan record pengiriman, pembaruan status, dan pelacakan pengiriman melalui nomor pelacakan. Setiap pembaruan status direkam sebagai event dengan timestamp, lokasi, dan deskripsi.

Integrasi dengan API Layanan Pengiriman

Untuk membuat sistem pengiriman yang lebih realistis, Anda perlu mengintegrasikannya dengan API layanan pengiriman seperti JNE, J&T, atau SiCepat. Berikut contoh sederhana bagaimana integrasi ini bisa diimplementasikan:

python

RunCopy

import requests
import json

class ShippingAPIIntegration:
    def __init__(self, api_key, base_url):
        self.api_key = api_key
        self.base_url = base_url
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
    
    def calculate_shipping_cost(self, origin, destination, weight, service_level):
        endpoint = f"{self.base_url}/calculate"
        payload = {
            "origin": origin,
            "destination": destination,
            "weight": weight,
            "service_level": service_level
        }
        
        try:
            response = requests.post(endpoint, headers=self.headers, json=payload)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"Error calculating shipping cost: {e}")
            return None
    
    def create_shipment_label(self, shipment_details):
        endpoint = f"{self.base_url}/labels"
        
        try:
            response = requests.post(endpoint, headers=self.headers, json=shipment_details)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"Error creating shipment label: {e}")
            return None
    
    def track_shipment(self, tracking_number):
        endpoint = f"{self.base_url}/track/{tracking_number}"
        
        try:
            response = requests.get(endpoint, headers=self.headers)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"Error tracking shipment: {e}")
            return None

Integrasi API ini memungkinkan sistem Anda untuk menghitung biaya pengiriman secara real-time, membuat label pengiriman, dan melacak status pengiriman menggunakan API pihak ketiga.

Implementasi Sistem Rute dan Optimasi Pengiriman

Untuk operasi logistik yang lebih efisien, Anda bisa menambahkan modul optimasi rute pengiriman. Berikut contoh sederhana menggunakan algoritma greedy:

python

RunCopy

import math

class RouteOptimization:
    def __init__(self):
        self.warehouse_location = (0, 0)  # Koordinat gudang
    
    def calculate_distance(self, point1, point2):
        # Menghitung jarak Euclidean antara dua titik
        return math.sqrt((point1[0] - point2[0])**2 + (point1[1] - point2[1])**2)
    
    def optimize_delivery_route(self, delivery_locations):
        # Implementasi algoritma greedy sederhana
        current_location = self.warehouse_location
        route = [current_location]
        remaining_locations = delivery_locations.copy()
        
        while remaining_locations:
            nearest_location = None
            min_distance = float('inf')
            
            for location in remaining_locations:
                distance = self.calculate_distance(current_location, location)
                if distance < min_distance:
                    min_distance = distance
                    nearest_location = location
            
            route.append(nearest_location)
            remaining_locations.remove(nearest_location)
            current_location = nearest_location
        
        # Kembali ke gudang
        route.append(self.warehouse_location)
        
        return route
    
    def calculate_route_distance(self, route):
        total_distance = 0
        for i in range(len(route) - 1):
            total_distance += self.calculate_distance(route[i], route[i+1])
        return total_distance

Modul optimasi rute ini menggunakan algoritma greedy sederhana untuk menentukan urutan pengiriman yang paling efisien berdasarkan jarak. Untuk implementasi yang lebih canggih, Anda bisa menggunakan algoritma seperti Traveling Salesman Problem (TSP) atau Vehicle Routing Problem (VRP).

Menambahkan Analisis Data dan Pelaporan

Sistem logistik modern tidak lengkap tanpa analisis data dan pelaporan. Berikut contoh sederhana implementasi modul pelaporan:

python

RunCopy

import pandas as pd
import matplotlib.pyplot as plt
from datetime import datetime, timedelta

class LogisticsReporting:
    def __init__(self, inventory, order_system, shipping_system):
        self.inventory = inventory
        self.order_system = order_system
        self.shipping_system = shipping_system
    
    def generate_inventory_report(self):
        # Mengubah data inventaris menjadi DataFrame untuk analisis
        inventory_data = []
        for product_id, details in self.inventory.products.items():
            inventory_data.append({
                "product_id": product_id,
                "name": details["name"],
                "quantity": details["quantity"],
                "location": details["location"]
            })
        
        df = pd.DataFrame(inventory_data)
        return df
    
    def generate_order_volume_report(self, days=30):
        # Menganalisis volume pesanan dalam periode tertentu
        start_date = datetime.now() - timedelta(days=days)
        
        order_data = []
        for order_id, details in self.order_system.orders.items():
            if details["created_at"] >= start_date:
                order_date = details["created_at"].strftime("%Y-%m-%d")
                total_items = sum(details["items"].values())
                
                order_data.append({
                    "date": order_date,
                    "order_id": order_id,
                    "total_items": total_items,
                    "status": details["status"]
                })
        
        if not order_data:
            return "No orders in the specified period"
        
        df = pd.DataFrame(order_data)
        daily_volume = df.groupby("date")["total_items"].sum().reset_index()
        
        # Membuat visualisasi
        plt.figure(figsize=(12, 6))
        plt.bar(daily_volume["date"], daily_volume["total_items"])
        plt.title(f"Daily Order Volume (Last {days} days)")
        plt.xlabel("Date")
        plt.ylabel("Total Items")
        plt.xticks(rotation=45)
        plt.tight_layout()
        
        return daily_volume, plt
    
    def calculate_delivery_performance(self):
        # Menghitung metrik kinerja pengiriman
        total_shipments = len(self.shipping_system.shipments)
        if total_shipments == 0:
            return "No shipments to analyze"
        
        on_time_deliveries = 0
        late_deliveries = 0
        
        for shipment_id, details in self.shipping_system.shipments.items():
            if details["status"] == "delivered":
                # Asumsikan pengiriman harus selesai dalam 3 hari
                creation_date = details["created_at"]
                delivery_event = next((event for event in reversed(details["events"]) 
                                      if event["status"] == "delivered"), None)
                
                if delivery_event:
                    delivery_date = delivery_event["timestamp"]
                    delivery_time = delivery_date - creation_date
                    
                    if delivery_time.days <= 3:
                        on_time_deliveries += 1
                    else:
                        late_deliveries += 1
        
        performance_metrics = {
            "total_shipments": total_shipments,
            "delivered_shipments": on_time_deliveries + late_deliveries,
            "on_time_deliveries": on_time_deliveries,
            "late_deliveries": late_deliveries,
            "on_time_delivery_rate": (on_time_deliveries / (on_time_deliveries + late_deliveries)) * 100 if (on_time_deliveries + late_deliveries) > 0 else 0
        }
        
        return performance_metrics

Modul pelaporan ini menggunakan library seperti Pandas untuk manipulasi data dan Matplotlib untuk visualisasi. Laporan yang dihasilkan membantu pengambilan keputusan berbasis data dalam operasi logistik.

Jasa website murah meriah! Website murah, kualitas wah! di sini

Menggabungkan Semua Komponen

Setelah mengembangkan semua modul individual, saatnya menggabungkan semuanya menjadi sistem logistik yang lengkap. Berikut contoh bagaimana mengintegrasikan semua komponen:

python

RunCopy

from inventory import Inventory
from order import Order
from shipping import Shipping
from shipping_api import ShippingAPIIntegration
from route_optimization import RouteOptimization
from reporting import LogisticsReporting

def main():
    # Inisialisasi komponen
    inventory = Inventory()
    order_system = Order(inventory)
    shipping_system = Shipping(order_system)
    
    # Integrasi dengan API pengiriman (gunakan API key Anda)
    shipping_api = ShippingAPIIntegration("your_api_key", "https://api.shipping-provider.com")
    
    # Inisialisasi optimasi rute
    route_optimizer = RouteOptimization()
    
    # Inisialisasi sistem pelaporan
    reporting = LogisticsReporting(inventory, order_system, shipping_system)
    
    # Contoh penggunaan: menambahkan produk ke inventaris
    inventory.add_product("P001", "Smartphone", 50, "A1-B2")
    inventory.add_product("P002", "Laptop", 30, "C3-D4")
    inventory.add_product("P003", "Headphones", 100, "E5-F6")
    
    # Contoh penggunaan: membuat pesanan
    customer_info = {
        "name": "John Doe",
        "address": "Jl. Sudirman No. 123, Jakarta",
        "phone": "081234567890",
        "email": "[email protected]"
    }
    
    items = {
        "P001": 2,
        "P003": 1
    }
    
    order_id = order_system.create_order(customer_info, items)
    print(f"Order created with ID: {order_id}")
    
    # Contoh penggunaan: membuat pengiriman
    shipment_id, tracking_number = shipping_system.create_shipment(order_id, "JNE", "REG")
    print(f"Shipment created with ID: {shipment_id}, Tracking Number: {tracking_number}")
    
    # Contoh penggunaan: memperbarui status pengiriman
    shipping_system.update_shipment_status(
        shipment_id, 
        "in_transit", 
        "Jakarta Sorting Center", 
        "Package has arrived at sorting center"
    )
    
    # Contoh penggunaan: melacak pengiriman
    tracking_events = shipping_system.track_shipment(tracking_number)
    print("Tracking events:")
    for event in tracking_events:
        print(f"{event['timestamp']} - {event['status']} - {event['location']}: {event['description']}")
    
    # Contoh penggunaan: optimasi rute
    delivery_locations = [(3, 4), (1, 7), (5, 2), (8, 9)]
    optimized_route = route_optimizer.optimize_delivery_route(delivery_locations)
    route_distance = route_optimizer.calculate_route_distance(optimized_route)
    print(f"Optimized delivery route: {optimized_route}")
    print(f"Total route distance: {route_distance:.2f} km")
    
    # Contoh penggunaan: menghasilkan laporan
    inventory_report = reporting.generate_inventory_report()
    print("\nInventory Report:")
    print(inventory_report)
    
    # Memperbarui status pengiriman menjadi delivered untuk demo
    shipping_system.update_shipment_status(
        shipment_id, 
        "delivered", 
        "Customer Address", 
        "Package has been delivered to the customer"
    )
    
    # Menghasilkan laporan kinerja pengiriman
    performance_metrics = reporting.calculate_delivery_performance()
    print("\nDelivery Performance Metrics:")
    for metric, value in performance_metrics.items():
        print(f"{metric}: {value}")

if __name__ == "__main__":
    main()

Menyimpan Data dengan Database

Untuk aplikasi logistik yang sebenarnya, Anda perlu menyimpan data di database daripada di memori. Berikut contoh implementasi dengan SQLite:

python

RunCopy

import sqlite3
import json
import datetime

class LogisticDatabase:
    def __init__(self, db_name="logistics.db"):
        self.conn = sqlite3.connect(db_name)
        self.cursor = self.conn.cursor()
        self.create_tables()
    
    def create_tables(self):
        # Tabel Produk
        self.cursor.execute('''
        CREATE TABLE IF NOT EXISTS products (
            product_id TEXT PRIMARY KEY,
            name TEXT NOT NULL,
            quantity INTEGER NOT NULL,
            location TEXT NOT NULL
        )
        ''')
        
        # Tabel Pesanan
        self.cursor.execute('''
        CREATE TABLE IF NOT EXISTS orders (
            order_id INTEGER PRIMARY KEY,
            customer_info TEXT NOT NULL,
            items TEXT NOT NULL,
            status TEXT NOT NULL,
            created_at TEXT NOT NULL,
            updated_at TEXT NOT NULL
        )
        ''')
        
        # Tabel Pengiriman
        self.cursor.execute('''
        CREATE TABLE IF NOT EXISTS shipments (
            shipment_id TEXT PRIMARY KEY,
            order_id INTEGER NOT NULL,
            tracking_number TEXT NOT NULL,
            carrier TEXT NOT NULL,
            service_level TEXT NOT NULL,
            status TEXT NOT NULL,
            events TEXT NOT NULL,
            created_at TEXT NOT NULL,
            FOREIGN KEY (order_id) REFERENCES orders (order_id)
        )
        ''')
        
        self.conn.commit()
    
    def add_product(self, product_id, name, quantity, location):
        try:
            self.cursor.execute('''
            INSERT INTO products (product_id, name, quantity, location)
            VALUES (?, ?, ?, ?)
            ON CONFLICT(product_id) DO UPDATE SET
                quantity = quantity + ?,
                name = ?,
                location = ?
            ''', (product_id, name, quantity, location, quantity, name, location))
            self.conn.commit()
            return True
        except Exception as e:
            print(f"Error adding product: {e}")
            return False
    
    def save_order(self, order_id, customer_info, items, status, created_at, updated_at):
        try:
            self.cursor.execute('''
            INSERT INTO orders (order_id, customer_info, items, status, created_at, updated_at)
            VALUES (?, ?, ?, ?, ?, ?)
            ''', (
                order_id,
                json.dumps(customer_info),
                json.dumps(items),
                status,
                created_at.isoformat(),
                updated_at.isoformat()
            ))
            self.conn.commit()
            return True
        except Exception as e:
            print(f"Error saving order: {e}")
            return False
    
    def save_shipment(self, shipment_id, order_id, tracking_number, carrier, service_level, status, events, created_at):
        try:
            self.cursor.execute('''
            INSERT INTO shipments (shipment_id, order_id, tracking_number, carrier, service_level, status, events, created_at)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
            ''', (
                shipment_id,
                order_id,
                tracking_number,
                carrier,
                service_level,
                status,
                json.dumps([{**event, "timestamp": event["timestamp"].isoformat()} for event in events]),
                created_at.isoformat()
            ))
            self.conn.commit()
            return True
        except Exception as e:
            print(f"Error saving shipment: {e}")
            return False

Kesimpulan

Program pengiriman barang berbasis logistik yang dibangun dengan Python memiliki potensi luar biasa untuk meningkatkan efisiensi operasi logistik. Dengan mengimplementasikan modul-modul seperti pengelolaan inventaris, pemrosesan pesanan, pengiriman dan pelacakan, optimasi rute, serta pelaporan dan analisis, Anda dapat membangun sistem logistik yang komprehensif dan tangguh.

Python menawarkan fleksibilitas dan kekuatan yang dibutuhkan untuk mengembangkan solusi logistik yang skalabel. Library seperti Pandas dan Matplotlib membantu dalam analisis data dan visualisasi, sementara framework web seperti Flask atau Django dapat digunakan untuk membangun antarmuka web yang memudahkan interaksi dengan sistem.

Implementasi contoh yang telah dibahas dalam artikel ini memberikan kerangka dasar yang dapat dikembangkan lebih lanjut sesuai dengan kebutuhan spesifik bisnis Anda. Dengan mengikuti prinsip-prinsip desain modular dan praktik terbaik pengembangan software, Anda dapat membangun sistem logistik yang tidak hanya efisien tetapi juga mudah dikelola dan dikembangkan di masa depan.

Jangan ragu untuk mengadaptasi dan memperluas contoh-contoh di atas untuk memenuhi kebutuhan spesifik bisnis Anda. Sistem logistik yang baik dapat menjadi keunggulan kompetitif yang signifikan dalam dunia bisnis yang semakin digital dan berorientasi pada kecepatan pengiriman.