Pola Desain Python - Panduan Cepat

Pola desain digunakan untuk merepresentasikan pola yang digunakan oleh pengembang untuk membuat perangkat lunak atau aplikasi web. Pola-pola ini dipilih berdasarkan analisis kebutuhan. Pola tersebut menggambarkan solusi untuk masalah, kapan dan di mana menerapkan solusi tersebut dan konsekuensi dari implementasinya.

Struktur pola desain

Pendokumentasian pola desain dipertahankan dengan cara yang lebih menitikberatkan pada teknologi yang digunakan dan dengan cara apa. Diagram berikut menjelaskan struktur dasar dokumentasi pola desain.

Nama Pola

Ini menggambarkan pola secara singkat dan efektif.

Maksud / Motif

Ini menjelaskan apa yang dilakukan polanya.

Penerapan

Ini menjelaskan daftar situasi di mana pola dapat diterapkan.

Peserta dan konsekuensi

Peserta memasukkan kelas dan objek yang berpartisipasi dalam pola desain dengan daftar konsekuensi yang ada dengan pola tersebut.

Mengapa Python?

Python adalah bahasa skrip open source. Ini memiliki perpustakaan yang mendukung berbagai pola desain. Sintaks python mudah dipahami dan menggunakan kata kunci bahasa Inggris.

Python memberikan dukungan untuk daftar pola desain yang disebutkan di bawah ini. Pola desain ini akan digunakan sepanjang tutorial ini -

• Pola Pengontrol Tampilan Model
• Pola tunggal
• Pola pabrik
• Pola Pembangun
• Pola Prototipe
• Pola Fasad
• Pola Perintah
• Pola Adaptor
• Pola Prototipe
• Pola Dekorator
• Pola Proksi
• Pola Rantai Tanggung Jawab
• Pola Pengamat
• Pola Status
• Pola Strategi
• Pola Template
• Pola Kelas Terbang
• Pola Pabrik Abstrak
• Pola Berorientasi Objek

Manfaat menggunakan pola desain

Berikut adalah manfaat yang berbeda dari pola desain -

• Pola memberi pengembang pilihan solusi yang telah dicoba dan diuji untuk masalah yang ditentukan.

• Semua pola desain netral bahasa.

• Pola membantu mencapai komunikasi dan memelihara dokumentasi dengan baik.

• Ini mencakup catatan pencapaian untuk mengurangi risiko teknis pada proyek.

• Pola desain sangat fleksibel untuk digunakan dan mudah dipahami.

Python adalah bahasa skrip sumber terbuka, yang tingkat tinggi, ditafsirkan, interaktif dan berorientasi objek. Ini dirancang agar sangat mudah dibaca. Sintaks bahasa Python mudah dipahami dan sering menggunakan kata kunci bahasa Inggris.

Fitur Bahasa Python

Di bagian ini, kita akan belajar tentang berbagai fitur bahasa Python.

Ditafsirkan

Python diproses saat runtime menggunakan interpreter. Tidak perlu mengkompilasi program sebelum dieksekusi. Ini mirip dengan PERL dan PHP.

Berorientasi pada objek

Python mengikuti gaya dan pola desain berorientasi objek. Ini mencakup definisi kelas dengan berbagai fitur seperti enkapsulasi, polimorfisme, dan banyak lagi.

Portabel

Kode Python ditulis dalam sistem operasi Windows dan dapat digunakan di sistem operasi Mac. Kode dapat digunakan kembali dan portabel sesuai kebutuhan.

Mudah untuk dikodekan

Sintaks Python mudah dipahami dan dikodekan. Setiap pengembang dapat memahami sintaks Python dalam beberapa jam. Python dapat dideskripsikan sebagai "ramah programmer"

Dapat diperluas

Jika diperlukan, pengguna dapat menulis beberapa kode Python dalam bahasa C. Dimungkinkan juga untuk meletakkan kode python dalam kode sumber dalam berbagai bahasa seperti C ++. Ini membuat Python menjadi bahasa yang bisa dikembangkan.

Poin Penting

Simak poin-poin penting berikut terkait bahasa pemrograman Python -

• Ini mencakup metode pemrograman fungsional dan terstruktur serta metode pemrograman berorientasi objek.

• Ini dapat digunakan sebagai bahasa scripting atau sebagai bahasa pemrograman.

• Ini termasuk pengumpulan sampah otomatis.

• Ini mencakup tipe data dinamis tingkat tinggi dan mendukung berbagai pemeriksaan tipe dinamis.

• Python menyertakan fitur integrasi dengan C, C ++ dan bahasa seperti Java.

Bagaimana cara mengunduh bahasa python di sistem Anda?

Untuk mengunduh bahasa Python di sistem Anda, ikuti tautan ini -

https://www.python.org/downloads/

Ini termasuk paket untuk berbagai sistem operasi seperti distribusi Windows, MacOS dan Linux.

Alat Penting dengan Python

Di bagian ini, kita akan belajar secara singkat tentang beberapa alat penting di Python.

String Python

Deklarasi dasar string adalah sebagai berikut -

str = 'Hello World!'

Daftar Python

Daftar python dapat dideklarasikan sebagai tipe data gabungan yang dipisahkan dengan koma dan diapit oleh tanda kurung siku ([]).

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']

Python Tuple

Tuple adalah tipe data dinamis dari Python, yang terdiri dari sejumlah nilai yang dipisahkan dengan koma. Tupel diapit dengan tanda kurung.

tinytuple = (123, 'john')

Kamus Python

Kamus Python adalah jenis tabel hash. Kunci kamus bisa berupa hampir semua tipe data Python. Tipe data biasanya angka atau string.

tinydict = {'name': 'omkar','code':6734, 'dept': 'sales'}

Apa yang dimaksud dengan pola desain dengan Python?

Python membantu dalam membentuk pola desain menggunakan parameter berikut -

• Nama Pola
• Intent
• Aliases
• Motivation
• Problem
• Solution
• Structure
• Participants
• Constraints
• Kode sampel

Model View Controller adalah pola desain yang paling umum digunakan. Pengembang merasa mudah untuk menerapkan pola desain ini.

Berikut ini adalah arsitektur dasar dari Model View Controller -

Sekarang mari kita lihat bagaimana struktur itu bekerja.

Model

Ini terdiri dari logika aplikasi murni, yang berinteraksi dengan database. Ini mencakup semua informasi untuk merepresentasikan data kepada pengguna akhir.

Melihat

View mewakili file HTML, yang berinteraksi dengan pengguna akhir. Ini mewakili data model kepada pengguna.

Kontroler

Ini bertindak sebagai perantara antara tampilan dan model. Ini mendengarkan peristiwa yang dipicu oleh tampilan dan model kueri untuk hal yang sama.

Kode Python

Mari kita pertimbangkan objek dasar yang disebut "Orang" dan membuat pola desain MVC.

Model.py

import json

class Person(object):
   def __init__(self, first_name = None, last_name = None):
      self.first_name = first_name
      self.last_name = last_name
   #returns Person name, ex: John Doe
   def name(self):
      return ("%s %s" % (self.first_name,self.last_name))
		
   @classmethod
   #returns all people inside db.txt as list of Person objects
   def getAll(self):
      database = open('db.txt', 'r')
      result = []
      json_list = json.loads(database.read())
      for item in json_list:
         item = json.loads(item)
         person = Person(item['first_name'], item['last_name'])
         result.append(person)
      return result

Ini memanggil sebuah metode, yang mengambil semua record dari tabel Person dalam database. Catatan disajikan dalam format JSON.

Melihat

Ini menampilkan semua catatan yang diambil dalam model. Tampilan tidak pernah berinteraksi dengan model; controller melakukan pekerjaan ini (berkomunikasi dengan model dan tampilan).

from model import Person
def showAllView(list):
   print 'In our db we have %i users. Here they are:' % len(list)
   for item in list:
      print item.name()
def startView():
   print 'MVC - the simplest example'
   print 'Do you want to see everyone in my db?[y/n]'
def endView():
   print 'Goodbye!'

Kontroler

Kontroler berinteraksi dengan model melalui getAll() metode yang mengambil semua catatan yang ditampilkan kepada pengguna akhir.

from model import Person
import view

def showAll():
   #gets list of all Person objects
   people_in_db = Person.getAll()
   #calls view
   return view.showAllView(people_in_db)

def start():
   view.startView()
   input = raw_input()
   if input == 'y':
      return showAll()
   else:
      return view.endView()

if __name__ == "__main__":
   #running controller function
   start()

Pola ini membatasi instansiasi kelas ke satu objek. Ini adalah jenis pola kreasi dan hanya melibatkan satu kelas untuk membuat metode dan objek tertentu.

Ini memberikan titik akses global ke instance yang dibuat.

Bagaimana cara menerapkan kelas tunggal?

Program berikut mendemonstrasikan implementasi kelas singleton yang mencetak instance yang dibuat beberapa kali.

class Singleton:
   __instance = None
   @staticmethod 
   def getInstance():
      """ Static access method. """
      if Singleton.__instance == None:
         Singleton()
      return Singleton.__instance
   def __init__(self):
      """ Virtually private constructor. """
      if Singleton.__instance != None:
         raise Exception("This class is a singleton!")
      else:
         Singleton.__instance = self
s = Singleton()
print s

s = Singleton.getInstance()
print s

s = Singleton.getInstance()
print s

Keluaran

Program di atas menghasilkan keluaran berikut -

Jumlah instance yang dibuat sama dan tidak ada perbedaan dalam objek yang tercantum dalam output.

Pola pabrik berada di bawah kategori daftar pola kreasi. Ini memberikan salah satu cara terbaik untuk membuat objek. Dalam pola pabrik, objek dibuat tanpa mengekspos logika ke klien dan merujuk ke objek yang baru dibuat menggunakan antarmuka umum.

Pola pabrik diimplementasikan dengan Python menggunakan metode pabrik. Ketika seorang pengguna memanggil metode sedemikian rupa sehingga kami mengirimkan string dan nilai yang dikembalikan sebagai objek baru diimplementasikan melalui metode pabrik. Jenis objek yang digunakan dalam metode pabrik ditentukan oleh string yang melewati metode.

Pada contoh di bawah ini, setiap metode menyertakan objek sebagai parameter, yang diimplementasikan melalui metode pabrik.

Bagaimana cara menerapkan pola pabrik?

Sekarang mari kita lihat bagaimana menerapkan pola pabrik.

class Button(object):
   html = ""
   def get_html(self):
      return self.html

class Image(Button):
   html = "<img></img>"

class Input(Button):
   html = "<input></input>"

class Flash(Button):
   html = "<obj></obj>"

class ButtonFactory():
   def create_button(self, typ):
      targetclass = typ.capitalize()
      return globals()[targetclass]()

button_obj = ButtonFactory()
button = ['image', 'input', 'flash']
for b in button:
   print button_obj.create_button(b).get_html()

Kelas tombol membantu membuat tag html dan halaman html terkait. Klien tidak akan memiliki akses ke logika kode dan outputnya mewakili pembuatan halaman html.

Keluaran

Penjelasan

Kode python menyertakan logika tag html, yang nilainya ditentukan. Pengguna akhir dapat melihat file HTML yang dibuat oleh kode Python.

Builder Pattern adalah pola desain unik yang membantu dalam membangun objek kompleks dengan menggunakan objek sederhana dan menggunakan pendekatan algoritmik. Pola desain ini termasuk dalam kategori pola kreasi. Dalam pola desain ini, kelas pembangun membuat objek akhir dalam prosedur langkah demi langkah. Pembangun ini tidak bergantung pada objek lain.

Keuntungan dari Pola Builder

• Ini memberikan pemisahan yang jelas dan lapisan unik antara konstruksi dan representasi objek tertentu yang dibuat oleh kelas.

• Ini memberikan kontrol yang lebih baik atas proses konstruksi dari pola yang dibuat.

• Ini memberikan skenario yang sempurna untuk mengubah representasi internal objek.

Bagaimana cara menerapkan pola pembangun?

Pada bagian ini, kita akan belajar bagaimana mengimplementasikan pola builder.

class Director:
   __builder = None
   
   def setBuilder(self, builder):
      self.__builder = builder
   
   def getCar(self):
      car = Car()
      
      # First goes the body
      body = self.__builder.getBody()
      car.setBody(body)
      
      # Then engine
      engine = self.__builder.getEngine()
      car.setEngine(engine)
      
      # And four wheels
      i = 0
      while i < 4:
         wheel = self.__builder.getWheel()
			car.attachWheel(wheel)
         i += 1
      return car

# The whole product
class Car:
   def __init__(self):
      self.__wheels = list()
      self.__engine = None
      self.__body = None

   def setBody(self, body):
      self.__body = body

   def attachWheel(self, wheel):
      self.__wheels.append(wheel)

   def setEngine(self, engine):
      self.__engine = engine

   def specification(self):
      print "body: %s" % self.__body.shape
      print "engine horsepower: %d" % self.__engine.horsepower
      print "tire size: %d\'" % self.__wheels[0].size

class Builder:
      def getWheel(self): pass
      def getEngine(self): pass
      def getBody(self): pass

class JeepBuilder(Builder):
   
   def getWheel(self):
      wheel = Wheel()
      wheel.size = 22
      return wheel
   
   def getEngine(self):
      engine = Engine()
      engine.horsepower = 400
      return engine
   
   def getBody(self):
      body = Body()
      body.shape = "SUV"
      return body

# Car parts
class Wheel:
   size = None

class Engine:
   horsepower = None

class Body:
   shape = None

def main():
   jeepBuilder = JeepBuilder() # initializing the class
   
   director = Director()
   
   # Build Jeep
   print "Jeep"
   director.setBuilder(jeepBuilder)
   jeep = director.getCar()
   jeep.specification()
   print ""

if __name__ == "__main__":
   main()

Keluaran

Program di atas menghasilkan keluaran berikut -

Pola desain prototipe membantu menyembunyikan kompleksitas instance yang dibuat oleh kelas. Konsep objek yang ada akan berbeda dengan objek baru yang dibuat dari awal.

Objek yang baru disalin mungkin memiliki beberapa perubahan pada properti jika diperlukan. Pendekatan ini menghemat waktu dan sumber daya yang digunakan untuk pengembangan produk.

Bagaimana cara menerapkan pola prototipe?

Sekarang mari kita lihat bagaimana menerapkan pola prototipe.

import copy

class Prototype:

   _type = None
   _value = None

   def clone(self):
      pass

   def getType(self):
      return self._type

   def getValue(self):
      return self._value

class Type1(Prototype):

   def __init__(self, number):
      self._type = "Type1"
      self._value = number

   def clone(self):
      return copy.copy(self)

class Type2(Prototype):

   """ Concrete prototype. """

   def __init__(self, number):
      self._type = "Type2"
      self._value = number

   def clone(self):
      return copy.copy(self)

class ObjectFactory:

   """ Manages prototypes.
   Static factory, that encapsulates prototype
   initialization and then allows instatiation
   of the classes from these prototypes.
   """

   __type1Value1 = None
   __type1Value2 = None
   __type2Value1 = None
   __type2Value2 = None

   @staticmethod
   def initialize():
      ObjectFactory.__type1Value1 = Type1(1)
      ObjectFactory.__type1Value2 = Type1(2)
      ObjectFactory.__type2Value1 = Type2(1)
      ObjectFactory.__type2Value2 = Type2(2)

   @staticmethod
   def getType1Value1():
      return ObjectFactory.__type1Value1.clone()

   @staticmethod
   def getType1Value2():
      return ObjectFactory.__type1Value2.clone()

   @staticmethod
   def getType2Value1():
      return ObjectFactory.__type2Value1.clone()

   @staticmethod
   def getType2Value2():
      return ObjectFactory.__type2Value2.clone()

def main():
   ObjectFactory.initialize()
   
   instance = ObjectFactory.getType1Value1()
   print "%s: %s" % (instance.getType(), instance.getValue())
   
   instance = ObjectFactory.getType1Value2()
   print "%s: %s" % (instance.getType(), instance.getValue())
   
   instance = ObjectFactory.getType2Value1()
   print "%s: %s" % (instance.getType(), instance.getValue())
   
   instance = ObjectFactory.getType2Value2()
   print "%s: %s" % (instance.getType(), instance.getValue())

if __name__ == "__main__":
   main()

Keluaran

Program di atas akan menghasilkan keluaran sebagai berikut -

Output membantu dalam membuat objek baru dengan yang sudah ada dan terlihat jelas dalam output yang disebutkan di atas.

Pola desain fasad menyediakan antarmuka terpadu ke satu set antarmuka dalam subsistem. Ini mendefinisikan antarmuka tingkat tinggi yang dapat digunakan subsistem apa pun.

Kelas fasad mengetahui subsistem mana yang bertanggung jawab atas permintaan.

Bagaimana cara mendesain pola fasad?

Sekarang mari kita lihat bagaimana mendesain pola fasad.

class _IgnitionSystem(object):
   
   @staticmethod
   def produce_spark():
      return True

class _Engine(object):

   def __init__(self):
      self.revs_per_minute = 0

   def turnon(self):
      self.revs_per_minute = 2000
   
   def turnoff(self):
      self.revs_per_minute = 0

class _FuelTank(object):
   
   def __init__(self, level=30):
      self._level = level
   
   @property
   def level(self):
      return self._level
   
   @level.setter
	def level(self, level):
      self._level = level

class _DashBoardLight(object):

   def __init__(self, is_on=False):
      self._is_on = is_on

   def __str__(self):
      return self.__class__.__name__

   @property
   def is_on(self):
      return self._is_on
   
   @is_on.setter
   def is_on(self, status):
      self._is_on = status
   
   def status_check(self):
      if self._is_on:
         print("{}: ON".format(str(self)))
      else:
         print("{}: OFF".format(str(self)))

class _HandBrakeLight(_DashBoardLight):
   pass

class _FogLampLight(_DashBoardLight):
   pass

class _Dashboard(object):
   
   def __init__(self):
      self.lights = {"handbreak": _HandBrakeLight(), "fog": _FogLampLight()}
   
   def show(self):
	   for light in self.lights.values():
      light.status_check()

# Facade
class Car(object):
   
   def __init__(self):
      self.ignition_system = _IgnitionSystem()
      self.engine = _Engine()
      self.fuel_tank = _FuelTank()
      self.dashboard = _Dashboard()
   
   @property
   def km_per_litre(self):
      return 17.0
   
   def consume_fuel(self, km):
      litres = min(self.fuel_tank.level, km / self.km_per_litre)
      self.fuel_tank.level -= litres
   
   def start(self):
      print("\nStarting...")
      self.dashboard.show()
      if self.ignition_system.produce_spark():
         self.engine.turnon()
      else:
         print("Can't start. Faulty ignition system")
   
   def has_enough_fuel(self, km, km_per_litre):
      litres_needed = km / km_per_litre
      if self.fuel_tank.level > litres_needed:
         return True
      else:
         return False
	   
      def drive(self, km = 100):
         print("\n")
         if self.engine.revs_per_minute > 0:
            while self.has_enough_fuel(km, self.km_per_litre):
               self.consume_fuel(km)
               print("Drove {}km".format(km))
               print("{:.2f}l of fuel still left".format(self.fuel_tank.level))
         else:
            print("Can't drive. The Engine is turned off!")
         
         def park(self):
            print("\nParking...")
            self.dashboard.lights["handbreak"].is_on = True
            self.dashboard.show()
            self.engine.turnoff()
         
         def switch_fog_lights(self, status):
            print("\nSwitching {} fog lights...".format(status))
            boolean = True if status == "ON" else False
            self.dashboard.lights["fog"].is_on = boolean
            self.dashboard.show()
         
         def fill_up_tank(self):
            print("\nFuel tank filled up!")
            self.fuel_tank.level = 100
				
# the main function is the Client
def main():
   car = Car()
   car.start()
   car.drive()
   car.switch_fog_lights("ON")
   car.switch_fog_lights("OFF")
	car.park()
   car.fill_up_tank()
   car.drive()
   car.start()
   car.drive()

if __name__ == "__main__":
   main()

Keluaran

Program di atas menghasilkan keluaran berikut -

Penjelasan

Program ini dirancang dengan skenario. Ini adalah menghidupkan mesin mobil atau kendaraan penggerak apa pun. Jika Anda mengamati kodenya, itu termasuk fungsi terkait untuk mengemudi, memarkir dan mengkonsumsi bahan bakar juga.

Pola Perintah menambahkan tingkat abstraksi antar tindakan dan menyertakan objek, yang memanggil tindakan ini.

Dalam pola desain ini, klien membuat objek perintah yang menyertakan daftar perintah yang akan dijalankan. Objek perintah yang dibuat mengimplementasikan antarmuka tertentu.

Berikut adalah arsitektur dasar dari pola perintah -

Bagaimana cara menerapkan pola perintah?

Sekarang kita akan melihat bagaimana mengimplementasikan pola desain.

def demo(a,b,c):
   print 'a:',a
   print 'b:',b
   print 'c:',c

class Command:
   def __init__(self, cmd, *args):
      self._cmd=cmd
      self._args=args

   def __call__(self, *args):
      return apply(self._cmd, self._args+args)
cmd = Command(dir,__builtins__)
print cmd()

cmd = Command(demo,1,2)
cmd(3)

Keluaran

Program di atas menghasilkan keluaran berikut -

Penjelasan

Outputnya mengimplementasikan semua perintah dan kata kunci yang terdaftar dalam bahasa Python. Ini mencetak nilai variabel yang diperlukan.

Pola adaptor berfungsi sebagai jembatan antara dua antarmuka yang tidak kompatibel. Jenis pola desain ini berada di bawah pola struktural karena pola ini menggabungkan kemampuan dua antarmuka independen.

Pola ini melibatkan satu kelas, yang bertanggung jawab untuk menggabungkan fungsionalitas antarmuka yang independen atau tidak kompatibel. Contoh kehidupan nyata dapat berupa kasus pembaca kartu, yang bertindak sebagai adaptor antara kartu memori dan laptop. Anda mencolokkan kartu memori ke dalam pembaca kartu dan pembaca kartu ke laptop sehingga kartu memori dapat dibaca melalui laptop.

Pola desain adaptor membantu mengerjakan kelas bersama-sama. Ini mengubah antarmuka kelas menjadi antarmuka lain berdasarkan kebutuhan. Pola tersebut mencakup spesiasi polimorfisme yang menamai satu nama dan beberapa bentuk. Katakanlah untuk kelas bentuk yang dapat digunakan sesuai persyaratan yang dikumpulkan.

Ada dua jenis pola adaptor -

Pola Adaptor Objek

Pola desain ini bergantung pada implementasi objek. Karenanya, ini disebut Pola Adaptor Objek.

Pola Adaptor Kelas

Ini adalah cara alternatif untuk mengimplementasikan pola desain adaptor. Pola tersebut dapat diimplementasikan menggunakan beberapa pewarisan.

Bagaimana cara menerapkan pola adaptor?

Sekarang mari kita lihat bagaimana menerapkan pola adaptor.

class EuropeanSocketInterface:
   def voltage(self): pass

   def live(self): pass
   def neutral(self): pass
   def earth(self): pass

# Adaptee
class Socket(EuropeanSocketInterface):
   def voltage(self):
      return 230

	def live(self):
      return 1
   
   def neutral(self):
      return -1
   
   def earth(self):
      return 0

# Target interface
class USASocketInterface:
   def voltage(self): pass
   def live(self): pass
   def neutral(self): pass

# The Adapter
class Adapter(USASocketInterface):
   __socket = None
   def __init__(self, socket):
      self.__socket = socket
   
   def voltage(self):
      return 110
   
   def live(self):
      return self.__socket.live()
   
   def neutral(self):
      return self.__socket.neutral()

# Client
class ElectricKettle:
   __power = None
   
   def __init__(self, power):
	   self.__power = power
   
   def boil(self):
      if self.__power.voltage() > 110:
         print "Kettle on fire!"
      else:
         if self.__power.live() == 1 and \
            self.__power.neutral() == -1:
            print "Coffee time!"
         else:
            print "No power."

def main():
   # Plug in
   socket = Socket()
   adapter = Adapter(socket)
   kettle = ElectricKettle(adapter)
	
   # Make coffee
   kettle.boil()
	
   return 0
	
if __name__ == "__main__":
   main()

Keluaran

Program di atas menghasilkan keluaran berikut -

Penjelasan

Kode tersebut mencakup antarmuka adaptor dengan berbagai parameter dan atribut. Ini termasuk Adaptee bersama dengan antarmuka Target yang mengimplementasikan semua atribut dan menampilkan keluaran sebagai terlihat.

Pola dekorator memungkinkan pengguna menambahkan fungsionalitas baru ke objek yang sudah ada tanpa mengubah strukturnya. Jenis pola desain ini berada di bawah pola struktural karena pola ini bertindak sebagai pembungkus kelas yang ada.

Pola ini membuat kelas dekorator, yang membungkus kelas asli dan menyediakan fungsionalitas tambahan yang menjaga agar tanda tangan metode kelas tetap utuh.

Motif pola dekorator adalah untuk melampirkan tanggung jawab tambahan dari suatu objek secara dinamis.

Bagaimana menerapkan pola desain dekorator

Kode yang disebutkan di bawah ini adalah demonstrasi sederhana tentang bagaimana menerapkan pola desain dekorator dengan Python. Ilustrasi tersebut melibatkan demonstrasi kedai kopi dalam format kelas. Kelas kopi yang dibuat adalah abstrak, yang artinya tidak dapat dibuat instance-nya.

import six
from abc import ABCMeta

@six.add_metaclass(ABCMeta)
class Abstract_Coffee(object):

   def get_cost(self):
      pass

   def get_ingredients(self):
      pass
   
   def get_tax(self):
      return 0.1*self.get_cost()

class Concrete_Coffee(Abstract_Coffee):
   
   def get_cost(self):
      return 1.00
   
   def get_ingredients(self):
      return 'coffee'

@six.add_metaclass(ABCMeta)
class Abstract_Coffee_Decorator(Abstract_Coffee):
   
   def __init__(self,decorated_coffee):
      self.decorated_coffee = decorated_coffee
   
   def get_cost(self):
      return self.decorated_coffee.get_cost()
   
   def get_ingredients(self):
      return self.decorated_coffee.get_ingredients()

class Sugar(Abstract_Coffee_Decorator):
   
   def __init__(self,decorated_coffee):
      Abstract_Coffee_Decorator.__init__(self,decorated_coffee)
   
   def get_cost(self):
      return self.decorated_coffee.get_cost()
   
   def get_ingredients(self):
	   return self.decorated_coffee.get_ingredients() + ', sugar'

class Milk(Abstract_Coffee_Decorator):
   
   def __init__(self,decorated_coffee):
      Abstract_Coffee_Decorator.__init__(self,decorated_coffee)
   
   def get_cost(self):
      return self.decorated_coffee.get_cost() + 0.25
   
   def get_ingredients(self):
      return self.decorated_coffee.get_ingredients() + ', milk'

class Vanilla(Abstract_Coffee_Decorator):
   
   def __init__(self,decorated_coffee):
      Abstract_Coffee_Decorator.__init__(self,decorated_coffee)
   
   def get_cost(self):
      return self.decorated_coffee.get_cost() + 0.75
   
   def get_ingredients(self):
      return self.decorated_coffee.get_ingredients() + ', vanilla'

Implementasi kelas abstrak dari kedai kopi dilakukan dengan file terpisah seperti yang disebutkan di bawah ini -

import coffeeshop

myCoffee = coffeeshop.Concrete_Coffee()
print('Ingredients: '+myCoffee.get_ingredients()+
   '; Cost: '+str(myCoffee.get_cost())+'; sales tax = '+str(myCoffee.get_tax()))

myCoffee = coffeeshop.Milk(myCoffee)
print('Ingredients: '+myCoffee.get_ingredients()+
   '; Cost: '+str(myCoffee.get_cost())+'; sales tax = '+str(myCoffee.get_tax()))

myCoffee = coffeeshop.Vanilla(myCoffee)
print('Ingredients: '+myCoffee.get_ingredients()+
   '; Cost: '+str(myCoffee.get_cost())+'; sales tax = '+str(myCoffee.get_tax()))

myCoffee = coffeeshop.Sugar(myCoffee)
print('Ingredients: '+myCoffee.get_ingredients()+
   '; Cost: '+str(myCoffee.get_cost())+'; sales tax = '+str(myCoffee.get_tax()))

Keluaran

Program di atas menghasilkan keluaran berikut -

Pola desain proxy menyertakan objek baru, yang disebut "Proxy" menggantikan objek yang sudah ada yang disebut "Subjek Nyata". Objek proxy yang dibuat dari subjek nyata harus berada pada antarmuka yang sama sedemikian rupa sehingga klien tidak boleh mendapatkan ide bahwa proxy digunakan sebagai pengganti objek sebenarnya. Permintaan yang dibuat oleh klien ke proxy diteruskan melalui subjek yang sebenarnya.

Representasi UML dari pola proxy adalah sebagai berikut -

Bagaimana cara menerapkan pola proxy?

Sekarang mari kita lihat bagaimana menerapkan pola proxy.

class Image:
   def __init__( self, filename ):
      self._filename = filename
   
   def load_image_from_disk( self ):
      print("loading " + self._filename )
   
   def display_image( self ):
      print("display " + self._filename)

class Proxy:
   def __init__( self, subject ):
      self._subject = subject
      self._proxystate = None

class ProxyImage( Proxy ):
   def display_image( self ):
      if self._proxystate == None:
         self._subject.load_image_from_disk()
         self._proxystate = 1
      print("display " + self._subject._filename )

proxy_image1 = ProxyImage ( Image("HiRes_10Mb_Photo1") )
proxy_image2 = ProxyImage ( Image("HiRes_10Mb_Photo2") )

proxy_image1.display_image() # loading necessary
proxy_image1.display_image() # loading unnecessary
proxy_image2.display_image() # loading necessary
proxy_image2.display_image() # loading unnecessary
proxy_image1.display_image() # loading unnecessary

Keluaran

Program di atas menghasilkan keluaran berikut -

Desain pola proxy membantu dalam mereplikasi gambar yang kita buat. Fungsi display_image () membantu untuk memeriksa apakah nilai dicetak pada prompt perintah.

Pola rantai tanggung jawab digunakan untuk mencapai kopling longgar dalam perangkat lunak di mana permintaan tertentu dari klien diteruskan melalui rantai objek yang termasuk di dalamnya. Ini membantu dalam membangun rantai objek. Permintaan masuk dari satu ujung dan berpindah dari satu objek ke objek lainnya.

Pola ini memungkinkan objek mengirimkan perintah tanpa mengetahui objek mana yang akan menangani permintaan tersebut.

Bagaimana menerapkan pola rantai tanggung jawab?

Sekarang kita akan melihat bagaimana menerapkan pola rantai tanggung jawab.

class ReportFormat(object):
   PDF = 0
   TEXT = 1
class Report(object):
   def __init__(self, format_):
      self.title = 'Monthly report'
      self.text = ['Things are going', 'really, really well.']
      self.format_ = format_

class Handler(object):
   def __init__(self):
      self.nextHandler = None

   def handle(self, request):
      self.nextHandler.handle(request)

class PDFHandler(Handler):

   def handle(self, request):
      if request.format_ == ReportFormat.PDF:
         self.output_report(request.title, request.text)
      else:
         super(PDFHandler, self).handle(request)
	
   def output_report(self, title, text):
      print '<html>'
      print ' <head>'
      print ' <title>%s</title>' % title
      print ' </head>'
      print ' <body>'
      for line in text:
         print ' <p>%s
' % line
      print ' </body>'
      print '</html>'

class TextHandler(Handler):
   
   def handle(self, request):
      if request.format_ == ReportFormat.TEXT:
         self.output_report(request.title, request.text)
      else:
         super(TextHandler, self).handle(request)
   
   def output_report(self, title, text):
      print 5*'*' + title + 5*'*'
      for line in text:
         print line

class ErrorHandler(Handler):
   def handle(self, request):
      print "Invalid request"

if __name__ == '__main__':
   report = Report(ReportFormat.TEXT)
   pdf_handler = PDFHandler()
   text_handler = TextHandler()

   pdf_handler.nextHandler = text_handler
   text_handler.nextHandler = ErrorHandler()
	pdf_handler.handle(report)

Keluaran

Program di atas menghasilkan keluaran berikut -

Penjelasan

Kode di atas membuat laporan untuk tugas bulanan yang mengirimkan perintah melalui setiap fungsi. Dibutuhkan dua penangan - untuk PDF dan untuk teks. Ini mencetak output setelah objek yang diperlukan menjalankan setiap fungsi.

Dalam pola ini, objek direpresentasikan sebagai pengamat yang menunggu peristiwa dipicu. Seorang pengamat menempel pada subjek setelah peristiwa tertentu terjadi. Saat peristiwa itu terjadi, subjek memberi tahu pengamat bahwa peristiwa itu telah terjadi.

Diagram UML berikut merepresentasikan pola pengamat -

Bagaimana cara menerapkan pola pengamat?

Sekarang mari kita lihat bagaimana menerapkan pola pengamat.

import threading
import time
import pdb

class Downloader(threading.Thread):
   
   def run(self):
      print 'downloading'
      for i in range(1,5):
         self.i = i
         time.sleep(2)
			print 'unfunf'
         return 'hello world'

class Worker(threading.Thread):
   def run(self):
      for i in range(1,5):
         print 'worker running: %i (%i)' % (i, t.i)
         time.sleep(1)
         t.join()

         print 'done'

t = Downloader()
t.start()

time.sleep(1)

t1 = Worker()
t1.start()

t2 = Worker()
t2.start()

t3 = Worker()
t3.start()

Keluaran

Program di atas menghasilkan keluaran berikut -

Penjelasan

Kode di atas menjelaskan prosedur mengunduh hasil tertentu. Sesuai logika pola pengamat, setiap objek diperlakukan sebagai pengamat. Ini mencetak output ketika acara dipicu.

Ini menyediakan modul untuk mesin negara, yang diimplementasikan menggunakan subclass, yang berasal dari kelas mesin negara yang ditentukan. Metode ini tidak bergantung negara dan menyebabkan transisi dideklarasikan menggunakan dekorator.

Bagaimana cara menerapkan pola negara?

Implementasi dasar dari pola negara ditunjukkan di bawah ini -

class ComputerState(object):

   name = "state"
   allowed = []

   def switch(self, state):
      """ Switch to new state """
      if state.name in self.allowed:
         print 'Current:',self,' => switched to new state',state.name
         self.__class__ = state
      else:
         print 'Current:',self,' => switching to',state.name,'not possible.'

   def __str__(self):
      return self.name

class Off(ComputerState):
   name = "off"
   allowed = ['on']

class On(ComputerState):
   """ State of being powered on and working """
   name = "on"
   allowed = ['off','suspend','hibernate']

class Suspend(ComputerState):
   """ State of being in suspended mode after switched on """
   name = "suspend"
   allowed = ['on']

class Hibernate(ComputerState):
   """ State of being in hibernation after powered on """
   name = "hibernate"
   allowed = ['on']

class Computer(object):
   """ A class representing a computer """
   
   def __init__(self, model='HP'):
      self.model = model
      # State of the computer - default is off.
      self.state = Off()
   
   def change(self, state):
      """ Change state """
      self.state.switch(state)

if __name__ == "__main__":
   comp = Computer()
   comp.change(On)
   comp.change(Off)
   comp.change(On)
   comp.change(Suspend)
   comp.change(Hibernate)
   comp.change(On)
   comp.change(Off)

Keluaran

Program di atas menghasilkan keluaran berikut -

Pola strategi adalah jenis pola perilaku. Tujuan utama dari pola strategi adalah untuk memungkinkan klien memilih dari berbagai algoritma atau prosedur untuk menyelesaikan tugas yang ditentukan. Algoritme yang berbeda dapat ditukar masuk dan keluar tanpa komplikasi untuk tugas yang disebutkan.

Pola ini dapat digunakan untuk meningkatkan fleksibilitas saat sumber daya eksternal diakses.

Bagaimana cara menerapkan pola strategi?

Program yang ditunjukkan di bawah ini membantu dalam menerapkan pola strategi.

import types

class StrategyExample:
   def __init__(self, func = None):
      self.name = 'Strategy Example 0'
      if func is not None:
         self.execute = types.MethodType(func, self)

   def execute(self):
      print(self.name)

def execute_replacement1(self): 
   print(self.name + 'from execute 1')

def execute_replacement2(self):
   print(self.name + 'from execute 2')

if __name__ == '__main__':
   strat0 = StrategyExample()
   strat1 = StrategyExample(execute_replacement1)
   strat1.name = 'Strategy Example 1'
   strat2 = StrategyExample(execute_replacement2)
   strat2.name = 'Strategy Example 2'
   strat0.execute()
   strat1.execute()
   strat2.execute()

Keluaran

Program di atas menghasilkan keluaran berikut -

Penjelasan

Ini memberikan daftar strategi dari fungsi, yang menjalankan output. Fokus utama dari pola perilaku ini adalah perilaku.

Pola templat mendefinisikan algoritme dasar dalam kelas dasar menggunakan operasi abstrak di mana subkelas menggantikan perilaku konkret. Pola templat menyimpan kerangka algoritme dalam metode terpisah. Metode ini disebut sebagai metode templat.

Berikut adalah fitur-fitur berbeda dari pola templat -

• Ini mendefinisikan kerangka algoritma dalam suatu operasi

• Ini termasuk subclass, yang mendefinisikan ulang langkah-langkah tertentu dari suatu algoritma.

class MakeMeal:

   def prepare(self): pass
   def cook(self): pass
   def eat(self): pass

   def go(self):
      self.prepare()
      self.cook()
      self.eat()

class MakePizza(MakeMeal):
   def prepare(self):
      print "Prepare Pizza"
   
   def cook(self):
      print "Cook Pizza"
   
   def eat(self):
      print "Eat Pizza"

class MakeTea(MakeMeal):
   def prepare(self):
      print "Prepare Tea"
	
   def cook(self):
      print "Cook Tea"
   
   def eat(self):
      print "Eat Tea"

makePizza = MakePizza()
makePizza.go()

print 25*"+"

makeTea = MakeTea()
makeTea.go()

Keluaran

Program di atas menghasilkan keluaran berikut -

Penjelasan

Kode ini membuat template untuk menyiapkan makanan. Di sini, setiap parameter mewakili atribut untuk membuat bagian dari makanan seperti teh, pizza, dll.

Outputnya merepresentasikan visualisasi atribut.

Pola kelas terbang berada di bawah kategori pola desain struktural. Ini memberikan cara untuk mengurangi jumlah objek. Ini mencakup berbagai fitur yang membantu dalam meningkatkan struktur aplikasi. Fitur terpenting dari objek kelas terbang adalah kekekalan. Ini berarti bahwa mereka tidak dapat dimodifikasi setelah dibuat. Pola tersebut menggunakan HashMap untuk menyimpan objek referensi.

Bagaimana cara menerapkan pola kelas terbang?

Program berikut membantu dalam menerapkan pola kelas terbang -

class ComplexGenetics(object):
   def __init__(self):
      pass
   
   def genes(self, gene_code):
      return "ComplexPatter[%s]TooHugeinSize" % (gene_code)
class Families(object):
   family = {}
   
   def __new__(cls, name, family_id):
      try:
         id = cls.family[family_id]
      except KeyError:
         id = object.__new__(cls)
         cls.family[family_id] = id
      return id
   
   def set_genetic_info(self, genetic_info):
      cg = ComplexGenetics()
      self.genetic_info = cg.genes(genetic_info)
   
   def get_genetic_info(self):
      return (self.genetic_info)

def test():
   data = (('a', 1, 'ATAG'), ('a', 2, 'AAGT'), ('b', 1, 'ATAG'))
   family_objects = []
   for i in data:
      obj = Families(i[0], i[1])
      obj.set_genetic_info(i[2])
      family_objects.append(obj)
   
   for i in family_objects:
      print "id = " + str(id(i))
      print i.get_genetic_info()
   print "similar id's says that they are same objects "

if __name__ == '__main__':
   test()

Keluaran

Program di atas menghasilkan keluaran berikut -

Pola pabrik yang abstrak juga disebut pabrik pabrik. Pola desain ini termasuk dalam kategori pola desain kreasi. Ini memberikan salah satu cara terbaik untuk membuat objek.

Ini termasuk antarmuka, yang bertanggung jawab untuk membuat objek yang terkait dengan Pabrik.

Bagaimana cara menerapkan pola pabrik abstrak?

Program berikut membantu dalam mengimplementasikan pola pabrik abstrak.

class Window:
   __toolkit = ""
   __purpose = ""

   def __init__(self, toolkit, purpose):
      self.__toolkit = toolkit
      self.__purpose = purpose
   
   def getToolkit(self):
      return self.__toolkit
   
   def getType(self):
      return self.__purpose

class GtkToolboxWindow(Window):
   def __init__(self):
      Window.__init__(self, "Gtk", "ToolboxWindow")

class GtkLayersWindow(Window):
   def __init__(self):
      Window.__init__(self, "Gtk", "LayersWindow")

class GtkMainWindow(Window):
   def __init__(self):
      Window.__init__(self, "Gtk", "MainWindow")

class QtToolboxWindow(Window):
   def __init__(self):
      Window.__init__(self, "Qt", "ToolboxWindow")

class QtLayersWindow(Window):
   def __init__(self):
      Window.__init__(self, "Qt", "LayersWindow")

class QtMainWindow(Window):
   def __init__(self):
      Window.__init__(self, "Qt", "MainWindow")

# Abstract factory class
class UIFactory:
   def getToolboxWindow(self): pass
   def getLayersWindow(self): pass
   def getMainWindow(self): pass

class GtkUIFactory(UIFactory):
   def getToolboxWindow(self):
      return GtkToolboxWindow()
   def getLayersWindow(self):
      return GtkLayersWindow()
   def getMainWindow(self):
      return GtkMainWindow()

class QtUIFactory(UIFactory):
   def getToolboxWindow(self):
      return QtToolboxWindow()
   def getLayersWindow(self):
      return QtLayersWindow()
   def getMainWindow(self):
      return QtMainWindow()

if __name__ == "__main__":
   gnome = True
   kde = not gnome
   
   if gnome:
      ui = GtkUIFactory()
   elif kde:
      ui = QtUIFactory()
   
   toolbox = ui.getToolboxWindow()
   layers = ui.getLayersWindow()
   main = ui.getMainWindow()
   
   print "%s:%s" % (toolbox.getToolkit(), toolbox.getType())
   print "%s:%s" % (layers.getToolkit(), layers.getType())
   print "%s:%s" % (main.getToolkit(), main.getType())

Keluaran

Program di atas menghasilkan keluaran berikut -

Penjelasan

Dalam program di atas, pabrik abstrak membuat objek untuk setiap jendela. Ini memanggil setiap metode, yang mengeksekusi keluaran seperti yang diharapkan.

Pola berorientasi objek adalah pola yang paling umum digunakan. Pola ini bisa ditemukan di hampir semua bahasa pemrograman.

Bagaimana cara menerapkan pola berorientasi objek?

Sekarang mari kita lihat bagaimana mengimplementasikan pola berorientasi objek.

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

Program di atas menghasilkan keluaran sebagai berikut

Penjelasan

Kode termasuk atribut kelas dan atribut contoh, yang dicetak sesuai kebutuhan output. Ada berbagai fitur yang menjadi bagian dari pola berorientasi objek. Fitur-fiturnya dijelaskan di bab selanjutnya.

Dalam bab ini, kita akan fokus pada pola yang menggunakan konsep berorientasi objek dan implementasinya dengan Python. Ketika kita merancang program kita di sekitar blok pernyataan, yang memanipulasi data di sekitar fungsi, itu disebut pemrograman berorientasi prosedur. Dalam pemrograman berorientasi objek, ada dua contoh utama yang disebut kelas dan objek.

Bagaimana cara menerapkan kelas dan variabel objek?

Implementasi kelas dan variabel objek adalah sebagai berikut -

class Robot:
   population = 0
   
   def __init__(self, name):
      self.name = name
      print("(Initializing {})".format(self.name))
      Robot.population += 1
   
   def die(self):
      print("{} is being destroyed!".format(self.name))
      Robot.population -= 1
      if Robot.population == 0:
         print("{} was the last one.".format(self.name))
      else:
         print("There are still {:d} robots working.".format(
            Robot.population))
   
   def say_hi(self):
      print("Greetings, my masters call me {}.".format(self.name))
   
   @classmethod
   def how_many(cls):
      print("We have {:d} robots.".format(cls.population))
droid1 = Robot("R2-D2")
droid1.say_hi()
Robot.how_many()

droid2 = Robot("C-3PO")
droid2.say_hi()
Robot.how_many()

print("\nRobots can do some work here.\n")

print("Robots have finished their work. So let's destroy them.")
droid1.die()
droid2.die()

Robot.how_many()

Keluaran

Program di atas menghasilkan keluaran berikut -

Penjelasan

Ilustrasi ini membantu menunjukkan sifat variabel kelas dan objek.

• "Populasi" termasuk dalam kelas "Robot". Oleh karena itu, ini disebut sebagai variabel atau objek kelas.

• Di sini, kami merujuk ke variabel kelas populasi sebagai Robot.population dan bukan sebagai self.population.

Pola desain iterator termasuk dalam kategori pola desain perilaku. Pengembang menemukan pola iterator di hampir setiap bahasa pemrograman. Pola ini digunakan sedemikian rupa sehingga membantu untuk mengakses elemen dari suatu koleksi (kelas) secara berurutan tanpa memahami desain lapisan yang mendasarinya.

Bagaimana cara menerapkan pola iterator?

Sekarang kita akan melihat bagaimana mengimplementasikan pola iterator.

import time

def fib():
   a, b = 0, 1
   while True:
      yield b
      a, b = b, a + b

g = fib()

try:
   for e in g:
      print(e)
      time.sleep(1)

except KeyboardInterrupt:
   print("Calculation stopped")

Keluaran

Program di atas menghasilkan keluaran berikut -

Jika Anda fokus pada pola, deret Fibonacci dicetak dengan pola iterator. Pada penghentian paksa pengguna, output berikut akan dicetak -

Penjelasan

Kode python ini mengikuti pola iterator. Di sini, operator increment digunakan untuk memulai penghitungan. Penghitungan berakhir pada penghentian paksa oleh pengguna.

Kamus adalah struktur data, yang menyertakan kombinasi nilai kunci. Ini banyak digunakan sebagai pengganti JSON - JavaScript Object Notation. Kamus digunakan untuk pemrograman API (Application Programming Interface). Kamus memetakan sekumpulan objek ke kumpulan objek lainnya. Kamus bisa berubah; ini berarti mereka dapat diubah jika dan bila diperlukan berdasarkan persyaratan.

Bagaimana cara menerapkan kamus dengan Python?

Program berikut menunjukkan implementasi dasar kamus dengan Python mulai dari pembuatannya hingga implementasinya.

# Create a new dictionary
d = dict() # or d = {}

# Add a key - value pairs to dictionary
d['xyz'] = 123
d['abc'] = 345

# print the whole dictionary
print(d)

# print only the keys
print(d.keys())

# print only values
print(d.values())

# iterate over dictionary
for i in d :
   print("%s %d" %(i, d[i]))
	
# another method of iteration
for index, value in enumerate(d):
   print (index, value , d[value])

# check if key exist 23. Python Data Structure –print('xyz' in d)

# delete the key-value pair
del d['xyz']

# check again
print("xyz" in d)

Keluaran

Program di atas menghasilkan keluaran berikut -

Note −Ada kekurangan terkait dengan penerapan kamus dengan Python.

Kekurangan

Kamus tidak mendukung operasi sekuens dari tipe data sekuens seperti string, tupel, dan daftar. Ini termasuk dalam jenis pemetaan bawaan.

Struktur data Daftar adalah jenis data serbaguna dengan Python, yang dapat ditulis sebagai daftar nilai yang dipisahkan koma di antara tanda kurung siku.

Sintaksis

Berikut adalah sintaks dasar untuk struktur -

List_name = [ elements ];

Jika Anda amati, sintaksnya dideklarasikan seperti array dengan satu-satunya perbedaan yaitu list dapat menyertakan elemen dengan tipe data berbeda. Array menyertakan elemen dari tipe data yang sama. Daftar dapat berisi kombinasi string, bilangan bulat, dan objek. Daftar dapat digunakan untuk implementasi tumpukan dan antrian.

Daftar bisa berubah. Ini dapat diubah jika diperlukan.

Bagaimana cara menerapkan daftar?

Program berikut menunjukkan implementasi daftar -

my_list = ['p','r','o','b','e']
# Output: p
print(my_list[0])

# Output: o
print(my_list[2])

# Output: e
print(my_list[4])

# Error! Only integer can be used for indexing
# my_list[4.0]

# Nested List
n_list = ["Happy", [2,0,1,5]]

# Nested indexing

# Output: a
print(n_list[0][1])

# Output: 5
print(n_list[1][3])

Keluaran

Program di atas menghasilkan keluaran berikut -

Fungsi bawaan daftar Python adalah sebagai berikut -

• Append()- Menambahkan elemen ke akhir daftar.

• Extend()- Menambahkan elemen dari daftar ke daftar lain.

• Insert()- Ini menyisipkan item ke indeks yang ditentukan.

• Remove()- Ini menghapus elemen dari daftar yang ditentukan.

• Reverse()- Ini membalikkan elemen dalam daftar.

• sort() - Ini membantu untuk mengurutkan elemen dalam urutan kronologis.

Kumpulan dapat didefinisikan sebagai koleksi tidak berurutan yang dapat diulang, dapat berubah dan tidak ada penyertaan elemen duplikat di dalamnya. Dalam Python, kelas himpunan adalah notasi himpunan matematika. Keuntungan utama menggunakan set adalah menyertakan metode yang sangat dioptimalkan untuk memeriksa elemen tertentu.

Python menyertakan kategori terpisah yang disebut set beku. Set ini adalah objek tetap yang hanya mendukung metode dan operator yang memberikan hasil yang diperlukan.

Bagaimana cara mengimplementasikan set?

Program berikut membantu dalam implementasi set -

# Set in Python

# Creating two sets
set1 = set()
set2 = set()

# Adding elements to set1
for i in range(1, 6):
   set1.add(i)

# Adding elements to set2
for i in range(3, 8):
   set2.add(i)

print("Set1 = ", set1)
print("Set2 = ", set2)
print("\n")

# Union of set1 and set2
set3 = set1 | set2# set1.union(set2)
print("Union of Set1 & Set2: Set3 = ", set3)

# Intersection of set1 and set2
set4 = set1 & set2# set1.intersection(set2)
print("Intersection of Set1 & Set2: Set4 = ", set4)
print("\n")

# Checking relation between set3 and set4
if set3 > set4: # set3.issuperset(set4)
   print("Set3 is superset of Set4")
elif set3 < set4: # set3.issubset(set4)
   print("Set3 is subset of Set4")
else : # set3 == set4
   print("Set3 is same as Set4")

# displaying relation between set4 and set3
if set4 < set3: # set4.issubset(set3)
   print("Set4 is subset of Set3")
   print("\n")

# difference between set3 and set4
set5 = set3 - set4
print("Elements in Set3 and not in Set4: Set5 = ", set5)
print("\n")

# checkv if set4 and set5 are disjoint sets
if set4.isdisjoint(set5):
   print("Set4 and Set5 have nothing in common\n")

# Removing all the values of set5
set5.clear()

print("After applying clear on sets Set5: ")
print("Set5 = ", set5)

Keluaran

Program di atas menghasilkan keluaran berikut -

Set beku dapat didemonstrasikan menggunakan program berikut -

normal_set = set(["a", "b","c"])

# Adding an element to normal set is fine
normal_set.add("d")

print("Normal Set")
print(normal_set)

# A frozen set
frozen_set = frozenset(["e", "f", "g"])

print("Frozen Set")
print(frozen_set)

Keluaran

Program di atas menghasilkan keluaran berikut -

Antrian adalah kumpulan objek, yang mendefinisikan struktur data sederhana mengikuti prosedur FIFO (Fast In Fast Out) dan LIFO (Last In First Out). Operasi penyisipan dan penghapusan disebut sebagaienqueue dan dequeue operasi.

Antrian tidak mengizinkan akses acak ke objek yang dikandungnya.

Bagaimana cara menerapkan prosedur FIFO?

Program berikut membantu dalam penerapan FIFO -

import Queue

q = Queue.Queue()

#put items at the end of the queue
for x in range(4):
   q.put("item-" + str(x))

#remove items from the head of the queue
while not q.empty():
   print q.get()

Keluaran

Program di atas menghasilkan keluaran berikut -

Bagaimana cara menerapkan prosedur LIFO?

Program berikut membantu dalam implementasi prosedur LIFO -

import Queue

q = Queue.LifoQueue()

#add items at the head of the queue
for x in range(4):
   q.put("item-" + str(x))

#remove items from the head of the queue
while not q.empty():
   print q.get()

Keluaran

Program di atas menghasilkan keluaran berikut -

Apa itu Antrian Prioritas?

Antrian prioritas adalah struktur data kontainer yang mengelola sekumpulan record dengan kunci yang diurutkan untuk menyediakan akses cepat ke record dengan kunci terkecil atau terbesar dalam struktur data yang ditentukan.

Bagaimana cara menerapkan antrian prioritas?

Implementasi antrian prioritas adalah sebagai berikut -

import Queue

class Task(object):
   def __init__(self, priority, name):
      self.priority = priority
      self.name = name
   
   def __cmp__(self, other):
      return cmp(self.priority, other.priority)

q = Queue.PriorityQueue()

q.put( Task(100, 'a not agent task') )
q.put( Task(5, 'a highly agent task') )
q.put( Task(10, 'an important task') )

while not q.empty():
   cur_task = q.get()
	print 'process task:', cur_task.name

Keluaran

Program di atas menghasilkan keluaran berikut -

Serialisasi string adalah proses menulis keadaan objek ke dalam aliran byte. Dalam python, pustaka "acar" digunakan untuk mengaktifkan serialisasi. Modul ini menyertakan algoritme yang kuat untuk membuat serial dan membatalkan serialisasi struktur objek Python. "Pengawetan" adalah proses mengubah hierarki objek Python menjadi aliran byte dan "membongkar" adalah prosedur sebaliknya.

Demonstrasi modul acar adalah sebagai berikut -

import pickle

#Here's an example dict
grades = { 'Alice': 89, 'Bob': 72, 'Charles': 87 }

#Use dumps to convert the object to a serialized string
serial_grades = pickle.dumps( grades )
print(serial_grades)

#Use loads to de-serialize an object
received_grades = pickle.loads( serial_grades )
print(received_grades)

Keluaran

Program di atas menghasilkan keluaran berikut -

Konkurensi sering disalahartikan sebagai paralelisme. Concurrency menyiratkan penjadwalan kode independen untuk dieksekusi secara sistematis. Bab ini berfokus pada eksekusi konkurensi untuk sistem operasi menggunakan Python.

Program berikut membantu dalam pelaksanaan konkurensi untuk sistem operasi -

import os
import time
import threading
import multiprocessing

NUM_WORKERS = 4

def only_sleep():
   print("PID: %s, Process Name: %s, Thread Name: %s" % (
      os.getpid(),
      multiprocessing.current_process().name,
      threading.current_thread().name)
   )
   time.sleep(1)

def crunch_numbers():
   print("PID: %s, Process Name: %s, Thread Name: %s" % (
      os.getpid(),
      multiprocessing.current_process().name,
      threading.current_thread().name)
   )
   x = 0
   while x < 10000000:
      x += 1
for _ in range(NUM_WORKERS):
   only_sleep()
end_time = time.time()
print("Serial time=", end_time - start_time)

# Run tasks using threads
start_time = time.time()
threads = [threading.Thread(target=only_sleep) for _ in range(NUM_WORKERS)]
[thread.start() for thread in threads]
[thread.join() for thread in threads]
end_time = time.time()

print("Threads time=", end_time - start_time)

# Run tasks using processes
start_time = time.time()
processes = [multiprocessing.Process(target=only_sleep()) for _ in range(NUM_WORKERS)]
[process.start() for process in processes]
[process.join() for process in processes]
end_time = time.time()

print("Parallel time=", end_time - start_time)

Keluaran

Program di atas menghasilkan keluaran berikut -

Penjelasan

"Multiprocessing" adalah paket yang mirip dengan modul threading. Paket ini mendukung konkurensi lokal dan jarak jauh. Karena modul ini, programmer mendapatkan keuntungan untuk menggunakan banyak proses pada sistem yang diberikan.

Anti-pola mengikuti strategi yang bertentangan dengan pola desain yang telah ditentukan sebelumnya. Strategi tersebut mencakup pendekatan umum untuk masalah umum, yang dapat diformalkan dan secara umum dapat dianggap sebagai praktik pembangunan yang baik. Biasanya, anti-pola berlawanan dan tidak diinginkan. Antipola adalah pola tertentu yang digunakan dalam pengembangan perangkat lunak, yang dianggap sebagai praktik pemrograman yang buruk.

Fitur penting anti pola

Sekarang mari kita lihat beberapa fitur penting dari anti-pola.

Ketepatan

Pola-pola ini benar-benar merusak kode Anda dan membuat Anda melakukan hal yang salah. Berikut adalah ilustrasi sederhana tentang ini -

class Rectangle(object):
def __init__(self, width, height):
self._width = width
self._height = height
r = Rectangle(5, 6)
# direct access of protected member
print("Width: {:d}".format(r._width))

Pemeliharaan

Suatu program dikatakan dapat dipelihara jika mudah dipahami dan dimodifikasi sesuai kebutuhan. Mengimpor modul dapat dianggap sebagai contoh pemeliharaan.

import math
x = math.ceil(y)
# or
import multiprocessing as mp
pool = mp.pool(8)

Contoh anti pola

Contoh berikut membantu dalam demonstrasi anti-pola -

#Bad
def filter_for_foo(l):
   r = [e for e in l if e.find("foo") != -1]
   if not check_some_critical_condition(r):
      return None
   return r

res = filter_for_foo(["bar","foo","faz"])

if res is not None:
   #continue processing
   pass

#Good
def filter_for_foo(l):
   r = [e for e in l if e.find("foo") != -1]
   if not check_some_critical_condition(r):
      raise SomeException("critical condition unmet!")
   return r

try:
   res = filter_for_foo(["bar","foo","faz"])
   #continue processing

except SomeException:
   i = 0
while i < 10:
   do_something()
   #we forget to increment i

Penjelasan

Contohnya termasuk demonstrasi standar baik dan buruk untuk membuat fungsi dengan Python.

Penanganan pengecualian juga merupakan kriteria utama pola desain. Pengecualian adalah kesalahan yang terjadi selama eksekusi program. Saat kesalahan tertentu terjadi, penting untuk membuat pengecualian. Ini membantu dalam mengekang crash program.

Mengapa menggunakan pengecualian?

Pengecualian adalah cara mudah untuk menangani kesalahan dan kondisi khusus dalam sebuah program. Ketika seorang pengguna berpikir bahwa kode yang ditentukan dapat menghasilkan kesalahan maka penting untuk menggunakan penanganan pengecualian.

Contoh - Pembagian dengan nol

import sys

randomList = ['a', 0, 2]

for entry in randomList:
   try:
      print("The entry is", entry)
      r = 1/int(entry)
      break
   except:
      print("Oops!",sys.exc_info()[0],"occured.")
      print("Next entry.")
      print()
print("The reciprocal of",entry,"is",r)

Keluaran

Program di atas menghasilkan keluaran berikut -

Meningkatkan Pengecualian

Dalam pemrograman Python, pengecualian dimunculkan ketika kesalahan kode yang sesuai terjadi pada waktu proses. Ini dapat dinaikkan secara paksa menggunakan“raise” kata kunci.

Sintaksis

raise KeyboardInterrupt
Traceback (most recent call last):
...
KeyboardInterrupt