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