Higher order functions in Python using reduce technique For the below query, show that both summation and product are
  instances of a more general function, called accumulate, with the
  following signature:

def accumulate(combiner, start, n, term):
    """Return the result of combining the first n terms in a sequence."""
    "*** YOUR CODE HERE ***"

  
  Accumulate takes as arguments the same arguments term and n as
  summation and product, together with a combiner function (of two
  arguments) that specifies how the current term is to be combined with
  the accumulation of the preceding terms and a start value that
  specifies what base value to use to start the accumulation. Implement
  accumulate and show how summation and product can both be defined as
  simple calls to accumulate:

def summation_using_accumulate(n, term):
    """An implementation of summation using accumulate.

    &gt;&gt;&gt; summation_using_accumulate(4, square)
    30
    """
    "*** YOUR CODE HERE ***"

def product_using_accumulate(n, term):
    """An implementation of product using accumulate.

    &gt;&gt;&gt; product_using_accumulate(4, square)
    576
    """
    "*** YOUR CODE HERE ***"



Below is the solution:

    from operator import mul, add


def accumulate(combiner, start, n, f):
    """Return the result of combining the first n terms in a sequence."""

    total = start           #Result of summation gets stored here
    i = 1                   #Initial value of sequence
    while i &lt;= n:
        total = combiner(total, f(i))
        i = i + 1
    return total


def summation_using_accumulate(n, f):
    """An implementation of summation using accumulate.

    &gt;&gt;&gt; summation_using_accumulate(4, square)
    30
    """
    return accumulate(add, 0, n, f)



def product_using_accumulate(n, f):
    """An implementation of product using accumulate.

    &gt;&gt;&gt; product_using_accumulate(4, square)
    576
    """
    return accumulate(mul, 1, n, f)


def square(x):
    return mul(x, x)

print("product_using_accumulate: ",product_using_accumulate(4, square))
print("summation_using_accumulate: ",summation_using_accumulate(4, square))
print(accumulate(add, 0, 4, square)) 
print(accumulate(mul, 1, 4, square))


I have tested this code and looks good to me.

My questions:


Does the solution look incorrect in any aspect?
Any feedback on naming conventions?
Any feedback on coding style?
If a homework problem starts with the words "Show that", I would expect the answer to contain a proof (or at least an argument), not just an implementation.
You've misunderstood the problem statement. It says that start "specifies what value to use to start the accumulation", but in your implementation, start is the index of the first item in the sequence to contribute to the accumulation. Both of the test cases have start=1 and f(1)=1 so they are incapable of detecting your mistake.
Your implementations of summation_using_accumulate and product_using_accumulate do not actually use accumulate!