Belajar Tipe Data Tuple di Python

Pengenalan Tuple

Tuple merupakan salah satu tipe data berurut selain list dan string. Ia juga termasuk anggota struktur data, karena dapat menyimpan banyak data sekaligus secara terstruktur.

Cara Membuat Tuple

Untuk membuat tuple ada dua cara, cara pertama menggunakan tanda kurung, sedangkan cara kedua tanpa tanda kurung.

>>> # Menggunakan tanda kurung
... angka = (0, 1, 2, 3, 4, 5)
>>> type(angka)
<class 'tuple'>

>>> # Tanpa menggunakan tanda kurung
... angka = 0, 1, 2, 3, 4, 5
>>> type(angka)
<class 'tuple'>

Jika kita perhatikan untuk cara kedua (tanpa tanda kurung) tampak sedikit aneh, karena jika dibandingkan dengan struktur data lain seperti list, set, dan dictionary pada pendeklarasiannya menggunakan tanda kurung.

Tapi meskipun begitu untuk kasus di atas sepertinya tidak ada masalah selama python menganggapnya valid.

Hanya saja masalah ini akan menjadi berakibat fatal ketika kita ingin mendeklarasikan tuple tanpa satu pun anggota di dalamnya (kosong), maka penggunaan tanda kurung wajib hukumnya di sini.

>>> tuple_ = ()
>>> type(tuple)
<class 'tuple'>

Karena jika tanpa tanda kurung maka python akan menganggap hal itu sebagai kesalahan sintaks.

>>> tuple_ = 
  File "", line 1
    tuple = 
           ^
SyntaxError: invalid syntax

Selain deklarasi tuple dengan anggota kosong, kita juga perlu perhatikan ketika mendeklarasikan tuple dengan hanya satu anggota, seperti contoh di bawah ini

>>> angka = (1)
>>> type(angka)
<class 'int'>

>>> angka = 1
>>> type(angka)
<class 'int'>

Meskipun sudah diberi tanda kurung, python lantas tidak langsung menganggapnya sebagai tuple, alih-alih malah menganggapnya sebagai proses pembuatan variabel (seperti cara kedua), jadi ketika dicek tipe data anggotanya, maka akan keluar tipe data integer (untuk contoh kasus di atas).

Maka dari itu untuk mengatasi masalah ini, perlu ditambahkannya tanda koma di akhir anggota yang bersangkutan.

>>> angka = (1,)
>>> type(tuple)
<class 'tuple'>

>>> angka = 1,
>>> type(angka)
<class 'tuple'>

Macam Anggota Tuple

Sebelum masuk ke situ, saya ingin jelaskan sedikit bahwa penyebutan isi dalam tuple bisa kalian sebut sebagai data, item, elemen, atau anggota. Kalau saya lebih suka menyebutnya anggota.

Lanjut, anggota tuple dapat terdiri dari semua tipe data, dan dalam satu rangkaiannya bisa terdiri dari tipe yang sama atau bahkan campuran dari berbagai tipe. Untuk mengetahui bagaimana tuple bekerja dengan anggota dalam berbagai tipe kita akan ulas satu-satu di bawah ini.

Tuple Beranggotakan Tipe Data Numerik

Terdapat tiga tipe yang termasuk ke dalam tipe data numerik, antara lain integer, float, dan complex. Ketiganya dapat menjadi anggota tuple

>>> # Tuple Beranggotakan bilangan bulat (integer) 
... bulat = (1, 2, 3, 4, 5) 
>>> bulat 
(1, 2, 3, 4, 5) 

>>> # Tuple Beranggotakan bilangan desimal (float) 
... desimal = (1.0, 2.0, 3.0, 4.0, 5.0) 
>>> desimal 
(1.0, 2.0, 3.0, 4.0, 5.0) 

>>> # Tuple Beranggotakan bilangan kompleks (complex) 
... kompleks = (1j, 2j, 3j, 4j, 5j) 
>>> kompleks 
(1j, 2j, 3j, 4j, 5j)

Tuple Beranggotakan Tipe Data String

Tipe data string atau tipe data teks juga dapat menjadi anggota tuple, meskipun kita tahu bahwa tipe data ini juga termasuk ke dalam tipe data berurut

>>> teks = ("Ani", "Budi", "Cita", "Dika", "Ega") 
>>> teks 
('Ani', 'Budi', 'Cita', 'Dika', 'Ega')

Tuple Beranggotakan Tipe Data Boolean

Tipe data boolean terdiri dari dua nilai, True dan False. Meskipun hanya terdiri dari dua nilai, tipe data ini juga dapat menjadi anggota tuple

>>> boolean = (True, False, True, False) 
>>> boolean 
(True, False, True, False)

Tuple Beranggotakan Tipe Data Berurut

Selain string yang sudah disebutkan sebelumnya, keanggotaan tuple juga dapat terdiri dari saudaranya sendiri seperti list.

>>> list_ = ([1, 2, 3], [4, 5, 6], [7, 8, 9]) 
>>> list_ 
([1, 2, 3], [4, 5, 6], [7, 8, 9])

Bahkan juga dapat berisi dirinya sendiri (tuple), hal ini dikenal dengan sebutan nested tuple atau tuple bersarang.

>>> tuple_ = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
>>> tuple_
((1, 2, 3), (4, 5, 6), (7, 8, 9))

Tuple Beranggotakan Tipe Data Set

Set merupakan tipe data yang tidak memiliki indeks, namun meskipun begitu ia juga dapat menjadi anggota tuple.

>>> set_ = ({1, 2, 3}, {4, 5, 6}, {7, 8, 9})
>>> set_
({1, 2, 3}, {4, 5, 6}, {8, 9, 7})

Tuple Beranggotakan Tipe Data Dictionary

Tipe data yang terdiri dari key dan value ini bisa juga dimasukkan ke dalam anggota tuple.

>>> dictionary = ({1: 'A', 2:'B', 3:'C'}, {4:'D', 5:'E', 6:'F'})
>>> dictionary
({1: 'A', 2: 'B', 3: 'C'}, {4: 'D', 5: 'E', 6: 'F'})

Cara Mengakses Tuple

Cara mengakses tuple sama dengan tipe data berurut lainnya. Maksud dari mengakses di sini mencakup cara kita dalam menampilkan, mengambil atau mendapatkan anggota dari tipe data berurut. Sebelum memulai belajar mengakses anggota tipe data berurut, kita diharapkan mengerti tentang pengindeksan. Jika tidak, kita akan kebingungan.

Indeks merupakan angka yang mewakili tiap anggota tipe data berurut, baik itu string, list, atau tuple. Indeks mereka bertiga dimulai dari nol bukan satu. Kemudian ada juga istilah panjang tipe data berurut, hal ini merujuk pada jumlah anggotanya.

Kembali lagi untuk cara atau teknik dalam mengakses anggota tuple, terdapat tiga cara di sini antara lain:

• Cara manual
• Teknik Slicing
• Menggunakan Perulangan

Selanjutnya ketiga cara ini akan kita praktekan satu-satu

Cara Manual

Cara manual di sini maksudnya, kita mengakses anggota tuple secara individu atau satu persatu secara manual. Untuk menerapkan cara ini, kita memerlukan nama variabel yang bersangkutan diikuti dengan tanda kurung siku. Nah, di dalam kurung siku inilah indeks setiap anggota diletakkan. Lebih jelasnya lihat rumus berikut.

>>> nama_variabel[indeks]

Untuk penerapan kodenya sebagai berikut.

>>> siswa = ("Ani", "Budi", "Cita", "Dika", "Ega") 
>>> siswa[0]
'Ani'
>>> siswa[4]
'Ega'

Gunakan angka negatif untuk mendapatkan anggota tuple dari urutan belakang.

>>> siswa = ("Ani", "Budi", "Cita", "Dika", "Ega") 
>>> siswa[-1]
'Ega'

Dengan cara manual ini juga kita dapat mengetahui masing-masing nilai anggota berurut.

>>> tuple_ = (1, 1.0, 1j, "satu", True, [1, 2], (1, 2), {1, 2}, {1:"satu"})
>>> type(tuple_[0]); type(tuple_[1]); type(tuple_[2]); type(tuple_[3]); type(tuple_[4]); type(tuple_[5]); type(tuple_[6]); type(tuple_[7]); type(tuple_[8])

<class 'int'>
<class 'float'>
<class 'complex'>
<class 'str'>
<class 'bool'>
<class 'list'>
<class 'tuple'>
<class 'set'>
<class 'dict'>

Teknik Slicing

Kedua dengan cara atau teknik slicing. Dengan cara ini memungkinkan kita untuk mendapatkan lebih dari satu anggota secara berurut dengan rentang yang kita tentukan sendiri. Nantinya kita akan membutuhkan dua parameter berupa indeks awal yang berarti dari indeks ke berapa data tersebut didapatkan dan indeks akhir yang berarti sampai indeks ke berapa data tersebut didapatkan.

>>> nama_variabel[indeks_awal : indeks_akhir]

Lalu, dalam penerapan kodenya sama seperti cara manual, kita akan membutuhkan tanda kurung siku, yang membedakan adalah di dalam kurung siku nanti akan ada tanda titik dua yang digunakan sebagai pemisah kedua parameter (indeks awal dan akhir) tersebut atau dapat juga diartikan sebagai rentang dari indeks awal sampai indeks akhir.

>>> siswa = ("Ani", "Budi", "Cita", "Dika", "Ega")
>>> siswa[1:3]
('Budi', 'Cita')

Perhatikan di sini, meskipun kita tetapkan indeks akhir atau batas dalam pengambilan data adalah indeks ketiga pada kenyataannya data yang didapatkan hanya sampai indeks kedua. Jadi indeks ketiga tidak termasuk.

Selanjutnya kita juga dapat mengosongi parameter indeks awal, bila anggota yang ingin didapatkan dimulai dari indeks 0.

>>> siswa = ("Ani", "Budi", "Cita", "Dika", "Ega") 
>>> siswa[:4]
('Ani', 'Budi', 'Cita', 'Dika')

Sedangkan bila parameter indeks akhir yang kosong, berarti indeks yang akan kita ambil dimulai dari indeks awal yang kita tentukan sampai indeks akhir dari tuple itu sendiri.

>>> siswa = ("Ani", "Budi", "Cita", "Dika", "Ega")
>>> siswa[1:]
('Budi', 'Cita', 'Dika', 'Ega')

Jika keduanya kosong? Ya tentu akan menampilkan seluruh anggota tuple tersebut dari indeks ke-0 sampai indeks ke-n.

>>> siswa = ("Ani", "Budi", "Cita", "Dika", "Ega")
>>> siswa[:]
('Ani', 'Budi', 'Cita', 'Dika', 'Ega')

Menggunakan Perulangan

Tipe data tuple merupakan salah satu objek iterator. Objek iterator sendiri merupakan objek yang dapat melakukan aktivitas secara berulang, yang mana kita dapat menggunakan perulangan untuk mengakses anggotanya.

>>> siswa = ("Ani", "Budi", "Cita", "Dika", "Ega") 
>>> for i in siswa:
...  print(i)
... 
Ani
Budi
Cita
Dika
Ega

Berikut contoh lain penggunaan perulangan untuk menampilkan tiap tipe data anggota tuple.

>>> tuple_ = (1, 1.0, 1j, "satu", True, [1, 2], (1, 2), {1, 2}, {1:"satu"})
>>> for i in tuple_:
...  print(type(i))
... 
<class 'int'>
<class 'float'>
<class 'complex'>
<class 'str'>
<class 'bool'>
<class 'list'>
<class 'tuple'>
<class 'set'>
<class 'dict'>

Ekstrak Tuple

Ekstrak tuple atau juga bisa disebut unpacking tuple merupakan proses untuk mengambil seluruh anggota di dalam suatu tuple. Sedangkan untuk proses pembuatannya dapat disebut packing.

>>> # Proses Packing
... data = (1, "Ani", 20, "Surabaya")
 
>>> # Proses Unpacking
... absen, nama, umur, asal = data
>>> absen
1
>>> nama
'Ani'
>>> umur
20
>>> asal
'Surabaya'

Pada kode tersebut variabel data yang merupakan tuple dengan anggota di dalamnya yang beragam ‘membagikan’ setiap anggotanya kepada variabel lain secara berurutan. Variabel absen mendapat data pada indeks ke-0, bergeser ke kanan variabel nama mendapat data indeks ke-1, dan seterusnya.

Tuple Bersifat Immutable

Immutable artinya data di dalam tuple tidak dapat diubah. Sifat immutable ini juga dimiliki oleh string.

>>> # Immutable pada Tuple 
... siswa = ("Ani", "Budi", "Cita", "Dika", "Ega")
>>> siswa[2] = "Fani"
Traceback (most recent call last):
  File "", line 1, in 
TypeError: 'tuple' object does not support item assignment

>>> # Immutable pada String
... angka = "012345"
>>> angka[2] = "9"
Traceback (most recent call last):
  File "", line 1, in 
TypeError: 'str' object does not support item assignment

Lawannya adalah mutable (bisa diubah) seperti list.

>>> siswa = ["Ani", "Budi", "Cita", "Dika", "Ega"]
>>> siswa[2] = "Fani"
>>> siswa
['Ani', 'Budi', 'Fani', 'Dika', 'Ega']

Berbagai Fungsi Dalam Tuple

Karena bersifat immutable maka fungsi pengoperasian seperti append(), remove(), insert(), dan lain-lain tidak bisa diterapkan pada tuple, berbeda dengan list yang bersifat mutable yang mana ia dapat memiliki atribut untuk melakukan itu..

Namun meskipun begitu kita masih bisa mencari informasi dari suatu objek bertipe tuple dengan fungsi-fungsi umum untuk tipe data berurut.

Mendapatkan Anggota Dengan Nilai Terendah dan Tertinggi

Untuk mendapatkan anggota dengan nilai terendah dan tertinggi dari suatu tuple kita dapat gunakan fungsi min() dan max().

>>> angka = (2, 5, 1, 4, 3)
>>> min(angka)
1
>>> max(angka)
5

Fungsi min() dan max() juga bisa diterapkan pada data bertipe string.

>>> siswa = ("Citra", "Gilang", "Ani", "Erika", "Budi", "Fani", "Denis")
>>> min(siswa)
'Ani'
>>> max(siswa)
'Gilang'

Mendapatkan Panjang Tuple

Sekali lagi maksud dari panjang tuple ini merujuk ke jumlah anggota dalam suatu tuple, untuk mengetahui panjang atau berapa banyak jumlah anggota dalam tuple ini kita gunakan fungsi len().

>>> siswa = ("Citra", "Gilang", "Ani", "Erika", "Budi", "Fani", "Denis")
>>> len(siswa)
7

Konversi Tipe Data Tuple

Python juga membuat sebuah fungsi yaitu tuple() untuk mengkonversi suatu objek iterasi ke dalam bentuk tuple. Objek iterasi sendiri merupakan sebuah objek yang dapat melakukan hal yang berulang dalam satu rangkaian. Mereka mencakup keluarga tipe data berurut seperti string dan list serta anggota struktur data lainnya seperti dictionary dan set.

>>> # Fungsi tuple() pada List
... angka = [1, 2, 3, 4, 5]
>>> tuple(angka)
(1, 2, 3, 4, 5)

>>> # Fungsi tuple() pada String
... sekolah = "Sekolah Kopi"
>>> tuple(sekolah)
('S', 'e', 'k', 'o', 'l', 'a', 'h', ' ', 'K', 'o', 'p', 'i')

>>> # Fungsi tuple() pada Set
... siswa = {"Ani", "Budi", "Cika", "Denis", "Erika"}
>>> tuple(siswa)
('Budi', 'Denis', 'Cika', 'Erika', 'Ani')

>>> # Fungsi tuple() pada Dictionary
... absensi = {1:"Ani", 2:"Budi", 3:"Cika", 4:"Denis", 5:"Erika"} 
>>> tuple(absensi)
(1, 2, 3, 4, 5)

Sedangkan jika kita tetap memaksa untuk menggunakan objek non-iterasi, maka akan menimbulkan error.

>>> #Objek iterasi 
... angka = tuple([1])
>>> angka
(1,)

>>> # Objek non-iterasi
... angka = tuple(1)
Traceback (most recent call last):
  File "", line 1, in 
TypeError: 'int' object is not iterable

Fungsi tuple() hanya membutuhkan satu parameter yaitu objek iterasi itu sendiri dan ini juga bersifat opsional. Dengan kata lain kita juga bisa mendeklarasikannya dengan nilai kosong.

>>> angka = tuple()
>>> angka
()