Hint: Use a recursive routine. If an operation is unary plus or minus, leave the plus or minus sign alone and continue with the operand. (That means, recursively call the derivative routine on the operand.) If an operation is addition or subtraction, leave the plus or minus sign alone and recursively find the derivative of each operand. If the operation is multiplication, use the product rule. If the operation is division, use the quotient rule. If the operation is exponentiation, use the generalized power rule. (Do you know that rule, for u ^ v? It is not given in most first-year calculus books but is easy to find using logarithmic differentiation.) (Now that you have clarified in a comment that there will be no variable in the exponent, you can use the regular power rule (u^n)' = n * u^(n-1) * u' where n is a constant.) And at the base of the recursion, the derivative of x is 1 and the derivative of a constant is zero.

The result of such an algorithm would be very un-simplified but it would meet your stated requirements. Since this algorithm looks at an operation then looks at the operands, having the expression in Polish notation may be simpler than reverse Polish or "regular expression." But you could still do it for the expression in those forms.

If you need more detail, show us more of your work.

You have four options

1. Finite Differences
2. Automatic Derivatives
3. Symbolic Differentiation
4. Compute derivatives by hand.

Finite differences require no external tools but are prone to numerical error and, if you're in a multivariate situation, can take a while.

Symbolic differentiation is ideal if your problem is simple enough. Symbolic methods are getting quite robust these days. SymPy is an excellent project for this that integrates well with NumPy. Look at the autowrap or lambdify functions or check out Jensen's blogpost about a similar question.

Automatic derivatives are very cool, aren't prone to numeric errors, but do require some additional libraries (google for this, there are a few good options). This is the most robust but also the most sophisticated/difficult to set up choice. If you're fine restricting yourself to numpy syntax then Theano might be a good choice.

Here is an example using SymPy

In [1]: from sympy import *
In [2]: import numpy as np
In [3]: x = Symbol('x')
In [4]: y = x**2 + 1
In [5]: yprime = y.diff(x)
In [6]: yprime
Out[6]: 2⋅x

In [7]: f = lambdify(x, yprime, 'numpy')
In [8]: f(np.ones(5))
Out[8]: [ 2.  2.  2.  2.  2.]

It is hard to read your code when it is so compact on one line. Is there a reason you want it so compact and hard to read (are you in a coding competition?). I would recommend to spread your code out a little, then you can easily see what to do (and others can too).

It looks like your code is not handling the constant and linear cases very well. We should also point out that a derivative is really easy if I had a list of coefficients. Maybe some functions, like:

def list_to_poly(coef_list): 
    poly_list = [] 
    if not coef_list or coef_list==[0]: 
        poly_list.append('0') 
    if len(coef_list)>=1 and coef_list[0]: 
        poly_list.append(f'{coef_list[0]}') 
    if len(coef_list)>=2 and coef_list[1]: 
        poly_list.append(f'{coef_list[1] if coef_list[1]!=1 else ""}x') 
    poly_list.extend([f'{i if i!=1 else ""}x^{j+2}' for j,i in enumerate(coef_list[2:]) if i]) 
    return ' + '.join(poly_list) 

def poly_to_list(string): 
    terms     = string.split(' + ') 
    poly_list = [] 
    for term in terms: 
        if 'x^' not in term: 
            if 'x' not in term: 
                poly_list.append(int(term)) 
            else: 
                linear_coef = term.split('x')[0] 
                poly_list.append(int(linear_coef) if linear_coef else 1) 
        else: 
            coef,exp = term.split('x^') 
            for i in range(len(poly_list),int(exp)): 
                poly_list.append(0) 
            poly_list.append(int(coef) if coef else 1) 
    return poly_list 

def derivative(string): 
    poly_list  = poly_to_list(string) 
    derivative = [i*j for i,j in enumerate(poly_list)][1:] 
    d_string   = list_to_poly(derivative) 
    return d_string 

print(derivative('0'))
print(derivative('3 + 5x'))
print(derivative('3 + x^5 + -3x^7'))

Your function fprime is not the derivative. It is a function that returns the derivative (as a Sympy expression). To evaluate it, you can use .subs to plug values into this expression:

>>> fprime(x, y).evalf(subs={x: 1, y: 1})
3.00000000000000

If you want fprime to actually be the derivative, you should assign the derivative expression directly to fprime, rather than wrapping it in a function. Then you can evalf it directly:

>>> fprime = sym.diff(f(x,y),x)
>>> fprime.evalf(subs={x: 1, y: 1})
3.00000000000000

diff is a "wrapper" method that it is going to instantiate the Derivative class. So, doing this:

from sympy import *
expr = x**2
expr.diff(x)

# out: 2*x

is equivalent to do:

Derivative(expr, x).doit()

# out: 2*x

However, the Derivative class might be useful to delay the evaluation of a derivative. For example:

Derivative(expr, x)

# out: Derivative(x**2, x)

But the same thing can also be achieved with:

expr.diff(x, evaluate=False)

# out: Derivative(x**2, x)

So, to answer your question, in the example you provided there is absolutely no difference in using diff vs Derivative.

If expr.diff(variable) can be evaluated, it will return an instance of Expr (either a symbol, a number, multiplication, addition, power operation, depending on expr). Otherwise, it will return an object of type Derivative.