Phyton 9 : Struktur Data Tuple Part 2

Phyton 9 : Struktur Data Tuple Part 2

Python adalah bahasa pemrograman yang kaya akan struktur data, yang memungkinkan pengembang untuk menyimpan dan memanipulasi data dengan cara yang efisien dan intuitif. Dalam seri tutorial ini, kita telah membahas berbagai aspek dari struktur data di Python, termasuk tuple. Pada artikel berjudul "Tutorial Python 9 : Struktur Data Tuple Part 2" ini, kita akan melanjutkan eksplorasi kita tentang tuple, sebuah struktur data yang bersifat tidak dapat diubah (immutable) dan sering digunakan untuk menyimpan sekumpulan elemen yang terkait. Bagian kedua ini akan mendalami lebih lanjut operasi-operasi lanjutan, teknik manipulasi, serta penerapan praktis dari tuple dalam pemrograman sehari-hari. Dengan pemahaman yang lebih mendalam tentang tuple, Anda akan dapat memanfaatkan potensi penuh dari struktur data ini dalam proyek Python Anda.

Mengambil Panjang Tuple

Untuk mengambil panjang atau jumlah item di dalam tuple, kita bisa menggunakan fungsi bawaan `len()` di Python. Fungsi ini mengembalikan jumlah elemen yang ada dalam tuple. Ini sangat berguna ketika kita perlu mengetahui berapa banyak item yang ada di dalam tuple tanpa harus menghitungnya secara manual. Berikut adalah cara penggunaannya:

 

Contoh Penggunaan Fungsi `len()`

Berikut adalah contoh bagaimana kita bisa menggunakan `len()` untuk mengambil panjang dari sebuah tuple:

 

```python
Membuat Tuple
hari = ('Senin', 'Selasa', 'Rabu', 'Kamis', 'Jum\'at', 'Sabtu', 'Minggu')


Mengambil panjang tuple hari
print("Jumlah hari: %d" % len(hari))
```

 

Dalam contoh di atas, kita membuat tuple `hari` yang berisi nama-nama hari dalam seminggu. Fungsi `len(hari)` digunakan untuk menghitung jumlah elemen dalam tuple `hari`, yang kemudian dicetak dengan menggunakan sintaks string format.

Penjelasan Kode

 

1. Membuat Tuple:

   

```python
   hari = ('Senin', 'Selasa', 'Rabu', 'Kamis', 'Jum\'at', 'Sabtu', 'Minggu')
   ```

   Di sini, kita membuat sebuah tuple bernama `hari` yang berisi tujuh elemen, masing-masing mewakili nama hari dalam seminggu.

 

2. Mengambil Panjang Tuple:

   

```python
   print("Jumlah hari: %d" % len(hari))
   ```

   Fungsi `len(hari)` digunakan untuk menghitung jumlah elemen dalam tuple `hari`. Hasilnya adalah angka 7, yang merupakan jumlah elemen dalam tuple tersebut. Hasil ini kemudian dicetak dengan menggunakan string format `"%d"`, yang merupakan placeholder untuk angka dalam string format.

 

Contoh Lain Menggunakan Fungsi `len()`

Berikut beberapa contoh lain untuk menunjukkan fleksibilitas fungsi `len()` dalam berbagai konteks:

 

1. Menghitung Elemen dalam Tuple Kosong:

  

 ```python
   empty_tuple = ()
   print("Jumlah elemen: %d" % len(empty_tuple))  # Output: Jumlah elemen: 0
   ``` 

 

   Di sini, kita membuat tuple kosong `empty_tuple` dan menggunakan `len()` untuk mengonfirmasi bahwa panjangnya adalah 0.

 

2. Menghitung Elemen dalam Tuple dengan Berbagai Tipe Data:

 

   

```python
   mixed_tuple = (1, "Python", 3.14, True)
   print("Jumlah elemen: %d" % len(mixed_tuple))  # Output: Jumlah elemen: 4
   ```

 

   Tuple `mixed_tuple` berisi elemen dengan berbagai tipe data (integer, string, float, boolean). Fungsi `len()` menghitung jumlah total elemen yang ada, yaitu 4.

 

Mengambil Panjang Tuple di Dalam Fungsi

Kita juga bisa menggunakan `len()` di dalam fungsi untuk mengembalikan panjang tuple yang diberikan sebagai argumen:

 

```python
def hitung_panjang(t):
    return len(t)


Contoh penggunaan


example_tuple = (10, 20, 30, 40)
print("Panjang tuple: %d" % hitung_panjang(example_tuple))  # Output: Panjang tuple: 4
```

Dalam contoh ini, fungsi `hitung_panjang` menerima sebuah tuple `t` sebagai argumen dan mengembalikan panjangnya menggunakan `len(t)`.

Dengan menggunakan fungsi `len()`, kita bisa dengan mudah dan efisien mengetahui jumlah elemen dalam sebuah tuple, yang sangat berguna dalam berbagai situasi pemrograman.

 

Baca Juga

• Struktur Tuple 1
• Struktur Dictionary

 

Tuple Nested

Tuple di Python tidak hanya dapat menyimpan data primitif seperti angka dan string, tetapi juga dapat berisi tuple lain di dalamnya. Ini dikenal sebagai nested tuple. Dengan kemampuan ini, kita dapat membuat struktur data yang kompleks dan bersarang, yang sangat berguna dalam berbagai aplikasi pemrograman.

 

Contoh Nested Tuple

Berikut adalah contoh sederhana dari nested tuple, di mana sebuah tuple berisi dua tuple lainnya:

 

```python
# Membuat dua tuple
tuple1 = ("aku", "cinta", "kamu")
tuple2 = ("selama", 3, "tahun")


# Membuat nested tuple
tuple3 = (tuple1, tuple2)


# Output nested tuple
print(tuple3)  # Output: (('aku', 'cinta', 'kamu'), ('selama', 3, 'tahun'))
```

 

Dalam contoh di atas, `tuple3` adalah nested tuple yang berisi `tuple1` dan `tuple2`. Nested tuple `tuple3` berisi dua elemen, masing-masing adalah tuple yang terpisah.

 

Mengakses Elemen di Nested Tuple

Kita dapat mengakses elemen dalam nested tuple dengan menggunakan indeks berulang. Berikut adalah contoh bagaimana mengakses elemen-elemen dalam nested tuple:

 

```python
# Mengakses elemen dalam nested tuple
print(tuple3[0])      # Output: ('aku', 'cinta', 'kamu')
print(tuple3[1])      # Output: ('selama', 3, 'tahun')
print(tuple3[0][1])   # Output: cinta
print(tuple3[1][2])   # Output: tahun
```

 

Dalam contoh ini, `tuple3[0]` mengakses tuple pertama, dan `tuple3[0][1]` mengakses elemen kedua dari tuple pertama.

 

Nested Tuple dengan Berbagai Objek

Selain tuple, kita juga bisa mengisi tuple dengan objek lain seperti list, dictionary, dan nilai boolean. Ini memungkinkan kita untuk membuat struktur data yang lebih dinamis dan fleksibel. Berikut adalah contoh penggunaannya:

 

```python
# Membuat nested tuple dengan berbagai objek
t = ([1, 2, 3], {'nama': 'Petani Kode', 'rank': 123}, True)


# Output nested tuple
print(t)  # Output: ([1, 2, 3], {'nama': 'Petani Kode', 'rank': 123}, True)
```

 

Dalam contoh ini, tuple `t` berisi tiga elemen: list `[1, 2, 3]`, dictionary `{'nama': 'Petani Kode', 'rank': 123}`, dan nilai boolean `True`.

 

Mengakses Elemen dalam Nested Tuple dengan Objek Berbeda

Kita juga dapat mengakses dan mengelola elemen dalam nested tuple yang berisi berbagai objek:

 

```python
# Mengakses elemen dalam nested tuple
print(t[0])          # Output: [1, 2, 3]
print(t[1])          # Output: {'nama': 'Petani Kode', 'rank': 123}
print(t[2])          # Output: True


# Mengakses elemen dalam list di nested tuple
print(t[0][1])       # Output: 2


# Mengakses elemen dalam dictionary di nested tuple
print(t[1]['nama'])  # Output: Petani Kode
```

 

Dalam contoh ini, kita mengakses elemen list, dictionary, dan boolean dalam nested tuple `t`. Kita juga dapat mengakses elemen spesifik dari list dan dictionary yang ada dalam nested tuple.

 

Modifikasi Objek dalam Nested Tuple

Meskipun tuple bersifat immutable (tidak dapat diubah setelah diciptakan), objek yang ada di dalam tuple seperti list dan dictionary masih bisa dimodifikasi. Berikut adalah contohnya:

 

```python
# Modifikasi list dalam nested tuple
t[0][1] = 20
print(t)  # Output: ([1, 20, 3], {'nama': 'Petani Kode', 'rank': 123}, True)


# Modifikasi dictionary dalam nested tuple
t[1]['rank'] = 456
print(t)  # Output: ([1, 20, 3], {'nama': 'Petani Kode', 'rank': 456}, True)
```

 

Dalam contoh ini, meskipun kita tidak bisa mengubah elemen tuple `t` secara langsung, kita bisa mengubah elemen dalam list dan dictionary yang ada di dalam tuple.

Dengan memahami konsep dan penggunaan nested tuple, kita dapat memanfaatkan struktur data ini untuk membuat program yang lebih efisien dan terorganisir. Tuple yang berisi objek lain seperti list, dictionary, dan nilai boolean memungkinkan kita untuk menyimpan dan mengelola data yang kompleks dengan cara yang lebih terstruktur.

 

Sequence Unpacking

Proses pembuatan tuple disebut sebagai packing, di mana kita menggabungkan beberapa nilai menjadi satu objek tuple. Sebaliknya, unpacking adalah proses mengambil (mengekstrak) seluruh isinya dan menempatkan setiap elemen dalam variabel terpisah. Ini memungkinkan kita untuk dengan mudah memisahkan nilai yang tersimpan dalam satu tuple ke dalam beberapa variabel.

 

Contoh Packing dan Unpacking

Berikut adalah contoh bagaimana kita melakukan packing dan unpacking pada tuple:

 

```python
# Packing tuple
web = 123, "divisidev", "https://www.divisiev.com"


# Unpacking tuple
id_web, nama, url = web


# Mari kita cetak hasilnya
print(id_web)  # Output: 123
print(nama)    # Output: divisidev
print(url)     # Output: https://www.divisidev.com
```

 

Dalam contoh di atas, `web` adalah tuple yang berisi tiga elemen: sebuah integer, sebuah string, dan sebuah URL. Saat kita melakukan unpacking, kita mengekstrak setiap elemen dari tuple `web` dan menempatkannya dalam variabel `id_web`, `nama`, dan `url`.

 

Penjelasan Kode

1. Packing Tuple:

   

```python
   web = 123, "Divisidev", "https://www.divisidev.com"
   ```

   Di sini, kita membuat tuple `web` dengan tiga elemen. Ini adalah proses packing di mana beberapa nilai digabungkan menjadi satu tuple.

 

2. Unpacking Tuple:

   

```python
   id_web, nama, url = web
   ```

   Di sini, kita melakukan unpacking dengan mengekstrak nilai dari tuple `web` dan menempatkannya ke dalam variabel `id_web`, `nama`, dan `url`. Setelah unpacking, variabel-variabel ini akan berisi nilai yang sesuai dari tuple `web`.

 

3. Mencetak Nilai:

   

```python
   print(id_web)
   print(nama)
   print(url)
   ```

   Hasil dari mencetak variabel-variabel ini adalah nilai yang terdapat dalam tuple `web`.

 

Unpacking dengan Jumlah Variabel yang Sesuai

Unpacking harus dilakukan dengan jumlah variabel yang sesuai dengan jumlah elemen dalam tuple. Jika tidak, akan muncul error. Berikut adalah contoh yang benar dan salah dalam unpacking:

 

```python
# Unpacking yang benar
a, b, c = (1, 2, 3)
print(a, b, c)  # Output: 1 2 3


# Unpacking yang salah (akan menyebabkan ValueError)
# a, b = (1, 2, 3)
# print(a, b)
```

 

Unpacking dengan `*` Operator

Jika kita tidak mengetahui jumlah elemen dalam tuple atau ingin menempatkan sisa elemen ke dalam list, kita bisa menggunakan `*` operator:

 

```python
# Menggunakan * operator untuk sisa elemen
a, *b = (1, 2, 3, 4, 5)
print(a)  # Output: 1
print(b)  # Output: [2, 3, 4, 5]


# Menggunakan * operator di tengah
a, *b, c = (1, 2, 3, 4, 5)
print(a)  # Output: 1
print(b)  # Output: [2, 3, 4]
print(c)  # Output: 5
```

 

Dalam contoh di atas, `*b` menangkap semua elemen kecuali yang pertama dan terakhir. Ini adalah cara fleksibel untuk menangani tuple dengan jumlah elemen yang tidak diketahui atau bervariasi.

 

Contoh Lain Unpacking

Unpacking dapat digunakan dalam berbagai konteks, termasuk fungsi yang mengembalikan tuple, dan iterasi dalam loop:

 

```python
# Fungsi yang mengembalikan tuple
def get_point():
    return (10, 20)


x, y = get_point()
print(x, y)  # Output: 10 20


# Iterasi dengan unpacking dalam loop
points = [(1, 2), (3, 4), (5, 6)]
for x, y in points:
    print(x, y)
```

 

Dengan memahami dan memanfaatkan packing dan unpacking, kita bisa bekerja dengan data secara lebih efisien dan terstruktur, terutama saat menangani data yang dikelompokkan dalam tuple. Teknik ini sangat berguna dalam berbagai aplikasi pemrograman, mulai dari manipulasi data sederhana hingga implementasi algoritma kompleks.

Published on June 24, 2024
Last updated on June 03, 2026