Python Class dan Object: Fungsi dan Cara Membuatnya

Pada konten sebelumnya, kita telah membahas bagaimana cara menggunakan function. Pada konten kali ini, kita akan membahas mengenai salah satu fitur dari Python, yaitu class.

Apa itu Python Class dan Perbedaannya dengan Function?

Salah satu perbedaan mendasar Python class dan function adalah bagaimana cara class dan function mengartikan sebuah variabel: apakah variabel tersebut dianggap variabel lokal (hanya bisa diakses di dalam fungsi atau modul tempatnya berada) atau variabel global (dapat digunakan di seluruh program). 

Untuk dapat melihat perbedaannya, mari kita perhatikan contoh berikut ini: 

def hewan():
	def hewan1():
		jenis = "anjing"
	def hewan2() :
		nonlocal jenis
		jenis = "kucing”
	def hewan3():
		global jenis
		jenis = "bebek"

	jenis = "ayam"
	hewan1()
	print (f"Jenis hewan pertama adalah {jenis}")
	hewan2()
	print (f"]enis hewan kedua adalah {jenis}")
	hewan3()
	print (f"]enis hewan ketiga adalah {jenis}")
  
hewan()
print(f"]enis hewan adalah {jenis}")

# Output Jenis hewan pertama adalah ayam
Jenis hewan kedua adalah kucing
Jenis hewan ketiga adalah kucing
Jenis hewan adalah bebek

Perhatikan contoh di atas. Dalam contoh tersebut, kita membuat sebuah function hewan untuk mengeluarkan berbagai jenis hewan. Perhatikan perbedaan sifat variabel di tiap function di dalam function hewan(). 

Pada function hewan1(), kita menyatakan jenis = “anjing” dan variabel jenis ini merupakan sebuah local variable yang hanya dapat digunakan pada function tersebut. 

Pada function hewan2(), kita menyatakan jenis = “kucing” dan kita juga menyatakan bahwa jenis pada hewan2 merupakan sebuah nonlocal variable, di mana variabel tersebut dapat digunakan pada keseluruhan function. 

Pada function hewan3(), kita menyatakan jenis = “bebek” dan kita juga menyatakan bahwa jenis pada hewan3() merupakan sebuah global variable, di mana variabel tersebut dapat digunakan pada keseluruhan Python script.  

Di dalam function hewan() itu sendiri, kita menyatakan sebuah local variable jenis yaitu “ayam”. Perhatikan ketika kita mengeluarkan output dari masing-masing function tersebut.

Ketika hewan1() kita panggil, lalu kita coba untuk mengeluarkan isi variabel jenis, ternyata hasil keluarannya adalah “ayam” dan bukan “anjing”. Ini artinya, local variable hanya dapat berfungsi di dalam function tersebut dan apabila tidak dinyatakan dalam variabel lain ketika function dipanggil, maka local variable dalam hewan1() akan hilang dan digantikan dengan variabel lain (di mana pada kasus hewan(), local variable yang dipanggil adalah “ayam”).

Ketika hewan2() kita panggil, lalu kita coba keluarkan isi variabelnya, maka variabel jenis berubah menjadi “kucing”. Ini artinya apabila variabel tersebut kita nyatakan sebagai nonlocal variable, maka nilai variabel tersebut akan berlaku selama masih ada di dalam function hewan(). 

Ketika hewan3() kita panggil, lalu kita coba keluarkan isi variabelnya, ternyata hasil keluarannya masih “kucing”. Untuk variabel jenis di dalam hewan3() ini, kita nyatakan sebagai global variable. Ketika kita coba memanggil variabel jenis ini di luar dari function hewan() yang kita buat, ternyata variabel jenis ini mengeluarkan “bebek” yang merupakan global variable. 

Dari sini, kita dapat menyimpulkan bahwa global variable dapat digunakan di keseluruhan Python script yang kita buat.

Kegunaan Python Class

Dari percobaan mengenai function sebelumnya, maka kita bisa melihat bagaimana tidak efektifnya dalam penggunaan variabel di dalam sebuah function. Alasannya, kita harus menyatakan sifat dari tiap variabel tersebut, apakah variabel tersebut digunakan secara local, nonlocal, atau global. 

Untuk itu, Python memiliki sebuah metode lain yang disebut class, di mana di dalam class ini kita bisa membuat banyak function, yang biasa disebut sebagai object. Dan kita bisa menginisialisasi variabel itu sendiri di dalam class, apakah akan digunakan untuk local maupun nonlocal. 

Dikutip dari Geeks for Geeks, class biasa digunakan untuk membuat sebuah blueprint dari object. Class ini dapat berguna apabila kita ingin membuat sebuah program yang memanfaatkan object (object-oriented programming/OOP). 

Mungkin untuk pemula, definisi class ini terdengar asing. Kita akan bahas satu per satu di sini. 

Cara Menggunakan Python Class dan Python Object

Class sendiri pada Python diartikan sebagai instansi bagi sebuah object. Sebuah class memiliki ciri penulisan diawali dengan class, lalu nama class itu sendiri, mirip seperti cara penulisan function, berikut contohnya: 

class hewan():
	pass

Pada contoh di atas, kita membuat sebuah class bernama hewan(). Biasanya, dalam penulisan sebuah class, diikuti dengan object untuk menentukan sifat dari class itu sendiri. Selain object, kita juga dapat memberikan input ke dalamnya.

Berikut contoh sederhana dari sebuah class yang hanya memiliki object dan tanpa input: 

class hewan():
	def anjing():
		print ("gukguk")
	def kucing():
		print ("meong")
	def bebek():
		print("kwek kwek")
	def ayam():
		print ("kukuruyuk")

print(hewan.ayam())

# Output kukuruyuk

Pada contoh di atas, kita memanggil class hewan dan kita ingin mengeluarkan output berupa suara hewan, di mana pada contoh tersebut kita menggunakan object yaitu ayam(). Untuk pemanggilan perintah pada suatu object di dalam class, kita menggunakan <instansi>.<object_name()>.

Ketika kita akan mengeluarkan output dari hewan.ayam(), maka class akan otomatis memanggil fungsi, atau di sini kita sebut dengan object di dalam instansi yang telah kita buat, dan akan mengeluarkan output “kukuruyuk” sesuai dengan perintah print di dalam object ayam().

Cara Inisialisasi dan Penamaan Variabel di Python

Pada contoh sebelumnya, kita telah melihat sebuah class yang sederhana untuk mengeluarkan output string sesuai dengan object yang kita panggil. Namun, apabila terdapat input di dalam class itu, maka kita perlu memasangkan tiap input ke dalam tiap object yang memerlukan input tersebut yang berada di dalam class. 

Bila kita melakukan hal ini, maka tidak akan ada bedanya dengan local variable di dalam sebuah function. Oleh karena itu, terdapat sebuah method yang digunakan untuk inisialisasi variabel, yang dapat digunakan secara global ke dalam seluruh object yang dibentuk di dalam class. 

Inisialisasi tersebut dilakukan dengan menambahkan sebuah function def init(self) atau biasa bisa disebut dengan method dalam class tersebut. Function init ini tidak bisa mengakses variabel input yang diberikan kepada class, oleh karena itu kita perlu menambahkan “self” yang digunakan agar method dapat membaca variabel input. 

Untuk tiap variabel input inisialisasi di dalam class akan dinyatakan dalam bentuk self.< input >. Untuk contoh penulisan sebuah class yang memiliki method dapat dilihat pada contoh di bawah berikut ini:

class hewan():
	def __init__(self, jenis, nama):
		self. jenis = jenis
		self.nama = nama

	def jenis():
		print(self.jenis)

	def nama):
		print(self.nama)

binatang = hewan ("reptil", "komodo")

text = f"(binatang.nama} termasuk ke dalam kategori hewan {binatang.jenis}"
print(text)

# Output komodo termasuk ke dalam kategori hewan reptil

Apa yang terjadi dalam contoh di atas ini? Pada contoh di atas, kita membuat sebuah class bernama hewan(). Class atau instansi ini akan dipanggil sebagai pada variabel “binatang” dengan input berupa jenis “reptil” dan juga nama “komodo”. 

Jadi, apabila kita memberikan dua input ketika memanggil variabel “binatang”, maka input pertama akan masuk menjadi input bagi “jenis” yang kita definisikan sebagai self.jenis dan akan menjadi input untuk object jenis(), lalu input kedua akan masuk menjadi input bagi “nama” yang kita definisikan sebagai self.nama dan akan menjadi input untuk object nama(). 

Function init ini merupakan sebuah method dalam class yang fungsinya adalah untuk menginisialisasi variabel input (dalam contoh di atas yaitu “jenis” dan “nama”) menjadi terkesan sebuah nonlocal variable dalam class tersebut. 

Karena variabel self.< input > ini bertindak seperti nonlocal variable, ketika kita membuat function jenis(), maka kita hanya perlu menuliskan print(self.jenis). Begitu juga ketika kita membuat function nama(), maka kita hanya perlu menuliskan print(self.nama) untuk mengeluarkan masing-masing variabel tersebut.

Setelah class, method, dan object telah ditentukan, maka kita bisa membuat variabel “binatang” yang dituliskan sebagai hewan (< input_jenis >,< input_nama >). Perhatikan di sini bahwa ketika kita memanggil class di mana terdapat method init di dalamnya.

Maka input dari class tersebut sama seperti jumlah input yang ada di init namun mengecualikan “self” dikarenakan “self” hanya digunakan untuk menginisialisasi variabel saja, sehingga kita memasukan dua buah input di sini, yaitu “reptil” sebagai input untuk object “jenis”, dan “komodo” sebagai input untuk object “nama”. 

Untuk memanggil object ini, kita hanya perlu menuliskan bentuk < instansi >.< object > untuk mengeluarkan isi dari object tersebut, seperti yang dicontohkan untuk memanggil nama hewan tersebut “binatang.nama” dan jenis hewan tersebut “binatang.jenis”.

Perhatikan bahwa pada kedua contoh penulisan class pada konten ini, memiliki cara pemanggilan object yang berbeda. 

Pada contoh pertama, kita menggunakan perintah print(hewan.ayam()) untuk mengeluarkan output “kukuruyuk”. Namun pada contoh kedua, untuk memanggil output, kita menuliskan binatang.nama tanpa menggunakan tanda kurung “()” di akhir object untuk mengeluarkan output-nya. 

Hal ini disebabkan karena kita menggunakan inisialisasi self pada contoh kedua, sehingga kita tidak menggunakan tanda kurung “()” untuk memanggil isi object, karena tanda kurung tersebut biasa digunakan untuk memanggil sebuah function biasa, bukan object. 

Cara Mengakses Python Class dan Object di Built-In Function

Pada konten kali ini, kita belajar mengenai cara menggunakan class dan juga object, aplikasinya, dan juga perbedaannya dengan function. Kebanyakan programmer yang membuat library sendiri pada Python, menggunakan gabungan dari class dan object ini untuk membuat custom library masing-masing. 

Apabila kita menggunakan import < library > ketika kita membuat sebuah blok script pada Python, secara tidak langsung sebenarnya kita sedang mengakses class dan object yang telah dibuat orang lain atau yang merupakan built-in function dari Python.

Berikut merupakan salah satu contoh untuk kita dapat melihat sebuah class yang merupakan built-in function dari Python, dengan bantuan fungsi help(): 

from datetime import datetime

help(datetime)

# Output Help on class datetime in module datetime:

class datetime(date)
	datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])

	The year, month and day arguments are required. tzinfo may be None, or an
	instance of a tzinfo subclass. The remaining arguments may be ints.

	Method resolution order:
		datetime
		date
		builtins.object

	Methods defined here:

	__add__(self, value, /)
	Return self+value.

	__eq_(self, value, /)
	Return self>=value.

	__ge__(self, value, /)
	Return self==value.

	__getattribute_(self, name, /)
	Return getattr(self, name).

	__gt__(self, value, /)
	Return self>value.

	__hash__(self, /)
	Return hash(self).

	__le__(self, value, /)
	Return self<=value.

	__lt__(self, value, /)
	Return self<value,

	__ne__(self, value, /)
	Return self!=value

	__radd__(self, value, /)
	Return value+self.

Pada contoh di atas, merupakan salah satu built-in function yang cukup umum dipakai oleh programmer, untuk menyatakan sebuah tipe data datetime pada variabel. Apabila kita gunakan help(datetime), maka kita bisa melihat bahwa fungsi datetime tersebut juga dibuat dengan menggunakan class dan banyak object seperti add dan lainnya. 

Oleh karena itu, seorang programmer, terutama yang ingin membuat custom library sendiri, dapat menggunakan dan memanfaatkan penuh fungsi class dan object ini.