- Notifications
You must be signed in to change notification settings - Fork0
🛁 Clean Code concepts adapted for Python
License
Illuminater1/clean-code-python
Folders and files
| Name | Name | Last commit message | Last commit date | |
|---|---|---|---|---|
Repository files navigation
Software engineering principles, from Robert C. Martin's bookCleanCode, adapted for Python. This is not a style guide. It's a guide to producingreadable, reusable, and refactorable software in Python.
Not every principle herein has to be strictly followed, and even fewer will beuniversally agreed upon. These are guidelines and nothing more, but they areones codified over many years of collective experience by the authors ofCleanCode.
Adaptedfromclean-code-javascript
Targets Python3.7+
Bad:
importdatetimeymdstr=datetime.date.today().strftime("%y-%m-%d")
Additionally, there's no need to add the type of the variable (str) to itsname.
Good:
importdatetimecurrent_date:str=datetime.date.today().strftime("%y-%m-%d")
Bad:Here we use three different names for the same underlying entity:
defget_user_info():passdefget_client_data():passdefget_customer_record():pass
Good:If the entity is the same, you should be consistent in referring to it in yourfunctions:
defget_user_info():passdefget_user_data():passdefget_user_record():pass
Even betterPython is (also) an object oriented programming language. If it makes sense,package the functions together with the concrete implementation of the entityin your code, as instance attributes, property methods, or methods:
fromtypingimportUnion,DictclassRecord:passclassUser:info:str@propertydefdata(self)->Dict[str,str]:return {}defget_record(self)->Union[Record,None]:returnRecord()
We will read more code than we will ever write. It's important that the code wedo write is readable and searchable. Bynot naming variables that end upbeing meaningful for understanding our program, we hurt our readers. Make yournames searchable.
Bad:
importtime# What is the number 86400 for again?time.sleep(86400)
Good:
importtime# Declare them in the global namespace for the module.SECONDS_IN_A_DAY=60*60*24time.sleep(SECONDS_IN_A_DAY)
Bad:
importreaddress="One Infinite Loop, Cupertino 95014"city_zip_code_regex=r"^[^,\\]+[,\\\s]+(.+?)\s*(\d{5})?$"matches=re.match(city_zip_code_regex,address)ifmatches:print(f"{matches[1]}:{matches[2]}")
Not bad:
It's better, but we are still heavily dependent on regex.
importreaddress="One Infinite Loop, Cupertino 95014"city_zip_code_regex=r"^[^,\\]+[,\\\s]+(.+?)\s*(\d{5})?$"matches=re.match(city_zip_code_regex,address)ifmatches:city,zip_code=matches.groups()print(f"{city}:{zip_code}")
Good:
Decrease dependence on regex by naming subpatterns.
importreaddress="One Infinite Loop, Cupertino 95014"city_zip_code_regex=r"^[^,\\]+[,\\\s]+(?P<city>.+?)\s*(?P<zip_code>\d{5})?$"matches=re.match(city_zip_code_regex,address)ifmatches:print(f"{matches['city']},{matches['zip_code']}")
Don’t force the reader of your code to translate what the variable means.Explicit is better than implicit.
Bad:
seq= ("Austin","New York","San Francisco")foriteminseq:# do_stuff()# do_some_other_stuff()# Wait, what's `item` again?print(item)
Good:
locations= ("Austin","New York","San Francisco")forlocationinlocations:# do_stuff()# do_some_other_stuff()# ...print(location)
If your class/object name tells you something, don't repeat that in yourvariable name.
Bad:
classCar:car_make:strcar_model:strcar_color:str
Good:
classCar:make:strmodel:strcolor:str
Tricky
Why write:
importhashlibdefcreate_micro_brewery(name):name="Hipster Brew Co."ifnameisNoneelsenameslug=hashlib.sha1(name.encode()).hexdigest()# etc.
... when you can specify a default argument instead? This also makes it clearthat you are expecting a string as the argument.
Good:
importhashlibdefcreate_micro_brewery(name:str="Hipster Brew Co."):slug=hashlib.sha1(name.encode()).hexdigest()# etc.
This is by far the most important rule in software engineering. When functionsdo more than one thing, they are harder to compose, test, and reason about.When you can isolate a function to just one action, they can be refactoredeasily and your code will read much cleaner. If you take nothing else away fromthis guide other than this, you'll be ahead of many developers.
Bad:
fromtypingimportListclassClient:active:booldefemail(client:Client)->None:passdefemail_clients(clients:List[Client])->None:"""Filter active clients and send them an email. """forclientinclients:ifclient.active:email(client)
Good:
fromtypingimportListclassClient:active:booldefemail(client:Client)->None:passdefget_active_clients(clients:List[Client])->List[Client]:"""Filter active clients. """return [clientforclientinclientsifclient.active]defemail_clients(clients:List[Client])->None:"""Send an email to a given list of clients. """forclientinget_active_clients(clients):email(client)
Do you see an opportunity for using generators now?
Even better
fromtypingimportGenerator,IteratorclassClient:active:booldefemail(client:Client):passdefactive_clients(clients:Iterator[Client])->Generator[Client,None,None]:"""Only active clients"""return (clientforclientinclientsifclient.active)defemail_client(clients:Iterator[Client])->None:"""Send an email to a given list of clients. """forclientinactive_clients(clients):email(client)
A large amount of parameters is usually the sign that a function isdoing too much (has more than one responsibility). Try to decompose itinto smaller functions having a reduced set of parameters, ideally less thanthree.
If the function has a single responsibility, consider if you can bundlesome or all parameters into a specialized object that will be passed as anargument to the function. These parameters might be attributes of a singleentity that you can represent with a dedicated data structure. You may alsobe able to reuse this entity elsewhere in your program. The reason why this isa better arrangement is than having multiple parameters is that we may be ableto move some computations, done with those parameters inside thefunction, into methods belonging to the new object, therefore reducing thecomplexity of the function.
Bad:
defcreate_menu(title,body,button_text,cancellable):pass
Java-esque:
classMenu:def__init__(self,config:dict):self.title=config["title"]self.body=config["body"]# ...menu=Menu( {"title":"My Menu","body":"Something about my menu","button_text":"OK","cancellable":False })
Also good
classMenuConfig:"""A configuration for the Menu. Attributes: title: The title of the Menu. body: The body of the Menu. button_text: The text for the button label. cancellable: Can it be cancelled? """title:strbody:strbutton_text:strcancellable:bool=Falsedefcreate_menu(config:MenuConfig)->None:title=config.titlebody=config.body# ...config=MenuConfig()config.title="My delicious menu"config.body="A description of the various items on the menu"config.button_text="Order now!"# The instance attribute overrides the default class attribute.config.cancellable=Truecreate_menu(config)
Fancy
fromtypingimportNamedTupleclassMenuConfig(NamedTuple):"""A configuration for the Menu. Attributes: title: The title of the Menu. body: The body of the Menu. button_text: The text for the button label. cancellable: Can it be cancelled? """title:strbody:strbutton_text:strcancellable:bool=Falsedefcreate_menu(config:MenuConfig):title,body,button_text,cancellable=config# ...create_menu(MenuConfig(title="My delicious menu",body="A description of the various items on the menu",button_text="Order now!" ))
Even fancier
fromdataclassesimportastuple,dataclass@dataclassclassMenuConfig:"""A configuration for the Menu. Attributes: title: The title of the Menu. body: The body of the Menu. button_text: The text for the button label. cancellable: Can it be cancelled? """title:strbody:strbutton_text:strcancellable:bool=Falsedefcreate_menu(config:MenuConfig):title,body,button_text,cancellable=astuple(config)# ...create_menu(MenuConfig(title="My delicious menu",body="A description of the various items on the menu",button_text="Order now!" ))
Even fancier, Python3.8+ only
fromtypingimportTypedDictclassMenuConfig(TypedDict):"""A configuration for the Menu. Attributes: title: The title of the Menu. body: The body of the Menu. button_text: The text for the button label. cancellable: Can it be cancelled? """title:strbody:strbutton_text:strcancellable:booldefcreate_menu(config:MenuConfig):title=config["title"]# ...create_menu(# You need to supply all the parametersMenuConfig(title="My delicious menu",body="A description of the various items on the menu",button_text="Order now!",cancellable=True ))
Bad:
classEmail:defhandle(self)->None:passmessage=Email()# What is this supposed to do again?message.handle()
Good:
classEmail:defsend(self)->None:"""Send this message"""message=Email()message.send()
When you have more than one level of abstraction, your function is usuallydoing too much. Splitting up functions leads to reusability and easier testing.
Bad:
# type: ignoredefparse_better_js_alternative(code:str)->None:regexes= [# ... ]statements=code.split('\n')tokens= []forregexinregexes:forstatementinstatements:passast= []fortokenintokens:passfornodeinast:pass
Good:
fromtypingimportTuple,List,DictREGEXES:Tuple= (# ...)defparse_better_js_alternative(code:str)->None:tokens:List=tokenize(code)syntax_tree:List=parse(tokens)fornodeinsyntax_tree:passdeftokenize(code:str)->List:statements=code.split()tokens:List[Dict]= []forregexinREGEXES:forstatementinstatements:passreturntokensdefparse(tokens:List)->List:syntax_tree:List[Dict]= []fortokenintokens:passreturnsyntax_tree
Flags tell your user that this function does more than one thing. Functionsshould do one thing. Split your functions if they are following different codepaths based on a boolean.
Bad:
fromtempfileimportgettempdirfrompathlibimportPathdefcreate_file(name:str,temp:bool)->None:iftemp: (Path(gettempdir())/name).touch()else:Path(name).touch()
Good:
fromtempfileimportgettempdirfrompathlibimportPathdefcreate_file(name:str)->None:Path(name).touch()defcreate_temp_file(name:str)->None: (Path(gettempdir())/name).touch()
A function produces a side effect if it does anything other than take a valuein and return another value or values. For example, a side effect could bewriting to a file, modifying some global variable, or accidentally wiring allyour money to a stranger.
Now, you do need to have side effects in a program on occasion - for example,like in the previous example, you might need to write to a file. In thesecases, you should centralize and indicate where you are incorporating sideeffects. Don't have several functions and classes that write to a particularfile - rather, have one(and only one) service that does it.
The main point is to avoid common pitfalls like sharing state between objectswithout any structure, using mutable data types that can be written to byanything, or using an instance of a class, and not centralizing where your sideeffects occur. If you can do this, you will be happier than the vast majorityof other programmers.
Bad:
# type: ignore# This is a module-level name.# It's good practice to define these as immutable values, such as a string.# However...fullname="Ryan McDermott"defsplit_into_first_and_last_name()->None:# The use of the global keyword here is changing the meaning of the# the following line. This function is now mutating the module-level# state and introducing a side-effect!globalfullnamefullname=fullname.split()split_into_first_and_last_name()# MyPy will spot the problem, complaining about 'Incompatible types in# assignment: (expression has type "List[str]", variable has type "str")'print(fullname)# ["Ryan", "McDermott"]# OK. It worked the first time, but what will happen if we call the# function again?
Good:
fromtypingimportList,AnyStrdefsplit_into_first_and_last_name(name:AnyStr)->List[AnyStr]:returnname.split()fullname="Ryan McDermott"name,surname=split_into_first_and_last_name(fullname)print(name,surname)# => Ryan McDermott
Also good
fromdataclassesimportdataclass@dataclassclassPerson:name:str@propertydefname_as_first_and_last(self)->list:returnself.name.split()# The reason why we create instances of classes is to manage state!person=Person("Ryan McDermott")print(person.name)# => "Ryan McDermott"print(person.name_as_first_and_last)# => ["Ryan", "McDermott"]
Robert C. Martin writes:
A class should have only one reason to change.
"Reasons to change" are, in essence, the responsibilities managed by a class orfunction.
In the following example, we create an HTML element that represents a commentwith the version of the document:
Bad
fromimportlibimportmetadataclassVersionCommentElement:"""An element that renders an HTML comment with the program's version number """defget_version(self)->str:"""Get the package version"""returnmetadata.version("pip")defrender(self)->None:print(f'<!-- Version:{self.get_version()} -->')VersionCommentElement().render()
This class has two responsibilities:
- Retrieve the version number of the Python package
- Render itself as an HTML element
Any change to one or the other carries the risk of impacting the other.
We can rewrite the class and decouple these responsibilities:
Good
fromimportlibimportmetadatadefget_version(pkg_name:str)->str:"""Retrieve the version of a given package"""returnmetadata.version(pkg_name)classVersionCommentElement:"""An element that renders an HTML comment with the program's version number """def__init__(self,version:str):self.version=versiondefrender(self)->None:print(f'<!-- Version:{self.version} -->')VersionCommentElement(get_version("pip")).render()
The result is that the class only needs to take care of rendering itself. Itreceives the version text during instantiation and this text is generated bycalling a separate function,get_version(). Changing the class has no impacton the other, and vice-versa, as long as the contract between them does notchange, i.e. the function provides a string and the class__init__ methodaccepts a string.
As an added bonus, theget_version() is now reusable elsewhere.
“Incorporate new features by extending the system, not by makingmodifications (to it)”,Uncle Bob.
Objects should be open for extension, but closed to modification. It should bepossible to augment the functionality provided by an object (for example, aclass)without changing its internal contracts. An object can enable this when it isdesigned to be extended cleanly.
In the following example, we try to implement a simple web framework thathandles HTTP requests and returns responses. TheView class has a singlemethod.get() that will be called when the HTTP server will receive a GETrequest from a client.
View is intentionally simple and returnstext/plain responses. We wouldalso like to return HTML responses based on a template file, so we subclass itusing theTemplateView class.
Bad
fromdataclassesimportdataclass@dataclassclassResponse:"""An HTTP response"""status:intcontent_type:strbody:strclassView:"""A simple view that returns plain text responses"""defget(self,request)->Response:"""Handle a GET request and return a message in the response"""returnResponse(status=200,content_type='text/plain',body="Welcome to my web site" )classTemplateView(View):"""A view that returns HTML responses based on a template file."""defget(self,request)->Response:"""Handle a GET request and return an HTML document in the response"""withopen("index.html")asfd:returnResponse(status=200,content_type='text/html',body=fd.read() )
TheTemplateView class has modified the internal behaviour of its parentclass in order to enable the more advanced functionality. In doing so, it nowrelies on theView to not change the implementation of the.get()method, which now needs to be frozen in time. We cannot introduce, for example,some additional checks in all ourView-derived classes because the behaviouris overridden in at least one subtype and we will need to update it.
Let's redesign our classes to fix this problem and let theView class beextended (not modified) cleanly:
Good
fromdataclassesimportdataclass@dataclassclassResponse:"""An HTTP response"""status:intcontent_type:strbody:strclassView:"""A simple view that returns plain text responses"""content_type="text/plain"defrender_body(self)->str:"""Render the message body of the response"""return"Welcome to my web site"defget(self,request)->Response:"""Handle a GET request and return a message in the response"""returnResponse(status=200,content_type=self.content_type,body=self.render_body() )classTemplateView(View):"""A view that returns HTML responses based on a template file."""content_type="text/html"template_file="index.html"defrender_body(self)->str:"""Render the message body as HTML"""withopen(self.template_file)asfd:returnfd.read()
Note that we did need to override therender_body() in order to change thesource of the body, but this method has a single, well defined responsibilitythatinvites subtypes to override it. It is designed to be extended by itssubtypes.
Another good way to use the strengths of both object inheritance and objectcomposition is touseMixins.
Mixins are bare-bones classes that are meant to be used exclusively with otherrelated classes. They are "mixed-in" with the target class using multipleinheritance, in order to change the target's behaviour.
A few rules:
- Mixins should always inherit from
object - Mixins always come before the target class,e.g.
class Foo(MixinA, MixinB, TargetClass): ...
Also good
fromdataclassesimportdataclass,fieldfromtypingimportProtocol@dataclassclassResponse:"""An HTTP response"""status:intcontent_type:strbody:strheaders:dict=field(default_factory=dict)classView:"""A simple view that returns plain text responses"""content_type="text/plain"defrender_body(self)->str:"""Render the message body of the response"""return"Welcome to my web site"defget(self,request)->Response:"""Handle a GET request and return a message in the response"""returnResponse(status=200,content_type=self.content_type,body=self.render_body() )classTemplateRenderMixin:"""A mixin class for views that render HTML documents using a template file Not to be used by itself! """template_file:str=""defrender_body(self)->str:"""Render the message body as HTML"""ifnotself.template_file:raiseValueError("The path to a template file must be given.")withopen(self.template_file)asfd:returnfd.read()classContentLengthMixin:"""A mixin class for views that injects a Content-Length header in the response Not to be used by itself! """defget(self,request)->Response:"""Introspect and amend the response to inject the new header"""response=super().get(request)# type: ignoreresponse.headers['Content-Length']=len(response.body)returnresponseclassTemplateView(TemplateRenderMixin,ContentLengthMixin,View):"""A view that returns HTML responses based on a template file."""content_type="text/html"template_file="index.html"
As you can see, Mixins make object composition easier by packaging togetherrelated functionality into a highly reusable class with a singleresponsibility, allowing clean decoupling. Class extension is achieved by "mixing-in" the additional classes.
The popular Django project makes heavy use of Mixins to compose its class-basedviews.
FIXME: re-enable typechecking for the line above once it's clear how to usetyping.Protocol to make the type checker work with Mixins.
“Functions that use pointers or references to base classesmust be able to use objects of derived classes without knowing it”,Uncle Bob.
This principle is named after Barbara Liskov, who collaborated with fellowcomputer scientist Jeannette Wing on the seminal paper*"A behavioral notion of subtyping" (1994). A core tenet of the paper is that"a subtype (must) preserve the behaviour of the supertype methods and also allinvariant and history properties of its supertype".
In essence, a function accepting a supertype should also accept all itssubtypes with no modification.
Can you spot the problem with the following code?
Bad
fromdataclassesimportdataclass@dataclassclassResponse:"""An HTTP response"""status:intcontent_type:strbody:strclassView:"""A simple view that returns plain text responses"""content_type="text/plain"defrender_body(self)->str:"""Render the message body of the response"""return"Welcome to my web site"defget(self,request)->Response:"""Handle a GET request and return a message in the response"""returnResponse(status=200,content_type=self.content_type,body=self.render_body() )classTemplateView(View):"""A view that returns HTML responses based on a template file."""content_type="text/html"defget(self,request,template_file:str)->Response:# type: ignore"""Render the message body as HTML"""withopen(template_file)asfd:returnResponse(status=200,content_type=self.content_type,body=fd.read() )defrender(view:View,request)->Response:"""Render a View"""returnview.get(request)
The expectation is thatrender() function will be able to work withViewand its subtypeTemplateView, but the latter has broken compatibility bymodifying the signature of the.get() method. The function will raiseaTypeErrorexception when used withTemplateView.
If we want therender() function to work with any subtype ofView, we mustpay attention not to break its public-facing protocol. But how do we know whatconstitutes it for a given class? Type hinters likemypy will raise an errorwhen it detects mistakes like this:
error: Signature of "get" incompatible with supertype "View"<string>:36: note: Superclass:<string>:36: note: def get(self, request: Any) -> Response<string>:36: note: Subclass:<string>:36: note: def get(self, request: Any, template_file: str) -> Response“Keep interfaces smallso that users don’t end up depending on things they don’t need.”,Uncle Bob.
Several well known object oriented programming languages, like Java and Go,have a concept called interfaces. An interface defines the public methods andproperties of an object without implementing them. They are useful when wedon't want to couple the signature of a function to a concrete object; we'drather say "I don't care what object you give me, as long as it has certainmethods and attributes I expect to make use of".
Python does not have interfaces. We have Abstract Base Classes instead, whichare a little different, but can serve the same purpose.
Good
fromabcimportABCMeta,abstractmethod# Define the Abstract Class for a generic Greeter objectclassGreeter(metaclass=ABCMeta):"""An object that can perform a greeting action."""@staticmethod@abstractmethoddefgreet(name:str)->None:"""Display a greeting for the user with the given name"""classFriendlyActor(Greeter):"""An actor that greets the user with a friendly salutation"""@staticmethoddefgreet(name:str)->None:"""Greet a person by name"""print(f"Hello{name}!")defwelcome_user(user_name:str,actor:Greeter):"""Welcome a user with a given name using the provided actor"""actor.greet(user_name)welcome_user("Barbara",FriendlyActor())
Now imagine the following scenario: we have a certain number of PDF documentsthat we author and want to serve to our web site visitors. We are using aPython web framework and we might be tempted to design a class to manage thesedocuments, so we go ahead and design a comprehensive abstract base class forour document.
Error
importabcclassPersistable(metaclass=abc.ABCMeta):"""Serialize a file to data and back"""@property@abc.abstractmethoddefdata(self)->bytes:"""The raw data of the file"""@classmethod@abc.abstractmethoddefload(cls,name:str):"""Load the file from disk"""@abc.abstractmethoddefsave(self)->None:"""Save the file to disk"""# We just want to serve the documents, so our concrete PDF document# implementation just needs to implement the `.load()` method and have# a public attribute named `data`.classPDFDocument(Persistable):"""A PDF document"""@propertydefdata(self)->bytes:"""The raw bytes of the PDF document""" ...# Code goes here - omitted for brevity@classmethoddefload(cls,name:str):"""Load the file from the local filesystem""" ...# Code goes here - omitted for brevitydefview(request):"""A web view that handles a GET request for a document"""requested_name=request.qs['name']# We want to validate this!returnPDFDocument.load(requested_name).data
But we can't! If we don't implement the.save() method, an exception will beraised:
Can't instantiate abstract class PDFDocument with abstract method save.That's annoying. We don't really need to implement.save() here. We couldimplement a dummy method that does nothing or raisesNotImplementedError, butthat's useless code that we will need to maintain.
At the same time, if we remove.save() from the abstract class now we willneed to add it back when we will later implement a way for users to submittheir documents, bringing us back to the same situation as before.
The problem is that we have written aninterface that has features we don'tneed right now as we are not using them.
The solution is to decompose the interface into smaller and composableinterfaces that segregate each feature.
Good
importabcclassDataCarrier(metaclass=abc.ABCMeta):"""Carries a data payload"""@propertydefdata(self): ...classLoadable(DataCarrier):"""Can load data from storage by name"""@classmethod@abc.abstractmethoddefload(cls,name:str): ...classSaveable(DataCarrier):"""Can save data to storage"""@abc.abstractmethoddefsave(self)->None: ...classPDFDocument(Loadable):"""A PDF document"""@propertydefdata(self)->bytes:"""The raw bytes of the PDF document""" ...# Code goes here - omitted for brevity@classmethoddefload(cls,name:str)->None:"""Load the file from the local filesystem""" ...# Code goes here - omitted for brevitydefview(request):"""A web view that handles a GET request for a document"""requested_name=request.qs['name']# We want to validate this!returnPDFDocument.load(requested_name).data
“Depend upon abstractions, not concrete details”,Uncle Bob.
Imagine we wanted to write a web view that returns an HTTP response thatstreams rows of a CSV file we create on the fly. We want to use the CSV writerthat is provided by the standard library.
Bad
importcsvfromioimportStringIOclassStreamingHttpResponse:"""A streaming HTTP response""" ...# implementation code goes heredefsome_view(request):rows= ( ['First row','Foo','Bar','Baz'], ['Second row','A','B','C','"Testing"',"Here's a quote"] )# Define a generator to stream data directly to the clientdefstream():buffer_=StringIO()writer=csv.writer(buffer_,delimiter=';',quotechar='"')forrowinrows:writer.writerow(row)buffer_.seek(0)data=buffer_.read()buffer_.seek(0)buffer_.truncate()yielddata# Create the streaming response object with the appropriate CSV header.response=StreamingHttpResponse(stream(),content_type='text/csv')response['Content-Disposition']='attachment; filename="somefilename.csv"'returnresponse
Our first implementation works around the CSV's writer interface bymanipulating aStringIO object (which is file-like) and performing severallow level operations in order to farm out the rows from the writer. It's a lotof work and not very elegant.
A better way is to leverage the fact that the writer just needs an object witha.write() method to do our bidding. Why not pass it a dummy object thatimmediately returns the newly assembled row, so thattheStreamingHttpResponseclass can immediate stream it back to the client?
Good
importcsvclassEcho:"""An object that implements just the write method of the file-like interface. """defwrite(self,value):"""Write the value by returning it, instead of storing in a buffer."""returnvaluedefsome_streaming_csv_view(request):"""A view that streams a large CSV file."""rows= ( ['First row','Foo','Bar','Baz'], ['Second row','A','B','C','"Testing"',"Here's a quote"] )writer=csv.writer(Echo(),delimiter=';',quotechar='"')returnStreamingHttpResponse( (writer.writerow(row)forrowinrows),content_type="text/csv",headers={'Content-Disposition':'attachment; filename="somefilename.csv"'}, )
Much better, and it works like a charm! The reason it's superior to theprevious implementation should be obvious: less code (and more performant) toachieve the same result. We decided to leverage the fact that the writer classdepends on the.write() abstraction of the object it receives, without caringabout the low level, concrete details of what the method actually does.
This example was taken froma submission made to the Django documentationby this author.
Try to observe theDRYprinciple.
Do your absolute best to avoid duplicate code. Duplicate code is bad because itmeans that there's more than one place to alter something if you need to changesome logic.
Imagine if you run a restaurant and you keep track of your inventory: all yourtomatoes, onions, garlic, spices, etc. If you have multiple lists that you keepthis on, then all have to be updated when you serve a dish with tomatoes inthem. If you only have one list, there's only one place to update!
Often you have duplicate code because you have two or more slightly differentthings, that share a lot in common, but their differences force you to have twoor more separate functions that do much of the same things. Removing duplicatecode means creating an abstraction that can handle this set of different thingswith just one function/module/class.
Getting the abstraction right is critical. Bad abstractions can be worse thanduplicate code, so be careful! Having said this, if you can make a goodabstraction, do it! Don't repeat yourself, otherwise you'll find yourselfupdating multiple places any time you want to change one thing.
Bad:
fromtypingimportList,Dictfromdataclassesimportdataclass@dataclassclassDeveloper:def__init__(self,experience:float,github_link:str)->None:self._experience=experienceself._github_link=github_link@propertydefexperience(self)->float:returnself._experience@propertydefgithub_link(self)->str:returnself._github_link@dataclassclassManager:def__init__(self,experience:float,github_link:str)->None:self._experience=experienceself._github_link=github_link@propertydefexperience(self)->float:returnself._experience@propertydefgithub_link(self)->str:returnself._github_linkdefget_developer_list(developers:List[Developer])->List[Dict]:developers_list= []fordeveloperindevelopers:developers_list.append({'experience':developer.experience,'github_link':developer.github_link })returndevelopers_listdefget_manager_list(managers:List[Manager])->List[Dict]:managers_list= []formanagerinmanagers:managers_list.append({'experience':manager.experience,'github_link':manager.github_link })returnmanagers_list## create list objects of developerscompany_developers= [Developer(experience=2.5,github_link='https://github.com/1'),Developer(experience=1.5,github_link='https://github.com/2')]company_developers_list=get_developer_list(developers=company_developers)## create list objects of managerscompany_managers= [Manager(experience=4.5,github_link='https://github.com/3'),Manager(experience=5.7,github_link='https://github.com/4')]company_managers_list=get_manager_list(managers=company_managers)
Good:
fromtypingimportList,Dictfromdataclassesimportdataclass@dataclassclassEmployee:def__init__(self,experience:float,github_link:str)->None:self._experience=experienceself._github_link=github_link@propertydefexperience(self)->float:returnself._experience@propertydefgithub_link(self)->str:returnself._github_linkdefget_employee_list(employees:List[Employee])->List[Dict]:employees_list= []foremployeeinemployees:employees_list.append({'experience':employee.experience,'github_link':employee.github_link })returnemployees_list## create list objects of developerscompany_developers= [Employee(experience=2.5,github_link='https://github.com/1'),Employee(experience=1.5,github_link='https://github.com/2')]company_developers_list=get_employee_list(employees=company_developers)## create list objects of managerscompany_managers= [Employee(experience=4.5,github_link='https://github.com/3'),Employee(experience=5.7,github_link='https://github.com/4')]company_managers_list=get_employee_list(employees=company_managers)
This document is also available in other languages:
- 🇨🇳 **Chinese**yinruiqing/clean-code-python
- 🇰🇷 ** Korean **wooy0ng/clean-code-python
- 🇵🇹 🇧🇷 **Portugese**fredsonchaves07/clean-code-python
- 🇮🇷 **Persian:**SepehrRasouli/clean-code-python
About
🛁 Clean Code concepts adapted for Python
Resources
License
Uh oh!
There was an error while loading.Please reload this page.
Stars
Watchers
Forks
Releases
Packages0
Languages
- Python98.7%
- Makefile1.3%