Phyton 9 - Struktur Data Tuple

Phyton 9 - Struktur Data Tuple

Dalam dunia pemrograman, Python dikenal dengan berbagai struktur data yang kuat dan fleksibel, salah satunya adalah tuple. Tutorial ini akan membahas secara mendalam tentang struktur data tuple, yang merupakan salah satu elemen penting dalam pengembangan aplikasi Python. Tuple, dengan sifatnya yang tidak dapat diubah setelah diciptakan, memberikan keunggulan tersendiri dalam hal kinerja dan keamanan data. Dalam artikel ini, kita akan menjelajahi cara membuat, mengakses, dan memanipulasi tuple, serta membahas berbagai kegunaannya dalam pemrograman sehari-hari. Mari kita mulai memahami kekuatan dan fleksibilitas dari struktur data tuple dalam Python.

Cara Membuat Tuple di Python

Tuple adalah salah satu tipe data di Python yang digunakan untuk menyimpan sekumpulan item yang tidak dapat diubah setelah diciptakan. Ini membuat tuple menjadi pilihan yang tepat untuk menyimpan data yang harus tetap konsisten selama program berjalan. Ada beberapa cara untuk membuat tuple di Python, baik dengan menggunakan tanda kurung maupun tanpa tanda kurung. Berikut penjelasan mendalam mengenai kedua metode tersebut:

 

Menggunakan Tanda Kurung

Cara paling umum untuk membuat tuple adalah dengan menggunakan tanda kurung. Item-item yang ingin dimasukkan ke dalam tuple dipisahkan oleh koma di dalam tanda kurung. Contohnya:

 

```python
t = (1234, 4321, 'Hello')
```

 

Dalam contoh di atas, `t` adalah sebuah tuple yang berisi tiga elemen: dua bilangan bulat dan satu string. Tanda kurung memberikan kejelasan bahwa kita sedang mendefinisikan sebuah tuple.

 

Tanpa Tanda Kurung

Python juga memperbolehkan pembuatan tuple tanpa tanda kurung. Ini sering digunakan dalam konteks unpacking atau multiple assignment. Contohnya:

 

```python
t = 1234, 4321, 'World!'
```

 

Dalam contoh ini, `t` tetap menjadi sebuah tuple dengan tiga elemen yang sama seperti contoh sebelumnya. Python mengenali kumpulan nilai yang dipisahkan oleh koma sebagai sebuah tuple secara otomatis.

 

Tuple Tunggal

Jika ingin membuat tuple dengan hanya satu elemen, tanda kurung tetap diperlukan, tetapi kita juga harus menambahkan koma di akhir elemen untuk menghindari kebingungan dengan tanda kurung biasa. Contohnya:

 

```python
single_element_tuple = (1234,)
```

 

Tanpa koma, Python akan menganggap itu hanya sebuah ekspresi yang berada di dalam tanda kurung, bukan sebuah tuple.

 

Tuple Kosong

Tuple kosong juga dapat dibuat dengan menggunakan tanda kurung tanpa ada elemen di dalamnya:

 

```python
empty_tuple = ()
```

 

Fungsi `tuple()`

Selain metode-metode di atas, kita juga bisa menggunakan fungsi `tuple()` untuk membuat tuple dari iterables lain seperti list atau string:

 

```python
list_to_tuple = tuple([1, 2, 3])
string_to_tuple = tuple('abc')
```

 

Dalam contoh ini, `list_to_tuple` adalah tuple `(1, 2, 3)` yang dibuat dari list `[1, 2, 3]`, dan `string_to_tuple` adalah tuple `('a', 'b', 'c')` yang dibuat dari string `'abc'`.

Dengan memahami berbagai cara untuk membuat tuple di Python, kita bisa memilih metode yang paling sesuai dengan kebutuhan spesifik dalam program kita. Tuple menawarkan cara yang efisien dan aman untuk mengelola data yang tidak perlu diubah, sehingga sangat berguna dalam berbagai konteks pemrograman.

 

Baca Juga

• Struktur Data Dictionary
• Variasi Print

 

Mengakses Nilai Tuple

Sama seperti list, tuple juga memiliki indeks untuk mengakses item di dalamnya. Indeks tuple dan list selalu dimulai dari nol (0), yang berarti elemen pertama berada pada indeks 0, elemen kedua pada indeks 1, dan seterusnya. Berikut adalah beberapa cara untuk mengakses nilai dalam sebuah tuple di Python.

 

Indeks Positif

Untuk mengakses elemen tertentu dalam tuple, kita bisa menggunakan indeks positif. Berikut adalah contohnya:

 

```python
# membuat tuple
nama = ('divisidev', 'kode', 'linux')


# mengakses nilai tuple
print(nama[1])  # Output: kode
```

 

Dalam contoh di atas, `nama[1]` mengakses elemen kedua dari tuple `nama`, yaitu `'kode'`. Ingat bahwa indeks dimulai dari 0, sehingga `nama[0]` adalah `'divisidev'`, `nama[1]` adalah `'kode'`, dan `nama[2]` adalah `'linux'`.

 

Indeks Negatif

Python juga memungkinkan penggunaan indeks negatif untuk mengakses elemen dari belakang tuple. Indeks negatif dimulai dari -1 untuk elemen terakhir. Berikut contohnya:

 

```python
# mengakses nilai tuple dengan indeks negatif
print(nama[-1])  # Output: linux
```

 

Dalam contoh ini, `nama[-1]` mengakses elemen terakhir dari tuple `nama`, yaitu `'linux'`.

 

Mengakses Subtuple (Slicing)

Kita juga dapat mengakses sebagian dari tuple dengan menggunakan slicing. Slicing memungkinkan kita untuk mendapatkan subtuple dari tuple asli. Berikut adalah contoh penggunaan slicing:

 

```python
# mengakses subtuple
print(nama[0:2])  # Output: ('divisidev', 'kode')
```

 

Dalam contoh ini, `nama[0:2]` mengakses elemen mulai dari indeks 0 hingga (tetapi tidak termasuk) indeks 2, menghasilkan subtuple `('divisidev', 'kode')`.

 

Menggunakan Fungsi `len()`

Untuk mengetahui panjang tuple atau berapa banyak elemen yang ada di dalamnya, kita bisa menggunakan fungsi `len()`:

 

```python
# mendapatkan panjang tuple
print(len(nama))  # Output: 3
```

 

Dalam contoh ini, `len(nama)` mengembalikan nilai 3, yang merupakan jumlah elemen dalam tuple `nama`.

 

Menggunakan Loop

Kita juga dapat menggunakan loop untuk mengakses setiap elemen dalam tuple secara berurutan:

 

```python
# mengakses nilai tuple menggunakan loop
for item in nama:
    print(item)
```

 

Output dari loop ini adalah:

 

```
divisidev
kode
linux
```

 

Dengan berbagai cara untuk mengakses nilai dalam tuple, kita memiliki fleksibilitas untuk bekerja dengan data di dalamnya sesuai kebutuhan. Apakah kita membutuhkan akses langsung ke elemen tertentu, sebagian elemen, atau iterasi melalui seluruh elemen, Python menyediakan alat yang efisien dan mudah digunakan.

 

Memotong Tuple (Slicing)

Sama seperti list, di dalam tuple juga kita bisa melakukan slicing untuk mengakses sebagian elemen dari tuple. Slicing memungkinkan kita untuk membuat subtuple dari tuple asli berdasarkan indeks yang ditentukan. Berikut adalah penjelasan dan contoh cara melakukan slicing pada tuple.

 

Slicing Dasar

Slicing dilakukan dengan menggunakan tanda titik dua `:` di dalam tanda kurung siku `[]`. Format dasarnya adalah `tuple[start:end]`, di mana `start` adalah indeks awal (termasuk) dan `end` adalah indeks akhir (tidak termasuk). Berikut adalah contohnya:

 

```python
# mula-mula kita punya tuple seperti ini
web = (123, 'divisidev Kode', 'https://www.divisidev.com')


# lalu kita ingin potong agar ditampilkan
# dari indeks nomor 1 sampai 2
print(web[1:2])  # Output: ('divisidev Kode',)
```

 

Dalam contoh di atas, `web[1:2]` mengakses elemen mulai dari indeks 1 hingga tetapi tidak termasuk indeks 2. Hasilnya adalah subtuple `('divisidev Kode',)`.

 

Slicing dengan Indeks Negatif

Kita juga bisa menggunakan indeks negatif untuk melakukan slicing, yang memungkinkan kita untuk memotong tuple dari akhir:

 

```python
# slicing menggunakan indeks negatif
print(web[-2:])  # Output: ('divisidev Kode', 'https://www.divisidev.com')
```

 

Dalam contoh ini, `web[-2:]` memotong tuple mulai dari indeks -2 (elemen kedua dari belakang) hingga akhir tuple, menghasilkan subtuple `('divisidev Kode', 'https://www.divisidev.com')`.

 

Slicing dengan Langkah (Step)

Selain `start` dan `end`, kita juga bisa menambahkan parameter `step` untuk menentukan interval elemen yang diambil. Formatnya adalah `tuple[start:end:step]`:

 

```python
# slicing dengan langkah (step)
numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
print(numbers[1:8:2])  # Output: (1, 3, 5, 7)
```

 

Dalam contoh di atas, `numbers[1:8:2]` mengakses elemen mulai dari indeks 1 hingga tetapi tidak termasuk indeks 8, dengan langkah 2. Hasilnya adalah subtuple `(1, 3, 5, 7)`.

 

Slicing Tanpa Indeks Awal atau Akhir

Kita juga bisa menghilangkan `start` atau `end` dalam slicing untuk memotong dari awal hingga titik tertentu, atau dari titik tertentu hingga akhir:

 

```python
# slicing dari awal hingga indeks tertentu
print(web[:2])  # Output: (123, 'divisidev Kode')


# slicing dari indeks tertentu hingga akhir
print(web[1:])  # Output: ('divisidev Kode', 'https://www.divisidev.com')
```

 

Dalam contoh pertama, `web[:2]` memotong tuple dari awal hingga tetapi tidak termasuk indeks 2. Dalam contoh kedua, `web[1:]` memotong tuple mulai dari indeks 1 hingga akhir.

 

Slicing Keseluruhan Tuple

Kita juga bisa melakukan slicing untuk mendapatkan seluruh isi tuple, yang berguna saat kita ingin membuat salinan tuple:

 

```python
# slicing keseluruhan tuple
print(web[:])  # Output: (123, 'divisidev Kode', 'https://www.divisidev.com')
```

 

Dengan memahami berbagai teknik slicing ini, kita dapat dengan mudah mengakses dan memanipulasi bagian-bagian tertentu dari tuple sesuai kebutuhan, memberikan fleksibilitas dan kontrol lebih dalam pemrograman menggunakan Python.

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