Contents

Modul 8: Tipe Data Terstruktur

Chapter ini akan membahas beberapa struktur data built-in dari Python. Namun struktur data serupa juga ada di berbagai bahasa pemrograman lainnya dengan nama yang mungkin berbeda. Sebelumnya kita telah mengenal dan menggunakan data yang bersifat Primitif, yang bisa diartikan sederhana, yaitu int, float, string, boolean. Tipe data tersebut hanya menyimpan satu buah nilai saja. Sedangkan pada pemrograman, banyak sekali kebutuhan untuk menyimpan dan memanipulasi sejumlah data. Untuk itu, sekarang kita akan membahas struktur data, yang artinya tipe data yang dapat menyimpan banyak nilai dan memiliki struktur tertentu. Salah satu yang pernah kita gunakan adalah list, pada saat membahas for. Di chapter ini kita akan membahas lebih dalam beserta jenis lainnya yaitu tuple, set, dan dictionary.

List

Berikut adalah karakteristik tipe data List.

  • List dapat menyimpan elemen dengan tipe data berbeda-beda

  • List mempunyai index(posisi), sehingga elemen tersimpan terurut berdasarkan index

  • List dan elemen list bersifat mutable, artinya list dapat diubah (ditambah, dikurangi), dan elemennya dapat diganti

  • Elemen list boleh redundan (ada beberapa elemen yang sama)

Membuat List

Untuk membuat sebuah list baru di Python, kita cukup menggunakan tanda buka dan tutup kurung siku [] atau list(). Jika list baru memiliki elemen, nilainya diletakkan di dalam kurung tersebut dan antar elemen list dipisahkan dengan koma.

my_list1 = [] # list kosong

my_list2 = [1, 2, 3, 3] # list berisi integer

my_list3 = [True, 2, 'Tiga'] # list berisi nilai dengan berbeda type

my_list4 = [[90, 90], [100, 90]] # list berisi list lain

my_list5 = list([1, 2, 3])


print(my_list1)
print(my_list2)
print(my_list3)
print(my_list4)
print(my_list5)

[]
[1, 2, 3, 3]
[True, 2, 'Tiga']
[[90, 90], [100, 90]]
[1, 2, 3]

Mengakses Elemen List

Akses dengan Index (<my_list>[<index>])

Untuk mengakses nilai pada elemen list, kita bisa menggunakan [<index>]. Index pada Python dimulai dari 0.

print(my_list2[2]) # mengakses elemen ke-3, yaitu integer 3
print(my_list3[0]) # mengakses elemen ke-1, yaitu boolean True
print(my_list4[0]) # mengakses elemen ke-1, yaitu list berisi [90, 90]
print(my_list4[1][0]) # mengakses elemen ke-1 dari elemen ke-2 my_list ([100, 90]), yaitu integer 100

3
True
[90, 90]
100

Akses dengan Index Negatif

Python juga menyediakan cara untuk mengakses dari elemen terakhir pada list, yaitu melalui index bernilai negatif. Elemen terakhir bisa diakses melalui [-1], elemen kedua terakhir diakses dengan [-2], dan seterusnya.

Perhatikan, agar berbeda dengan akses dari depan, di mana dimulai dari 0, akses dari belakang tidak dimulai dari -0, tetapi -1.

print(my_list2[-1]) # mengakses elemen terakhir, yaitu integer 3
print(my_list3[-3]) # mengakses elemen ke-3 dari terakhir, yaitu boolean True

3
True

Error pada Akses List

Beberapa error yang bisa dijumpai pada saat akses elemen list adalah:

  • list belum dibuat

  • index list melebihi jumlah elemen pada list

  • index bukan integer

try:
    my_list6[0] # my_list5 belum ada
# ini adalah cara untuk menangkap exception, lalu di aliaskan dengan variable e, 
# sehingga kita bisa printkan messagenya. Program tidak berhenti, namun pesan error tetap diketahui
except Exception as e: 
    print('Error:', e)
    
try:
    print(my_list2[3]) # my_list2 cuma berisi 3 elemen, sementara ingin diakses elemen ke-4
except Exception as e:
    print('Error:', e)
    
try:
    print(my_list2[3.0]) # akses tidak bisa menggunakan float, harus integer
except Exception as e:
    print('Error:', e)

Error: name 'my_list6' is not defined
3
Error: list indices must be integers or slices, not float

Mencari Index pada List (<my_list>.index(<nilai>))

Selain mengakses elemen list berdasarkan index, kita juga bisa melakukan sebaliknya, yaitu mencari index/posisi dari suatu nilai.

print(my_list2.index(2)) # mendapatkan index dari nilai 2
print(my_list3.index('Tiga')) # mendapatkan index dari nilai 'Tiga'

1
2

Namun harus berhati-hati, jika nilai yang dicari tidak ada di dalam index, maka akan memunculkan exception seperti di bawah ini. Disarankan menggunakan exception handling jika ingin menggunakan .index().

print(my_list2.index(10))

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-28-aa2e8f25c7f1> in <module>
----> 1 print(my_list2.index(10))

ValueError: 10 is not in list

Cek Keanggotaan List (<nilai> in <my_list>)

Misalnya kita ingin tau apakah 10 ada di dalam my_list2 atau tidak, maka selain menggunakan .index() (jika tidak error berarti nilai ada dalam list), kita bisa menggunakan operator in yang akan mengembalikan True jika ada, dan False jika nilai tidak ada. Karena menghasilkan boolean, operator in sering digunakan sebagai kondisi pada statement if.

print(10 in my_list2)

if 1 in my_list2:
    print("Sudah ada dalam list")

False
Sudah ada dalam list

Iterasi Elemen List (for <my_var> in <my_list>:)

Cara lain untuk mengakses elemen list adalah melalui pengulangan seperti berikut ini:

my_list = [5, 'empat', 3, (2, 1)]

for i in my_list: # mengakses seluruh elemen list satu per satu
    print(i)

sum_int = 0
for x in my_list: # mengakses seluruh elemen list satu per satu
    if isinstance(x, int):
        sum_int += x
print('Jumlah integer:',sum_int)

5
empat
3
(2, 1)
Jumlah integer: 8

Slice pada List (<my_list>[<start>:<end>])

Selain mengakses elemen satu per satu, Python juga menyediakan pengaksesan beberapa elemen sekaligus, yang biasa disebut dengan slicing. Sebagai contoh, misalnya array menyimpan data nilai siswa mulai dari yang pertama didapat sampai yang terakhir didapat seorang siswa, maka kita bisa mendapatkan misalnya 3 nilai terakhir siswa tersebut, atau 5 nilai pertama, dan seterusnya. Slicing pada python menggunakan tanda [<start>:<end>] (titik dua), dan elemen yang dikembalikan adalah elemen dari index ke <start> sampai ke <end>-1.

my_list = [90,80,95,85,85,100,88,98,79,80]
print(my_list[0:5]) # akan mengambil 5 elemen,  yaitu di index ke-0, 1, 2, 3, dan 4 (end-1).
print(my_list[-3:]) # akan mengambil elemen mulai dari index -3, sampai selesai. Jika <end> kosong, maka artinya sampai selesai.
print(my_list[:5])  # jika <start> kosong, maka artinya dimulai dari awal
print(my_list[3:5])

[90, 80, 95, 85, 85]
[98, 79, 80]
[90, 80, 95, 85, 85]
[85, 85]

Menambah Elemen List

  • Menambah 1 buah elemen di akhir list menggunakan append: <my_list>.append(<nilai>)

  • Menambah beberapa buah elemen sekligus di akhir list menggunakan extend: <my_list>.extend(<iterable>)

  • Menambah satu buah item di posisi tertentu dengan insert: <my_list>.insert(<index>, <nilai>)

Notes: iterable adalah sebuah object yang bisa diakses elemennya satu per satu. Contoh iterable object adalah list, str, tuple, dict, file.

my_list = [1,'dua',3]
my_list.append('empat')
print(my_list)

my_list.extend([5, 6, 7])
print(my_list)

my_list.extend('halo') # 'halo' adalah iterable, sehingga setiap hurufnya menjadi satu buah elemen
print(my_list)

my_list.insert(1, 100) # menambahkan 100 di index ke-1 (posisi ke-2 di list), dan menggeser elemen setelahnya 1 posisi
print(my_list)

[1, 'dua', 3, 'empat']
[1, 'dua', 3, 'empat', 5, 6, 7]
[1, 'dua', 3, 'empat', 5, 6, 7, 'h', 'a', 'l', 'o']
[1, 100, 'dua', 3, 'empat', 5, 6, 7, 'h', 'a', 'l', 'o']

Mengubah Elemen List

Karena sifatnya mutable, maka elemen list dapat diupdate nilainya dengan re-assignment.

my_list = [90,80,95,85,85,100,88,98,79,80]
my_list[0] = 10 # update 1 buah nilai
my_list[3:5] = [10, 10] # update beberapa nilai sekaligus dengan slicing
print(my_list)

[10, 80, 95, 10, 10, 100, 88, 98, 79, 80]

Menghapus Elemen List

  • Menghapus berdasarkan nilai dengan remove: <my_list>.remove(<nilai>)

  • Menghapus berdasarkan index dengan pop: <my_list>.pop(<index>). Jika index tidak diberikan, maka dianggap index terakhir

  • Menghapus semua elemen dengan clear: <my_list>.clear()

my_list = [90,80,95,85,85,100,88,98,79,80]

my_list.remove(80) # menghapus elemen 80 yang pertama kali ditemukan
print(my_list)
my_list.pop(4) # menghapus elemen ke-4 yaitu 100
print(my_list)
my_list.pop() # menghapus elemen terakhir yaitu 80
print(my_list)
nilai = my_list.pop(1) # pop akan mereturn nilai yang dikeluarkan dari list, sehingga bisa disimpan di sebuah variable untuk diproses lebih lanjut
print(nilai, my_list)
my_list.clear() # hapus semua elemen list
print(my_list)

[90, 95, 85, 85, 100, 88, 98, 79, 80]
[90, 95, 85, 85, 88, 98, 79, 80]
[90, 95, 85, 85, 88, 98, 79]
95 [90, 85, 85, 88, 98, 79]
[]

Tuple

Berikut adalah karakteristik tipe data Tuple.

  • Tuple dapat menyimpan elemen dengan tipe data berbeda-beda

  • Tuple mempunyai index(posisi), sehingga elemen tersimpan terurut berdasarkan index

  • Tuple dan elemen tuple bersifat immutable, artinya tuple tidak dapat diubah (ditambah, dikurangi), dan elemennya tidak dapat diganti. Namun, jika ada elemen tuple bersifat mutable seperti list, maka list tersebut tetap dapat diubah.

  • Elemen tuple boleh redundan (ada beberapa elemen yang sama)

Membuat Tuple

my_tuple = tuple() # bisa dengan tuple()
print(my_tuple)
my_tuple1 = ("Jono", 24, 175, 60) # atau cukup dengan buka dan tutup kurung
print(type(my_tuple1))
my_tuple2 = "Jene", 25, 165, 50
print(type(my_tuple2))

# khusus jika tuple hanya berisi 1 item, maka perlu ditambahkan 1 buah koma stelahnya
my_tuple3 = (1,)
print(type(my_tuple3))
my_tuple4 = 1,
print(type(my_tuple4))
# jika tanpa koma maka tidak menjadi tuple
my_tuple5 = (1)
print(type(my_tuple5))

# seperti list, bisa berisi type data berbeda, termasuk tuple dan list
my_tuple6 = (1, 2, 1, (4, 5), [1, 2])
print(my_tuple6)

()
<class 'tuple'>
<class 'tuple'>
<class 'tuple'>
<class 'tuple'>
<class 'int'>
(1, 2, 1, (4, 5), [1, 2])

Mengakses Elemen Tuple

Mengakses elemen tuple sama seperti pada List. Mencari index, cek keanggotaan, slicing, dan iterasi juga berlaku untuk tuple.

my_tuple6 = (1, 2, 1, (4, 5), [1, 2])

print(my_tuple6[1])
print(my_tuple6[-1])
print(my_tuple6[3][1])
print(my_tuple6[1:4])
print(my_tuple6.index(2))
print((4, 5) in my_tuple6)

2
[1, 2]
5
(2, 1, (4, 5))
1
True

Mengubah, Menambah, Menghapus

Karena Tuple bersifat immutable, maka tuple tidak bisa dimodifikasi dengan mengganti, menambah, atau menghapus elemennya. Namun, seandainya ada elemen dari tuple bersifat mutable, maka kita bisa memodifikasi elemen yang bersifat mutable tersebut.

my_tuple = ("immutable", ["mutable1", "mutable2"]) # tuple immutable, namun elemen kedua tersebut adalah sebuah list yang mutable
try:
    my_tuple[1] = ["test", "test"] #akan menimbulkan error
except Exception as e:
    print('Error:', e)
my_tuple[1][0] = "mutable3" # tidak error
print(my_tuple)
my_tuple[1].append("mutable4") # juga diperbolehkan karena mengubah mutable object
print(my_tuple)

Error: 'tuple' object does not support item assignment
('immutable', ['mutable3', 'mutable2'])
('immutable', ['mutable3', 'mutable2', 'mutable4'])

Set

Berikut adalah karakteristik tipe data Set.

  • Set dapat menyimpan elemen dengan tipe data berbeda-beda, namun elemen set harus bersifat immutable

  • Set tidak mempunyai index(posisi), sehingga elemen set tidak memiliki urutan tertentu.

  • Set bersifat mutable, artinya set dapat diubah (ditambah, dikurangi), namun elemennya tidak dapat diubah.

  • Elemen set tidak redundan (hanya menyimpan elemen unik)

Membuat Set

my_set1 = {1, 4, 'telU', 4} # membuat set dengan kurung kurawal, set hanya akan menyimpan 1 buah nilai 4
print(my_set1)
my_set2 = set([1, 'telu', 4, 'telu']) # membuat set dengan set()
print(my_set2)
my_set3 = {} # jika set awal kosong, maka membuat set hanya bisa dengan set(). Karena {} digunakan untuk membuat dictionary
print(type(my_set3))
my_set4 = set()
print(type(my_set4))
my_set5 = {1, 4, 'telU', [1, 2]} # jika elemen set ada yang bersifat mutable, maka akan terjadi error

{1, 4, 'telU'}
{1, 4, 'telu'}
<class 'dict'>
<class 'set'>

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-2-cbceb92b3d5a> in <module>
      7 my_set4 = set()
      8 print(type(my_set4))
----> 9 my_set5 = {1, 4, 'telU', [1, 2]} # jika elemen set ada yang bersifat mutable, maka akan terjadi error

TypeError: unhashable type: 'list'

Mengakses Elemen Set

Karena Set tidak memiliki index, sehingga pengaksesan elemen juga tidak bisa dilakukan melalui index seperti pada list dan tuple. Namun pengaksesan dengan cek keanggotaan dan iterasi dapat dilakukan pada set.

my_set = {1, 2, 3}
print(5 in my_set)

for i in my_set: # perlu diingat set tidak terurut, sehingga urutannya bisa berubah dan tidak konsisten
    print(i)

False
1
2
3

Menambah Elemen Set

  • Menambah 1 item dengan add

  • Menambah banyak item dengan update

Perhatikan bahwa yang bisa menjadi elemen dari Set hanya tipe data yang bersifat immutable, sehingga list tidak bisa menjadi elemen dari set. Salah satu cara agar bisa menjadi elemen adalah dengan mengubah ke bentuk tuple.

my_set = {1, 2, 3}
my_set.add(5)
print(my_set)
my_set.update([6, 7, 8])
print(my_set)
try:
    my_set.add([9, 10])
except Exception as e:
    print('Error:', e)
my_set.add(tuple([9, 10]))
print(my_set)

{1, 2, 3, 5}
{1, 2, 3, 5, 6, 7, 8}
Error: unhashable type: 'list'
{1, 2, 3, 5, 6, 7, 8, (9, 10)}

Mengubah Elemen Set

Meskipun Set bersifat mutable, namun elemen pada set tidak bisa diubah atau diganti setelah ditambahkan ke dalam set.

Menghapus Elemen Set

  • Elemen set dapat dihapus dengan remove: <my_set>.remove(<nilai>). Namun akan menimbulkan exception jika <nilai> tidak terdapat di dalam set.

  • Elemen set dapat juga dihapus dengan discard: <my_set>.discard(<nilai>). Jika <nilai> tidak ada di dalam set, maka tidak menimbulkan exception.

  • Elemen set dapat dihapus dengan pop, pop akan menghapus 1 buah sembarang elemen, dan mereturn elemen yang dihapus tersebut.

my_set = {1, 2, 3, 4}

my_set.remove(1)
print(my_set)

try:
    my_set.remove(5) # menimbulkan exception karena 5 tidak ada dalam set.
except Exception as e:
    print('Error:', e)

my_set.discard(4)
print(my_set)
    
my_set.discard(5) # tidak menimbulkan exception meskipun 5 tidak ada dalam set.
print(my_set)

p = my_set.pop()
print('pop1:', p, my_set)
q = my_set.pop()
print('pop2:', q, my_set)
r = my_set.pop() # menimbulkan exception karena set kosong, tidak ada nilai yang bisa di-pop
print('pop3:', r, my_set)

{2, 3, 4}
Error: 5
{2, 3}
{2, 3}
pop1: 2 {3}
pop2: 3 set()

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-51-0f116f5c4e32> in <module>
     19 q = my_set.pop()
     20 print('pop2:', q, my_set)
---> 21 r = my_set.pop() # menimbulkan exception karena set kosong, tidak ada nilai yang bisa di-pop
     22 print('pop3:', r, my_set)

KeyError: 'pop from an empty set'

Dictionary

Karakteristik tipe data Dictionary yaitu:

  • Data tersimpan dalam bentuk pasangan Key dan Value

  • Key harus bersifat immutable dan unik, sedangkan Value boleh memiliki tipe berbeda-beda baik mutable maupun immutable.

  • Dictionary tidak mempunyai index, sehingga elemen tidak memiliki urutan tertentu

  • Dictionary bersifat mutable, artinya bisa ditambah atau dikurangi.

Membuat Dictionary

Dictionary dapat dibuat dengan dua buah cara yaitu melalui {} atau dict():

  • {key1: value1, key2: value2, ...}

  • dict([(key1, value1), (key2, value2), ... ])

my_dict1 = {}
print(type(my_dict1))
my_dict2 = dict()
print(type(my_dict2))

my_dict3 = {1: 'satu', 2: 'dua', (3, 4): [1, 2, 3], 'four': {1: 'senin', 2: 'selasa'}}

my_dict4 = dict([(1, 'satu'), (2, 'dua'), ((3, 4), [1, 2, 3]), ('four', {1: 'senin', 2: 'selasa'})])

print(my_dict3)
print(my_dict4)

my_dict5 = {[1, 2]: 'satu'} #error karena key tidak boleh mutable

<class 'dict'>
<class 'dict'>
{1: 'satu', 2: 'dua', (3, 4): [1, 2, 3], 'four': {1: 'senin', 2: 'selasa'}}
{1: 'satu', 2: 'dua', (3, 4): [1, 2, 3], 'four': {1: 'senin', 2: 'selasa'}}

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-11-3017160b661f> in <module>
     11 print(my_dict4)
     12 
---> 13 my_dict5 = {[1, 2]: 'satu'} #error karena key tidak boleh mutable

TypeError: unhashable type: 'list'

Mengakses elemen Dictionary

Akses dengan Key

Akses dengan key dapat dilakukan dengan 2 cara yaitu melalui [] dan .get():

  • <my_dict>[<key>]: jika key tidak ada dalam dictionary, akan mengeluarkan exception

  • <my_dict>.get(<key>): jika key tidak ada dalam dictionary, akan mengembalikan None

my_dict = {1: 'satu', 2: 'dua', (3, 4): [1, 2, 3], 'four': {1: 'senin', 2: 'selasa'}}

print(my_dict[1])
print(my_dict[(3, 4)])
print(my_dict['four'])
print(my_dict['four'][2])

print(my_dict.get(10))

print(my_dict[10]) #akan menimbulkan exception KeyError

satu
[1, 2, 3]
{1: 'senin', 2: 'selasa'}
selasa
None

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-16-44771564c881> in <module>
      8 print(my_dict.get(10))
      9 
---> 10 print(my_dict[10]) #akan menimbulkan exception KeyError

KeyError: 10

Cek Keanggotaan Dictionary (<key> in <my_dict>)

my_dict = {1: 'satu', 2: 'dua', (3, 4): [1, 2, 3], 'four': {1: 'senin', 2: 'selasa'}}

print(1 in my_dict)
print(10 in my_dict)

True
False

Iterasi Elemen Dictionary

  • Pertama, iterasi melalui key: (for <my_key> in <my_dict>:)

  • Kedua, kedua iterasi melalui key dan vlaue: (for <my_key>, <my_val> in <my_dict>.items():)

my_dict = {1: 'satu', 2: 'dua', (3, 4): [1, 2, 3], 'four': {1: 'senin', 2: 'selasa'}}

for k in my_dict:
    print(k)

for k, v in my_dict.items():
    print('key:', k,' val:', v)

1
2
(3, 4)
four
key: 1  val: satu
key: 2  val: dua
key: (3, 4)  val: [1, 2, 3]
key: four  val: {1: 'senin', 2: 'selasa'}

Menambah Elemen dan Mengganti Value

Untuk menambahkan pasangan key-value baru ke dalam dictionary, cukup assign value ke key tersebut: <my_dict>[<key>] = <value>. Jika <key> belum ada di dalam dictionary, maka pasangan key-value tersebut akan ditambahkan ke dalam dictionary, tetapi jika key sudah ada di dalam dictionary, maka value dari key tersebut akan diupdate dengan yang baru di-assign.

my_dict = {1: 'satu', 2: 'dua', (3, 4): [1, 2, 3], 'four': {1: 'senin', 2: 'selasa'}}

my_dict[10] = 'sepuluh' #key 10 belum ada, sehingga ditambahkan pasangan key-value ke dalam dictionary
print(my_dict)

my_dict[10] = 'ten' #key 10 sudah ada, sehingga value diupdate
print(my_dict)

{1: 'satu', 2: 'dua', (3, 4): [1, 2, 3], 'four': {1: 'senin', 2: 'selasa'}, 10: 'sepuluh'}
{1: 'satu', 2: 'dua', (3, 4): [1, 2, 3], 'four': {1: 'senin', 2: 'selasa'}, 10: 'ten'}

Menghapus Elemen Dictionary

Untuk menghapus elemen ada beberapa opsi:

  • Menghapus elemen berdasarkan key tertentu dengan pop: <my_dict>.pop(<key>). Jika key tidak ada, maka akan menimbulkan exception

  • Menghapus sebuah elemen sembarang dengan popitem: <my_dict>.popitem(). Jika dictionary kosong akan menimbulkan exception

  • Menghapus semua elemen dengan clear: <my_dict>.clear().

my_dict = {1: 'satu', 2: 'dua', (3, 4): [1, 2, 3], 'four': {1: 'senin', 2: 'selasa'}}

v = my_dict.pop(1) #pop mengembalikan value dari key yang di-pop
print(v)
print(my_dict)

kv = my_dict.popitem() #popitem mengembalikan sembarang tuple (key, value)
print(kv)

my_dict.clear()
print(my_dict)

satu
{2: 'dua', (3, 4): [1, 2, 3], 'four': {1: 'senin', 2: 'selasa'}}
('four', {1: 'senin', 2: 'selasa'})
{}

Selamat anda telah menyelesaikan Modul 8!!

Mohon berkenan memberikan Rating dan Feedback agar kami dapat meningkatkan kualitas modul ini!