Tutorial Tuple Python

Tuple versus List

Seperti yang mungkin Anda perhatikan, tuple sangat mirip dengan list. Faktanya, Anda bisa mengatakan bahwa tuple adalah list yang immutable, yang berarti setelah sebuah tuple dibuat Anda tidak dapat menghapus atau mengubah nilai dari item yang disimpan di dalamnya. Anda juga tidak dapat menambahkan nilai baru. Perhatikan ini:

numbers_tuple = (1,2,3,4,5)
numbers_list = [1,2,3,4,5]

# Append a number to the tuple
numbers_tuple.append(6)

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-26-e47776d745ce> in <module>()
      3 
      4 # Append a number to the tuple
----> 5 numbers_tuple.append(6)


AttributeError: 'tuple' object has no attribute 'append'

Ini menghasilkan error karena Anda tidak dapat menghapus dari atau menambahkan ke tuple, tetapi Anda bisa melakukannya pada list.

# Append numbers to the list
numbers_list.append(6)
numbers_list.append(7)
numbers_list.append(8)

# Remove a number from the list
numbers_list.remove(7)
print(numbers_list)

[1, 2, 3, 4, 5, 6, 8]

Tapi mengapa Anda menggunakan tuple jika mereka immutable?

Tidak hanya menyediakan akses "read-only" ke nilai data, tuple juga lebih cepat daripada list. Pertimbangkan potongan kode berikut:

import timeit
timeit.timeit('x=(1,2,3,4,5,6,7,8,9)', number=100000)

0.0018976779974764213

timeit.timeit('x=[1,2,3,4,5,6,7,8,9]', number=100000)

0.019868606992531568

Apa sebenarnya arti immutable terkait dengan tuple?

Menurut dokumentasi resmi Python, immutable adalah 'objek dengan nilai tetap', tetapi 'nilai' adalah istilah yang agak samar, istilah yang lebih tepat untuk tuple adalah 'id'. 'id' adalah identitas lokasi suatu objek di memori.

Mari kita lihat lebih mendalam:

# Tuple 'n_tuple' dengan sebuah list sebagai salah satu itemnya.
n_tuple = (1, 1, [3,4])

#Item dengan nilai yang sama memiliki id yang sama.
id(n_tuple[0]) == id(n_tuple[1])

True

#Item dengan nilai berbeda memiliki id yang berbeda.
id(n_tuple[0]) == id(n_tuple[2])

False

id(n_tuple[0])

4297148528

id(n_tuple[2])

4359711048

n_tuple.append(5)

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-40-3cd258e024ff> in <module>()
----> 1 n_tuple.append(5)


AttributeError: 'tuple' object has no attribute 'append'

Kita tidak bisa menambahkan item ke tuple, itulah sebabnya Anda mendapatkan error di atas. Inilah mengapa tuple disebut immutable. Namun, Anda selalu bisa melakukan ini:

n_tuple[2].append(5)
n_tuple

(1, 1, [3, 4, 5])

Dengan demikian, Anda sebenarnya memodifikasi tuple asli. Lalu mengapa tuple masih disebut immutable?

Ini karena id dari list di dalam tuple tetap sama meskipun Anda menambahkan 5 ke dalamnya.

id(n_tuple[2])

4359711048

Merangkum apa yang telah Anda pelajari sejauh ini:

Beberapa tuple (yang hanya berisi objek immutable: string, dll.) bersifat immutable dan beberapa tuple lain (yang berisi satu atau lebih objek mutable: list, dll.) bersifat mutable. Namun, ini sering menjadi topik perdebatan di kalangan Pythonista dan Anda memerlukan latar belakang pengetahuan lebih untuk memahaminya sepenuhnya. Artikel ini membahasnya lebih dalam. Untuk saat ini, mari katakan saja tuple secara umum dianggap immutable.

• Anda tidak bisa menambahkan elemen ke tuple karena sifatnya yang immutable. Tidak ada metode append() atau extend() untuk tuple,
• Anda tidak bisa menghapus elemen dari tuple, juga karena immutabilitasnya. Tuple tidak memiliki metode remove() atau pop(),
• Anda dapat mencari elemen dalam tuple karena hal ini tidak mengubah tuple.
• Anda juga dapat menggunakan operator in untuk memeriksa apakah sebuah elemen ada dalam tuple.

Jadi, jika Anda mendefinisikan sekumpulan nilai konstan dan yang akan Anda lakukan hanyalah mengiterasinya, gunakan tuple alih-alih list. Ini akan lebih cepat daripada bekerja dengan list dan juga lebih aman, karena tuple berisi data yang "tulis-dilindungi".

Jika Anda ingin mengetahui lebih lanjut tentang list di Python, pastikan untuk melihat tutorial ini!

Operasi Tuple yang Umum

Python menyediakan sejumlah cara untuk memanipulasi tuple. Mari kita lihat beberapa yang penting beserta contohnya.

Tuple Slicing

Nilai pertama dalam tuple diindeks 0. Sama seperti pada list Python, Anda dapat menggunakan nilai indeks bersama tanda kurung siku [] untuk mengakses item dalam sebuah tuple:

numbers = (0,1,2,3,4,5)
numbers[0]

0

Anda juga dapat menggunakan indeks negatif pada tuple:

numbers[-1]

5

Sementara indexing digunakan untuk mendapatkan item tertentu, slicing memungkinkan Anda memperoleh subset item. Saat Anda memasukkan rentang yang ingin diekstrak, ini disebut range slicing. Format umum range slicing adalah:

[Start index (included):Stop index (excluded):Increment]

Di sini Increment adalah parameter opsional, dan secara default nilainya 1.

# Item pada indeks 4 tidak disertakan
numbers[1:4]

(1, 2, 3)

# Ini memberikan semua item dalam tuple
numbers[:]

(0, 1, 2, 3, 4, 5)

# Increment = 2
numbers[::2]

(0, 2, 4)

Tip: Anda juga dapat menggunakan nilai increment negatif untuk membalik urutan tuple.

numbers[::-1]

(5, 4, 3, 2, 1, 0)

Penjumlahan Tuple

Anda dapat menggabungkan tuple untuk membentuk tuple baru. Operasi penjumlahan pada tuple pada dasarnya melakukan penggabungan (concatenation).

x = (1,2,3,4)
y = (5,6,7,8)

# Menggabungkan dua tuple menjadi tuple baru
z = x + y 

print(z)

(1, 2, 3, 4, 5, 6, 7, 8)

y = [5,6,7,8]
z = x + y
print(z)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-55-d352c6414a4c> in <module>()
      1 y = [5,6,7,8]
----> 2 z = x + y
      3 print(z)


TypeError: can only concatenate tuple (not "list") to tuple

Anda hanya dapat menambahkan atau menggabungkan tipe data yang sama. Maka dari itu, menggabungkan tuple dan list akan menghasilkan error.

Perkalian Tuple

Operasi perkalian menghasilkan pengulangan isi tuple.

x = (1,2,3,4)
z = x*2
print(z)

(1, 2, 3, 4, 1, 2, 3, 4)

Fungsi Tuple

Tidak seperti list di Python, tuple tidak memiliki metode seperti append(), remove(), extend(), insert() dan pop() karena sifatnya yang immutable. Namun, ada banyak metode bawaan lain untuk bekerja dengan tuple:

count() dan len()

count() mengembalikan jumlah kemunculan suatu item dalam tuple.

a = [1,2,3,4,5,5]
a.count(5)

2

Dengan fungsi len(), Anda dapat mengembalikan panjang tuple:

a = (1,2,3,4,5)
print(len(a))

5

any()

Anda dapat menggunakan any() untuk mengetahui apakah ada elemen dari sebuah tuple yang bersifat iterable. Anda akan mendapatkan True jika demikian, jika tidak maka akan mengembalikan False.

a = (1,)
print(any(a))

True

Perhatikan tanda , pada deklarasi tuple a di atas. Jika Anda tidak menuliskan koma saat menginisialisasi satu item dalam tuple, Python menganggap Anda secara keliru menambahkan sepasang tanda kurung ekstra (yang tidak berbahaya) namun tipe datanya bukan tuple. Jadi ingat untuk menambahkan koma saat mendeklarasikan satu item dalam tuple.

Kembali ke fungsi any(): Dalam konteks boolean, nilai sebuah item tidak relevan. Tuple kosong bernilai false, tuple mana pun dengan setidaknya satu item bernilai true.

b = ()
print(any(b))

False

Fungsi ini mungkin berguna saat Anda memanggil sebuah tuple di suatu bagian program dan ingin memastikan bahwa tuple tersebut terisi.

tuple()

Gunakan tuple() untuk mengonversi suatu tipe data menjadi tuple. Misalnya, pada cuplikan kode di bawah, Anda mengonversi list Python menjadi tuple.

a_list = [1,2,3,4,5]
b_tuple = tuple(a_list)
print(type(b_tuple))

<class 'tuple'>

min() dan max()

Sementara max() mengembalikan elemen terbesar dalam tuple, Anda dapat menggunakan min() untuk mengembalikan elemen terkecil dari tuple. Pertimbangkan contoh berikut:

print(max(a))
print(min(a))

5
A

Anda juga dapat menggunakannya pada tuple yang berisi tipe data string.

# String 'Apple' secara otomatis dikonversi menjadi urutan karakter. 
a = ('Apple') 
print(max(a))

p

sum()

Dengan fungsi ini, Anda mengembalikan jumlah total item dalam tuple. Ini hanya dapat digunakan dengan nilai numerik.

sum(a)

28

sorted()

Untuk mengembalikan tuple dengan elemen dalam urutan yang terurut, gunakan sorted(), seperti pada contoh berikut:

a = (6,7,4,2,1,5,3)
sorted(a)

[1, 2, 3, 4, 5, 6, 7]

Perlu dicatat bahwa tipe nilai kembalian adalah list, bukan tuple. Urutan pada tuple asli 'a' tidak berubah dan tipe data 'a' tetap tuple.

Bonus: Mengatribusikan Banyak Nilai

Hal menarik yang dapat Anda lakukan dengan tuple adalah menggunakannya untuk mengatribusikan banyak nilai sekaligus. Perhatikan ini:

a = (1,2,3)
(one,two,three) = a
print(one)

1

a adalah sebuah tuple berisi tiga elemen dan (one,two,three) adalah tuple yang berisi tiga variabel. Memberi atribusi (one,two,three) ke tuple a akan menetapkan masing-masing nilai dari a ke setiap variabel: one, two, dan three, secara berurutan. Ini bisa berguna ketika Anda harus mengatribusikan serangkaian nilai ke sebuah urutan yang disimpan dalam tuple.

Selamat!

Anda telah sampai di akhir tutorial tuple ini! Sepanjang jalan, Anda telah mempelajari lebih lanjut tentang apa itu tuple Python, bagaimana cara menginisialisasinya, operasi umum apa saja yang dapat Anda lakukan untuk memanipulasinya, dan metode umum apa saja yang perlu diketahui agar Anda bisa mendapatkan lebih banyak wawasan dari struktur data Python ini. Sebagai bonus, Anda juga mempelajari bahwa Anda dapat mengatribusikan banyak nilai ke tuple sekaligus.