"""An HTTP response""" status: int content_type: str body: str class View: We wouldĪlso like to return HTML responses based on a template file, so we subclass itįrom dataclasses import dataclass dataclass class Response: View is intentionally simple and returns text/plain responses. get() that will be called when the HTTP server will receive a GET Handles HTTP requests and returns responses. In the following example, we try to implement a simple web framework that Possible to augment the functionality provided by an object (for example, a Objects should be open for extension, but closed to modification. “Incorporate new features by extending the system, not by making the function provides a string and the class _init_ methodĪs an added bonus, the get_version() is now reusable elsewhere. On the other, and vice-versa, as long as the contract between them does notĬhange, i.e. Receives the version text during instantiation and this text is generated byĬalling a separate function, get_version(). The result is that the class only needs to take care of rendering itself. VersionCommentElement( get_version( "pip")). version = version def render( self) -> None: """An element that renders an HTML comment with the program's version number """ def _init_( self, version: str): """Retrieve the version of a given package""" return metadata. If you can do this, you will be happier than the vast majorityįrom importlib import metadata def get_version( pkg_name: str) -> str: Without any structure, using mutable data types that can be written to byĪnything, or using an instance of a class, and not centralizing where your sideĮffects occur. The main point is to avoid common pitfalls like sharing state between objects
Don't have several functions and classes that write to a particular In theseĬases, you should centralize and indicate where you are incorporating sideĮffects. Like in the previous example, you might need to write to a file. Now, you do need to have side effects in a program on occasion - for example, Writing to a file, modifying some global variable, or accidentally wiring all To move some computations, done with those parameters inside theįunction, into methods belonging to the new object, therefore reducing theįrom tempfile import gettempdir from pathlib import Path def create_file( name: str) -> None:ĭef create_temp_file( name: str) -> None:Ī function produces a side effect if it does anything other than take a value The reason why this isĪ better arrangement is than having multiple parameters is that we may be able You may alsoīe able to reuse this entity elsewhere in your program. These parameters might be attributes of a singleĮntity that you can represent with a dedicated data structure.
Some or all parameters into a specialized object that will be passed as anĪrgument to the function. If the function has a single responsibility, consider if you can bundle Into smaller functions having a reduced set of parameters, ideally less than ⬆ back to top Function arguments (2 or fewer ideally)Ī large amount of parameters is usually the sign that a function isĭoing too much (has more than one responsibility). """ for client in active_clients( clients):
"""Send an email to a given list of clients. active)ĭef email_client( clients: Iterator) -> None:
"""Only active clients""" return ( client for client in clients if client. Pass def active_clients( clients: Iterator) -> Generator: From typing import Generator, Iterator class Client:
0 kommentar(er)
