Funcy

Warnings

• breaking When migrating from Python 2 to Python 3, `funcy` versions 0.9 and above adopted Python 3's 'iterator by default' convention for functions like `map` and `filter`. This means functions that previously returned lists might now return iterators, potentially breaking code expecting list results.
  Fix: For code expecting lists, explicitly use the `l`-prefixed versions of functions (e.g., `lmap`, `lfilter`, `lkeep`) or convert iterator results to lists (e.g., `list(map(...))`). Refer to the documentation's 'Python 3 support' section for a full list of renamed functions.
• gotcha Many Funcy functions that operate on sequences offer two versions: one that returns an iterator (e.g., `flatten`, `chunks`) and one that returns an immediate list (e.g., `lflatten`, `lchunks`). Confusing these can lead to unexpected behavior or performance issues.
  Fix: Always be mindful of the desired return type. Use the `l`-prefixed functions for concrete list results when immediate evaluation is needed, and the non-prefixed versions for lazy, iterator-based processing. Check the cheatsheet or function signatures for clarity.
• gotcha Funcy does not natively support method chaining for data transformations in the same way some other functional libraries or Pandas do. If you expect to call `funcy` functions as methods on data structures, it won't work out of the box.
  Fix: For method chaining, consider using wrapper libraries like `funcy-chain` or `funcy-pipe` if that programming style is essential. Otherwise, compose functions using nested calls or assign intermediate results to variables.
• gotcha While some older examples or quick experiments might use `from funcy import *`, this practice is discouraged for production code. Funcy is a comprehensive library, and wildcard imports can easily lead to namespace collisions and make code harder to read and debug.
  Fix: Always import specific functions you need (e.g., `from funcy import lmap, lfilter`). This improves code clarity, prevents unexpected overrides, and makes it clear which functions are being used from `funcy`.

Install

• pip install funcy Install Funcy

Imports

• lmap

  from funcy import lmap

  Prefer specific imports over `from funcy import *` to avoid namespace pollution and improve readability.
• lflatten

  from funcy import lflatten

  Many sequence-transforming functions have an `l` prefix (e.g., `lflatten`) to return a list, while the non-prefixed version (e.g., `flatten`) returns an iterator following Python 3 conventions.
• merge

  from funcy import merge

  Common utilities like `merge` for collections are available directly from the top-level `funcy` module.

Quickstart

This quickstart demonstrates core Funcy operations: `lflatten` for un-nesting collections, `lmap` and `lfilter` for transforming and selecting elements from sequences, `merge` for combining dictionaries, and `first` combined with `drop` and `count` for working with iterators.

from funcy import lmap, lfilter, lflatten, merge, first, drop, count

# Flatten a nested list
data = [1, 2, [3, 4], 5, [6, [7, 8]]]
flattened = lflatten(data)
print(f"Flattened: {flattened}")

# Map and filter a sequence
numbers = [1, 2, 3, 4, 5, 6]
even_squares = lmap(lambda x: x**2, lfilter(lambda x: x % 2 == 0, numbers))
print(f"Even squares: {even_squares}")

# Merge dictionaries
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
merged_dict = merge(dict1, dict2)
print(f"Merged dict: {merged_dict}")

# Get the Nth item from an infinite sequence using iterators
third_item = first(drop(2, count(1)))
print(f"Third item in count(1): {third_item}")