- Notifications
You must be signed in to change notification settings - Fork0
🛁 Clean Code concepts adapted for Python
License
jonathanmorais/clean-code-python
Folders and files
| Name | Name | Last commit message | Last commit date | |
|---|---|---|---|---|
Repository files navigation
- Introduction
- Variables
- Functions
- Objects and Data Structures
- Classes
- Don't repeat yourself (DRY)
- Translation
Software engineering principles, from Robert C. Martin's bookClean Code,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 be universallyagreed upon. These are guidelines and nothing more, but they are ones codified over manyyears of collective experience by the authors ofClean Code.
Inspired fromclean-code-javascript
Targets Python3.7+
Bad:
import datetimeymdstr = datetime.date.today().strftime("%y-%m-%d")Good:
import datetimecurrent_date: str = datetime.date.today().strftime("%y-%m-%d")Bad:Here we use three different names for the same underlying entity:
def get_user_info(): passdef get_client_data(): passdef get_customer_record(): passGood:If the entity is the same, you should be consistent in referring to it in your functions:
def get_user_info(): passdef get_user_data(): passdef get_user_record(): passEven betterPython is (also) an object oriented programming language. If it makes sense, package the functions together with the concrete implementationof the entity in your code, as instance attributes, property methods, or methods:
from typing import Union, Dictclass Record: passclass User: info : str @property def data(self) -> Dict[str, str]: return {} def get_record(self) -> Union[Record, None]: return Record()We will read more code than we will ever write. It's important that the code we do write isreadable and searchable. Bynot naming variables that end up being meaningful forunderstanding our program, we hurt our readers.Make your names searchable.
Bad:
import time# What is the number 86400 for again?time.sleep(86400)Good:
import time# Declare them in the global namespace for the module.SECONDS_IN_A_DAY = 60 * 60 * 24time.sleep(SECONDS_IN_A_DAY)Bad:
import readdress = "One Infinite Loop, Cupertino 95014"city_zip_code_regex = r"^[^,\\]+[,\\\s]+(.+?)\s*(\d{5})?$"matches = re.match(city_zip_code_regex, address)if matches: print(f"{matches[1]}: {matches[2]}")Not bad:
It's better, but we are still heavily dependent on regex.
import readdress = "One Infinite Loop, Cupertino 95014"city_zip_code_regex = r"^[^,\\]+[,\\\s]+(.+?)\s*(\d{5})?$"matches = re.match(city_zip_code_regex, address)if matches: city, zip_code = matches.groups() print(f"{city}: {zip_code}")Good:
Decrease dependence on regex by naming subpatterns.
import readdress = "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)if matches: 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")for item in seq: #do_stuff() #do_some_other_stuff() # Wait, what's `item` again? print(item)Good:
locations = ("Austin", "New York", "San Francisco")for location in locations: #do_stuff() #do_some_other_stuff() # ... print(location)If your class/object name tells you something, don't repeat that in yourvariable name.
Bad:
class Car: car_make: str car_model: str car_color: strGood:
class Car: make: str model: str color: strTricky
Why write:
import hashlibdef create_micro_brewery(name): name = "Hipster Brew Co." if name is None else name slug = hashlib.sha1(name.encode()).hexdigest() # etc.... when you can specify a default argument instead? This also makes it clear thatyou are expecting a string as the argument.
Good:
import hashlibdef create_micro_brewery(name: str = "Hipster Brew Co."): slug = hashlib.sha1(name.encode()).hexdigest() # etc.Limiting the amount of function parameters is incredibly important because it makestesting your function easier. Having more than three leads to a combinatorial explosionwhere you have to test tons of different cases with each separate argument.
Zero arguments is the ideal case. One or two arguments is ok, and three should be avoided.Anything more than that should be consolidated. Usually, if you have more than twoarguments then your function is trying to do too much. In cases where it's not, mostof the time a higher-level object will suffice as an argument.
Bad:
def create_menu(title, body, button_text, cancellable): passJava-esque:
class Menu: 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
class MenuConfig: """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: str body: str button_text: str cancellable: bool = Falsedef create_menu(config: MenuConfig) -> None: title = config.title body = 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
from typing import NamedTupleclass MenuConfig(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: str body: str button_text: str cancellable: bool = Falsedef create_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
from dataclasses import astuple, dataclass@dataclassclass MenuConfig: """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: str body: str button_text: str cancellable: bool = Falsedef create_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
from typing import TypedDictclass MenuConfig(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: str body: str button_text: str cancellable: booldef create_menu(config: MenuConfig): title = config["title"] # ...create_menu( # You need to supply all the parameters MenuConfig( title="My delicious menu", body="A description of the various items on the menu", button_text="Order now!", cancellable=True ))This is by far the most important rule in software engineering. When functions do morethan one thing, they are harder to compose, test, and reason about. When you can isolatea function to just one action, they can be refactored easily and your code will read muchcleaner. If you take nothing else away from this guide other than this, you'll be aheadof many developers.
Bad:
from typing import Listclass Client: active: booldef email(client: Client) -> None: passdef email_clients(clients: List[Client]) -> None: """Filter active clients and send them an email. """ for client in clients: if client.active: email(client)Good:
from typing import Listclass Client: active: booldef email(client: Client) -> None: passdef get_active_clients(clients: List[Client]) -> List[Client]: """Filter active clients. """ return [client for client in clients if client.active]def email_clients(clients: List[Client]) -> None: """Send an email to a given list of clients. """ for client in get_active_clients(clients): email(client)Do you see an opportunity for using generators now?
Even better
from typing import Generator, Iteratorclass Client: active: booldef email(client: Client): passdef active_clients(clients: Iterator[Client]) -> Generator[Client, None, None]: """Only active clients""" return (client for client in clients if client.active)def email_client(clients: Iterator[Client]) -> None: """Send an email to a given list of clients. """ for client in active_clients(clients): email(client)Bad:
class Email: def handle(self) -> None: passmessage = Email()# What is this supposed to do again?message.handle()Good:
class Email: def send(self) -> None: """Send this message"""message = Email()message.send()When you have more than one level of abstraction, your function is usually doing toomuch. Splitting up functions leads to reusability and easier testing.
Bad:
# type: ignoredef parse_better_js_alternative(code: str) -> None: regexes = [ # ... ] statements = code.split('\n') tokens = [] for regex in regexes: for statement in statements: pass ast = [] for token in tokens: pass for node in ast: passGood:
from typing import Tuple, List, DictREGEXES: Tuple = ( # ...)def parse_better_js_alternative(code: str) -> None: tokens: List = tokenize(code) syntax_tree: List = parse(tokens) for node in syntax_tree: passdef tokenize(code: str) -> List: statements = code.split() tokens: List[Dict] = [] for regex in REGEXES: for statement in statements: pass return tokensdef parse(tokens: List) -> List: syntax_tree: List[Dict] = [] for token in tokens: pass return syntax_treeFlags 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:
from tempfile import gettempdirfrom pathlib import Pathdef create_file(name: str, temp: bool) -> None: if temp: (Path(gettempdir()) / name).touch() else: Path(name).touch()Good:
from tempfile import gettempdirfrom pathlib import Pathdef create_file(name: str) -> None: Path(name).touch()def create_temp_file(name: str) -> None: (Path(gettempdir()) / name).touch()A function produces a side effect if it does anything other than take a value inand return another value or values. For example, a side effect could be writingto a file, modifying some global variable, or accidentally wiring all your moneyto a stranger.
Now, you do need to have side effects in a program on occasion - for example, likein the previous example, you might need to write to a file. In these cases, youshould centralize and indicate where you are incorporating side effects. Don't haveseveral functions and classes that write to a particular file - 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 by anything,or using an instance of a class, and not centralizing where your side effects occur.If you can do this, you will be happier than the vast majority of 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"def split_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! global fullname fullname = 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:
from typing import List, AnyStrdef split_into_first_and_last_name(name: AnyStr) -> List[AnyStr]: return name.split()fullname = "Ryan McDermott"name, surname = split_into_first_and_last_name(fullname)print(name, surname) # => Ryan McDermottAlso good
from dataclasses import dataclass@dataclassclass Person: name: str @property def name_as_first_and_last(self) -> list: return self.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"]Coming soon
Coming soon
Try to observe theDRY principle.
Do your absolute best to avoid duplicate code. Duplicate code is bad becauseit means that there's more than one place to alter something if you need tochange some 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 thatyou keep this on, then all have to be updated when you serve a dish withtomatoes in them. If you only have one list, there's only one place to update!
Often you have duplicate code because you have two or more slightlydifferent things, that share a lot in common, but their differences force youto have two or more separate functions that do much of the same things. Removingduplicate code means creating an abstraction that can handle this set of differentthings with just one function/module/class.
Getting the abstraction right is critical. Bad abstractions can beworse than duplicate code, so be careful! Having said this, if you can makea good abstraction, do it! Don't repeat yourself, otherwise you'll find yourselfupdating multiple places any time you want to change one thing.
Bad:
from typing import List, Dictfrom dataclasses import dataclass@dataclassclass Developer: def __init__(self, experience: float, github_link: str) -> None: self._experience = experience self._github_link = github_link @property def experience(self) -> float: return self._experience @property def github_link(self) -> str: return self._github_link @dataclassclass Manager: def __init__(self, experience: float, github_link: str) -> None: self._experience = experience self._github_link = github_link @property def experience(self) -> float: return self._experience @property def github_link(self) -> str: return self._github_link def get_developer_list(developers: List[Developer]) -> List[Dict]: developers_list = [] for developer in developers: developers_list.append({ 'experience' : developer.experience, 'github_link' : developer.github_link }) return developers_listdef get_manager_list(managers: List[Manager]) -> List[Dict]: managers_list = [] for manager in managers: managers_list.append({ 'experience' : manager.experience, 'github_link' : manager.github_link }) return managers_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:
from typing import List, Dictfrom dataclasses import dataclass@dataclassclass Employee: def __init__(self, experience: float, github_link: str) -> None: self._experience = experience self._github_link = github_link @property def experience(self) -> float: return self._experience @property def github_link(self) -> str: return self._github_link def get_employee_list(employees: List[Employee]) -> List[Dict]: employees_list = [] for employee in employees: employees_list.append({ 'experience' : employee.experience, 'github_link' : employee.github_link }) return employees_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:
Brazilian Portuguese:fredsonchaves07/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
- Python97.6%
- Makefile2.4%