# Python Scipy Freqz [With 7 Amazing Examples]

In this Python tutorial, we will learn about the “Python Scipy Freqz” which is generally utilized to deal with analog and digital frequency. Now, to understand the use of “Python Scipy Freqz“, we will discuss the following topic with various examples.

• Python Scipy Freqz
• Python Scipy Freqz Sos
• Python Scipy Freqz Freqs
• Python Scipy Signal Freqz Zpk
• Python Scipy Signal Freqs Zpk
• Python Scipy IIR Filter Freqz
• Python Scipy Example

## Python Scipy Freqz

To compute a digital filter’s frequency response, Python Scipy has a method freqz() in a module `scipy.signal`. Determine the frequency response of a digital filter by computing its M-order numerator b and N-order denominator a.

The syntax is given below.

``scipy.signal.freqz(b, a=1, whole=False, worN=512, plot=None, include_nyquist=False, fs=6.28318530717958)``

Where parameters are:

• b(array_data): a linear filter’s numerator B.shape[1:], a.shap[1:] and the shape of the frequencies array must all be compatible for broadcasting if b has a dimension larger than 1, which is considered to be the case.
• a(array_data): Filter’s linear denominator The coefficients are assumed to be kept in the first dimension if b has a dimension larger than 1, and the shapes of b.shape[1:], a.shape[1:], and the frequencies array must all be consistent with broadcasting.
• whole(boolean): The Nyquist frequency, fs/2, is the standard range from which frequencies are calculated (upper-half of unit-circle). Do a frequency calculation from 0 to fs if the entire is True. ignored if worN is array-like.
• wordN(int, array, None): Calculate at that many frequencies if there is only one integer (the default N value is 512). This is a practical substitution for: “np.linspace(), fs if whole else fs/2, N, endpoint=include_nyquist)”. It is possible to accelerate computations by using a fast number for FFT calculations. Calculate the response at the specified frequencies if the data is array-like. These are measured in fs-compatible units.
• plot: a function call that accepts two arguments. The return parameters w and h are sent to plot if they are present. helpful for displaying the frequency response within freqz.
• include_nyquist(boolean): Include nyquist will include the most recent frequency (Nyquist frequency) if entire is False and worN is an integer; otherwise, it will be omitted.
• fs(float): the system’s sampling rate in digital form. defaults to radians/sample at 2*pi (so w is from 0 to pi).

The method `freqz()` returns `w`(The frequencies at which h was calculated, expressed in fs-compatible units. W is often normalized to the 0, pi range) and `h`(Complex numbers representing the frequency response) of type ndarray.

Let’s take an example by following the below steps:

Import the required libraries and compute a digital filter’s frequency response using the below code.

``````from scipy.signal import firwin, freqz
sig = firwin(50, 0.2, window=('kaiser', 5))
w, h = freqz(sig)

print(w,h)``````

This is how to compute a digital filter’s frequency response using the method `freqz()` of Python Scipy.

Also, check: Python Scipy Distance Matrix

## Python Scipy Freqz Sos

To calculate a digital filter’s frequency response in SOS format. The Python Scipy module `scipy.signal` has a method `sosfreqz()`.

The syntax is given below.

``scipy.signal.sosfreqz(sos, whole=False, worN=512, fs=6.283185307179586)``

Where parameters are:

• sos(array_data): A second-order filter coefficient array with the shape (n sections, 6) is required. The first three columns give the numerator coefficients and the final three give the denominator coefficients, and each row represents a second-order section.
• whole(boolean): The Nyquist frequency, fs/2, is the standard range from which frequencies are calculated (upper-half of unit-circle). Do a frequency calculation from 0 to fs if the entire is True. ignored if worN is array-like.
• wordN(int, array, None): Calculate at that many frequencies if there is only one integer (the default N value is 512). This is a practical substitution for: “np.linspace(0, fs if whole else fs/2, N, endpoint=include_nyquist)”. It is possible to accelerate computations by using a fast number for FFT calculations. Calculate the response at the specified frequencies if the data is array-like. These are measured in fs-compatible units.
• fs(float): the system’s sampling rate in digital form. defaults to radians/sample at 2*pi (so w is from 0 to pi).

Let’s take an example by following the below steps:

Import the required libraries using the below python code.

``from scipy.signal import ellip, sosfreqz``

Create an SOS-formatted 20th-order bandpass filter using the below code.

``````sos_format = ellip(20, 0.4, 70, (0.3, 0.5), btype='bandpass',
output='sos')``````

Calculate the frequency response between DC and Nyquist at 2000 points using the below code.

``````w, h = sosfreqz(sos_format, worN=2000)
print("w = {},h={}".format(w,h))
``````

This is how to calculate a digital filter’s frequency response in SOS format using the method `sosfreqz()` of Python Scipy.

## Python Scipy Freqz Freqs

To compute the analog filter’s frequency response, The Python Scipy contains a method `freqs()` in a module `scipy.signal`.

The syntax is given below.

``scipy.signal.freqs(b, a, worN=200, plot=None)``

Where parameters are:

• b(array_data): a linear filter’s numerator B.
• a(array_data): Filter’s linear denominator.
• wordN(int, array, None): If None, then calculate at 200 Hz around the interesting response curve regions (determined by pole-zero locations). If it’s a single integer, compute it at that many iterations. In any other case, calculate the response using the worN-provided angular frequencies (such as rad/s).
• plot: a function call that accepts two arguments. The return parameters w and h are sent to plot if they are present. helpful for displaying the frequency response within freqs.

## Python Scipy Signal Freqz Zpk

The Python Scipy has a method `freqz_zpk()` in a module `scipy.signal` that calculates the ZPK form of a digital filter’s frequency response.

The syntax is given below.

``scipy.signal.freqz_zpk(z, p, k, worN=512, whole=False, fs=6.283185307179586)``

Where parameters are:

• z(array_data): Filters’ zeroes in a linear.
• p(array_data): A linear filter’s poles.
• k(scalar): A linear filter’s gain
• whole(boolean): The Nyquist frequency, fs/2, is the standard range from which frequencies are calculated (upper-half of unit-circle). Do a frequency calculation from 0 to fs if the entire is True. ignored if worN is array-like.
• wordN(int, array, None): Calculate at that many frequencies if there is only one integer (the default N value is 512). This is a practical substitution for: “np.linspace(0, fs if whole else fs/2, N, endpoint=include_nyquist)”. It is possible to accelerate computations by using a fast number for FFT calculations. Calculate the response at the specified frequencies if the data is array-like. These are measured in fs-compatible units.
• fs(float): the system’s sampling rate in digital form. defaults to radians/sample at 2*pi (so w is from 0 to pi).

The method `freqz_zpk()` returns `w`(The frequencies at which h was calculated, expressed in fs-compatible units. W is often normalized to the 0, pi range) and `h`(Complex numbers representing the frequency response) of type ndarray.

Let’s take an example by creating a 1000 Hz sample rate system and a 4th-order digital Butterworth filter with a 100 Hz cutoff using the below code.

``````from scipy import signal
zeroes_filt, pole_filt, gain_filt = signal.butter(4, 100, output='zpk', fs=1000)
w, h = signal.freqz_zpk(zeroes_filt, pole_filt, gain_filt, fs=1000)
print("w = {},h={}".format(w,h))``````

This is how to compute the ZPK form of a digital filter’s frequency response using the method `freqz_zpk()` of Python Scipy.

## Python Scipy Signal Freqs Zpk

The Python Scipy has a method `freqs_zpk()` in a module `scipy.signal` that computes the analog filter’s frequency response.

The syntax is given below.

``scipy.signal.freqz_zpk(z, p, k, worN=200)``

Where parameters are:

• z(array_data): Filters’ zeroes in a linear.
• p(array_data): A linear filter’s poles.
• k(scalar): A linear filter’s gain
• wordN(int, array, None): If None, then calculate at 200 Hz around the interesting response curve regions (determined by pole-zero locations). If it’s a single integer, compute it at that many iterations. In any other case, calculate the response using the worN-provided angular frequencies (such as rad/s).

The method `freqs_zpk()` returns `w`(the angular frequencies that were used to calculate h) and `h`(the response to frequency.) of type ndarray.

Let’s take an example by following the below steps:

Import the required libraries using the below python code.

``````from scipy import signal
import numpy as np``````

Create a 5th-order analog filter, then provide the filter coefficients using the below code.

``````zeroes_filt, pole_filt, gain_filt = signal.iirfilter(5, [1, 10], 1, 50, analog=True, ftype='cheby1',
output='zpk')
w, h = signal.freqs_zpk(zeroes_filt, pole_filt, gain_filt, worN=np.logspace(-1, 2, 9000))``````

Check the result returned from the method `freqs_zpk()` using the below code.

``print("w = {},h={}".format(w,h))``

This is how to use the method `freqs_zpk()` of Python Scipy to compute the analog filter’s frequency response.

## Python Scipy IIR Filter Freqz

We have learned about the method `freqz()` in the above sub-section, here we will design the filter using the method iirfilter() and the result from this to a method `freqz()` to compute a digital filter’s frequency response.

Let’s take an example by following the below steps:

Import the required libraries using the below python code.

``````import numpy as np
from scipy.signal import iirfilter, freqz``````

Create a 50 Hz–200 Hz 15th-order Chebyshev II analogue bandpass filter using the below code.

``````b, a = iirfilter(15, [2*np.pi*50, 2*np.pi*200], rs=50,
btype='band', analog=True, ftype='cheby2')``````

Now compute a digital filter’s frequency response using the below code.

``````w, h = freqz(b, a, 1000)
print("w = {},h={}".format(w,h))``````

This is how to use the `iirfilter()` results with the method `freqz()` of Python Scipy to compute the digital filter’s frequency response.

## Python Scipy Freqz Example

We already know about the method `freqz()` of Python Scipy. Here in this section, we will do one more example related to the digital filter’s frequency response.

Let’s take an example by following the below steps:

Import the required libraries using the below python code.

``````from scipy.signal import iirfilter, freqz
import numpy as np``````

Create a 40 Hz–150 Hz 10th-order Chebyshev II analog bandpass filter using the below code.

``````b, a = iirfilter(15, [2*np.pi*50, 2*np.pi*200], rs=50,
btype='band', analog=True, ftype='cheby2')``````

Now compute a digital filter’s frequency response using the below code.

``````w, h = freqz(b, a, 1000)
print("w = {},h={}".format(w,h))``````