Python Tasarım Kalıpları - Hızlı Kılavuz

Tasarım kalıpları, geliştiriciler tarafından yazılım veya web uygulaması oluşturmak için kullanılan kalıbı temsil etmek için kullanılır. Bu modeller, ihtiyaç analizine göre seçilir. Örüntüler, sorunun çözümünü, çözümün ne zaman ve nerede uygulanacağını ve uygulamanın sonuçlarını açıklar.

Bir tasarım modelinin yapısı

Tasarım modelinin dokümantasyonu, daha çok kullanılan teknolojiye ve hangi şekillerde odaklanacak şekilde tutulur. Aşağıdaki şema, tasarım şablonu belgelerinin temel yapısını açıklamaktadır.

Desen Adı

Modeli kısa ve etkili bir şekilde açıklar.

Amaç / Sebep

Modelin ne yaptığını açıklar.

Uygulanabilirlik

Modelin uygulanabilir olduğu durumların listesini açıklar.

Katılımcılar ve sonuçlar

Katılımcılar, desenle birlikte var olan sonuçların bir listesiyle tasarım modeline katılan sınıfları ve nesneleri içerir.

Neden Python?

Python, açık kaynaklı bir betik dilidir. Çeşitli tasarım modellerini destekleyen kitaplıklara sahiptir. Python sözdiziminin anlaşılması kolaydır ve İngilizce anahtar sözcükler kullanır.

Python, aşağıda belirtilen tasarım modellerinin listesi için destek sağlar. Bu tasarım kalıpları bu eğitim boyunca kullanılacaktır -

  • Model Görünümü Denetleyici Kalıbı
  • Tekli desen
  • Fabrika deseni
  • Oluşturucu Desen
  • Prototip Desen
  • Cephe Deseni
  • Komut Deseni
  • Adaptör Modeli
  • Prototip Desen
  • Dekoratör Deseni
  • Proxy Kalıbı
  • Sorumluluk Zinciri Modeli
  • Gözlemci Örüntüsü
  • Durum Modeli
  • Strateji Modeli
  • Şablon Deseni
  • Flyweight Desen
  • Soyut Fabrika Modeli
  • Nesneye Yönelik Desen

Tasarım desenini kullanmanın faydaları

Aşağıda, tasarım modelinin farklı faydaları verilmiştir -

  • Desenler, geliştiriciye, belirtilen sorunlar için denenmiş ve test edilmiş çözümlerden bir seçim sağlar.

  • Tüm tasarım modelleri dilden bağımsızdır.

  • Kalıplar, iletişimi sağlamaya ve belgelerin iyi korunmasına yardımcı olur.

  • Projeye yönelik herhangi bir teknik riski azaltmak için bir başarı kaydı içerir.

  • Tasarım modellerinin kullanımı oldukça esnektir ve anlaşılması kolaydır.

Python, yüksek seviyeli, yorumlanmış, etkileşimli ve nesne yönelimli bir açık kaynak kodlama dilidir. Oldukça okunabilir olacak şekilde tasarlanmıştır. Python dilinin sözdiziminin anlaşılması kolaydır ve sık sık İngilizce anahtar sözcükler kullanır.

Python Dilinin Özellikleri

Bu bölümde, Python dilinin farklı özelliklerini öğreneceğiz.

Yorumlandı

Python, yorumlayıcı kullanılarak çalışma zamanında işlenir. Çalıştırmadan önce program derlemeye gerek yoktur. PERL ve PHP'ye benzer.

Nesne odaklı

Python, nesneye yönelik stili ve tasarım modellerini takip eder. Kapsülleme, polimorfizm ve çok daha fazlası gibi çeşitli özelliklerle sınıf tanımını içerir.

Taşınabilir

Python kodu Windows işletim sisteminde yazılmıştır ve Mac işletim sisteminde kullanılabilir. Kod, gereksinimlere göre yeniden kullanılabilir ve taşınabilir.

Kodlaması kolay

Python sözdiziminin anlaşılması ve kodlanması kolaydır. Herhangi bir geliştirici birkaç saat içinde Python sözdizimini anlayabilir. Python, "programcı dostu" olarak tanımlanabilir

Genişletilebilir

Gerekirse, kullanıcı bazı Python kodunu C dilinde de yazabilir. Python kodunu C ++ gibi farklı dillerde kaynak koduna koymak da mümkündür. Bu, Python'u genişletilebilir bir dil yapar.

Önemli noktalar

Python programlama dili ile ilgili aşağıdaki önemli noktaları göz önünde bulundurun -

  • İşlevsel ve yapılandırılmış programlama yöntemlerinin yanı sıra nesneye yönelik programlama yöntemlerini içerir.

  • Komut dosyası dili veya programlama dili olarak kullanılabilir.

  • Otomatik çöp toplamayı içerir.

  • Üst düzey dinamik veri türlerini içerir ve çeşitli dinamik tür denetimini destekler.

  • Python, C, C ++ ve Java gibi dillerle entegrasyon özelliği içerir.

Sisteminize python dili nasıl indirilir?

Python dilini sisteminize indirmek için bu bağlantıyı izleyin -

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

Windows, MacOS ve Linux dağıtımları gibi çeşitli işletim sistemleri için paketler içerir.

Python'daki Önemli Araçlar

Bu bölümde, Python'daki birkaç önemli araç hakkında kısaca bilgi edineceğiz.

Python Dizeleri

Dizelerin temel beyanı aşağıdaki gibidir -

str = 'Hello World!'

Python Listeleri

Python listeleri, virgülle ayrılmış ve köşeli parantez ([]) içine alınmış bileşik veri türleri olarak bildirilebilir.

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

Python Tuples

Tuple, virgülle ayrılmış değerlerin sayısından oluşan dinamik veri türü Python'dur. Tuple'lar parantez içine alınır.

tinytuple = (123, 'john')

Python Sözlüğü

Python sözlüğü bir tür karma tablodur. Bir sözlük anahtarı, hemen hemen her veri türü Python olabilir. Veri türleri genellikle sayılar veya dizelerdir.

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

Python'da bir tasarım modelini neler oluşturur?

Python, aşağıdaki parametreleri kullanarak bir tasarım modeli oluşturmaya yardımcı olur -

  • Desen Adı
  • Intent
  • Aliases
  • Motivation
  • Problem
  • Solution
  • Structure
  • Participants
  • Constraints
  • Basit kod

Model View Controller, en yaygın kullanılan tasarım modelidir. Geliştiriciler bu tasarım modelini uygulamayı kolay buluyor.

Aşağıda Model Görünüm Denetleyicisinin temel bir mimarisi verilmiştir -

Şimdi yapının nasıl çalıştığını görelim.

Modeli

Veritabanıyla etkileşime giren saf uygulama mantığından oluşur. Verileri son kullanıcıya sunacak tüm bilgileri içerir.

Görünüm

Görünüm, son kullanıcıyla etkileşime giren HTML dosyalarını temsil eder. Modelin verilerini kullanıcıya gösterir.

Kontrolör

Görünüm ve model arasında bir aracı görevi görür. Aynı şekilde view ve sorgu modelinin tetiklediği olayları dinler.

Python kodu

"Kişi" adlı temel bir nesneyi düşünelim ve bir MVC tasarım modeli oluşturalım.

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

Veritabanındaki Person tablosunun tüm kayıtlarını getiren bir yöntemi çağırır. Kayıtlar JSON formatında sunulmaktadır.

Görünüm

Model içinde getirilen tüm kayıtları görüntüler. View asla modelle etkileşim kurmaz; denetleyici bu işi yapar (model ve görünümle iletişim kurarak).

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!'

Kontrolör

Denetleyici, modelle etkileşime girer. getAll() Son kullanıcıya görüntülenen tüm kayıtları getiren yöntem.

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()

Bu desen, bir sınıfın somutlaştırılmasını tek bir nesneyle sınırlar. Bu bir tür yaratımsal modeldir ve metotları ve belirli nesneleri oluşturmak için yalnızca bir sınıf içerir.

Oluşturulan örneğe genel bir erişim noktası sağlar.

Bir singleton sınıfı nasıl uygulanır?

Aşağıdaki program, birden çok kez oluşturulan örnekleri yazdırdığı singleton sınıfının uygulamasını gösterir.

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

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Oluşturulan örneklerin sayısı aynıdır ve çıktıda listelenen nesnelerde hiçbir fark yoktur.

Fabrika kalıbı, yaratım kalıpları listesi kategorisinin altında gelir. Bir nesne yaratmanın en iyi yollarından birini sağlar. Fabrika modelinde nesneler, mantığı istemciye göstermeden ve ortak bir arayüz kullanılarak yeni oluşturulan nesneye atıfta bulunmadan oluşturulur.

Fabrika kalıpları, fabrika yöntemi kullanılarak Python'da uygulanır. Bir kullanıcı, bir dizeyi iletecek şekilde bir yöntemi çağırdığında ve yeni bir nesne olarak dönüş değeri fabrika yöntemi aracılığıyla uygulanır. Fabrika yönteminde kullanılan nesnenin türü, yöntemden geçirilen dizge tarafından belirlenir.

Aşağıdaki örnekte, her yöntem, fabrika yöntemiyle uygulanan bir parametre olarak nesneyi içerir.

Bir fabrika modeli nasıl uygulanır?

Şimdi bir fabrika modelinin nasıl uygulanacağını görelim.

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()

Düğme sınıfı, html etiketlerini ve ilişkili html sayfasını oluşturmaya yardımcı olur. İstemcinin kod mantığına erişimi olmayacak ve çıktı html sayfasının oluşturulmasını temsil edecek.

Çıktı

Açıklama

Python kodu, değeri belirten html etiketlerinin mantığını içerir. Son kullanıcı, Python kodu tarafından oluşturulan HTML dosyasına bakabilir.

Builder Pattern, basit nesneler kullanarak karmaşık nesneler oluşturmaya yardımcı olan ve algoritmik bir yaklaşım kullanan benzersiz bir tasarım modelidir. Bu tasarım deseni, yaratıcı desen kategorisine girer. Bu tasarım modelinde, bir oluşturucu sınıfı, son nesneyi adım adım prosedürle oluşturur. Bu kurucu diğer nesnelerden bağımsızdır.

Builder Modelinin Avantajları

  • Sınıf tarafından oluşturulan belirli bir nesnenin yapımı ve temsili arasında net bir ayrım ve benzersiz bir katman sağlar.

  • Oluşturulan desenin yapım süreci üzerinde daha iyi kontrol sağlar.

  • Nesnelerin iç temsilini değiştirmek için mükemmel bir senaryo verir.

Oluşturucu kalıbı nasıl uygulanır?

Bu bölümde, oluşturucu modelinin nasıl uygulanacağını öğreneceğiz.

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()

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Prototip tasarım deseni, sınıf tarafından oluşturulan örneklerin karmaşıklığını gizlemeye yardımcı olur. Mevcut nesnenin konsepti, sıfırdan yaratılan yeni nesnenin konseptinden farklı olacaktır.

Yeni kopyalanan nesnenin, gerekirse özelliklerinde bazı değişiklikler olabilir. Bu yaklaşım, bir ürünün geliştirilmesi için harcanan zamandan ve kaynaklardan tasarruf sağlar.

Bir prototip kalıbı nasıl uygulanır?

Şimdi bir prototip modelinin nasıl uygulanacağını görelim.

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()

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretecektir -

Çıktı, mevcut nesnelerle yeni nesneler oluşturmaya yardımcı olur ve yukarıda belirtilen çıktıda açıkça görülebilir.

Cephe tasarım modeli, bir alt sistemdeki bir dizi arabirime birleşik bir arabirim sağlar. Herhangi bir alt sistemin kullanabileceği daha yüksek seviyeli bir arabirimi tanımlar.

Bir cephe sınıfı, bir talepten hangi alt sistemin sorumlu olduğunu bilir.

Cephe kalıbı nasıl tasarlanır?

Şimdi bir cephe deseninin nasıl tasarlanacağını görelim.

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()

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Açıklama

Bu program bir senaryo ile tasarlanmıştır. Bir arabanın veya herhangi bir sürülen aracın motorunu çalıştırma işlemidir. Kodu gözlemlerseniz, sürüş, park etme ve yakıt tüketme ile ilgili işlevleri de içerir.

Komut Modeli, eylemler arasına bir soyutlama düzeyi ekler ve bu eylemleri başlatan bir nesne içerir.

Bu tasarım modelinde, müşteri yürütülecek komutların bir listesini içeren bir komut nesnesi oluşturur. Oluşturulan komut nesnesi belirli bir arabirimi uygular.

Aşağıda, komut modelinin temel mimarisi verilmiştir -

Komut kalıbı nasıl uygulanır?

Şimdi tasarım modelinin nasıl uygulanacağını göreceğiz.

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)

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Açıklama

Çıktı, Python dilinde listelenen tüm komutları ve anahtar kelimeleri uygular. Değişkenlerin gerekli değerlerini yazdırır.

Bağdaştırıcı modeli, iki uyumsuz arabirim arasında bir köprü görevi görür. Bu model, iki bağımsız arayüzün kapasitesini birleştirdiğinden, bu tür bir tasarım modeli yapısal modele girer.

Bu model, bağımsız veya uyumsuz arayüzlerin işlevlerini birleştirmekten sorumlu tek bir sınıfı içerir. Gerçek hayattan bir örnek, hafıza kartı ile dizüstü bilgisayar arasında adaptör görevi gören bir kart okuyucu durumu olabilir. Hafıza kartını kart okuyucuya ve kart okuyucuyu dizüstü bilgisayara takarsınız, böylece hafıza kartı dizüstü bilgisayar üzerinden okunabilir.

Adaptör tasarım modeli, sınıfların birlikte çalışılmasına yardımcı olur. Bir sınıfın arayüzünü ihtiyaca göre başka bir arayüze dönüştürür. Model, bir tür, bir adı ve birden çok formu adlandıran bir polimorfizm içerir. Toplanan gereksinimlere göre kullanılabilecek bir şekil sınıfı için söyleyin.

İki tür adaptör modeli vardır -

Nesne Bağdaştırıcı Modeli

Bu tasarım modeli, nesne uygulamasına dayanır. Bu nedenle buna Nesne Adaptör Modeli denir.

Sınıf Adaptör Modeli

Bu, adaptör tasarım modelini uygulamanın alternatif bir yoludur. Model, birden çok miras kullanılarak uygulanabilir.

Adaptör modeli nasıl uygulanır?

Şimdi adaptör modelinin nasıl uygulanacağını görelim.

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()

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Açıklama

Kod, çeşitli parametreler ve niteliklere sahip adaptör arabirimini içerir. Tüm öznitelikleri uygulayan ve çıktıyı görünür olarak görüntüleyen Hedef arabirimiyle birlikte Adaptee'yi içerir.

Dekoratör deseni, bir kullanıcının yapısını değiştirmeden mevcut bir nesneye yeni işlevsellik eklemesine izin verir. Bu desen türü, bu desen mevcut sınıf için bir sarmalayıcı görevi gördüğünden yapısal modele girer.

Bu desen, orijinal sınıfı saran ve sınıf yöntemlerinin imzasını olduğu gibi koruyan ek işlevsellik sağlayan bir dekoratör sınıfı oluşturur.

Bir dekoratör modelinin amacı, bir nesneye dinamik olarak ek sorumluluklar eklemektir.

Dekoratör tasarım modeli nasıl uygulanır

Aşağıda bahsedilen kod, Python'da dekoratör tasarım modelinin nasıl uygulanacağının basit bir göstergesidir. Çizim, sınıf formatında bir kafenin gösterimini içerir. Oluşturulan kahve sınıfı soyuttur, yani somutlaştırılamaz.

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'

Kahvehanenin soyut sınıfının uygulaması aşağıda belirtildiği gibi ayrı bir dosya ile yapılmaktadır -

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()))

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Proxy tasarım deseni, "Gerçek Özne" olarak adlandırılan mevcut bir nesnenin yerine "Proxy" adı verilen yeni bir nesne içerir. Gerçek özneden oluşturulan proxy nesnesi, istemcinin gerçek nesnenin yerine proxy kullanıldığına dair herhangi bir fikir almaması için aynı arayüzde olmalıdır. Müşteri tarafından vekile yapılan talepler gerçek konu üzerinden iletilir.

Proxy modelinin UML gösterimi aşağıdaki gibidir -

Proxy modeli nasıl uygulanır?

Şimdi proxy modelinin nasıl uygulanacağını görelim.

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

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Proxy desen tasarımı, oluşturduğumuz görüntülerin kopyalanmasına yardımcı olur. Display_image () işlevi, değerlerin komut isteminde yazdırılıp yazdırılmadığını kontrol etmeye yardımcı olur.

Sorumluluk zinciri modeli, müşteriden gelen belirli bir talebin içerdiği nesneler zincirinden geçirildiği yazılımda gevşek bağlantı sağlamak için kullanılır. Bir nesne zinciri oluşturmaya yardımcı olur. İstek bir uçtan girer ve bir nesneden diğerine geçer.

Bu kalıp, bir nesnenin, hangi nesnenin isteği yerine getireceğini bilmeden bir komut göndermesine izin verir.

Sorumluluk zinciri modeli nasıl uygulanır?

Şimdi sorumluluk zinciri modelinin nasıl uygulanacağını göreceğiz.

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)

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Açıklama

Yukarıdaki kod, her işlev aracılığıyla komutlar gönderdiği aylık görevler için bir rapor oluşturur. İki işleyici gerektirir - PDF ve metin için. Çıkışı, gerekli nesne her işlevi çalıştırdığında yazdırır.

Bu modelde nesneler, bir olayın tetiklenmesini bekleyen gözlemciler olarak temsil edilir. Bir gözlemci, belirtilen olay gerçekleştiğinde özneye bağlanır. Olay meydana geldikçe, denek gözlemcilere bunun gerçekleştiğini söyler.

Aşağıdaki UML diyagramı, gözlemci modelini temsil eder -

Gözlemci modeli nasıl uygulanır?

Şimdi gözlemci modelinin nasıl uygulanacağını görelim.

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()

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Açıklama

Yukarıdaki kod, belirli bir sonucu indirme prosedürünü açıklamaktadır. Gözlemci örüntü mantığına göre, her nesne gözlemci olarak kabul edilir. Olay tetiklendiğinde çıktıyı yazdırır.

Belirli bir durum makinesi sınıfından türetilen alt sınıflar kullanılarak uygulanan durum makineleri için bir modül sağlar. Yöntemler durumdan bağımsızdır ve dekoratörler kullanılarak bildirilen geçişlere neden olur.

Durum modeli nasıl uygulanır?

Durum modelinin temel uygulaması aşağıda gösterilmiştir -

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)

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Strateji kalıbı bir tür davranış kalıbıdır. Strateji modelinin ana amacı, müşterinin belirtilen görevi tamamlamak için farklı algoritmalar veya prosedürler arasından seçim yapmasını sağlamaktır. Belirtilen görev için herhangi bir komplikasyon olmadan farklı algoritmalar içeri ve dışarı değiştirilebilir.

Bu model, dış kaynaklara erişildiğinde esnekliği artırmak için kullanılabilir.

Strateji modeli nasıl uygulanır?

Aşağıda gösterilen program, strateji modelinin uygulanmasına yardımcı olur.

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()

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Açıklama

Çıktıyı yürüten işlevlerden stratejilerin bir listesini sağlar. Bu davranış modelinin ana odağı davranıştır.

Bir şablon desen, alt sınıfların somut davranışı geçersiz kıldığı, soyut işlemi kullanan bir temel sınıfta temel bir algoritmayı tanımlar. Şablon kalıbı, algoritmanın ana hatlarını ayrı bir yöntemde tutar. Bu yöntem, şablon yöntemi olarak adlandırılır.

Şablon modelinin farklı özellikleri aşağıdadır -

  • Bir işlemde algoritmanın iskeletini tanımlar

  • Bir algoritmanın belirli adımlarını yeniden tanımlayan alt sınıfları içerir.

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()

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Açıklama

Bu kod, yemek hazırlamak için bir şablon oluşturur. Buradaki her parametre, yemeğin çay, pizza vb. Gibi bir bölümünü oluşturan özelliği temsil eder.

Çıktı, niteliklerin görselleştirilmesini temsil eder.

Flyweight patterb, yapısal tasarım modelleri kategorisine girer. Nesne sayısını azaltmanın bir yolunu sağlar. Uygulama yapısını iyileştirmeye yardımcı olan çeşitli özellikler içerir. Flyweight nesnelerin en önemli özelliği değişmez olmasıdır. Bu, inşa edildikten sonra değiştirilemeyecekleri anlamına gelir. Desen, referans nesnelerini depolamak için bir HashMap kullanır.

Uçuş ağırlığı modeli nasıl uygulanır?

Aşağıdaki program, uçuş ağırlığı modelinin uygulanmasına yardımcı olur -

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()

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Soyut fabrika modeline fabrikalar fabrikası da denir. Bu tasarım deseni, yaratıcı tasarım deseni kategorisine girer. Bir nesne yaratmanın en iyi yollarından birini sağlar.

Fabrika ile ilgili nesnelerin oluşturulmasından sorumlu bir arayüz içerir.

Soyut fabrika modeli nasıl uygulanır?

Aşağıdaki program, soyut fabrika modelinin uygulanmasına yardımcı olur.

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())

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Açıklama

Yukarıdaki programda, soyut fabrika her pencere için nesneler oluşturur. Çıkışı beklendiği gibi yürüten her yöntemi çağırır.

Nesne yönelimli desen, en yaygın kullanılan modeldir. Bu kalıp hemen hemen her programlama dilinde bulunabilir.

Nesne yönelimli desen nasıl uygulanır?

Şimdi nesne yönelimli modelin nasıl uygulanacağını görelim.

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))

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir

Açıklama

Kod, çıktının gereksinimine göre yazdırılan sınıf özniteliğini ve örnek özniteliklerini içerir. Nesne yönelimli desenin bir parçasını oluşturan çeşitli özellikler vardır. Özellikler sonraki bölümde açıklanmaktadır.

Bu bölümde, nesne yönelimli kavramları kullanan kalıplara ve Python'da uygulanmasına odaklanacağız. Programlarımızı, fonksiyonlar etrafındaki verileri işleyen ifade blokları etrafında tasarladığımızda, buna prosedür odaklı programlama denir. Nesne yönelimli programlamada, sınıflar ve nesneler olarak adlandırılan iki ana örnek vardır.

Sınıflar ve nesne değişkenleri nasıl uygulanır?

Sınıfların ve nesne değişkenlerinin uygulanması aşağıdaki gibidir -

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()

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Açıklama

Bu çizim, sınıf ve nesne değişkenlerinin doğasını göstermeye yardımcı olur.

  • "Nüfus", "Robot" sınıfına aittir. Bu nedenle, bir sınıf değişkeni veya nesne olarak adlandırılır.

  • Burada, nüfus sınıfı değişkenini kendi kendine nüfus olarak değil, Robot popülasyonu olarak adlandırıyoruz.

Yineleyici tasarım modeli, davranışsal tasarım modelleri kategorisine girer. Geliştiriciler, neredeyse her programlama dilinde yineleyici modeliyle karşılaşır. Bu desen, temel katman tasarımını anlamadan bir koleksiyonun (sınıfın) öğelerine sıralı bir şekilde erişmeye yardımcı olacak şekilde kullanılır.

Yineleyici modeli nasıl uygulanır?

Şimdi yineleyici modelinin nasıl uygulanacağını göreceğiz.

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")

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Desene odaklanırsanız, Fibonacci serisi yineleyici desenle yazdırılır. Kullanıcının zorla sonlandırılması üzerine, aşağıdaki çıktı yazdırılır -

Açıklama

Bu python kodu yineleyici modelini takip eder. Burada, sayımı başlatmak için artış operatörleri kullanılır. Sayım, kullanıcı tarafından zorla feshedildiğinde sona erer.

Sözlükler, bir anahtar-değer kombinasyonu içeren veri yapılarıdır. Bunlar, JSON - JavaScript Object Notation yerine yaygın olarak kullanılmaktadır. Sözlükler, API (Uygulama Programlama Arayüzü) programlama için kullanılır. Sözlük, bir dizi nesneyi başka bir nesne kümesiyle eşler. Sözlükler değiştirilebilir; bu, gereksinimlere göre gerektiğinde değiştirilebilecekleri anlamına gelir.

Python'da sözlükler nasıl uygulanır?

Aşağıdaki program, sözlüklerin Python'da oluşturulmasından uygulanmasına kadar temel uygulamasını göstermektedir.

# 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)

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Note −Python'da sözlüklerin uygulanmasının sakıncaları vardır.

Dezavantaj

Sözlükler dizeler, tuplelar ve listeler gibi dizi veri türlerinin sıralı çalışmasını desteklemez. Bunlar yerleşik eşleme türüne aittir.

Listeler veri yapısı, Python'da köşeli parantezler arasında virgülle ayrılmış değerlerin bir listesi olarak yazılabilen çok yönlü bir veri türüdür.

Sözdizimi

İşte yapı için temel sözdizimi -

List_name = [ elements ];

Gözlem yaparsanız, sözdizimi diziler gibi bildirilir; tek fark, listelerin farklı veri türlerine sahip öğeleri içerebilmesidir. Diziler aynı veri türündeki öğeleri içerir. Bir liste, dizelerin, tam sayıların ve nesnelerin bir kombinasyonunu içerebilir. Listeler yığınların ve kuyrukların uygulanması için kullanılabilir.

Listeler değiştirilebilir. Bunlar gerektiğinde değiştirilebilir.

Listeler nasıl uygulanır?

Aşağıdaki program listelerin uygulamalarını göstermektedir -

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])

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Python listelerinin yerleşik işlevleri aşağıdaki gibidir -

  • Append()- Listenin sonuna eleman ekler.

  • Extend()- Listenin unsurlarını başka bir listeye ekler.

  • Insert()- Tanımlanan dizine bir öğe ekler.

  • Remove()- Belirtilen listeden elemanı siler.

  • Reverse()- Listedeki öğeleri tersine çevirir.

  • sort() - Öğelerin kronolojik sıraya göre sıralanmasına yardımcı olur.

Bir küme, yinelenebilen, değiştirilebilen ve içinde yinelenen öğeler bulunmayan sırasız koleksiyon olarak tanımlanabilir. Python'da, küme sınıfı matematiksel kümenin bir gösterimidir. Bir set kullanmanın temel avantajı, belirli bir öğeyi kontrol etmek için oldukça optimize edilmiş bir yöntem içermesidir.

Python, dondurulmuş kümeler adı verilen ayrı bir kategori içerir. Bu kümeler, yalnızca gerekli sonucu üreten yöntemleri ve işleçleri destekleyen değişmez nesnelerdir.

Setler nasıl uygulanır?

Aşağıdaki program setlerin uygulanmasına yardımcı olur -

# 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)

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Dondurulmuş set aşağıdaki program kullanılarak gösterilebilir -

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)

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Kuyruk, FIFO (Hızlı Giriş Hızlı Çıkış) ve LIFO (Son Giren İlk Çıkar) prosedürlerini izleyen basit bir veri yapısını tanımlayan bir nesneler koleksiyonudur. Ekleme ve silme işlemleri,enqueue ve dequeue operasyonlar.

Kuyruklar, içerdikleri nesnelere rastgele erişime izin vermez.

FIFO prosedürü nasıl uygulanır?

Aşağıdaki program FIFO'nun uygulanmasına yardımcı olur -

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()

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

LIFO prosedürü nasıl uygulanır?

Aşağıdaki program LIFO prosedürünün uygulanmasına yardımcı olur -

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()

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Öncelik Sırası nedir?

Öncelik kuyruğu, belirtilen veri yapısındaki en küçük veya en büyük anahtarla kayda hızlı erişim sağlamak için sıralı anahtarlarla bir dizi kaydı yöneten bir kapsayıcı veri yapısıdır.

Öncelik kuyruğu nasıl uygulanır?

Öncelik kuyruğunun uygulanması aşağıdaki gibidir -

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

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

String serileştirme, bir nesnenin durumunu bir bayt akışına yazma işlemidir. Python'da, serileştirmeyi etkinleştirmek için "turşu" kitaplığı kullanılır. Bu modül, bir Python nesne yapısını serileştirmek ve serileştirmeyi kaldırmak için güçlü bir algoritma içerir. "Pickling", Python nesne hiyerarşisini bayt akışına dönüştürme işlemidir ve "çözme" ise tersi prosedürdür.

Turşu modülünün gösterimi aşağıdaki gibidir -

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)

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Eşzamanlılık genellikle paralellik olarak yanlış anlaşılır. Eşzamanlılık, bağımsız kodun sistematik bir şekilde yürütülebilmesi için zamanlamayı ifade eder. Bu bölüm, Python kullanan bir işletim sistemi için eşzamanlılığın yürütülmesine odaklanmaktadır.

Aşağıdaki program, bir işletim sistemi için eşzamanlılığın yürütülmesine yardımcı olur -

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)

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

Açıklama

"Çoklu işlem", diş açma modülüne benzer bir pakettir. Bu paket, yerel ve uzak eşzamanlılığı destekler. Bu modül sayesinde, programcılar verilen sistemde birden çok işlemi kullanma avantajına sahip olurlar.

Anti-kalıplar, önceden tanımlanmış tasarım modellerine karşı bir strateji izler. Strateji, resmileştirilebilecek ve genellikle iyi bir kalkınma uygulaması olarak düşünülebilecek ortak sorunlara yönelik ortak yaklaşımları içerir. Genellikle anti-paternler zıttır ve istenmez. Anti-kalıplar, yazılım geliştirmede kullanılan ve kötü programlama uygulamaları olarak kabul edilen belirli kalıplardır.

Anti-desenlerin önemli özellikleri

Şimdi anti-modellerin birkaç önemli özelliğini görelim.

Doğruluk

Bu modeller kodunuzu tam anlamıyla bozar ve yanlış şeyler yapmanıza neden olur. Aşağıdakiler bunun basit bir örneğidir -

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))

Sürdürülebilirlik

İhtiyaca göre anlaşılması ve değiştirilmesi kolaysa, programın sürdürülebileceği söylenir. Modülün içe aktarılması, bir bakım kolaylığı örneği olarak düşünülebilir.

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

Anti-desen örneği

Aşağıdaki örnek, anti-kalıpların gösterilmesine yardımcı olur -

#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

Açıklama

Örnek, Python'da bir işlev oluşturmak için iyi ve kötü standartların gösterimini içerir.

İstisnaların ele alınması da tasarım modellerinin birincil kriteridir. Bir istisna, bir programın yürütülmesi sırasında meydana gelen bir hatadır. Belirli bir hata oluştuğunda, bir istisna oluşturmak önemlidir. Bu, program çökmelerini engellemeye yardımcı olur.

Neden istisnalar kullanılıyor?

İstisnalar, bir programdaki hataları ve özel koşulları işlemenin uygun yollarıdır. Bir kullanıcı belirtilen kodun bir hata üretebileceğini düşündüğünde, istisna işlemeyi kullanmak önemlidir.

Örnek - Sıfıra bölme

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)

Çıktı

Yukarıdaki program aşağıdaki çıktıyı üretir -

İstisnaları Artırma

Özellikle Python programlamasında, çalışma zamanında karşılık gelen kod hatası oluştuğunda istisnalar ortaya çıkar. Bu, kullanılarak zorla yükseltilebilir“raise” anahtar kelime.

Sözdizimi

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