Pemrograman Berorientasi Objek di Python: Panduan Lengkap

Menginstansiasi objek

Untuk menginstansiasi sebuah objek, ketik nama class, diikuti dua tanda kurung. Anda dapat menugaskannya ke variabel untuk melacak objek tersebut.

ozzy = Dog()

Dan cetak:

print(ozzy)

<__main__.Dog object at 0x111f47278>

Menambahkan atribut ke sebuah class

Setelah mencetak ozzy, jelas bahwa objek ini adalah seekor anjing. Namun Anda belum menambahkan atribut apa pun. Mari beri class Dog nama dan usia dengan menuliskannya ulang:

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

Anda dapat melihat bahwa fungsinya kini menerima dua argumen setelah self: name dan age. Keduanya kemudian ditetapkan ke self.name dan self.age. Anda sekarang dapat membuat objek ozzy baru dengan nama dan usia:

ozzy = Dog("Ozzy", 2)

Untuk mengakses atribut objek di Python, Anda dapat menggunakan notasi titik. Ini dilakukan dengan mengetik nama objek, diikuti titik dan nama atributnya

print(ozzy.name)

print(ozzy.age)

Ozzy
2

Ini juga dapat digabungkan dalam kalimat yang lebih lengkap:

print(ozzy.name + " is " + str(ozzy.age) + " year(s) old.")

Ozzy is 2 year(s) old.

Fungsi str() digunakan di sini untuk mengonversi atribut age, yang berupa integer, menjadi string, sehingga Anda dapat menggunakannya dalam fungsi print().

Mendefinisikan method dalam sebuah class

Sekarang Anda memiliki class Dog, class ini memang memiliki nama dan usia yang dapat Anda pantau, tetapi belum melakukan apa pun. Di sinilah instance method berperan. Anda dapat menulis ulang class untuk kini menyertakan method bark(). Perhatikan bagaimana keyword def digunakan lagi, serta argumen self.

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def bark(self):
        print("bark bark!")

Method bark kini dapat dipanggil dengan notasi titik, setelah menginstansiasi objek ozzy yang baru. Method ini akan mencetak "bark bark!" ke layar. Perhatikan tanda kurung pada .bark(). Ini selalu digunakan saat memanggil method. Tanda kurungnya kosong dalam kasus ini, karena method bark() tidak menerima argumen apa pun.

ozzy = Dog("Ozzy", 2)

ozzy.bark()

bark bark!

Ingat ketika Anda mencetak ozzy sebelumnya? Kode di bawah ini kini menerapkan fungsionalitas tersebut dalam class Dog, dengan method doginfo(). Anda kemudian menginstansiasi beberapa objek dengan properti berbeda dan memanggil method tersebut pada masing-masing objek.

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def bark(self):
        print("bark bark!")

    def doginfo(self):
        print(self.name + " is " + str(self.age) + " year(s) old.")

ozzy = Dog("Ozzy", 2)
skippy = Dog("Skippy", 12)
filou = Dog("Filou", 8)

ozzy.doginfo()
skippy.doginfo()
filou.doginfo()

Ozzy is 2 year(s) old.
Skippy is 12 year(s) old.
Filou is 8 year(s) old.

Seperti yang Anda lihat, Anda dapat memanggil method doginfo() pada objek dengan notasi titik. Responsnya kini bergantung pada objek Dog mana yang Anda panggil method-nya.

Karena anjing bertambah tua, akan lebih baik jika Anda bisa menyesuaikan usianya. Ozzy baru saja berusia 3 tahun, jadi mari ubah usianya.

ozzy.age = 3

print(ozzy.age)

3

Semudah menetapkan nilai baru ke atribut. Anda juga bisa menerapkan ini sebagai method birthday() dalam class Dog:

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def bark(self):
        print("bark bark!")

    def doginfo(self):
        print(self.name + " is " + str(self.age) + " year(s) old.")

    def birthday(self):
        self.age +=1

ozzy = Dog("Ozzy", 2)

print(ozzy.age)

2

ozzy.birthday()

print(ozzy.age)

3

Sekarang, Anda tidak perlu lagi mengubah usia anjing secara manual. Kapan pun ulang tahunnya, Anda cukup memanggil method birthday(). 

Meneruskan argumen ke method

Anda ingin anjing-anjing kita memiliki teman. Ini sebaiknya bersifat opsional karena tidak semua anjing suka bersosialisasi.

Lihat method setBuddy() di bawah. Method ini menerima self, seperti biasa, dan buddy sebagai argumen. Dalam hal ini, buddy akan menjadi objek Dog lain. Tetapkan atribut self.buddy ke buddy, dan atribut buddy.buddy ke self.

Ini berarti relasinya bersifat timbal balik; Anda adalah teman dari teman Anda. Dalam kasus ini, Filou akan menjadi teman Ozzy, yang berarti Ozzy otomatis menjadi teman Filou.

Anda juga bisa menetapkan atribut ini secara manual alih-alih mendefinisikan method, tetapi itu akan memerlukan lebih banyak pekerjaan (menulis dua baris kode alih-alih satu) setiap kali Anda ingin menetapkan seorang teman.

Perhatikan bahwa di Python, Anda tidak perlu menentukan tipe argumennya. Jika ini Java, itu akan diperlukan.

class Dog:

    def __init__(self, name, age):  
        self.name = name
        self.age = age

    def bark(self):
        print("bark bark!")

    def doginfo(self):
        print(self.name + " is " + str(self.age) + " year(s) old.")

    def birthday(self):
        self.age +=1

    def setBuddy(self, buddy):
        self.buddy = buddy
        buddy.buddy = self

Sekarang Anda dapat memanggil method tersebut dengan notasi titik dan meneruskannya objek Dog lain. Dalam hal ini, teman Ozzy adalah Filou:

ozzy = Dog("Ozzy", 2)
filou = Dog("Filou", 8)

ozzy.setBuddy(filou)

Jika sekarang Anda ingin mendapatkan informasi tentang teman Ozzy, Anda dapat menggunakan notasi titik dua kali: Pertama, untuk merujuk pada teman Ozzy, dan kedua untuk merujuk pada atributnya.

print(ozzy.buddy.name)
print(ozzy.buddy.age)

Filou
8

Perhatikan bagaimana ini juga dapat dilakukan untuk Filou.

print(filou.buddy.name)
print(filou.buddy.age)

Ozzy
2

Method milik teman juga dapat dipanggil. Argumen self yang diteruskan ke doginfo() sekarang adalah ozzy.buddy, yaitu filou.

ozzy.buddy.doginfo()

Filou is 8 year(s) old.

Contoh OOP Python

Salah satu contoh di mana pemrograman berorientasi objek di Python berguna adalah tutorial Python For Finance: Algorithmic Trading kami. Di dalamnya, kami menjelaskan cara menyiapkan strategi trading untuk portofolio saham.

Strategi trading didasarkan pada moving average harga saham. Jika signals['short_mavg'][short_window:] > signals['long_mavg'][short_window:] terpenuhi, sebuah sinyal dibuat. Sinyal ini adalah prediksi untuk perubahan harga saham di masa depan.

Pada kode di bawah, Anda akan melihat bahwa ada inisialisasi terlebih dahulu, diikuti perhitungan moving average dan pembuatan sinyal. Karena ini bukan kode berorientasi objek, ini hanyalah satu potongan besar yang dieksekusi sekaligus.

Perhatikan bahwa kita menggunakan aapl pada contoh, yang merupakan ticker saham Apple. Jika Anda ingin melakukannya untuk saham lain, Anda harus menulis ulang kodenya.

# Initialize
short_window = 40
long_window = 100
signals = pd.DataFrame(index=aapl.index)
signals['signal'] = 0.0

# Create short simple moving average over the short window
signals['short_mavg'] = aapl['Close'].rolling(window=short_window, min_periods=1, center=False).mean()

# Create long simple moving average over the long window
signals['long_mavg'] = aapl['Close'].rolling(window=long_window, min_periods=1, center=False).mean()

# Create signals
signals['signal'][short_window:] = np.where(signals['short_mavg'][short_window:] > signals['long_mavg'][short_window:], 1.0, 0.0)   

# Generate trading orders
signals['positions'] = signals['signal'].diff()

# Print `signals`
print(signals)

Dalam pendekatan berorientasi objek, Anda hanya perlu menulis kode inisialisasi dan pembuatan sinyal sekali.

Anda kemudian dapat membuat objek baru untuk setiap saham yang ingin Anda hitung strateginya, dan memanggil method generate_signals() pada objek tersebut. Perhatikan bahwa kode OOP sangat mirip dengan kode di atas, dengan tambahan self.

class MovingAverage():

    def __init__(self, symbol, bars, short_window, long_window):
        self.symbol = symbol
        self.bars = bars
        self.short_window = short_window
        self.long_window = long_window

    def generate_signals(self):
        signals = pd.DataFrame(index=self.bars.index)
        signals['signal'] = 0.0

        signals['short_mavg'] = self.bars['Close'].rolling(window=self.short_window, min_periods=1, center=False).mean()
        signals['long_mavg'] = bars['Close'].rolling(window=self.long_window, min_periods=1, center=False).mean()

        signals['signal'][self.short_window:] = np.where(signals['short_mavg'][self.short_window:] > signals['long_mavg'][self.short_window:], 1.0, 0.0)   

        signals['positions'] = signals['signal'].diff()   

        return signals

Sekarang Anda cukup menginstansiasi sebuah objek dengan parameter yang Anda inginkan dan menghasilkan sinyal untuknya.

apple = MovingAverage('aapl', aapl, 40, 100)
print(apple.generate_signals())

Melakukan ini untuk saham lain menjadi sangat mudah. Ini hanya soal menginstansiasi objek baru dengan simbol saham yang berbeda.

microsoft = MovingAverage('msft', msft, 40, 100)
print(microsoft.generate_signals())

Pikiran Akhir

Kita telah membahas beberapa konsep utama OOP di Python. Anda kini tahu cara mendeklarasikan class dan method, menginstansiasi objek, menetapkan atributnya, dan memanggil instance method. Keterampilan ini akan berguna untuk karier Anda sebagai data scientist.

Untuk pendekatan yang lebih modern dalam mendefinisikan class, lihat Python data classes, yang mengurangi boilerplate code. Jika Anda ingin memperluas konsep kunci yang Anda perlukan untuk bekerja lebih lanjut dengan Python, pastikan untuk melihat kursus Intermediate Python kami.

Dengan OOP, kode Anda akan bertambah kompleks seiring program menjadi lebih besar. Anda akan memiliki berbagai class, subclass, objek, pewarisan, instance method, dan lainnya. Untuk skenario pewarisan yang kompleks, pelajari tentang multiple inheritance dan super().