Python Coding Principles and Best Practices

Encoding Principles

Suggestion 1: Understand the Pythonic concept—see "The Zen of Python".

Suggestion 2: Write Pythonic code.

Suggestion 3: Recognize differences between Python and C (indentation vs. braces, quotes, ternary operator, switch‑case, etc.).

Suggestion 4: Add appropriate comments in code.

Suggestion 5: Use blank lines to improve code layout.

Suggestion 6: Follow four principles when writing functions: keep them short, simple, compatible, and single‑purpose.

Suggestion 7: Centralize constants in a single file using all‑uppercase names.

Programming Idioms

Suggestion 8: Use assert statements for debugging, but be aware of performance impact.

Suggestion 9: Swap values directly with a, b = b, a instead of a temporary variable.

Suggestion 10: Leverage lazy evaluation to avoid unnecessary calculations.

Suggestion 11: Understand the drawbacks of custom enum implementations (Python now has built‑in enum ).

Suggestion 12: Prefer isinstance() over type() for type checking.

Suggestion 13: Convert operands to float before division (relevant for Python 2).

Suggestion 14: Beware of eval() security risks, similar to SQL injection.

Suggestion 15: Use enumerate() to get index and value while iterating.

Suggestion 16: Distinguish between == and is , especially for immutable types.

Suggestion 17: Prefer Unicode strings; Python 3 handles encoding automatically.

Suggestion 18: Organize packages with a clear module hierarchy.

Advanced Idioms

Suggestion 19: Use from … import sparingly to avoid namespace pollution.

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

Suggestion 21: i += 1 is not the same as ++i ; the latter is just a unary plus.

Suggestion 22: Use with to automatically close resources, especially files.

Suggestion 23: Use else clauses on loops for cleaner exception handling.

Suggestion 24: Follow basic exception‑handling principles: keep try blocks small, catch specific exceptions, maintain proper exception order, and provide clear messages.

Suggestion 25: Avoid pitfalls in finally blocks.

Suggestion 26: Understand None and correctly test for emptiness.

Suggestion 27: Prefer "".join() over string concatenation with + .

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

Suggestion 29: Treat mutable and immutable objects differently, especially as function arguments.

Suggestion 30: Use consistent container literals ( [] , {} , () ) and list comprehensions for clarity and speed.

Suggestion 31: Parameters are passed by object reference, not by value or by reference.

Suggestion 32: Beware of mutable default arguments.

Suggestion 33: Use variable‑length arguments ( *args , **kwargs ) judiciously; they can obscure function signatures.

Suggestion 34: Distinguish str() (user‑friendly) from repr() (developer‑oriented) and know that repr() output can often be fed to eval() to recreate the object.

Suggestion 35: Use staticmethod and classmethod appropriately.

Library Usage

Suggestion 36: Master basic string operations.

Suggestion 37: Choose between list.sort() (in‑place) and sorted() (returns a new iterable).

Suggestion 38: Use the copy module to differentiate shallow and deep copies.

Suggestion 39: Use collections.Counter for counting.

Suggestion 40: Learn configparser for configuration files.

Suggestion 41: Use argparse for command‑line argument parsing.

Suggestion 42: Use pandas for large CSV processing; it supports chunking and merging.

Suggestion 43: Use xml.etree.ElementTree to parse XML.

Suggestion 44: Understand the pros and cons of pickle (simple, cross‑platform, but insecure and not language‑agnostic).

Suggestion 45: Use json for serialization (load/dump).

Suggestion 46: Use traceback to retrieve stack information.

Suggestion 47: Use logging for log management.

Suggestion 48: Use threading for multithreaded programs.

Suggestion 49: Use queue.Queue to make multithreading safer.

Design Patterns

Suggestion 50: Implement the Singleton pattern using modules.

Suggestion 51: Apply mixin patterns for flexibility.

Suggestion 52: Use publish‑subscribe for loose coupling.

Suggestion 53: Use the State pattern to improve code readability.

Internal Mechanisms

Suggestion 54: Understand built‑in objects.

Suggestion 55: __init__() is not a constructor; distinguish it from new() .

Suggestion 56: Grasp variable scope (local, global, nested, built‑in).

Suggestion 57: Know why the self parameter is required.

Suggestion 58: Understand Method Resolution Order (MRO) and multiple inheritance.

Suggestion 59: Learn descriptor protocol.

Suggestion 60: Differentiate getattr() and getattribute() .

Suggestion 61: Use safer property implementations.

Suggestion 62: Master metaclasses.

Suggestion 63: Familiarize with Python's object protocol.

Suggestion 64: Use operator overloading for infix syntax.

Suggestion 65: Understand the iterator protocol.

Suggestion 66: Work with generators.

Suggestion 67: Use generator‑based coroutines (greenlet) and know differences among coroutines, threads, and processes.

Suggestion 68: Recognize the limitations of the Global Interpreter Lock (GIL).

Suggestion 69: Manage objects and garbage collection.

Tool‑Assisted Development

Suggestion 70: Install third‑party packages from PyPI.

Suggestion 71: Use pip and yolk for package management.

Suggestion 72: Use paster to create packages.

Suggestion 73: Understand unit‑testing concepts.

Suggestion 74: Write unit tests for packages.

Suggestion 75: Apply Test‑Driven Development (TDD) to improve testability.

Suggestion 76: Use Pylint for style checking.

Suggestion 77: Conduct efficient code reviews.

Suggestion 78: Publish packages to PyPI.

Performance Profiling & Optimization

Suggestion 79: Learn basic code‑optimization principles.

Suggestion 80: Leverage performance‑optimization tools.

Suggestion 81: Use cProfile to locate bottlenecks.

Suggestion 82: Use memory_profiler and objgraph for memory analysis.

Suggestion 83: Reduce algorithmic complexity.

Suggestion 84: Apply loop‑optimization techniques (minimize work inside loops, prefer implicit loops, use local variables).

Suggestion 85: Use generators to improve efficiency.

Suggestion 86: Choose appropriate data structures for performance.

Suggestion 87: Exploit the advantages of set .

Suggestion 88: Use multiprocessing to bypass GIL limitations.

Suggestion 89: Use thread pools for better throughput.

Suggestion 90: Write C extensions with Cython .