# PySnooper: Effortless Python Debugging Without Print Statements

This repository profile is provided by osrepos.com, an open source repository discovery platform.

Source: osrepos.com
Repository profile: https://osrepos.com/repo/cool-rr-pysnooper
Generated for open source discovery and AI-assisted research.

PySnooper is a powerful, yet simple, debugging tool for Python that eliminates the need for manual `print` statements. By adding a single decorator, developers can get a detailed, play-by-play log of function execution, including line-by-line tracing and variable value changes. It's designed for quick integration into any codebase without extensive setup.

GitHub: https://github.com/cool-RR/PySnooper
OSRepos URL: https://osrepos.com/repo/cool-rr-pysnooper

## Summary

PySnooper is a powerful, yet simple, debugging tool for Python that eliminates the need for manual `print` statements. By adding a single decorator, developers can get a detailed, play-by-play log of function execution, including line-by-line tracing and variable value changes. It's designed for quick integration into any codebase without extensive setup.

## Topics

- python
- debug
- debugger
- introspection
- logging
- development
- tooling

## Repository Information

Last analyzed by OSRepos: Mon Apr 20 2026 01:56:17 GMT+0100 (Western European Summer Time)
Detail views: 9
GitHub clicks: 13

## Safety Notice

OSRepos shares public repositories for knowledge and discovery only. Review source code, dependencies, licenses, and security implications before running or installing anything.

## Content

## Introduction

PySnooper is an incredibly useful Python debugging tool that aims to completely replace the common practice of using `print` statements for debugging. Often described as "a poor man's debugger" or "like `set -x` for Python, but fancier," PySnooper provides a detailed, play-by-play log of your function's execution. It shows which lines ran, when they ran, and precisely when local variables changed their values.

The primary advantage of PySnooper is its simplicity. Instead of carefully crafting numerous `print` lines, you just add a single decorator, `@pysnooper.snoop()`, to the function you're interested in. This makes it exceptionally easy to integrate into any existing codebase, even large and complex ones, without requiring any setup or configuration.

## Installation

Installing PySnooper is straightforward using pip:

console
$ pip install pysnooper


Other installation options include Conda, Arch Linux, and Fedora Linux, as detailed in the official repository.

## Examples

Let's see PySnooper in action. Here's an example of a function that converts a number to binary, with the `@pysnooper.snoop()` decorator applied:

python
import pysnooper

@pysnooper.snoop()
def number_to_bits(number):
    if number:
        bits = []
        while number:
            number, remainder = divmod(number, 2)
            bits.insert(0, remainder)
        return bits
    else:
        return [0]

number_to_bits(6)


When `number_to_bits(6)` is called, PySnooper outputs a detailed log to stderr, showing each line executed, the values of variables at each step, and the elapsed time.

If you only need to trace a specific part of a function, you can use PySnooper within a `with` block:

python
import pysnooper
import random

def foo():
    lst = []
    for i in range(10):
        lst.append(random.randrange(1, 1000))

    with pysnooper.snoop():
        lower = min(lst)
        upper = max(lst)
        mid = (lower + upper) / 2
        print(lower, mid, upper)

foo()


This will generate a similar detailed log, but only for the code block wrapped by `with pysnooper.snoop()`.

## Why Use PySnooper

PySnooper stands out for its ease of use and powerful features:

*   **Zero Setup**: Simply add the decorator or use a `with` block. No complex configuration files or debugger interfaces are needed.
*   **Detailed Tracing**: Get a clear view of line execution order and variable changes.
*   **Output Redirection**: Redirect the snoop output to a file, stream, or callable instead of stderr, for example: `@pysnooper.snoop('/my/log/file.log')`.
*   **Watch Expressions**: Monitor specific expressions that are not local variables, such as `foo.bar` or `self.x["whatever"]`, using `@pysnooper.snoop(watch=('foo.bar',))`.
*   **Call Depth**: Trace into functions called by your snooped function using `depth`, for example: `@pysnooper.snoop(depth=2)`.

For more advanced options and detailed usage, refer to the official documentation.

## Links

*   **GitHub Repository**: [https://github.com/cool-RR/PySnooper](https://github.com/cool-RR/PySnooper){:target="_blank"}
*   **Advanced Usage Documentation**: [https://github.com/cool-RR/PySnooper/blob/master/ADVANCED_USAGE.md](https://github.com/cool-RR/PySnooper/blob/master/ADVANCED_USAGE.md){:target="_blank"}