SciPy 1.12 中文文档（三十一）

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

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

../../_images/scipy-signal-ellipord-1.png

`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'）、极点-零点（'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()

../../_images/scipy-signal-bessel-1_00_00.png

和相位中点：

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

../../_images/scipy-signal-bessel-1_01_00.png

绘制幅度归一化频率响应，显示-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()

../../_images/scipy-signal-bessel-1_02_00.png

绘制延迟归一化滤波器，显示 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()

../../_images/scipy-signal-bessel-1_03_00.png

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

../../_images/scipy-signal-iirnotch-1.png

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

../../_images/scipy-signal-iirpeak-1.png

`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’，‘peak’}

函数生成的梳状滤波器的类型。如果是'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()

../../_images/scipy-signal-iircomb-1_00_00.png

设计并在 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()

../../_images/scipy-signal-iircomb-1_01_00.png

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

../../_images/scipy-signal-lsim-1_00_00.png

在第二个示例中，我们模拟双积分器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()

../../_images/scipy-signal-lsim-1_01_00.png

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

../../_images/scipy-signal-lsim2-1_00_00.png

在第二个例子中，我们模拟一个双积分器 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()

../../_images/scipy-signal-lsim2-1_01_00.png

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

../../_images/scipy-integrate-odeint-1.png

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

../../_images/scipy-signal-impulse-1.png

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

../../_images/scipy-signal-impulse2-1.png

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

../../_images/scipy-signal-step-1.png

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

../../_images/scipy-signal-step2-1.png

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

../../_images/scipy-signal-freqresp-1.png

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

../../_images/scipy-signal-bode-1_00.png

`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-1-12-中文文档-三十一-

SciPy 1.12 中文文档（三十一）

scipy.signal.ellipord

scipy.signal.bessel

scipy.signal.iirnotch

scipy.signal.iirpeak

scipy.signal.iircomb

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

scipy.signal.StateSpace

scipy.signal.TransferFunction

scipy.signal.ZerosPolesGain

scipy.signal.lsim

scipy.signal.lsim2

scipy.integrate.odeint

scipy.signal.impulse

scipy.signal.impulse2

scipy.signal.step

scipy.signal.step2

scipy.signal.freqresp

scipy.signal.bode

scipy.signal.dlti

`scipy.signal.ellipord`

`scipy.signal.bessel`

`scipy.signal.iirnotch`

`scipy.signal.iirpeak`

`scipy.signal.iircomb`

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

`scipy.signal.StateSpace`

`scipy.signal.TransferFunction`

`scipy.signal.ZerosPolesGain`

`scipy.signal.lsim`

`scipy.signal.lsim2`

`scipy.integrate.odeint`

`scipy.signal.impulse`

`scipy.signal.impulse2`

`scipy.signal.step`

`scipy.signal.step2`

`scipy.signal.freqresp`

`scipy.signal.bode`

`scipy.signal.dlti`