Getting all combinations of an array by looping through binary numbers

Format

Modern Python often uses f-strings for formatting, it also has specification for binary format, this means that:

binary_indexes = ("{:0" + str(len(array)) + "d}").format(int(str(bin(i))[2:]))

Becomes:

binary_indexes = f"{i:0{len(array)}b}"

As brought up by Peter Cordes in the comments, if you want to be able to extract the bits of a number, it might be better to use something like:

def bits(n, length=None):
    if length is None:
        length = n.bit_length()

    for _ in range(length):
        yield n & 1
        n = n >> 1

Which yields the bits (little-endian style, though since you're doing combinations this is not an issue)

Comprehensions

Instead of building a list in a loop, it is often much more efficient to use list comprehensions to construct lists, they allow for multiple loops and predicates. It's also often better to loop over objects themselves rather than indexing repeatedly

        current_combination = []
        for j in range(len(binary_indexes)):
            if binary_indexes[j] == "1":
                current_combination.append(array[j])

becomes

        current_combination = [array[j] for j, ind in enumerate(binary_indexes)
                               if ind == "1"]

Or better

        current_combination = [elem for elem, ind in zip(array, binary_indexes)
                               if ind == "1"]

If using the bits method above, this might become:

        current_combination = [elem for elem, bit in zip(array, bits(i, len(array)))
                               if bit]

Generators

You mention not wanting to wait until all combinations are generated. Python provides a tool for this called generators.

Generators can be a little confusing at first, the way they are constructed, they look like functions (or list comprehensions), but they behave subtly differently. When they yield a value they pause, storing whatever state's still there and on the next call, they run until they hit the next yield. They do not store their history! So you can't wind them back, so once they've gone past a value it's gone and they can exhaust (run out of values to return) which usually results in StopIteration being raised as an error (for loops handle this automatically for you).

You can build lists from generators, or iterate over them as iterables in a loop. In your case, your function becomes:

def binary_combinations(array):
    total_combinations = 2 ** len(array) - 1

    for i in range(total_combinations + 1):
        binary_indexes = f"{i:0{len(array)}b}"
        current_combination = [elem for elem, ind in zip(array, binary_indexes)
                               if ind == "1"]

        yield current_combination

We can then call this by saying:

for comb in binary_combinations([1, 2, 3, 4]):
    print(comb)

or if we need a list

x = list(binary_combinations([1, 2, 3, 4]))

or

x = [comb for comb in binary_combinations([1, 2, 3, 4]) if predicate]

or

x = binary_combinations([1, 2, 3, 4]) # This means X is a generator
first_val = next(x)
second_val = next(x)

Whatever else you want to do with it.

Using stdlib

It seems like what you're trying to do is something which already exists in the Python stdlib. The itertools module (see: itertools.combinations). If you're not implementing this as an exercise to yourself, I'd check that out along with the other components of the Python stdlib.