Traversing Nested Lists Made Simple

A straightforward method to traverse complex nested lists is available with Pipe's traverse command. For example:

list([[1, 2], [3, 4], [5], [6, [7, 8, 9]]] | traverse)

This will output:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

Removing Duplicates

The dedup function easily eliminates duplicates from a list, whether retaining or ignoring the sign values. Here's how it works:

print("With signs: ", list([-1, 0, 0, 0, 1, 2, 3] | dedup))

print("Ignoring signs: ", list([-1, 0, 0, 0, 1, 2, 3] | dedup(key=abs)))

Output:

With signs: [-1, 0, 1, 2, 3]

Ignoring signs: [-1, 0, 2, 3]

To remove only consecutive duplicates, the uniq function can be employed:

list([1, 1, 2, 2, 3, 3, 1, 2, 3] | uniq)

The result will be:

[1, 2, 3, 1, 2, 3]

Generating Permutations

You can easily obtain all permutations of a character set using the permutations function:

list(['X', 'Y', 'Z'] | permutations(2))

Output:

[('X', 'Y'), ('X', 'Z'), ('Y', 'X'), ('Y', 'Z'), ('Z', 'X'), ('Z', 'Y')]

For strings, ensure the input is an iterable:

print("With two letters:")

for item in 'THEN' | permutations(2):

print(item)

Output:

With two letters:

('T', 'H') ('T', 'E') ('T', 'N') ('H', 'T') ('H', 'E') ('H', 'N') ('E', 'T') ('E', 'H') ('E', 'N') ('N', 'T') ('N', 'H') ('N', 'E')

Transposing Matrices

To transpose a matrix (a list of lists), use the transpose function:

list([[1, 2, 3], [4, 5, 6], [7, 8, 9]] | transpose)

This results in:

[(1, 4, 7), (2, 5, 8), (3, 6, 9)]

Applying Filter Functions to Iterables

The select function offers similar capabilities to the built-in map and filter functions. For instance, to find even numbers:

mylist = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

list(mylist | select(lambda num: num % 2 == 0))

Output:

[False, True, False, True, False, True, False, True, False, True]

Chaining operations with where enhances functionality:

list(mylist | where(lambda num: num > 5) | select(lambda num: num % 2 == 0))

Output:

[True, False, True, False, True]

Combining lists and dictionaries for specific key or value operations is also feasible by chaining functions.

Miscellaneous Functions

Pipe also includes useful functions like groupby and chain, which replicate functionalities of Python's built-in itertools:

list([[1, 2], [3, 4], [5]] | chain)

Output:

[1, 2, 3, 4, 5]

The skip function allows you to omit elements from an iterable:

list((1, 2, 3, 4, 5) | skip(2))

Output:

[3, 4, 5]

You can also employ itertools.islice as a Pipe function:

list((1, 2, 3, 4, 5, 6, 7, 8, 9) | islice(2, 8, 2))

Output:

[3, 5, 7]

For more details, refer to the official documentation.

A Few Final Thoughts

This concise overview highlights the utility of the Pipe library, which simplifies tasks that may otherwise be cumbersome with list comprehensions. However, exercise caution when applying these functions to large iterables, as performance may vary.

Feel free to experiment with custom pipe functions, and don't forget to check the GitHub documentation for further insights.

For a deeper dive, check out the video titled "Tutorial: Sebastian Witowski - Modern Python Developer's Toolkit."

Additionally, you might find the video "Python 101: Learn the 5 Must-Know Concepts" to be beneficial.