Styjun

I am look for a way to receive the frequency from a Signal.

Lets create an example together

signal = [numpy.sin(numpy.pi * x / 2) for x in range(1000)]

This Array will represent the sample of a recorded sound. (x = miliseconds)
sin(pi*x/2) => 250 Hrz

Now image we have no idea what the function looks like. We just got the signal (list of points. How can we receive the frequency form this array ?

Important:

I have read many Stackoverflow threads and watch many youtube videos. I am yet to find an answer. Please use simple words.
(I am Thankfull for every answer)

It seems that what you want is the Fourier Transform of the signal, from wiki:

The Fourier transform (FT) decomposes a function of time (a signal) into the frequencies that make it up

This is in essence a mathematical operation that when applied over a signal, gives you an idea of how present each frequency is in the time series. In order to get some intuition behind this, it might be helpful to look at the mathematical definition of the DFT:

Where k here is swept all the way up t N-1 to calculate all the DFT coefficients.

The first thing to notice is that, this definition resembles somewhat that of the correlation of two functions, in this case x(n) and the negative exponential function. While this may seem a little bit abstract, by using Euler's formula and by playing a bit around with the definition, the DFT can be expressed as the correlation with both a sine wave and a cosine wave, which will account for the imaginary and the real parts of the DFT.

So keeping in ming that this is in essence computing a correlation, whenever a corresponding sine or cosine from the decomposition of the complex exponential matches with that of x(n), there will be a peak in X(K), meaning that, such frequency is present in the signal.

So having given a very brief theoretical background, let's consider an example to see how this can be implemented in python. Lets consider the following signal:

Fs = 150.0; # sampling rate
Ts = 1.0/Fs; # sampling interval
t = np.arange(0,1,Ts) # time vector

ff = 50; # frequency of the signal
y = np.sin(2*np.pi*ff*t)

Now, the DFT can be computed by using np.fft.fft, which as mentioned, will be telling you which is the contribution of each frequency in the signal now in the transformed domain:

n = len(y) # length of the signal
k = np.arange(n)
T = n/Fs
frq = k/T # two sides frequency range
frq = frq[:len(frq)//2] # one side frequency range

Y = np.fft.fft(y)/n # dft and normalization
Y = Y[:n//2]

Now, if we plot the actual spectrum, you will see that we get a peak at the frequency of 50Hz, which in mathematical terms it will be a delta function centred in the fundamental frequency of 50Hz. This can be checked in the following Table of Fourier Transform Pairs.

So for the used signal, we would get:

plt.plot(frq,abs(Y)) # plotting the spectrum
plt.xlabel('Freq (Hz)')
plt.ylabel('|Y(freq)|')