Class Python merupakan salah satu bahasa pemograman berorientasi objek (OOP).

Konsep OOP sangat membantu dalam membuat aplikasi terutama yang berskala besar. Pada bagian pembuatan aplikasi kita akan banyak menerapkan konsep OOP dalam hal ini class. Disini akan dijelaskan mengenai hal-hal umum mengenai OOP pada python dimana menurut penulis lebih sederhana daripada di Java ataupun C++. Bentuk umum class di python adalah:
class <nama_class>: doc data fungsi

Doc mengacu pada dokumen string yang menjelaskan suatu class dan bersifat opsional. Data dan fungsi mungkin sudah dapat pembaca pahami. Aga lebih mudah memahami kita langsung saja pada contoh berikut:
>>> class profile: ... 'bagian ini hanya sebuah komentar' ... nama='rido' ... umur=21 ... kampus='amikom' ... def f1(self): ... print 'fungsi1 di dalam class' ... def f2(self,n,u,k): ... print n,u,k ... >>> instanprofile=profile() >>> dir(instanprofile) ['__doc__', '__module__', 'f1', 'f2', 'kampus', 'nama', 'umur'] >>> instanprofile.nama 'rido >>> instanprofile.f1() fungsi1 di dalam class >>> instanprofile.f2('eva',21,'amikom') eva 21 amikom

Kata self berarti mengacu pada referensi suatu objek itu sendiri, dalam contoh di atas adalah class profile beserta anggota datanya. Objek hasil instansiasi, seperti instanprofile, bisa ditambahkan anggota datanya setelah proses instansiasi dimana tidak akan akan mengubah datadata pada class sumber. Perhatikan contoh berikut:

>>> class C: ... x='' ... def f1(self,s): ... self.x=s ... >>> c=C() >>> c.x '' >>> c.f1('rido') >>> c.x 'rido' >>> instanprofile.a='tambahan' >>> instanprofile.b=4400 >>> dir(instanprofile) ['__doc__', '__module__', 'a', 'b', 'f1', 'f2', 'kampus', 'nama', 'umur'] >>> dir(profile) ['__doc__', '__module__', 'f1', 'f2', 'kampus', 'nama', umur']

Bagi yang sudah mengenal OOP, pasti tahu adanya data public dan private. Data public bisa diakses di setiap objek hasil instansiasi suatu class. Sedangkan data private hanya bisa diakses oleh anggota classnya sendiri. Pendeklarasian data private di python diawali 2 underscore dan diakhiri maksimal 1 underscore. Berikut contohnya:
>>> class oop: ... data1='data ini bersifat public' ... __data2='data ini bersifat private' ... >>> x=oop() >>> x.data1 'data ini bersifat public' >>> x.data2 Traceback (most recent call last): File "<stdin>", line 1, in ? AttributeError: oop instance has no attribute 'data2'

Tampak objek (x) hasil instansiasi class oop tidak dapat mengakses anggota data class yang bersifat private yakni __data2. Sebenarnya di python tidak ada anggota private, yang ada hanyalah pengalihan nama untuk anggota data tersebut. Python melakukan pengalihan nama suatu data yang seolah-olah bersifat private, contoh __data2, menjadi _oop__data2. Untuk mengetahuinya lakukan perintah dir().

>>> dir(oop) ['__doc__', '__module__', '_oop__data2', 'data1'] >>> dir(x) ['__doc__', '__module__', '_oop__data2', 'data1'] >>> x._oop__data2 'data ini bersifat private'

Kadang kita menginginkan beberapa class dengan kondisi yang mirip dengan 1 class sebagai class utama. Hal ini berhubungan dengan konsep penurunan class atau inheritance pada oop. Penurunan class akan membuat semacam class anak yang akan mewarisi anggota class utama atau orang tua serta bisa mengganti beberapa anggota data atau membuat baru sehingga class anak ini lebih spesifik. Hal-hal yang bisa dijadikan pedoman dalam penurunan class adalah: Class orang tua disebutkan dalam tanda kurung nama class anak Class anak akan mengambil semua anggota data class orang tua yang berhak diambilnya bila class orang tua masih memiliki orang tua juga Penurunan class bisa dilakukan dari banyak orang tua secara berjenjang dengan dipisah oleh tanda koma Bila class orang tua dan anak memiliki nama anggota data yang sama, maka anggota class anaklah yang berlaku.
>>> class oop: ... xoop='anggota oop' ... def foop(self): ... print xoop ... >>> class oop1(oop): ... xoop1='anggota oop1' ... def foop1(self): ... print xoop1 ... >>> a=oop() >>> b=oop1() >>> dir(a) ['__doc__', '__module__', 'foop', 'xoop'] >>> dir(b) ['__doc__', '__module__', 'foop', 'foop1', 'xoop', 'xoop1'] >>> class oop2(): ... xoop2='anggota oop2'

... def foop2(self): ... print xoop2 ... >>> class oop3(oop,oop2): ... def foop3(self): ... print 'hasil penurunan berjenjang' ... >>> dir(oop2) ['__doc__', '__module__', 'foop2', 'xoop2'] >>> dir(oop3) ['__doc__', '__module__', 'foop', 'foop2', 'foop3', 'xoop', 'xoop2'] >>> class anak(oop3): ... def foop3(self): ... print 'fungsi di class anak' ... >>> dir(anak) ['__doc__', '__module__', 'foop', 'foop2', 'foop3', 'xoop', 'xoop2'] >>> c=anak() >>> c.foop3() fungsi di class anak

Bagaimana membuat constructor dan destructor class pada python? Dalam hal ini kita akan mengenal beberapa operator overloading di python. Operator overloading adalah mengubah tugas suatu operator dengan tugas baru, misalkan tanda + akan bertugas menjumlahkan pada suatu operasi bilangan kemudian pada operasi string akan bertugas sebagai penggabungan. Berikut tabel operator overloading yang berhubungan dengan class: Operator __init__ __del__ __add__ __sub__ __or__ __repr__ __call__ __getattr__ __getitem__ __setitem__ __getslice__ __len__ Keterangan constructor destructor penjumlahan pengurangan bitwise or konversi ke string dengan pasangan `` atau pencetakan pemanggilan dalam fungsi pengambilan atribut pengambilan indeks assignment pada indeks irisan nilai panjang

Operator __cmp__ __radd__ Contoh:

Keterangan perbandingan penjumlahan objek di sebelah kanan

>>> class oop: ... def __init__(self): ... print 'constructor class oop' ... >>> class oop1(oop): ... def __init__(self): ... print 'constructor class oop1' ... oop.__init__(self) ... >>> anak=oop1() constructor class oop1 constructor class oop

Fungsi __init__ akan dijalankan secara otomatis ketika ada proses instansiasi. Bila terdapat penurunan class, maka constructor yang akan dipanggil adalah dari class anak. Agar constructor bisa dipanggil semua kita harus memanggilnya secara explisit pada class anak.
>>> class oop: ... def __del__(self): ... print 'proses dealokasi data dari memori' ... >>> a=oop() >>> dir(a) ['__del__', '__doc__', '__module__'] >>> del a proses dealokasi data dari memori >>> dir(a) Traceback (most recent call last): File "<stdin>", line 1, in ? NameError: name 'a' is not defined

Fungsi ini akan dijalankan secara otomatis ketika suatu class dihancurkan/dealokasi dari memori. Contoh di atas mengilustrasikan suatu objek a (hasil instansiasi class oop) yang dihancurkan dari memori dengan perintah del, maka akan memanggil fungsi __del__ yang berfungsi sebagai destructor class.

>>> class oop: ... jml=0 ... def __add__(self,data): ... self.jml=self.jml+data ... print 'hasil penjumlahan=',self.jml ... >>> anak=oop() >>> anak+10 hasil penjumlahan=10 >>> class oop: ... jml=0 ... def __sub__(self,data): ... self.jml=self.jml-data ... print 'hasil pengurangan=',self.jml ... >>> anak=oop() >>> anak-10 hasil pengurangan=-10

Fungsi __add__ dan __sub__ akan dipanggil ketika suatu objek instansiasi diberi operasi penjumlahan dan pengurangan.
>>> class oop: ... data1=0 ... def __or__(self,data2): ... self.data1=self.data1|data2 ... print 'nilai data=',self.data1 ... >>> anak=oop() >>> anak|10 nilai data=10

Fungsi ini akan melakukan bitwise or pada objek yang dikenai operasi |.
>>> ... ... ... ... >>> >>> '10 >>> 16 >>> 10 class oop: data=10 def __repr__(self,data): return `self.data anak=oop() anak.__repr__()+' hari' hari' anak.data+6 anak

Tampak bahwa fungsi ini akan melakukan konversi ke tipe data string dan melakukan pencetakan.

>>> class oop: ... data=10 ... def __call__(self): ... print self.data ... >>> anak=oop() >>> anak <__main__.O instance at 0x403f0e2c> >>> anak() 10

Pemanggilan class dilakukan layaknya pemanggilan fungsi karena ada operator overloading __call__.
>>> class oop: ... def __getattr__(self,x): ... if x='atribut': ... print 'atribut class' ... else: ... print 'bukan atribut class' ... >>> anak=oop() >>> anak.f bukan atribut class >>> anak.atribut atribut class

Fungsi ini akan dipanggil ketika kita mengakses nilai suatu atribut class.
>>> ... ... ... ... >>> >>> ... ... h a class oop: data='hallo' def __getitem__(self,x): return self.data[x] anak=oop() for i in anak: print i, l l o

Fungsi ini akan dipanggil setiap pengambilan indeks pada suatu objek.

kita

melakukan

>>> class oop: ... data=[] ... def __setitem__(self, indeks, nilai): ... self.data.append(nilai) ... >>> anak=oop()

>>> [] >>> >>> >>> [1, >>> [1,

anak.data anak[0]=1 anak[1]=2 anak.data 2] oop.data 2]

Dengan adanya fungsi __setitem__, suatu objek seolah-olah memiliki indeks dan kita bisa melakukan assignment pada indeks objek tersebut.
>>> class oop: ... data='hallo' ... def __getslice__(self,i,j): ... return self.data[i:j] ... >>> anak=oop() >>> anak[1:3] 'al'

Operator __getslice__ berguna untuk melakukan irisan dengan mengambil nila indeks dari data suatu objek.
>>> class oop: ... data='hallo' ... def __len__(self): ... return len(self.data) ... >>> anak=oop() >>> len(anak) 5 >>> class oop: ... data=10 ... def __cmp__(self,x): ... return cmp(self.data,x) ... >>> anak=oop() >>> anak<0 False >>> anak==10 True >>> class oop: ... jml=0 ... def __radd__(self,x): ... return self.jml+x ... >>> anak=oop() >>> 5+anak 5 >>> anak+10

Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: unsupported operand type(s) for +: 'instance' and 'int'

Penjelasam fungsi __len__, __cmp__, __radd__ mungkin cukup jelas dari contoh yang diberikan. Sebenarnya kegunaan __add__ dan __radd__ adalah sama yakni untuk penjumlahan. Perbedaan keduanya adalah letak objek yang dikenai operasi penjumlahan. Jika __add__ objeknya terletak di sebelah kiri operator +, sedangkan __radd__ terletak di sebelah kanan operator +.