Finding all divisors of an integer
Lazy generators

Most often in Python you do not want to build an actual list and return it.

If I want to sum the divisors of a number, and there are many, I will waste a lot of space if I put them in a list first.

Also, not creating a list is even shorter, you just give out the elements one by one from the function:

def factorize(n):
    for item in primes_list:
        if item &gt; n:
            break
        else:
            while n &gt; 1:
                if n % item == 0:
                    n //= item
                    yield item
                else:
                    break


Reduce nesting

You got some serious nesting going on, each level of nesting is a level of complexity so getting it a bit down is positive. Luckily if we break we do not need an else: the code after will not be executed anyway:

def factorize(n):
    for item in primes_list:
        if item &gt; n:
            break

        while n &gt; 1:
            if n % item != 0:
                break
            n //= item
            yield item


Still two nested loops, but the situation is becoming more manageable.

Now let me re-factor the while loop away:

def how_many_times_divides(n, div):
    """
    &gt;&gt;&gt; list(how_many_times_divides(40, 2))
    [2, 2, 2]
    """
    while n &gt; 1:
        if n % div != 0:
            break
        n //= div
        yield div


And now factorize is starting to look nice and small:

def factorize(n):
    """
    &gt;&gt;&gt; list(factorize(480))
    [2, 2, 2, 2, 2, 3, 5]
    """
    for item in primes_list:
        if item &gt; n:
            break
        yield from how_many_times_divides(n, item)


Doctests

You may have noted that I added some examples of usage in the doc-strings of this functions. They are actually automatically runnable with doctests and I highly recommend them when writing numerical code.

Avoid unnecessary assignments &amp; mutation

It is just simpler to return the expression:

combination_product = list(functools.reduce(operator.mul, i)
                           for i in unique_combinations)
combination_product.sort()

return combination_product


Becomes:

return sorted(functools.reduce(operator.mul, i)
                 for i in unique_combinations)


Note that I omitted list as it was not really needed.