SciPy-1-12-中文文档-十三-

SciPy 1.12 中文文档（十三）

原文：docs.scipy.org/doc/scipy-1.12.0/index.html

scipy.signal.invresz

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.invresz.html#scipy.signal.invresz

scipy.signal.invresz(r, p, k, tol=0.001, rtype='avg')

从部分分数展开计算 b(z) 和 a(z)。

如果 M 是分子 b 的次数，N 是分母 a 的次数：

 b(z)     b[0] + b[1] z**(-1) + ... + b[M] z**(-M)
H(z) = ------ = ------------------------------------------
        a(z)     a[0] + a[1] z**(-1) + ... + a[N] z**(-N) 

则部分分数展开 H(z) 定义为：

 r[0]                   r[-1]
= --------------- + ... + ---------------- + k[0] + k[1]z**(-1) ...
  (1-p[0]z**(-1))         (1-p[-1]z**(-1)) 

如果存在重复的根（距离小于tol），则部分分数展开式会有如下项：

 r[i]              r[i+1]                    r[i+n-1]
-------------- + ------------------ + ... + ------------------
(1-p[i]z**(-1))  (1-p[i]z**(-1))**2         (1-p[i]z**(-1))**n 

此函数用于 z 的负幂次多项式，例如 DSP 中的数字滤波器。对于正幂次，请使用 invres。

参数：

rarray_like

与极点对应的残差。对于重复的极点，残差必须按幂升序排列。

parray_like

极点。相等的极点必须相邻。

karray_like

直接多项式项的系数。

tolfloat，可选

两个根被视为相等的公差。默认为 1e-3。有关详细信息，请参见 unique_roots。

rtype，可选

用于计算代表一组相同根的根的方法。默认为‘avg’。有关详细信息，请参见 unique_roots。

返回：

bndarray

分子多项式系数。

andarray

分母多项式系数。

另请参阅

residuez, unique_roots, invres

scipy.signal.BadCoefficients

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.BadCoefficients.html#scipy.signal.BadCoefficients

exception scipy.signal.BadCoefficients

关于条件不佳的滤波器系数的警告

with_traceback()

Exception.with_traceback(tb) – 设置 self.traceback 为 tb 并返回 self。

scipy.signal.abcd_normalize

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.abcd_normalize.html#scipy.signal.abcd_normalize

scipy.signal.abcd_normalize(A=None, B=None, C=None, D=None)

检查状态空间矩阵，并确保它们是二维的。

如果提供了关于系统的足够信息，即通过传递足够适当形状的数组到函数中，缺失的数组将从这些信息中构建，确保正确的行数和列数。否则会引发 ValueError。

参数：

A, B, C, Darray_like，可选

状态空间矩阵。所有矩阵默认为 None（缺失）。查看ss2tf 的格式。

返回：

A, B, C, Darray

适当形状的状态空间矩阵。

引发：

ValueError

如果没有提供关于系统的足够信息。

scipy.signal.band_stop_obj

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.band_stop_obj.html#scipy.signal.band_stop_obj

scipy.signal.band_stop_obj(wp, ind, passb, stopb, gpass, gstop, type)

阻带目标函数以减少阶数。

返回模拟带阻滤波器的非整数阶数。

参数：

wpscalar

通带passb的边缘。

indint，{0, 1}

指定要变化的passb边缘的索引（0 或 1）。

passbndarray

两个固定通带边缘的二元序列。

stopbndarray

两个固定阻带边缘的二元序列。

gstopfloat

阻带中的衰减量（以 dB 为单位）。

gpassfloat

通带中的波动量（以 dB 为单位）。

type

滤波器类型。

返回：

nscalar

滤波器阶数（可能是非整数）。

scipy.signal.besselap

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.besselap.html#scipy.signal.besselap

scipy.signal.besselap(N, norm='phase')

返回 N 阶 Bessel 滤波器的模拟原型 (z,p,k)。

参数:

Nint

滤波器的阶数。

norm, 可选项

频率归一化:

phase

该滤波器经过归一化处理，使得相位响应在角（例如，rad/s）截止频率为 1 时达到其中点。这适用于低通和高通滤波器，因此这是“相位匹配”的情况。[6]

幅度响应渐近线与具有相同阶数和截止频率 Wn 的 Butterworth 滤波器相同。

这是默认设置，并与 MATLAB 的实现相匹配。

delay

该滤波器经过归一化处理，使得通带中的群延迟为 1 (例如，1 秒)。这是通过解 Bessel 多项式得到的“自然”类型

mag

该滤波器经过归一化处理，使得在角频率为 1 时，增益幅度为 -3 dB。这被 Bond 称为“频率归一化” [1]

新版本 0.18.0 中新增内容。

返回:

zndarray

传递函数的零点。始终为空数组。

pndarray

传递函数的极点。

kscalar

传递函数的增益。对于相位归一化，这总是 1。

另请参见

bessel

使用此原型进行滤波器设计函数

注释

要找到极点位置，首先生成普通 Bessel 多项式零点的近似起始点 [2]，然后使用 Aberth-Ehrlich 方法 [4] [5] 对 Kv(x) Bessel 函数进行更精确的零点计算，然后将这些位置倒置到单位圆上。

参考文献

[1]

C.R. Bond, “Bessel 滤波器常数”, www.crbond.com/papers/bsf.pdf

[2]

Campos 和 Calderon, “Bessel 多项式零点的近似闭式公式”, arXiv:1105.0957.

[3]

Thomson, W.E., “具有最大平坦频率特性的延迟网络”, 电气工程师学会论文集, 第 III 部分, 1949 年 11 月, Vol. 96, No. 44, pp. 487-490.

[4]

Aberth, “同时找到多项式所有零点的迭代方法”, 计算数学, Vol. 27, No. 122, 1973 年 4 月

[5]

Ehrlich, “多项式的修改 Newton 方法”, ACM 通讯, Vol. 10, Issue 2, pp. 107-108, 1967 年 2 月, DOI:10.1145/363067.363115

[6]

Miller 和 Bohn 在 1998 年发表了题为“A Bessel Filter Crossover, and Its Relation to Others”的论文，《RaneNote 147》，www.ranecommercial.com/legacy/note147.html。

scipy.signal.buttap

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.buttap.html#scipy.signal.buttap

scipy.signal.buttap(N)

返回 N 阶 Butterworth 模拟原型的 (z, p, k)。

滤波器将具有 1 的角频率截止（例如，rad/s）。

另请参阅

butter

使用此原型设计滤波器功能

scipy.signal.cheb1ap

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.cheb1ap.html#scipy.signal.cheb1ap

scipy.signal.cheb1ap(N, rp)

返回第 N 阶 Chebyshev 类型 I 模拟低通滤波器的(z,p,k)。

返回的滤波器原型在通带中具有rp分贝的波纹。

该滤波器的角频率（例如 rad/s）截止频率被归一化为 1，定义为增益首次低于-rp的点。

参见

cheby1

使用该原型设计滤波器函数

scipy.signal.cheb2ap

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.cheb2ap.html#scipy.signal.cheb2ap

scipy.signal.cheb2ap(N, rs)

返回第 N 阶切比雪夫二型模拟低通滤波器的 (z, p, k)。

返回的滤波器原型在阻带中至少具有rs分贝的衰减。

滤波器的角频率截止频率（例如 rad/s）标准化为 1，定义为衰减首次达到rs的点。

另见

cheby2

使用此原型设计滤波器功能

scipy.signal.cmplx_sort

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.cmplx_sort.html#scipy.signal.cmplx_sort

scipy.signal.cmplx_sort(p)

scipy.signal.ellipap

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.ellipap.html#scipy.signal.ellipap

scipy.signal.ellipap(N, rp, rs)

返回 N 阶椭圆模拟低通滤波器的（z,p,k）。

滤波器是一个归一化的原型，通带中有rp分贝的波纹，而阻带下降rs分贝。

滤波器的角频率（例如，rad/s）截止频率被归一化为 1，即增益首次低于-rp的点。

另见

ellip

使用这种原型进行滤波器设计功能

参考文献

[1]

Lutova、Tosic 和 Evans，《信号处理滤波器设计》，第五章和第十二章。

[2]

Orfanidis，《椭圆滤波器设计讲义》，www.ece.rutgers.edu/~orfanidi/ece521/notes.pdf

scipy.signal.lp2bp

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.lp2bp.html#scipy.signal.lp2bp

scipy.signal.lp2bp(b, a, wo=1.0, bw=1.0)

将低通滤波器原型转换为带通滤波器。

返回一个模拟带通滤波器，其中心频率为wo，带宽为bw，从具有单位截止频率的模拟低通滤波器原型中获得，以传递函数（‘ba’）表示。

参数：

barray_like

分子多项式系数。

aarray_like

转换后的带通滤波器的分母多项式系数。

wofloat

所需的通带中心，作为角频率（例如，rad/s）。默认为不变。

bwfloat

所需的通带宽度，作为角频率（例如，rad/s）。默认为 1.

返回

barray_like

转换后的带通滤波器的分子多项式系数。

aarray_like

转换后的带通滤波器的分母多项式系数。

参见

lp2lp, lp2hp, lp2bs, bilinear

lp2bp_zpk

注释

这是从 s 平面替换导出的

[s \rightarrow \frac{s² + {\omega_0}²}{s \cdot \mathrm{BW}}]

这是“宽带”变换，产生以wo为中心的通带，具有几何（对数频率）关于wo的对称性。

示例

>>> from scipy import signal
>>> import matplotlib.pyplot as plt 

>>> lp = signal.lti([1.0], [1.0, 1.0])
>>> bp = signal.lti(*signal.lp2bp(lp.num, lp.den))
>>> w, mag_lp, p_lp = lp.bode()
>>> w, mag_bp, p_bp = bp.bode(w) 

>>> plt.plot(w, mag_lp, label='Lowpass')
>>> plt.plot(w, mag_bp, label='Bandpass')
>>> plt.semilogx()
>>> plt.grid(True)
>>> plt.xlabel('Frequency [rad/s]')
>>> plt.ylabel('Magnitude [dB]')
>>> plt.legend() 

scipy.signal.lp2bp_zpk

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.lp2bp_zpk.html#scipy.signal.lp2bp_zpk

scipy.signal.lp2bp_zpk(z, p, k, wo=1.0, bw=1.0)

将低通滤波器原型转换为带通滤波器。

返回一个模拟带通滤波器，其中心频率为wo，带宽为bw，来自具有单位截止频率的模拟低通滤波器原型，使用零点、极点和增益（‘zpk’）表示法。

参数：

zarray_like

模拟滤波器传递函数的零点。

parray_like

模拟滤波器传递函数的极点。

kfloat

模拟滤波器传递函数的系统增益。

wofloat

期望的通带中心，作为角频率（例如，rad/s）。默认不变。

bwfloat

期望的通带宽度，作为角频率（例如，rad/s）。默认为 1。

返回：

zndarray

转换后的带通滤波器传递函数的零点。

pndarray

转换后的带通滤波器传递函数的极点。

kfloat

转换后带通滤波器的系统增益。

另请参见

lp2lp_zpk, lp2hp_zpk, lp2bs_zpk, bilinear

lp2bp

注意

这是从 s 平面代换推导出的。

[s \rightarrow \frac{s² + {\omega_0}²}{s \cdot \mathrm{BW}}]

这是“宽带”变换，产生具有wo的频率对称的通带（对数频率）。

1.1.0 版中的新增功能。

示例

使用低通滤波器的‘zpk’（零极点增益）表示法将其转换为带通滤波器，其中心频率为 wo，带宽为 bw。

>>> from scipy.signal import lp2bp_zpk
>>> z   = [ 5 + 2j ,  5 - 2j ]
>>> p   = [ 7      ,  -16    ]
>>> k   = 0.8
>>> wo  = 0.62
>>> bw  = 15
>>> lp2bp_zpk(z, p, k, wo, bw)
(   array([7.49955815e+01+3.00017676e+01j, 7.49955815e+01-3.00017676e+01j,
 4.41850748e-03-1.76761126e-03j, 4.41850748e-03+1.76761126e-03j]), 
 array([1.04996339e+02+0.j, -1.60167736e-03+0.j,  3.66108003e-03+0.j,
 -2.39998398e+02+0.j]), 0.8) 

scipy.signal.lp2bs

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.lp2bs.html#scipy.signal.lp2bs

scipy.signal.lp2bs(b, a, wo=1.0, bw=1.0)

将低通滤波器原型转换为带阻滤波器。

从单位截止频率的模拟低通滤波器原型转换为带阻滤波器，其传递函数（'ba'表示）中心频率为wo，带宽为bw。

参数：

barray_like

转换后带阻滤波器的分子多项式系数。

aarray_like

转换后带阻滤波器的分母多项式系数。

wofloat

所需阻带中心，作为角频率（例如，rad/s）。默认为无变化。

bwfloat

所需阻带宽度，作为角频率（例如，rad/s）。默认为 1。

返回：

barray_like

转换后带阻滤波器的分子多项式系数。

aarray_like

转换后带阻滤波器的分母多项式系数。

另请参阅

lp2lp，lp2hp，lp2bp，bilinear

lp2bs_zpk

注意

这是从 s 平面替换派生出来的。

[s \rightarrow \frac{s \cdot \mathrm{BW}}{s² + {\omega_0}²}]

这是“宽带”变换，产生围绕wo具有几何（对数频率）对称性的阻带。

示例

>>> from scipy import signal
>>> import matplotlib.pyplot as plt 

>>> lp = signal.lti([1.0], [1.0, 1.5])
>>> bs = signal.lti(*signal.lp2bs(lp.num, lp.den))
>>> w, mag_lp, p_lp = lp.bode()
>>> w, mag_bs, p_bs = bs.bode(w)
>>> plt.plot(w, mag_lp, label='Lowpass')
>>> plt.plot(w, mag_bs, label='Bandstop')
>>> plt.semilogx()
>>> plt.grid(True)
>>> plt.xlabel('Frequency [rad/s]')
>>> plt.ylabel('Magnitude [dB]')
>>> plt.legend() 

scipy.signal.lp2bs_zpk

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.lp2bs_zpk.html#scipy.signal.lp2bs_zpk

scipy.signal.lp2bs_zpk(z, p, k, wo=1.0, bw=1.0)

将低通滤波器原型变换为带阻滤波器。

返回一个模拟带阻滤波器，其中心频率为wo，阻带宽度为bw，从具有单位截止频率的模拟低通滤波器原型使用零点、极点和增益（‘zpk’）表示。

参数：

zarray_like

模拟滤波器传递函数的零点。

parray_like

模拟滤波器传递函数的极点。

kfloat

模拟滤波器传递函数的系统增益。

wofloat

所需的阻带中心，作为角频率（例如，rad/s）。默认无变化。

bwfloat

所需的阻带宽度，作为角频率（例如，rad/s）。默认为 1。

返回值：

zndarray

变换后带阻滤波器传递函数的零点。

pndarray

变换后带阻滤波器传递函数的极点。

kfloat

变换后带阻滤波器的系统增益。

参见

lp2lp_zpk, lp2hp_zpk, lp2bp_zpk, bilinear

lp2bs

注意

这是从 s 平面替换推导出来的

[s \rightarrow \frac{s \cdot \mathrm{BW}}{s² + {\omega_0}²}]

这是“宽带”变换，产生一个以wo为中心频率的阻带，具有几何（对数频率）对称性。

1.1.0 版本中的新功能。

示例

将以‘zpk’（零极点增益）形式表示的低通滤波器转换为以‘zpk’形式表示的带阻滤波器，中心频率为 wo，带宽为 bw。

>>> from scipy.signal import lp2bs_zpk
>>> z   = [             ]
>>> p   = [ 0.7 ,    -1 ]
>>> k   = 9
>>> wo  = 0.5
>>> bw  = 10
>>> lp2bs_zpk(z, p, k, wo, bw)
(   array([0.+0.5j, 0.+0.5j, 0.-0.5j, 0.-0.5j]), 
 array([14.2681928 +0.j, -0.02506281+0.j,  0.01752149+0.j, -9.97493719+0.j]), 
 -12.857142857142858) 

scipy.signal.lp2hp

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.lp2hp.html#scipy.signal.lp2hp

scipy.signal.lp2hp(b, a, wo=1.0)

将低通滤波器原型变换为高通滤波器。

从具有单位截止频率的模拟低通滤波器原型转换为具有截止频率 wo 的模拟高通滤波器，以传递函数（‘ba’）表示。

参数：

barray_like

转换后的高通滤波器的分子多项式系数。

aarray_like

分母多项式系数。

wofloat

所需的截止频率，作为角频率（例如，rad/s）。默认为不变。

返回：

barray_like

转换后的高通滤波器的分子多项式系数。

aarray_like

转换后的高通滤波器的分母多项式系数。

See also

lp2lp, lp2bp, lp2bs, bilinear

lp2hp_zpk

注意事项

这是从 s 平面替换导出的。

[s \rightarrow \frac{\omega_0}{s}]

这在对数尺度上保持了低通和高通响应的对称性。

示例

>>> from scipy import signal
>>> import matplotlib.pyplot as plt 

>>> lp = signal.lti([1.0], [1.0, 1.0])
>>> hp = signal.lti(*signal.lp2hp(lp.num, lp.den))
>>> w, mag_lp, p_lp = lp.bode()
>>> w, mag_hp, p_hp = hp.bode(w) 

>>> plt.plot(w, mag_lp, label='Lowpass')
>>> plt.plot(w, mag_hp, label='Highpass')
>>> plt.semilogx()
>>> plt.grid(True)
>>> plt.xlabel('Frequency [rad/s]')
>>> plt.ylabel('Magnitude [dB]')
>>> plt.legend() 

scipy.signal.lp2hp_zpk

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.lp2hp_zpk.html#scipy.signal.lp2hp_zpk

scipy.signal.lp2hp_zpk(z, p, k, wo=1.0)

将低通滤波器原型转换为高通滤波器。

返回具有单位截止频率的模拟低通滤波器原型的模拟高通滤波器，使用零点、极点和增益（'zpk'）表示。

参数：

zarray_like

模拟滤波器传递函数的零点。

parray_like

模拟滤波器传递函数的极点。

kfloat

模拟滤波器传递函数的系统增益。

wofloat

所需截止频率，作为角频率（例如，rad/s）。默认为不变。

返回：

zndarray

转换后的模拟高通滤波器传递函数的零点。

pndarray

转换后的模拟高通滤波器传递函数的极点。

kfloat

转换后的模拟高通滤波器的系统增益。

另请参见

lp2lp_zpk, lp2bp_zpk, lp2bs_zpk, bilinear

lp2hp

注：

这是从 s 平面替换导出的。

[s \rightarrow \frac{\omega_0}{s}]

这保持了低通和高通响应在对数尺度上的对称性。

新功能版本 1.1.0 中引入。

示例

使用低通滤波器的“zpk”（零-极点-增益）表示将其转换为具有截止频率 wo 的高通滤波器。

>>> from scipy.signal import lp2hp_zpk
>>> z   = [ -2 + 3j ,  -0.5 - 0.8j ]
>>> p   = [ -1      ,  -4          ]
>>> k   = 10
>>> wo  = 0.6
>>> lp2hp_zpk(z, p, k, wo)
(   array([-0.09230769-0.13846154j, -0.33707865+0.53932584j]),
 array([-0.6 , -0.15]),
 8.5) 

scipy.signal.lp2lp

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.lp2lp.html#scipy.signal.lp2lp

scipy.signal.lp2lp(b, a, wo=1.0)

将一个低通滤波器原型转换到不同的频率。

从模拟低通滤波器原型（单位截止频率）的模拟低通滤波器返回带截止频率 wo 的传递函数（'ba'）表示。

参数：

barray_like

分子多项式系数。

aarray_like

分母多项式系数。

wofloat

期望的截止频率，作为角频率（例如 rad/s）。默认为无变化。

返回：

barray_like

被转换的低通滤波器的分子多项式系数。

aarray_like

被转换的低通滤波器的分母多项式系数。

另请参见

lp2hp，lp2bp，lp2bs，bilinear

lp2lp_zpk

注意事项

这是从 s 平面替换导出的

[s \rightarrow \frac{s}{\omega_0}]

示例

>>> from scipy import signal
>>> import matplotlib.pyplot as plt 

>>> lp = signal.lti([1.0], [1.0, 1.0])
>>> lp2 = signal.lti(*signal.lp2lp(lp.num, lp.den, 2))
>>> w, mag_lp, p_lp = lp.bode()
>>> w, mag_lp2, p_lp2 = lp2.bode(w) 

>>> plt.plot(w, mag_lp, label='Lowpass')
>>> plt.plot(w, mag_lp2, label='Transformed Lowpass')
>>> plt.semilogx()
>>> plt.grid(True)
>>> plt.xlabel('Frequency [rad/s]')
>>> plt.ylabel('Magnitude [dB]')
>>> plt.legend() 

scipy.signal.lp2lp_zpk

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.lp2lp_zpk.html#scipy.signal.lp2lp_zpk

scipy.signal.lp2lp_zpk(z, p, k, wo=1.0)

将一个低通滤波器原型转换到不同的频率。

返回一个模拟低通滤波器，其截止频率 wo 来自具有单位截止频率的模拟低通滤波器原型，使用零点、极点和增益（‘zpk’）表示。

参数：

zarray_like

模拟滤波器传递函数的零点。

parray_like

模拟滤波器传递函数的极点。

kfloat

模拟滤波器传递函数的系统增益。

wofloat

所需截止频率，作为角频率（例如，rad/s）。默认情况下无变化。

返回：

zndarray

转换后的低通滤波器传递函数的零点。

pndarray

转换后的低通滤波器传递函数的极点。

kfloat

转换后的低通滤波器的系统增益。

参见

lp2hp_zpk, lp2bp_zpk, lp2bs_zpk, bilinear

lp2lp

注意事项

这是从 s 平面替换得到

[s \rightarrow \frac{s}{\omega_0}]

版本 1.1.0 中的新功能。

示例

使用‘zpk’（零-极点-增益）表示低通滤波器，将其转换为一个新的‘zpk’表示，关联的截止频率为 wo。

>>> from scipy.signal import lp2lp_zpk
>>> z   = [7,   2]
>>> p   = [5,   13]
>>> k   = 0.8
>>> wo  = 0.4
>>> lp2lp_zpk(z, p, k, wo)
(   array([2.8, 0.8]), array([2\. , 5.2]), 0.8) 

scipy.signal.normalize

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.normalize.html#scipy.signal.normalize

scipy.signal.normalize(b, a)

规范化连续时间传递函数的分子/分母。

如果 b 的值太接近 0，则将其移除。在这种情况下，会发出 BadCoefficients 警告。

参数：

b：array_like

传递函数的分子。可以是 2-D 数组，用于规范化多个传递函数。

a：array_like

传递函数的分母。最多为 1-D。

返回：

num：数组

规范化传递函数的分子。至少是一个 1-D 数组。如果输入的 num 是 2-D 数组，则为 2-D 数组。

den：1-D 数组

规范化传递函数的分母。

注释

系数应按降幂顺序指定，分子和分母（例如，s² + 3s + 5应表示为[1, 3, 5]）。

示例

>>> from scipy.signal import normalize 

规范化传递函数的系数 (3*s² - 2*s + 5) / (2*s² + 3*s + 1)：

>>> b = [3, -2, 5]
>>> a = [2, 3, 1]
>>> normalize(b, a)
(array([ 1.5, -1\. ,  2.5]), array([1\. , 1.5, 0.5])) 

如果例如 b 的第一个系数为 0，则会生成警告。在下面的示例中，结果符合预期：

>>> import warnings
>>> with warnings.catch_warnings(record=True) as w:
...     num, den = normalize([0, 3, 6], [2, -5, 4]) 

>>> num
array([1.5, 3\. ])
>>> den
array([ 1\. , -2.5,  2\. ]) 

>>> print(w[0].message)
Badly conditioned filter coefficients (numerator): the results may be meaningless 

scipy.signal.butter

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.butter.html#scipy.signal.butter

scipy.signal.butter(N, Wn, btype='low', analog=False, output='ba', fs=None)

巴特沃斯数字和模拟滤波器设计。

设计第 N 阶数字或模拟巴特沃斯滤波器并返回滤波器系数。

参数：

N整数

滤波器的阶数。对于‘带通’和‘带阻’滤波器，所得二阶段（‘sos’）矩阵的最终阶数为2*N，其中N是所需系统的双二阶段节的数量。

Wn类似数组

临界频率或频率。对于低通和高通滤波器，Wn 为标量；对于带通和带阻滤波器，Wn 为长度为 2 的序列。

对于巴特沃斯滤波器，这是增益降到通过带的 1/sqrt(2)的点（“-3 dB 点”）。

对于数字滤波器，如果未指定fs，Wn单位被归一化为 0 到 1，其中 1 是奈奎斯特频率（Wn因此为半周期/样本，定义为 2临界频率/fs）。如果指定了fs，Wn与fs*单位相同。

对于模拟滤波器，Wn是一个角频率（例如 rad/s）。

btype，可选

滤波器类型。默认为‘低通’。

模拟布尔型，可选

当设置为 True 时，返回模拟滤波器，否则返回数字滤波器。

输出，可选

输出类型：分子/分母（‘ba’）、极点零点（‘zpk’）或二阶段（‘sos’）。默认为‘ba’以保持向后兼容性，但应用于通用滤波的‘sos’应该被使用。

fs浮点数，可选

数字系统的采样频率。

版本 1.2.0 中的新功能。

返回：

b, a数组，数组

IIR 滤波器的分子（b）和分母（a）多项式。仅在output='ba'时返回。

z, p, k数组，数组，浮点数

IIR 滤波器传递函数的零点、极点和系统增益。仅在output='zpk'时返回。

sos数组

IIR 滤波器的二阶段表示。仅在output='sos'时返回。

另请参见

buttord，buttap

注释

巴特沃斯滤波器在通过带中具有最大平坦频率响应。

'sos'输出参数于 0.16.0 中添加。

如果请求传递函数形式[b, a]，则可能会出现数值问题，因为在 N >= 4 的情况下，根和多项式系数之间的转换是一种数值敏感的操作。建议使用 SOS 表示。

警告

在 TF 形式中设计高阶和窄带 IIR 滤波器可能由于浮点数精度问题导致不稳定或不正确的滤波。考虑检查输出滤波器特性 freqz 或通过 output='sos' 设计二阶段滤波器。

示例

设计一个模拟滤波器并绘制其频率响应图，显示关键点：

>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> import numpy as np 

>>> b, a = signal.butter(4, 100, 'low', analog=True)
>>> w, h = signal.freqs(b, a)
>>> plt.semilogx(w, 20 * np.log10(abs(h)))
>>> plt.title('Butterworth filter frequency response')
>>> plt.xlabel('Frequency [radians / second]')
>>> plt.ylabel('Amplitude [dB]')
>>> plt.margins(0, 0.1)
>>> plt.grid(which='both', axis='both')
>>> plt.axvline(100, color='green') # cutoff frequency
>>> plt.show() 

生成一个由 10 Hz 和 20 Hz 组成、1 kHz 采样的信号

>>> t = np.linspace(0, 1, 1000, False)  # 1 second
>>> sig = np.sin(2*np.pi*10*t) + np.sin(2*np.pi*20*t)
>>> fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True)
>>> ax1.plot(t, sig)
>>> ax1.set_title('10 Hz and 20 Hz sinusoids')
>>> ax1.axis([0, 1, -2, 2]) 

设计一个数字高通滤波器，在 15 Hz 处去除 10 Hz 的分量，并将其应用于信号。（建议在滤波时使用二阶段格式，避免传递函数 (ba) 格式的数值误差）：

>>> sos = signal.butter(10, 15, 'hp', fs=1000, output='sos')
>>> filtered = signal.sosfilt(sos, sig)
>>> ax2.plot(t, filtered)
>>> ax2.set_title('After 15 Hz high-pass filter')
>>> ax2.axis([0, 1, -2, 2])
>>> ax2.set_xlabel('Time [seconds]')
>>> plt.tight_layout()
>>> plt.show() 

scipy.signal.buttord

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.buttord.html#scipy.signal.buttord

scipy.signal.buttord(wp, ws, gpass, gstop, analog=False, fs=None)

巴特沃斯滤波器阶数选择。

返回损失不超过gpass dB 的通带和阻带至少gstop dB 衰减的最低阶数字或模拟巴特沃斯滤波器的阶数。

参数：

wp, wsfloat

通带和阻带边缘频率。

对于数字滤波器，这些单位与fs相同。默认情况下，fs为 2 个半周期/样本，因此这些单位在 0 到 1 之间归一化，其中 1 为奈奎斯特频率。因此，wp和ws以半周期/样本计。例如：

• 低通：wp = 0.2，ws = 0.3
• 高通：wp = 0.3，ws = 0.2
• 带通：wp = [0.2, 0.5]，ws = [0.1, 0.6]
• 带阻：wp = [0.1, 0.6]，ws = [0.2, 0.5]

对于模拟滤波器，wp和ws是角频率（例如，rad/s）。

gpassfloat

通带中的最大损失（dB）。

gstopfloat

阻带中的最小衰减（dB）。

analogbool，可选

当为 True 时，返回模拟滤波器，否则返回数字滤波器。

fsfloat，可选

数字系统的采样频率。

自 1.2.0 版本新增。

返回：

ordint

满足规格的最低巴特沃斯滤波器阶数。

wnndarray 或 float

巴特沃斯自然频率（即“3dB 频率”）。应与butter一起使用以提供滤波器结果。如果指定了fs，则单位相同，同时必须将fs传递给butter。

参见：

butter

使用阶数和关键点进行滤波器设计

cheb1ord

从通带和阻带规格中查找阶数和关键点

cheb2ord，ellipord

iirfilter

使用阶数和关键频率进行一般滤波器设计

iirdesign

使用通带和阻带规格进行一般滤波器设计

示例

设计一个模拟带通滤波器，通带内从 20 到 50 rad/s 的损失不超过 3 dB，同时在 14 rad/s 以下和 60 rad/s 以上至少有-40 dB 的衰减。绘制其频率响应图，显示通带和阻带约束为灰色。

>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> import numpy as np 

>>> N, Wn = signal.buttord([20, 50], [14, 60], 3, 40, True)
>>> b, a = signal.butter(N, Wn, 'band', True)
>>> w, h = signal.freqs(b, a, np.logspace(1, 2, 500))
>>> plt.semilogx(w, 20 * np.log10(abs(h)))
>>> plt.title('Butterworth bandpass filter fit to constraints')
>>> plt.xlabel('Frequency [radians / second]')
>>> plt.ylabel('Amplitude [dB]')
>>> plt.grid(which='both', axis='both')
>>> plt.fill([1,  14,  14,   1], [-40, -40, 99, 99], '0.9', lw=0) # stop
>>> plt.fill([20, 20,  50,  50], [-99, -3, -3, -99], '0.9', lw=0) # pass
>>> plt.fill([60, 60, 1e9, 1e9], [99, -40, -40, 99], '0.9', lw=0) # stop
>>> plt.axis([10, 100, -60, 3])
>>> plt.show() 

scipy.signal.cheby1

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.cheby1.html#scipy.signal.cheby1

scipy.signal.cheby1(N, rp, Wn, btype='low', analog=False, output='ba', fs=None)

Chebyshev 类型 I 数字和模拟滤波器设计。

设计 N 阶数字或模拟 Chebyshev 类型 I 滤波器并返回滤波器系数。

参数：

N整数

滤波器的阶数。

rp浮点数

允许通过通带下方的最大纹波。以分贝为单位，作为正数。

Wn数组类型

一个标量或长度为 2 的序列，给出关键频率。对于类型 I 滤波器，这是在增益首次降至-rp的过渡带中的点。

对于数字滤波器，Wn与fs具有相同的单位。默认情况下，fs为每样本 2 个半周期，因此这些被归一化为 0 到 1，其中 1 为奈奎斯特频率。 （Wn因此在半周期/样本中。）

对于模拟滤波器，Wn是角频率（例如，rad/s）。

btype，可选

滤波器的类型。默认为‘低通’。

analog布尔型，可选

当为 True 时，返回模拟滤波器，否则返回数字滤波器。

output，可选

输出类型：分子/分母（‘ba’），极点-零点（‘zpk’）或二阶段（‘sos’）。默认为‘ba’以保持向后兼容性，但一般用于过滤的‘sos’应该使用。

fs浮点数，可选

数字系统的采样频率。

新版本 1.2.0 中新增。

返回：

b, a数组，数组

IIR 滤波器的分子（b）和分母（a）多项式。仅在output='ba'时返回。

z, p, k数组，数组，浮点数

IIR 滤波器传递函数的零点、极点和系统增益。仅在output='zpk'时返回。

sos数组

IIR 滤波器的二阶段表示。仅在output='sos'时返回。

另请参阅

cheb1ord，cheb1ap

注意事项

Chebyshev 类型 I 滤波器在频率响应的通带和阻带之间的切换速率最大化，但代价是通带中的纹波增加和阶跃响应中的增加振荡。

类型 I 滤波器比类型 II 滤波器（cheby2）更快地衰减，但类型 II 滤波器在通带中没有任何纹波。

均波通带有 N 个最大或最小值（例如，5 阶滤波器具有 3 个最大值和 2 个最小值）。因此，奇数阶滤波器的直流增益为单位，偶数阶滤波器为-rp dB。

'sos'输出参数在 0.16.0 中添加。

示例

设计模拟滤波器并绘制其频率响应图，显示关键点：

>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> import numpy as np 

>>> b, a = signal.cheby1(4, 5, 100, 'low', analog=True)
>>> w, h = signal.freqs(b, a)
>>> plt.semilogx(w, 20 * np.log10(abs(h)))
>>> plt.title('Chebyshev Type I frequency response (rp=5)')
>>> plt.xlabel('Frequency [radians / second]')
>>> plt.ylabel('Amplitude [dB]')
>>> plt.margins(0, 0.1)
>>> plt.grid(which='both', axis='both')
>>> plt.axvline(100, color='green') # cutoff frequency
>>> plt.axhline(-5, color='green') # rp
>>> plt.show() 

生成一个由 10 Hz 和 20 Hz 组成的信号，采样频率为 1 kHz

>>> t = np.linspace(0, 1, 1000, False)  # 1 second
>>> sig = np.sin(2*np.pi*10*t) + np.sin(2*np.pi*20*t)
>>> fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True)
>>> ax1.plot(t, sig)
>>> ax1.set_title('10 Hz and 20 Hz sinusoids')
>>> ax1.axis([0, 1, -2, 2]) 

设计一个数字高通滤波器，在 15 Hz 处去除 10 Hz 的音调，并将其应用到信号中。（在滤波时建议使用二阶段格式，以避免使用传递函数（ba）格式时的数值误差）：

>>> sos = signal.cheby1(10, 1, 15, 'hp', fs=1000, output='sos')
>>> filtered = signal.sosfilt(sos, sig)
>>> ax2.plot(t, filtered)
>>> ax2.set_title('After 15 Hz high-pass filter')
>>> ax2.axis([0, 1, -2, 2])
>>> ax2.set_xlabel('Time [seconds]')
>>> plt.tight_layout()
>>> plt.show() 

scipy.signal.cheb1ord

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.cheb1ord.html#scipy.signal.cheb1ord

scipy.signal.cheb1ord(wp, ws, gpass, gstop, analog=False, fs=None)

切比雪夫 I 型滤波器阶数选择。

返回数字或模拟切比雪夫 I 型滤波器的最低阶数，其在通带内不超过gpass dB 的损失，并且在阻带至少有gstop dB 的衰减。

参数：

wp, wsfloat

通带和阻带的边缘频率。

对于数字滤波器，这些单位与fs相同。默认情况下，fs是每样本 2 个半周期，因此这些单位归一化为 0 到 1，其中 1 是奈奎斯特频率。 (wp和ws因此在半周期/样本中。) 例如：

• 低通：wp = 0.2, ws = 0.3
• 高通：wp = 0.3, ws = 0.2
• 带通：wp = [0.2, 0.5], ws = [0.1, 0.6]
• 带阻：wp = [0.1, 0.6], ws = [0.2, 0.5]

对于模拟滤波器，wp和ws是角频率（例如，rad/s）。

gpassfloat

通带内的最大损失（dB）。

gstopfloat

阻带中的最小衰减（dB）。

analogbool, optional

如果为 True，则返回模拟滤波器，否则返回数字滤波器。

fsfloat, optional

数字系统的采样频率。

1.2.0 版本的新功能。

返回：

ordint

满足规格的切比雪夫 I 型滤波器的最低阶数。

wnndarray 或 float

切比雪夫自然频率（“3 dB 频率”），用于与cheby1一起提供滤波器结果。如果指定了fs，则以相同的单位表示，必须同时传递给cheby1。

另请参见

cheby1

使用通带和阻带规格进行滤波器设计

buttord

从通带和阻带规格中找到阶数和关键点

cheb2ord, ellipord

iirfilter

使用阶数和关键频率进行通用滤波器设计。

iirdesign

使用通带和阻带规格查找阶数和关键点

示例

设计数字低通滤波器，使其通带在 0.2(fs/2)内保持在 3 dB 以内，同时在 0.3(fs/2)以上至少拒绝-40 dB。在灰色中显示其频率响应曲线，展示通带和阻带的限制。

>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> import numpy as np 

>>> N, Wn = signal.cheb1ord(0.2, 0.3, 3, 40)
>>> b, a = signal.cheby1(N, 3, Wn, 'low')
>>> w, h = signal.freqz(b, a)
>>> plt.semilogx(w / np.pi, 20 * np.log10(abs(h)))
>>> plt.title('Chebyshev I lowpass filter fit to constraints')
>>> plt.xlabel('Normalized frequency')
>>> plt.ylabel('Amplitude [dB]')
>>> plt.grid(which='both', axis='both')
>>> plt.fill([.01, 0.2, 0.2, .01], [-3, -3, -99, -99], '0.9', lw=0) # stop
>>> plt.fill([0.3, 0.3,   2,   2], [ 9, -40, -40,  9], '0.9', lw=0) # pass
>>> plt.axis([0.08, 1, -60, 3])
>>> plt.show() 

scipy.signal.cheby2

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.cheby2.html#scipy.signal.cheby2

scipy.signal.cheby2(N, rs, Wn, btype='low', analog=False, output='ba', fs=None)

Chebyshev type II 数字和模拟滤波器设计。

设计一个 N 阶数字或模拟 Chebyshev type II 滤波器并返回滤波器系数。

参数：

Nint

滤波器的阶数。

rsfloat

在停止带中所需的最小衰减。以分贝表示，作为正数。

Wn array_like

一个标量或长度为 2 的序列，给出关键频率。对于 Type II 滤波器，这是增益首次达到 -rs 的过渡带中的点。

对于数字滤波器，Wn 的单位与 fs 相同。默认情况下，fs 是每样本 2 个半周期，因此这些值在 0 到 1 之间归一化，其中 1 是奈奎斯特频率。 (Wn 因此是半周期 / 样本。)

对于模拟滤波器，Wn 是一个角频率（例如，rad/s）。

类型，可选

滤波器类型。默认为‘低通’。

模拟bool，可选

当为 True 时，返回模拟滤波器，否则返回数字滤波器。

输出，可选

输出类型：分子/分母（‘ba’）、极点-零点（‘zpk’）或二阶段（‘sos’）。默认为 ‘ba’，为了向后兼容性，但一般用于滤波的 ‘sos’ 应该使用。

fsfloat，可选

数字系统的采样频率。

新功能，版本 1.2.0 中添加。

返回：

b, a ndarray, ndarray

IIR 滤波器的分子（b）和分母（a）多项式。仅当 output='ba' 时返回。

z, p, k ndarray, ndarray, float

IIR 滤波器传递函数的零点、极点和系统增益。仅当 output='zpk' 时返回。

sos ndarray

IIR 滤波器的二阶段表示。仅当 output='sos' 时返回。

另见

cheb2ord、cheb2ap

注：

Chebyshev type II 滤波器最大化通频带和阻带之间的截止速率，但以阻带中的波纹和阶跃响应中的增加振荡为代价。

Type II 滤波器不像 Type I 那样快速衰减（cheby1）。

'sos' 输出参数在版本 0.16.0 中添加。

示例

设计一个模拟滤波器并绘制其频率响应，显示关键点：

>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> import numpy as np 

>>> b, a = signal.cheby2(4, 40, 100, 'low', analog=True)
>>> w, h = signal.freqs(b, a)
>>> plt.semilogx(w, 20 * np.log10(abs(h)))
>>> plt.title('Chebyshev Type II frequency response (rs=40)')
>>> plt.xlabel('Frequency [radians / second]')
>>> plt.ylabel('Amplitude [dB]')
>>> plt.margins(0, 0.1)
>>> plt.grid(which='both', axis='both')
>>> plt.axvline(100, color='green') # cutoff frequency
>>> plt.axhline(-40, color='green') # rs
>>> plt.show() 

生成一个由 10 Hz 和 20 Hz 组成的信号，采样频率为 1 kHz

>>> t = np.linspace(0, 1, 1000, False)  # 1 second
>>> sig = np.sin(2*np.pi*10*t) + np.sin(2*np.pi*20*t)
>>> fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True)
>>> ax1.plot(t, sig)
>>> ax1.set_title('10 Hz and 20 Hz sinusoids')
>>> ax1.axis([0, 1, -2, 2]) 

设计一个数字高通滤波器，截止频率为 17 Hz，以去除 10 Hz 音调，并将其应用于信号。（在滤波时推荐使用二阶段格式，以避免传递函数 (ba) 格式的数值误差）：

>>> sos = signal.cheby2(12, 20, 17, 'hp', fs=1000, output='sos')
>>> filtered = signal.sosfilt(sos, sig)
>>> ax2.plot(t, filtered)
>>> ax2.set_title('After 17 Hz high-pass filter')
>>> ax2.axis([0, 1, -2, 2])
>>> ax2.set_xlabel('Time [seconds]')
>>> plt.show() 

scipy.signal.cheb2ord

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.cheb2ord.html#scipy.signal.cheb2ord

scipy.signal.cheb2ord(wp, ws, gpass, gstop, analog=False, fs=None)

Chebyshev II 类型滤波器阶数选择。

返回不超过 gpass dB 的通带损失且在阻带中至少具有 gstop dB 衰减的最低阶数字或模拟 Chebyshev II 类型滤波器的阶数。

参数：

wp, ws：浮点数

通带和阻带边缘频率。

对于数字滤波器，这些单位与 fs 相同。默认情况下，fs 为 2 半周期/样本，因此这些值归一化为 0 到 1，其中 1 是奈奎斯特频率。(wp 和 ws 因此在半周期/样本中。) 例如：

• 低通：wp = 0.2，ws = 0.3
• 高通：wp = 0.3，ws = 0.2
• 带通：wp = [0.2, 0.5]，ws = [0.1, 0.6]
• 带阻带：wp = [0.1, 0.6]，ws = [0.2, 0.5]

对于模拟滤波器，wp 和 ws 是角频率（例如，rad/s）。

gpass：浮点数

通带中的最大损失（dB）。

gstop：浮点数

阻带中的最小衰减（dB）。

analog：布尔值，可选

当为 True 时，返回模拟滤波器，否则返回数字滤波器。

fs：浮点数，可选

数字系统的采样频率。

1.2.0 版中的新内容。

返回：

ord：整数

满足规格要求的 Chebyshev II 类型滤波器的最低阶数。

wn：ndarray 或 浮点数

Chebyshev 自然频率（“3dB 频率”），用于与 cheby2 结合以获得滤波器结果。如果指定了 fs，则单位相同，同时必须将 fs 传递给 cheby2。

另请参阅

cheby2

使用阶数和临界点设计滤波器

buttord

从通带和阻带规格中找到阶数和临界点

cheb1ord, ellipord

iirfilter

使用阶数和临界频率进行一般滤波器设计

iirdesign

使用通带和阻带规格的一般滤波器设计

示例

设计一个数字带阻滤波器，从 0.2(fs/2) 到 0.5(fs/2) 拒绝 -60 dB，同时保持在 0.1(fs/2) 以下或 0.6(fs/2) 以上的 3 dB 内。绘制其频率响应图，显示通带和阻带约束为灰色。

>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> import numpy as np 

>>> N, Wn = signal.cheb2ord([0.1, 0.6], [0.2, 0.5], 3, 60)
>>> b, a = signal.cheby2(N, 60, Wn, 'stop')
>>> w, h = signal.freqz(b, a)
>>> plt.semilogx(w / np.pi, 20 * np.log10(abs(h)))
>>> plt.title('Chebyshev II bandstop filter fit to constraints')
>>> plt.xlabel('Normalized frequency')
>>> plt.ylabel('Amplitude [dB]')
>>> plt.grid(which='both', axis='both')
>>> plt.fill([.01, .1, .1, .01], [-3,  -3, -99, -99], '0.9', lw=0) # stop
>>> plt.fill([.2,  .2, .5,  .5], [ 9, -60, -60,   9], '0.9', lw=0) # pass
>>> plt.fill([.6,  .6,  2,   2], [-99, -3,  -3, -99], '0.9', lw=0) # stop
>>> plt.axis([0.06, 1, -80, 3])
>>> plt.show() 

scipy.signal.ellip

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.ellip.html#scipy.signal.ellip

scipy.signal.ellip(N, rp, rs, Wn, btype='low', analog=False, output='ba', fs=None)

椭圆（Cauer）数字和模拟滤波器设计。

设计一个 N 阶数字或模拟椭圆滤波器并返回滤波器系数。

参数：

N 整数

滤波器的阶数。

rp 浮点数

允许通过通带下方的最大波纹。以分贝表示，为正数。

rs 浮点数

在停止带中所需的最小衰减。以分贝表示，为正数。

Wn array_like

一个标量或长度为 2 的序列，给出关键频率。对于椭圆滤波器，这是增益第一次低于-rp的过渡带中的点。

对于数字滤波器，Wn与fs具有相同的单位。默认情况下，fs为 2 个半周期/样本，因此这些值在 0 到 1 之间归一化，其中 1 是奈奎斯特频率。 (Wn因此在半周期/样本中。)

对于模拟滤波器，Wn是角频率（例如，rad/s）。

btype {‘lowpass’，‘highpass’，‘bandpass’，‘bandstop’}，可选

滤波器的类型。默认为‘lowpass’。

analog 布尔值，可选

当为 True 时，返回模拟滤波器，否则返回数字滤波器。

output {‘ba’，‘zpk’，‘sos’}，可选

输出类型：分子/分母（‘ba’）、极点-零点（‘zpk’）或二阶段（‘sos’）。默认为‘ba’以保持向后兼容性，但一般用于通用滤波应该使用‘sos’。

fs浮点数，可选

数字系统的采样频率。

新版本 1.2.0 中新增。

返回：

b, a ndarray, ndarray

IIR 滤波器的分子（b）和分母（a）多项式。仅在output='ba'时返回。

z, p, k ndarray, ndarray, 浮点数

IIR 滤波器传递函数的零点、极点和系统增益。仅在output='zpk'时返回。

sos ndarray

IIR 滤波器的二阶段表示。仅在output='sos'时返回。

另见

ellipord，ellipap

注意

也称为 Cauer 或 Zolotarev 滤波器，椭圆滤波器在频率响应的通带和阻带之间的过渡速率最大化，但牺牲了两者的波纹，并增加了阶跃响应中的振荡。

当rp接近 0 时，椭圆滤波器变成 Chebyshev II 型滤波器（cheby2）。当rs接近 0 时，它变成 Chebyshev I 型滤波器（cheby1）。当两者都接近 0 时，它变成 Butterworth 滤波器（butter）。

等纹通带有 N 个极大值或极小值（例如，一个 5 阶滤波器有 3 个极大值和 2 个极小值）。因此，奇阶滤波器的直流增益为单位，偶阶滤波器为 -rp dB。

'sos' 输出参数在 0.16.0 版本中被添加。

示例

设计一个模拟滤波器，并绘制其频率响应图，显示关键点：

>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> import numpy as np 

>>> b, a = signal.ellip(4, 5, 40, 100, 'low', analog=True)
>>> w, h = signal.freqs(b, a)
>>> plt.semilogx(w, 20 * np.log10(abs(h)))
>>> plt.title('Elliptic filter frequency response (rp=5, rs=40)')
>>> plt.xlabel('Frequency [radians / second]')
>>> plt.ylabel('Amplitude [dB]')
>>> plt.margins(0, 0.1)
>>> plt.grid(which='both', axis='both')
>>> plt.axvline(100, color='green') # cutoff frequency
>>> plt.axhline(-40, color='green') # rs
>>> plt.axhline(-5, color='green') # rp
>>> plt.show() 

生成由 10 Hz 和 20 Hz 组成的信号，采样频率为 1 kHz。

>>> t = np.linspace(0, 1, 1000, False)  # 1 second
>>> sig = np.sin(2*np.pi*10*t) + np.sin(2*np.pi*20*t)
>>> fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True)
>>> ax1.plot(t, sig)
>>> ax1.set_title('10 Hz and 20 Hz sinusoids')
>>> ax1.axis([0, 1, -2, 2]) 

设计一个数字高通滤波器，截止频率为 17 Hz，以去除 10 Hz 分量，并将其应用于信号。（建议在滤波时使用二阶段格式，以避免在传递函数 (ba) 格式中出现数值误差）：

>>> sos = signal.ellip(8, 1, 100, 17, 'hp', fs=1000, output='sos')
>>> filtered = signal.sosfilt(sos, sig)
>>> ax2.plot(t, filtered)
>>> ax2.set_title('After 17 Hz high-pass filter')
>>> ax2.axis([0, 1, -2, 2])
>>> ax2.set_xlabel('Time [seconds]')
>>> plt.tight_layout()
>>> plt.show() 

scipy.signal.ellipord

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.ellipord.html#scipy.signal.ellipord

scipy.signal.ellipord(wp, ws, gpass, gstop, analog=False, fs=None)

选择椭圆（高尔）滤波器阶数。

返回最低阶数字或模拟椭圆滤波器，通带中损耗不超过 gpass dB，停带中至少有 gstop dB 衰减。

参数：

wp, wsfloat

通带和阻带的边缘频率。

对于数字滤波器，单位与 fs 相同。默认情况下，fs 是每样本的 2 个半周期，因此规范化为 0 到 1，其中 1 是奈奎斯特频率。 (wp 和 ws 因此以半周期/样本计量。) 例如：

• 低通：wp = 0.2, ws = 0.3
• 高通：wp = 0.3, ws = 0.2
• 带通：wp = [0.2, 0.5], ws = [0.1, 0.6]
• 带阻：wp = [0.1, 0.6], ws = [0.2, 0.5]

对于模拟滤波器，wp 和 ws 是角频率（例如，rad/s）。

gpassfloat

通带中的最大损耗（dB）。

gstopfloat

停带中的最小衰减（dB）。

analogbool，可选

当为 True 时，返回模拟滤波器，否则返回数字滤波器。

fsfloat，可选

数字系统的采样频率。

新版本 1.2.0 中新增。

返回：

ordint

满足规格的最低阶椭圆（高尔）滤波器。

wnndarray 或 float

用于与ellip配合使用的切比雪夫自然频率（“3dB 频率”）。如果指定了 fs，则单位相同，同时必须传递给 ellip。

另请参阅

ellip

使用阶数和临界点进行滤波器设计

buttord

从通带和阻带规格中找到阶数和临界点

cheb1ord, cheb2ord

iirfilter

使用阶数和临界频率进行一般滤波器设计

iirdesign

使用通带和阻带规格进行一般滤波器设计

示例

设计一个模拟高通滤波器，使其通带在 30 rad/s 以上 3 dB，同时在 10 rad/s 处拒绝-60 dB。绘制其频率响应图，显示通带和阻带约束为灰色。

>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> import numpy as np 

>>> N, Wn = signal.ellipord(30, 10, 3, 60, True)
>>> b, a = signal.ellip(N, 3, 60, Wn, 'high', True)
>>> w, h = signal.freqs(b, a, np.logspace(0, 3, 500))
>>> plt.semilogx(w, 20 * np.log10(abs(h)))
>>> plt.title('Elliptical highpass filter fit to constraints')
>>> plt.xlabel('Frequency [radians / second]')
>>> plt.ylabel('Amplitude [dB]')
>>> plt.grid(which='both', axis='both')
>>> plt.fill([.1, 10,  10,  .1], [1e4, 1e4, -60, -60], '0.9', lw=0) # stop
>>> plt.fill([30, 30, 1e9, 1e9], [-99,  -3,  -3, -99], '0.9', lw=0) # pass
>>> plt.axis([1, 300, -80, 3])
>>> plt.show() 

scipy.signal.bessel

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.bessel.html#scipy.signal.bessel

scipy.signal.bessel(N, Wn, btype='low', analog=False, output='ba', norm='phase', fs=None)

贝塞尔/汤姆森数字和模拟滤波器设计。

设计第 N 阶数字或模拟贝塞尔滤波器，并返回滤波器系数。

参数：

Nint

滤波器的阶数。

Wnarray_like

标量或长度为 2 的序列，给出关键频率（由norm参数定义）。对于模拟滤波器，Wn是角频率（例如，rad/s）。

对于数字滤波器，Wn与fs具有相同的单位。默认情况下，fs为 2 个半周期/样本，因此归一化为 0 到 1，其中 1 为奈奎斯特频率。(Wn因此为半周期/样本。)

btype，可选

滤波器的类型。默认为'低通'。

模拟布尔型，可选

当为 True 时，返回模拟滤波器，否则返回数字滤波器（详见注意事项）。

output，可选

输出类型：分子/分母（'ba'）、极点-零点（'zpk'）或二阶段（'sos'）。默认为'ba'。

norm，可选

关键频率归一化：

phase

滤波器被归一化，使得相位响应在角（例如 rad/s）频率Wn达到其中点。这适用于低通和高通滤波器，因此这是“相位匹配”的情况。

幅度响应渐近线与相同阶数的 Butterworth 滤波器和Wn截止频率相同。

这是默认设置，与 MATLAB 的实现匹配。

delay

滤波器被归一化，使得通带中的群延迟为 1/Wn（例如，秒）。这是通过解 Bessel 多项式获得的“自然”类型。

mag

滤波器被归一化，使得增益幅度在角频率Wn处为-3 dB。

新功能，版本 0.18.0。

fsfloat，可选

数字系统的采样频率。

新功能，版本 1.2.0。

返回：

b, andarray，ndarray

IIR 滤波器的分子（b）和分母（a）多项式。仅当output='ba'时返回。

z, p, kndarray，ndarray，float

IIR 滤波器传递函数的零点、极点和系统增益。仅当output='zpk'时返回。

sosndarray

IIR 滤波器的二阶段表示。仅当output='sos'时返回。

注意事项

也被称为汤姆森滤波器，模拟贝塞尔滤波器具有最大平坦群延迟和最大线性相位响应，在阶跃响应中几乎没有振铃现象。[1]

Bessel 本质上是一个模拟滤波器。此函数使用双线性变换生成数字 Bessel 滤波器，该变换不保留模拟滤波器的相位响应。因此，在大约 fs/4 以下的频率下，它只是近似正确的。要在较高频率获得最大平坦组延迟，必须使用保相技术转换模拟 Bessel 滤波器。

参见besselap以获取实现细节和参考资料。

'sos'输出参数添加于 0.16.0 版本。

参考文献

[1]

汤姆逊（Thomson, W.E.），“具有最大平坦频率特性的延迟网络”，电气工程师学会论文集，第三部分，1949 年 11 月，第 96 卷，第 44 期，487-490 页。

示例

绘制相位归一化频率响应，显示与 Butterworth 截止频率（绿色）的关系：

>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> import numpy as np 

>>> b, a = signal.butter(4, 100, 'low', analog=True)
>>> w, h = signal.freqs(b, a)
>>> plt.semilogx(w, 20 * np.log10(np.abs(h)), color='silver', ls='dashed')
>>> b, a = signal.bessel(4, 100, 'low', analog=True, norm='phase')
>>> w, h = signal.freqs(b, a)
>>> plt.semilogx(w, 20 * np.log10(np.abs(h)))
>>> plt.title('Bessel filter magnitude response (with Butterworth)')
>>> plt.xlabel('Frequency [radians / second]')
>>> plt.ylabel('Amplitude [dB]')
>>> plt.margins(0, 0.1)
>>> plt.grid(which='both', axis='both')
>>> plt.axvline(100, color='green')  # cutoff frequency
>>> plt.show() 

和相位中点：

>>> plt.figure()
>>> plt.semilogx(w, np.unwrap(np.angle(h)))
>>> plt.axvline(100, color='green')  # cutoff frequency
>>> plt.axhline(-np.pi, color='red')  # phase midpoint
>>> plt.title('Bessel filter phase response')
>>> plt.xlabel('Frequency [radians / second]')
>>> plt.ylabel('Phase [radians]')
>>> plt.margins(0, 0.1)
>>> plt.grid(which='both', axis='both')
>>> plt.show() 

绘制幅度归一化频率响应，显示-3 dB 截止：

>>> b, a = signal.bessel(3, 10, 'low', analog=True, norm='mag')
>>> w, h = signal.freqs(b, a)
>>> plt.semilogx(w, 20 * np.log10(np.abs(h)))
>>> plt.axhline(-3, color='red')  # -3 dB magnitude
>>> plt.axvline(10, color='green')  # cutoff frequency
>>> plt.title('Magnitude-normalized Bessel filter frequency response')
>>> plt.xlabel('Frequency [radians / second]')
>>> plt.ylabel('Amplitude [dB]')
>>> plt.margins(0, 0.1)
>>> plt.grid(which='both', axis='both')
>>> plt.show() 

绘制延迟归一化滤波器，显示 0.1 秒处的最大平坦组延迟：

>>> b, a = signal.bessel(5, 1/0.1, 'low', analog=True, norm='delay')
>>> w, h = signal.freqs(b, a)
>>> plt.figure()
>>> plt.semilogx(w[1:], -np.diff(np.unwrap(np.angle(h)))/np.diff(w))
>>> plt.axhline(0.1, color='red')  # 0.1 seconds group delay
>>> plt.title('Bessel filter group delay')
>>> plt.xlabel('Frequency [radians / second]')
>>> plt.ylabel('Group delay [seconds]')
>>> plt.margins(0, 0.1)
>>> plt.grid(which='both', axis='both')
>>> plt.show() 

scipy.signal.iirnotch

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.iirnotch.html#scipy.signal.iirnotch

scipy.signal.iirnotch(w0, Q, fs=2.0)

设计二阶 IIR 陷波数字滤波器。

陷波滤波器是带阻滤波器，具有较窄带宽（高品质因数）。它拒绝一个窄频带，并使其余频谱略有改变。

参数：

w0float

从信号中去除的频率。如果指定了fs，则其单位与fs相同。默认情况下，它是一个归一化标量，必须满足0 < w0 < 1，其中w0 = 1对应于采样频率的一半。

Qfloat

品质因数。无量纲参数，表征陷波滤波器在其中心频率上相对于其-3 dB 带宽bw的宽度，Q = w0/bw。

fsfloat，可选

数字系统的采样频率。

1.2.0 版新功能。

返回：

b, andarray, ndarray

IIR 滤波器的分子（b）和分母（a）多项式。

另请参阅

iirpeak

注释

0.19.0 版新功能。

参考资料

[1]

Sophocles J. Orfanidis，《信号处理简介》，Prentice-Hall，1996 年

示例

设计并绘制滤波器，以从以 200 Hz 采样的信号中去除 60 Hz 分量，使用品质因数 Q = 30。

>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> import numpy as np 

>>> fs = 200.0  # Sample frequency (Hz)
>>> f0 = 60.0  # Frequency to be removed from signal (Hz)
>>> Q = 30.0  # Quality factor
>>> # Design notch filter
>>> b, a = signal.iirnotch(f0, Q, fs) 

>>> # Frequency response
>>> freq, h = signal.freqz(b, a, fs=fs)
>>> # Plot
>>> fig, ax = plt.subplots(2, 1, figsize=(8, 6))
>>> ax[0].plot(freq, 20*np.log10(abs(h)), color='blue')
>>> ax[0].set_title("Frequency Response")
>>> ax[0].set_ylabel("Amplitude (dB)", color='blue')
>>> ax[0].set_xlim([0, 100])
>>> ax[0].set_ylim([-25, 10])
>>> ax[0].grid(True)
>>> ax[1].plot(freq, np.unwrap(np.angle(h))*180/np.pi, color='green')
>>> ax[1].set_ylabel("Angle (degrees)", color='green')
>>> ax[1].set_xlabel("Frequency (Hz)")
>>> ax[1].set_xlim([0, 100])
>>> ax[1].set_yticks([-90, -60, -30, 0, 30, 60, 90])
>>> ax[1].set_ylim([-90, 90])
>>> ax[1].grid(True)
>>> plt.show() 

scipy.signal.iirpeak

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.iirpeak.html#scipy.signal.iirpeak

scipy.signal.iirpeak(w0, Q, fs=2.0)

设计二阶 IIR 峰值（谐振）数字滤波器。

峰值滤波器是带通滤波器，具有窄带宽（高质量因子）。它拒绝在窄频带之外的分量。

参数：

w0浮点数

在信号中保留的频率。如果指定了 fs，则与 fs 单位相同。默认情况下，它是一个标准化的标量，必须满足 0 < w0 < 1，其中 w0 = 1 对应于采样频率的一半。

Q浮点数

质量因子。无量纲参数，用于描述峰值滤波器的 -3 dB 带宽 bw 相对于其中心频率的比例，Q = w0/bw。

fs浮点数，可选

数字系统的采样频率。

新版本 1.2.0 中的内容。

返回：

b, a数组, 数组

IIR 滤波器的分子 (b) 和分母 (a) 多项式。

参见

iirnotch

注释

新版本 0.19.0 中的内容。

参考

[1]

Sophocles J. Orfanidis，《信号处理导论》，Prentice-Hall，1996 年

示例

设计并绘制滤除除了信号中 1000 Hz 采样时 300 Hz 分量的频率的滤波器，使用质量因子 Q = 30

>>> import numpy as np
>>> from scipy import signal
>>> import matplotlib.pyplot as plt 

>>> fs = 1000.0  # Sample frequency (Hz)
>>> f0 = 300.0  # Frequency to be retained (Hz)
>>> Q = 30.0  # Quality factor
>>> # Design peak filter
>>> b, a = signal.iirpeak(f0, Q, fs) 

>>> # Frequency response
>>> freq, h = signal.freqz(b, a, fs=fs)
>>> # Plot
>>> fig, ax = plt.subplots(2, 1, figsize=(8, 6))
>>> ax[0].plot(freq, 20*np.log10(np.maximum(abs(h), 1e-5)), color='blue')
>>> ax[0].set_title("Frequency Response")
>>> ax[0].set_ylabel("Amplitude (dB)", color='blue')
>>> ax[0].set_xlim([0, 500])
>>> ax[0].set_ylim([-50, 10])
>>> ax[0].grid(True)
>>> ax[1].plot(freq, np.unwrap(np.angle(h))*180/np.pi, color='green')
>>> ax[1].set_ylabel("Angle (degrees)", color='green')
>>> ax[1].set_xlabel("Frequency (Hz)")
>>> ax[1].set_xlim([0, 500])
>>> ax[1].set_yticks([-90, -60, -30, 0, 30, 60, 90])
>>> ax[1].set_ylim([-90, 90])
>>> ax[1].grid(True)
>>> plt.show() 

scipy.signal.iircomb

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.iircomb.html#scipy.signal.iircomb

scipy.signal.iircomb(w0, Q, ftype='notch', fs=2.0, *, pass_zero=False)

设计 IIR 陷波或峰值数字梳状滤波器。

陷波梳状滤波器由间隔规则的带阻滤波器组成，带宽窄（高品质因数）。每个滤除一个窄频带，其余频谱变化不大。

峰值梳状滤波器由间隔规则的带通滤波器组成，带宽窄（高品质因数）。每个滤除窄频带外的成分。

参数：

w0浮点型

梳状滤波器的基本频率（其峰值之间的间隔）。这必须均匀地划分采样频率。如果指定了fs，则与fs具有相同的单位。默认情况下，它是一个标准化的标量，必须满足0 < w0 < 1，其中w0 = 1对应于采样频率的一半。

Q浮点型

质量因数。无量纲参数，表征凹口滤波器的-3 dB 带宽bw相对于其中心频率的关系，Q = w0/bw。

ftype

函数生成的梳状滤波器的类型。如果是'notch'，则 Q 因子适用于凹口。如果是'peak'，则 Q 因子适用于峰值。默认为'notch'。

fs浮点型，可选

信号的采样频率。默认为 2.0。

pass_zero布尔型，可选

如果为 False（默认），滤波器的凹口（空值）位于频率[0, w0, 2w0, …]的中心，峰值位于中点[w0/2, 3w0/2, 5w0/2, …]。如果为 True，则峰值位于[0, w0, 2w0, …]（通过零频率），反之亦然。

新版本 1.9.0 中增加。

返回：

b, a数组，数组

IIR 滤波器的分子（b）和分母（a）多项式。

引发：

ValueError

如果w0小于或等于 0，或大于或等于fs/2，如果fs不能被w0整除，如果ftype不是'notch'或'peak'

另请参见

iirnotch

iirpeak

注释

有关实现细节，请参见[1]。由于使用了单个重复极点，该梳状滤波器的 TF 实现在更高的阶数下仍然是数值稳定的，不会因精度损失而受到影响。

参考

[1]

Sophocles J. Orfanidis，“信号处理导论”，Prentice-Hall，1996 年，第十一章，“数字滤波器设计”

示例

在 200 Hz 采样信号上设计并绘制 20 Hz 处的梳状陷波滤波器，使用质量因数 Q = 30

>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> import numpy as np 

>>> fs = 200.0  # Sample frequency (Hz)
>>> f0 = 20.0  # Frequency to be removed from signal (Hz)
>>> Q = 30.0  # Quality factor
>>> # Design notching comb filter
>>> b, a = signal.iircomb(f0, Q, ftype='notch', fs=fs) 

>>> # Frequency response
>>> freq, h = signal.freqz(b, a, fs=fs)
>>> response = abs(h)
>>> # To avoid divide by zero when graphing
>>> response[response == 0] = 1e-20
>>> # Plot
>>> fig, ax = plt.subplots(2, 1, figsize=(8, 6), sharex=True)
>>> ax[0].plot(freq, 20*np.log10(abs(response)), color='blue')
>>> ax[0].set_title("Frequency Response")
>>> ax[0].set_ylabel("Amplitude (dB)", color='blue')
>>> ax[0].set_xlim([0, 100])
>>> ax[0].set_ylim([-30, 10])
>>> ax[0].grid(True)
>>> ax[1].plot(freq, (np.angle(h)*180/np.pi+180)%360 - 180, color='green')
>>> ax[1].set_ylabel("Angle (degrees)", color='green')
>>> ax[1].set_xlabel("Frequency (Hz)")
>>> ax[1].set_xlim([0, 100])
>>> ax[1].set_yticks([-90, -60, -30, 0, 30, 60, 90])
>>> ax[1].set_ylim([-90, 90])
>>> ax[1].grid(True)
>>> plt.show() 

设计并在 1000 Hz 采样信号上绘制 250 Hz 处的峰值梳状滤波器，使用质量因数 Q = 30

>>> fs = 1000.0  # Sample frequency (Hz)
>>> f0 = 250.0  # Frequency to be retained (Hz)
>>> Q = 30.0  # Quality factor
>>> # Design peaking filter
>>> b, a = signal.iircomb(f0, Q, ftype='peak', fs=fs, pass_zero=True) 

>>> # Frequency response
>>> freq, h = signal.freqz(b, a, fs=fs)
>>> response = abs(h)
>>> # To avoid divide by zero when graphing
>>> response[response == 0] = 1e-20
>>> # Plot
>>> fig, ax = plt.subplots(2, 1, figsize=(8, 6), sharex=True)
>>> ax[0].plot(freq, 20*np.log10(np.maximum(abs(h), 1e-5)), color='blue')
>>> ax[0].set_title("Frequency Response")
>>> ax[0].set_ylabel("Amplitude (dB)", color='blue')
>>> ax[0].set_xlim([0, 500])
>>> ax[0].set_ylim([-80, 10])
>>> ax[0].grid(True)
>>> ax[1].plot(freq, (np.angle(h)*180/np.pi+180)%360 - 180, color='green')
>>> ax[1].set_ylabel("Angle (degrees)", color='green')
>>> ax[1].set_xlabel("Frequency (Hz)")
>>> ax[1].set_xlim([0, 500])
>>> ax[1].set_yticks([-90, -60, -30, 0, 30, 60, 90])
>>> ax[1].set_ylim([-90, 90])
>>> ax[1].grid(True)
>>> plt.show() 

docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.lti.html#scipy.signal.lti

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.lti.html#scipy.signal.lti

class scipy.signal.lti(*system)

连续时间线性时不变系统基类。

参数：

*systemarguments

lti 类可以使用 2、3 或 4 个参数实例化。以下是参数数量及其对应的连续时间子类：

• 2: TransferFunction：（分子，分母）
• 3: ZerosPolesGain：（零点，极点，增益）
• 4: StateSpace：（A，B，C，D）

每个参数都可以是数组或序列。

参见

ZerosPolesGain、StateSpace、TransferFunction、dlti

注意事项

lti 实例并不存在直接。相反，lti 会创建其子类之一的实例：StateSpace、TransferFunction 或 ZerosPolesGain。

如果对于 *system 传入了（分子，分母），则分子和分母的系数都应以降幂顺序指定（例如，s² + 3s + 5 应表示为 [1, 3, 5]）。

更改当前系统表示中不直接部分（如 StateSpace 系统的 zeros）的属性值非常低效且可能导致数值不准确。最好在访问/更改零点、极点或增益之前先转换为特定系统表示。例如，在访问/更改零点、极点或增益之前调用 sys = sys.to_zpk()。

示例

>>> from scipy import signal 

>>> signal.lti(1, 2, 3, 4)
StateSpaceContinuous(
array([[1]]),
array([[2]]),
array([[3]]),
array([[4]]),
dt: None
) 

构建传递函数 (H(s) = \frac{5(s - 1)(s - 2)}{(s - 3)(s - 4)})：

>>> signal.lti([1, 2], [3, 4], 5)
ZerosPolesGainContinuous(
array([1, 2]),
array([3, 4]),
5,
dt: None
) 

构建传递函数 (H(s) = \frac{3s + 4}{1s + 2})：

>>> signal.lti([3, 4], [1, 2])
TransferFunctionContinuous(
array([3., 4.]),
array([1., 2.]),
dt: None
) 

属性：

dt

返回系统的采样时间，对于 lti 系统返回 None。

poles

系统的极点。

zeros

系统的零点。

方法

bode([w, n])	计算连续时间系统的 Bode 幅值和相位数据。
freqresp([w, n])	计算连续时间系统的频率响应。
impulse([X0, T, N])	返回连续时间系统的冲激响应。
output(U, T[, X0])	返回连续时间系统对输入 U 的响应。
step([X0, T, N])	返回连续时间系统的阶跃响应。
to_discrete(dt[, method, alpha])	返回当前系统的离散化版本。

scipy.signal.StateSpace

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.StateSpace.html#scipy.signal.StateSpace

class scipy.signal.StateSpace(*system, **kwargs)

线性时不变状态空间形式系统。

将系统表示为连续时间的一阶微分方程 (\dot{x} = A x + B u) 或离散时间的差分方程 (x[k+1] = A x[k] + B u[k])。根据使用的系统表示，StateSpace 系统从 lti 或 dlti 类继承额外功能。

参数：

*系统：参数

StateSpace 类可以用 1 个或 4 个参数实例化。以下列出了输入参数的数量及其解释：

• 1: lti 或 dlti 系统：(StateSpace, TransferFunction 或 ZerosPolesGain)
• 4: 数组类型：(A, B, C, D)

dt：浮点数，可选

离散时间系统的采样时间[s]。默认为None（连续时间）。必须作为关键字参数指定，例如，dt=0.1。

另见

TransferFunction, ZerosPolesGain, lti, dlti

ss2zpk, ss2tf, zpk2sos

注记

更改不属于 StateSpace 系统表示的属性值（例如 zeros 或 poles）非常低效且可能导致数值不准确。最好先转换为特定系统表示。例如，在访问/更改零点、极点或增益之前调用 sys = sys.to_zpk()。

示例

>>> from scipy import signal
>>> import numpy as np
>>> a = np.array([[0, 1], [0, 0]])
>>> b = np.array([[0], [1]])
>>> c = np.array([[1, 0]])
>>> d = np.array([[0]]) 

>>> sys = signal.StateSpace(a, b, c, d)
>>> print(sys)
StateSpaceContinuous(
array([[0, 1],
 [0, 0]]),
array([[0],
 [1]]),
array([[1, 0]]),
array([[0]]),
dt: None
) 

>>> sys.to_discrete(0.1)
StateSpaceDiscrete(
array([[1\. , 0.1],
 [0\. , 1\. ]]),
array([[0.005],
 [0.1  ]]),
array([[1, 0]]),
array([[0]]),
dt: 0.1
) 

>>> a = np.array([[1, 0.1], [0, 1]])
>>> b = np.array([[0.005], [0.1]]) 

>>> signal.StateSpace(a, b, c, d, dt=0.1)
StateSpaceDiscrete(
array([[1\. , 0.1],
 [0\. , 1\. ]]),
array([[0.005],
 [0.1  ]]),
array([[1, 0]]),
array([[0]]),
dt: 0.1
) 

属性：

A

StateSpace系统的状态矩阵。

B

StateSpace系统的输入矩阵。

C

StateSpace系统的输出矩阵。

D

StateSpace系统的传递矩阵。

dt

返回系统的采样时间，对于lti系统为None。

poles

系统的极点。

zeros

系统的零点。

方法

__mul__(other)	后乘另一个系统或标量。
to_ss()	返回当前StateSpace系统的副本。
to_tf(**kwargs)	将系统表示转换为TransferFunction。
to_zpk(**kwargs)	将系统表示转换为ZerosPolesGain。

scipy.signal.TransferFunction

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.TransferFunction.html#scipy.signal.TransferFunction

class scipy.signal.TransferFunction(*system, **kwargs)

转移函数形式的线性时不变系统类。

将系统表示为连续时间传递函数 (H(s)=\sum_{i=0}^N b[N-i] s^i / \sum_{j=0}^M a[M-j] s^j) 或离散时间传递函数 (H(z)=\sum_{i=0}^N b[N-i] z^i / \sum_{j=0}^M a[M-j] z^j)，其中 (b) 是分子 num 的元素，(a) 是分母 den 的元素，且 (N == len(b) - 1), (M == len(a) - 1)。TransferFunction 系统从相应的 lti 或 dlti 类继承附加功能，具体取决于所用的系统表示。

参数：

系统: 参数

TransferFunction 类可以用 1 或 2 个参数实例化。以下是输入参数的数量及其解释：

• 1: lti 或 dlti 系统：(StateSpace, TransferFunction 或 ZerosPolesGain)
• 2: array_like: (分子, 分母)

dt: 浮点数，可选

离散时间系统的采样时间 [s]。默认为 None（连续时间）。必须作为关键字参数指定，例如 dt=0.1。

参见

ZerosPolesGain, StateSpace, lti, dlti

tf2ss, tf2zpk, tf2sos

注释

更改不属于 TransferFunction 系统表示的属性值（例如 A、B、C、D 状态空间矩阵）是非常低效且可能导致数值不精确。最好在访问/更改 A、B、C、D 系统矩阵之前先转换为特定的系统表示。例如，在访问/更改 A、B、C、D 系统矩阵之前调用 sys = sys.to_ss()。

如果对 *system 传入 (分子, 分母)，则分子和分母的系数应按降幂顺序指定（例如，s² + 3s + 5 或 z² + 3z + 5 应表示为 [1, 3, 5]）

示例

构建传递函数 (H(s) = \frac{s² + 3s + 3}{s² + 2s + 1})：

>>> from scipy import signal 

>>> num = [1, 3, 3]
>>> den = [1, 2, 1] 

>>> signal.TransferFunction(num, den)
TransferFunctionContinuous(
array([1., 3., 3.]),
array([1., 2., 1.]),
dt: None
) 

构建传递函数 (H(z) = \frac{z² + 3z + 3}{z² + 2z + 1})，采样时间为 0.1 秒：

>>> signal.TransferFunction(num, den, dt=0.1)
TransferFunctionDiscrete(
array([1., 3., 3.]),
array([1., 2., 1.]),
dt: 0.1
) 

属性:

den

TransferFunction 系统的分母。

dt

返回系统的采样时间，lti 系统返回 None。

num

TransferFunction 系统的分子。

poles

系统的极点。

zeros

系统的零点。

方法

to_ss()	将系统表示转换为StateSpace.
to_tf()	返回当前TransferFunction系统的副本。
to_zpk()	将系统表示转换为ZerosPolesGain.

scipy.signal.ZerosPolesGain

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.ZerosPolesGain.html#scipy.signal.ZerosPolesGain

class scipy.signal.ZerosPolesGain(*system, **kwargs)

零点、极点、增益形式的线性时不变系统类。

表示系统为连续或离散时间传递函数 (H(s)=k \prod_i (s - z[i]) / \prod_j (s - p[j]))，其中 (k) 是 增益，(z) 是 零点，(p) 是 极点。ZerosPolesGain 系统从 lti 或 dlti 类继承额外功能，具体取决于所使用的系统表示形式。

参数：

*systemarguments

ZerosPolesGain 类可以用 1 或 3 个参数实例化。以下给出了输入参数的数量及其解释：

• 1: lti 或 dlti 系统：(StateSpace，TransferFunction 或 ZerosPolesGain)
• 3: array_like：(zeros, poles, gain)

dt: float, optional

离散时间系统的采样时间 [s]。默认为 None（连续时间）。必须作为关键字参数指定，例如，dt=0.1。

另请参见

TransferFunction，StateSpace，lti，dlti

zpk2ss，zpk2tf，zpk2sos

注意

更改不属于 ZerosPolesGain 系统表示的属性值（如 A、B、C、D 状态空间矩阵）的效率非常低，并可能导致数值不准确。最好先转换为特定的系统表示。例如，在访问/更改 A、B、C、D 系统矩阵之前调用 sys = sys.to_ss()。

示例：

构造传递函数 (H(s) = \frac{5(s - 1)(s - 2)}{(s - 3)(s - 4)})：

>>> from scipy import signal 

>>> signal.ZerosPolesGain([1, 2], [3, 4], 5)
ZerosPolesGainContinuous(
array([1, 2]),
array([3, 4]),
5,
dt: None
) 

构造传递函数 (H(z) = \frac{5(z - 1)(z - 2)}{(z - 3)(z - 4)})，采样时间为 0.1 秒：

>>> signal.ZerosPolesGain([1, 2], [3, 4], 5, dt=0.1)
ZerosPolesGainDiscrete(
array([1, 2]),
array([3, 4]),
5,
dt: 0.1
) 

属性：

dt

返回系统的采样时间，lti 系统返回 None。

gain

ZerosPolesGain 系统的增益。

poles

ZerosPolesGain 系统的极点。

zeros

ZerosPolesGain 系统的零点。

方法：

to_ss()	将系统表示转换为 StateSpace。
to_tf()	将系统表示转换为 TransferFunction。
to_zpk()	返回当前 'ZerosPolesGain' 系统的副本。

scipy.signal.lsim

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.lsim.html#scipy.signal.lsim

scipy.signal.lsim(system, U, T, X0=None, interp=True)

模拟连续时间线性系统的输出。

参数：

systemLTI 类的实例或描述系统的元组。

下面给出元组中元素的数量和解释：

• 1：（lti的实例）

• 2：（num，den）

• 3：（zeros，poles，gain）

• 4：（A，B，C，D）

Uarray_like

描述每个时间T的输入的输入数组（假设在给定时间之间进行插值）。如果有多个输入，则二维数组的每列表示一个输入。如果 U = 0 或 None，则使用零输入。

Tarray_like

定义输入和期望输出的时间步长。必须是非负、递增且等间距的。

X0array_like，可选

状态向量的初始条件（默认为零）。

interp布尔值，可选

是否使用线性（True，默认）或零阶保持（False）插值输入数组。

返回：

T1D ndarray

输出的时间值。

yout1D ndarray

系统响应。

xoutndarray

状态向量的时间演变。

注意事项

如果system传入(num, den)，则分子和分母系数应按降幂顺序指定（例如，s² + 3s + 5应表示为[1, 3, 5]）。

示例

我们将使用lsim来模拟应用于信号的模拟 Bessel 滤波器。

>>> import numpy as np
>>> from scipy.signal import bessel, lsim
>>> import matplotlib.pyplot as plt 

创建一个 12 Hz 截止频率的低通 Bessel 滤波器。

>>> b, a = bessel(N=5, Wn=2*np.pi*12, btype='lowpass', analog=True) 

生成要应用滤波器的数据。

>>> t = np.linspace(0, 1.25, 500, endpoint=False) 

输入信号是三个正弦曲线的和，频率分别为 4 Hz、40 Hz 和 80 Hz。滤波器应大部分消除 40 Hz 和 80 Hz 分量，只留下 4 Hz 信号。

>>> u = (np.cos(2*np.pi*4*t) + 0.6*np.sin(2*np.pi*40*t) +
...      0.5*np.cos(2*np.pi*80*t)) 

使用lsim模拟滤波器。

>>> tout, yout, xout = lsim((b, a), U=u, T=t) 

绘制结果。

>>> plt.plot(t, u, 'r', alpha=0.5, linewidth=1, label='input')
>>> plt.plot(tout, yout, 'k', linewidth=1.5, label='output')
>>> plt.legend(loc='best', shadow=True, framealpha=1)
>>> plt.grid(alpha=0.3)
>>> plt.xlabel('t')
>>> plt.show() 

在第二个示例中，我们模拟双积分器y'' = u，具有恒定输入u = 1。我们将使用积分器的状态空间表示。

>>> from scipy.signal import lti
>>> A = np.array([[0.0, 1.0], [0.0, 0.0]])
>>> B = np.array([[0.0], [1.0]])
>>> C = np.array([[1.0, 0.0]])
>>> D = 0.0
>>> system = lti(A, B, C, D) 

t和u定义要模拟的系统的时间和输入信号。

>>> t = np.linspace(0, 5, num=50)
>>> u = np.ones_like(t) 

计算仿真，然后绘制y。如预期，图形显示曲线y = 0.5*t**2。

>>> tout, y, x = lsim(system, u, t)
>>> plt.plot(t, y)
>>> plt.grid(alpha=0.3)
>>> plt.xlabel('t')
>>> plt.show() 

scipy.signal.lsim2

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.lsim2.html#scipy.signal.lsim2

scipy.signal.lsim2(system, U=None, T=None, X0=None, **kwargs)

通过使用 ODE 求解器scipy.integrate.odeint模拟连续时间线性系统的输出。

自 1.11.0 版本起弃用：函数lsim2已被更快的lsim函数所取代。lsim2将在 SciPy 1.13 中移除。

参数：

system是lti类的实例或描述系统的元组。

以下是元组中元素数量及其解释：

• 1：（lti的实例）

• 2：（num，den）

• 3：（零点，极点，增益）

• 4：（A，B，C，D）

U array_like（1D 或 2D），可选

描述每个时间 T 处输入的输入数组。在给定时间之间使用线性插值。如果有多个输入，则二维数组的每列代表一个输入。如果未给出 U，则假定输入为零。

T array_like（1D 或 2D），可选

输入被定义和输出所需的时间步骤。默认是在区间[0,10.0]上均匀分布的 101 个点。

X0 array_like（1D），可选

状态向量的初始条件。如果未给出X0，则假定初始条件为 0。

kwargs字典

额外的关键字参数将传递给函数odeint。有关更多详细信息，请参阅下面的说明。

返回：

T 1D ndarray

输出的时间值。

yout ndarray

系统的响应。

xout ndarray

系统的时间演化。

另请参阅

lsim

注：

此函数使用scipy.integrate.odeint来解决系统的微分方程。传递给lsim2的额外关键字参数将传递给scipy.integrate.odeint。请参阅scipy.integrate.odeint的文档以获取完整的参数列表。

因为 lsim2 已经不推荐使用，建议用户转向速度更快、更精确的 lsim 函数。scipy.integrate.odeint 的关键字参数在 lsim 中不被支持，但通常也是不需要的。

如果 system 中传递了 (num, den)，则应按降序指定分子和分母的系数（例如，s² + 3s + 5 应表示为 [1, 3, 5]）。

示例

我们将使用 lsim2 来模拟应用于信号的模拟贝塞尔滤波器。

>>> import numpy as np
>>> from scipy.signal import bessel, lsim2
>>> import matplotlib.pyplot as plt 

创建一个截止频率为 12 Hz 的低通贝塞尔滤波器。

>>> b, a = bessel(N=5, Wn=2*np.pi*12, btype='lowpass', analog=True) 

生成数据并应用滤波器。

>>> t = np.linspace(0, 1.25, 500, endpoint=False) 

输入信号是三个正弦曲线的和，频率分别为 4 Hz、40 Hz 和 80 Hz。滤波器应主要消除 40 Hz 和 80 Hz 成分，仅保留 4 Hz 信号。

>>> u = (np.cos(2*np.pi*4*t) + 0.6*np.sin(2*np.pi*40*t) +
...      0.5*np.cos(2*np.pi*80*t)) 

使用 lsim2 模拟滤波器。

>>> tout, yout, xout = lsim2((b, a), U=u, T=t) 

绘制结果。

>>> plt.plot(t, u, 'r', alpha=0.5, linewidth=1, label='input')
>>> plt.plot(tout, yout, 'k', linewidth=1.5, label='output')
>>> plt.legend(loc='best', shadow=True, framealpha=1)
>>> plt.grid(alpha=0.3)
>>> plt.xlabel('t')
>>> plt.show() 

在第二个例子中，我们模拟一个双积分器 y'' = u，其中输入信号 u = 1 是一个常量。我们将使用积分器的状态空间表示。

>>> from scipy.signal import lti
>>> A = np.array([[0, 1], [0, 0]])
>>> B = np.array([[0], [1]])
>>> C = np.array([[1, 0]])
>>> D = 0
>>> system = lti(A, B, C, D) 

t 和 u 分别定义了系统模拟的时间和输入信号。

>>> t = np.linspace(0, 5, num=50)
>>> u = np.ones_like(t) 

计算模拟结果，然后绘制 y。预期的绘图结果将显示曲线 y = 0.5*t**2。

>>> tout, y, x = lsim2(system, u, t)
>>> plt.plot(t, y)
>>> plt.grid(alpha=0.3)
>>> plt.xlabel('t')
>>> plt.show() 

scipy.integrate.odeint

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.integrate.odeint.html#scipy.integrate.odeint

scipy.integrate.odeint(func, y0, t, args=(), Dfun=None, col_deriv=0, full_output=0, ml=None, mu=None, rtol=None, atol=None, tcrit=None, h0=0.0, hmax=0.0, hmin=0.0, ixpr=0, mxstep=0, mxhnil=0, mxordn=12, mxords=5, printmessg=0, tfirst=False)

积分一个常微分方程组。

注意

对于新代码，请使用 scipy.integrate.solve_ivp 来解决微分方程。

使用来自 FORTRAN 库 odepack 的 lsoda 解决常微分方程组的问题。

解决刚性或非刚性的一阶常微分方程系统的初值问题：

dy/dt = func(y, t, ...)  [or func(t, y, ...)] 

其中 y 可以是一个向量。

注意

默认情况下，func 的前两个参数的顺序与 scipy.integrate.ode 类和函数 scipy.integrate.solve_ivp 中系统定义函数中参数的顺序相反。要使用签名 func(t, y, ...) 的函数，必须将参数 tfirst 设置为 True。

参数：

func 可调用函数(y, t, …) 或 可调用函数(t, y, …)

计算 y 在 t 处的导数。如果签名是 callable(t, y, ...)，则必须设置参数 tfirst 为 True。

y0 数组

y 的初始条件（可以是一个向量）。

t 数组

用于解 y 的时间点序列。初始值点应为此序列的第一个元素。此序列必须单调递增或单调递减；允许重复值。

args 元组，可选

传递给函数的额外参数。

Dfun 可调用函数(y, t, …) 或 可调用函数(t, y, …)

func 的梯度（雅可比矩阵）。如果签名是 callable(t, y, ...)，则必须设置参数 tfirst 为 True。

col_deriv 布尔值，可选

如果 Dfun 定义列导数（更快），否则 Dfun 应定义行导数。

full_output 布尔值，可选

如果作为第二个输出返回一个可选输出的字典，则返回 True

printmessg 布尔值，可选

是否打印收敛消息

tfirst 布尔值，可选

如果为 True，则 func 的前两个参数（和 Dfun，如果给定）必须是 t, y，而不是默认的 y, t。

新版本特性 1.1.0。

返回：

y 数组，形状为 (len(t), len(y0))

数组，包含在 t 中每个期望的时间点上 y 的值，初始值 y0 在第一行。

infodict 字典，仅当 full_output == True 时返回

包含额外输出信息的字典

key	meaning
‘hu’	向量，成功用于每个时间步长的步长大小
‘tcur’	向量，包含每个时间步长达到的 t 值（至少与输入时间一样大）
‘tolsf’	向量，大于 1.0 的容差比例因子，在检测到对精度要求过高的请求时计算
‘tsw’	上一次方法切换时的 t 值（给出每个时间步长）
‘nst’	时间步长的累积数
‘nfe’	每个时间步骤的函数评估的累积数
‘nje’	每个时间步长的雅可比矩阵评估的累积数
‘nqu’	每个成功步长的方法顺序的向量
‘imxer’	在错误返回时加权局部误差向量（e / ewt）中具有最大幅度的分量的索引，否则为 -1
‘lenrw’	所需双精度工作数组的长度
‘leniw’	所需整数工作数组的长度
‘mused’	每个成功时间步长的方法指示符向量：1: adams（非刚性），2: bdf（刚性）

其他参数:

ml, muint，可选

如果其中任何一个不是 None 或非负，则假定雅可比矩阵为带状矩阵。这些参数给出了带状矩阵中下限和上限非零对角线的数量。对于带状情况，Dfun 应返回一个矩阵，其行包含非零带（从最低对角线开始）。因此，Dfun 返回的矩阵 jac 应具有形状 (ml + mu + 1, len(y0))，当 ml >=0 或 mu >=0 时。jac 中的数据必须存储为 jac[i - j + mu, j]，表示第 i 个方程相对于第 j 个状态变量的导数。如果 col_deriv 为 True，则必须返回此 jac 的转置。

rtol, atolfloat，可选

输入参数 rtol 和 atol 决定求解器执行的误差控制。求解器将根据形如 max-norm of (e / ewt) <= 1 的不等式控制估计的局部误差向量 e，其中 ewt 是计算为 ewt = rtol * abs(y) + atol 的正误差权重向量。rtol 和 atol 可以是与 y 同样长度的向量或标量。默认为 1.49012e-8。

tcritndarray，可选

向量临界点（例如奇点），需要特别注意积分。

h0float，（0：求解器确定），可选

尝试在第一步上尝试的步长大小。

hmaxfloat，（0：求解器确定），可选

允许的最大绝对步长大小。

hminfloat，（0：求解器确定），可选

允许的最小绝对步长大小。

ixprbool，可选

是否在方法切换时生成额外打印。

mxstepint，（0：求解器确定），可选

每个积分点在 t 上允许的最大步数（内部定义）。

mxhnilint，（0：求解器确定），可选

打印的最大消息数。

mxordnint，（0：求解器确定），可选

允许的非刚性（Adams）方法的最大阶数。

mxordsint，（0：求解器确定），可选

BDF 方法允许的最大阶数。

另请参见

solve_ivp

求解常微分方程组的初值问题

ode

基于 VODE 的更面向对象的积分器

quad

用于找出曲线下面积的方法

示例

受重力和摩擦力影响的摆的角度 theta 的二阶微分方程可以写成：

theta''(t) + b*theta'(t) + c*sin(theta(t)) = 0 

其中 b 和 c 是正常数，而撇号（’）表示导数。要使用 odeint 解决这个方程，我们必须首先将它转化为一阶方程组。通过定义角速度 omega(t) = theta'(t)，我们得到以下系统：

theta'(t) = omega(t)
omega'(t) = -b*omega(t) - c*sin(theta(t)) 

让 y 是向量 [theta, omega]。我们在 Python 中实现这个系统如下：

>>> import numpy as np
>>> def pend(y, t, b, c):
...     theta, omega = y
...     dydt = [omega, -b*omega - c*np.sin(theta)]
...     return dydt
... 

我们假设常数为 b = 0.25 和 c = 5.0：

>>> b = 0.25
>>> c = 5.0 

对于初始条件，我们假设摆是几乎垂直的，theta(0) = pi - 0.1，并且初始静止，因此 omega(0) = 0。然后初始条件向量是

>>> y0 = [np.pi - 0.1, 0.0] 

我们将在区间 0 <= t <= 10 中生成 101 个均匀间隔的样本的解决方案。因此，我们的时间数组是：

>>> t = np.linspace(0, 10, 101) 

调用 odeint 生成解决方案。要将参数 b 和 c 传递给 pend，我们将它们通过 args 参数传递给 odeint。

>>> from scipy.integrate import odeint
>>> sol = odeint(pend, y0, t, args=(b, c)) 

解是一个形状为 (101, 2) 的数组。第一列是 theta(t)，第二列是 omega(t)。下面的代码绘制了两个分量。

>>> import matplotlib.pyplot as plt
>>> plt.plot(t, sol[:, 0], 'b', label='theta(t)')
>>> plt.plot(t, sol[:, 1], 'g', label='omega(t)')
>>> plt.legend(loc='best')
>>> plt.xlabel('t')
>>> plt.grid()
>>> plt.show() 

scipy.signal.impulse

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.impulse.html#scipy.signal.impulse

scipy.signal.impulse(system, X0=None, T=None, N=None)

连续时间系统的脉冲响应。

参数：

systemLTI 类的实例或 array_like 的元组

描述系统。以下给出了元组中元素的数量及其解释：

• 1（lti的实例）
• 2 (num, den)
• 3（zeros, poles, gain）
• 4（A, B, C, D）

X0array_like, optional

初始状态向量。默认为零。

Tarray_like, optional

时间点。如果未给出，则计算。

Nint, optional

要计算的时间点数量（如果未给出T）。

返回：

Tndarray

时间点的一维数组。

youtndarray

包含系统脉冲响应的一维数组（除了零处的奇异性）。

注意事项

如果对于system传递了(num, den)，则分子和分母的系数应以降幂顺序指定（例如，s² + 3s + 5应表示为[1, 3, 5]）。

示例

计算具有重复根的二阶系统的脉冲响应：x''(t) + 2*x'(t) + x(t) = u(t)

>>> from scipy import signal
>>> system = ([1.0], [1.0, 2.0, 1.0])
>>> t, y = signal.impulse(system)
>>> import matplotlib.pyplot as plt
>>> plt.plot(t, y) 

scipy.signal.impulse2

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.impulse2.html#scipy.signal.impulse2

scipy.signal.impulse2(system, X0=None, T=None, N=None, **kwargs)

单输入连续时间线性系统的冲激响应。

自版本 1.11.0 起弃用：函数impulse2已弃用，建议用户切换到更快、更精确的impulse函数。impulse2将在 SciPy 1.13 中移除。

参数：

systemLTI 类的实例或数组样式的元组

描述系统的整数。以下给出了元组中元素的数量和解释：

• 1 (实例lti)
• 2 (num, den)
• 3 (零点、极点、增益)
• 4 (A、B、C、D)

X01-D array_like，可选

状态向量的初始条件。默认值为 0（零向量）。

T1-D array_like, 可选

输入定义和输出所需的时间步长。如果未给定 T，则函数将自动生成一组时间样本。

Nint，可选

要计算的时间点数。默认值为 100。

kwargs各种类型

额外的关键字参数被传递给函数scipy.signal.lsim2，该函数进一步将其传递给scipy.integrate.odeint；请参阅后者的文档以获取有关这些参数的信息。

返回：

Tndarray

输出的时间值。

youtndarray

系统的输出响应。

另请参见

impulse，lsim2，scipy.integrate.odeint

注释

通过调用scipy.signal.lsim2生成解，该函数使用微分方程求解器scipy.integrate.odeint。

由于现在impulse2已被弃用，建议用户切换到速度更快、更精确的impulse函数。scipy.integrate.odeint的关键字参数在impulse中不受支持，但通常不需要。

如果 system 参数传入 (num, den)，则分子和分母的系数都应按降幂顺序指定（例如，s² + 3s + 5 应表示为 [1, 3, 5]）。

新功能在版本 0.8.0 中引入。

示例

计算具有重复根的二阶系统的冲激响应：x''(t) + 2*x'(t) + x(t) = u(t)

>>> from scipy import signal 

>>> system = ([1.0], [1.0, 2.0, 1.0]) 

>>> t, y = signal.impulse2(system)
>>> import matplotlib.pyplot as plt
>>> plt.plot(t, y) 

scipy.signal.step

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.step.html#scipy.signal.step

scipy.signal.step(system, X0=None, T=None, N=None)

连续时间系统的阶跃响应。

参数：

system：LTI 类的实例或数组类的元组

描述系统。以下列出了元组中元素的数量和解释：

• 1（lti 的实例）
• 2（num, den）
• 3（零点、极点、增益）
• 4（A, B, C, D）

X0：数组类，可选

初始状态向量（默认为零）。

T：数组类，可选

时间点（如果未给出则计算）。

N：整数，可选

如果未给出 T，则计算的时间点数。

返回:

T：1D ndarray

输出时间点。

yout：1D ndarray

系统的阶跃响应。

注意事项

如果 system 传入了 (num, den)，则应按降幂顺序指定分子和分母的系数（例如，s² + 3s + 5 应表示为 [1, 3, 5]）。

示例

>>> from scipy import signal
>>> import matplotlib.pyplot as plt
>>> lti = signal.lti([1.0], [1.0, 1.0])
>>> t, y = signal.step(lti)
>>> plt.plot(t, y)
>>> plt.xlabel('Time [s]')
>>> plt.ylabel('Amplitude')
>>> plt.title('Step response for 1\. Order Lowpass')
>>> plt.grid() 

scipy.signal.step2

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.step2.html#scipy.signal.step2

scipy.signal.step2(system, X0=None, T=None, N=None, **kwargs)

连续时间系统的阶跃响应。

此函数与scipy.signal.step功能上相同，但使用函数scipy.signal.lsim2计算阶跃响应。

自版本 1.11.0 起弃用：函数step2已弃用，建议使用更快的step函数。step2将在 SciPy 1.13 中移除。

参数：

systemLTI 类的实例或 array_like 元组

描述系统。以下给出了元组中元素数量及其解释：

• 1（lti的实例）
• 2（num、den）
• 3（零点、极点、增益）
• 4（A、B、C、D）

X0array_like，可选

初始状态向量（默认为零）。

Tarray_like，可选

时间点（如果未给出则计算）。

Nint，可选

如果未提供T，则计算的时间点数。

kwargs各种类型

额外的关键字参数传递给函数scipy.signal.lsim2，后者再传递给scipy.integrate.odeint。有关这些参数的信息，请参阅scipy.integrate.odeint的文档。

返回：

T1 维 ndarray

输出时间点。

yout1 维 ndarray

系统的阶跃响应。

另请参阅

scipy.signal.step

注

由于step2已被弃用，建议用户转而使用更快、更准确的step函数。一般情况下，不支持scipy.signal.step中的scipy.integrate.odeint的关键字参数，但通常也不需要。

如果对于system传递了(num, den)，则分子和分母的系数应按降幂顺序指定（例如，s² + 3s + 5应表示为[1, 3, 5]）。

新版本 0.8.0 中新增。

示例

>>> from scipy import signal
>>> import matplotlib.pyplot as plt 

>>> lti = signal.lti([1.0], [1.0, 1.0])
>>> t, y = signal.step2(lti) 

>>> plt.plot(t, y)
>>> plt.xlabel('Time [s]')
>>> plt.ylabel('Amplitude')
>>> plt.title('Step response for 1\. Order Lowpass')
>>> plt.grid() 

scipy.signal.freqresp

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.freqresp.html#scipy.signal.freqresp

scipy.signal.freqresp(system, w=None, n=10000)

计算连续时间系统的频率响应。

参数：

system是 lti 类的实例或描述系统的元组。

下列内容给出了元组中元素的数量及其解释：

• 1 (实例 lti)
• 2 (num, den)
• 3 (零点、极点、增益)
• 4 (A, B, C, D)

w array_like，可选

频率数组（以弧度/秒为单位）。对于该数组中的每个值，都计算其幅度和相位数据。如果未指定，则会计算一个合理的集合。

n int，可选

如果未给定 w，计算频率点的数量。这 n 个频率在一个区间中对数间隔排列，该区间被选择为包括系统的极点和零点的影响。

返回：

w 1D ndarray

频率数组 [rad/s]

H 1D ndarray

复数幅度值数组

注意：

如果 system 传入 (num, den)，则应该指定分子和分母的系数，按降幂顺序排列（例如，s² + 3s + 5 应表示为 [1, 3, 5]）。

示例

生成传递函数的奈奎斯特图

>>> from scipy import signal
>>> import matplotlib.pyplot as plt 

构造传递函数 (H(s) = \frac{5}{(s-1)³})：

>>> s1 = signal.ZerosPolesGain([], [1, 1, 1], [5]) 

>>> w, H = signal.freqresp(s1) 

>>> plt.figure()
>>> plt.plot(H.real, H.imag, "b")
>>> plt.plot(H.real, -H.imag, "r")
>>> plt.show() 

scipy.signal.bode

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.bode.html#scipy.signal.bode

scipy.signal.bode(system, w=None, n=100)

计算连续时间系统的波德幅度和相位数据。

参数：

systemLTI 类的实例或描述系统的元组。

以下给出元组中的元素数和解释：

• 1 (一个 lti 实例)
• 2 (num, den)
• 3 (零点、极点、增益)
• 4 (A, B, C, D)

warray_like, optional

频率数组（以 rad/s 为单位）。对于该数组中的每个值都计算幅度和相位数据。如果未给定，将计算一组合理的值。

nint, optional

若w未给定，则计算的频率点数。n个频率在一个区间内对数间隔，选定以包括系统的极点和零点的影响。

返回值：

w1D ndarray

频率数组 [rad/s]

mag1D ndarray

幅度数组 [dB]

phase1D ndarray

相位数组 [deg]

注意

如果system传入(num, den)，则应按降幂顺序指定系统的分子和分母系数（例如，s² + 3s + 5 应表示为 [1, 3, 5]）。

新版本 0.11.0 中新增。

示例

>>> from scipy import signal
>>> import matplotlib.pyplot as plt 

>>> sys = signal.TransferFunction([1], [1, 1])
>>> w, mag, phase = signal.bode(sys) 

>>> plt.figure()
>>> plt.semilogx(w, mag)    # Bode magnitude plot
>>> plt.figure()
>>> plt.semilogx(w, phase)  # Bode phase plot
>>> plt.show() 

scipy.signal.dlti

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.dlti.html#scipy.signal.dlti

class scipy.signal.dlti(*system, **kwargs)

离散时间线性时不变系统基类。

参数：

*系统: 参数

可以使用 2、3 或 4 个参数实例化dlti类。以下是参数数量及相应创建的离散时间子类：

• 2: 传递函数: (分子, 分母)
• 3: 零极增益: (零点, 极点, 增益)
• 4: 状态空间: (A, B, C, D)

每个参数可以是数组或序列。

dt: 浮点数，可选

采样时间[s]为离散时间系统的采样时间。默认为True（未指定采样时间）。必须作为关键字参数指定，例如dt=0.1。

另请参阅

零极增益，状态空间，传递函数，lti

注：

dlti实例不存在。相反，dlti创建其子类之一的实例：状态空间、传递函数或零极增益。

更改不直接属于当前系统表示的属性值（例如零点在状态空间系统中）非常低效且可能导致数值不准确。最好先转换为特定系统表示。例如，在访问/更改零点、极点或增益之前调用sys = sys.to_zpk()。

如果对*系统传入了（分子，分母），则分子和分母的系数应按降幂顺序指定（例如，z² + 3z + 5表示为[1, 3, 5]）。

新功能，版本 0.18.0。

示例

>>> from scipy import signal 

>>> signal.dlti(1, 2, 3, 4)
StateSpaceDiscrete(
array([[1]]),
array([[2]]),
array([[3]]),
array([[4]]),
dt: True
) 

>>> signal.dlti(1, 2, 3, 4, dt=0.1)
StateSpaceDiscrete(
array([[1]]),
array([[2]]),
array([[3]]),
array([[4]]),
dt: 0.1
) 

使用采样时间为 0.1 秒构造传递函数(H(z) = \frac{5(z - 1)(z - 2)}{(z - 3)(z - 4)})：

>>> signal.dlti([1, 2], [3, 4], 5, dt=0.1)
ZerosPolesGainDiscrete(
array([1, 2]),
array([3, 4]),
5,
dt: 0.1
) 

使用采样时间为 0.1 秒构建传递函数 (H(z) = \frac{3z + 4}{1z + 2})：

>>> signal.dlti([3, 4], [1, 2], dt=0.1)
TransferFunctionDiscrete(
array([3., 4.]),
array([1., 2.]),
dt: 0.1
) 

属性：

dt

返回系统的采样时间。

poles

系统的极点。

zeros

系统的零点。

方法

bode([w, n])	计算离散时间系统的 Bode 幅度和相位数据。
freqresp([w, n, whole])	计算离散时间系统的频率响应。
impulse([x0, t, n])	返回离散时间dlti系统的冲激响应。
output(u, t[, x0])	返回离散时间系统对输入 u 的响应。
step([x0, t, n])	返回离散时间dlti系统的阶跃响应。

scipy.signal.StateSpace

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.StateSpace.html#scipy.signal.StateSpace

class scipy.signal.StateSpace(*system, **kwargs)

线性时不变系统的状态空间形式。

表示系统为连续时间的一阶微分方程 (\dot{x} = A x + B u) 或离散时间的差分方程 (x[k+1] = A x[k] + B u[k])。状态空间 系统继承了 lti 或 dlti 类的额外功能，取决于所使用的系统表示形式。

参数：

*系统：参数

状态空间 类可以用 1 个或 4 个参数进行实例化。以下给出了输入参数的数量及其解释：

• 1: lti 或 dlti 系统：（状态空间，传递函数 或 零极点增益）
• 4: array_like: (A, B, C, D)

dt: float, optional

离散时间系统的采样时间 [s]。默认为 None（连续时间）。必须作为关键字参数指定，例如，dt=0.1。

另见

传递函数，零极点增益，lti，dlti

ss2zpk，ss2tf，zpk2sos

备注

修改不属于 状态空间 系统表示的属性值（如 零点 或 极点）非常低效且可能导致数值不准确。最好先转换为特定的系统表示。例如，在访问/修改零点、极点或增益之前调用 sys = sys.to_zpk()。

示例

>>> from scipy import signal
>>> import numpy as np
>>> a = np.array([[0, 1], [0, 0]])
>>> b = np.array([[0], [1]])
>>> c = np.array([[1, 0]])
>>> d = np.array([[0]]) 

>>> sys = signal.StateSpace(a, b, c, d)
>>> print(sys)
StateSpaceContinuous(
array([[0, 1],
 [0, 0]]),
array([[0],
 [1]]),
array([[1, 0]]),
array([[0]]),
dt: None
) 

>>> sys.to_discrete(0.1)
StateSpaceDiscrete(
array([[1\. , 0.1],
 [0\. , 1\. ]]),
array([[0.005],
 [0.1  ]]),
array([[1, 0]]),
array([[0]]),
dt: 0.1
) 

>>> a = np.array([[1, 0.1], [0, 1]])
>>> b = np.array([[0.005], [0.1]]) 

>>> signal.StateSpace(a, b, c, d, dt=0.1)
StateSpaceDiscrete(
array([[1\. , 0.1],
 [0\. , 1\. ]]),
array([[0.005],
 [0.1  ]]),
array([[1, 0]]),
array([[0]]),
dt: 0.1
) 

属性：

A

StateSpace 系统的状态矩阵。

B

StateSpace 系统的输入矩阵。

C

StateSpace 系统的输出矩阵。

D

StateSpace 系统的传递矩阵。

dt

返回系统的采样时间，对于 lti 系统返回 None。

poles

系统的极点。

zeros

系统的零点。

方法

__mul__(other)	对另一个系统或标量进行后乘操作。
to_ss()	返回当前 StateSpace 系统的副本。
to_tf(**kwargs)	将系统表示转换为 TransferFunction。
to_zpk(**kwargs)	将系统表示转换为 ZerosPolesGain。

scipy.signal.TransferFunction

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.TransferFunction.html#scipy.signal.TransferFunction

class scipy.signal.TransferFunction(*system, **kwargs)

传递函数形式的线性时不变系统类。

表示系统为连续时间传递函数 (H(s)=\sum_{i=0}^N b[N-i] s^i / \sum_{j=0}^M a[M-j] s^j) 或离散时间传递函数 (H(z)=\sum_{i=0}^N b[N-i] z^i / \sum_{j=0}^M a[M-j] z^j)，其中 (b) 是分子的元素 num，(a) 是分母的元素 den，且 N == len(b) - 1，M == len(a) - 1。TransferFunction 系统从 lti 或 dlti 类继承附加功能，具体取决于所使用的系统表示形式。

参数：

*系统：参数

TransferFunction 类可以用 1 或 2 个参数实例化。以下是输入参数的数量及其解释：

• 1：lti 或 dlti 系统：(StateSpace，TransferFunction 或 ZerosPolesGain)
• 2：array_like：(分子，分母)

dt：float，可选

离散时间系统的采样时间 [s]。默认为 None（连续时间）。必须作为关键字参数指定，例如，dt=0.1。

另请参见

ZerosPolesGain，StateSpace，lti，dlti

tf2ss，tf2zpk，tf2sos

注意事项

更改不属于TransferFunction系统表示的属性值（如A、B、C、D状态空间矩阵）效率非常低且可能导致数值不准确。最好先转换为特定的系统表示。例如，在访问/更改 A、B、C、D 系统矩阵之前调用sys = sys.to_ss()。

如果对于*system传入了(numerator, denominator)，则分子和分母的系数应以降幂顺序指定（例如s² + 3s + 5或z² + 3z + 5应表示为[1, 3, 5])

示例

构建传递函数(H(s) = \frac{s² + 3s + 3}{s² + 2s + 1})：

>>> from scipy import signal 

>>> num = [1, 3, 3]
>>> den = [1, 2, 1] 

>>> signal.TransferFunction(num, den)
TransferFunctionContinuous(
array([1., 3., 3.]),
array([1., 2., 1.]),
dt: None
) 

构建采样时间为 0.1 秒的传递函数(H(z) = \frac{z² + 3z + 3}{z² + 2z + 1})：

>>> signal.TransferFunction(num, den, dt=0.1)
TransferFunctionDiscrete(
array([1., 3., 3.]),
array([1., 2., 1.]),
dt: 0.1
) 

属性：

den

TransferFunction系统的分母。

dt

返回系统的采样时间，对于lti系统返回None。

num

TransferFunction系统的分子。

poles

系统的极点。

zeros

系统的零点。

方法

to_ss()	将系统表示转换为StateSpace。
to_tf()	返回当前TransferFunction系统的副本。
to_zpk()	将系统表示转换为ZerosPolesGain。

scipy.signal.ZerosPolesGain

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.ZerosPolesGain.html#scipy.signal.ZerosPolesGain

class scipy.signal.ZerosPolesGain(*system, **kwargs)

线性时不变系统类以零点、极点、增益形式表示。

表示系统的连续或离散时间传递函数 (H(s)=k \prod_i (s - z[i]) / \prod_j (s - p[j]))，其中 (k) 是增益，(z) 是零点，(p) 是极点。ZerosPolesGain 系统从 lti 或 dlti 类继承额外的功能，具体取决于所使用的系统表示。

参数：

*系统参数

ZerosPolesGain 类可以使用 1 个或 3 个参数实例化。以下给出了输入参数的数量及其解释：

• 1：lti 或 dlti 系统：(StateSpace，TransferFunction 或 ZerosPolesGain)
• 3：array_like：(zeros, poles, gain)

dt: float, optional

离散时间系统的采样时间 [s]。默认为 None（连续时间）。必须作为关键字参数指定，例如，dt=0.1。

另见

TransferFunction，StateSpace，lti，dlti

zpk2ss，zpk2tf，zpk2sos

注意事项

更改不属于 ZerosPolesGain 系统表示的属性值（如 A, B, C, D 状态空间矩阵）非常低效，可能导致数值不准确。最好先转换为特定的系统表示。例如，在访问/更改 A、B、C、D 系统矩阵之前调用 sys = sys.to_ss()。

示例

构建传递函数 (H(s) = \frac{5(s - 1)(s - 2)}{(s - 3)(s - 4)})：

>>> from scipy import signal 

>>> signal.ZerosPolesGain([1, 2], [3, 4], 5)
ZerosPolesGainContinuous(
array([1, 2]),
array([3, 4]),
5,
dt: None
) 

使用采样时间为 0.1 秒构建传递函数 (H(z) = \frac{5(z - 1)(z - 2)}{(z - 3)(z - 4)})：

>>> signal.ZerosPolesGain([1, 2], [3, 4], 5, dt=0.1)
ZerosPolesGainDiscrete(
array([1, 2]),
array([3, 4]),
5,
dt: 0.1
) 

属性:

dt

返回系统的采样时间，对于 lti 系统返回 None。

gain

ZerosPolesGain 系统的增益。

poles

ZerosPolesGain 系统的极点。

zeros

ZerosPolesGain 系统的零点。

方法

to_ss()	将系统表示转换为StateSpace。
to_tf()	将系统表示转换为TransferFunction。
to_zpk()	返回当前 'ZerosPolesGain' 系统的副本。

scipy.signal.dlsim

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.dlsim.html#scipy.signal.dlsim

scipy.signal.dlsim(system, u, t=None, x0=None)

模拟离散时间线性系统的输出。

参数：

systemarray_like 或dlti实例的元组

描述系统的元组。以下给出了元组中元素的数量和解释：

• 1:（dlti的实例）
• 3:（num，den，dt）
• 4:（zeros，poles，gain，dt）
• 5:（A，B，C，D，dt）

uarray_like

描述每个时间t处输入的输入数组（假定在给定时间之间进行插值）。如果有多个输入，则二维数组的每列表示一个输入。

tarray_like，可选

定义输入的时间步长。如果给定了t，则它必须与u的长度相同，并且t中的最后一个值确定输出中返回的步数。

x0array_like，可选

状态向量的初始条件（默认为零）。

返回：

toutndarray

输出的时间值，作为一维数组。

youtndarray

系统响应，作为一维数组。

xoutndarray，可选

状态向量的时间演化。仅当输入为StateSpace系统时生成。

参见

lsim，dstep，dimpulse，cont2discrete

示例

一个简单的积分器传递函数，离散时间步长为 1.0，可以实现为：

>>> import numpy as np
>>> from scipy import signal
>>> tf = ([1.0,], [1.0, -1.0], 1.0)
>>> t_in = [0.0, 1.0, 2.0, 3.0]
>>> u = np.asarray([0.0, 0.0, 1.0, 1.0])
>>> t_out, y = signal.dlsim(tf, u, t=t_in)
>>> y.T
array([[ 0.,  0.,  0.,  1.]]) 

scipy.signal.dimpulse

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.dimpulse.html#scipy.signal.dimpulse

scipy.signal.dimpulse(system, x0=None, t=None, n=None)

离散时间系统的冲激响应。

参数：

system tuple of array_like or instance of dlti

描述系统的元组。以下是元组中元素的数量和解释：

• 1: (instance of dlti)
• 3: (num, den, dt)
• 4: (zeros, poles, gain, dt)
• 5: (A, B, C, D, dt)

x0 array_like, 可选

初始状态向量。默认为零。

t array_like, 可选

时间点。如果未给出，则计算。

n int, 可选

要计算的时间点数量（如果未给出 t）。

返回：

tout ndarray

输出的时间值，作为一维数组。

yout tuple of ndarray

系统的冲激响应。元组的每个元素代表每个输入中的冲激系统的输出。

另请参阅

impulse, dstep, dlsim, cont2discrete

示例

>>> import numpy as np
>>> from scipy import signal
>>> import matplotlib.pyplot as plt 

>>> butter = signal.dlti(*signal.butter(3, 0.5))
>>> t, y = signal.dimpulse(butter, n=25)
>>> plt.step(t, np.squeeze(y))
>>> plt.grid()
>>> plt.xlabel('n [samples]')
>>> plt.ylabel('Amplitude') 

scipy.signal.dstep

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.dstep.html#scipy.signal.dstep

scipy.signal.dstep(system, x0=None, t=None, n=None)

离散时间系统的阶跃响应。

参数：

systemarray_like 元组

描述系统的元组。以下提供元组中元素的数量及其解释：

• 1: (实例dlti)
• 3: (num, den, dt)
• 4: (zeros, poles, gain, dt)
• 5: (A, B, C, D, dt)

x0array_like, optional

初始状态向量，默认为零。

tarray_like, optional

时间点。如果未给出，则计算。

nint, optional

计算时间点的数量（如果未给出t）。

返回：

toutndarray

输出时间点，作为 1-D 数组。

youtndarray 元组

系统的阶跃响应。元组的每个元素表示基于每个输入的阶跃响应的系统输出。

另请参见

step, dimpulse, dlsim, cont2discrete

示例

>>> import numpy as np
>>> from scipy import signal
>>> import matplotlib.pyplot as plt 

>>> butter = signal.dlti(*signal.butter(3, 0.5))
>>> t, y = signal.dstep(butter, n=25)
>>> plt.step(t, np.squeeze(y))
>>> plt.grid()
>>> plt.xlabel('n [samples]')
>>> plt.ylabel('Amplitude') 

scipy.signal.dfreqresp

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.dfreqresp.html#scipy.signal.dfreqresp

scipy.signal.dfreqresp(system, w=None, n=10000, whole=False)

计算离散时间系统的频率响应。

参数：

systemdlti类的一个实例或描述系统的元组。

以下内容给出元组中的元素数量及其解释：

• 1 (一个实例dlti的)
• 2 (分子、分母、采样时间)
• 3 (零点、极点、增益、采样时间)
• 4 (A、B、C、D、采样时间)

warray_like, 可选

频率数组（以弧度/样本表示）。将为此数组中的每个值计算幅度和相位数据。如果未给出一个合理的集合将被计算。

nint, 可选

如果未给出w，计算的频率点数。n频率在一个被选择的区间内对数间隔地分布，该区间包括系统的极点和零点的影响。

wholebool, 可选

通常情况下，如果未提供‘w’，则从 0 到奈奎斯特频率 pi 弧度/样本（单位圆的上半部分）计算频率。如果whole为 True，则从 0 到 2*pi 弧度/样本计算。

返回：

w1D ndarray

频率数组[弧度/样本]

H1D ndarray

复数幅值数组

注意事项

如果system传递(num, den)，则应在降序指数顺序（例如，z² + 3z + 5表示为[1, 3, 5]）中指定分子和分母的系数。

0.18.0 版本中的新内容。

示例

生成传递函数的奈奎斯特图

>>> from scipy import signal
>>> import matplotlib.pyplot as plt 

使用采样时间为 0.05 秒构造传递函数 (H(z) = \frac{1}{z² + 2z + 3})：

>>> sys = signal.TransferFunction([1], [1, 2, 3], dt=0.05) 

>>> w, H = signal.dfreqresp(sys) 

>>> plt.figure()
>>> plt.plot(H.real, H.imag, "b")
>>> plt.plot(H.real, -H.imag, "r")
>>> plt.show() 

scipy.signal.dbode

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.dbode.html#scipy.signal.dbode

scipy.signal.dbode(system, w=None, n=100)

计算离散时间系统的波德幅度和相位数据。

参数：

systemLTI 类的实例或描述系统的元组。

以下内容给出元组中的元素数和其解释：

• 1（dlti的实例）
• 2（num、den、dt）
• 3（zeros、poles、gain、dt）
• 4（A、B、C、D、dt）

warray_like，可选

频率数组（以弧度/样本表示）。将为该数组中的每个值计算幅度和相位数据。如果未提供，将计算一个合理的集合。

nint，可选

如果未提供w，则计算的频率点数。这n个频率在选择的间隔内对数间隔分布，以包括系统的极点和零点的影响。

返回：

w1D ndarray

频率数组 [rad/time_unit]

mag1D ndarray

幅度数组 [dB]

phase1D ndarray

相位数组 [deg]

注：

如果对于system传入(num, den)，则分子和分母的系数应按降幂顺序指定（例如，z² + 3z + 5表示为[1, 3, 5]）。

从版本 0.18.0 开始新增。

示例

>>> from scipy import signal
>>> import matplotlib.pyplot as plt 

用采样时间为 0.05 秒构造传递函数 (H(z) = \frac{1}{z² + 2z + 3})：

>>> sys = signal.TransferFunction([1], [1, 2, 3], dt=0.05) 

等效：sys.bode()

>>> w, mag, phase = signal.dbode(sys) 

>>> plt.figure()
>>> plt.semilogx(w, mag)    # Bode magnitude plot
>>> plt.figure()
>>> plt.semilogx(w, phase)  # Bode phase plot
>>> plt.show() 

scipy.signal.tf2zpk

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.tf2zpk.html#scipy.signal.tf2zpk

scipy.signal.tf2zpk(b, a)

从线性滤波器的分子、分母表示返回零点、极点、增益（z, p, k）的表示。

参数：

barray_like

分子多项式系数。

aarray_like

分母多项式系数。

返回：

zndarray

传输函数的零点。

pndarray

传输函数的极点。

kfloat

系统增益。

笔记

如果b的某些值太接近 0，则它们将被移除。在这种情况下，会发出 BadCoefficients 警告。

数组b和a被解释为传输函数变量的正向递减幂的系数。因此，输入(b = [b_0, b_1, ..., b_M])和(a =[a_0, a_1, ..., a_N])可以表示形如以下模拟滤波器：

[H(s) = \frac {b_0 s^M + b_1 s^{(M-1)} + \cdots + b_M} {a_0 s^N + a_1 s^{(N-1)} + \cdots + a_N}]

或形如以下离散时间滤波器：

[H(z) = \frac {b_0 z^M + b_1 z^{(M-1)} + \cdots + b_M} {a_0 z^N + a_1 z^{(N-1)} + \cdots + a_N}]

这种“正幂”形式在控制工程中更为常见。如果M和N相等（这对所有通过双线性变换生成的滤波器都成立），那么这等同于 DSP 中更受青睐的“负幂”离散时间形式：

[H(z) = \frac {b_0 + b_1 z^{-1} + \cdots + b_M z^{-M}} {a_0 + a_1 z^{-1} + \cdots + a_N z^{-N}}]

尽管对于常见的滤波器是如此，但请记住这在一般情况下并非如此。如果M和N不相等，则必须先将离散时间传输函数系数转换为“正幂”形式，然后再找到极点和零点。

示例

找到具有传输函数的零点、极点和增益

[H(s) = \frac{3s²}{s² + 5s + 13}]

>>> from scipy.signal import tf2zpk
>>> tf2zpk([3, 0, 0], [1, 5, 13])
(   array([ 0\.               ,  0\.              ]), 
 array([ -2.5+2.59807621j ,  -2.5-2.59807621j]), 
 3.0) 

scipy.signal.tf2sos

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.tf2sos.html#scipy.signal.tf2sos

scipy.signal.tf2sos(b, a, pairing=None, *, analog=False)

返回传递函数表示的二阶段节

参数:

barray_like

分子多项式系数。

aarray_like

分母多项式系数。

pairing, 可选的

用于将极点和零点对成节的方法。有关pairing和analog参数的信息和限制，请参见zpk2sos。

analogbool, 可选的

如果为 True，则系统为模拟系统，否则为离散系统。

新版本 1.8.0.

返回：

sosndarray

形状为(n_sections, 6)的二阶滤波器系数数组。有关 SOS 滤波器格式规范，请参见sosfilt。

参见

zpk2sos, sosfilt

注意

通常不建议将 TF 格式转换为 SOS 格式，因为这样做通常不会改善数值精度误差。相反，考虑直接在 ZPK 格式中设计滤波器，然后直接转换为 SOS 格式。TF 首先转换为 ZPK 格式，然后将 ZPK 转换为 SOS 格式。

新版本 0.16.0.

示例

使用其多项式表示找到传递函数 H(s)的“sos”（二阶段节）。

[H(s) = \frac{s² - 3.5s - 2}{s⁴ + 3s³ - 15s² - 19s + 30}]

>>> from scipy.signal import tf2sos
>>> tf2sos([1, -3.5, -2], [1, 3, -15, -19, 30], analog=True)
array([[  0\. ,   0\. ,   1\. ,   1\. ,   2\. , -15\. ],
 [  1\. ,  -3.5,  -2\. ,   1\. ,   1\. ,  -2\. ]]) 

scipy.signal.tf2ss

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.tf2ss.html#scipy.signal.tf2ss

scipy.signal.tf2ss(num, den)

将传递函数转换为状态空间表示。

参数：

num, den array_like

表示分子和分母多项式系数的序列，按降幂排序。分母长度至少应与分子相同。

返回：

A, B, C, D ndarray

控制器标准形式的系统状态空间表示。

示例

转换传递函数：

[H(s) = \frac{s² + 3s + 3}{s² + 2s + 1}]

>>> num = [1, 3, 3]
>>> den = [1, 2, 1] 

转换为状态空间表示：

[ \begin{align}\begin{aligned}\begin{split}\dot{\textbf{x}}(t) = \begin{bmatrix} -2 & -1 \ 1 & 0 \end{bmatrix} \textbf{x}(t) + \begin{bmatrix} 1 \ 0 \end{bmatrix} \textbf{u}(t) \\end{split}\\textbf{y}(t) = \begin{bmatrix} 1 & 2 \end{bmatrix} \textbf{x}(t) + \begin{bmatrix} 1 \end{bmatrix} \textbf{u}(t)\end{aligned}\end{align} ]

>>> from scipy.signal import tf2ss
>>> A, B, C, D = tf2ss(num, den)
>>> A
array([[-2., -1.],
 [ 1.,  0.]])
>>> B
array([[ 1.],
 [ 0.]])
>>> C
array([[ 1.,  2.]])
>>> D
array([[ 1.]]) 

scipy.signal.zpk2tf

原文链接：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.zpk2tf.html#scipy.signal.zpk2tf

scipy.signal.zpk2tf(z, p, k)

从零点和极点返回多项式传递函数表示

参数：

zarray_like

传递函数的零点。

parray_like

传递函数的极点。

kfloat

系统增益。

返回：

bndarray

分子多项式系数。

andarray

分母多项式系数。

示例

使用其‘zpk’（零极点增益）表示法找到传递函数 H(s)的多项式表示。

[H(z) = 5 \frac { (s - 2)(s - 6) } { (s - 1)(s - 8) }]

>>> from scipy.signal import zpk2tf
>>> z   = [2,   6]
>>> p   = [1,   8]
>>> k   = 5
>>> zpk2tf(z, p, k)
(   array([  5., -40.,  60.]), array([ 1., -9.,  8.])) 

scipy.signal.zpk2sos

原文：docs.scipy.org/doc/scipy-1.12.0/reference/generated/scipy.signal.zpk2sos.html#scipy.signal.zpk2sos

scipy.signal.zpk2sos(z, p, k, pairing=None, *, analog=False)

返回系统的零极点和增益的二阶节

参数：

zarray_like

传递函数的零点。

parray_like

传递函数的极点。

kfloat

系统增益。

pairing，可选

用于将极点和零点对组合成节的方法。如果 analog 是 False 并且 pairing 是 None，则将 pairing 设置为 'nearest'；如果 analog 是 True，则 pairing 必须是 'minimal'，如果为 None，则设置为该值。

analogbool，可选

如果为 True，则系统为模拟系统，否则为离散系统。

新版本 1.8.0 中新增。

返回：

sosndarray

具有形状 (n_sections, 6) 的二阶滤波器系数数组。有关 SOS 滤波器格式规范，请参见 sosfilt。

另请参见

sosfilt

注释

用于将 ZPK 转换为 SOS 格式的算法旨在最小化由数值精度问题引起的误差。配对算法试图最小化每个二阶节的峰值增益。这是通过将最接近单位圆的极点与最接近虚轴的极点配对开始的，适用于离散时间系统和连续时间系统。

pairing='minimal' 输出可能不适用于 sosfilt，而 analog=True 的输出永远不适用于 sosfilt。

算法

pairing='nearest'、pairing='keep_odd' 和 pairing='minimal' 算法中的步骤大部分是共享的。 'nearest' 算法试图最小化峰值增益，而 'keep_odd' 在保持奇阶系统应保留一个节作为一阶的约束条件下最小化峰值增益。 'minimal' 类似于 'keep_odd'，但不引入额外的极点或零点。

算法步骤如下：

作为 pairing='nearest'、pairing='keep_odd' 的预处理步骤，根据需要向原点添加极点或零点，以获取相同数量的极点和零点进行配对。如果极点数量为奇数且 pairing == 'nearest'，则在原点处添加一个额外的极点和零点。

然后迭代以下步骤，直到不再有极点或零点：

1. 取最靠近单位圆（或对于 analog=True，虚轴）的（下一个剩余）极点（复数或实数），以开始一个新的滤波器节。

2. 如果极点是实数且没有其他剩余的实数极点[1]，则将最接近的实数零点添加到该部分，并将其保留为一阶部分。请注意，在此步骤之后，我们保证会留下偶数个实数极点、复数极点、实数零点和复数零点，以供后续配对迭代使用。

3. 否则：

   1. 如果极点是复数且零点是唯一剩余的实数零点，则将极点与下一个*最接近的零点（保证为复数）配对。这是必要的，以确保最终将保留一个实数零点，以创建一个一阶部分（从而保持奇序）。
   3. 否则，将极点与最接近的剩余零点（复数或实数）配对。
   5. 继续通过为当前部分中的当前极点和零点添加另一个极点和零点来完成第二阶段：

   6. 1. 如果当前极点和零点都是复数，则添加它们的共轭。
      3. 否则，如果极点是复数且零点是实数，则添加共轭极点和下一个最接近的实数零点。
      5. 否则，如果极点是实数且零点是复数，则添加共轭零点和最接近这些零点的实数极点。
      7. 否则（我们必须有一个实数极点和实数零点），则添加最接近单位圆的下一个实数极点，然后添加最接近该极点的实数零点。

从版本 0.16.0 开始。

示例

为具有 8000 Hz 采样率的系统设计一个 6 阶低通椭圆数字滤波器，其通带角频率为 1000 Hz。通带中的波动不应超过 0.087 dB，而阻带的衰减应至少为 90 dB。

在接下来的ellip调用中，我们可以使用output='sos'，但是对于此示例，我们将使用output='zpk'，然后使用zpk2sos转换为 SOS 格式：

>>> from scipy import signal
>>> import numpy as np
>>> z, p, k = signal.ellip(6, 0.087, 90, 1000/(0.5*8000), output='zpk') 

现在转换为 SOS 格式。

>>> sos = signal.zpk2sos(z, p, k) 

各部分分子的系数：

>>> sos[:, :3]
array([[0.0014152 , 0.00248677, 0.0014152 ],
 [1\.        , 0.72976874, 1\.        ],
 [1\.        , 0.17607852, 1\.        ]]) 

系数中的对称性是因为所有零点都在单位圆上。

各部分分母的系数：

>>> sos[:, 3:]
array([[ 1\.        , -1.32544025,  0.46989976],
 [ 1\.        , -1.26118294,  0.62625924],
 [ 1\.        , -1.2570723 ,  0.8619958 ]]) 

下一个示例展示了pairing选项的效果。我们的系统有三个极点和三个零点，因此 SOS 数组的形状为(2, 6)。这意味着在 SOS 表示中，事实上存在额外的极点和原点处的额外零点。

>>> z1 = np.array([-1, -0.5-0.5j, -0.5+0.5j])
>>> p1 = np.array([0.75, 0.8+0.1j, 0.8-0.1j]) 

使用pairing='nearest'（默认），我们得到：

>>> signal.zpk2sos(z1, p1, 1)
array([[ 1\.  ,  1\.  ,  0.5 ,  1\.  , -0.75,  0\.  ],
 [ 1\.  ,  1\.  ,  0\.  ,  1\.  , -1.6 ,  0.65]]) 

第一部分具有零点{-0.5-0.05j，-0.5+0.5j}和极点{0，0.75}，第二部分具有零点{-1，0}和极点{0.8+0.1j，0.8-0.1j}。请注意，原点处的额外极点和零点已分配到不同的部分。

使用pairing='keep_odd'，我们得到：

>>> signal.zpk2sos(z1, p1, 1, pairing='keep_odd')
array([[ 1\.  ,  1\.  ,  0\.  ,  1\.  , -0.75,  0\.  ],
 [ 1\.  ,  1\.  ,  0.5 ,  1\.  , -1.6 ,  0.65]]) 

原点处的额外极点和零点位于同一部分。事实上，第一部分是一个一阶部分。

使用pairing='minimal'，第一阶段不包括原点处的额外极点和零点：

>>> signal.zpk2sos(z1, p1, 1, pairing='minimal')
array([[ 0\.  ,  1\.  ,  1\.  ,  0\.  ,  1\.  , -0.75],
 [ 1\.  ,  1\.  ,  0.5 ,  1\.  , -1.6 ,  0.65]])