PyFunctional

1.5.0 · active · verified Tue Apr 14

PyFunctional is a Python package designed for creating data pipelines using a functional programming paradigm, inspired by Scala and Spark. It provides tools for chaining operations on sequences, supporting lazy evaluation, parallel processing, and various data transformations. The current version is 1.5.0, and the project generally focuses on API stability since its 1.0.0 release.

Warnings

breaking The library was renamed from `ScalaFunctional` to `PyFunctional` in version 0.6.0. Projects using the old package name will need to update their `install_requires` and import paths.
Fix: Update `pip install scalafunctional` to `pip install pyfunctional` and change `from scalafunctional import ...` to `from functional import ...`.
breaking The behavior of `Sequence.zip_with_index` was modified in version 0.5.0. It no longer behaves as expected in previous versions and should be replaced.
Fix: Replace calls to `Sequence.zip_with_index()` with Python's built-in `enumerate()` for equivalent functionality.
gotcha Starting from version 0.3.0, all operations in PyFunctional are lazy by default. This means transformations are not executed until an action (like `reduce`, `to_list`, `to_dict`, or iteration) consumes the sequence. This can lead to unexpected behavior if intermediate results are expected to be immediately available or if debugging relies on immediate evaluation.
Fix: To force immediate evaluation for debugging or specific needs, append an action like `.to_list()` or `.to_dict()` at the point where you need the results.
gotcha For automatic parallelization of pipeline operations (e.g., `map`, `filter`), you must explicitly import and use `pseq` instead of `seq`. `seq` does not use parallel processing.
Fix: If your pipeline operations are CPU-bound and you want to leverage multiple cores, ensure your pipeline starts with `from functional import pseq` and use `pseq(...)`.

Install

pip install pyfunctional Install PyFunctional

Imports

seq
```
from functional import seq
```
Use `seq` for standard, lazy functional pipelines.
pseq
```
from functional import pseq
```
Use `pseq` for pipelines that automatically leverage parallel processing for performance.

Quickstart

This example demonstrates creating a sequence, applying common functional transformations like `map` and `filter`, and finally aggregating results with `reduce`.

from functional import seq

# Create a sequence from a range of numbers
result = seq(range(10))
    .map(lambda x: x * x) # Square each number
    .filter(lambda x: x > 10) # Keep numbers greater than 10
    .reduce(lambda x, y: x + y, 0) # Sum the remaining numbers, starting with 0

print(result)
# Expected output: 285

view raw JSON →