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[1],h[1])

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.

Read: Python Scipy Exponential

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.

Read: Python Scipy Chi-Square Test 

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.

Read: Python Scipy FFT

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.

Read: Scipy Linalg – Helpful Guide

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.

Read: Scipy Stats Zscore + Examples

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))

Also, take a look at some more Python Scipy tutorials.

• Scipy Signal – Helpful Tutorial
• Python Scipy Mann Whitneyu
• Scipy Integrate + Examples
• Scipy Stats – Complete Guide
• Scipy Sparse – Helpful Tutorial
• Scipy Optimize – Helpful Guide
• Python Scipy Stats Multivariate_Normal

So, in this tutorial, we have learned about the “Python Scipy Freqz” and covered the following topics.

• 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