Uma uqala ukusebenza kumaphrojekthi amakhulu ePython, enye yezinto zokuqala oziqaphelayo ukuthi Ikhodi iba nzima ukuyiqonda, ukuyihlola, kanye nokuyelula. Uma ungalandeli imithetho embalwa eyisisekelo yokuklama. Yilapho-ke izimiso ezidumile ze-SOLID zingena khona: iqoqo lemikhuba emihle eyenzelwe ukwenza impilo yeqembu ibe lula kakhulu.
Lezi zimiso zaqala emkhakheni we- uhlelo oluqondiswe ezintweni zakudala (i-Java, i-C++, i-C#, njll.)Kodwa zihambisana kahle ne-Python uma nje usebenzisa amakilasi nezinto ngendlela engathi sína kakhulu. Ake sibheke ngokuningiliziwe ukuthi ziyini, zivelaphi, kungani zibalulekile, futhi, ngaphezu kwakho konke, kanjani Faka i-SOLID ngezibonelo ezicacile ku-Python ukwenza ikhodi yakho ihlale ihlelekile, ikhuliswe, futhi kube mnandi ukusebenza nayo.
Kuyini i-SOLID futhi konke kuvelaphi?
Leli gama I-SOLID isifinyezo esathandwa kakhulu yi-Michael Feathers ukuqoqa izimiso zokuklama ezinhlanu ezaphakanyiswa ekuqaleni nguRobert C. Martin, owaziwa kakhulu ngokuthi uMalume Bob. Lo njiniyela wesofthiwe waseMelika, omunye wabasayini be-Agile Manifesto, washicilela isihloko esithi "Izimiso ze-OOD" maphakathi nawo-90s kanye kamuva "Izimiso Zokuklama Namaphethini Okuklama," lapho abeka khona izisekelo eziningi zomklamo wanamuhla ogxile ezintweni.
Ngokuhamba kwesikhathi, abanye ababhali abafana UBarbara Liskov noBertrand Meyer Baphinde banikela ngemibono ehlanganiswe kulolu hlelo lwezimiso. UMichael Feathers wayenomqondo (ohlakaniphile kakhulu) wokuzihlela kabusha ukuze izinhlamvu zokuqala zakhe igama elithi SOLID, elabasiza ukuba basakazeke njengomlilo wasendle emphakathini othuthukayo.
Izinhlamvu ezinhlanu ze-SOLID zihambisana nalezi zimiso zokuklama eziqondiswe ezintweni, ezisebenza naku-Python:
- S - Isimiso Somthwalo Wemfanelo Oyedwa (Isimiso Somthwalo Wemfanelo Oyedwa)
- O - Isimiso Esivulekile/Esivaliwe (Isimiso Esivulekile/Esivaliwe)
- L – Isimiso Sokufaka Esikhundleni sikaLiskov (Isimiso Sokufaka Esikhundleni sikaLiskov)
- I - Isimiso Sokuhlukaniswa Kwesixhumi (Isimiso Sokuhlukaniswa Kwezixhumi)
- D - Isimiso Sokuguqulwa Kokuxhomekeka (Isimiso Sokuguqulwa Kokuxhomekeka)
Umqondo ojwayelekile uwukuthi lezi zimiso ezinhlanu, ezisetshenziswa ndawonye, Bakusiza ukuthi ubhale isofthiwe eguquguqukayo, elula ukuyihlola, futhi enakekelwayoLokhu kuholela ekusetshenzisweni okusheshayo, ukuncipha kwamaphutha ayimfihlakalo, ukusetshenziswa kabusha kwekhodi okungcono, kanye nokuncipha kwamakhanda lapho iphrojekthi isikhiqize iminyaka embalwa.
Yiziphi izimiso ze-SOLID ezisetshenziswa ku-Python?
Ukusebenzisa izimiso ze-SOLID ku-Python akuyona nje umsebenzi wezemfundo; kunomthelela oqondile emsebenzini wansuku zonke weqembu. Uma ulandela lezi zimiso, Zinciphisa ikhodi ye-spaghetti, zinciphise iphunga lekhodi, futhi zivimbele i-codebase yakho ukuthi "inganuki ukubola."kusetshenziswa isifaniso esidumile, “uma kunuka kabi, kukhona okuklanywe kabi.” Ku-Windows, abathuthukisi abaningi bakhetha ukwenza kanjalo Faka futhi ulungiselele i-WSL2 ukuze kube nendawo ye-Linux eseduze nokukhiqizwa.
Ezindaweni zokubambisana (amaqembu okuthuthukisa i-backend, ubunjiniyela bedatha, imikhiqizo enemijikelezo emide, njll.) lezi zimiso ziyisihluthulelo sokwenza Abantu abaningi bangasebenza ku-codebase efanayo ngaphandle kokweqa imingcele yabo noma ukwephula yonke into ngokuthinta okuncane.Ngaphezu kwalokho, i-Python, yize iguquguquka futhi inamandla, ivumela ukusetshenziswa okungenamthungo kwezifinyezo ezijwayelekile ze-OOP: amakilasi angabonakali, amazinga efa, ukwakheka, kanye nezixhumi ngokusebenzisa abc, Njll
Ngamafuphi, i-SOLID ikusiza ukufeza:
- Ikhodi ehlanzekile, efundeka kalulangisho nangemva kweminyaka eminingi ngiyibhalile.
- Ukuhlolwa okuthuthukisiwengoba imithwalo yemfanelo ihlukaniswe ngokusobala.
- Ukuphinda kusetshenziswe futhi kukhule kakhulu ngenxa yokuxhomekeka okuncane okuqinile phakathi kwamamojula.
- Amaphutha ambalwa okuqinisekisaUma ushintsha okuthile kumojuli eyodwa, awuphuli ngengozi ezinye izinto ezinhlanu.
S - Isimiso Somthwalo Wemfanelo Oyedwa
Isimiso sokuqala sithi Ikilasi kufanele libe nesizathu esisodwa sokushintsha.Ngamanye amazwi, kumele ithathe umthwalo wemfanelo owodwa, ochazwe kahle. Lokhu akusho ukuthi kufanele ibe nendlela eyodwa kuphela, kodwa kunalokho yonke imicabango yayo kufanele ibhekisele enhlosweni eyodwa, ehambisanayo.
Cabanga ngekilasi le-Python elimele umsebenzisi futhi, ngaphezu kokugcina idatha yakhe, liphinde liphathe ukufinyelela kusizindalwazi nokukhiqiza imibiko:
class User:
def __init__(self, name: str):
self.name = name
def get_user_from_database(self, user_id: int) -> dict:
# Recupera datos desde la base de datos
# ...
pass
def save_user_to_database(self) -> None:
# Persiste el usuario en la base de datos
# ...
pass
def generate_user_report(self) -> str:
# Genera un informe del usuario
# ...
passNasi ikilasi ihlanganisa imithwalo yemfanelo emithathu ehlukeneUkumela umsebenzisi, ukuphatha ukuphikelela, kanye nokwakha imibiko. Izinguquko kusizindalwazi, ifomethi yombiko, noma izimfanelo zomsebenzisi zidinga ukuguqulwa kwesigaba esifanayo, okwandisa ingozi yokwethula iziphazamiso ezihlanganisayo.
Uma sihlukanisa lezi zinkinga, umklamo uthuthuka kakhulu:
class User:
def __init__(self, name: str):
self.name = name
class UserDB:
@staticmethod
def get_user(user_id: int) -> User:
# Lógica para obtener usuarios de la base de datos
# ...
return User("John Doe")
@staticmethod
def save_user(user: User) -> None:
# Lógica para guardar el usuario
# ...
pass
class UserReportGenerator:
@staticmethod
def generate_report(user: User) -> str:
# Lógica para generar informes de usuario
# ...
return f"Report for user: {user.name}"Manje ikilasi Umsebenzisi umelela umsebenzisi njengenhlangano kuphelaUma indlela imibiko ekhiqizwa ngayo izinguquko, vele uthephe UserReportGeneratorUma ushintsha isizindalwazi, umane uthinte UserDBIkilasi ngalinye linesizathu esisodwa sokushintsha, okwenza kube lula ukulungisa amaphutha kanye nokuvela kwesistimu.
I-SRP isetshenziswe esibonelweni esingokoqobo: amadada nokuxhumana
Ake sibheke isimo esijwayelekile esilungisiwe: ikilasi Idada Ekuqaleni, imithwalo yemfanelo yenezelwa kancane kancane kuze kube yilapho iba yisilo esinzima ukusinakekela. Cabanga ngokusetshenziswa okungenalwazi:
class Duck:
def __init__(self, name: str):
self.name = name
def fly(self) -> None:
print(f"{self.name} is flying not very high")
def swim(self) -> None:
print(f"{self.name} swims in the lake and quacks")
def do_sound(self) -> str:
return "Quack"
def greet(self, other_duck: "Duck") -> None:
print(f"{self.name}: {self.do_sound()}, hello {other_duck.name}")Ikilasi Kufanele ichazwe kalula ngokuthi “idada”Kodwa futhi ilawula indlela abaxhumana ngayo. Uma kusasa ushintsha umqondo wengxoxo (imishwana eminingi, ezinye izilimi, iziteshi ezahlukene), kufanele ushintshe ikilasi ledada, elivele lisebenza kahle njengenhlangano.
Isixazululo esihlonipha i-SRP ukukhipha lowo mthwalo wemfanelo wesibili kwelinye ikilasi eligxile kwezokuxhumana:
class Duck:
def __init__(self, name: str):
self.name = name
def fly(self) -> None:
print(f"{self.name} is flying not very high")
def swim(self) -> None:
print(f"{self.name} swims in the lake and quacks")
def do_sound(self) -> str:
return "Quack"
class Communicator:
def __init__(self, channel: str):
self.channel = channel
def communicate(self, duck1: Duck, duck2: Duck) -> None:
sentence1 = f"{duck1.name}: {duck1.do_sound()}, hello {duck2.name}"
sentence2 = f"{duck2.name}: {duck2.do_sound()}, hello {duck1.name}"
conversation =
print(*conversation, f"(via {self.channel})", sep="\n")Ngenxa yalokhu kuhlukana, Ungathuthukisa indlela yokuxhumana ngaphandle kokuthinta incazelo yedadaNgaphezu kwalokho, ikhodi kulula ukuyihlola: uhlola ukuziphatha kwe Duck futhi ngakolunye uhlangothi, lowo we Communicatorngaphandle kokuxuba imithwalo yemfanelo.
O - Isimiso Esivulekile/Esivaliwe
Umgomo we-OCP uthi Izinhlangano zesofthiwe kufanele zivulekele ukwandisa ukuziphatha kwazo, kodwa zivaliwe ekuguqulweni okuqondile.Ngamanye amazwi, uma ufuna ukwengeza ukusebenza okusha, kungcono ukuthi ungadingi ukubhala kabusha amakilasi asevele esebenza futhi asetshenziswa amanye amamojula.
Isibonelo esivamile ukubala izindawo zezibalo zejiyometri. Ake siqale sibheke inguqulo ayihloniphi i-OCP:
class Rectangle:
def __init__(self, width: float, height: float):
self.width = width
self.height = height
class Circle:
def __init__(self, radius: float):
self.radius = radius
class AreaCalculator:
def calculate_area(self, shape) -> float:
if isinstance(shape, Rectangle):
return shape.width * shape.height
elif isinstance(shape, Circle):
return 3.14159 * shape.radius * shape.radius
else:
raise ValueError("Forma no soportada")Uma ufuna ukwengeza unxantathu kusasa, uzophoqeleka ukuthi shintsha ikhodi ye AreaCalculatorukwengeza okunye elifLokhu kwephula i-OCP, ngoba ikilasi "alisavaliwe" ezinguqukweni.
Inguqulo efanele ihilela ukwethula isifinyezo Shape ngendlela area() okuyinto umuntu ngamunye ayifezayo ngendlela yakhe:
from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def area(self) -> float:
pass
class Rectangle(Shape):
def __init__(self, width: float, height: float):
self.width = width
self.height = height
def area(self) -> float:
return self.width * self.height
class Circle(Shape):
def __init__(self, radius: float):
self.radius = radius
def area(self) -> float:
return 3.14159 * self.radius * self.radius
class AreaCalculator:
def calculate_area(self, shape: Shape) -> float:
return shape.area()Ngenxa yalo mklamo, engeza unxantathu ongawuthinti AreaCalculatorUmane udale iklasi elincane elisha:
class Triangle(Shape):
def __init__(self, base: float, height: float):
self.base = base
self.height = height
def area(self) -> float:
return 0.5 * self.base * self.heightUmgomo we-Open/Closed uhambisana kahle nomqondo wokuthi chaza amaphuzu acacile okwelulwa ngokusebenzisa izifinyezo: izinkundla zokuxhumana, amakilasi angaqondakali, izingwegwe, njll. Ku-Python, imodyuli abc Ikuvumela ukuthi uveze lokhu ngokucacile, noma ngabe ulimi lushintshashintsha.
I-OCP isetshenziswa esibonelweni sokuxhumana
Uma sibuyela esibonelweni sika Oxhumana nayeSingathatha isinyathelo esengeziwe futhi silungiselele umklamo ukuze usekele izinhlobo ezahlukene zezingxoxo ngaphandle kokubhala kabusha i-communicator isikhathi ngasinye. Ukuze senze lokhu, sichaza isifinyezo sengxoxo bese sivumela i-communicator ukuthi isebenzise yona kuphela:
from typing import final
from abc import ABC, abstractmethod
class AbstractConversation(ABC):
@abstractmethod
def do_conversation(self) -> list:
pass
class SimpleConversation(AbstractConversation):
def __init__(self, duck1: Duck, duck2: Duck):
self.duck1 = duck1
self.duck2 = duck2
def do_conversation(self) -> list:
sentence1 = f"{self.duck1.name}: {self.duck1.do_sound()}, hello {self.duck2.name}"
sentence2 = f"{self.duck2.name}: {self.duck2.do_sound()}, hello {self.duck1.name}"
return
class Communicator:
def __init__(self, channel: str):
self.channel = channel
@final
def communicate(self, conversation: AbstractConversation) -> None:
print(*conversation.do_conversation(), f"(via {self.channel})", sep="\n")Kule nguqulo, Uma ufuna ukwengeza indlela entsha yokukhuluma (isibonelo, ingxoxo enolaka, ingxoxo ethatha ithuba, njll.), umane udala elinye iqembu elincane AbstractConversation. Indlela communicate() de Communicator Akushintshi, kuhambisana ne-OCP njengoba kuchaziwe.
L – Isimiso Sokufaka Esikhundleni sikaLiskov
Isimiso Sokufaka Esisekelweni sikaLiskov, esakhiwe nguBarbara Liskov, sithi Ama-subclass kufanele akwazi ukufaka esikhundleni ama-base class awo ngaphandle kokushintsha indlela okulindeleke ngayo uhlelo.Empeleni, lokhu kusho ukuthi uma ikhodi isebenza ngesibonelo esisodwa sekilasi eliyisisekelo, kufanele isebenze kahle nanoma yisiphi isibonelo sekilasi elincane.
Isibonelo esijwayelekile sokwephulwa kwe-LSP ukwenza amamodeli kuzo zonke izinyoni ngendlela eyodwa fly()kufaka phakathi izintshe:
class Bird:
def fly(self) -> None:
pass
class Duck(Bird):
def fly(self) -> None:
print("¡El pato está volando!")
class Ostrich(Bird):
def fly(self) -> None:
# Las avestruces no vuelan
raise NotImplementedError("Las avestruces no pueden volar")Noma iyiphi ikhodi ecabanga ukuthi Yonke inyoni ekwazi ukundiza izohluleka uma ithola intshe. Lokho kusho, Ostrich Akuyona into efanelekile esikhundleni salokho Bird, ngaleyo ndlela kwephulwa i-LSP.
Isixazululo ukulungisa uhlu lwezigaba ukuze lubonise kangcono iqiniso: akuzona zonke izinyoni ezindizayo, ngakho-ke Ingxenye eyodwa kuphela yezinyoni okufanele ibe nendlela fly():
class Bird:
pass
class FlyingBird(Bird):
def fly(self) -> None:
pass
class Duck(FlyingBird):
def fly(self) -> None:
print("¡El pato está volando!")
class Ostrich(Bird):
# No vuela, así que no implementa fly()
passNgalo mklamo, Noma yimuphi umsebenzi odinga inyoni endizayo uzosho ukuthi uyawudinga. FlyingBirdfuthi ngeke ithole intshe. Ngale ndlela, i-LSP iyahlonishwa futhi okuhlukile kwesikhathi sokusebenza okungalindelekile kuyagwenywa.
Izingxoxo ze-LSP nezinyoni
Uma sibuyela esibonelweni sezingxoxo, kuvamile ukuqala ukubhala ikhodi ucabanga ngamadada kuphela bese ufuna ukwengeza amagwababa noma ezinye izinyoni. Uma ikilasi lengxoxo lincike ku Duck, Ngeke ukwazi ukuyisebenzisa kabusha nezinye izinhlobo zezinyoni ngaphandle kokuthinta ikhodi:
class Crow:
# Implementación específica del cuervo
...Si SimpleConversation Ibhalwe ngezinhlobo zamadada kuphela; awukwazi nje ukudlulisa igwababa ngaphandle kokulishintsha. Indlela efanele ukudala isifinyezo esivamile. Bird futhi wenze ingxoxo incike kulokho okucashuniwe:
from abc import ABC, abstractmethod
class Bird(ABC):
def __init__(self, name: str):
self.name = name
@abstractmethod
def do_sound(self) -> str:
pass
class Crow(Bird):
def do_sound(self) -> str:
return "Caw"
class Duck(Bird):
def do_sound(self) -> str:
return "Quack"
class SimpleConversation(AbstractConversation):
def __init__(self, bird1: Bird, bird2: Bird):
self.bird1 = bird1
self.bird2 = bird2
def do_conversation(self) -> list:
sentence1 = f"{self.bird1.name}: {self.bird1.do_sound()}, hello {self.bird2.name}"
sentence2 = f"{self.bird2.name}: {self.bird2.do_sound()}, hello {self.bird1.name}"
return Ngale ndlela, noma yiliphi iqembu elincane Bird ohlonipha inkontileka (do_sound()(igama, njll.) kuyinto esikhundleni esivumelekile futhi ngeke kuphule ukuziphatha okulindelekile kwe SimpleConversation.
I - Isimiso Sokuhlukaniswa Kwesixhumi
Umgomo we-ISP uthi Akukho khasimende okufanele liphoqwe ukuthi lithembele ezindleleni elingazisebenzisi.Kuhunyushwe kwaba amakilasi noma ama-interface angaqondakali, lokhu kusho ukuthi kungcono ukuba nama-interface amaningana amancane, athile kune-interface eyodwa enkulu, ejwayelekile.
Qaphela lo mklamo lapho isikhombimsebenzisi Worker Kudinga ukuthi bonke labo abakusebenzisayo babe nezindlela ezithile zokusebenza kanye nokudla:
from abc import ABC, abstractmethod
class Worker(ABC):
@abstractmethod
def work(self) -> None:
pass
@abstractmethod
def eat(self) -> None:
pass
class Human(Worker):
def work(self) -> None:
print("El humano está trabajando")
def eat(self) -> None:
print("El humano está comiendo")
class Robot(Worker):
def work(self) -> None:
print("El robot está trabajando")
def eat(self) -> None:
# El robot no come, pero está obligado a declarar este método
passIkilasi Irobhothi lithembele endleleni ethile eat() lokho akudingiNoma yiluphi ushintsho oluhlobene nokudla luzothinta irobhothi, noma ngabe aluhlobene nalokho kuziphatha.
Ngokusebenzisa i-ISP, sihlukanise i-interface ibe yizimbili ezincane nezicacile:
class Workable(ABC):
@abstractmethod
def work(self) -> None:
pass
class Eatable(ABC):
@abstractmethod
def eat(self) -> None:
pass
class Human(Workable, Eatable):
def work(self) -> None:
print("El humano está trabajando")
def eat(self) -> None:
print("El humano está comiendo")
class Robot(Workable):
def work(self) -> None:
print("El robot está trabajando")Manje, Ikilasi ngalinye lisebenzisa kuphela izindlela elizidingayo ngempela.Lokhu kunciphisa ukuhlanganiswa, kwenza kube lula ukuvela komklamo, futhi kwenza ikhodi izwakale kakhudlwana: kuba sobala kakhulu ukuthi ubani ongenzani.
I-ISP ekubunjweni kwezinyoni: ukundiza nokubhukuda
Kwenzeka okufanayo lapho kwenziwa amamodeli ezinyoni ezindizayo futhi zibhukuda. Uma ukucashunwa okuyisisekelo Bird Kudinga ukusebenzisa kokubili fly() njengoba swim()Uzogcina unezifundo ezifana Crow okumele benze sengathi bayakwazi ukubhukuda:
class Bird(ABC):
def __init__(self, name: str):
self.name = name
@abstractmethod
def fly(self) -> None:
pass
@abstractmethod
def swim(self) -> None:
pass
@abstractmethod
def do_sound(self) -> str:
passIsixazululo ngokusho kwe-ISP yilesi hlukanisa isikhombikubona sibe amakhono athile kakhulu:
class Bird(ABC):
def __init__(self, name: str):
self.name = name
@abstractmethod
def do_sound(self) -> str:
pass
class FlyingBird(Bird):
@abstractmethod
def fly(self) -> None:
pass
class SwimmingBird(Bird):
@abstractmethod
def swim(self) -> None:
pass
class Crow(FlyingBird):
def fly(self) -> None:
print(f"{self.name} is flying high and fast!")
def do_sound(self) -> str:
return "Caw"
class Duck(SwimmingBird, FlyingBird):
def fly(self) -> None:
print(f"{self.name} is flying not very high")
def swim(self) -> None:
print(f"{self.name} swims in the lake and quacks")
def do_sound(self) -> str:
return "Quack"Uma uke wanquma ukwenza imodeli yephenguin, mane nje umenza azuze ifa SwimmingBird kepha hhayi kusuka FlyingBirdFuthi ngeke kudingeke usebenzise izindlela ezingenalutho noma ulahle okuhlukile kokwenziwa.
D - Isimiso Sokuguqulwa Kokuxhomekeka
Isimiso sokugcina, i-DIP, singafingqwa ngemibono emibili eyinhloko: Amamojula asezingeni eliphezulu akufanele ancike kumamojula asezingeni eliphansi; womabili kufanele ancike ezintweni ezifinyeziwe.Futhi izifinyezo akufanele zincike emininingwaneni, kodwa kunalokho imininingwane kufanele incike ezifinyezweni.
Empeleni, lokhu kusho ukuthi i-logic yebhizinisi lakho akufanele ixhunywe emininingwaneni ethile efana nokuthi "Ngisebenzisa i-MySQL," "Ngibhalela ifayela lendawo," noma "Ngithumela imiyalezo ye-SMS nalo mhlinzeki." Esikhundleni salokho, uchaza izixhumi ezingabonakali (ngokwesibonelo, Database, Channel, NotificationService) futhi wenza ikhodi yakho yezinga eliphezulu ikhulume nabo kuphela.
Umklamo ukuthi phula i-DIP Lokhu kungaba yindawo yokugcina yomsebenzisi efaka ngqo i-database ye-MySQL:
class MySQLDatabase:
def connect(self) -> None:
# Conectar a MySQL
pass
def query(self, sql: str) -> list:
# Ejecutar consulta
return []
class UserRepository:
def __init__(self) -> None:
self.database = MySQLDatabase() # Dependencia directa
def get_users(self) -> list:
return self.database.query("SELECT * FROM users")Uma unquma ukusebenzisa i-PostgreSQL kusasa, kufanele shintsha ikilasi lezinga eliphezulu UserRepositoryUxhumene nemininingwane ethile yokusetshenziswa.
Ngokusebenzisa i-DIP, siqala ngokuchaza ukuhlukaniswa kwedatha bese sithola ukuqaliswa kokhonkolo okuvela kukho:
from abc import ABC, abstractmethod
class Database(ABC):
@abstractmethod
def connect(self) -> None:
pass
@abstractmethod
def query(self, sql: str) -> list:
pass
class MySQLDatabase(Database):
def connect(self) -> None:
# Conexión a MySQL
pass
def query(self, sql: str) -> list:
# Consulta en MySQL
return []
class PostgreSQLDatabase(Database):
def connect(self) -> None:
# Conexión a PostgreSQL
pass
def query(self, sql: str) -> list:
# Consulta en PostgreSQL
return []
class UserRepository:
def __init__(self, database: Database) -> None:
self.database = database # Depende de una abstracción
def get_users(self) -> list:
return self.database.query("SELECT * FROM users")Ngale ndlela, Ungafaka noma yikuphi ukusetshenziswa kwe Database lapho udala indawo yokugcina, ngaphandle kokuthinta ikhodi yayo yangaphakathi:
mysql_db = MySQLDatabase()
user_repo = UserRepository(mysql_db)
postgres_db = PostgreSQLDatabase()
user_repo = UserRepository(postgres_db)Le ndlela yaziwa ngokuthi Umjovo Wokuncika Futhi kuyindlela evame kakhulu yokusebenzisa i-DIP: amakilasi awadali ukuncika kwawo, kodwa athola kusuka ngaphandle (ngomakhi noma ngezindlela ezithile), esebenzisa njalo izifinyezo njengohlobo.
I-DIP isetshenziswa eziteshini nakubaxhumanisi
Esibonelweni sezingxoxo zezinyoni, singathuthukisa nokuphathwa kweziteshi ngokusebenzisa i-DIP. Ake sithi uchaza isifinyezo esisodwa sesiteshi kanye nesinye sesikhulumi:
class AbstractChannel(ABC):
@abstractmethod
def get_channel_message(self) -> str:
pass
class AbstractCommunicator(ABC):
@abstractmethod
def get_channel(self) -> AbstractChannel:
pass
@final
def communicate(self, conversation: AbstractConversation) -> None:
print(*conversation.do_conversation(),
self.get_channel().get_channel_message(),
sep="\n")Ukuqaliswa kokuqala, okungenalwazi kungaba:
class SMSChannel(AbstractChannel):
def get_channel_message(self) -> str:
return "(via SMS)"
class SMSCommunicator(AbstractCommunicator):
def __init__(self) -> None:
self._channel = SMSChannel() # Depende de detalle concreto
def get_channel(self) -> AbstractChannel:
return self._channelNakuba kubonakala kulungile, Lo mxhumanisi usaxhunyaniswe ngqo SMSChannelSithuthukise umklamo ngokuba ne-communicator ithole isiteshi sivela ngaphandle (ukufakwa kokuthembela), ngakho-ke sincike kuphela ekususeni:
class SimpleCommunicator(AbstractCommunicator):
def __init__(self, channel: AbstractChannel) -> None:
self._channel = channel
def get_channel(self) -> AbstractChannel:
return self._channelNgale ndlela, noma yisiphi isiteshi esisha (i-imeyili, izaziso ze-push, njll.) siyasetshenziswa AbstractChannel y Ingasetshenziswa ngaphandle kokushintsha ikhodi yokuxhumana.Futhi, amakilasi asezingeni eliphezulu ancike ezintweni ezifingqiwe, hhayi emininingwaneni.
Kwenzekani uma ungayinaki i-SOLID?
Uma lezi zimiso zinganakwa, ikhodi ivame ukuhlushwa yizinkinga ezifana nokuthi iphunga lekhodi, ukubola kwekhodi, kanye nokuhlanganiswa okungenakwenzeka ukukuqaqaOkusho ukuthi, izigaba ezinkulu ezinemithwalo yemfanelo eyinkulungwane, izigaba ezincane eziphula izinkontileka, ukuncika okuphindaphindiwe, kanye nezindlela ezishintsha nsuku zonke ngoba zenza izinto eziningi kakhulu.
Imiphumela icacile futhi ibuhlungu kakhulu kunoma yiliphi iqembu: Ubuthakathaka obengeziwe, amaphutha amaningi, ukuvuselelwa njalo, futhi, esimweni esibi kakhulu, ikhodi egcina ingasetshenziswa.Yilokho okuvame ukubizwa ngokuthi "ikhodi yespaghetti": kunzima ukukulandela, kugcwele ama-patches, futhi cishe akunakwenzeka ukuwelula ngaphandle kokuphula into ebalulekile.
Izimiso ze-SOLID azikabekwa phansi, futhi akusizi ngaso sonke isikhathi ukuzisebenzisa ngokuqinile, ikakhulukazi ekwenzeni ama-prototyping ngokushesha noma kumaphrojekthi amancane kakhulu. Noma kunjalo, Zikhumbule futhi uzisebenzise ekwakhiweni kwakho okuningi okugxile ezintweni ku-Python. Kwenza umehluko phakathi kwephrojekthi ekhula ngokuhamba kwesikhathi kanye nephrojekthi ewohlokayo ngokushesha nje lapho ikhula kancane.
