Clean up Python function with too many if/else statements

A data-oriented function should return data or raise an exception, not print. If there are no matching stacks, just return an empty list or raise.

Establish a habit of defining regular expressions with raw strings. If you always define regex patterns with raw strings, you never have to waste time thinking about whether your pattern contains things like \n, \t, and so forth. This is one example of a preemptive strategy to avoid silly bugs. Efficient developers have many habits like this.

Instead of checking everything at once, apply multiple filtering passes. Your current strategy sets up all of the conditional logic branches based on the environment and the presence/absence of account_ids and then writes the complete loop for each branch. That's a lot of code and it imposes a high mental cost on the reader who must try to discern small differences between each branch. But that's not necessary. If you break the process down into phases, everything simplifies: first filter by environment, and then filter by account IDs. Notice also that this reorganization of the code has the benefit of laying the groundwork should you decide in the future to put environment-filtering and account-id-filtering in separate functions (for example, if the filtering logic in one or both becomes more complex).

Organize code in commented paragraphs. As illustrated below, a few simple comments -- especially if they focus on strategy or purpose -- can help future readers navigate the code. The most likely future reader is you.

import re

def filter_stacks(stacks, environment, account_ids):
    # Determine whether the environment is nonprod.
    nonprod_rgx = re.compile(r'non-?prod')
    env_is_nonprod = bool(nonprod_rgx.match(environment))

    # Filter based on environment.
    if re.compile(r'all').match(environment):
        to_update = stacks
    else:
        to_update = [
            s
            for s in stacks
            if env_is_nonprod is bool(nonprod_rgx.search(s['StackName']))
        ]

    # Optionally filter based on account_ids.
    if account_ids:
        return [s for s in to_update if s['AccountId'] in account_ids]
    else:
        return to_update

According to your code the first optimization that came to my mind is to group your if statements by the variable accounts_ids like the next example

    if accounts_ids:
        if non_prod_regex.match(environment):
            do....
        elif re.compile("all").match(environment):
            do....
        else:
            do...
    else:
        if non_prod_regex.match(environment):
            do....
        elif re.compile("all").match(environment):
            stacks_to_update = stacks
        else:
            do....

That will make the code a bit more readable, however when there is multiple if statements my recommendation is that you use a Visitor pattern to solve the problem. Hope it helps to clarify

As other answers already pointed out, you should not compile call re.compile several times, and there is no need to try to filter according to all filters at the same time.

I would go even further and suggest to use iterators, which are great tools in Python. It would allow you to write a single function per filter, and apply a bunch of function to each stack in a single iteration.

I would also suggest to type your code, which makes any review process easier.

Here is a suggestion that will work only in python 3.8+ (due to functools.cached_property usage):

import re
from functools import cached_property
from typing import (
    Any,
    Iterable,
    Iterator,
    List,
    Pattern,
    TypeVar,
    Mapping,
)


class Patterns:
    """Wrapper regex patterns into cached properties"""

    @cached_property
    def NON_PROD(self) -> Pattern[str]:
        return re.compile(r"non-?prod")

    @cached_property
    def ALL(self) -> Pattern[str]:
        return re.compile(r"all")


# Create a global instance that can be used accross the module
PATTERNS = Patterns()


def account_ids_filter(stack: Mapping[str, Any], account_ids: List[str]) -> bool:
    """Return True is stack account ID is present in list of accoutn IDs"""
    return stack["AccountId"] in account_ids


def environment_filter(stack: Mapping[str, Any], environment: str) -> bool:
    """Return True if stack matches environment else False"""
    env_is_non_prod = True if PATTERNS.NON_PROD.match(environment) else False
    return env_is_non_prod is bool(PATTERNS.NON_PROD.search(stack["StackName"]))


# Whatever type is going into filter_stacks will also come out from filter_stacks
StackT = TypeVar("StackT", bound=Mapping[str, Any])

def filter_stacks(
    stacks: Iterable[StackT],
    environment: str,
    account_ids: List[str],
) -> Iterator[StackT]:
    """Returns an iterator of filtered stacks"""
    # Return early in case "all" pattern matches
    if PATTERNS.ALL.match(environment):
        return iter(stacks)

    # Iterate through stacks
    for stack in stacks:
        # Filter using environment
        if not environment_filter(stack, environment):
            continue
        # Filter using account IDs
        if not account_ids_filter(stack, account_ids):
            continue
        yield stack


def get_filtered_stacks(
    stacks: Iterable[StackT], environment: str, account_ids: List[str]
) -> List[StackT]:
    """Returns a list of filtered stacks"""
    return list(filter_stacks(stacks, environment=environment, account_ids=account_ids))

Because we're working with iterators, the input stacks argument is iterated on once only.

Moreover, regexp patterns are stored as cached properties on a global variable so that they are generated lazily (on first call, and not at module import)

If you filters grow more complex, you can write more filter functions, unit test them easily, and call them in the filter_stacks function