Pipe: A Elegant Alternative to Nested map and filter Calls in Python

Pipe is a Python library that enables infix notation (pipes), offering a cleaner alternative to nested function calls. Here are some of the most useful methods from the Pipe library:

select and where (aliases for map and filter):

    Python’s built-in map and filter functions are powerful tools for working with iterables, allowing for efficient data transformation and filtering. However, when used together, they can lead to code that’s difficult to read due to nested function calls. For example:

    Open In Colab
    nums = [1, 2, 3, 4, 5, 6]
    
    list(
        filter(lambda x: x % 2 == 0, 
               map(lambda x: x ** 2, nums)
        )
    )
    [4, 16, 36]

    Pipe allows for a more intuitive and readable way of chaining operations:

    from pipe import select, where
    
    list(
        nums
        | select(lambda x: x ** 2)
        | where(lambda x: x % 2 == 0)
    )
    [4, 16, 36]

    In this version, the operations are read from left to right, mirroring the order in which they’re applied. The select method corresponds to map, while where corresponds to filter. This syntax not only improves readability but also makes it easier to add, remove, or reorder operations in your data processing pipeline.

    traverse:

      The traverse method recursively unfolds nested iterables, which is useful for flattening deeply nested lists:

      from pipe import traverse
      from pipe import traverse
      
      nested = [[1, 2, [3]], [4, 5]]
      flattened = list(nested | traverse)
      print(flattened) 
      [1, 2, 3, 4, 5]

      chain:

        The chain method combines multiple iterables:

        from pipe import chain
        
        result = list([[1, 2], [3, 4], [5]] | chain)
        print(result)
        [1, 2, 3, 4, 5]

        take and skip:

          These methods allow you to select or skip a specific number of elements from an iterable:

          from pipe import take, skip
          from itertools import count
          
          first_five = list(count() | take(5))
          print(first_five) 
          [0, 1, 2, 3, 4]
          skip_first_two = list([1, 2, 3, 4, 5] | skip(2))
          print(skip_first_two) 
          [3, 4, 5]

          Link to Pipe.

          Scroll to Top