Python Coding Principles and Best Practices

Coding Principles

Understand the Pythonic concept by reading "The Zen of Python" and strive to write Pythonic code.

Avoid non‑standard code such as case‑only variable names, confusing identifiers, and 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 styles, ternary operators, switch‑case equivalents).

Add appropriate comments and blank lines to improve code layout.

Group constants in a dedicated file using all‑caps naming.

Programming Conventions

Use assert for debugging while being aware of its performance impact.

Swap values directly with a, b = b, a instead of temporary variables.

Leverage lazy evaluation to avoid unnecessary calculations.

Prefer enumerate() to obtain index and value during iteration.

Distinguish between == and is , especially for immutable types.

Prefer Unicode handling; Python 3 largely eliminates encoding headaches.

Structure packages logically to manage modules.

Design functions with four principles: keep them short, simple, compatible, and single‑purpose.

Use all‑caps for constants and centralize them.

Prefer join() over + for string concatenation and format() over the % operator for formatting.

Understand mutable vs. immutable objects, especially as function arguments.

Initialize containers consistently (lists, dicts, tuples) and use list comprehensions for clarity and speed.

Pass arguments by object reference, not by value.

Avoid mutable default arguments and be cautious with *args and **kwargs as they can obscure signatures.

Distinguish str() (user‑friendly) from repr() (developer‑oriented) and know that repr() output can often be fed to eval() .

Use staticmethod and classmethod appropriately.

Library Usage

Master string operations, choose between sort() (in‑place) and sorted() (returns new iterable).

Use the copy module for deep copies.

Utilize collections.Counter for counting.

Familiarize with configparser for configuration files.

Parse command‑line arguments with argparse .

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

Parse XML using ElementTree .

Understand the advantages and security concerns of pickle ; consider JSON for safer serialization.

Use traceback for stack traces, logging for logs, threading for multithreading, and queue for thread‑safe communication.

Apply design patterns such as Singleton, mixins, publish‑subscribe, and State via modules.

Internal Mechanisms

Know built‑in objects, the difference between __init__() and __new__() , and variable scope (local, global, nested, built‑in).

Understand the purpose of self , method resolution order (MRO), descriptors, and the distinction between getattr() and __getattribute__() .

Use safe property implementations and explore metaclasses.

Familiarize with the Python object protocol and operator overloading for infix syntax.

Know iterator and generator protocols, coroutine concepts, and the limitations of the GIL.

Manage object lifecycle and garbage collection.

Install third‑party packages from PyPI using pip (or yolk ) and create packages with paster .

Write unit tests, adopt test‑driven development (TDD), and use pylint for style and error checking.

Perform code reviews effectively.

Publish packages to PyPI.

Performance Profiling and Optimization

Follow basic optimization principles and use tools like cProfile , memory_profiler , and objgraph .

Reduce algorithmic complexity, optimize loops (minimize work inside loops, prefer comprehensions, use local variables), and replace explicit loops with built‑in functions when possible.

Leverage generators, appropriate data structures, and sets for efficiency.

Overcome GIL limitations with multiprocessing and improve concurrency using thread pools.

Consider writing performance‑critical extensions with Cython.