Minggu 4 - Materi Dasar Memahami Struktur Data Dan Fungsi Bawaan Dalam Python
Let's linked LinkedIn

Tujuan Pembelajaran

  • Memahami struktur data bawaan Python (list, dictionary, tuple, dan set) dalam konteks pengelolaan data.
  • Mampu memanipulasi data secara efisien menggunakan fungsi-fungsi bawaan Python sebelum beralih ke Pandas.
  • Mempelajari cara membaca dan menulis file data dasar, seperti CSV dan JSON.

Rincian Materi

1. Pengantar Struktur Data Bawaan Python

Sebelum menggunakan Pandas, penting bagi peserta untuk memahami bagaimana struktur data dasar bekerja di Python. Materi ini mencakup pengenalan empat struktur data dasar yang paling sering digunakan dalam pemrograman sehari-hari, terutama dalam pengelolaan data:

  • List: Koleksi yang terurut, di mana elemen bisa diubah dan diperluas. List digunakan untuk menyimpan kumpulan data yang dapat diakses berdasarkan indeks.
  • Dictionary: Struktur data yang menyimpan data dalam bentuk pasangan kunci-nilai (key-value). Sangat berguna untuk menyimpan data terstruktur di mana setiap elemen memiliki kunci unik.
  • Tuple: Mirip dengan list, tetapi bersifat immutable (tidak bisa diubah). Tuples berguna untuk data yang tidak boleh diubah setelah didefinisikan.
  • Set: Koleksi yang tidak terurut dan tidak mengandung duplikasi. Berguna untuk pengelolaan data yang memerlukan penghilangan elemen duplikat.

2. Operasi Dasar pada List dan Dictionary

Setelah memahami struktur data, peserta akan belajar operasi-operasi dasar yang sering digunakan untuk memanipulasi data.

Operasi pada List:

  • Menambah, menghapus, dan memodifikasi elemen: Menjelaskan cara menambahkan elemen ke list dengan menggunakan append(), menghapus dengan remove(), serta memodifikasi elemen dengan mengaksesnya menggunakan indeks.
  • Sorting dan filtering: Bagaimana menyortir data dalam list menggunakan sort() atau sorted(), serta bagaimana memfilter elemen menggunakan list comprehensions.

Operasi pada Dictionary:

  • Mengakses elemen: Bagaimana mengakses nilai dari sebuah kunci menggunakan dict[key].
  • Menambah dan menghapus elemen: Menambahkan pasangan kunci-nilai baru atau menghapusnya menggunakan del atau pop().
  • Iterasi dalam dictionary: Penggunaan items(), keys(), dan values() untuk mengiterasi elemen dalam dictionary.

Iterable adalah objek dalam Python yang dapat mengembalikan elemen-elemennya satu per satu, memungkinkan Anda untuk melakukan iterasi (perulangan) melalui elemen-elemen tersebut. Sederhananya, iterable adalah sesuatu yang dapat Anda “lewati” elemen demi elemen.

Contoh Iterable:

  • List: [1, 2, 3, 4]
  • Tuple: (1, 2, 3, 4)
  • String: "Halo"
  • Set: {1, 2, 3, 4}
  • Dictionary: {"nama": "Ali", "usia": 30}

Bagaimana Iterable Bekerja:

Iterable bekerja dengan menggunakan iterator. Ketika Anda melakukan iterasi melalui iterable, Python secara internal membuat iterator untuk objek tersebut. Iterator ini bertanggung jawab untuk melacak posisi saat ini dalam iterable dan mengembalikan elemen berikutnya setiap kali diminta.

Contoh penggunaan iterable dalam loop for:

angka = [1, 2, 3, 4]
for angka in angka:
  print(angka)

Dalam kode di atas, list angka adalah iterable. Loop for secara otomatis membuat iterator untuk list tersebut dan mengiterasi melalui setiap elemennya.

Fungsi Lambda adalah fungsi anonim (tanpa nama) yang didefinisikan menggunakan kata kunci lambda. Fungsi lambda adalah cara ringkas untuk membuat fungsi kecil dan sederhana tanpa harus mendefinisikannya secara formal menggunakan kata kunci def.

Sintaks Fungsi Lambda:

lambda arguments: expression
  • arguments: Parameter yang diterima oleh fungsi lambda.
  • expression: Ekspresi yang akan dievaluasi dan dikembalikan oleh fungsi lambda.

Contoh Fungsi Lambda:

kuadrat = lambda x: x * x
print(kuadrat(5))  # Output: 25

Dalam kode di atas, lambda x: x * x adalah fungsi lambda yang menerima satu argumen (x) dan mengembalikan kuadrat dari argumen tersebut.

Kegunaan Fungsi Lambda:

  • Fungsi Sederhana: Ideal untuk fungsi sederhana yang dapat didefinisikan dalam satu baris.
  • Fungsi Anonim: Berguna ketika Anda membutuhkan fungsi sementara yang tidak perlu didefinisikan dengan nama.
  • Fungsi “on-the-fly”: Dapat didefinisikan langsung di dalam kode di mana mereka digunakan, seperti di dalam fungsi map(), filter(), dan reduce().

Contoh penggunaan fungsi lambda dengan map():

angka = [1, 2, 3, 4]
kuadrat = list(map(lambda x: x * x, angka))
print(kuadrat)  # Output: [1, 4, 9, 16]

Dalam kode di atas, fungsi lambda lambda x: x * x digunakan untuk menghitung kuadrat dari setiap elemen dalam list angka menggunakan fungsi map().

Iterable memungkinkan Anda untuk memproses elemen-elemen dalam suatu objek secara berurutan, sedangkan fungsi lambda menyediakan cara ringkas untuk membuat fungsi kecil dan sederhana. Keduanya merupakan konsep penting dalam Python yang sering digunakan bersama-sama, terutama dalam pemrosesan data.

3. Fungsi Bawaan untuk Pengelolaan Data

Python menyediakan beberapa fungsi bawaan yang sangat berguna untuk memanipulasi data tanpa perlu menggunakan library eksternal. Peserta akan belajar menggunakan fungsi-fungsi berikut:

  • map(): Menerapkan fungsi ke setiap elemen dari sebuah iterable (seperti list).
  • filter(): Menghasilkan subset dari elemen-elemen yang memenuhi kriteria tertentu.
  • reduce(): Digunakan untuk mereduksi iterable menjadi sebuah nilai tunggal, misalnya menjumlahkan semua elemen dalam list.
  • zip(): Menggabungkan dua atau lebih iterable ke dalam tuple yang sesuai.
  • enumerate(): Menyediakan indeks untuk iterable selama proses iterasi.

4. Pengelolaan Data dengan Modul Bawaan: csv dan json

Sebelum peserta menggunakan Pandas, mereka akan belajar cara membaca dan menulis data dari format populer seperti CSV dan JSON menggunakan modul Python bawaan.

Modul csv:

  • Membaca data dari file CSV menggunakan csv.reader() dan memproses setiap baris sebagai list.
  • Menulis data ke file CSV menggunakan csv.writer() dan menyimpan hasil manipulasi data.

Modul json:

  • Membaca dan menulis data dalam format JSON menggunakan json.load() dan json.dump(). JSON sering digunakan untuk pertukaran data antar aplikasi.

5. Studi Kasus: Pengelolaan Data Sederhana

Peserta akan mengaplikasikan semua konsep yang telah dipelajari dalam sebuah studi kasus. Studi kasus ini mencakup operasi pengelolaan data sederhana dengan menggunakan list, dictionary, tuple,set, fungsi2 map(), reduce(), filter(), zip(), enumerate() dan modul csv/json.

Sebelum kita masuk ke penggunaan Pandas untuk pengolahan data yang lebih kompleks, penting untuk memahami struktur data dasar yang disediakan oleh Python. Struktur data ini menjadi fondasi bagi segala bentuk pengelolaan data dalam Python, termasuk manipulasi, penyimpanan, dan analisis data. Mari kita bahas empat struktur data utama di Python secara mendalam: List, Dictionary, Tuple, dan Set.

1. Pengantar Struktur Data Bawaan Python

Apa itu Struktur Data?

Struktur data adalah cara mengorganisir dan menyimpan data agar dapat diakses dan dimanipulasi dengan efisien. Python menyediakan beberapa struktur data bawaan yang sangat fleksibel dan mudah digunakan. Beberapa struktur data ini bersifat mutable (bisa diubah), sementara yang lain bersifat immutable (tidak bisa diubah). Dengan memahami bagaimana struktur data bekerja, kita bisa memanfaatkan Python untuk berbagai keperluan pemrograman, terutama yang berkaitan dengan pengelolaan data dalam skala besar.

1.1. List: Koleksi Data yang Terurut dan Mutable

List dalam Python adalah koleksi elemen-elemen yang terurut, di mana setiap elemen dapat diubah atau dimodifikasi. List sangat fleksibel, dapat menyimpan berbagai tipe data, dan mendukung berbagai operasi seperti menambah, menghapus, dan memodifikasi elemen. List berguna ketika Anda perlu mengelola data yang perlu dimodifikasi secara dinamis, misalnya ketika Anda bekerja dengan data sensor atau catatan harian penggunaan air.

  • Terurut: Elemen-elemen dalam list disusun berdasarkan urutan yang kita tambahkan.
  • Mutable: Kita dapat mengubah elemen setelah list dibuat.
  • Indeks: Setiap elemen dalam list memiliki posisi (indeks) yang dapat diakses mulai dari 0.
Contoh Dasar:

Misalkan kita memiliki data penggunaan air harian dalam liter:

penggunaan_air = [120, 130, 110, 140, 135]
  • Menambah Elemen: Misalnya, Anda ingin menambahkan data penggunaan hari berikutnya:
penggunaan_air.append(145)
print(penggunaan_air)  # Output: [120, 130, 110, 140, 135, 145]
  • Mengubah Elemen: Jika ada kesalahan pencatatan pada hari ke-2 (indeks 1), kita dapat memperbaikinya:
penggunaan_air[1] = 125
print(penggunaan_air)  # Output: [120, 125, 110, 140, 135, 145]
  • Menghapus Elemen: Untuk menghapus elemen dari list, Anda bisa menggunakan metode remove() atau pop():
penggunaan_air.remove(110)
print(penggunaan_air)  # Output: [120, 125, 140, 135, 145]
Penggunaan dalam Industri Utilitas Air:

Dalam industri utilitas air, list dapat digunakan untuk menyimpan data pengukuran sensor harian, di mana setiap elemen adalah jumlah air yang digunakan pada hari tertentu. Ini membantu teknisi dan manajemen melihat pola penggunaan air dan membuat keputusan tentang distribusi air.

1.2. Dictionary: Struktur Data Berbasis Kunci-Nilai

Dictionary adalah struktur data yang menyimpan pasangan kunci-nilai (key-value pairs). Kunci harus unik, dan digunakan untuk mengakses nilai yang terkait. Dictionary sangat berguna ketika Anda ingin menyimpan data terstruktur, misalnya data pelanggan atau perangkat yang diidentifikasi dengan kunci unik (misalnya nomor ID).

  • Unik: Setiap kunci dalam dictionary harus unik.
  • Mutable: Nilai dari kunci dapat diubah, ditambah, atau dihapus.
Contoh Dasar:

Misalkan kita menyimpan data pelanggan utilitas air, di mana ID pelanggan menjadi kunci, dan informasi seperti nama dan konsumsi air bulanan menjadi nilai:

pelanggan = {
    "001": {"nama": "Ali", "alamat": "Jl. Merdeka", "konsumsi_air": 500},
    "002": {"nama": "Budi", "alamat": "Jl. Sudirman", "konsumsi_air": 650}
}
  • Mengakses Elemen: Untuk mengakses data pelanggan berdasarkan ID-nya, kita dapat menggunakan kunci tersebut:
print(pelanggan["001"])
# Output: {'nama': 'Ali', 'alamat': 'Jl. Merdeka', 'konsumsi_air': 500}
  • Menambah atau Memodifikasi Elemen: Jika ada pelanggan baru yang mendaftar, kita bisa menambahkannya ke dalam dictionary:
pelanggan["003"] = {"nama": "Citra", "alamat": "Jl. Gatot Subroto", "konsumsi_air": 700}
print(pelanggan)
  • Menghapus Elemen: Anda bisa menggunakan del atau pop() untuk menghapus pasangan kunci-nilai:
del pelanggan["002"]
print(pelanggan)  
# Output: {'001': {'nama': 'Ali', 'alamat': 'Jl. Merdeka', 'konsumsi_air': 500}, '003': {'nama': 'Citra', 'alamat': 'Jl. Gatot Subroto', 'konsumsi_air': 700}}
Penggunaan dalam Industri Utilitas Air:

Dalam utilitas air, dictionary bisa digunakan untuk menyimpan data pelanggan, dengan ID sebagai kunci dan detail konsumsi air serta alamat sebagai nilai. Ini memudahkan pengelolaan ribuan data pelanggan secara efisien dan cepat.

1.3. Tuple: Koleksi Data yang Immutable

Tuple adalah struktur data mirip dengan list, tetapi bersifat immutable, artinya data di dalamnya tidak dapat diubah setelah tuple dibuat. Tuples sering digunakan untuk menyimpan data yang tidak boleh diubah, misalnya koordinat geografis dari pipa distribusi atau informasi yang sifatnya tetap.

  • Immutable: Data di dalam tuple tidak bisa diubah setelah didefinisikan.
  • Terurut: Elemen-elemen di dalam tuple tetap terurut berdasarkan bagaimana mereka didefinisikan.
Contoh Dasar:

Misalkan Anda ingin menyimpan koordinat geografis dari titik pipa distribusi air:

koordinat_pipa = (6.9175, 107.6191)
  • Mengakses Elemen: Anda bisa mengakses nilai di dalam tuple berdasarkan indeks:
print(koordinat_pipa[0])  # Output: 6.9175
print(koordinat_pipa[1])  # Output: 107.6191

Karena tuple bersifat immutable, koordinat ini tidak akan berubah secara tidak sengaja.

Penggunaan dalam Industri Utilitas Air:

Tuple cocok untuk menyimpan koordinat geografis dari jaringan distribusi air. Data seperti ini biasanya tidak berubah, sehingga tuple memberikan keamanan bahwa data ini tidak akan dimodifikasi setelah ditetapkan.

1.4. Set: Koleksi Data Unik Tanpa Duplikasi

Set adalah struktur data yang digunakan untuk menyimpan sekumpulan elemen yang unik dan tidak terurut. Set sangat berguna ketika Anda ingin menghindari duplikasi data, misalnya ketika menyimpan perangkat sensor atau zona distribusi air.

  • Tidak ada duplikasi: Set secara otomatis menghapus elemen-elemen yang berulang.
  • Tidak terurut: Elemen-elemen di dalam set tidak memiliki indeks atau urutan.
Contoh Dasar:

Misalkan Anda memiliki daftar perangkat sensor yang terpasang di berbagai zona distribusi air. Anda ingin memastikan bahwa tidak ada duplikasi dalam pencatatan perangkat:

perangkat_sensor = {"SensorA", "SensorB", "SensorC", "SensorA"}
print(perangkat_sensor)  
# Output: {'SensorA', 'SensorB', 'SensorC'}

Karena set tidak mengizinkan duplikasi, “SensorA” hanya akan muncul satu kali.

  • Operasi Set: Anda bisa melakukan operasi matematika pada set, seperti union (gabungan) dan intersection (irisan).
Penggunaan dalam Industri Utilitas Air:

Set dapat digunakan untuk menyimpan daftar perangkat sensor atau alat pemantau yang terpasang di lapangan, sehingga memastikan tidak ada pencatatan duplikat. Ini sangat membantu ketika memantau banyak perangkat di berbagai lokasi yang terhubung ke jaringan distribusi air.

2. Operasi Dasar pada List dan Dictionary

Setelah memahami struktur data, langkah berikutnya adalah mempelajari operasi dasar yang sering digunakan untuk memanipulasi data dalam list dan dictionary. Ini akan membantu kita memproses dan mengelola data dengan lebih efisien.

2.1. Operasi pada List

  • Menambah Elemen: Gunakan append() untuk menambahkan elemen baru ke akhir list.

    penggunaan_air.append(1550)

  • Menghapus Elemen: Gunakan remove() atau pop() untuk menghapus elemen dari list.

    penggunaan_air.remove(1300)

  • Memodifikasi Elemen: Gunakan indeks untuk mengakses dan memodifikasi elemen.

    penggunaan_air[2] = 1400

  • Sorting dan Filtering: Anda bisa mengurutkan list dengan sort() dan menyaring elemen dengan list comprehension.

List Comprehensions adalah cara singkat dan elegan untuk membuat list baru dari list yang sudah ada atau iterable lainnya. Ini memungkinkan kita untuk menulis loop, kondisi, dan logika pembuatan list dalam satu baris kode.

Contoh Sederhana

Misalnya, kita ingin membuat list yang berisi kuadrat dari angka 1 hingga 5:

Cara Biasa:

squares = []
for x in range(1, 6):
    squares.append(x**2)

Dengan List Comprehension:

squares = [x**2 for x in range(1, 6)]

Hasilnya sama: [1, 4, 9, 16, 25]

Sintaks List Comprehensions

[expression for item in iterable if condition]
  • expression: Nilai atau operasi yang ingin diterapkan ke setiap elemen.
  • item: Setiap elemen dari iterable.
  • iterable: Sumber data (seperti list, range, atau string).
  • condition (opsional): Filter untuk memilih elemen tertentu.

Contoh Lain:

1. Membuat list dari elemen yang genap saja:

even_numbers = [x for x in range(10) if x % 2 == 0]
# Hasil: [0, 2, 4, 6, 8]

2. Mengubah setiap elemen menjadi huruf kapital:

names = ["ali", "budi", "citra"]
capitalized_names = [name.upper() for name in names]
# Hasil: ['ALI', 'BUDI', 'CITRA']

List comprehensions membuat kode lebih singkat, mudah dibaca, dan lebih “pythonic” (sesuai dengan gaya penulisan Python yang disarankan).

penggunaan_air.sort()
penggunaan_tinggi = [x for x in penggunaan_air if x > 1500]

2.2. Operasi pada Dictionary

  • Mengakses Elemen: Gunakan kunci untuk mengakses nilai dalam dictionary.

    print(pelanggan["001"])

  • Menambah atau Menghapus Elemen: Gunakan del atau pop() untuk menambah atau menghapus elemen.

    del pelanggan["003"]

  • Iterasi dalam Dictionary: Gunakan items(), keys(), dan values() untuk mengiterasi elemen dalam dictionary.

    for id_pelanggan, detail in pelanggan.items():
    print(id_pelanggan, detail)

2.3. Operasi Dasar pada Tuple

Tuple, seperti yang telah dijelaskan sebelumnya, bersifat immutable, artinya elemen-elemen dalam tuple tidak dapat diubah setelah tuple tersebut didefinisikan. Oleh karena itu, operasi pada tuple lebih terbatas dibandingkan dengan list. Namun, meskipun tidak bisa diubah, tuple sangat berguna dalam banyak skenario, terutama saat kita ingin menjaga data tetap konstan dan aman dari modifikasi yang tidak disengaja. Berikut adalah beberapa operasi dasar yang bisa dilakukan pada tuple:

  • Mengakses Elemen: Seperti pada list, elemen dalam tuple dapat diakses menggunakan indeks. Indeks dimulai dari 0 untuk elemen pertama.

    koordinat = (6.9175, 107.6191)
print(koordinat[0])  # Output: 6.9175
print(koordinat[1])  # Output: 107.6191

  • Menggabungkan Tuple: Meskipun tuple tidak bisa diubah, kita bisa menggabungkan dua tuple untuk membuat tuple baru.

    koordinat_1 = (6.9175, 107.6191)
koordinat_2 = (7.0242, 107.5305)
koordinat_gabungan = koordinat_1 + koordinat_2
print(koordinat_gabungan)  
# Output: (6.9175, 107.6191, 7.0242, 107.5305)

  • Menghitung Panjang Tuple: Untuk mengetahui berapa banyak elemen yang ada dalam tuple, Anda bisa menggunakan len().

    print(len(koordinat))  # Output: 2

  • Memeriksa Keberadaan Elemen dalam Tuple: Anda dapat menggunakan operator in untuk memeriksa apakah suatu elemen ada di dalam tuple.

    print(6.9175 in koordinat)  # Output: True
Penggunaan dalam Industri Utilitas Air:

Dalam utilitas air, tuple sangat berguna untuk menyimpan data koordinat pipa, di mana perubahan atau kesalahan tidak boleh terjadi. Karena tuple bersifat immutable, data ini akan tetap konsisten, dan Anda tidak perlu khawatir tentang perubahan yang tidak disengaja pada koordinat geografis pipa.

2.4. Operasi Dasar pada Set

Set adalah struktur data yang mengelola sekumpulan elemen unik dan tidak terurut. Hal ini sangat bermanfaat ketika Anda ingin menghindari duplikasi data atau ketika Anda perlu melakukan operasi matematis seperti gabungan atau irisan pada koleksi data. Berikut adalah beberapa operasi dasar yang dapat dilakukan pada set.

  • Menambah Elemen: Anda bisa menambahkan elemen baru ke dalam set menggunakan metode add().

    perangkat_sensor = {"SensorA", "SensorB", "SensorC"}
perangkat_sensor.add("SensorD")
print(perangkat_sensor)  # Output: {'SensorA', 'SensorB', 'SensorC', 'SensorD'}

  • Menghapus Elemen: Gunakan remove() atau discard() untuk menghapus elemen dari set.

    perangkat_sensor.remove("SensorB")
print(perangkat_sensor)  # Output: {'SensorA', 'SensorC', 'SensorD'}

    Catatan: Jika Anda menggunakan remove() untuk menghapus elemen yang tidak ada dalam set, Python akan menghasilkan kesalahan. Jika Anda ingin menghindari kesalahan, gunakan discard().

  • Gabungan Set (Union): Menggabungkan dua set menggunakan metode union() atau operator |.

    set1 = {"SensorA", "SensorB"}
set2 = {"SensorC", "SensorB"}
gabungan_set = set1.union(set2)
print(gabungan_set)  # Output: {'SensorA', 'SensorB', 'SensorC'}

  • Irisan Set (Intersection): Untuk menemukan elemen yang ada di kedua set, Anda bisa menggunakan intersection() atau operator &.

    irisan_set = set1.intersection(set2)
print(irisan_set)  # Output: {'SensorB'}

  • Selisih Set (Difference): Untuk menemukan elemen yang ada di set pertama tetapi tidak ada di set kedua, Anda bisa menggunakan difference() atau operator -.

    selisih_set = set1.difference(set2)
print(selisih_set)  # Output: {'SensorA'}

  • Menghapus Semua Elemen Set: Anda bisa menghapus semua elemen dalam set menggunakan clear().

    perangkat_sensor.clear()
print(perangkat_sensor)  # Output: set()
Penggunaan dalam Industri Utilitas Air:

Dalam pengelolaan perangkat sensor yang tersebar di berbagai lokasi jaringan pipa, set dapat digunakan untuk mencatat dan memastikan tidak ada duplikasi sensor. Selain itu, jika Anda memiliki dua set perangkat dari dua lokasi berbeda, Anda bisa menggunakan union untuk menggabungkan kedua set data, atau menggunakan intersection untuk mengetahui perangkat mana yang terdapat di kedua lokasi.

3. Fungsi Bawaan untuk Pengelolaan Data

Python menawarkan beberapa fungsi bawaan yang sangat berguna untuk pengelolaan dan manipulasi data secara efisien tanpa memerlukan library eksternal. Fungsi-fungsi seperti map(), filter(), reduce(), zip(), dan enumerate() memungkinkan Anda untuk memproses data dalam berbagai struktur seperti list, tuple, atau dictionary dengan cara yang ringkas dan elegan. Fungsi-fungsi ini sangat relevan dalam pengelolaan data yang sering muncul dalam industri utilitas air, seperti memproses data sensor, menggabungkan data pelanggan, dan menganalisis data penggunaan air.

Mari kita mulai dengan penjelasan mendalam mengenai fungsi-fungsi ini.

Konsep Dasar Fungsi Bawaan dalam Python

1. map()

map() adalah fungsi yang menerapkan sebuah fungsi ke setiap elemen dari suatu iterable (seperti list atau tuple). Fungsi ini sangat berguna ketika Anda ingin menerapkan operasi yang sama ke seluruh elemen dalam koleksi data tanpa harus menulis loop manual.

  • Sintaks: 
    map(function, iterable)
    Di sini, function adalah fungsi yang akan diterapkan ke setiap elemen dari iterable.
Contoh Dasar map():

Misalkan Anda memiliki daftar konsumsi air dalam liter, dan Anda ingin mengonversinya ke meter kubik (1 meter kubik = 1000 liter):

konsumsi_liter = [1000, 1500, 2000, 1750]

# Mengonversi liter ke meter kubik menggunakan map()
konsumsi_m3 = list(map(lambda liter: liter / 1000, konsumsi_liter))
print(konsumsi_m3)  
# Output: [1.0, 1.5, 2.0, 1.75]

Dalam contoh di atas, fungsi map() menggunakan lambda untuk mengonversi setiap elemen dalam list dari liter ke meter kubik. map() membantu menyederhanakan proses transformasi data.

Penggunaan map() dalam Industri Utilitas Air:

Dalam industri utilitas air, fungsi map() bisa digunakan untuk menerapkan perhitungan ke data sensor secara massal. Misalnya, jika Anda memiliki data tekanan air di berbagai lokasi dan ingin mengonversinya dari bar ke pascal:

tekanan_bar = [2.5, 3.0, 1.8, 2.0]

# Mengonversi tekanan dari bar ke pascal (1 bar = 100000 pascal)
tekanan_pascals = list(map(lambda bar: bar * 100000, tekanan_bar))
print(tekanan_pascals)  
# Output: [250000.0, 300000.0, 180000.0, 200000.0]

2. filter()

filter() digunakan untuk membuat subset dari elemen-elemen yang memenuhi kriteria tertentu. Fungsi ini menerima dua argumen: sebuah fungsi yang mengembalikan True atau False, dan iterable yang akan disaring berdasarkan fungsi tersebut.

  • Sintaks: 
    filter(function, iterable)
Contoh Dasar filter():

Misalkan Anda memiliki daftar konsumsi air per pelanggan, dan ingin menyaring pelanggan yang mengonsumsi lebih dari 1500 liter air.

konsumsi_liter = [1200, 1600, 1800, 1300, 1500]

# Mengambil pelanggan dengan konsumsi di atas 1500 liter
konsumsi_tinggi = list(filter(lambda x: x > 1500, konsumsi_liter))
print(konsumsi_tinggi)  
# Output: [1600, 1800]

Dalam contoh ini, fungsi lambda digunakan untuk memfilter pelanggan yang mengonsumsi air lebih dari 1500 liter.

Penggunaan filter() dalam Industri Utilitas Air:

Dalam utilitas air, filter() bisa digunakan untuk menganalisis data pelanggan yang mungkin memerlukan perhatian khusus. Misalnya, untuk memantau pelanggan yang memiliki konsumsi air yang tidak biasa (terlalu rendah atau terlalu tinggi), fungsi filter() bisa membantu menyaring data dengan cepat:

konsumsi_air = [500, 1000, 2000, 2500, 1200]

# Menemukan pelanggan dengan konsumsi air di atas 2000 liter
konsumsi_diatas_2000 = list(filter(lambda x: x > 2000, konsumsi_air))
print(konsumsi_diatas_2000)
# Output: [2500]

3. reduce()

reduce() adalah fungsi yang digunakan untuk mereduksi iterable menjadi satu nilai tunggal dengan cara menggabungkan elemen-elemen berdasarkan fungsi yang diberikan. Tidak seperti map() dan filter(), reduce() menggabungkan elemen-elemen secara berpasangan.

  • Sintaks: 
    from functools import reduce
reduce(function, iterable)
Contoh Dasar reduce():

Misalkan Anda memiliki data penggunaan air harian dan ingin menghitung total penggunaan air selama satu minggu:

from functools import reduce

konsumsi_liter = [1200, 1300, 1100, 1400, 1500]

# Menjumlahkan semua elemen dalam list
total_konsumsi = reduce(lambda x, y: x + y, konsumsi_liter)
print(total_konsumsi)  
# Output: 6500
Penggunaan reduce() dalam Industri Utilitas Air:

Dalam industri utilitas air, reduce() sangat berguna untuk menghitung total pengukuran dari sensor atau data penggunaan air. Misalnya, Anda ingin menghitung total konsumsi air dari berbagai zona distribusi:

from functools import reduce

konsumsi_zona = [5000, 7000, 6000, 8000, 7500]

# Menghitung total konsumsi air di semua zona
total_konsumsi_zona = reduce(lambda x, y: x + y, konsumsi_zona)
print(total_konsumsi_zona)  
# Output: 33500

4. zip()

zip() menggabungkan dua atau lebih iterable menjadi satu iterable baru yang berisi elemen-elemen yang dipasangkan dari setiap iterable yang diberikan. Fungsi ini sangat berguna ketika Anda ingin bekerja dengan dua set data yang terkait.

  • Sintaks: 
    zip(iterable1, iterable2, ...)
Contoh Dasar zip():

Misalkan Anda memiliki dua daftar: satu berisi ID pelanggan dan yang lainnya berisi konsumsi air per pelanggan. Anda bisa menggunakan zip() untuk menggabungkan data tersebut:

id_pelanggan = ["001", "002", "003"]
konsumsi_air = [1200, 1500, 1300]

# Menggabungkan ID pelanggan dengan konsumsi air
gabungan_data = list(zip(id_pelanggan, konsumsi_air))
print(gabungan_data)  
# Output: [('001', 1200), ('002', 1500), ('003', 1300)]
Penggunaan zip() dalam Industri Utilitas Air:

Dalam utilitas air, zip() bisa digunakan untuk menggabungkan berbagai data operasional. Misalnya, Anda ingin menggabungkan data ID meteran dengan data pengukuran tekanan air:

id_meteran = ["MTR001", "MTR002", "MTR003"]
tekanan_air = [2.5, 3.0, 2.8]

gabungan_tekanan = list(zip(id_meteran, tekanan_air))
print(gabungan_tekanan)  
# Output: [('MTR001', 2.5), ('MTR002', 3.0), ('MTR003', 2.8)]

5. enumerate()

enumerate() menambahkan indeks ke setiap elemen dalam iterable selama proses iterasi. Ini sangat berguna ketika Anda ingin menjaga track dari posisi elemen saat melakukan iterasi.

  • Sintaks: 
    enumerate(iterable, start=0)
Contoh Dasar enumerate():

Misalkan Anda ingin menampilkan indeks dari setiap elemen dalam daftar penggunaan air:

konsumsi_liter = [1200, 1500, 1300]

# Menggunakan enumerate untuk mendapatkan indeks dan nilai
for idx, nilai in enumerate(konsumsi_liter):
    print(f"Indeks {idx}: {nilai}")
# Output:
# Indeks 0: 1200
# Indeks 1: 1500
# Indeks 2: 1300
Penggunaan enumerate() dalam Industri Utilitas Air:

Dalam utilitas air, enumerate() bisa digunakan untuk memberi nomor urut pada data yang diambil dari berbagai sensor atau perangkat. Misalnya, Anda ingin mengidentifikasi urutan pengukuran dari berbagai zona distribusi air:



zona = ["Zona1", "Zona2", "Zona3"]
pengukuran_tekanan = [2.5, 3.0, 2.8]

for idx, (z, t) in enumerate(zip(zona, pengukuran_tekanan)):
    print(f"Pengukuran {idx + 1}: {z} - Tekanan: {t}")
# Output:
# Pengukuran 1: Zona1 - Tekanan: 2.5
# Pengukuran 2: Zona2 - Tekanan: 3.0
# Pengukuran 3: Zona3 - Tekanan: 2.8

4. Pengelolaan Data dengan Modul Bawaan: csv dan json

Dalam dunia pemrograman, pengelolaan data adalah tugas yang sangat penting, terutama dalam konteks industri seperti utilitas air, di mana data harus disimpan, dibaca, dan dianalisis secara efisien. Dua format file yang sering digunakan untuk penyimpanan dan pertukaran data adalah CSV (Comma-Separated Values) dan JSON (JavaScript Object Notation). Python menyediakan modul bawaan seperti csv dan json untuk menangani data dalam format ini, tanpa perlu menggunakan library eksternal.

Konsep Dasar Python dalam Pengelolaan Data dengan Modul Bawaan

1. Modul csv: Mengelola Data Berformat CSV

CSV (Comma-Separated Values) adalah format data yang sangat umum digunakan untuk menyimpan data dalam bentuk tabel, di mana setiap baris data mewakili satu entitas dan setiap nilai dalam baris dipisahkan oleh koma. Dalam banyak aplikasi, terutama di industri seperti utilitas air, data seperti pengukuran sensor, data pelanggan, atau data operasional sering disimpan dalam format CSV.

Modul csv di Python menyediakan berbagai fungsi untuk membaca dan menulis file CSV dengan mudah. Ada dua fungsi penting yang akan kita pelajari:

  • csv.reader(): Membaca file CSV dan memproses setiap baris sebagai list.
  • csv.writer(): Menulis data ke file CSV dalam bentuk baris.
Contoh Dasar Modul csv

Membaca Data dari CSV: Misalkan kita memiliki file penggunaan_air.csv yang menyimpan data penggunaan air harian pelanggan dalam format CSV. Kita ingin membaca dan memproses data ini di Python.

Format file CSV:

ID_Pelanggan,Nama,Konsumsi_Liter
001,Ali,1200
002,Budi,1500
003,Citra,1300

Untuk membaca file ini menggunakan csv.reader(), kita dapat menulis kode sebagai berikut:

import csv

# Membaca file CSV
with open('penggunaan_air.csv', mode='r') as file:
    csv_reader = csv.reader(file)
    header = next(csv_reader)  # Membaca header
    for row in csv_reader:
        print(row)
# Output:
# ['001', 'Ali', '1200']
# ['002', 'Budi', '1500']
# ['003', 'Citra', '1300']

Di sini, setiap baris di file CSV dibaca sebagai list, di mana setiap elemen dalam list mewakili kolom dari file CSV.

Menggunakan csv.writer() untuk Menulis Data ke CSV

Misalkan setelah memproses data, kita ingin menyimpan hasilnya ke file hasil_penggunaan_air.csv. Kita bisa menulis data ini menggunakan csv.writer():

import csv

# Data baru yang akan ditulis ke file CSV
data_baru = [
    ['ID_Pelanggan', 'Nama', 'Konsumsi_Liter'],
    ['004', 'Dewi', '1600'],
    ['005', 'Eko', '1700']
]

# Menulis data ke file CSV
with open('hasil_penggunaan_air.csv', mode='w', newline='') as file:
    csv_writer = csv.writer(file)
    csv_writer.writerows(data_baru)

Kode di atas akan membuat file CSV baru yang berisi data penggunaan air yang telah diperbarui.

Penggunaan csv dalam Industri Utilitas Air

Dalam industri utilitas air, modul csv sangat berguna untuk memproses data operasional seperti penggunaan air per pelanggan, data perangkat sensor, atau jadwal distribusi air. Misalnya, teknisi dapat membaca data sensor dari file CSV, memproses data tersebut (seperti menghitung total konsumsi air atau memeriksa adanya kebocoran), lalu menyimpan hasil analisisnya kembali ke file CSV untuk dilaporkan kepada manajemen.

2. Modul json: Mengelola Data Berformat JSON

JSON (JavaScript Object Notation) adalah format penyimpanan data yang sangat umum dalam aplikasi web dan perangkat lunak modern. JSON digunakan untuk pertukaran data antar sistem, dan strukturnya yang menyerupai dictionary dalam Python membuatnya mudah dipahami dan digunakan. Format JSON sering digunakan untuk menyimpan data pelanggan, pengaturan perangkat, atau data lain yang bersifat terstruktur.

Modul json di Python menyediakan dua fungsi utama untuk bekerja dengan data berformat JSON:

  • json.load(): Membaca data dari file JSON dan mengonversinya menjadi objek Python (biasanya dictionary).
  • json.dump(): Menulis objek Python ke file dalam format JSON.
Contoh Dasar Modul json

Membaca Data dari JSON: Misalkan kita memiliki file pelanggan.json yang berisi data pelanggan utilitas air dalam format JSON:

{
    "001": {"nama": "Ali", "alamat": "Jl. Merdeka", "konsumsi_liter": 1200},
    "002": {"nama": "Budi", "alamat": "Jl. Sudirman", "konsumsi_liter": 1500},
    "003": {"nama": "Citra", "alamat": "Jl. Gatot Subroto", "konsumsi_liter": 1300}
}

Untuk membaca file JSON ini ke dalam Python, kita dapat menggunakan json.load() sebagai berikut:

import json

# Membaca data dari file JSON
with open('pelanggan.json', 'r') as file:
    data_pelanggan = json.load(file)
    print(data_pelanggan)
# Output: {'001': {'nama': 'Ali', 'alamat': 'Jl. Merdeka', 'konsumsi_liter': 1200}, ...}

Data JSON ini akan diubah menjadi dictionary dalam Python, di mana kunci adalah ID pelanggan dan nilainya adalah detail pelanggan.

Misalkan setelah memproses data pelanggan, kita ingin menambahkan pelanggan baru ke dalam file pelanggan.json dan menyimpannya kembali. Kita bisa menulis data ini ke file JSON menggunakan json.dump():

import json

# Data baru yang akan ditambahkan
pelanggan_baru = {
    "004": {"nama": "Dewi", "alamat": "Jl. Thamrin", "konsumsi_liter": 1600}
}

# Membaca data lama dari file JSON
with open('pelanggan.json', 'r') as file:
    data_pelanggan = json.load(file)

# Menambah pelanggan baru
data_pelanggan.update(pelanggan_baru)

# Menulis data yang sudah diperbarui ke file JSON
with open('pelanggan.json', 'w') as file:
    json.dump(data_pelanggan, file, indent=4)

Hasilnya, file pelanggan.json akan diperbarui dengan data pelanggan baru.

Penggunaan json dalam Industri Utilitas Air

Dalam industri utilitas air, JSON sering digunakan untuk pertukaran data antar sistem. Misalnya, aplikasi manajemen pelanggan dapat menyimpan data pelanggan dalam format JSON, yang kemudian digunakan oleh sistem lain seperti sistem billing untuk menghitung tagihan air. Dengan json, data dapat dipertukarkan dengan mudah antar aplikasi tanpa kehilangan struktur dan kejelasan.

Contoh Kasus dalam Industri Utilitas Air

1. Membaca dan Menyimpan Data Inventaris dengan CSV

Misalkan perusahaan utilitas air ingin mengelola inventaris alat-alat yang digunakan dalam perawatan dan pemeliharaan pipa air, seperti valve, sensor, dan pompa. Data inventaris ini disimpan dalam file CSV.

File CSV inventaris.csv mungkin terlihat seperti ini:

ID_Barang,Nama,Stok,Harga
001,Valve,20,500000
002,Sensor,10,750000
003,Pompa,5,2000000

Untuk membaca dan memodifikasi data ini, lalu menyimpannya ke file CSV baru, kita bisa menggunakan kode berikut:

import csv

# Membaca data inventaris dari file CSV
with open('inventaris.csv', 'r') as file:
    csv_reader = csv.reader(file)
    header = next(csv_reader)  # Membaca header
    inventaris = [row for row in csv_reader]

# Menambah barang baru ke inventaris
inventaris.append(['004', 'Pipa', '50', '150000'])

# Menulis data inventaris yang sudah diperbarui ke file CSV baru
with open('inventaris_baru.csv', 'w', newline='') as file:
    csv_writer = csv.writer(file)
    csv_writer.writerow(header)  # Menulis header
    csv_writer.writerows(inventaris)

2. Membaca dan Menyimpan Data Pelanggan dengan JSON

Dalam contoh ini, kita akan membaca data pelanggan dari file pelanggan.json, memodifikasinya, dan menulis hasil modifikasinya kembali ke file.

File pelanggan.json mungkin terlihat seperti ini:

{
    "001": {"nama": "Ali", "alamat": "Jl. Merdeka", "konsumsi_liter": 1200},
    "002": {"

nama": "Budi", "alamat": "Jl. Sudirman", "konsumsi_liter": 1500}
}

Jika kita ingin memperbarui data pelanggan, misalnya menambahkan pelanggan baru dan memperbarui konsumsi air pelanggan lain, kita dapat melakukannya sebagai berikut:

import json

# Membaca data pelanggan dari file JSON
with open('pelanggan.json', 'r') as file:
    data_pelanggan = json.load(file)

# Memperbarui konsumsi air pelanggan "001"
data_pelanggan["001"]["konsumsi_liter"] = 1300

# Menambah pelanggan baru
data_pelanggan["003"] = {"nama": "Citra", "alamat": "Jl. Gatot Subroto", "konsumsi_liter": 1400}

# Menyimpan data pelanggan yang sudah diperbarui ke file JSON
with open('pelanggan_baru.json', 'w') as file:
    json.dump(data_pelanggan, file, indent=4)

5. Studi Kasus: Pengelolaan Data Sederhana dalam Industri Utilitas Air

Dalam studi kasus ini, kita akan menggabungkan semua konsep yang telah dipelajari—termasuk list, dictionary, tuple, set, serta fungsi bawaan Python seperti map(), reduce(), filter(), zip(), dan enumerate(), serta modul csv dan json—untuk memecahkan masalah pengelolaan data yang sering ditemui dalam industri utilitas air.

Konteks:

Perusahaan utilitas air mengelola berbagai jenis data operasional, seperti penggunaan air pelanggan, pemantauan perangkat sensor, pengolahan data konsumsi air, dan penyimpanan informasi pelanggan. Studi kasus ini bertujuan untuk menyederhanakan proses pengumpulan, pengelolaan, dan analisis data, sehingga teknisi dan manajemen bisa mengambil keputusan yang lebih baik dan lebih cepat.

Langkah-langkah Studi Kasus:

Studi kasus ini akan dibagi menjadi beberapa tahapan di mana setiap tahapan akan menggunakan konsep-konsep yang telah dipelajari:

1. Menyimpan Data Penggunaan Air Harian Menggunakan List

Skenario pertama adalah menyimpan data penggunaan air harian dari berbagai pelanggan dalam sebuah list. Data ini digunakan untuk menganalisis penggunaan air selama periode tertentu. Kita akan menggunakan list untuk menyimpan data dan menghitung total serta rata-rata konsumsi air.

Kasus: Setiap pelanggan memberikan data penggunaan air harian dalam liter. Kita ingin menyimpan data ini, menghitung total konsumsi, dan menghitung rata-rata penggunaan air per hari.

Implementasi:
# Data penggunaan air harian pelanggan (dalam liter)
konsumsi_harian = [1200, 1300, 1100, 1400, 1500, 1350, 1450]

# Menghitung total konsumsi air
total_konsumsi = sum(konsumsi_harian)

# Menghitung rata-rata konsumsi air per hari
rata_rata_konsumsi = total_konsumsi / len(konsumsi_harian)

print(f"Total konsumsi air selama seminggu: {total_konsumsi} liter")
print(f"Rata-rata konsumsi air per hari: {rata_rata_konsumsi:.2f} liter")

Hasil:

Total konsumsi air selama seminggu: 9300 liter
Rata-rata konsumsi air per hari: 1328.57 liter

2. Memetakan Data Pelanggan dengan Dictionary

Dalam langkah ini, kita akan menyimpan data pelanggan dalam bentuk dictionary. Setiap pelanggan memiliki ID, nama, dan alamat, serta data tentang penggunaan air. Menggunakan dictionary memungkinkan kita untuk mengakses data pelanggan dengan cepat berdasarkan ID unik mereka.

Kasus: Kita ingin menyimpan data pelanggan, memodifikasi data, dan mengaksesnya secara dinamis.

Implementasi:
# Data pelanggan (ID pelanggan, nama, alamat, konsumsi air)
pelanggan = {
    "001": {"nama": "Ali", "alamat": "Jl. Merdeka", "konsumsi_air": 1200},
    "002": {"nama": "Budi", "alamat": "Jl. Sudirman", "konsumsi_air": 1500},
    "003": {"nama": "Citra", "alamat": "Jl. Gatot Subroto", "konsumsi_air": 1300}
}

# Mengakses data pelanggan berdasarkan ID
id_pelanggan = "002"
data_pelanggan = pelanggan[id_pelanggan]
print(f"Data Pelanggan {id_pelanggan}: {data_pelanggan}")

# Memperbarui konsumsi air pelanggan "003"
pelanggan["003"]["konsumsi_air"] = 1400

# Menambah pelanggan baru
pelanggan["004"] = {"nama": "Dewi", "alamat": "Jl. Thamrin", "konsumsi_air": 1600}

# Menampilkan data terbaru pelanggan
print(pelanggan)

Hasil:

Data Pelanggan 002: {'nama': 'Budi', 'alamat': 'Jl. Sudirman', 'konsumsi_air': 1500}
{'001': {'nama': 'Ali', 'alamat': 'Jl. Merdeka', 'konsumsi_air': 1200},
 '002': {'nama': 'Budi', 'alamat': 'Jl. Sudirman', 'konsumsi_air': 1500},
 '003': {'nama': 'Citra', 'alamat': 'Jl. Gatot Subroto', 'konsumsi_air': 1400},
 '004': {'nama': 'Dewi', 'alamat': 'Jl. Thamrin', 'konsumsi_air': 1600}}

3. Menggunakan Tuple untuk Data yang Tidak Boleh Diubah

Tuple sangat berguna untuk menyimpan data yang bersifat tetap, seperti koordinat pipa air atau zona distribusi air yang tidak berubah. Tuples memastikan bahwa data ini tidak bisa diubah secara tidak sengaja selama operasi.

Kasus: Kita ingin menyimpan koordinat geografis jaringan pipa air di berbagai lokasi.

Implementasi:
# Koordinat pipa (lintang, bujur)
koordinat_pipa = (6.9175, 107.6191)  # Koordinat di kota Bandung

# Akses data koordinat
print(f"Koordinat Pipa: Lintang = {koordinat_pipa[0]}, Bujur = {koordinat_pipa[1]}")

Hasil:

Koordinat Pipa: Lintang = 6.9175, Bujur = 107.6191

4. Mengelola Data Sensor dengan Set

Set digunakan untuk memastikan tidak ada duplikasi dalam data. Ini penting dalam sistem monitoring perangkat sensor di industri air, di mana setiap sensor harus memiliki ID unik.

Kasus: Kita ingin menyimpan data sensor di jaringan distribusi air dan memastikan bahwa setiap sensor hanya tercatat satu kali.

Implementasi:
# Data perangkat sensor yang dipasang di jaringan
sensor = {"SensorA", "SensorB", "SensorC", "SensorA"}  # SensorA dicatat dua kali

# Set otomatis menghapus duplikat
print(f"Daftar perangkat sensor unik: {sensor}")

# Menambah sensor baru
sensor.add("SensorD")
print(f"Perangkat sensor setelah penambahan: {sensor}")

Hasil:

Daftar perangkat sensor unik: {'SensorA', 'SensorB', 'SensorC'}
Perangkat sensor setelah penambahan: {'SensorA', 'SensorD', 'SensorB', 'SensorC'}

5. Menggunakan map(), reduce(), dan filter() untuk Manipulasi Data

Kita akan menggunakan fungsi map() untuk mengubah data, reduce() untuk menghitung total konsumsi air, dan filter() untuk menyaring data berdasarkan kriteria tertentu.

Contoh Kasus:
  1. map(): Mengonversi konsumsi air dari liter ke meter kubik (1 meter kubik = 1000 liter).
  2. reduce(): Menghitung total konsumsi air dari semua pelanggan.
  3. filter(): Menemukan pelanggan dengan konsumsi air lebih dari 1300 liter.
Implementasi:
from functools import reduce

# Data konsumsi air pelanggan (dalam liter)
konsumsi_air = [1200, 1500, 1400, 1600]

# Mengonversi konsumsi air ke meter kubik
konsumsi_m3 = list(map(lambda x: x / 1000, konsumsi_air))
print(f"Konsumsi dalam meter kubik: {konsumsi_m3}")

# Menghitung total konsumsi air menggunakan reduce
total_konsumsi = reduce(lambda x, y: x + y, konsumsi_air)
print(f"Total konsumsi air: {total_konsumsi} liter")

# Menyaring pelanggan dengan konsumsi lebih dari 1300 liter
konsumsi_diatas_1300 = list(filter(lambda x: x > 1300, konsumsi_air))
print(f"Pelanggan dengan konsumsi di atas 1300 liter: {konsumsi_diatas_1300}")

Hasil:

Konsumsi dalam meter kubik: [1.2, 1.5, 1.4, 1.6]
Total konsumsi air: 5700 liter
Pelanggan dengan konsumsi di atas 1300 liter: [1500, 1400, 1600]

6. Menggabungkan Data dengan zip() dan enumerate()

Kita akan menggunakan zip() untuk menggabungkan ID pelanggan dan konsumsi air mereka, serta enumerate() untuk memberikan nomor urut pada setiap pelanggan.

Implementasi:
id_pelanggan = ["001", "002", "003", "004"]
konsumsi_air

 = [1200, 1500, 1400, 1600]

# Menggabungkan ID pelanggan dengan konsumsi air menggunakan zip()
data_pelanggan = list(zip(id_pelanggan, konsumsi_air))

# Menampilkan data pelanggan dengan nomor urut menggunakan enumerate()
for idx, (id_pel, konsumsi) in enumerate(data_pelanggan, start=1):
    print(f"{idx}. ID Pelanggan: {id_pel}, Konsumsi Air: {konsumsi} liter")

Hasil:

1. ID Pelanggan: 001, Konsumsi Air: 1200 liter
2. ID Pelanggan: 002, Konsumsi Air: 1500 liter
3. ID Pelanggan: 003, Konsumsi Air: 1400 liter
4. ID Pelanggan: 004, Konsumsi Air: 1600 liter

7. Menyimpan dan Membaca Data dengan csv dan json

Akhirnya, kita akan menyimpan data pelanggan ke file CSV dan file JSON, kemudian membaca data tersebut kembali.

Menyimpan Data ke CSV:
import csv

# Menyimpan data pelanggan ke file CSV
header = ["ID_Pelanggan", "Konsumsi_Air"]
data_pelanggan = zip(id_pelanggan, konsumsi_air)

with open('data_pelanggan.csv', mode='w', newline='') as file:
    csv_writer = csv.writer(file)
    csv_writer.writerow(header)  # Menulis header
    csv_writer.writerows(data_pelanggan)
Menyimpan Data ke JSON:
import json

# Membuat dictionary pelanggan
data_json = {
    "001": {"nama": "Ali", "konsumsi_air": 1200},
    "002": {"nama": "Budi", "konsumsi_air": 1500},
    "003": {"nama": "Citra", "konsumsi_air": 1400},
    "004": {"nama": "Dewi", "konsumsi_air": 1600}
}

# Menyimpan data ke file JSON
with open('data_pelanggan.json', 'w') as file:
    json.dump(data_json, file, indent=4)
Membaca Data dari CSV:
import csv

# Membaca data dari file CSV
with open('data_pelanggan.csv', mode='r') as file:
    csv_reader = csv.reader(file)
    for row in csv_reader:
        print(row)
Membaca Data dari JSON:
import json

# Membaca data dari file JSON
with open('data_pelanggan.json', 'r') as file:
    data_pelanggan = json.load(file)
    print(data_pelanggan)

Kesimpulan

Memahami dan menggunakan struktur data bawaan Python seperti list, dictionary, tuple, dan set merupakan dasar yang sangat penting dalam pengelolaan data, terutama dalam industri utilitas air. Dengan menguasai cara kerja dan operasi dasar pada struktur-struktur data ini, Anda dapat mengelola data penggunaan air, data pelanggan, perangkat sensor, dan data operasional lainnya dengan lebih efisien dan akurat.

  • List memberikan fleksibilitas dalam pengelolaan data yang terurut dan sering berubah, seperti data penggunaan air harian.
  • Dictionary memungkinkan pengelolaan data yang terstruktur dengan baik, di mana setiap elemen memiliki kunci unik, misalnya data pelanggan dan konsumsi air mereka.
  • Tuple cocok digunakan untuk menyimpan data yang tidak boleh diubah, seperti koordinat pipa atau parameter jaringan.
  • Set membantu dalam pengelolaan data yang memerlukan keunikan dan menghindari duplikasi, seperti data perangkat sensor di lapangan.

Fungsi bawaan seperti map(), filter(), reduce(), zip(), dan enumerate() adalah alat yang sangat kuat dalam Python, memungkinkan kita untuk memproses dan memanipulasi data secara efisien dan ringkas. Dalam industri utilitas air, fungsi-fungsi ini dapat diterapkan untuk memproses data sensor, menganalisis konsumsi air, atau mengelola berbagai data operasional lainnya. Dengan pemahaman yang baik tentang fungsi-fungsi ini, Anda akan lebih siap untuk menangani pengelolaan data yang lebih kompleks menggunakan Python.

Menggunakan modul bawaan Python seperti csv dan json memungkinkan kita untuk mengelola data dalam format yang sering digunakan dalam aplikasi bisnis dan teknis, termasuk dalam industri utilitas air. Modul csv memungkinkan pengelolaan data tabular seperti penggunaan air pelanggan, sementara json sangat cocok untuk pertukaran data yang lebih kompleks antara sistem, seperti data pelanggan atau pengaturan perangkat sensor. Dengan memahami cara membaca dan menulis data dalam format CSV dan JSON, kita bisa memproses, menyimpan, dan menganalisis data secara efisien sebelum beralih ke tools yang lebih canggih seperti Pandas untuk analisis data yang lebih mendalam.

Dalam studi kasus, kita telah menggunakan berbagai konsep pengelolaan data di Python untuk menyelesaikan tugas-tugas operasional dalam industri utilitas air. Dengan menggabungkan penggunaan list, dictionary, tuple, set, serta fungsi bawaan seperti map(), reduce(), filter(), zip(), dan enumerate(), kita mampu mengelola data secara efektif. Terakhir, dengan bantuan modul csv dan json, kita bisa membaca dan menyimpan data dalam format yang umum digunakan di dunia nyata.

Berikut adalah 30 latihan soal yang memadukan penggunaan list, dictionary, tuple, set, fungsi bawaan seperti map(), reduce(), filter(), zip(), enumerate(), serta modul csv dan json. Setiap soal akan memiliki jawaban agar peserta dapat memahami konsep secara menyeluruh dan mendalam.

Latihan 1 - 5: List Manipulation

  1. Soal: Diberikan sebuah list berisi konsumsi air pelanggan dalam liter: [1500, 1200, 1800, 1100, 1300]. Hitung total konsumsi air menggunakan sum() dan rata-rata konsumsi air.

    Jawaban:

    konsumsi_air = [1500, 1200, 1800, 1100, 1300]
total = sum(konsumsi_air)
rata_rata = total / len(konsumsi_air)
print(f"Total: {total}, Rata-rata: {rata_rata}")

  2. Soal: Modifikasi list di atas dengan menambahkan konsumsi air 1400 liter di akhir list dan ubah konsumsi air pelanggan kedua (indeks 1) menjadi 1350 liter.

    Jawaban:

    konsumsi_air.append(1400)
konsumsi_air[1] = 1350
print(konsumsi_air)

  3. Soal: Sortir list tersebut secara descending (dari terbesar ke terkecil) dan tampilkan hasilnya.

    Jawaban:

    konsumsi_air.sort(reverse=True)
print(konsumsi_air)

  4. Soal: Gunakan list comprehension untuk membuat list baru yang hanya berisi konsumsi air di atas 1300 liter.

    Jawaban:

    konsumsi_diatas_1300 = [x for x in konsumsi_air if x > 1300]
print(konsumsi_diatas_1300)

  5. Soal: Kalikan setiap elemen dalam list konsumsi air dengan 1.2 (peningkatan konsumsi) menggunakan map() dan simpan hasilnya dalam list baru.

    Jawaban:

    konsumsi_ditingkatkan = list(map(lambda x: x * 1.2, konsumsi_air))
print(konsumsi_ditingkatkan)

Latihan 6 - 10: Dictionary Manipulation

  1. Soal: Buat dictionary yang menyimpan data pelanggan dengan ID, nama, dan alamat. Tampilkan data pelanggan dengan ID ‘002’.

    Jawaban:

    pelanggan = {
    '001': {'nama': 'Ali', 'alamat': 'Jl. Merdeka'},
    '002': {'nama': 'Budi', 'alamat': 'Jl. Sudirman'},
    '003': {'nama': 'Citra', 'alamat': 'Jl. Thamrin'}
}
print(pelanggan['002'])

  2. Soal: Tambahkan pelanggan baru dengan ID ‘004’ ke dictionary, kemudian perbarui alamat pelanggan ‘001’ menjadi “Jl. Gatot Subroto”.

    Jawaban:

    pelanggan['004'] = {'nama': 'Dewi', 'alamat': 'Jl. Gatot Subroto'}
pelanggan['001']['alamat'] = 'Jl. Gatot Subroto'
print(pelanggan)

  3. Soal: Hapus pelanggan dengan ID ‘003’ dari dictionary.

    Jawaban:

    del pelanggan['003']
print(pelanggan)

  4. Soal: Buat sebuah fungsi yang menerima dictionary pelanggan dan mengembalikan dictionary baru yang hanya berisi pelanggan yang alamatnya mengandung ‘Jl. Sudirman’.

    Jawaban:

    def filter_pelanggan_by_alamat(pelanggan):
    return {k: v for k, v in pelanggan.items() if 'Jl. Sudirman' in v['alamat']}

filtered_pelanggan = filter_pelanggan_by_alamat(pelanggan)
print(filtered_pelanggan)

  5. Soal: Buat dictionary baru dengan ID pelanggan sebagai kunci dan konsumsi air sebagai nilai, kemudian hitung total konsumsi air menggunakan sum().

Jawaban:

konsumsi_air = {'001': 1500, '002': 1300, '003': 1600}
total_konsumsi = sum(konsumsi_air.values())
print(f"Total konsumsi: {total_konsumsi}")

Latihan 11 - 15: Tuple Manipulation

  1. Soal: Buat tuple yang menyimpan koordinat geografis (latitude, longitude) untuk tiga zona distribusi air. Akses dan tampilkan koordinat zona kedua.

Jawaban:

koordinat_zona = ((-6.9175, 107.6191), (-7.0242, 107.5275), (-6.9209, 107.6081))
print(koordinat_zona[1])
  1. Soal: Gabungkan dua tuple koordinat berikut (6.9175, 107.6191) dan (7.0242, 107.5275) menjadi satu tuple baru.

Jawaban:

koordinat1 = (6.9175, 107.6191)
koordinat2 = (7.0242, 107.5275)
koordinat_gabungan = koordinat1 + koordinat2
print(koordinat_gabungan)
  1. Soal: Tentukan panjang dari tuple yang menyimpan koordinat dari tiga zona distribusi air.

Jawaban:

print(len(koordinat_zona))
  1. Soal: Buat tuple berisi data nama pelanggan yang tidak boleh diubah, kemudian coba modifikasi elemen di dalamnya (dan lihat kesalahan yang terjadi).

Jawaban:

pelanggan_tuple = ("Ali", "Budi", "Citra")
try:
    pelanggan_tuple[0] = "Dewi"
except TypeError as e:
    print(f"Error: {e}")
  1. Soal: Iterasi melalui tuple koordinat_zona dan tampilkan setiap koordinatnya.

Jawaban:

for koordinat in koordinat_zona:
    print(koordinat)

Latihan 16 - 20: Set Manipulation

  1. Soal: Buat set yang menyimpan ID perangkat sensor yang dipasang di zona distribusi air dan pastikan tidak ada ID duplikat.

Jawaban:

sensor = {"SensorA", "SensorB", "SensorC", "SensorA"}
print(sensor)  # Hanya ada satu SensorA
  1. Soal: Tambahkan ID sensor baru “SensorD” ke set, lalu hapus “SensorB” dari set tersebut.

Jawaban:

sensor.add("SensorD")
sensor.remove("SensorB")
print(sensor)
  1. Soal: Gabungkan dua set sensor yang berada di dua zona berbeda: {"SensorA", "SensorB"} dan {"SensorB", "SensorC"} menggunakan operasi union.

Jawaban:

sensor_zona1 = {"SensorA", "SensorB"}
sensor_zona2 = {"SensorB", "SensorC"}
gabungan_sensor = sensor_zona1.union(sensor_zona2)
print(gabungan_sensor)
  1. Soal: Gunakan intersection untuk menemukan sensor yang ada di kedua zona distribusi.

Jawaban:

irisan_sensor = sensor_zona1.intersection(sensor_zona2)
print(irisan_sensor)
  1. Soal: Hitung berapa banyak sensor unik yang ada dalam set setelah melakukan operasi gabungan.

Jawaban:

print(len(gabungan_sensor))

Latihan 21 - 25: Menggunakan map(), reduce(), dan filter()

  1. Soal: Gunakan map() untuk mengonversi list konsumsi air dari liter ke meter kubik (1 meter kubik = 1000 liter).

Jawaban:

konsumsi_air = [1200, 1500, 1600, 1300]
konsumsi_m3 = list(map(lambda x: x / 1000, konsumsi_air))
print(konsumsi_m3)
  1. Soal: Gunakan filter() untuk menyaring pelanggan dengan konsumsi air di atas 1400 liter.

Jawaban:

konsumsi_air = [1200, 1500, 1600, 1300]
konsumsi

_diatas_1400 = list(filter(lambda x: x > 1400, konsumsi_air))
print(konsumsi_diatas_1400)
  1. Soal: Gunakan reduce() untuk menghitung total konsumsi air dari list pelanggan.

Jawaban:

from functools import reduce
konsumsi_air = [1200, 1500, 1600, 1300]
total_konsumsi = reduce(lambda x, y: x + y, konsumsi_air)
print(total_konsumsi)
  1. Soal: Gunakan map() untuk menambah konsumsi air pelanggan sebesar 10% dan simpan hasilnya dalam list baru.

Jawaban:

konsumsi_air_ditambah = list(map(lambda x: x * 1.1, konsumsi_air))
print(konsumsi_air_ditambah)
  1. Soal: Gunakan filter() untuk mendapatkan pelanggan dengan konsumsi air di bawah 1300 liter.

Jawaban:

konsumsi_dibawah_1300 = list(filter(lambda x: x < 1300, konsumsi_air))
print(konsumsi_dibawah_1300)

Latihan 26 - 30: Menggunakan zip(), enumerate(), dan Modul csv/json

  1. Soal: Gunakan zip() untuk menggabungkan list ID pelanggan dan konsumsi air menjadi satu list tuple.

Jawaban:

id_pelanggan = ['001', '002', '003', '004']
konsumsi_air = [1200, 1500, 1600, 1300]
gabungan_data = list(zip(id_pelanggan, konsumsi_air))
print(gabungan_data)
  1. Soal: Gunakan enumerate() untuk menampilkan data pelanggan beserta nomor urutnya.

Jawaban:

for idx, (id_pel, konsumsi) in enumerate(gabungan_data, start=1):
    print(f"{idx}. ID: {id_pel}, Konsumsi: {konsumsi} liter")
  1. Soal: Buat dan simpan data pelanggan ke file CSV menggunakan modul csv.

Jawaban:

import csv
header = ['ID_Pelanggan', 'Konsumsi_Air']
data_pelanggan = zip(id_pelanggan, konsumsi_air)
with open('data_pelanggan.csv', mode='w', newline='') as file:
    writer = csv.writer(file)
    writer.writerow(header)
    writer.writerows(data_pelanggan)
  1. Soal: Baca data dari file data_pelanggan.csv dan tampilkan ke layar.

Jawaban:

with open('data_pelanggan.csv', mode='r') as file:
    reader = csv.reader(file)
    for row in reader:
        print(row)
  1. Soal: Simpan data pelanggan dalam format JSON menggunakan modul json.

Jawaban:

import json
data_json = {
    '001': {'nama': 'Ali', 'konsumsi_air': 1200},
    '002': {'nama': 'Budi', 'konsumsi_air': 1500},
    '003': {'nama': 'Citra', 'konsumsi_air': 1600},
    '004': {'nama': 'Dewi', 'konsumsi_air': 1300}
}
with open('data_pelanggan.json', 'w') as file:
    json.dump(data_json, file, indent=4)

Dengan 30 latihan soal ini, peserta akan dapat mempraktekkan dan memahami secara mendalam semua konsep yang terkait dengan list, dictionary, tuple, set, serta penggunaan fungsi-fungsi bawaan Python dan modul csv serta json dalam skenario yang relevan dengan industri utilitas air.

Berikut adalah glossary untuk materi ini, dengan fokus pada istilah-istilah kunci dan konsep-konsep penting yang relevan dengan industri utilitas air:

A

  • append(): Fungsi untuk menambahkan elemen ke akhir list.
  • add(): Fungsi untuk menambahkan elemen ke dalam set.

C

  • CSV (Comma-Separated Values): Format file teks yang digunakan untuk menyimpan data tabular, di mana setiap baris mewakili satu record dan setiap nilai dipisahkan oleh koma.
  • csv.reader(): Fungsi dalam modul csv untuk membaca file CSV dan memproses setiap baris sebagai list.
  • csv.writer(): Fungsi dalam modul csv untuk menulis data ke file CSV.
  • clear(): Fungsi untuk menghapus semua elemen dalam set.

D

  • Dictionary: Struktur data yang menyimpan data dalam bentuk pasangan kunci-nilai (key-value pairs).
  • del: Perintah untuk menghapus elemen dari dictionary atau list.
  • difference(): Fungsi untuk mencari elemen yang ada di set pertama tetapi tidak ada di set kedua.
  • discard(): Fungsi untuk menghapus elemen dari set jika ada.

E

  • enumerate(): Fungsi yang menambahkan indeks ke setiap elemen dalam iterable selama proses iterasi.

F

  • filter(): Fungsi yang digunakan untuk membuat subset dari elemen-elemen yang memenuhi kriteria tertentu.

I

  • Immutable: Sifat objek yang tidak dapat diubah setelah didefinisikan (contoh: tuple).
  • intersection(): Fungsi untuk mencari elemen yang ada di kedua set.
  • items(): Fungsi untuk mengiterasi pasangan kunci-nilai dalam dictionary.

J

  • JSON (JavaScript Object Notation): Format pertukaran data yang ringan, mudah dibaca dan ditulis oleh manusia, serta mudah diurai dan dibuat oleh mesin.
  • json.load(): Fungsi dalam modul json untuk membaca data dari file JSON.
  • json.dump(): Fungsi dalam modul json untuk menulis data ke file JSON.

K

  • Kunci (Key): Nilai unik yang digunakan untuk mengidentifikasi elemen dalam dictionary.

L

  • List: Struktur data yang menyimpan koleksi elemen terurut yang dapat diubah (mutable).
  • List Comprehension: Cara ringkas untuk membuat list baru dari list yang sudah ada dengan menerapkan kondisi dan operasi pada setiap elemen.
  • len(): Fungsi untuk menghitung jumlah elemen dalam list, tuple, atau set.

M

  • map(): Fungsi yang menerapkan sebuah fungsi ke setiap elemen dari suatu iterable.
  • Mutable: Sifat objek yang dapat diubah setelah didefinisikan (contoh: list, dictionary).

N

  • Nilai (Value): Data yang terkait dengan kunci dalam dictionary.

P

  • pop(): Fungsi untuk menghapus dan mengembalikan elemen dari list atau dictionary.

R

  • reduce(): Fungsi yang digunakan untuk mereduksi iterable menjadi satu nilai tunggal.
  • remove(): Fungsi untuk menghapus elemen dari list atau set.

S

  • Set: Struktur data yang menyimpan koleksi elemen unik yang tidak terurut.
  • sort(): Fungsi untuk mengurutkan elemen dalam list.
  • sorted(): Fungsi untuk mengurutkan elemen dalam iterable dan mengembalikan list baru.
  • sum(): Fungsi untuk menjumlahkan semua elemen dalam list atau tuple.

T

  • Tuple: Struktur data yang menyimpan koleksi elemen terurut yang tidak dapat diubah (immutable).

U

  • union(): Fungsi untuk menggabungkan dua set.

Z

  • zip(): Fungsi yang menggabungkan dua atau lebih iterable ke dalam tuple yang sesuai.

Istilah Industri Utilitas Air:

  • Data Pelanggan: Informasi tentang pelanggan, seperti ID, nama, alamat, dan konsumsi air.
  • Data Penggunaan Air: Informasi tentang jumlah air yang digunakan oleh pelanggan.
  • ID Meteran: Nomor identifikasi unik untuk setiap meteran air.
  • Inventaris: Daftar barang yang dimiliki oleh perusahaan utilitas air, seperti valve, sensor, dan pompa.
  • Koordinat Pipa: Lokasi geografis pipa air, biasanya dalam bentuk latitude dan longitude.
  • Pengukuran Tekanan Air: Data tentang tekanan air di berbagai titik dalam jaringan distribusi.
  • Perangkat Sensor: Perangkat yang digunakan untuk memantau berbagai parameter dalam jaringan distribusi air, seperti tekanan, aliran, dan kualitas air.
  • Zona Distribusi Air: Wilayah geografis yang dilayani oleh jaringan distribusi air tertentu.
Tags: Python  Data Structures  Programming  CSV  JSON  map()  filter()  reduce()