7
\$\begingroup\$

I wrote this function to flatten nested iterables (with arbitrary depth) but refrain from flattening excepted types (for instance, string or tuple):

from typing import Iterable, Tuple, Type


def flatten(item: Iterable, except_types: Type | Tuple[Type] | None = None):
    if except_types is not None and isinstance(item, except_types):
        yield item
    for element in item:
        if except_types is not None and isinstance(element, except_types):
            yield element
            continue
        try:
            yield from flatten(element, except_types)
        except TypeError:
            yield element

Therefore it works this way:

>>> list(flatten([(1, 2), [(3, 4), [(5, 6), (7, 8)]]], tuple))
[(1, 2), (3, 4), (5, 6), (7, 8)]

Could this code be made more concise and elegant, and yet easily readable?

\$\endgroup\$

1 Answer 1

Reset to default
7
\$\begingroup\$

The function fails with strings. If the input includes a str, the function hits a RecursionError. Strings are often a hassle with functions like this because even after you flatten a string once (eg, converting "foo" into a list of characters) the elements in the list are of the same iterable type that you started with, str. The bottom line is that this kind of function will need some special logic to terminate when it hits single characters.

Logic can be simplified if except_types defaults to an empty tuple. It makes the isinstance() check easier.

When writing a recursive function, resist the temptation to look ahead. You check types twice, at the start of the function and right before recursing. That's a common temptation (I saw it dozens of times in coding interviews, for example) and it almost always leads one down a more difficult path. Much better is to recurse confidently/blindly and let the function's termination checks at the start of the function do their job.

def flatten(xs, except_types = ()):
    # Terminate for except_types.
    if isinstance(xs, except_types):
        yield xs
        return

    # Terminate for single characters.
    if isinstance(xs, str) and len(xs) == 1:
        yield xs
        return

    # Terminate for non-iterable.
    try:
        it = iter(xs)
    except TypeError:
        yield xs
        return

    # Iterate and recurse with confidence.
    for x in it:
        yield from flatten(x, except_types)
\$\endgroup\$
3
  • 1
    \$\begingroup\$ Thank you, I understand. A silly doubt: why in many examples I saw online, the parameter to be flattened is called xs? \$\endgroup\$ Commented May 15, 2023 at 16:03
  • 4
    \$\begingroup\$ @VBobCat It's based on a common naming convention for situations where you don't know anything specific about the object you have. In math, for example, an unknown is often called x. If you have a collection of unknowns, you pluralize it by adding an "s" to get xs. I like the convention because it tightly links each single element x to its parent collection xs. By contrast, if we use your original name, item, for the collection, we don't have a good name to use for elements (you used element, which is OK, but it lacks the tight linkage that xs and x have with each other). \$\endgroup\$ Commented May 15, 2023 at 16:17
  • 1
    \$\begingroup\$ @FMc It seems to be better to use item/items or element/elements (for loop variable and function parameter respectively). Xs imply mathematical context (such as a list of co-ordinates), but here we operate on a higher, OOP level. \$\endgroup\$ Commented May 16, 2023 at 12:19

You must log in to answer this question.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.