Modul 1 Struktur Data: Tipe Data di Python

Kembali ke Struktur Data (dengan Python)

Selamat datang di praktikum Struktur Data! Sesuai nama mata kuliahnya, kita akan mempelajari cara mengimplementasikan (membuat) berbagai jenis struktur data dengan bahasa pemrograman Python. Nantinya, berbagai struktur data akan dibentuk “di atas” struktur data array dan yang namanya linked list, tetapi yang lebih mendasar lagi daripada keduanya adalah tipe data.

Di pertemuan pertama ini, kita akan membahas tentang berbagai tipe data yang ada di Python, baik yang sudah kita kenal di mata kuliah Algoritma dan Pemrograman (pasti tersedia di semua bahasa pemrograman) maupun beberapa tipe data khusus yang ada di Python tetapi belum tentu ada di bahasa pemrograman lain. Tujuannya agar kalian lebih mahir dan lebih mudah ketika menggunakan Python untuk menyelesaikan berbagai masalah dalam kehidupan sehari-hari :D

Kita juga akan membahas tentang array dari numpy di Python (bisa disebut static homogeneous array atau biasa disebut array saja), dan bedanya dengan list di Python (dynamic heterogeneous array).

Review Tipe Data

Pada AlProg, ada beberapa jenis tipe data yang kalian pelajari, yaitu:

Numerik: int, float
Teks: string
List

Tipe Numerik

# Tipe Data Integer
a1 = 5
a2 = -180

# Melihat isinya
print(a1)
print(a2)

5
-180

# Mengecek tipe data menggunakan syntax type
print(type(a1))
print(type(a2))

<class 'int'>
<class 'int'>

Menurut output yang diperoleh, variabel a1 dan a2 saat ini berupa bilangan bulat atau integer. Python punya “kode” atau nama tersendiri untuk tiap tipe data. Untuk bilangan bulat, namanya adalah int. Nama ini sudah ketetapan dari sananya; kapanpun kita berurusan dengan bilangan bulat di Python, sebutannya selalu int.

Kebetulan, Python juga menyebut istilah class. Kita akan belajar lebih lanjut tentang class di pertemuan berikutnya. Untuk sekarang ini, terima saja dulu ya: kurang lebih, maksud dari istilah class adalah tipe data. Jadi intinya, Python memberi tahu bahwa tipe data nya adalah int.

Hasil jumlahan bilangan bulat pasti juga bilangan bulat.

a3 = a1 + a2
print(a3)
print(type(a3))

-175
<class 'int'>

Selanjutnya, kita bahas tentang float atau floating-point number. Intinya ya koma-komaan atau bilangan rasional. Kenapa disebut “floating-point”, itu karena menurut komputer, titik nya itu bisa dengan mudah dipindah-pindah. Barangkali pernah dibahas dulu di awal kuliah Metode Numerik. Tapi detil itu tidak penting, intinya terima saja, namanya float

# Tipe data float
b1 = 2.54
b2 = -3.141592
b3 = float('inf') # memasukkan infinity sebagai float

# Melihat isinya
print(b1)
print(b2)
print(b3)

# Mengecek tipe data
print(type(b1))
print(type(b2))
print(type(b3))

2.54
-3.141592
inf
<class 'float'>
<class 'float'>
<class 'float'>

float("inf") atau float('inf') yang melambangkan tak hingga ini gunanya untuk perbandingan, barangkali sewaktu-waktu kalian membutuhkan suatu bilangan yang selalu lebih besar daripada semua bilangan lain.

# apapun itu, pasti lebih kecil daripada b3 yaitu tak hingga
if (b1 < b3):
    print("lebih kecil")
else:
    print("lebih besar")

lebih kecil

Ada juga float("-inf") atau float('-inf') yang melambangkan negatif tak hingga, yang selalu lebih kecil daripada semua bilangan lain.

b4 = float("-inf")
if (-123456789 > b4):
    print("masih lebih besar dari -inf")
else:
    print("lebih kecil dari -inf")

masih lebih besar dari -inf

# Operasi dengan int dan float
print(b1 * b2)
print(a1 ** b1)
print(abs(b2))

-7.979643680000001
59.618879710940476
3.141592

# Jika int bertemu float, maka tipe datanya akan menjadi float,
# walaupun float nya sebenarnya bulat
print(type(a1 ** b1))

<class 'float'>

print(10.0 / 2)
print(type(10.0 / 2))

5.0
<class 'float'>

Tipe Teks

Untuk menyimpan teks atau “tulisan” di Python, kita gunakan tipe data string, yang menurut Python sebutannya str. Penulisannya bisa menggunakan tanda petik ' atau tanda kutip " itu sama saja, sama-sama string, yang penting konsisten.

# Tipe Data String
c1 = "string biasa"
c2 = 'string lagi'

# Print isinya
print(c1)
print(c2)

string biasa
string lagi

# Mengecek Tipe Data
print(type(c1))
print(type(c2))

<class 'str'>
<class 'str'>

Apabila tanda petik atau tanda kutip itu diketik tiga kali berturut-turut, string nya bisa berbaris-baris (disebut multiline string).

c3 = '''string
sampe
bawah'''

print(c3)
print(type(c3))

string
sampe
bawah
<class 'str'>

Sebenarnya, secara internal, baris baru atau newline itu berupa “huruf” atau karakter tersendiri. Ada cara penulisan khusus, yaitu \n untuk newline character. Dengan demikian, kita bisa mengadakan baris baru tanpa menekan tombol Enter.

c4 = "Selamat\nsore\nsemuanya"
print(c4)
print(type(c4))

Selamat
sore
semuanya
<class 'str'>

Cara penulisan khusus seperti \n itu disebut escape character. Maksudnya, yang tadinya berupa huruf “n” itu diawali garis miring \ sehingga maknanya berubah.

Pada string dapat dilakukan penggabungan (s + s), penggandaan (s * n), slicing (s[a:b]), cari panjang (len), maksimum-minimum (max-min di sini diliat dari urutannya di ASCII), dll.

print('ayam' + 'geprek')

ayamgeprek

print('ayam' + ' ' + 'geprek')

ayam geprek

# Penjumlahan berulang adalah perkalian :)
print('es jeruk' * 5)

es jerukes jerukes jerukes jerukes jeruk

print('es jeruk, ' * 5)

es jeruk, es jeruk, es jeruk, es jeruk, es jeruk,

List, Tuple, dan Set

Ketiganya dapat digunakan untuk menyimpan banyak item sekaligus.

# Membuat list
list1 = [10, -1, 13.7]
list2 = ["apel", "pisang", "mangga"]
list3 = [-75, "kartu", True]
list4 = list("rumput")

print(list1)
print(list2)
print(list3)
print(list4)

[10, -1, 13.7]
['apel', 'pisang', 'mangga']
[-75, 'kartu', True]
['r', 'u', 'm', 'p', 'u', 't']

Perhatikan bahwa kita dapat menyimpan berbagai tipe data yang berbeda-beda di dalam list yang sama. Kita juga dapat memodifikasi list:

nilai = [100, 75, 30, 60]
nilai[2] = 55

print(nilai)

[100, 75, 55, 60]

Bahkan, kita dapat dengan mudah menambahkan elemen di belakang list:

warna = ["merah", "hijau", "biru"]
warna.append("kuning")
warna.append("putih")
warna.append("hitam")

print(warna)

['merah', 'hijau', 'biru', 'kuning', 'putih', 'hitam']

Kita dapat memperoleh panjangnya (banyaknya elemen; isinya ada berapa) menggunakan len seperti berikut

print(len(warna))

Selanjutnya, mari kita coba membuat tuple.

# Membuat tuple
t1 = (2, 3)
t2 = (4, 'abc')
t3 = tuple('kacang')

print(t1)
print(t2)
print(t3)

(2, 3)
(4, 'abc')
('k', 'a', 'c', 'a', 'n', 'g')

print(type(t1))
print(type(t2))
print(type(t3))

<class 'tuple'>
<class 'tuple'>
<class 'tuple'>

Tuple dapat dianggap sebagai list yang isinya tidak bisa diganti, ditambah, ataupun dihapus. Namun masih berlaku operasi list yang tidak termasuk editing. Kelebihan tuple adalah bisa menjadi key untuk dict (akan dijelaskan kemudian)

# Kalau mencoba edit tuple, pasti error
t2[1] = 'xyz'

TypeError: 'tuple' object does not support item assignment

Kata error nya sih, ga ada fitur assignment. Ini memang disengaja, tuple itu dimaksudkan sebagai list yang tidak bisa diubah.

Barangkali sewaktu-waktu kalian perlu menyimpan data yang sudah pasti tidak berubah. Kalian bisa menggunakan tuple untuk berjaga-jaga, takutnya kalian ga sengaja mengubah datanya, nah itu akan error agar kalian ingat bahwa tidak bisa diubah.

Kemudian, mari kita mencoba membuat set atau himpunan. Penulisannya menggunakan kurung kurawal. Konsep set atau himpunan di Python ini diharapkan sama seperti himpunan yang kalian pelajari di mata kuliah Logika dan Himpunan (LDH).

# Membuat set
s1 = {'ayam', 'bebek', 'ayam', 'kuda'}
s2 = set(list('kacang'))

print(s1)
print(s2)

{'ayam', 'bebek', 'kuda'}
{'a', 'g', 'k', 'n', 'c'}

Bisa jadi, hasil di atas itu agak berbeda dengan hasil kalian, karena memang agak random, urutan elemen di himpunan itu benar-benar tidak diperhatikan di Python.

Set bisa dianggap sebagai list yang tidak mempunyai urutan, sehingga tidak ada indexing dan slicing. Kelebihan utamanya adalah set hanya bisa mempunyai elemen yang unik (tidak bisa ada elemen yang sama di set). Hal ini berguna jika kalian mempunyai list yang kalian ingin hilangkan dobel-dobelnya (efek sampingnya, indeksnya jadi hilang sehingga bisa saja isinya tak beraturan).

Atau bisa jadi, mungkin kalian memang memerlukan konsep himpunan dari LDH itu di dalam Python, seperti memeriksa apakah suatu elemen ada atau tidak ada di himpunan.

if ('ayam' in s1):
    print("ada ayam")
else:
    print("ayam habis")

ada ayam

Beberapa operator himpunan matematika juga ada di set, seperti subset, superset, disjoint, union, intersection, dll.

s3 = set('matematika')
s4 = set('statistika')
s5 = set('aktuaria')

print(s3)
print(s4)
print(s5)

{'a', 'm', 'k', 't', 'e', 'i'}
{'a', 's', 'k', 't', 'i'}
{'a', 'k', 'u', 't', 'i', 'r'}

print(s3 & s4) # irisan/intersection

{'a', 'i', 't', 'k'}

print(s3 | s4) # gabungan/union

{'a', 'm', 's', 'k', 't', 'e', 'i'}

# subset
print(s4 <= s5)
print( {3, 4} <= {1, 2, 3, 4, 5} )

False
True

# superset
print(s4 >= s3)
print( {3, 4, 5, 6, 7, 8} >= {7, 4} )

False
True

Set/List/Tuple Comprehension

Istilah set/list/tuple comprehension itu konsepnya sama saja, mungkin kita bahas di set/himpunan dulu yaa.

Misalnya kalian punya himpunan ini:

\(B = \{ 1, 2, 3, 4, 5 \}\)

B = {1, 2, 3, 4, 5}
print(B)
print(type(B))

{1, 2, 3, 4, 5}
<class 'set'>

Terus misalnya kalian ingin membangun himpunan baru (seperti di LDH) seperti berikut:

\(C = \{ 2x : x \in B \}\)

Menariknya, di Python, kalian tinggal mengetik seperti ini:

C = {2*x for x in B}
print(C)

{2, 4, 6, 8, 10}

Bahkan kita juga bisa menambahkan syarat tambahan, misalnya:

\(D = \{ 2x : x \in B, x < 3 \}\)

D = {2*x for x in B if x < 3}
print(D)

{2, 4}

Jangan lupa, himpunan itu tidak memperhatikan urutan (di sini kebetulan aja lagi berurut, tumben). Untungnya, penulisan set comprehension ini juga berlaku sama persis di list maupun tuple, sehingga ada istilah list comprehension dan tuple comprehension kalau dilakukan di list maupun tuple.

Walaupun fitur ini mungkin hanya ada di Python, set/list/tuple comprehension ini bisa sangat mempersingkat kode kita. Terkadang kita membangun list menggunakan for loop, dan for loop tersebut bisa saja memakan beberapa line. Dengan list comprehension, kita dapat membangun list tersebut hanya menggunakan 1 line dan kode kita menjadi lebih enak untuk dibaca.

Sebagai contoh, misal kita ingin membuat list yang berisi nilai dari \(2^x\):

expo = []
for i in range(6):
    expo.append(2**i)

print(expo)

[1, 2, 4, 8, 16, 32]

Jika menggunakan list comprehension, akan menjadi seperti ini:

expo = [2 ** i for i in range(6)]

print(expo)

[1, 2, 4, 8, 16, 32]

List comprehension dibuat dengan membuat list yang berisi suatu ekspresi lalu diikuti dengan for, dan jika diinginkan, bisa ditambah lagi for atau if. Hasilnya seolah-olah kita menjalankan for loop untuk membuat list tersebut, namun hanya menggunakan satu baris kode.

List comprehension dapat menggunakan lebih dari satu variabel pada ekspresinya. Hal ini ekivalen dengan menggunakan nested for loop untuk membuat list tersebut.

Contohnya, ada konsep cartesian product dari dua himpunan, yaitu memasangkan tiap elemen pertama dengan tiap elemen kedua, seperti berikut:

\(\{ 1, 2 \} \times \{ a, b, c \} = \{ (1, a), (1, b), (1, c), (2, a), (2, b), (2, c) \}\)

Di Python, kita bisa menggunakan list comprehension untuk membuat list hasil cartesian product dengan mudah, yaitu dengan dua for:

cartesian_prod = [(x, y) for x in [1, 2] for y in ['a', 'b', 'c']]
print(cartesian_prod)

[(1, 'a'), (1, 'b'), (1, 'c'), (2, 'a'), (2, 'b'), (2, 'c')]

(Tentu saja, daripada menggunakan list, kita bisa menggunakan set atau bahkan tuple.)

Potongan kode di atas ekivalen dengan:

cartesian_prod = []
for x in [1, 2]:
    for y in ['a', 'b', 'c']:
        cartesian_prod.append((x, y))

print(cartesian_prod)

[(1, 'a'), (1, 'b'), (1, 'c'), (2, 'a'), (2, 'b'), (2, 'c')]

Ingat bahwa urutan pembacaan setiap ekspresi for dan if pada list comprehension adalah dari kiri ke kanan.

List comprehension pun juga bisa di-nesting.

mat = [[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]]

mat_transpos = [[baris[j] for baris in mat] for j in range(len(mat))]
print(mat_transpos)

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

Dictionary

Dictionary ini secara harfiah memang artinya “kamus” ya. Di dalam kamus, ada kata dan ada definisi, sebagai pasangan, di mana kita memiliki kata dan kita mencari definisi.

Di Python, dictionary seperti semacam “perumuman” dari konsep pasangan kata-definisi untuk kamus, di mana “kata” disebut “key” atau kunci dan “definisi” menjadi “value” atau nilai atau data yang sedang dicari berdasarkan key nya.

Kita juga bisa memandang dictionary sebagai list yang indeksnya tidak harus berupa bilangan bulat (tetapi, seperti set, tidak ada urutan).

Strukturnya adalah {key1:value1, key2:value2, ....}.

Dictionary dalam hal ini juga terkadang disebut associative array.

# Membuat dictionary
d1 = {'a': 1, 'b': 2, 'c': 3}
d2 = {'kopi': 6000, 'teh': 5000, 'susu': 7000}

print(d1)
print(d2)
print(type(d1))
print(type(d2))

{'a': 1, 'b': 2, 'c': 3}
{'kopi': 6000, 'teh': 5000, 'susu': 7000}
<class 'dict'>
<class 'dict'>

Tidak seperti list yang diindeks menggunakan suatu range bilangan, dictionary diindeks menggunakan key. Jadi, untuk memanggil suatu value, panggil layaknya list, namun indeksnya menggunakan key

print(d2['kopi'])

Tipe data dari value boleh bebas, namun untuk key itu harus yang immutable (kurang lebih artinya tidak bisa diubah). Seandainya kita coba membuat dictionary dengan key berupa tipe data yang mutable (bisa diubah) seperti list, akan error:

d3 = { [2, 3]: 6, [3, 4]: 12 }
print(d3)

TypeError: unhashable type: 'list'

Sehingga, kita harus menggunakan tuple:

d3 = {(2, 3): 6, (3, 4): 12}
print(d3)

{(2, 3): 6, (3, 4): 12}

print(d3[(3, 4)])

Untuk menambah suatu pasangan key:value baru, cukup menggunakan d[key] = value, dan akan masuk ke dict tersebut.

d3[(3, 5)] = 15
print(d3)

{(2, 3): 6, (3, 4): 12, (3, 5): 15}

Jika ingin menghapus elemen pada dict, dapat menggunakan del

del d3[(2, 3)]
print(d3)

{(3, 4): 12, (3, 5): 15}

Bagaimana dengan array?

Sebenarnya, list yang ada di Python itu sedikit berbeda dengan array (larik) yang biasa dibahas di Alprog. Suatu array:

harus statis, yaitu ukurannya tidak dapat berubah;
harus homogen, yaitu tipe datanya harus sama semua.

Di Python, kita bisa menggunakan array melalui numpy. Mari kita coba, import numpy dulu:

import numpy as np

Ada “cara cepat” untuk membuat array yang berisi nol semua atau berisi satu semua, yaitu dengan numpy.zeros dan numpy.ones:

array1 = np.zeros(5)
array2 = np.ones(3)

print(array1)
print(array2)
print(type(array1))
print(type(array2))

[0. 0. 0. 0. 0.]
[1. 1. 1.]
<class 'numpy.ndarray'>
<class 'numpy.ndarray'>

Maksud dari istilah ndarray adalah n-dimensional array atau array yang dimensinya bisa berupa bilangan asli apapun.

Apabila kita memasukkan tuple, kita bisa membuat array dengan dimensi yang lebih tinggi.

# Memasukkan tuple (3, 2) untuk ukuran 3 x 2
array3 = np.ones((3, 2))
print(array3)

[[1. 1.]
 [1. 1.]
 [1. 1.]]

array1[3] = -15
print(array1)

[  0.   0.   0. -15.   0.]

array1.append(7)

AttributeError: 'numpy.ndarray' object has no attribute 'append'

Mungkin di beberapa referensi pemrograman yang membahas array, ada istilah deklarasi dan inisialisasi. Deklarasi itu sekedar menyatakan bahwa array akan memiliki ukuran sekian, sedangkan inisialisasi adalah memasang nilai awal.

Dengan numpy, kita bisa menggunakan numpy.empty(ukuran) untuk deklarasi saja, atau numpy.array(list_isinya) untuk sekaligus memasang nilai awal.

Misalnya, kita coba deklarasi + inisialisasi sekaligus:

array4 = np.array([10, -5, 2, 17])
print(array4)

[10 -5  2 17]

Perhatikan bahwa array4 yang sudah kita buat ini berisi bilangan bulat semua. Setelah membuat array tersebut, ukurannya sudah tetap dan tipe datanya juga sudah tetap (dan harus seragam).

Seandainya kita mencoba memasang float ke array bilangan bulat, akan dipaksakan menjadi bilangan bulat:

array4[3] = 3.14
print(array4)

[10 -5  2  3]

Seandainya mencoba memasang str ke array bilangan bulat, Python menyerah dan menjadi error:

array4[3] = "string"
print(array4)

ValueError: invalid literal for int() with base 10: 'string'

Bagaimana kalau kita ingin membuat array float meskipun data kita kebetulan bilangan bulat semua? Salah satu caranya adalah menambahkan .0 ke salah satu elemennya:

array5 = np.array([10.0, -5, 2, 17])
print(array5)

[10. -5.  2. 17.]

Dengan demikian, kita bisa memasang float:

array5[3] = 3.14
print(array5)

[10.   -5.    2.    3.14]

Cara lain adalah dengan memberitahu numpy, melalui dtype yaitu tipe data yang kita tentukan. Perhatikan, untuk dtype, di sini kita menggunakan nama yang dikenal oleh Python. Misalnya, float untuk koma-komaan dan int untuk bilangan bulat.

array6 = np.array([10, -5, 2, 17], dtype=float)
print(array6)

[10. -5.  2. 17.]

Kita bahkan bisa membuat array berisi string yaitu str

array7 = np.array(['p', 'r', 'a', 'k'], dtype=str)
print(array7)

['p' 'r' 'a' 'k']

Namun, ingat bahwa array bersifat fixed size. Bahkan, di sini kita sudah terlanjur membuat array berisi 4 string dan masing-masing satu huruf. Maka, array ini sudah terlanjur hanya bisa menampung 4 string dengan masing-masing string hanya sebesar satu karakter.

array7[3] = "praktikum"
print(array7)

['p' 'r' 'a' 'p']

Terakhir, tentang deklarasi menggunakan numpy.empty. Kalau kita hanya melakukan deklarasi, kita hanya menyatakan ukurannya, tanpa memberitahu isinya apa. Dengan demikian, komputer kita akan mencari memori yang sedang tidak digunakan, lalu langsung menggunakannya untuk array baru kita. Kemungkinan besar, memori yang sudah ditemukan itu tadinya bekas data lain yang sudah terhapus.

Cara menggunakan numpy.empty serupa dengan numpy.ones atau numpy.zeros:

array8 = np.empty(8)
print(array8)

[3.10503618e+231 1.49457044e-154 3.95252517e-323 0.00000000e+000
 0.00000000e+000 0.00000000e+000 3.10503618e+231 3.10503618e+231]

Lho, muncul angka-angka ga jelas. Mungkin di kalian akan berbeda. Inilah bekas dari data yang sudah terhapus.

Tahukah kalian, ketika kalian menghapus file, sebenarnya data itu belum tentu benar-benar terhapus? Datanya hanya diberi tanda “terhapus”, bukan benar-benar dihilangkan. Data bekas seperti itu disebut garbage value.

Biasanya, ketika kita membuat file baru, barulah komputer mencari memori yang “kosong”, yaitu berisi garbage value, kemudian komputer menimpa data yang baru di atas data yang lama (garbage value) tersebut.

Tentu saja, array hasil deklarasi ini kemudian bisa dipasang nilainya satu-per-satu (assignment):

# bisa manual tiap indeks
array8[0] = -17.6
array8[1] = 24.3

# bisa juga dengan for loop
for i in range(2, len(array8)): # dari i=2 sampai i=7
    array8[i] = 5*i/4

print(array8)

[-17.6   24.3    2.5    3.75   5.     6.25   7.5    8.75]

Kebetulan, hasil numpy.empty berisi float, sehingga tipe data array nya otomatis menjadi float. Namun, tentu saja, kita bisa menentukan dtype yang kita inginkan (begitu juga untuk numpy.ones dan numpy.zeros, sama seperti numpy.array).

Contohnya, dengan dtype=str kita mendapatkan array yang tiap elemennya berupa string yang hanya bisa menampung satu karakter (secara teori juga disebut tipe data karakter atau char):

array9 = np.empty(4, dtype=str)
print(array9)

array9[2] = "coba"
print(array9)

['' '' '' '']
['' '' 'c' '']

Untuk string dengan panjang maksimum \(n\) karakter, gunakan dtype='<Un' atau dtype="<Un". Misalnya, dtype='<U3' atau dtype="<U3" untuk tiga karakter:

array10 = np.empty(5, dtype="<U3")
print(array10)

array10[2] = "percobaan"
print(array10)

['' '' '' '' '']
['' '' 'per' '' '']

Untuk bilangan bulat, seperti biasa, gunakan dtype=int

array11 = np.empty(11, dtype=int)
print(array11)

[8070450532247928832 1152930267120700532                   6
                   0                   0 3832119515839358315
 3271410370466756915 3762814858193679157 4120005537702227256
 3977580307635332705 8386112019188900194]

Sangat random ya! Lagi-lagi, isi dari hasil numpy.empty sangat mungkin berbeda-beda untuk tiap komputer dan di tiap saat. Intinya, kita hanya meminta array dengan ukuran tertentu, tanpa menentukan isinya (tidak seperti numpy.ones dan numpy.zeros yang isinya sudah pasti, atau numpy.array di mana kita manual menentukan isinya), sehingga isinya bisa berupa apa saja. Begitulah jadinya, jika array hanya dideklarasi tanpa ditentukan isinya.

Pada prakteknya, deklarasi array selalu diikuti dengan menentukan isinya, seperti dengan assignment atau contoh for loop di atas (atau kalau mau, kita bisa saja menggunakan numpy.ones, numpy.zeros, atau bahkan numpy.array agar tidak pusing).

Selanjutnya bahas apa?

Sekian praktikum Struktur Data minggu ini. Di pertemuan selanjutnya, kita akan belajar tentang class, di mana kita seolah-olah bisa membuat tipe data sendiri lho! Selain itu, fitur class ini akan sering kita gunakan untuk membuat berbagai struktur data ke depannya. Sekalian, kita akan membahas juga tentang object-oriented programming atau biasa disingkat OOP (atau dalam bahasa Indonesia: pemrograman berorientasi objek, biasa disingkat PBO), yaitu semacam “paradigma pemrograman” atau “gaya pemrograman” di mana kita sering berurusan dengan class. Sampai jumpa!