Personal notes of a python developer
A place where I save all my nuggets of self learning on Python as well as small projects
-
deploying package
- sys.path
- .pth in site-packages to add paths to sys.path (like configuring PYTHONPATH) on initialisation of interpreter --> via site.py
- _init_.py in parent_folder(import parent_folder) and subfolders(import parent_folder.subfolder) is to create a namespace and only import modules.py from its folder, outside the folder, or files inside other subfolders outside folder. PEP8 says keep it flat, not nested so import pandas as __pd to avoid calling import mypackage.pd
-
Logging
- metaclass
-
Design Patterns
- abc / interfaces
- collections
-
memory management
- gc
- weakref
- psutil / resource
- objgraph
-
Front End Client-Server RESTful object tranmission
- django (Full Stack)
- flask (Non Full Stack)
- http.client
- wsgiref
- json
-
Parallel Processing
- dask
- multiprocessing
- threading
- asyncio
- concurrent.futures
-
Automation
- win32com.client
- pythoncom
-
Configuration
- pickle
- YAML
- JSON
-
Security
- hashlib
- base64
References I read to gain mastery of Python
- Design Patterns
- Mastering Object-Oriented Python
- Python Patterns/Idioms by @faif
- *Python Designs Receipes Idioms
A collection of design patterns and idioms in Python.
When an implementation is added or modified, be sure to update this file and
rerun append_output.sh
(eg. ./append_output.sh borg.py) to keep the output
comments at the bottom up to date.
Current Patterns:
Creational Patterns:
Pattern | Description |
---|---|
abstract_factory | use a generic function with specific factories |
borg | a singleton with shared-state among instances |
builder | instead of using multiple constructors, builder object receives parameters and returns constructed objects |
factory_method | delegate a specialized function/method to create instances |
lazy_evaluation | lazily-evaluated property pattern in Python |
pool | preinstantiate and maintain a group of instances of the same type |
prototype | use a factory and clones of a prototype for new instances (if instantiation is expensive) |
Structural Patterns:
Pattern | Description |
---|---|
3-tier | data<->business logic<->presentation separation (strict relationships) |
adapter | adapt one interface to another using a white-list |
bridge | a client-provider middleman to soften interface changes |
composite | lets clients treat individual objects and compositions uniformly |
decorator | wrap functionality with other functionality in order to affect outputs |
facade | use one class as an API to a number of others |
flyweight | transparently reuse existing instances of objects with similar/identical state |
front_controller | single handler requests coming to the application |
mvc | model<->view<->controller (non-strict relationships) |
proxy | an object funnels operations to something else |
Behavioral Patterns:
Pattern | Description |
---|---|
chain | apply a chain of successive handlers to try and process the data |
catalog | general methods will call different specialized methods based on construction parameter |
chaining_method | continue callback next object method |
command | bundle a command and arguments to call later |
iterator | traverse a container and access the container's elements |
mediator | an object that knows how to connect other objects and act as a proxy |
memento | generate an opaque token that can be used to go back to a previous state |
observer | provide a callback for notification of events/changes to data |
publish_subscribe | a source syndicates events/data to 0+ registered listeners |
registry | keep track of all subclasses of a given class |
specification | business rules can be recombined by chaining the business rules together using boolean logic |
state | logic is organized into a discrete number of potential states and the next state that can be transitioned to |
strategy | selectable operations over the same data |
template | an object imposes a structure but takes pluggable components |
visitor | invoke a callback for all items of a collection |
Design for Testability Patterns:
Pattern | Description |
---|---|
setter_injection | the client provides the depended-on object to the SUT via the setter injection (implementation variant of dependency injection) |
Fundamental Patterns:
Pattern | Description |
---|---|
delegation_pattern | an object handles a request by delegating to a second object (the delegate) |
Others:
Pattern | Description |
---|---|
blackboard | architectural model, assemble different sub-system knowledge to build a solution, AI approach - non gang of four pattern |
graph_search | graphing algorithms - non gang of four pattern |
hsm | hierarchical state machine - non gang of four pattern |
Contributions are welcome! For bug reports or requests please submit an issue.
This repository contains a variety of content; some developed by J., and some from third-parties. The third-party content is distributed under the license provided by those parties.
The content developed by J. is distributed under the following license:
Copyright 2018 J.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.