Python Pipe Library

2.2 · active · verified Fri Apr 17

The `pipe` library enables a shell-like infix syntax in Python, allowing users to chain operations on iterables using the pipe (`|`) operator. It provides a functional programming style for data processing, similar to LINQ in C# or shell pipes. The current stable version is 2.2, and it follows a slow but steady release cadence, focusing on stability given its utility nature.

Common errors

```
NameError: name 'select' is not defined
```
cause Attempting to use a `pipe` function (like `select`, `where`, `take`) without explicitly importing it from the `pipe` module.

fix Add the necessary import statement: `from pipe import select` (or the specific function you are using).
```
TypeError: unsupported operand type(s) for |: 'int' and 'function'
```
cause Trying to apply a pipe operation to a non-iterable object, such as an integer, instead of a list, tuple, or generator.

fix Ensure the initial object being piped is an iterable. If you have a single value, wrap it in a list: `[my_int] | select(...)`.
```
(No output/empty result when expected)
```
cause The `pipe` operations return generators, which are lazy. If you don't explicitly consume the generator, you won't see any concrete results or side effects.

fix Call `list()`, `tuple()`, `set()`, `next()`, or iterate over the result to force evaluation: `final_data = list(initial_data | op1 | op2)`.

Warnings

gotcha Pipe operations are lazy and return generators. To get a concrete result (e.g., a list or a single value), you must explicitly consume the generator.
Fix: Wrap the final piped result in `list()`, `tuple()`, `set()`, or iterate over it: `final_list = list(my_iterable | op1 | op2)`.
gotcha The `pipe` library functions (e.g., `select`, `where`) are standalone functions that receive the iterable via the pipe operator, not methods of the iterable itself.
Fix: Always use `my_list | function_name(...)` instead of `my_list | .function_name(...)` or `my_list.function_name(...)`. Ensure you import the specific functions.
gotcha Piped operations work on iterables. Passing a non-iterable (like an integer) as the initial input or at any point in the chain where an iterable is expected will raise a TypeError.
Fix: Ensure the left-hand side of each pipe operation (`|`) is an iterable. For single values, you might wrap them in a list or tuple: `[value] | select(...)`.

Install

pip install pipe Install stable version

Imports

select
```
from pipe import select
```
where
```
from pipe import where
```
take
```
from pipe import take
```

Quickstart

This quickstart demonstrates chaining `where` (filter), `select` (map), and `take` (limit) operations on a list using the pipe syntax. It highlights that `pipe` operations are lazy and return generators, which must be explicitly consumed (e.g., by `list()`) to obtain concrete results.

from pipe import select, where, take

l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# Chain operations: filter even numbers, double them, take the first 3
result = l | where(lambda x: x % 2 == 0) | select(lambda x: x * 2) | take(3)

# The result is a generator; convert to list to see concrete values
final_list = list(result)

print(final_list)

view raw JSON →