Dalam tutorial ini, Anda akan belajar tentang Pemrograman Berorientasi Objek (OOP) dengan Python dan konsep dasarnya dengan bantuan contoh.
Video: Pemrograman Berorientasi Objek dengan Python
Pemrograman berorientasi objek
Python adalah bahasa pemrograman multi-paradigma. Ini mendukung pendekatan pemrograman yang berbeda.
Salah satu pendekatan populer untuk memecahkan masalah pemrograman adalah dengan membuat objek. Ini dikenal sebagai Pemrograman Berorientasi Objek (OOP).
Sebuah benda memiliki dua karakteristik:
- atribut
- tingkah laku
Mari kita ambil contoh:
Burung beo dapat menjadi objek, karena memiliki sifat sebagai berikut:
- nama, umur, warna sebagai atribut
- bernyanyi, menari sebagai perilaku
Konsep OOP dengan Python berfokus pada pembuatan kode yang dapat digunakan kembali. Konsep ini juga dikenal dengan DRY (Don't Repeat Yourself).
Dalam Python, konsep OOP mengikuti beberapa prinsip dasar:
Kelas
Kelas adalah cetak biru untuk objek tersebut.
Kita dapat menganggap kelas sebagai sketsa burung beo berlabel. Berisi semua detail tentang nama, warna, ukuran dll. Berdasarkan uraian tersebut, kita dapat mempelajari tentang burung beo. Di sini, burung beo adalah objek.
Contoh untuk kelas burung beo dapat berupa:
class Parrot: lulus
Di sini, kami menggunakan classkata kunci untuk mendefinisikan kelas Parrot kosong. Dari kelas, kami membuat instance. Instance adalah objek tertentu yang dibuat dari kelas tertentu.
Obyek
Objek (instance) adalah instance kelas. Saat kelas ditentukan, hanya deskripsi untuk objek yang ditentukan. Oleh karena itu, tidak ada memori atau penyimpanan yang dialokasikan.
Contoh objek kelas burung beo dapat berupa:
obj = Burung beo ()
Di sini, obj adalah objek kelas Parrot.
Misalkan kita memiliki detail burung beo. Sekarang, kami akan menunjukkan cara membuat kelas dan objek burung beo.
Contoh 1: Membuat Kelas dan Objek dengan Python
class Parrot: # class attribute species = "bird" # instance attribute def __init__(self, name, age): self.name = name self.age = age # instantiate the Parrot class blu = Parrot("Blu", 10) woo = Parrot("Woo", 15) # access the class attributes print("Blu is a ()".format(blu.__class__.species)) print("Woo is also a ()".format(woo.__class__.species)) # access the instance attributes print("() is () years old".format( blu.name, blu.age)) print("() is () years old".format( woo.name, woo.age))
Keluaran
Blu adalah seekor burung Woo juga seekor burung Blu adalah 10 tahun Woo berumur 15 tahun
Pada program di atas, kami membuat kelas dengan nama Parrot. Kemudian, kami mendefinisikan atribut. Atribut merupakan ciri dari suatu objek.
Atribut ini didefinisikan di dalam __init__metode kelas. Ini adalah metode penginisialisasi yang dijalankan pertama kali segera setelah objek dibuat.
Kemudian, kami membuat instance dari kelas Parrot. Di sini, blu dan woo adalah referensi (nilai) ke objek baru kita.
Kita dapat mengakses atribut kelas menggunakan __class__.species. Atribut kelas sama untuk semua instance kelas. Demikian pula, kami mengakses atribut instance menggunakan blu.namedan blu.age. Namun, atribut instance berbeda untuk setiap instance kelas.
Untuk mempelajari lebih lanjut tentang kelas dan objek, buka Kelas dan Objek Python
Metode
Metode adalah fungsi yang ditentukan di dalam tubuh kelas. Mereka digunakan untuk mendefinisikan perilaku suatu objek.
Contoh 2: Membuat Metode dengan Python
class Parrot: # instance attributes def __init__(self, name, age): self.name = name self.age = age # instance method def sing(self, song): return "() sings ()".format(self.name, song) def dance(self): return "() is now dancing".format(self.name) # instantiate the object blu = Parrot("Blu", 10) # call our instance methods print(blu.sing("'Happy'")) print(blu.dance())
Keluaran
Blu menyanyikan 'Happy' Blu sekarang menari
Dalam program di atas, kami mendefinisikan dua metode yaitu sing()dan dance(). Ini disebut metode instance karena mereka dipanggil pada objek instance yaitu blu.
Warisan
Inheritance is a way of creating a new class for using details of an existing class without modifying it. The newly formed class is a derived class (or child class). Similarly, the existing class is a base class (or parent class).
Example 3: Use of Inheritance in Python
# parent class class Bird: def __init__(self): print("Bird is ready") def whoisThis(self): print("Bird") def swim(self): print("Swim faster") # child class class Penguin(Bird): def __init__(self): # call super() function super().__init__() print("Penguin is ready") def whoisThis(self): print("Penguin") def run(self): print("Run faster") peggy = Penguin() peggy.whoisThis() peggy.swim() peggy.run()
Output
Bird is ready Penguin is ready Penguin Swim faster Run faster
In the above program, we created two classes i.e. Bird (parent class) and Penguin (child class). The child class inherits the functions of parent class. We can see this from the swim() method.
Again, the child class modified the behavior of the parent class. We can see this from the whoisThis() method. Furthermore, we extend the functions of the parent class, by creating a new run() method.
Additionally, we use the super() function inside the __init__() method. This allows us to run the __init__() method of the parent class inside the child class.
Encapsulation
Using OOP in Python, we can restrict access to methods and variables. This prevents data from direct modification which is called encapsulation. In Python, we denote private attributes using underscore as the prefix i.e single _ or double __.
Example 4: Data Encapsulation in Python
class Computer: def __init__(self): self.__maxprice = 900 def sell(self): print("Selling Price: ()".format(self.__maxprice)) def setMaxPrice(self, price): self.__maxprice = price c = Computer() c.sell() # change the price c.__maxprice = 1000 c.sell() # using setter function c.setMaxPrice(1000) c.sell()
Output
Selling Price: 900 Selling Price: 900 Selling Price: 1000
In the above program, we defined a Computer class.
We used __init__() method to store the maximum selling price of Computer. We tried to modify the price. However, we can't change it because Python treats the __maxprice as private attributes.
As shown, to change the value, we have to use a setter function i.e setMaxPrice() which takes price as a parameter.
Polymorphism
Polymorphism is an ability (in OOP) to use a common interface for multiple forms (data types).
Suppose, we need to color a shape, there are multiple shape options (rectangle, square, circle). However we could use the same method to color any shape. This concept is called Polymorphism.
Example 5: Using Polymorphism in Python
class Parrot: def fly(self): print("Parrot can fly") def swim(self): print("Parrot can't swim") class Penguin: def fly(self): print("Penguin can't fly") def swim(self): print("Penguin can swim") # common interface def flying_test(bird): bird.fly() #instantiate objects blu = Parrot() peggy = Penguin() # passing the object flying_test(blu) flying_test(peggy)
Output
Parrot can fly Penguin can't fly
In the above program, we defined two classes Parrot and Penguin. Each of them have a common fly() method. However, their functions are different.
Untuk menggunakan polimorfisme, kami membuat antarmuka umum yaitu flying_test()fungsi yang mengambil objek apa pun dan memanggil fly()metode objek. Jadi, ketika kami melewati objek blu dan peggy dalam flying_test()fungsi tersebut, itu berjalan secara efektif.
Poin Penting untuk Diingat:
- Pemrograman Berorientasi Objek membuat program mudah dipahami dan juga efisien.
- Karena kelas dapat dibagikan, kode dapat digunakan kembali.
- Data aman dan terjamin dengan abstraksi data.
- Polimorfisme memungkinkan antarmuka yang sama untuk objek yang berbeda, sehingga pemrogram dapat menulis kode yang efisien.
