初识SciPy库

1. SciPy
2. SciPy任务子模块
3. 文件输入/输出：
4. 特殊函数：
5. 线性代数操作：
6. 快速傅立叶变换：
7. 优化及拟合：
- 7.1 寻找标量函数的最小值
- 7.2 寻找标量函数的根
- 7.3 曲线拟合
8. 统计和随机数：
- 8.1 直方图和概率密度函数
- 8.2 百分位数
- 8.3 统计检验
9. 插值：
10. 数值积分：
11. 信号处理：
12. 图像处理：scipy.ndimage
- 12.1 图像的几何变换
- 12.2 图像滤波器
- 12.3 数学形态学
- 12.4 测量图像
- 12.5 图像处理应用：

1. SciPy

SciPy包含许多专注于科学计算中的常见问题的工具箱。它的子模块对应于不同的应用，比如插值、积分、优化、图像处理、统计和特殊功能等。

SciPy可以与其他标准科学计算包相对比，比如GSL (C和C++的GNU科学计算包), 或者Matlab的工具箱。SciPy是Python中科学程序的核心程序包；这意味着有效的操作NumPy数组，因此，NumPy和SciPy可以一起工作。

在实现一个程序前，有必要确认一下需要的数据处理方式是否已经在SciPy中实现了。作为非专业程序员，科学家通常倾向于重新发明轮子，这产生了小玩具、不优化、很难分享以及不可以维护的代码。相反，SciPy的程序是优化并且测试过的，因此应该尽可能使用。

警告这个教程根本不是数值计算的介绍。因为列举SciPy的不同子模块和功能将会是非常枯燥的，相反我们将聚焦于列出一些例子，给出如何用SciPy进行科学计算的大概思路。

参考资料

SciPy文档

2. SciPy任务子模块

关键词参数	可选值
scipy.cluster	向量计算
scipy.constants	物理和数学常量
scipy.fftpack	傅里叶变换
scipy.integrate	积分程序
scipy.interpolate	插值
scipy.io	数据输入和输出
scipy.linalg	线性代数程序
scipy.ndimage	n-维图像包
scipy.odr	正交距离回归
scipy.optimize	优化
scipy.signal	信号处理
scipy.sparse	稀疏矩阵
scipy.spatial	空间数据结构和算法
scipy.special	一些特殊数学函数
scipy.stats	统计

他们全都依赖于NumPy, 但是大多数是彼此独立的。

导入NumPy和SciPy的标准方式：

import numpy as np
from scipy import stats  # 其他的子模块统计类

scipy的主要命名空间通常包含的函数其实是numpy（试一下scipy.cos其实是np.cos) 。这些函数的暴露只是因为历史原因；通常没有必要在你的代码中使用import scipy。

3. 文件输入/输出：

scipy.io

载入和保存matlab文件：

from scipy import io as spioa = np.ones((3, 3))
spio.savemat('file.mat', {'a': a}) # savemat expects a dictionary
data = spio.loadmat('file.mat', struct_as_record=True)
data['a']

更多请见：

加载文本文件：numpy.loadtxt()/numpy.savetxt()
智能加载文本/csv文件：numpy.genfromtxt()/numpy.recfromcsv()
快速有效，但是针对numpy的二进制格式：numpy.save()/numpy.load()

4. 特殊函数：

特殊函数是超验函数。scipy.special模块的文档字符串写的很详细，因此我们不会在这里列出所有的函数。常用的一些函数如下：

贝塞尔函数，比如scipy.special.jn() (第n个整型顺序的贝塞尔函数)
椭圆函数 (scipy.special.ellipj() Jacobian椭圆函数, …)
Gamma 函数: scipy.special.gamma(), 也要注意 scipy.special.gammaln() 将给出更高准确数值的 Gamma的log。
Erf, 高斯曲线的面积：scipy.special.erf()

5. 线性代数操作：

scipy.linalg 模块提供了标准的线性代数操作，这依赖于底层的高效实现（BLAS、LAPACK）。

scipy.linalg.det() 函数计算方阵的行列式：

from scipy import linalg
arr = np.array([[1, 2],[3, 4]])
linalg.det(arr)#求取行列式的值det

arr = np.array([[3, 2],[6, 4]])
linalg.det(arr)

try:linalg.det(np.ones((3, 4)))
except ValueError:print("expected square matrix")

scipy.linalg.inv() 函数计算逆方阵：

arr = np.array([[1, 2],[3, 4]])
iarr = linalg.inv(arr)
iarr

判断矩阵与矩阵的逆乘积是否为单位矩阵

np.allclose(np.dot(arr, iarr), np.eye(2))

最后计算逆奇异矩阵（行列式为0）将抛出LinAlgError :

arr = np.array([[3, 2],[6, 4]])try:linalg.inv(arr)
except np.linalg.LinAlgError as err:print("singular matrix")

还有更多高级的操作，奇异值分解（SVD）：

arr = np.arange(9).reshape((3, 3)) + np.diag([1, 0, 1])
uarr, spec, vharr = linalg.svd(arr)

原始矩阵可以用svd和np.dot矩阵相乘的结果重新获得：

sarr = np.diag(spec)
svd_mat = uarr.dot(sarr).dot(vharr)
np.allclose(svd_mat, arr)#判断两个矩阵是否相同

SVD常被用于统计和信号处理。其他标准分解 (QR, LU, Cholesky, Schur), 以及线性系统的求解器，也可以在scipy.linalg中找到。

6. 快速傅立叶变换：

scipy.fftpack 模块允许计算快速傅立叶变换。例子，一个（有噪音）的信号输入是这样：

time_step = 0.02
period = 5.
time_vec = np.arange(0, 20, time_step)
sig = np.sin(2 * np.pi / period * time_vec) + \0.5 * np.random.randn(time_vec.size)import matplotlib.pyplot as plt
plt.figure(figsize=(6, 5))
plt.plot(time_vec, sig, label='Original signal')

观察者并不知道信号的频率，只知道抽样时间步骤的信号sig。假设信号来自真实的函数，因此傅立叶变换将是对称的。scipy.fftpack.fftfreq() 函数将生成样本序列，而scipy.fftpack.fft()将计算快速傅立叶变换：

from scipy import fftpack
sample_freq = fftpack.fftfreq(sig.size, d=time_step)
sig_fft = fftpack.fft(sig)

因为生成的幂是对称的，寻找频率只需要使用频谱为正的部分：

pidxs = np.where(sample_freq > 0)
freqs = sample_freq[pidxs]
power = np.abs(sig_fft)[pidxs]

寻找信号频率：

freq = freqs[power.argmax()]
np.allclose(freq, 1./period)  # 检查是否找到了正确的频率

现在高频噪音将从傅立叶转换过的信号移除：

sig_fft[np.abs(sample_freq) > freq] = 0

生成的过滤过的信号可以用scipy.fftpack.ifft()函数：

main_sig = fftpack.ifft(sig_fft)

查看结果：

plt.figure(figsize=(6, 5))
plt.plot(time_vec, sig)
plt.plot(time_vec, main_sig.real, linewidth=3)
plt.xlabel('Time [s]')
plt.ylabel('Amplitude')
plt.show()

7. 优化及拟合：

优化是寻找最小化或等式的数值解的问题。

scipy.optimize 模块提供了函数最小化（标量或多维度）、曲线拟合和求根的有用算法。

from scipy import optimize

7.1 寻找标量函数的最小值

让我们定义下面的函数：

def f(x):return x**2 + 10*np.sin(x)

绘制它：

x = np.arange(-10, 10, 0.1)
plt.plot(x, f(x))
plt.show()

这个函数在-1.3附近有一个全局最小并且在3.8有一个局部最小。

找到这个函数的最小值的常用有效方式是从给定的初始点开始进行一个梯度下降。BFGS算法是这样做的较好方式：

optimize.fmin_bfgs(f, 0)

这个方法的一个可能问题是，如果这个函数有一些局部最低点，算法可能找到这些局部最低点而不是全局最低点，这取决于初始点：

optimize.fmin_bfgs(f, 3, disp=0)

如果我们不知道全局最低点，并且使用其临近点来作为初始点，那么我们需要付出昂贵的代价来获得全局最优。要找到全局最优点，最简单的算法是暴力算法，算法中会评估给定网格内的每一个点：

grid = (-10, 10, 0.1)
xmin_global = optimize.brute(f, (grid,))
xmin_global

对于更大的网格，scipy.optimize.brute() 变得非常慢。scipy.optimize.anneal() 提供了一个替代的算法，使用模拟退火。对于不同类型的全局优化问题存在更多的高效算法，但是这超出了scipy的范畴。OpenOpt、IPOPT、PyGMO和PyEvolve是关于全局优化的一些有用的包。

要找出局部最低点，让我们用scipy.optimize.fminbound将变量限制在(0,10)区间：

xmin_local = optimize.fminbound(f, 0, 10)
xmin_local

7.2 寻找标量函数的根

要寻找上面函数f的根，比如f(x)=0的一个点，我们可以用比如scipy.optimize.fsolve()：

7.3 曲线拟合

假设我们有来自f的样例数据，带有一些噪音：

xdata = np.linspace(-10, 10, num=20)
ydata = f(xdata) + np.random.randn(xdata.size)

现在，如果我们知道这些sample数据来自的函数（这个案例中是x2+sin(x)x^2 + sin(x)x2+sin(x)）的函数形式，而不知道每个数据项的系数，那么我们可以用最小二乘曲线拟合在找到这些系数。首先，我们需要定义函数来拟合：

def f2(x, a, b):return a*x**2 + b*np.sin(x)

然后我们可以使用scipy.optimize.curve_fit()来找到a和b：

guess = [2, 2]
params, params_covariance = optimize.curve_fit(f2, xdata, ydata, guess)
params

现在我们找到了f的最优解和根，并且用曲线去拟合它，我们将这些结果整合在一个图中：

plt.figure(figsize=(6, 4))
plt.scatter(xdata, ydata, label='Data')
plt.plot(xdata, f2(xdata, params[0], params[1]),label='Fitted function')

注：在Scipy中包含所有最小值和寻找根的算法的统一接口：scipy.optimize.minimize()、 scipy.optimize.minimize_scalar()和 scipy.optimize.root()。他们允许通过method关键词容易的比较多种算法。

你可以在scipy.optimize中找到对于多维度问题有相同功能的算法。

8. 统计和随机数：

scipy.stats模块包含统计工具和随机过程的概率描述。在numpy.random中可以找到多个随机数生成器。

8.1 直方图和概率密度函数

给定随机过程的观察值，它们的直方图是随机过程的PDF（概率密度函数）的估计值：

a = np.random.normal(size=1000)
bins = np.arange(-4, 5)
bins

histogram = np.histogram(a, bins=bins)[0]
bins = 0.5*(bins[1:] + bins[:-1])
bins

from scipy import statsb = stats.norm.pdf(bins)  # norm 是一种分布
plt.plot(bins, histogram)
plt.plot(bins, b)
plt.show()

8.2 百分位数

中位数是有一半值在其上一半值在其下的值：

np.median(a)

中数也被称为百分位数50，因为50%的观察值在它之下：

stats.scoreatpercentile(a, 50)

同样，我们也能计算百分位数90：

stats.scoreatpercentile(a, 90)

百分位数是CDF的估计值：累积分布函数。

8.3 统计检验

统计检验是一个决策指示器。例如，如果我们有两组观察值，我们假设他们来自于高斯过程，我们可以用T检验来决定这两组观察值是不是显著不同：

a = np.random.normal(0, 1, size=100)
b = np.random.normal(1, 1, size=10)
stats.ttest_ind(a, b)

生成的结果由以下内容组成：

T 统计值：一个值，符号与两个随机过程的差异成比例，大小与差异的程度有关。
p 值：两个过程相同的概率。如果它接近1，那么这两个过程几乎肯定是相同的。越接近于0，越可能这两个过程有不同的平均数。

9. 插值：

scipy.interpolate对从实验数据中拟合函数是非常有用的，因此，评估没有测量过的点。这个模块是基于netlib项目的Fortran子程序 FITPACK

假想一个接近sine函数的实验数据：

measured_time = np.linspace(0, 1, 10)
noise = (np.random.random(10)*2 - 1) * 1e-1
measures = np.sin(2 * np.pi * measured_time) + noise

scipy.interpolate.interp1d类可以建立一个线性插值函数：

from scipy.interpolate import interp1d
linear_interp = interp1d(measured_time, measures)

scipy.interpolate.linear_interp实例需要评估感兴趣的时间点：

computed_time = np.linspace(0, 1, 50)
linear_results = linear_interp(computed_time)

通过提供可选的参数kind也可以选择进行立方插值：

cubic_interp = interp1d(measured_time, measures, kind='cubic')
cubic_results = cubic_interp(computed_time)

现在结果可以被整合为下面的Matplotlib图片:

plt.figure(figsize=(6, 4))
plt.plot(measured_time, measures, 'o', ms=6, label='measures')
plt.plot(computed_time, linear_results, label='linear interp')
plt.plot(computed_time, cubic_results, label='cubic interp')

scipy.interpolate.interp2d 与scipy.interpolate.interp1d类似，但是是用于2-D数组。注意对于interp家族，计算的时间点必须在测量时间段之内。

10. 数值积分：

scipy.integrate

scipy.integrate.quad()是最常见的积分程序：

from scipy.integrate import quad
res, err = quad(np.sin, 0, np.pi/2)
np.allclose(res, 1)

其他的积分程序可以在fixed_quad、 quadrature、romberg中找到。

scipy.integrate 可提供了常微分公式(ODE)的特色程序。特别的，scipy.integrate.odeint() 是使用LSODA（Livermore Solver for Ordinary Differential equations with Automatic method switching for stiff and non-stiff problems）的通用积分器，更多细节请见ODEPACK Fortran 库。

odeint解决如下形式的第一顺序ODE系统：

dy/dt=rhs(y1,y2,..,t0,...)dy/dt = rhs(y1, y2, .., t0,...)dy/dt=rhs(y1,y2,..,t0,...)

作为一个介绍，让我们解一下在初始条件下y(t=0)=1y(t=0) = 1y(t=0)=1，这个常微分公式dy/dt=−2ydy/dt = -2ydy/dt=−2y在t=0..4t = 0..4t=0..4时的值。首先，这个函数计算定义位置需要的导数：

def calc_derivative(ypos, time, counter_arr):counter_arr += 1return -2 * ypos

添加了一个额外的参数counter_arr用来说明这个函数可以在一个时间步骤被调用多次，直到收敛。计数器数组定义如下：

counter = np.zeros((1,), dtype=np.uint16)

现在计算轨迹线：

from scipy.integrate import odeint
time_vec = np.linspace(0, 4, 40)
yvec, info = odeint(calc_derivative, 1, time_vec,args=(counter,), full_output=True)

注意，求解器对于首个时间步骤需要更多的循环。导数答案yvec可以画出来：

plt.figure(figsize=(4, 3))
plt.plot(time_vec, yvec)
plt.xlabel('t: Time')
plt.ylabel('y: Position')

11. 信号处理：

scipy.signal

scipy.signal.detrend(): 从信号中删除线性趋势：

from scipy import signalt = np.linspace(0, 5, 100)
x = t + np.random.normal(size=100)plt.plot(t, x, linewidth=3)
plt.plot(t, signal.detrend(x), linewidth=3)
plt.show()

scipy.signal 有许多窗口函数：scipy.signal.hamming(), scipy.signal.bartlett(), scipy.signal.blackman()…
scipy.signal 有滤镜 (中位数滤镜scipy.signal.medfilt(), Wienerscipy.signal.wiener())

12. 图像处理：scipy.ndimage

scipy中专注于专注于图像处理的模块是scipy.ndimage。

from scipy import ndimage

图像处理程序可以根据他们进行的处理来分类。

12.1 图像的几何变换

改变原点，解析度，…

from scipy import miscface = misc.face(gray=True)
shifted_face = ndimage.shift(face, (50, 50))
shifted_face2 = ndimage.shift(face, (50, 50), mode='nearest')
rotated_face = ndimage.rotate(face, 30)
cropped_face = face[50:-50, 50:-50]
zoomed_face = ndimage.zoom(face, 2)
zoomed_face.shape

plt.figure(figsize=(15, 3))
plt.subplot(151)
plt.imshow(shifted_face, cmap=plt.cm.gray)
plt.axis('off')plt.subplot(152)
plt.imshow(shifted_face2, cmap=plt.cm.gray)
plt.axis('off')plt.subplot(153)
plt.imshow(rotated_face, cmap=plt.cm.gray)
plt.axis('off')plt.subplot(154)
plt.imshow(cropped_face, cmap=plt.cm.gray)
plt.axis('off')plt.subplot(155)
plt.imshow(zoomed_face, cmap=plt.cm.gray)
plt.axis('off')plt.subplots_adjust(wspace=.05, left=.01, bottom=.01, right=.99, top=.99)

12.2 图像滤波器

from scipy import miscface = misc.face(gray=True)
face = face[:512, -512:]  # crop out square on right
import numpy as np
noisy_face = np.copy(face).astype(float)
noisy_face += face.std() * 0.5 * np.random.standard_normal(face.shape)
blurred_face = ndimage.gaussian_filter(noisy_face, sigma=3)
median_face = ndimage.median_filter(noisy_face, size=5)
plt.figure(figsize=(9, 3.5))
plt.subplot(131)
plt.imshow(noisy_face, cmap=plt.cm.gray)
plt.axis('off')
plt.title('noisy')plt.subplot(132)
plt.imshow(blurred_face, cmap=plt.cm.gray)
plt.axis('off')
plt.title('Gaussian filter')plt.subplot(133)
plt.imshow(median_face, cmap=plt.cm.gray)
plt.axis('off')
plt.title('median filter')plt.subplots_adjust(wspace=.05, left=.01, bottom=.01, right=.99, top=.99)

在scipy.ndimage.filters 和 scipy.signal 有更多应用于图像的滤波器。

12.3 数学形态学

数学形态学是集合理论分支出来的一个数学理论。它刻画并转换几何结构。特别是二元的图像（黑白）可以用这种理论来转换：被转换的集合是临近非零值像素的集合。这个理论也可以被扩展到灰度值图像。

初级数学形态学操作使用结构化的元素，以便修改其他几何结构。
首先让我们生成一个结构化元素。

el = ndimage.generate_binary_structure(2, 1)
el
el.astype(int)

腐蚀(ndimage.binary_erosion)

a = np.zeros((7,7), dtype=int)
a[1:6, 2:5] = 1
a

ndimage.binary_erosion(a).astype(a.dtype)

#腐蚀移除了比结构小的对象
ndimage.binary_erosion(a, structure=np.ones((5,5))).astype(a.dtype)

扩张 (ndimage.binary_dilation)

a = np.zeros((5, 5))
a[2, 2] = 1
a
ndimage.binary_dilation(a).astype(a.dtype)

开启(ndimage.binary_opening)

a = np.zeros((5,5), dtype=int)
a[1:4, 1:4] = 1; a[4, 4] = 1
a
# 开启移除了小对象
ndimage.binary_opening(a, structure=np.ones((3,3))).astype(int)
# 开启也可以平滑拐角
ndimage.binary_opening(a).astype(int)

闭合: ndimage.binary_closing
开启操作移除小的结构，而关闭操作填满了小洞。因此这些用来”清洗“图像。

a = np.zeros((50, 50))
a[10:-10, 10:-10] = 1
a += 0.25*np.random.standard_normal(a.shape)
mask = a>=0.5
opened_mask = ndimage.binary_opening(mask)
closed_mask = ndimage.binary_closing(opened_mask)
plt.figure(figsize=(12, 3.5))
plt.subplot(141)
plt.imshow(a, cmap=plt.cm.gray)
plt.axis('off')
plt.title('a')plt.subplot(142)
plt.imshow(mask, cmap=plt.cm.gray)
plt.axis('off')
plt.title('mask')plt.subplot(143)
plt.imshow(opened_mask, cmap=plt.cm.gray)
plt.axis('off')
plt.title('opened_mask')plt.subplot(144)
plt.imshow(closed_mask, cmap=plt.cm.gray)
plt.title('closed_mask')
plt.axis('off')plt.subplots_adjust(wspace=.05, left=.01, bottom=.01, right=.99, top=.99)

对于灰度值图像，腐蚀（区别于扩张）相当于用感兴趣的像素周围的结构元素中的最小（区别于最大）值替换像素。

a = np.zeros((7,7), dtype=int)
a[1:6, 1:6] = 3
a[4,4] = 2; a[2,3] = 1
a
ndimage.grey_erosion(a, size=(3,3))

12.4 测量图像

首先让我们生成一个漂亮的人造二维图。

x, y = np.indices((100, 100))
sig = np.sin(2*np.pi*x/50.)*np.sin(2*np.pi*y/50.)*(1+x*y/50.**2)**2
mask = sig > 1

现在让我们看一下图像中对象的各种信息：

labels, nb = ndimage.label(mask)
nb
areas = ndimage.sum(mask, labels, range(1, labels.max()+1))
areas
maxima = ndimage.maximum(sig, labels, range(1, labels.max()+1))
maxima
ndimage.find_objects(labels==4)

sl = ndimage.find_objects(labels==4)
plt.imshow(sig[sl[0]])
plt.show()

12.5 图像处理应用：

计数气泡和未融化的颗粒

问题描述

打开图像文件MV_HFV_012.jpg并且浏览一下。看一下imshow文档字符串中的参数，用“右”对齐来显示图片（原点在左下角，而不是像标准数组在右上角）。这个扫描元素显微图显示了一个带有一些气泡（黑色）和未溶解沙（深灰）的玻璃样本（轻灰矩阵）。我们想要判断样本由三个状态覆盖的百分比，并且预测沙粒和气泡的典型大小和他们的大小等。
修建图片，删除带有测量信息中底部面板。
用中位数过滤稍稍过滤一下图像以便改进它的直方图。看一下直方图的变化。
使用过滤后图像的直方图，决定允许定义沙粒像素，玻璃像素和气泡像素掩蔽的阈限。其他的选项：写一个函数从直方图的最小值自动判断阈限。
将三种不同的相用不同的颜色上色并显示图片。
用数学形态学清理不同的相。
为所有气泡和沙粒做标签，从沙粒中删除小于10像素的掩蔽。要这样做，用ndimage.sum或np.bincount来计算沙粒大小。
计算气泡的平均大小。

import numpy as np
from scipy import ndimage
import matplotlib.pyplot as pltdate = plt.imread('Images/MV_HFV_012.jpg')

修建图片，删除带有测量信息中底部面板。

date = date[:-60]
plt.imshow(date)

用中位数过滤稍稍过滤一下图像以便改进它的直方图。看一下直方图的变化。

filtdate = ndimage.median_filter(date, size=(7,7))
hi_date = np.histogram(date, bins=np.arange(256))
hi_filtdate = np.histogram(filtdate, bins=np.arange(256))
plt.plot(hi_date[1][:-1], hi_date[0])
plt.plot(hi_filtdate[1][:-1], hi_filtdate[0])

使用过滤后图像的直方图，决定允许定义沙粒像素，玻璃像素和气泡像素掩蔽的阈限。其他的选项：写一个函数从直方图的最小值自动判断阈限。

void = filtdate <= 50
sand = np.logical_and(filtdate > 50, filtdate <= 114)
glass = filtdate > 114

将三种不同的相用不同的颜色上色并显示图片。

phases = void.astype(int) + 2*glass.astype(int) + 3*sand.astype(int)
plt.imshow(phases)

单独显示砂砾

sand_op = ndimage.binary_opening(sand, iterations=2)
plt.imshow(sand_op.astype(int))

为所有气泡和沙粒做标签，从沙粒中删除小于10像素的掩蔽。要这样做，用ndimage.sum或np.bincount来计算沙粒大小。

sand_labels, sand_nb = ndimage.label(sand_op)
sand_areas = np.array(ndimage.sum(sand_op, sand_labels, np.arange(sand_labels.max()+1)))
mask = sand_areas > 100
remove_small_sand = mask[sand_labels.ravel()].reshape(sand_labels.shape)
plt.imshow(remove_small_sand.astype(int))

计算气泡的平均大小。

plt.imshow(void.astype(int))

bubbles_labels, bubbles_nb = ndimage.label(void)
bubbles_areas = np.bincount(bubbles_labels.ravel())[1:]
mean_bubble_size = bubbles_areas.mean()
median_bubble_size = np.median(bubbles_areas)
mean_bubble_size, median_bubble_size

参考文献来自桑鸿乾老师的课件：科学计算和人工智能

【初识SciPy库】相关推荐

python参数估计_python简单实现最大似然估计scipy库的使用详解
python简单实现最大似然估计 1.scipy库的安装 wim+R输入cmd,然后cd到python的pip路径,即安装:pip install scipy即可 2.导入scipy库 from sc ...
python解非线性规划问题讲析_python中线性规划中的单纯形法、scipy库与非线性规划求解问题...
单纯形法.scipy库与非线性规划求解问题单纯形法的基本定义大M法求解线性规划的原理 excel求解 Python调用optimize包和scipy求解线性规划 Python编程实现单纯形法对比 ...
【python数字信号处理】——scipy库设计滤波器（IIR为例）、绘制滤波器频谱响应、IIR滤波器滤波、读写wav音频文件
目录一.参考文献 1.scipy接口 2.scipy库介绍+IIR滤波器设计(含GUI)+绘制频谱响应
《Python数据可视化编程实战》—— 1.2　安装matplotlib、Numpy和Scipy库
本节书摘来异步社区<Python数据可视化编程实战>一书中的第1章,第1.2节,作者:[爱尔兰]Igor Milovanović,更多章节内容可以访问云栖社区"异步社区" ...
DirectX12（D3D12）基础教程（四）——初识DirectXMath库、使用独立堆创建常量缓冲、理解管线状态对象、理解围栏同步
目录 1.前言及本章内容提要 2.初识DirectXMath库 3.使用独立堆创建常量缓冲 4.理解管线状态对象 5.理解围栏同步 6.完整代码 1.前言及本章内容提要经过了之前3篇教程的跨度有点大 ...
Scipy库（win下安装）
Scipy库 SciPy 库建立在 Numpy 库之上,提供了大量科学算法Document 特殊函数 (scipy.special) 积分 (scipy.integrate) 最优化 (scipy.o ...
【Python】Windows下安装scipy库步骤
概述由于学习需要,需要安装scipy库.scipy库在Windows下使用pip安装失败,所以需要寻找安装包进行安装,下面是记录步骤. 开发环境 win10 x64 Python 3.5.1 安装s ...
python导入scipy库、sympy库遇到的问题及解决方式
首先从cmd中导入scipy库,输入代码: pip install scipy 注意: pip版本最好也要更新到最新版,否则容易发生版本冲突的问题. 但是出现异常:read time out 这时想到 ...
关于scipy库里面的DCT离散余弦变换函数
问题描述我们在手写DCT离散余弦函数的时候,算出来的值总是与scipy库里面的DCT函数不一样,结果和代码如下所示: ## 这是自己写的dct离散余弦函数 ## n代表阶数,0 < n < ...
Python学习-Scipy库稀疏矩阵的建立（面向列的稀疏矩阵、基于坐标格式的稀疏矩阵）
Python学习-Scipy库稀疏矩阵的建立稀疏矩阵指在矩阵中值为0的元素的数量远远多于非0值的矩阵 (非0元素总数/所有元素总数<=0.05) 稀疏矩阵的实现对象: csc_matrix() ...

【初识SciPy库】