Follow PEP 8 by using 4 spaces for indentation, limiting lines to 79 characters, naming variables with underscores, classes with CamelCase, and separating functions with blank lines, while using tools like black or flake8 for enforcement. 2. Use meaningful names such as total_price instead of tp and verbs for functions like calculate_tax, ensuring consistency across similar concepts. 3. Keep functions small and focused, ideally under 20–30 lines, by breaking large ones into smaller helpers like validate_order and ship_order. 4. Use type hints such as def greet(name: str) -> str to improve clarity and enable static analysis with mypy. 5. Write clear docstrings in Google or Sphinx format for functions, explaining parameters and return values, and avoid redundant comments. 6. Embrace Pythonic idioms like list comprehensions, context managers for file handling, and built-in functions like enumerate and zip. 7. Organize imports in order—standard library, third-party, local—separated by blank lines, and avoid wildcard imports. 8. Handle errors with specific exceptions like except ValueError instead of bare except clauses, and log meaningful messages. 9. Write unit tests using pytest or unittest with descriptive names such as test_calculate_tax_with_zero_income and maintain clean test code. 10. Refactor regularly by removing dead code, eliminating duplication, extracting reusable logic, and improving names as understanding evolves. Following these practices ensures Python code remains clean, readable, maintainable, and less error-prone over time.

Writing clean and readable Python code is essential for maintainability, collaboration, and reducing bugs. Here are some widely accepted best practices:

1. Follow PEP 8 – Style Guide for Python Code

PEP 8 is the official style guide for Python and covers formatting, naming conventions, and layout. Key points include:

• Use 4 spaces per indentation level (not tabs).
• Limit lines to 79 characters (72 for docstrings).
• Separate functions and classes with two blank lines.
• Use lowercase with underscores for function and variable names (my_variable, process_data).
• Use CamelCase for class names (MyClass, DataProcessor).
• Surround top-level functions and classes with blank lines.
• Avoid extraneous whitespace (e.g., func( arg ) → func(arg)).

You can use tools like flake8, black, or autopep8 to automatically check or format your code.

2. Write Meaningful Names

Choose descriptive and unambiguous names for variables, functions, and classes.

• Avoid single-letter names (except in loops or math contexts).
• Use total_price instead of tp.
• Use verbs for function names: calculate_tax(), fetch_user_data().
• Be consistent: if you use user_data, don’t switch to client_info for the same concept.

This makes your code self-documenting and easier to follow.

3. Keep Functions Small and Focused

Each function should do one thing and do it well (Single Responsibility Principle).

• Aim for functions under 20–30 lines.
• Break large functions into smaller helper functions.
• Use clear function names that describe what they do.

For example:

def process_orders(orders):
    validated = [validate_order(o) for o in orders]
    shipped = [ship_order(o) for o in validated if o.is_valid]
    send_notifications(shipped)

Instead of one long function doing validation, shipping, and notifications.

4. Use Type Hints

Type hints improve readability and help catch bugs early.

def greet(name: str) -> str:
    return f"Hello, {name}"

They’re especially useful in larger projects and when using tools like mypy for static analysis.

5. Write Clear and Concise Comments and Docstrings

Only comment when the code isn’t self-explanatory. Avoid stating the obvious.

Use docstrings for modules, classes, and functions. The most common format is Google style or Sphinx:

def calculate_area(radius: float) -> float:
    """Calculate the area of a circle given its radius.

    Args:
        radius: The radius of the circle.

    Returns:
        The area of the circle.
    """
    return 3.14159 * radius ** 2

6. Leverage Pythonic Idioms

Write code in a way that feels natural in Python:

• Use list comprehensions for simple transformations:

  squares = [x**2 for x in range(10)]

• Use context managers for file handling:

  with open("file.txt") as f:
      content = f.read()

• Use enumerate() and zip() instead of manual indexing.
• Prefer if not list over if len(list) == 0.

7. Organize Imports Properly

Follow the PEP 8 import order:

1. Standard library imports
2. Third-party imports
3. Local application imports

Separate each group with a blank line. Avoid wildcard imports (from module import *).

import os
import sys

import requests
import numpy as np

from mypackage import mymodule

8. Handle Errors Gracefully

Use specific exceptions and avoid bare except: clauses.

try:
    value = int(user_input)
except ValueError:
    print("Invalid number")

Log meaningful error messages and avoid silencing exceptions unless intentional.

9. Use Version Control and Write Tests

Clean code isn’t just about style—it’s also about reliability.

• Write unit tests using unittest or pytest.
• Keep test code clean too.
• Use descriptive test names: test_calculate_tax_with_zero_income.

10. Refactor Regularly

Don’t write code once and forget it. Revisit and simplify as you learn more.

• Remove dead code and duplicate logic.
• Extract repeated patterns into functions or classes.
• Rename things as your understanding evolves.

Basically, clean Python code reads like well-written prose: clear, concise, and easy to follow. Following these practices consistently makes a big difference over time.

The above is the detailed content of What are some best practices for writing clean and readable Python code?. For more information, please follow other related articles on the PHP Chinese website!