Class and Object in Python

Class dan Objek

Class Merupakan Struktur data yang bisa kita gunakan untuk mendefinisikan objek yang menyimpan data bersama-sama nilai-nilai dan perilaku (behavior). Kelas adalah suatu entitas yang merupakan bentuk program dari suatu abstraksi untuk permasalahan dunia nyata, dan instans dari class merupakan realisasi dari beberapa objek. contoh kelas : binatang, kendaraan, benda dsb. 2. objek merupakan Instance dari class. Jika class secara umum merepresentasikan (template) sebuah object, maka sebuah instance adalah representasi nyata dari class itu sendiri. 3. pada dasarnya ada 2 karakteristik yang utama pada sebuah objek : Objek memiliki attribut sebagai status yang disebut Stat Objek memiliki tingkahlaku yang kemudian disebut Method 4. keyword class diikuti dengan nama class yang kita inginkan. Lebih baik digunakan kata yang diawali huruf kapital. 5. Setiap method harus memiliki parameter self yang artinya method tersebut dimiliki dan terdaftar ke class tersebut untuk membedakan dari method atau fungsi yang ada di luar class

In [1]:

class kubus:
    def __init__(self,s): #constructor menggunakan method bawaan Python yang bernama init 
        self.sisi = s
             
    def tampilkansisi(self):
        print(self.sisi)
    
    def luas(self):
        print("luas=", self.sisi **2)
    def volume(self):
        print("volue=", self.sisi**3)
    def luas_permukaan(self):
        print ("luas permukaan=", self.sisi*6)
        
kubus1=kubus(4)
kubus1.tampilkansisi()
kubus1.luas()
kubus1.volume()
kubus1.luas_permukaan()

4
luas= 16
volue= 64
luas permukaan= 24

In [2]:

class orang: 
    def __init__(self,nama,nim):
        self.nm = nama
        self.np = nim
    def tampilkan(self):
        print ("nama:", self.nm,"\nnim:", self.np)
class mahasiswa(orang):
    pass

orang=orang("fitri", "1234556")
orang.tampilkan()

fitri=mahasiswa("anisa","19990422")
fitri.tampilkan()

nama: fitri 
nim: 1234556
nama: anisa 
nim: 19990422

In [4]:

class mahasiswa:
    def __init__(self,npm,nm,ipk):
        self.NIM=npm
        self.nama=nm
        self.IPK=ipk
    def tampilkan(self):
        print("NIM : ", self.NIM, "\nNama : ", self.nama, "\nIPK : ", self.IPK)
    def predikat(self):
        if self.IPK >= 3.5:
            print("cumloude")
        elif self.IPK < 3.5 :
            print ("samgat memuaskan")
        elif self.IPK <= 3.5 :
            print ("cukup")
mhs1=mahasiswa("170411100014", "Fitri Anisa", 4.0)
mhs1.tampilkan()
mhs1.predikat()

NIM :  170411100014 
Nama :  Fitri Anisa 
IPK :  4.0
cumloude

In [5]:

class nasabah:
    def __init__ (self,no,nm,rek):
        self.NoNasabah=no
        self.NamaNasabah=nm
        self.NomerRek=rek
    def tampilkan(self):
        print ("Nomer Nasabah:", self.NoNasabah, "Nama Nasabah:", self.NamaNasabah, "Rekening Nasabah:", self.NomerRek)
class rekening():
    def __init__ (self,rek,sal):
        self.rekeninh=rek
        self.saldo=sal
    def ambil(self):
        ambil_uang=int(input("ambil uang senilai : "))
        hasil=self.saldo-ambil_uang
        self.saldo = hasil
        print ("jumlah penarikan", ambil_uang, "sisa", hasil)
    def setor(self):
        setor_uang=int(input("menyetor sebesar : "))
        hasil=self.saldo+setor_uang
        self.saldo = hasil
        print("jumlah setoran", setor_uang, "sisa",hasil)
    def cek_saldo(self):
        print ("saldo", self.saldo)
        
fitri=nasabah("1", "Fitri Anisa","170411100014")
fitri.tampilkan() 

fitri_rek=rekening("170411100014", 100000)
fitri_rek.ambil()
fitri_rek.setor()
fitri_rek.cek_saldo()

Nomer Nasabah: 1 Nama Nasabah: Fitri Anisa Rekening Nasabah: 170411100014
ambil uang senilai : 50000
jumlah penarikan 50000 sisa 50000
menyetor sebesar : 50000
jumlah setoran 50000 sisa 100000
saldo 100000

Inheritance

1. Inheritance merupakan konsep mewariskan attribute dan method yang dimiliki oleh sebuah class kepada class turunannya. Dengan konsep ini class yang dibuat cukup mendefinisikan attribute dan method yang spesifik didalamnya, sedangkan attribute dan method yang lebih umum akan didapatkan dari class yang menjadi induknya 2. ISTILAH INHERITANCE : - Extends : ini adalah keyword agar sebuah class menjadi subclass. - Superclass : Menunjukkan class yang berarti parent class dari subclass/class anak. - Subclass : adalah class anak atau turunan dari superclass/parent class. - Super Keyword : untuk memanggil konstruktor dari superclass atau menjadi variabel yang mengacu pada superclass. - Methode Overriding : Pendefinisian ulang method yang sama pada subclass

In [2]:

class OrangTua(object):
    def __init__(self):
        print ("Object orang tua telah dibuat")
 
    def berkata(self, nama_anak):
        print ("Orang tua berkata : Wahai anakku %s ..." % nama_anak)
 
class Anak(OrangTua):
    def __init__(self):
        super(Anak, self).__init__()
        print ("Object anak telah dibuat")
 
    def berkata(self, sifat_ayah):
        OrangTua.berkata(self, 'Ali Rama')
        print ("Iya ayahanda %s ..." % sifat_ayah)
 
anak = Anak()
anak.berkata('tercinta')

Object orang tua telah dibuat
Object anak telah dibuat
Orang tua berkata : Wahai anakku Ali Rama ...
Iya ayahanda tercinta ...

In [6]:

class User:
    
    def __init__(self,name):
        self.name = name
    def printName(self):
        print("Name = " + self.name)
    
class programmer(User): #inheritance superClass-1 (untuk memaggil print name bukan hanya muncul last name saja
    def __init__(self,lastname):
        self.lastname = lastname
    def printlastName (self):
        print("Name = " + self.lastname)
    def doPython (self):
        print("programming Python")
        
class programmer1(User):
    pass

user = User("brian")
user.printName()

diana = programmer("diana")
diana.printlastName()
diana.doPython()

Name = brian
Name = diana
programming Python

In [7]:

class Fish :
    def __init__(self,firstname, lastname= "Fish",
                skeleton ="bone", eyelids= False):
        self.firstname = firstname
        self.lastname = lastname
        self.skeleton = skeleton
        self.eyelids = eyelids
    def swim(self):
        print ("The fish is swiming")
    def swim_backwards(self):
        print ("The fish can swim backwards")

class Trout(Fish):
    pass

class Clownfish(Fish):
    def live_with_anemone(self):
        print ("The clownfish is coexisting with sea anemoene")

terry = Trout("Terry")
print (terry.firstname+""+terry.lastname)
print (terry.skeleton)
print (terry.eyelids)
terry.swim()
terry.swim_backwards()

terry1=Trout("TerryS", "SmallFish", "no bone", True)
print (terry1.firstname+""+terry.lastname)
print(terry1.skeleton)
print(terry1.eyelids)

TerryFish
bone
False
The fish is swiming
The fish can swim backwards
TerrySFish
no bone
True

In [8]:

class orang:
    def __init__(self,Nama):
        self.nama=Nama
    def printnama(self):
        print("nama : ", self.nama)
class mahasiswa(orang):
    def __init__(self,NIM,angkatan):
        self.nim=NIM
        self.akt=angkatan
    def printnama(self):
        print ("nama mahasiswa : ", orang.nama)
    def printNIM(self):
        print ("NIM : ",self.nim)
    def semester (self):
        x = 18
        hasil = x-self.akt
        y=hasil*3
        print("Anda semester ", y)
class pegawai (orang):
    def __init__(self,NIP):
        self.np=NIP
    def printname(self):
        print("Nama pegawai : ", orang.nama)
    def printNIP(self):
        print("NIP : ", self.np)
class dosen(pegawai):
    def __init__(self,NIDN):
        self.nid=NIDN
    def printname(self):
        print ("Nama dosen : ", orang.nama)
    def printNIP(self):
        print("NIP : ", pegawai.np)
    def printnidn(self):
        print ("NIDN : ", self.nid)
class karyawan(pegawai):
    pass

print ("____________nama orang____________")
orang=orang("FItri")
orang.printnama()
print ("____________data mahasiswa____________")
mahasiswa=mahasiswa("170411100006",17)
mahasiswa.printnama()
mahasiswa.printNIM()
mahasiswa.semester()
print("____________data pegawai____________")
pegawai=pegawai("12345678")
pegawai.printname()
pegawai.printNIP()
print("____________nama dosen____________")
dosen=dosen("12345")
dosen.printname()
dosen.printNIP()
dosen.printnidn()
print("____________nama karyawan____________")
karyawan=karyawan("1234565768798")
karyawan.printname()
karyawan.printNIP()

____________nama orang____________
nama :  FItri
____________data mahasiswa____________
nama mahasiswa :  FItri
NIM :  170411100006
Anda semester  3
____________data pegawai____________
Nama pegawai :  FItri
NIP :  12345678
____________nama dosen____________
Nama dosen :  FItri
NIP :  12345678
NIDN :  12345
____________nama karyawan____________
Nama pegawai :  FItri
NIP :  1234565768798

Type of Inheritance

defult ini menggunakan properti dan method yang ada di current class

Overriding

defult dapat menambah atribut pada kelas induknya (sifat dari anak dapat di modifikasi)

In [9]:

class Fish :
    def __init__(self,first_name, last_name= "Fish",skeleton ="bone", eyelids= False):
        self.first_name = first_name
        self.last_name = last_name
        self.skeleton = skeleton
        self.eyelids = eyelids
    def swim(self):
        print ("The fish is swiming")
    def swim_backwards(self):
        print ("The fish can swim backwards")
        
class shark(Fish):
    def __init__(self,first_name, last_name= "Shark",skeleton ="cartilage", eyelids= False):
        self.first_name = first_name
        self.last_name = last_name
        self.skeleton = skeleton
        self.eyelids = eyelids
    def swim_backwards(self):
        print("The sark cannot swim backwards, but can sink backwards.")

hiu = Fish ("hiu besar")
hiu.swim_backwards()

The fish can swim backwards

In [10]:

class persegi:
    def __init__(self,sisi=4,bentuk='persegi'):
        self.sisi = sisi
        self.bentuk = bentuk
    def display (self): 
        print ("jumlah sisi = ", self.sisi)
        print ("Bentuk = ", self.bentuk)
    def deskripsi (self):
        print ("persegi memiliki 4 bentuk sisi")

class persegiPanjang(persegi):
    def __init__(self,sisi=4,bentuk="persegi panjang"):
        self.sisi = sisi 
        self.bentuk = bentuk
    def deskripsi (self):
        print ("persegi panjang memiliki panjang dan lebar")
        
class bujur_sangkar(persegi):
    def __init__(self,sisi=4,bentuk="bujur sangkar"):
        self.sisi=sisi
        self.bentuk=bentuk
    def deskripsi(self):
        print("keempatnya memiliki panjang yang sama bentuknya")

n=persegi()
n.display()
n.deskripsi()
n=persegiPanjang()
n.display()
n.deskripsi()
n=bujur_sangkar()
n.display()
n.deskripsi()

jumlah sisi =  4
Bentuk =  persegi
persegi memiliki 4 bentuk sisi
jumlah sisi =  4
Bentuk =  persegi panjang
persegi panjang memiliki panjang dan lebar
jumlah sisi =  4
Bentuk =  bujur sangkar
keempatnya memiliki panjang yang sama bentuknya

Super Class

dipakai jika membutuhkan properti khusus atau properti yang beda dengan induknya (jika atribut di anak ada yang tidak spesifik maka harus menambahkan atribut di kelas induk)

In [11]:

class orang:
    def __init__(self,Nama):
        self.nama=Nama
    def printnama(self):
        print('Nama : ', self.nama)
class mahasiswa (orang):
    def __init__(self,NIM,angkatan):
        self.nim=NIM
        self.akt=angkatan
        super().__init__("orang")
    def printname(self):
        print('Nama mahasiswa : ', orang.nama)
    def printNIM(self):
        print('NIM : '+ self.nim)
    def htgsemester(self):
        x=18
        hasil=x-self.akt
        y=hasil*3
        print('Semester Anda : ',y)
class pegawai (orang):
    def __init__(self,NIP):
        self.np=NIP
        super().__init__("teguh")
    def printname(self):
        print('Nama pegawai : ',pegawai.nama)
    def printNIP (self):
        print('NIP : '+ self.np)
class dosen(pegawai):
    def __init__(self,NIDN):
        self.nid=NIDN
        super().__init__("123345555")
    def printname(self):
        print('Nama dosen : ',dosen.nama)
    def printNIP (self):
        print('NIP : ',dosen.np)
    def printnidn(self):
        print('NIDN : '+ self.nid)
class karyawan(pegawai):
    pass
    

orang=orang('Fitri Dhea')
orang.printnama()

mahasiswa=mahasiswa('1704111100014',17)
mahasiswa.printname()
mahasiswa.printNIM()
mahasiswa.htgsemester()

pegawai=pegawai('140411100006')
pegawai.printname()
pegawai.printNIP()

dosen=dosen('12345678')
dosen.printname()
dosen.printNIP()
dosen.printnidn()

karyawan=karyawan('1234567890')
karyawan.printname()
karyawan.printNIP()

Nama :  Fitri Dhea
Nama mahasiswa :  Fitri Dhea
NIM : 1704111100014
Semester Anda :  3
Nama pegawai :  teguh
NIP : 140411100006
Nama dosen :  teguh
NIP :  123345555
NIDN : 12345678
Nama pegawai :  teguh
NIP : 1234567890

Multiple Inheritance

memiliki dua atau lebih parent class, mewarisi semua properti

In [ ]:

class person:
    def __init__(self):
        self.name = input("nama : ")
    def display(self):
        print("\n\nNama : ",self.name)
        
class marks:
    def __init__(self):
        self.npm = input("npm : ")
        print ("nilai")
        self.match = int(input("match : "))
        self.biology = int(input("biology : "))
    def display(self):
        print ("npm : ", self.npm)
        print ("nilai : ", self.match + self.biology)
    
class student (person,marks):
    def __init__(self):
        person. __init__ (self)
        marks. __init__ (self)
        
    def result (self):
        person.display (self)
        marks.display (self)

stu1 = student ()
stu2 = student ()
stu1 = result ()
stu2 = result ()

nama : fitri
npm : 170411100014
nilai
match : 90
biology : 80

Latihan : program untuk membuat kelas bilangan, property dari kelas tersebut adalah bilangan 1 dan bilangan 2, Method dari kelas tersebut adalah pengurangan, penjumlahan, perkalian dan pembagian kedua bilangan tersebut. Implementasikan program ini

In [1]:

class bilangan:
    def __init__(self,bil1,bil2):
        self.bilangan1 = bil1
        self.bilangan2 = bil2
    def penjumlahan(self):
        print ("hasil operasi penjumlahan = ",self.bilangan1+self.bilangan2)
    def pengurangan(self):
        print ("hasil operasi penjumlahan = ",self.bilangan1-self.bilangan2)
    def perkalian(self):
        print("hasil operasi penjumlahan = ",self.bilangan1*self.bilangan2)
    def pembagian(self):
        print("hasil operasi penjumlahan = ",self.bilangan1/self.bilangan2)
a=bilangan(10,5)
a.penjumlahan()
a.pengurangan()
a.perkalian()
a.pembagian()

hasil operasi penjumlahan =  15
hasil operasi penjumlahan =  5
hasil operasi penjumlahan =  50
hasil operasi penjumlahan =  2.0

Latihan : Kelas Lingkaran, dengan atribut jari-jari dan method menampilkan jari2, menghitung luaspermukaan (yaitu luas lingkaran tersebut), dan keliling lingkaran. Buatlah kelas tabung (merupakan sub kelas dari lingkaran), dengan atribut tambahan tinggi tabung dan method luaspermukaan(yaitu luas permukaan tabung). Buatlah konsep Superlass dan Overriding untuk luas permukaan.

In [2]:

class lingkaran:
    def __init__(self):
        self.r=int(input("masukkan jari-jari = "))
    def luaslingkaran(self):
        phi=3.14
        luas=phi*self.r**2
        print("luas lingkaran = ",luas)
    def keliling(self):
        phi=3.14
        kel=2*phi*self.r
        print("keliling lingkaran = ",kel)
        
class tabung(lingkaran):
    def __init__(self):
        self.tinggi=int(input("masukkan tinggi tabung = "))
        super().__init__()
    def luaspermukaan(self):
        phi=3.14
        luas=2*phi*self.r*(self.r+self.tinggi)
        print("luas permukaan tabung = ",luas)
        
a=lingkaran()
a.luaslingkaran()
a.keliling()
b=tabung()
b.luaspermukaan()

masukkan jari-jari = 5
luas lingkaran =  78.5
keliling lingkaran =  31.400000000000002
masukkan tinggi tabung = 10
masukkan jari-jari = 5
luas permukaan tabung =  471.00000000000006

Latihan : kelas pegawai (nama dan idpegawai) dan kelas toko (nama dan lokasi). Buatlah konsep dari multiple kelas tersebut(pegawai dan toko) yaitu kelas penempatan yang menampilkan nama pegawai dengan penempatan lokasi kerjanya di toko apa

In [3]:

class pegawai():
    def __init__(self):
        self.nm=input("masukkan nama anda ")
        self.ip=int(input("masukkan ID anda "))
    def display(self):
        print("Nama Pegawai : ",self.nm, "\nID Pegawai : ",self.ip)
class toko():
    def __init__(self):
        self.lk=input("masukkan lokasi toko ")
        self.nt=input("masukkan nama toko ")
    def display(self):
        print("Toko tujuan : ",self.lk, "\nNama toko tujuan : ",self.nt)
class penempatan(pegawai,toko):
    def __init__(self):
        pegawai. __init__(self)
        toko. __init__(self)
    def result(self):
        pegawai.display(self)
        toko.display(self)
        
a=penempatan()
a.result()

masukkan nama anda fitri
masukkan ID anda 1234567
masukkan lokasi toko Bangkalan
masukkan nama toko Fifa
Nama Pegawai :  fitri 
ID Pegawai :  1234567
Toko tujuan :  Bangkalan 
Nama toko tujuan :  Fifa

Polymorphism

Polymorphism adalah suatu objek dapat memiliki berbagai bentuk, sebagai objek dari class sendiri atau objek dari superclassnya (memiliki method yang sama namun tidak dari class yang sama) Polymorphism with class method, Polymorphism with a class abstrak class : dokumen class Polymorphism merupakan konsep yang memungkinkan digunakannya suatu interface yang sama untuk memerintah suatu object agar melakukan suatu tindakan yang mungkin secara prinsip sama tetapi secara proses berbeda.

In [4]:

class shark():
    def swim(self):
        print("The shark is swimming.")
    def swim_backwards(self):
        print("The shark cannot swim backwards, but can sik backwards.")
    def skeleton(self):
        print ("The shark's skeleton is of cartilage")
        
class clownfish():
    def swim(self):
        print("The clownfish is swimming")
    def swim_backwards(self):
        print("The clownfish can swim backwards")
    def skeleton(self):
        print("The clownfish's skeleton is made of bone")
        
sammy=shark()
sammy.skeleton()

casey=clownfish()
casey.skeleton()

The shark's skeleton is of cartilage
The clownfish's skeleton is made of bone

In [5]:

def in_the_pasific(fish):
    fish.swim()

sammy=shark()
casey=clownfish()

in_the_pasific(sammy)
in_the_pasific(casey)

#wiht function 

sammy=shark()
casey=clownfish()

for fish in (sammy,casey):
    fish.swim()
    fish.swim_backwards()
    fish.skeleton()

#with method

sammy=shark()
sammy.skeleton()
    
casey=clownfish()
casey.skeleton()

The shark is swimming.
The clownfish is swimming
The shark is swimming.
The shark cannot swim backwards, but can sik backwards.
The shark's skeleton is of cartilage
The clownfish is swimming
The clownfish can swim backwards
The clownfish's skeleton is made of bone
The shark's skeleton is of cartilage
The clownfish's skeleton is made of bone

In [6]:

#abstrak class
class dokument:
    def __init__(self,name):
        self.name=name
    def show(self):
        raise NotImplementedError ("Subclass must implement abstract method")
        
class show():
    def show(self):
        print ("Show pdf contents!")
    
a=dokument("fitri")

b=show()
b.show()

Show pdf contents!

In [10]:

class Srigala:
    def gonggong(self):
        print ("hooooowll")
 
class Anjing:
    def gonggong(self):
        print ("woork")
 
    def suara(hewan):
        hewan.gonggong()
 
dog = Anjing()
wolf = Srigala()
dog.suara()
wolf.gonggong()

woork
hooooowll

Berikut ini gabungan antara Inheritance dan Polymorphism :

In [11]:

class Hewan(object):
    def __init__(self, nama):
        self.nama = nama
 
    def gonggong(self):
        print ('Suara gonggongan hewan')
 
class Anjing(Hewan):
    def gonggong(self):
        super(Anjing, self).gonggong()
        return ("woork")
 
class Srigala(Hewan):
    def gonggong(self):
        Hewan.gonggong(self)
        return ("hooooowll")
 
class Singa(Hewan):
    def gonggong(self):
       return ("Roaaarsss")
 
dog = Anjing('Anjing')
wolf = Srigala('Serigala')
lion = Singa('Singa')
 
print ('Suara ' + dog.nama + ' yaitu ' + dog.gonggong())
print ('Suara ' + wolf.nama + ' yaitu ' + wolf.gonggong())
print ('Suara ' + lion.nama + ' yaitu ' + lion.gonggong())

Suara gonggongan hewan
Suara Anjing yaitu woork
Suara gonggongan hewan
Suara Serigala yaitu hooooowll
Suara Singa yaitu Roaaarsss

Overloading

perbedaan overloading dan overriding : metdod overloading operatornya yang banyak bentuk methot overloading : sebuah method dengan sebuah cara (method sama namun pemanggilan berbeda)

In [12]:

class fraction:
    def __init__(self,top,bottom):
        self.num = top
        self.den = bottom
        
    def show(self):
        print(self.num, "/", self.den)
    
    def __str__(self):
        return str(self.num)+"/"+str(self.den)
    
    def __add__(self,otherfruction):
        newnum = self.num*otherfruction.den+self.den*otherfruction.num
        newden = self.den*otherfruction.den
        
        return fraction(newnum,newden)

f1 = fraction(1,4)
f2 = fraction (1,2)
print(f1+f2)

f = fraction(2,4)
print(f)

6/8
2/4

In [13]:

class point:
    def __init__(self,x=0,y=0):
        self.x=x
        self.y=y
    
    #def __str__(self):
        #return "({0},{1})".format(self.x, self.y)
    def __str__(self):
        return "point object is at: (" + str(self.x) + "," + str(self.y) + ")"
    
    def __add__(self,other):
        x = self.x - other.x
        y = self.y - other.y
        return point (x,y)

p1 = point(2,3)
p2 = point(-1,2)
print(p1+p2)
print (p1.__add__(p2))

point object is at: (3,1)
point object is at: (3,1)

In [14]:

class Human:
    def sayHello(self, name=None):
        if name is not None:
            print("Hello" + name)
        else:
            print("Hello")
            
#create instance
obj = Human()

#call the method
obj.sayHello

#call the method with a parameter
obj.sayHello("Guido")

HelloGuido

Encapsulation

1. Encapsulation adalah pembungkusan attribut/properti (field atau variable) dan tingkah laku (method) di dalam sebuah kelas untuk menyembunyikan nya dari kelas lain, sehingga kelas lain tidak dapat mengakses atribut dan method yang disembunyikan di dalam kelas yang lainnya
2. Di dalam sebuah class terdapat atribut dan method yang memiliki hak akses tertentu terhadap environment/lingkungan-nya, hak akses ini biasa di sebut Access Modifier.
3. dengan enkapsulasi kita bisa menyembunyikan informasi-informasi yang tidak perlu diketahui oleh object lain.
4. Dua hal yang mendasar dalam enkapsulasi yakni :
   • Information hiding : Sebelumnya kita dapat mengakses anggota class baik berupa atribut maupun method secara langsung dengan menggunakan objek yang telah kita buat. Hal ini dikarenakan akses kontrol yang diberikan kepada atribut maupun method yang ada di dalam class tersebut adalah ‘public’. Kita dapat menyembunyikan informasi dari suatu class sehingga anggota class tersebut tidak dapat diakses dari luar, caranya adalah hanya dengan memberikan akses kontrol ‘private’ ketika mendeklarasikan atribut atau method. Proses ini disebut dengan information hiding.
   • Interface to access data : caranya adalah dengan membuat suatu interface berupa method untuk menginisialisasi atau merubah nilai dari suatu atribut tersebut.
5. Konsep enkapsulasi sangat penting dilakukan untuk menjaga kebutuhan program agar dapat diakses sewaktu-waktu, sekaligus menjaga program tersebut.

In [1]:

class Car:
 
    def __init__(self):
        self.__updateSoftware()
 
    def drive(self):
        print ('driving')
 
    def __updateSoftware(self):
        print ('updating software')
 
redcar = Car()
redcar.drive()

updating software
driving

In [ ]: