Object Oriented Programming (OOP) atau pemrograman berorientasi objek adalah salah satu pendekatan paling efektif dalam menulis kode suatu software. Pada OOP kita menulis class yang merepresentasikan suatu situasi seperti pada keadaan sebenarnya dan kita dapat membuat suatu objek berdasarkan class tersebut. Sebelum memulai mengenai OOP pada Python, ada baiknya memahami dasar pemrograman Python terlebih dahulu. Tunggu apa lagi, mari kita mulai!!!
Jika Anda ingin download file jupyter notebook. Silahkan menuju bagian kesimpulan.
Python adalah bahasa pemrograman berorientasi objek. Tidak seperti pada pemrograman berorientasi prosedural, di mana penekanan utama adalah pada fungsi(walaupun Python dapat melakukannya). Sedangkan pemrograman berorientasi objek lebih menekankan pada suatu objek
Kita pasti bertanya-tanya apa perbedaan antara pemrograman prosedural dan berorientasi objek. Untuk menghilangkan keraguan tersebut, mari kita bahas di antara kedua nya. Pada pemrograman prosedural, seluruh kode ditulis dalam satu prosedur yang panjang meskipun mungkin mengandung suatu fungsi dan subrutin. Dengan menggunakan cara tersebut, akan sangat sulit untuk di kelola di kemudian hari. Karena, data dan logika di campur bersama-sama.
Namun, ketika kita berbicara mengenai pemrograman berorientasi objek, kode program di bagi lagi menjadi suatu objek tersendiri.
Setiap objek mewakili bagian yang berbeda dari suatu program, dimana objek tersebut memiliki data dan logika tersendiri untuk saling berkomunikasi. Kita dapat membayangkan suatu situs web yang memiliki objek yang berbeda-beda seperti tulisan, gambar, video, dll.
Pemrograman berorientasi objek mencakup empat pillar utama, yaitu Encapsulation, Inheritance, Polymorphism dan Abstraction. Mari kita pahami topik ini secara lebih detail pada bagian selanjutnya.
Video penjelasan konsep pemrograman berorientasi objek:
Youtube Playlist mengenai OOP pada Python
Objek adalah suatu kumpulan data (variabel) dan metode (fungsi) yang bekerja pada data tersebut. Sedangkan, class adalah blueprint dari suatu objek. Lalu, bagaimana class memungkinkan untuk dapat mengelompokkan suatu data dan fungsi secara logis dengan cara yang mudah digunakan kembali serta bagaimana cara membangunnya jika diperlukan?
Kita dapat membayangkan class adalah sketsa dari sebuah rumah. Yang secara detail berisi mengenai lantai, pintu, jendela, dll. Berdasarkan uraian tersebut kita dapat membangun sebuah rumah. Maka, rumah adalah suatu objek.
Karena banyak rumah dapat di bangun dari sketsa tersebut. Sehingga, kita dapat membuat banyak objek dari suatu class jika dianalogikan pada pemrograman berorientasi objek. Selain itu, objek pun dapat disebut sebagai turunan dari suatu class. Proses pembuatan objek ini disebut sebagai instantiation.
Dengan menggunakan class, program yang kita tulis akan lebih konsisten. Sehingga, dapat menjadikannya lebih rapih dan efisien.
Class memiliki suatu atribut, yaitu data yang terdapat di dalamnya (variable class dan instance variable) serta metode yang dapat di akses dengan tanda titik ( . )
Syntax untuk mendeskripsikan suatu class:
class NamaSuatuClass:
pernyataan-1
pernyataan-2
.
.
.
pernyataan-N
class Rumah():
#Instance attribute
def __init__(self,bahan,harga,lokasi):
# self adalah instance dari class
self.bahan = bahan
self.harga = harga
self.lokasi = lokasi
#membuat objek
rumah1 = Rumah("Kayu",700000000,"desa")
rumah2 = Rumah("Beton",1500000000,"tengah kota")
print(rumah1)
#Output:
<__main__.Rumah object at 0x0000019371D149C8>
Output di atas memberitahukan kepada kita bahwa rumah merupakan suatu objek pada lokasi memory tertentu pada komputer. Untuk mengakses nilai atribut tersebut, kita perlu menggunakan dot ( . ), lalu memanggil atribut yang ingin diketahui nilainya, seperti pada contoh di bawah ini:
rumah1.bahan
#output:
'Kayu'
rumah1.harga
$output:
700000000
Untuk mencetak seluruh nilai atribut dari suatu object "rumah1" terhadap parameter yang telah diketahui (bahan, harga, lokasi), kita dapat menggunakan __dict__ "dictionary".
rumah1.__dict__
#output:
{'bahan': 'Kayu', 'harga': 700000000, 'lokasi': 'desa'}
Perlu diperhatikan bahwa self juga merupakan instance dari suatu class. Oleh karena instance suatu kelas memiliki nilai yang berbeda-beda kita dapat menyatakan Rumah.harga = harga daripada self.harga = harga. Namun, karena setiap rumah tidak memiliki harga yang sama, kita harus menetapkan nilai yang berbeda untuk contoh yang berbeda. Oleh karena itu diperlukan variable khusus self yang dapat membantu kita untuk melacak contoh individu dari setiap kelas.
catatan [Pemrograman berorientasi objek]: Variable khusus tidak harus menggunakan kata self. Penggunaan self dimaksudkan untuk standarisasi penulisan class pada Python agar dapat dipahami oleh seluruh Python programmer untuk keseragaman penulisan kode.
Encapsulation adalah salah satu konsep fundamental pada pemrograman berorientasi objek. Encapsulation menggambarkan suatu ide untuk membungkus data dan metode yang bekerja pada suatu data di dalam satu unit. Hal ini memberikan batasan dalam mengakses suatu variabel dan metode secara langsung. Sehingga, dapat mencegah modifikasi data yang tidak disengaja. Hal tersebut sangatlah penting, karena dapat mencegah perubahan yang tidak disengaja. Bukan tidak dapat di ubah, namun, variabel objek tersebut hanya dapat di ubah dengan metode objek.
Python tidak memiliki kata kunci private seperti pada bahasa pemrograman yang lain. Sebagai gantinya, hal ini dapat dilakukan oleh encapsulation. Variable class yang tidak boleh di akses secara langsung diawali oleh dua tanda garis bawah seperti pada contoh di bawah ini:
class Halo:
def __init__(self, angka):
self.a = 123
self._b = 20
self.__c = 40
halo = Halo("angka")
print(halo.a)
print(halo._b)
print(halo.__c)
#output:
123
20
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-40-a2c62dd721c7> in <module>
8 print(halo.a)
9 print(halo._b)
---> 10 print(halo.__c)
11
AttributeError: 'Halo' object has no attribute '__c'
Dapat diperhatikan pada contoh di atas bahwa variable a dan _ b dapat tercetak. Namun, variable __ c memberikan AttributeError.
Private variable dapat di ubah dengan menggunakan metode get dan set yang dapat memberikan akses secara tidak langsung.
class Software():
#Instance attribute
def __init__(self):
self.__version = 1
# Instance method
def getVersion(self):
print(self.__version)
def setVersion(self, version):
self.__version = version
# instanstiate objek Software
obj = Software()
obj.getVersion()
obj.setVersion(3)
obj.getVersion()
#Output:
1
3
Dapat di lihat pada contoh di atas, bahwa, untuk mengubah software version dari 1 kepada version 3 diperlukan metode get dan set. Oleh karena itu untuk mengakses variable yang memiliki double underscore harus di ubah dengan cara yang tidak langsung, yaitu dengan mengunakan metode get dan set.
Inheritance memungkinkan kita untuk mewarisi atribut dan metode dari suatu kelas dasar (base)atau induk(parent). Hal ini sangat berguna karena kita membuat sub-kelas yang dapat menggunakan semua fungsi dari parent class. Selain itu, kita dapat menimpa atau menambahkan fungsi yang baru tanpa mempengaruhi parent class. Untuk memahami konsep inheritance dengan mudah, kita dapat menganalogikan sifat seorang anak mewarisi sifat orang tuanya. Sama hal nya pada Python yang memiliki dua kelas, yaitu:
Class yang mewarisi sifat disebut sebagai Child class, sedangkan class yang diwarisi sifat nya adalah Parent class.
Inheritance memiliki kemampuan untuk membuat Sub-classes yang berisi spesialisasi dari Parent class. Selanjutnya, inheritance dapat di bagi lagi menjadi empat tipe. Yaitu single, multilevel, hierarchical, dan multiple inheritance. Untuk memahaminya lebih jelas, mari kita lihat diagram di bawah ini.
Untuk memahaminya pada Python, mari kita telusuri satu persatu.
Pada inheritance, child class dapat mengakses seluruh metode yang telah didefinisikan pada parent class. Selain itu, child class dapat meliputi metode spesifik yang dimilikinya.
Dalam bahasa pemrograman berorientasi objek pada Python, class turunan dapat mewarisi class utama dengan cara memanggil kembali kelas utama di dalam tanda kurung.
Misalkan kita ingin membuat class untuk Hewan. Lalu, dari jenis hewan memiliki spesies kucing. Seperti pada contoh di bawah ini:
# Parent class
class Hewan:
def bicara(self):
print("Hewan berbicara")
# Child class mewarisi dari class Hewan
class Kucing(Hewan):
def meaow(self):
print("meaow....meaow....meaow..!!!")
k = Kucing()
k.meaow()
k.bicara()
#output:
meaow....meaow....meaow..!!!
Hewan berbicara
Dapat di lihat pada contoh di atas, hewan adalah parent class dari se ekor kucing. Sehingga ketika kita menggunakan metode meaow(), maka yang keluar adalah suara kucing. Namun, ketika kita menggunakan metode bicara() pada kucing, maka yang keluar adalah suara hewan karena class Kucing dapat menggunakan metode parent class Hewan.
Multilevel inheritance adalah kondisi dimana ketika suatu class mewariskan class yang lainnya. Tidak ada batasan hingga berapa banyak jumlah level yang dapat digunakan pada multilevel inheritance pada Python. Contoh syntax:
# Parent class
class Hewan:
def bicara(self):
print("Hewan berbicara")
# Child class mewarisi dari class Hewan
class Kucing(Hewan):
def meaow(self):
print("meaow....meaow....meaow..!!!")
# Child class AnakKucing mewarisi dari class hewan
class AnakKucing(Kucing):
def minum(self):
print("minum susu")
a_k = AnakKucing()
a_k.bicara()
a_k.meaow()
a_k.minum()
#Output:
Hewan berbicara
meaow....meaow....meaow..!!!
minum susu
Dapat di lihat pada contoh di atas, bahwa, class AnakKucing dapat mewarisi sifat dari Kucing dan Hewan.
Hierarchical inheritance memungkinkan kita menurunkan lebih dari satu child class untuk mewarisi sifat dari parent class.
# Class utama
class Parent:
def fungsi1(self):
print("Fungsi pada parent class.")
# class 1 turunan
class Child1(Parent):
def fungsi2(self):
print("Fungsi pada child 1.")
# class 2 turunan
class Child2(Parent):
def fungsi3(self):
print("Fungsi pada child 2.")
object1 = Child1()
object2 = Child2()
object1.fungsi1()
object1.fungsi2()
object2.fungsi1()
object2.fungsi3()
#Output:
Fungsi pada parent class.
Fungsi pada child 1.
Fungsi pada parent class.
Fungsi pada child 2.
Contoh di atas menunjukkan bahwa class turunan Child1 dan Child2 dapat menggunakan fungsi pada class parent yang sama.
Silahkan untuk mencobanya:
Multiple inheritance memungkinkan satu kelas turunan untuk mewarisi lebih dari satu kelas utama.
## parent 1
class Perhitungan1:
def penjumlahan(self, a, b):
return a+b
## parent 2
class Perhitungan2:
def perkalian(self, a, b):
return a*b
## child
class Child(Perhitungan1, Perhitungan2):
def pembagian(self, a, b):
return a/b
c = Child()
print(c.penjumlahan(20, 30))
print(c.perkalian(5, 4))
print(c.pembagian(6, 12))
#output:
50
20
0.5
Pada contoh di atas menunjukkan bahwa class Child mewarisi sifat dari dua parent class yaitu class Perhitungan1 dan Perhitungan2.
Silahkan untuk mencobanya:
Polymorphism adalah kemampuan untuk mengambil bentuk yang berbeda. Polymorphism dalam Python memungkinkan kita untuk mendefinisikan metode pada child class dengan menggunakan nama yang sama seperti pada parent class.
Polymorphism di bangun berdasarkan dua suku kata, yaitu Poly (banyak) dan Morphism (bentuk). Artinya adalah fungsi yang sama dapat digunakan pada tipe yang berbeda. Sehingga membuat membuat programming lebih intuitif dan mudah. Dalam bahasa pemrograman berorientasi objek pada Python, kita memiliki cara-cara yang berbeda untuk mendefinisikan polymorphism.
Class child mewarisi seluruh method dari parent class. Namun, ada beberapa kasus di mana metode tersebut tidak cocok dengan child class. Oleh karena itu, kita harus mengimplementasikan kembali metode yang pada child class yang dinamakan Method Overriding. Contohnya dapat di lihat pada bagian Polymorphism dengan inheritance. (link ke bawah)
Ada beberapa metode untuk menggunakan polymorphism pada pemrograman berorientasi objek Python. Kita dapat menggunakan fungsi berbeda, metode class atau objek untuk mendefinisikannya.
Kita dapat membuat fungsi yang dapat mengambil objek apapun untuk mengimplememtasikan polymorphism.
Contoh di atas adalah menggunakan fungsi yang sudah terintegrasi pada Python yaitu len(). Fungsi tersebut dapat digunakan untuk tipe data yang berbeda. Pada kasus di atas adalah contoh untuk menghitung jumlah huruf dari string, list dan pasangan key-value pada dictonary.
Kita dapat menggunakan konsep polymorphism ketika membuat metode class. Python memungkinkan class yang berbeda untuk menggunakan metode dengan nama yang sama. Kemudian kita dapat memanggil metode tersebut dengan mengabaikan objek yang sedang kita gunakan. Contoh:
class Kucing:
def __init__(self, nama, umur):
self.nama = nama
self.umur = umur
def bersuara(self):
print("Meow")
class Dog:
def __init__(self, nama, umur):
self.nama = nama
self.umur = umur
def bersuara(self):
print("Guk..guk...")
kucing1 = Kucing("Tom", 3)
anjing1 = Dog("Spike", 4)
for hewan in (kucing1, anjing1):
hewan.bersuara()
# Output:
Meow
Guk..guk..
Kita telah membuat class Kucing dan Anjing. Keduanya memiliki struktur dan metode yang sama, yaitu bersuara().
Polymorphism pada pemrograman berorientasi objek Python mendefinisikan child class yang memiliki kesamaan nama metode pada parent class. Pada inheritance, child class mewarisi metode dari parent class. Selain itu, memungkinkan untuk memodifikasi metode di dalam child class yang telah diwarisi dari parent class. Contoh polymorphism dengan Inheritance dapat dilihat pada contoh di bawah ini:
class Burung:
def intro(self):
print("Di dunia ini ada beberapa type berbeda dari spesies burung")
def terbang(self):
print("Hampir semua burung dapat terbang, namun ada beberapa yang tidak dapat terbang")
class Elang(Burung):
def terbang(self):
print("Elang dapat terbang")
class BurungUnta(Burung):
def terbang(self):
print("Burung unta tidak dapat terbang")
obj_burung = Burung()
obj_elang = Elang()
obj_burung_unta = BurungUnta()
obj_burung.intro()
obj_burung.terbang()
obj_elang.intro()
obj_elang.terbang()
obj_burung_unta.intro()
obj_burung_unta.terbang()
#Output:
Di dunia ini ada beberapa type berbeda dari spesies burung
Hampir semua burung dapat terbang, namun ada beberapa yang tidak dapat terbang
Di dunia ini ada beberapa type berbeda dari spesies burung
Elang dapat terbang
Di dunia ini ada beberapa type berbeda dari spesies burung
Burung unta tidak dapat terbang
Contoh di atas adalah metode overriding, dimana metode terbang() pada parent class Burung, di timpa oleh oleh masing-masing metode child class-nya yang terdapat pada class Elang dan BurungUnta.
Abstraction adalah pilar terakhir dari ke-empat pilar pemrograman berorientasi objek yang di bahas pada artikel ini. Abstraction memiliki tujuan untuk menyembunyikan detail yang tidak terlalu penting dari user. Kita dapat membayangkannya seperti sebuah smartphone, dimana untuk menggunakan device tersebut, kita tidak perlu memahami apa yang terjadi di dalam logika elektronik dan software di dalamnya. Namun, kita hanya perlu menekan tombol power dan menyentuh layar dengan menggunakan tangan kita agar alat tersebut bisa bekerja dengan semestinya.
Python memiliki module untuk menggunakan Abstract Base Classes (ABC). Modulenya bernama abc. Contoh kode di bawah ini adalah cara penggunaan modul abc untuk mendefinisikan abstraction.
Untuk menggunakan metode abstrak, kita harus menambahkan dekorator pada metode yang akan dijadikan abstrak dengan cara menambahkan @abstraction di atas metode tersebut. Untuk menunjukkan bahwa metode tersebut adalah abstrak. Mari kita coba untuk menjalankan code ini.
from abc import ABC, abstractmethod
class Bentuk(ABC):
@abstractmethod
def luas(self):
return self.__sisi * self.__sisi
@abstractmethod
def keliling(self):
return 4 * self.__sisi
class Persegi(Bentuk):
def __init__(self, sisi):
self.__sisi = sisi
persegi = Persegi(6)
#Output:
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-159-d0755e2ccceb> in <module>
13 self.__sisi = sisi
14
---> 15 persegi = Persegi(6)
TypeError: Can't instantiate abstract class Persegi with abstract methods keliling, luas
Kode di atas memberikan peringatan TypeError karena metode di dalam class Bentuk yaitu area dan perimeter adalah metode yang abstrak. Perlu diperhatikan juga ketika kita menggunakan class Persegi, maka, akan menimbulkan error yang sama, karena pada kode di atas kita mewarisi parent class Bentuk pada child class Persegi. Untuk menjalankan metode tersebut, kita harus mengimplementasikan kembali metode yang ada pada parent class Bentuk agar tidak menimbulkan pesan error, seperti pada contoh di bawah ini:
from abc import ABC, abstractmethod
class Bentuk(ABC):
@abstractmethod
def luas(self):
return self.__sisi * self.__sisi
@abstractmethod
def keliling(self):
return 4 * self.__sisi
class Persegi(Bentuk):
def __init__(self, sisi):
self.__sisi = sisi
def luas(self):
return self.__sisi * self.__sisi
def keliling(self):
return 4 * self.__sisi
persegi = Persegi(6)
print(persegi.luas())
print(persegi.keliling())
#Output:
36
24
Pada artikel ini kita telah membahas mengenai empat pilar pemrograman berorientasi objek pada Python serta contoh penggunaannya. Sehingga lebih mudah untuk memahami konsep penting dalam pemrograman berorientasi objek.
Anda dapat membaca artikel lain mengenai dasar pemrograman python. Anda pun dapat mendownload catatan mengenai OOP dalam Jupyter notebook pada link di bawah ini:
Terima kasih telah meluangkan waktunya untuk membaca. Semoga memberikan suatu manfaat.
Python Data Visualisasi dengan Seaborn
Mendeteksi Object Dengan Tensorflow
IoT Dengan Python dan Raspberry Pi
Mendeteksi Object Dengan Raspberry Pi
https://www.programiz.com
python-textbok.readthedocs.io
Edureka
Javatpoint
Python-course.eu
Muhammad Zacky Asy'ari