Mastering Clean Code Practices in Python

Enhancing Readability, Collaboration, and Productivity

4 min readOct 8, 2023

Clean Python code provides several advantages: It’s easier to read, maintain, and collaborate on. Debugging is simplified, and it may run more efficiently.

Clean code enhances productivity, reduces technical debt, encourages code reuse, and makes code reviews smoother. Plus, in the professional world, it’s highly valued and can boost your career.

Let’s explore best practices to write clean code in Python.

1. How to Tell the Difference Between Good and Bad Code

Understanding what makes code “good” or “bad” is fundamental. Good code is readable, maintainable, and efficient. Bad code is often hard to understand and error-prone. Here are some key indicators of good and bad code:

Good Code:

Follows Python’s PEP 8 style guide.
Has meaningful variable and function names.
Avoids redundant or unnecessary code.
Employs consistent and concise formatting.
Follows the DRY (Don’t Repeat Yourself) principle.

def calculate_total_price(item_price, quantity):
    tax_rate = 0.2
    total_price = item_price * quantity * (1 + tax_rate)
    return total_price

Bad Code:

Uses cryptic variable names like a, b, or temp.
Contains large functions or classes with too many responsibilities.
Lacks proper documentation and comments.
Violates the Single Responsibility Principle (SRP).

def x(y): z=5;return y*z

2. How to Write Good Code and Transform Bad Code

Refactoring is the process of improving existing code. Transform bad code into good code through refactoring.

To write good code and refactor bad code, follow these steps:

Break down complex functions into smaller, single-responsibility functions.
Rename variables and functions to be descriptive.
Eliminate code duplication.
Remove unnecessary comments.
Ensure the code is self-explanatory.
Use meaningful data structures.

# Bad Code
def calculate_average(numbers):
    total = 0
    for num in numbers:
        total += num
      return total / len(numbers)

# Bad code
def add_numbers(a, b):
    return a + b

# Good code:
def add_numbers(num1, num2):
    return num1+ num2

3. How to Create Good Names, Functions, Objects, and Classes

Choosing meaningful names is crucial for code clarity.

Naming is crucial for code readability. Use descriptive names for variables, functions, objects, and classes. Follow the PEP 8 naming conventions.

# Bad Naming
x = 10  # What is 'x'?
def func(a, b):  # What does 'func' do?

# Good Naming
count = 10  # Descriptive name
def add_numbers(num1, num2):  # Clear function name

# Bad naming
def func(x, y):
    return x + y

# Good naming
def calculate_sum(num1, num2):
    return num1 + num2

4. How to Format Code for Maximum Readability

Consistent code formatting enhances readability.

Follow PEP 8 guidelines for code formatting. Use proper indentation, spacing, and line lengths. Use whitespace to enhance code readability.

# Bad Formatting
def some_function(x,y,z):
    result = x+y+z
return result

# Good Formatting
def some_function(x, y, z):
    result = x + y + z
    return result

5. How to implement complete error handling without obscuring code logic

Effective error handling prevents unexpected crashes.

Handle errors gracefully using try-except blocks. Avoid catching generic exceptions and be specific. Further, avoid ignoring exceptions without action.

# Bad Error Handling
try:
    result = 10 / 0
except Exception as e:
    print("An error occurred")

# Good Error Handling
try:
    result = 10 / 0
except ZeroDivisionError as e:
    print("Division by zero error:", e)

# Bad error handling
def divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        return None

# Good error handling
def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero.")
    return a / b

6. How to Unit Test and Practice Test-Driven Development

Unit testing ensures code correctness and reliability.

Write unit tests for your code using Python’s built-in unittest module or third-party libraries like pytest.

Write tests before implementing code (Test-Driven Development).
Test edge cases and different scenarios.
Follow the Arrange-Act-Assert pattern in your tests.

# Bad Testing
def add(a, b):
    return a + b

# No testing
# Good Testing (Using pytest)
import pytest
def add(a, b):
    return a + b
def test_add():
    assert add(2, 3) == 5
    assert add(-1, 1) == 0

# Bad code without tests
def add_numbers(x, y):
    return x + y

# Good code with tests
def add_numbers(x, y):
    if type(x) not in (int, float) or type(y) not in (int, float):
        raise ValueError("Input must be numeric.")
    return x + y

# Corresponding unit test
def test_add_numbers():
    assert add_numbers(2, 3) == 5
    assert add_numbers(0.5, 0.25) == 0.75
    assert add_numbers("hello", "world")  # Raises ValueError

Incorporating these clean code principles into your Python codebase will improve maintainability and collaboration, even in data science projects. Clean code is a skill that takes practice, but it’s essential for building reliable and efficient software.