Table of Contents

Introduction

Variables

의미 있고 발음하기 쉬운 변수명을 사용하기

importdatetimeymdstr=datetime.date.today().strftime("%y-%m-%d")

importdatetimecurrent_date:str=datetime.date.today().strftime("%y-%m-%d")

같은 타입의 변수에는 같은 단어 사용하기

defget_user_info():passdefget_client_data():passdefget_customer_record():pass

defget_user_info():passdefget_user_data():passdefget_user_record():pass

fromtypingimportUnion,DictclassRecord:passclassUser:info:str@propertydefdata(self)->Dict[str,str]:return {}defget_record(self)->Union[Record,None]:returnRecord()

검색하기 쉬운 이름 사용하기

importtime# What is the number 86400 for again?time.sleep(86400)

importtime# Declare them in the global namespace for the module.SECONDS_IN_A_DAY=60*60*24time.sleep(SECONDS_IN_A_DAY)

설명 가능한 변수 사용하기

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

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

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']}")

암시적인 의미 피하기

seq= ("Austin","New York","San Francisco")foriteminseq:# do_stuff()# do_some_other_stuff()# Wait, what's `item` again?print(item)

locations= ("Austin","New York","San Francisco")forlocationinlocations:# do_stuff()# do_some_other_stuff()# ...print(location)

불필요한 맥락 제거하기

classCar:car_make:strcar_model:strcar_color:str

classCar:make:strmodel:strcolor:str

Use default arguments instead of short circuiting or conditionals

importhashlibdefcreate_micro_brewery(name):name="Hipster Brew Co."ifnameisNoneelsenameslug=hashlib.sha1(name.encode()).hexdigest()# etc.

importhashlibdefcreate_micro_brewery(name:str="Hipster Brew Co."):slug=hashlib.sha1(name.encode()).hexdigest()# etc.

Functions

함수는 한 가지 일만 하기

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)

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)

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)

함수 인자 (이상적으로는 2개 이하)

defcreate_menu(title,body,button_text,cancellable):pass

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

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)

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

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

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

함수 이름은 함수가 무슨 일을 하는지 알기 쉽게

classEmail:defhandle(self)->None:passmessage=Email()# What is this supposed to do again?message.handle()

classEmail:defsend(self)->None:"""Send this message"""message=Email()message.send()

함수는 하나의 추상화 수준만 가지기

# type: ignoredefparse_better_js_alternative(code:str)->None:regexes= [# ...    ]statements=code.split('\n')tokens= []forregexinregexes:forstatementinstatements:passast= []fortokenintokens:passfornodeinast:pass

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

함수 파라미터로 플래그 사용하지 않기

fromtempfileimportgettempdirfrompathlibimportPathdefcreate_file(name:str,temp:bool)->None:iftemp:        (Path(gettempdir())/name).touch()else:Path(name).touch()

fromtempfileimportgettempdirfrompathlibimportPathdefcreate_file(name:str)->None:Path(name).touch()defcreate_temp_file(name:str)->None:    (Path(gettempdir())/name).touch()

사이드 이펙트 피하기

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

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

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

Classes

Single Responsibility Principle (SRP)

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

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

Open/Closed Principle (OCP)

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

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

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"

Liskov Substitution Principle (LSP)

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)

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

Interface Segregation Principle (ISP)

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

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

Can't instantiate abstract class PDFDocument with abstract method save.

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

의존성 역전 원칙(Dependency Inversion Principle (DIP))

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

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"'},     )

Don't repeat yourself (DRY)

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)

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)

Translations