Python Coding Best Practices, Design Patterns, and Performance Optimization Guide

1. Coding Principles

Understand the Pythonic concept by reading "The Zen of Python".

Write Pythonic code.

Avoid non‑standard code such as case‑only variable names, confusing identifiers, or overly short names; sometimes longer, descriptive names improve readability.

Deepen knowledge of Python language features, libraries, and evolution; study well‑known Pythonic codebases like Flask.

Recognize differences between Python and C (indentation vs. braces, quoting, ternary operator, switch‑case, etc.).

Add appropriate comments and blank lines to improve layout.

2. Function Design Principles

Keep functions short and avoid deep nesting.

Design clear, simple, and easy‑to‑use function signatures.

Make parameters backward‑compatible.

Ensure each function does one thing and maintains consistent granularity.

3. Programming Conventions

Use assert for debugging, aware of its performance impact.

Swap values without temporary variables: a, b = b, a .

Leverage lazy evaluation to avoid unnecessary computation.

Prefer isinstance() over type() for type checking.

Convert operands to float before division (Python 3 handles this automatically).

Beware of eval() security risks.

Use enumerate() to get index and value during iteration.

Distinguish == from is for immutable types.

Prefer Unicode strings; Python 3 simplifies encoding issues.

Organize modules with a sensible package hierarchy.

4. Advanced Conventions

Use from … import sparingly to avoid namespace pollution.

Prefer absolute imports (relative imports are removed in Python 3).

Remember i += 1 is not the same as ++i (the latter is just a positive sign).

Use with to automatically close resources, especially files.

Apply else clauses on loops for clean exception handling.

Follow exception‑handling best practices: keep try blocks small, catch specific exceptions, order catches properly, and provide helpful error messages.

Avoid pitfalls in finally blocks.

Understand None semantics for proper emptiness checks.

Prefer ''.join() over string concatenation with + .

Use str.format() instead of the % operator for formatting.

Distinguish mutable and immutable objects, especially as function arguments.

Initialize containers consistently (e.g., [] , {} , () ) and use list comprehensions for clarity and speed.

Know that function arguments are passed by object reference, not by value.

Beware default mutable arguments.

Limit use of variable‑length arguments ( *args , **kwargs ) to keep signatures clear.

Differentiate str() (user‑friendly) from repr() (developer‑oriented) and use repr() when an object must be reproducible via eval() .

Understand when to use staticmethod vs. classmethod .

5. Library Usage

Master basic string operations.

Choose sort() for in‑place list sorting; use sorted() for any iterable without mutating the original.

Use copy.deepcopy() for deep copies and know the difference from shallow copies.

Utilize collections.Counter for counting.

Familiarize with configparser for configuration files.

Parse command‑line arguments with argparse .

Process large CSV files with pandas (or the built‑in csv module for simple cases).

Parse XML using xml.etree.ElementTree .

Understand the advantages and limitations of pickle for serialization; consider json as an alternative.

Use traceback to obtain stack information and logging for structured logs.

Write multithreaded programs with threading and coordinate safely using queue.Queue .

6. Design Patterns

Implement the Singleton pattern via modules.

Apply mixins for flexible code reuse.

Use publish‑subscribe for loose coupling.

Adopt the State pattern to simplify complex state‑dependent logic.

7. Internal Mechanisms

Understand built‑in objects and the difference between __init__ and __new__ .

Learn scope rules: local, global, nested, and built‑in.

Know why self is required in instance methods.

Grasp Method Resolution Order (MRO) for multiple inheritance.

Understand descriptors, getattr() vs. __getattribute__ , and safe use of property .

Explore metaclasses, the object protocol, operator overloading, iterator and generator protocols, coroutine basics, and the limitations of the GIL.

Familiarize with garbage collection and object lifecycle management.

8. Tooling for Project Development

Install third‑party packages from PyPI using pip (or yolk for management).

Create packages with paster .

Understand unit testing concepts and write tests for packages.

Adopt Test‑Driven Development (TDD) to improve testability.

Use Pylint for style checking, error detection, and refactoring assistance.

Generate UML diagrams from code and integrate with CI tools like Jenkins.

Conduct efficient code reviews and publish packages to PyPI.

9. Performance Profiling and Optimization

Follow basic code‑optimization principles.

Leverage profiling tools such as cProfile , memory_profiler , and objgraph .

Reduce algorithmic complexity where possible.

Optimize loops by minimizing work inside them, using local variables, and preferring implicit over explicit loops when readability permits.

Use generators to improve efficiency.

Select appropriate data structures (e.g., set for fast membership tests).

Employ multiprocessing to bypass GIL limitations and use thread pools for I/O‑bound tasks.

Consider writing performance‑critical extensions with Cython.