You can do something similar to the following, taking this sample of your data:

Copydata = {
        'x': [1539071748.0, 1539071752.0, 1539071755.0, 1539071757.0, 1539071759.0,
          1539071760.0, 1539071764.0, 1539071765.0, 1539071768.0, 1539071872.0,
          1539071979.0, 1539071998.0, 1539072006.0, 1539072123.0, 1539072137.0,
          1539072226.0, 1539072250.0, 1539072386.0, 1539072398.0, 1539072450.0,
          1539072637.0, 1539073158.0, 1539073243.0, 1539073268.0, 1539073615.0,
          1539074097.0, 1539074101.0, 1539074533.0, 1539074691.0, 1539074763.0,
          1539075159.0, 1539075623.0],
        'y': [707, 1212, 1616, 1818, 2020, 2121, 2323, 2424, 2525, 6969, 11009, 11716,
              12019, 16059, 16564, 19493, 20099, 23533, 23836, 25149, 29896, 43127,
              45147, 45753, 55045, 66761, 66862, 77467, 81204, 82921, 92718, 104434]
        }

To compute your derivative (note here that data['y_p'] will be of size n-1, therefore data['y_p'][i] is actually an approximation of the derivative at (data['x'][i] + data['x'][i+1]) / 2):

Copyimport numpy as np

data['y_p'] = np.diff(data['y']) / np.diff(data['x'])
data['x_p'] = (np.array(data['x'])[:-1] + np.array(data['x'])[1:]) / 2

Then plot your results:

Copyimport matplotlib.pyplot as plt

plt.figure(1)
plt.plot(data['x'], data['y'], 'r')
plt.plot(data['x_p'], data['y_p'], 'b')
plt.show()

Among many others, there are two following methods:

Method 1

You can use derivative from scipy that takes a function f and returns its derivative w.r.t t. So you don't have to define the derivative function f1(t) explicitly.

from scipy.misc import derivative

def f(t):
    return np.power(1 + t, n) - n * t - 1

# Rest of the code

t = np.linspace(a, b, 4000)
g = f(t)

plt.plot(t, g, 'r') # plotting t, g separately 
plt.plot(t, derivative(f, t, dx=0.001), 'g')

Method 2

You can use gradient function of NumPy which uses central differences and returns the same shape as the input array.

t, dt = np.linspace(a, b, 4000, retstep=True)
g1 = np.gradient(f(t), dt)
plt.plot(t, g1, 'g')

The Savitzky-Golay filter uses a constant delta (the spacing of the samples,) and the default value of the delta in the filter implementation is 1, according to https://docs.scipy.org/doc/scipy-0.16.1/reference/generated/scipy.signal.savgol_filter.html. Your data set has irregular deltas, not 1, so the result from the Savgol filter is incorrect.

You have a loss of significance problem. It means that when adding a large floating point number to a small one, the precision of the small one is partially lost as a numpy double can only hold 64 bits of information.

To solve this issue you have to make sure that the scale of the numbers you add/multiply/divide is not too different. One simple solution is dividing x by 1e9 or multiplying h by 1e9. If you do this you get essentially the same precision as in your example.

Also if x has high enough resolution a simpler way to numerically differentiate the function would be der = np.diff(y) / np.diff(x). This way you do not have to worry about setting h. However in this case note that dy is one element shorter that y, and dy[i] is actually an approximation of the derivative at `(x[i] + x[i+1]) / 2. So to plot it you would do:

der = np.diff(y) / np.diff(x)
x2 = (x[:-1] + x[1:]) / 2
plt.plot(x2, der, 'r', x, y, 'g', x, -np.sin(x),'b')

matplotlib.pyplot.plot requires arrays in order to plot their points, but you are passing to it a sympy object.
In order to plot sympy object, you should use sympy.plotting.plot:
(I simplified your code in order to make the point clear)

import matplotlib.pyplot as plt
from sympy.plotting import plot
import sympy as sp

x = sp.Symbol("x")
ex = 3
a = 6
expo = 2
b = 2

f = a*x**expo - b
derivative = sp.diff(f, x)

plot(derivative, ylabel = "f'(x)")

You can use df.diff().eval('y/X') to compute the derivative:

ax = df.plot(x='X', y='y')
df = df.assign(derivative=df.diff().eval('y/X'))
df.plot(x='X', y='derivative', ax=ax)

You appear to be misusing scipy.integrate.quad. This function gives the definite integral between two values. From the docs:

>>> f = lambda x,a : a*x
>>> y, err = integrate.quad(f, 0, 1, args=(1,))
>>> y
0.5

So this returns the value of the integral and the error on that value in a tuple. You are trying to plot that tuple against the x = np.arange(-10, 10, 0.01) array. Clearly the size of tuple and the array don't match, so you cannot plot the data.

If you wanted to plot a straight line at the value of the integral for all the specified X coordinates, you can use:

pyl.hlines(i[0],x[0],x[-1])