Make your Debugging easier with these 8 tips in Python

Make your Debugging easier with these 8 tips in Python

Aditya Tiwari's photo
Aditya Tiwari
·Mar 3, 2023·

9 min read

Table of contents

  • Introduction
  • Tip 1: Use assertions
  • Tip 2: Use logging
  • Tip 3: Use a linter
  • Tip 4: Use Unit Tests
  • Tip 5: Use Try-except
  • Tip 6: Use type hints and docstrings
  • Tip 7: Use context managers
  • Tip 8: Use decorators
  • Conclusion


Debugging is the process of finding and fixing errors, bugs, and issues in computer programs. As a programmer, debugging is an essential skill to master, as it is a crucial step in ensuring the code you write is accurate and functioning correctly. There are many reasons due to which there can be errors in the code and it is very important to debug the error else it can cause a wide range of problems like data loss, vulnerabilities, system crashes and more.

In this blog, we will discuss 8 tips and techniques that can help you debug your Python code faster and more effectively. From using assertions and debugging tools to writing unit tests and breaking down your code into smaller pieces, we will cover a range of strategies that you can use to make the debugging process more manageable.

These tips most of the time works for me, hence I think its worth sharing with you all as well. So, let's dive in and explore how you can take your debugging skills to the next level.

Tip 1: Use assertions

Assertions are a powerful tool for debugging Python code. An assertion is a statement that tests a condition and raises an exception if the condition is not met. In other words, an assertion checks whether something is true, and if it's not, it will stop the program and raise an error.

  • Assertions can help you catch errors and bugs in your code by checking that certain conditions are met at specific points in your code.

  • For example, you might use an assertion to check that a function's input is of the correct type, or that a value falls within a certain range. If the condition is not met, the assertion will raise an exception and stop the program, allowing you to quickly identify the issue and fix it.


def divide(a, b):
    assert b != 0, "Error: division by zero"
    return a / b

result = divide(10, 0)

In this code, we define a simple function called divide that takes two arguments, a and b, and returns their division. However, we've also added an assertion statement that checks whether b is not equal to zero. If b is equal to zero, the assertion will raise an exception with the error message "Error: division by zero".

When we call divide(10, 0), the assertion will be triggered and raise an exception, stopping the program and printing the error message. This allows us to quickly identify the issue (division by zero) and fix the function accordingly.

This code will raise an AssertionError with the message "Cannot divide by zero".

Tip 2: Use logging

Logging is a technique used to record events that occur during the execution of a program. It involves creating log messages that contain information about what happened, when it happened, and any other relevant details.

  • Logging is a powerful tool for debugging because it allows you to see what's happening inside your code, even when you're not actively running it.
  • When you're working with complex code, it can be difficult to understand what's happening at each stage of the program's execution. Logging allows you to see what's happening in your code as it runs, so you can track down errors and understand how your program is working.

For example:

import logging


def divide(x, y):"Dividing %d by %d", x, y)
    result = x / y"Result is %d", result)
    return result

result = divide(10, 0)

This code will raise a ZeroDivisionError.

However, you can use logging to track the flow of the program and see the values of variables. The output will be:

INFO:root:Dividing 10 by 0
ERROR:root:division by zero
Traceback (most recent call last):
ZeroDivisionError: division by zero

Tip 3: Use a linter

A linter is a tool that analyzes your code for errors and style violations. It can help you identify potential bugs and improve the readability of your code.

  • Linters can catch errors that might not be immediately apparent when you're running your code. For example, if you forget to define a variable or misspell a function name, a linter can identify these issues and provide suggestions for fixing them.

  • Linters can enforce coding standards and best practices, which can help you write cleaner and more maintainable code. By highlighting areas where your code deviates from these standards, you can identify potential issues and make your code more consistent.

  • Linters can integrate with other tools, such as IDEs or version control systems, to provide a more seamless debugging experience. For example, some linters can be configured to run automatically when you save your code, which can help you catch issues earlier in the development process.

For example:

def add(x, y):
    z = x + y
    return z

result = add(5, 10)

You can use a linter such as pylint to check for errors and style violations:

pip install pylint


This will give you a list of errors and style violations in your code.

Tip 4: Use Unit Tests

Unit tests can help you identify errors early in your code. They allow you to test individual functions and methods to ensure they are working correctly.

For example, suppose you have the following code:

def add(x, y):
    z = x + y
    return z

def test_add():
    assert add(5, 10) == 15
    assert add(-5, 10) == 5
    assert add(0, 0) == 0


You can use unit tests to test the add function and ensure it is working correctly. The output will be:

$ python

Tip 5: Use Try-except

Using try-except blocks can help you handle errors and prevent your program from crashing. It allows you to catch exceptions and handle them gracefully.

  • When an error occurs, the try-except block can be used to provide more information about what went wrong. For example, you can print the error message or stack trace to help you identify where the error occurred and what caused it.

  • By intentionally raising an exception within a try-except block, you can test your code and ensure that it's handling errors correctly. This can be particularly useful for testing edge cases or unexpected inputs.

  • In some cases, you may want to provide a fallback option in case an error occurs. For example, you could use a try-except block to attempt to load a configuration file and provide default values if the file is not found or contains errors.

For example:

def divide(x, y):
    return x / y

result = divide(5, 0)

This code divides 5 by 0, which will raise a ZeroDivisionError. You can use a try-except block to catch the exception and handle it:

def divide(x, y):
        return x / y
    except ZeroDivisionError:
        return "Error: division by zero"

result = divide(5, 0)

This will output "Error: division by zero" instead of raising an exception.

Tip 6: Use type hints and docstrings

Type hints can help you clarify the types of variables and arguments in your code. They can make your code more readable and help prevent errors.

For example, suppose you have the following code:

def add(x: int, y: int) -> int:
    z = x + y
    return z

result = add(5, 10)

Docstrings can help you document your code and make it more readable. They provide information about the purpose of a function or module, its inputs and outputs, and any exceptions that it may raise.

For example:

def add(x, y):
    Add two numbers together.

    :param x: The first number to add.
    :type x: int
    :param y: The second number to add.
    :type y: int
    :return: The sum of x and y.
    :rtype: int
    z = x + y
    return z

result = add(5, 10)

Tip 7: Use context managers

Context managers are a powerful tool for managing resources in Python, such as files or database connections.

  • They allow us to easily handle common issues such as opening and closing files or handling exceptions, and can help you avoid common errors and bugs. By using context managers, we can ensure that our code is properly handling resources and avoiding potential errors.
  • Context managers can be used to provide additional debugging information about a resource, such as its current state or the operations that have been performed on it. This can be particularly useful when trying to track down problems with a resource, as it can help you identify where an error occurred and what might have caused it.

For example:

with open("data.txt", "w") as f:
    f.write("Hello, aditya!")

Above example uses a context manager to open the "data.txt" file and write the string "Hello, aditya" to it. The "with" statement ensures that the file is closed after the block of code is executed, hence reduces the chances of error.

Tip 8: Use decorators

Decorators can help you modify the behavior of functions or classes. They allow you to add functionality to existing code without modifying it directly. By adding print statements or logging messages to a decorator, you can quickly and easily add debugging information to your code.

def log_function(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with args {args} and kwargs {kwargs}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned {result}")
        return result
    return wrapper

def add_numbers(a, b):
    return a + b

result = add_numbers(1, 2)

In this code, I defined a decorator function called log_function that takes a function as an argument and returns a new function that wraps the original function with logging statements. The wrapper function prints name of the function, the input arguments, and the output result before returning the result.

I then applied the decorator to a simple function called add_numbers using the @log_function syntax. When I called add_numbers(1, 2), the decorator adds logging statements to the function and prints the input and output values. The final line prints the result of the function call.

This was a simple example of how decorators can be used for debugging. By adding logging statements to your functions, you can quickly and easily identify any issues or errors that may occur.


Debugging Python can be tough, but it's also really rewarding when you finally figure out what's going on.

I hope you guys enjoyed this blog and learned something from it.

If you want to level up your Python skills and learn more advanced techniques, be sure to follow me on Twitter, I post all kinds of cool Python stuff, from beginner-friendly tips to advanced tricks and techniques that will blow your mind. So what are you waiting for?

Also, if you love my content and blogs, you can consider taking membership or buy me a coffee to support me. Thankyou, that's all for the blog.

Did you find this article valuable?

Support Aditya Tiwari by becoming a sponsor. Any amount is appreciated!

Learn more about Hashnode Sponsors
Share this