Python科学计算为目标学习路线应该怎么走- _星空五金网
你的位置：&&&文章正文……
Python科学计算为目标学习路线应该怎么走
Python科学计算为目标学习路线应该怎么走
基础知识学习在你深入了解Python的数据科学库之前，你首先需要学习一些Python的基础知识。Python是一门面向对象的编程语言。在Python中，对象既可以赋值给一个变量，也可以作为参数传递给一个函数。以下都是Python中的对象：数字、字符串、列表、元组、集合、字典、函数以及类。Python中的函数与普通数学中的函数基本上是一致的——它接收输入数据，对数据进行处理并输出结果。输出的结果完全取决于函数是如何被设计的。另一方面，Python中的类是被设计为输出其他对象的对象的原型。如果你的目标是编写快速、可复用、易于修改的Python代码，那么你必须使用函数和类。使用函数和类有助于保证代码的高效与整洁。现在，让我们看看Python中有哪些可用的数据科学工具库。科学计算：Numpy与ScipyNumpy是一个主要用于处理n维数组对象的Python工具包，而Scip乏鼎催刮诎钙挫水旦惊y则提供了许多数学算法与复杂函数的实现，可用来扩展Numpy库的功能。Scipy库为Python添加了一些专门的科学函数，以应对数据科学中的一些特定任务。为了在Python中使用Numpy（或其他任何Python库），你必须首先导入对应的工具库。当你使用普通的Python程序时——未使用任何外部扩展（例如工具库）的Python程序——你只能受限地使用一维列表来存储数据。但是，如果你使用Numpy库来扩展Python，你可以直接使用n维数组。（如果你想知道的话，n维数组是包含一个或多个维度的数组。）最开始就学习Numpy，是因为在使用Python进行科学计算时Numpy必不可少。对Numpy的深入了解将有助于你高效地使用Pandas和Scipy这样的工具库。数据再加工：PandasPandas是数据再加工过程中使用的最为广泛的工具。它包含为使数据分析更加快速便捷而设计的高级数据结构与数据操作工具。对于使用R语言进行统计计算的用户，一定不会对DataFrame的变量名感到陌生。Pandas是Python成长为一个强大而高效的数据分析平台的关键因素之一。接下来，我将向你展示如何使用Pandas处理一个小型数据集。DataFrame是一个电子表格结构，包含一个有序的列集合。每个列都可以有不同的变量类型。DataFrame既包含行索引，也包含列索引。可视化：Matplotlib + Seaborn + BokehMatlplotlib是Python中一个用于数据可视化的模块。Matplotlib可使你轻松地绘制线形图、饼状图、直方图以及其他专业图表。你可以使用Matplotlib自定义图表中的每个细节。当你在IPython中使用Matplotlib时，Matplotlib具备缩放、平移等交互特性。Matplotlib在所有操作系统上均支持不同的GUI后端，同时，它也可以将图表导出为若干种常见的图像格式，如PDF、SVG、JPG、PNG、BMP、GIF等。Seaborn是一个基于Matplotlib的数据可视化工具库，用来在Python中创建富有吸引力且内容翔实的统计图表。Seaborn的主要特点在于，其仅使用相对简单的命令就可以从Pandas数据中创建出复杂的图表类型。机器学习: Scikit-learn机器学习的目标在于通过向机器（软件）提供一些示例（如何执行任务或者执行什么无法完成任务）来教会机器执行任务。Python中有很多机器学习的工具库，然而，Scikit-learn是最受欢迎的一个。Scikit-learn建立在Numpy......Web开发 如Flask、Django、Tornado等等，需要良好的文档阅读能力。 推荐书籍： 《FlaskWeb开发：基于Python的Web应用开发实战》、《The Django Book》等。渗透测试 陡峭的学习曲线，需要其它如汇编、计算机网络、数据结构等基础知识。推荐书籍：《Python灰帽子》、《Python黑帽子》等。数据挖掘/大数据 据说还需要学习其它语言，如R语言等。推荐从Scrapy入手。这里有张图，我认为规划的最好：科学计算 了解不多~_~ ... 推荐书籍：《Python科学计算》。机器学习 了解不多~_~ ... 推荐书籍：《机器学习实战》。软件开发 如Tkinter、wxpython、PyQt、PyGTK+等等。这些图形界面库各有优缺点。其中PyQt普及程度要搞一些，比如说有道词典Linux版、深度截图用的就是PyQt5。有兴趣的鱼油可以移步淘贴PyQt。软件测试测试 如Selenium、QTP等自动化测试工具。有兴趣的鱼油可以移步自动化测试框架Selenium。推荐书籍：《Selenium 2自动化测试实战——基于Python语言》。
没什么好走的，随用随学就是了。核心就是numy,pandas和scipy。
Web开发 如Flask、Django、Tornado等等,需要良好的文档阅读能力。 推荐书籍: 《...……
python做科学计算的特点: 1. 科学库很全。 科学库:numpy,scipy。作图:matpl...……
还可以。。我看了numpy这章。scipy感觉就跟不上了(统计知识太差)。。可能是我基础不行。没有讲...……
Python用在科学计算领域有两大好处: 强大的胶水功能,可以粘合其他的第三方库,处理任何碰到的问题...……
Python(x, y)没有64位的版本,开数组开大了就Memory Error了。 用过Entho...……
还可以。 我看了numpy这章,scipy感觉就跟不上了(统计知识太差),可能是我基础不行,没有讲p...……
去品品品资源论坛,在那搜下“Python”……
numpy scipy scikit-learn 安装这三个基本可以满足需求,要画图的话再加上 ma...……
数组a的shape属性只有一个元素,因此它是一维数组。而数组c的shape属性有两个元素,因此它是二...……
Python(x, y)没有64位的版本,开数组开大了就Memory Error了。 用过Entho...
五金者，指金、银、铜、铁、锡五项金属材料之称，五金材料之产品，通常只分为大五金及小五金两大类。大五金指钢板、钢筋，扁铁、万能角钢、槽铁、工字铁及各类型之钢铁材料，小五金则为建筑五金、白铁皮、锁类铁钉、铁丝、钢铁丝网、钢丝剪、家庭五金、各种工具等等。就五金之性质与用途，应分钢铁材料、非铁金属材料、机械机件、传动器材、辅助工具、工作工具、建筑五金、家庭五金等八大类
Copyright & 2017
相关信息仅供参考，不对其真实性准确性有效性作任何的保证，有事情请发邮件到xkynjf＃(把＃换成@)370被浏览20152分享邀请回答def laplace(u):
nx, ny = u.shape
for i in xrange(1,nx-1):
for j in xrange(1, ny-1):
u[i,j] = ((u[i+1, j] + u[i-1, j]) * dy2 +
(u[i, j+1] + u[i, j-1]) * dx2) / (2*(dx2+dy2))
有两个嵌套循环，还不算外部迭代的。Python嵌套循环非常慢，尽量不要超过两层。边界条件是底边为1，其余是0.因为我是忠实的蓝猫教信徒，所以迭代3000次。耗时44秒。用NumPy的数组计算重新写拉普拉斯方程：def mat_laplace(u):
u[1:-1,1:-1] = ((u[2:,1:-1]+u[:-2,1:-1])*dy2 +
(u[1:-1,2:] + u[1:-1,:-2])*dx2) / (2*(dx2+dy2))
注意需先导入Numpy库：import numpy as np
数组初始化用NumPy里的zerosu = np.zeros([N, N])
还是迭代3000次，耗时0.33秒。27379 条评论分享收藏感谢收起106 条评论分享收藏感谢收起查看更多回答numpy模块中的矩阵对象为numpy.matrix，包括矩阵数据的处理，矩阵的计算，以及基本的统计功能，转置，可逆性等等，包括对复数的处理，均在matrix对象中。 class&numpy.matrix(data,dtype,copy):返回一个矩阵，其中data为ndarray对象或者字符形式；dtype:为data的type；copy:为bool类型。
&&& a = np.matrix('1 2 7; 3 4 8; 5 6 9')
&&& a&&&&&&&&&&&& #矩阵的换行必须是用分号(;)隔开，内部数据必须为字符串形式(& &)，矩
matrix([[1, 2, 7],&&&&&& #阵的元素之间必须以空格隔开。
[3, 4, 8],
[5, 6, 9]])
&&& b=np.array([[1,5],[3,2]])
&&& x=np.matrix(b)&& #矩阵中的data可以为数组对象。
matrix([[1, 5],
矩阵对象的属性：
matrix.T transpose：返回矩阵的转置矩阵
matrix.H hermitian (conjugate) transpose：返回复数矩阵的共轭元素矩阵
matrix.I inverse：返回矩阵的逆矩阵
matrix.A base array：返回矩阵基于的数组
矩阵对象的方法：
all([axis, out]) :沿给定的轴判断矩阵所有元素是否为真(非0即为真)
any([axis, out]) :沿给定轴的方向判断矩阵元素是否为真，只要一个元素为真则为真。
argmax([axis, out]) :沿给定轴的方向返回最大元素的索引（最大元素的位置）.
argmin([axis, out]): 沿给定轴的方向返回最小元素的索引（最小元素的位置）
argsort([axis, kind, order]) :返回排序后的索引矩阵
astype(dtype[, order, casting, subok, copy]):将该矩阵数据复制，且数据类型为指定的数据类型
byteswap(inplace) Swap the bytes of the array elements
choose(choices[, out, mode]) :根据给定的索引得到一个新的数据矩阵（索引从choices给定）
clip(a_min, a_max[, out]) :返回新的矩阵，比给定元素大的元素为a_max，小的为a_min
compress(condition[, axis, out]) :返回满足条件的矩阵
conj() :返回复数的共轭复数
conjugate() :返回所有复数的共轭复数元素
copy([order]) :复制一个矩阵并赋给另外一个对象，b=a.copy()
cumprod([axis, dtype, out]) :返回沿指定轴的元素累积矩阵
cumsum([axis, dtype, out]) :返回沿指定轴的元素累积和矩阵
diagonal([offset, axis1, axis2]) :返回矩阵中对角线的数据
dot(b[, out]) :两个矩阵的点乘
dump(file) :将矩阵存储为指定文件,可以通过pickle.loads()或者numpy.loads()如:a.dump(&d:\\a.txt&)
dumps() :将矩阵的数据转存为字符串.
fill(value) :将矩阵中的所有元素填充为指定的value
flatten([order]) :将矩阵转化为一个一维的形式，但是还是matrix对象
getA() :返回自己，但是作为ndarray返回
getA1()：返回一个扁平（一维）的数组（ndarray）
getH() :返回自身的共轭复数转置矩阵
getI() :返回本身的逆矩阵
getT() :返回本身的转置矩阵
max([axis, out]) ：返回指定轴的最大值
mean([axis, dtype, out]) :沿给定轴方向，返回其均值
min([axis, out]) ：返回指定轴的最小值
nonzero() :返回非零元素的索引矩阵
prod([axis, dtype, out]) :返回指定轴方型上，矩阵元素的乘积.
ptp([axis, out]) :返回指定轴方向的最大值减去最小值.
put(indices, values[, mode]) :用给定的value替换矩阵本身给定索引（indices）位置的值
ravel([order]) :返回一个数组，该数组是一维数组或平数组
repeat(repeats[, axis]) :重复矩阵中的元素，可以沿指定轴方向重复矩阵元素，repeats为重复次数
reshape(shape[, order]) :改变矩阵的大小,如：reshape([2,3])
resize(new_shape[, refcheck]) :改变该数据的尺寸大小
round([decimals, out]) :返回指定精度后的矩阵，指定的位数采用四舍五入，若为1，则保留一位小数
searchsorted(v[, side, sorter]) :搜索V在矩阵中的索引位置
sort([axis, kind, order]) :对矩阵进行排序或者按轴的方向进行排序
squeeze([axis]) :移除长度为1的轴
std([axis, dtype, out, ddof]) :沿指定轴的方向，返回元素的标准差.
sum([axis, dtype, out]) ：沿指定轴的方向，返回其元素的总和
swapaxes(axis1, axis2):交换两个轴方向上的数据.
take(indices[, axis, out, mode]) :提取指定索引位置的数据,并以一维数组或者矩阵返回(主要取决axis)
tofile(fid[, sep, format]) :将矩阵中的数据以二进制写入到文件
tolist() :将矩阵转化为列表形式
tostring([order]):将矩阵转化为python的字符串.
trace([offset, axis1, axis2, dtype, out]):返回对角线元素之和
transpose(*axes) :返回矩阵的转置矩阵，不改变原有矩阵
var([axis, dtype, out, ddof]) ：沿指定轴方向，返回矩阵元素的方差
view([dtype, type]) :生成一个相同数据，但是类型为指定新类型的矩阵。
&& All方法
&&& a = np.asmatrix('0 2 7; 3 4 8; 5 0 9')
&&& a.all()
&&& a.all(axis=0)
matrix([[False, False,& True]], dtype=bool)
&&& a.all(axis=1)
matrix([[False],
[False]], dtype=bool)
&& Astype方法
&&& a.astype(float)
matrix([[ 12.,&& 3.,&& 5.],
[ 32.,& 23.,&& 9.],
[ 10., -14.,& 78.]])
&& Argsort方法
&&& a=np.matrix('12 3 5; 32 23 9; 10 -14 78')
&&& a.argsort()
matrix([[1, 2, 0],
[2, 1, 0],
[1, 0, 2]])
&& Clip方法
matrix([[ 12,&& 3,&& 5],
[ 32,& 23,&& 9],
[ 10, -14,& 78]])
&&& a.clip(12,32)
matrix([[12, 12, 12],
[32, 23, 12],
[12, 12, 32]])
&& Cumprod方法
&&& a.cumprod(axis=1)
matrix([[&&& 12,&&&& 36,&&& 180],
[&&& 32,&&& 736,&& 6624],
[&&& 10,&& -140, -10920]])
&& Cumsum方法
&&& a.cumsum(axis=1)
matrix([[12, 15, 20],
[32, 55, 64],
[10, -4, 74]])
&& Tolist方法
&&& b.tolist()
[[12, 3, 5], [32, 23, 9], [10, -14, 78]]
&& Tofile方法
&&& b.tofile('d:\\b.txt')
&& compress()方法
&&& from numpy import *
&&& a = array([10, 20, 30, 40])
&&& condition = (a & 15) & (a & 35)
&&& condition
array([False, True, True, False], dtype=bool)
&&& a.compress(condition)
array([20, 30])
&&& a[condition]&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& # same effect
array([20, 30])
&&& compress(a &= 30, a)&&&&&&&&&&&&&&&&&&&&&&&&&&&&& # this form a
array([30, 40])
&&& b = array([[10,20,30],[40,50,60]])
&&& b.compress(b.ravel() &= 22)
array([30, 40, 50, 60])
&&& x = array([3,1,2])
&&& y = array([50, 101])
&&& b.compress(x &= 2, axis=1)&&&&&&&&&&&&&&&&&&&&&& # illustrates
the use of the axis keyword
array([[10, 30],
[40, 60]])
&&& b.compress(y &= 100, axis=0)
array([[40, 50, 60]])
阅读(...) 评论()使用numpy前需要先导入
import numpy
一、建立矩阵
a = numpy.array([[1,2,3],[4,5,6],[7,8,9]])
b = numpy.array([[1,2], [3,4]], dtype=complex )
从tuple建立
a = [[1,2,3],[4,5,6],[7,8,9]]
b = numpy.array(a)
建立特殊矩阵
a = numpy.zeros([4,5]) # all zero
a = numpy.ones([7,6]) # all one
a = numpy.eye(4,7) # 4x7 diagonal
a = numpy.diag(range(5)) # 5x5 diagonal
a = numpy.empty((2,3))
a = numpy.arange(10, 30, 5) # array([10, 15, 20, 25]), 1-D
a = numpy.linspace(0, 2, 9) # 9 numbers from 0 to 2
a = numpy.random.random((2,3)) # 随机数矩阵
a = numpy.fromfunction(f,(5,4),dtype=int) # 从函数f(x,y)建立
二、矩阵变换、变形
a.reshape(-1)
a.reshape(3, 4, -1)
a.T # 转置
a.transpose() # 转置
numpy.linalg.inv(a) # 求逆
a.diagonal([offset, axis1, axis2]) # 对角元
numpy.einsum('iijj-&ij',a)
numpy.r_[a,b] # 在a中增加新行b
numpy.c_[a,b] # 新列
三、一般运算
y = x # 建立引用，修改x会影响y
y = x.copy() # 建立副本，修改x不会影响y
a.dot(b) # 矩阵乘法
numpy.dot(a,b) # 矩阵乘法
numpy.trace(a) #求迹
四、特殊运算
numpy.einsum('iijj-&ij',a)
阅读(...) 评论()python科学计算包numpy使用心得 - CSDN博客
python科学计算包numpy使用心得
1 数据结构
numpy使用一种称为ndarray的类似Matlab的矩阵式数据结构管理数据，比python的列表和标准库的array类更为强大，处理数据更为方便。
1.1 数组的生成
在numpy中，生成数组需要指定数据类型，默认是int32，即整数，可以通过dtype参数来指定，一般用到的有int32、bool、float32、uint32、complex，分别代表整数、布尔值、浮点型、无符号整数和复数
一般而言，生成数组的方法有这么几种：
以list列表为参数生成（用tolist方法即可转换回list）：
In[3]: a = array([1, 2, 3])
Out[4]: array([1, 2, 3])
In[5]: a.tolist()
Out[5]: [1, 2, 3]
指定起点、终点和步长生成等差序列或等比数列：
In[7]: a = arange(1, 10, 2)
Out[8]: array([1, 3, 5, 7, 9])
In[13]: a = linspace(0, 10, 5)
Out[14]: array([
In[148]: a = logspace(0, 3, 10)
In[149]: a
21.5443469 ,
215.443469
从迭代器中生成：
In[17]: iter = (i for i in range(5))
In[18]: a = fromiter(iter, dtype=int32)
Out[19]: array([0, 1, 2, 3, 4])
从函数中生成：
In[156]: def f(i, j):
return abs(i-j)
In[157]: fromfunction(f, (4, 4))
array([[ 0.,
还可以用zeros、ones、empty等函数快速创建数组。
矩阵视为二维数组：
In[24]: b = array([arange(5), arange(1, 6), arange(2, 7)])
array([[0, 1, 2, 3, 4],
[1, 2, 3, 4, 5],
[2, 3, 4, 5, 6]])
根据相同的方法可以拓展到更高维。
另外，我们还可以生成自定义数据格式的数组（称为结构数组），用来记录电子表格或数据库中一行数据的信息：
In[61]: t = dtype([('name', str, 40), ('number', int32), ('score', float32)])
Out[62]: dtype([('name', '&U40'), ('number', '&i4'), ('score', '&f4')])
In[63]: students = array([('Tom', 10, 80), ('Jenny', 11, 90.5), ('Mike', 9, 98.5)], dtype=t)
In[64]: students
array([('Tom', 10, 80.0), ('Jenny', 11, 90.5), ('Mike', 9, 98.5)],
dtype=[('name', '&U40'), ('number', '&i4'), ('score', '&f4')])
In[65]: students[1]
Out[65]: ('Jenny', 11, 90.5)
后面我们会看到pandas提供了一种更精致的方法处理记录。
1.2 数组的索引
简单的下标索引：
In[30]: a[2]
Out[30]: 2
In[31]: b[2, 1]
Out[31]: 3
与python一样，索引的起点为0。负数的索引当然也是可以的：
In[32]: a[-1]
Out[32]: 4
In[33]: b[-1, -2]
Out[33]: 5
以整数数组为下标索引，一次性索引多个值：
In[162]: arange(11, 20)[array([2, 4, 8])]
Out[161]: array([13, 15, 19])
还可以通过布尔值来索引：
In[40]: idx = array([True, False, False, True, True])
In[41]: a[idx]
Out[41]: array([0, 3, 4])
这可以应用在高级索引中，比如条件索引：
Out[42]: array([4, 4, 5, 4, 5, 6])
得到b中所有大于3的元素，以array形式返回，我们能这么写的原因是b&3会返回一个布尔数组，形式与b一致，各位置的值是b中各元素与3比较之后的结果：
In[43]: b&3
array([[False, False, False, False,
[False, False, False,
[False, False,
True]], dtype=bool)
1.3 数组的切片
ndarray数组支持各种形式的切片，既可以以下标为线索，还可以以值为线索，为了区分二者，重新生成一个数组：
a = arange(11, 20)
Out[54]: array([11, 12, 13, 14, 15, 16, 17, 18, 19])
根据下标切片：
In[55]: a[1:4]
Out[55]: array([12, 13, 14])
In[56]: a[1:8:2]
Out[56]: array([12, 14, 16, 18])
In[57]: a[1::2]
Out[57]: array([12, 14, 16, 18])
In[58]: a[:8:]
Out[58]: array([11, 12, 13, 14, 15, 16, 17, 18])
方括号中三个参数为别是起点、终点和步长，默认值分别是0、-1、1，注意终点是不被包含的。可以简单地令步长为-1来翻转数组：
In[60]: a[::-1]
Out[60]: array([19, 18, 17, 16, 15, 14, 13, 12, 11])
ndarray也支持多维数组的切片，先生成一个三维数组，可以通过修改一维数组的shape属性或调用其reshape方法来生成：
In[68]: a = arange(0, 24).reshape(2, 3, 4)
array([[[ 0,
9, 10, 11]],
[[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]]])
多维数组的索引其实跟一维区别不大，可以用:代表选取所有：
In[70]: a[:, 0, 0]
Out[70]: array([ 0, 12])
In[71]: a[0, :, 0]
Out[71]: array([0, 4, 8])
In[72]: a[0, 0, :]
Out[72]: array([0, 1, 2, 3])
In[73]: a[0, 0:2, 0:3]
array([[0, 1, 2],
[4, 5, 6]])
多个冒号还可以用...来代替：
In[74]: a[...,3]
array([[ 3,
[15, 19, 23]])
最后，可以使用slice对象来表示切片，它与用1:10:2形式产生切片类似：
In[169]: idx = slice(None, None, 2)
In[171]: a[idx,idx,idx]
array([[[ 0,
[ 8, 10]]])
相当于a[::2, ::2, ::2]
1.4 数组的变换
可以将上述三维数组展平：
In[75]: a.flatten()
array([ 0,
9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23])
In[77]: b.transpose()
array([[0, 1, 2],
[1, 2, 3],
[2, 3, 4],
[3, 4, 5],
[4, 5, 6]])
修改shape属性来改变维度：
In[79]: a.shape = 4, 6
array([[ 0,
9, 10, 11],
[12, 13, 14, 15, 16, 17],
[18, 19, 20, 21, 22, 23]])
1.5 数组的组合
首先创建一个与a同大小的数组：
In[83]: b = 2*a
可以进行多种方式组合，如水平组合：
In[88]: hstack((a, b))
array([[ 0,
9, 10, 11, 12, 14, 16, 18, 20, 22],
[12, 13, 14, 15, 16, 17, 24, 26, 28, 30, 32, 34],
[18, 19, 20, 21, 22, 23, 36, 38, 40, 42, 44, 46]])
垂直组合：
In[89]: vstack((a, b))
array([[ 0,
9, 10, 11],
[12, 13, 14, 15, 16, 17],
[18, 19, 20, 21, 22, 23],
[12, 14, 16, 18, 20, 22],
[24, 26, 28, 30, 32, 34],
[36, 38, 40, 42, 44, 46]])
用concatenate函数可以同时实现这两种方式，通过指定axis参数，默认为0，使用垂直组合。
还可以进行深度组合：
In[91]: dstack((a, b))
array([[[ 0,
[ 5, 10]],
[[ 6, 12],
[11, 22]],
[[12, 24],
[17, 34]],
[[18, 36],
[23, 46]]])
就好像将两张二维平面的点数据沿纵轴方向叠在一起一样。
1.6 数组的分割
水平分割：
In[94]: hsplit(a, 3)
[array([[ 0,
[18, 19]]), array([[ 2,
[20, 21]]), array([[ 4,
[22, 23]])]
垂直分割：
In[97]: vsplit(a, 2)
[array([[ 0,
9, 10, 11]]), array([[12, 13, 14, 15, 16, 17],
[18, 19, 20, 21, 22, 23]])]
用split函数可以同时实现这两个效果，通过设置其axis参数区别。
类似地，可以通过函数dsplit进行深度分割。
另外可以使用ndarray的一些属性来查看数组的信息：
In[125]: a.ndim
Out[124]: 2
In[126]: a.size
Out[125]: 24
In[127]: a.itemsize
Out[126]: 4
In[128]: a.shape
Out[127]: (4, 6)
In[130]: a.T
array([[ 0,
6, 12, 18],
7, 13, 19],
8, 14, 20],
9, 15, 21],
[ 4, 10, 16, 22],
[ 5, 11, 17, 23]], dtype=int32)
另外多维数组的flat属性可以给出一个”扁平迭代器“——flatiter对象，使我们能像一维数组一样迭代高维数组：
In[134]: for item in array([1, 2, 3, 4]).reshape(2, 2).flat:
print(item)
flatiter对象可以直接获取多个元素，并直接赋值修改：
In[140]: af = a.flat
In[141]: af[:]
array([ 0,
9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23], dtype=int32)
In[143]: af[3] = 15
In[144]: af[:]
array([ 0,
9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23], dtype=int32)
1.7 矩阵的生成
上面提到了可以用二维数组来模拟矩阵，其实，numpy专门提供了一种用于处理矩阵的数据结构——matrix，它通过mat函数构造生成：
In[8]: m = mat('1 2 3; 4 5 6; 7 8 9')
matrix([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
二维数组与矩阵可以很方便地相互转换：
In[11]: array(m)
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
In[12]: mat(_)
matrix([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
用matrix来处理矩阵更方便，有更多方法以供使用，如：
In[17]: m.I
matrix([[ -4.,
分块矩阵：
In[25]: I = eye(3)
In[26]: bmat('m I; I m')
matrix([[ 1.,
2 数据处理
2.1 条件判断和搜索
用where函数可以得到满足条件的索引，便于后期处理：
In[219]: a = arange(24).reshape(4, 6)
In[220]: where(a&8)
(array([1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3], dtype=int32),
array([3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5], dtype=int32))
用compress函数可以筛选出一维数组中满足条件的值：
In[28]: a[0, :].compress(a[0, :] & 2)
Out[28]: array([3, 4, 5])
2.2 CSV文件读写
CSV（逗号分割值）格式可以简单方便地保存数组或矩阵。相比于python的pickle方法，保存为CSV文件可以用一般文本编辑器随时打开查看。保存和读取CSV文件都很简单。
In[190]: b
array([[ 0,
[12, 14, 16, 18, 20, 22],
[24, 26, 28, 30, 32, 34],
[36, 38, 40, 42, 44, 46]])
In[191]: savetxt("b.txt", b, delimiter=",")
In[192]: b1, b2 = loadtxt("b.txt", delimiter=",", usecols=(3, 4), unpack=True)
In[193]: b1, b2
Out[192]: (array([
42.]), array([
保存时参数delimiter可选，用来分隔数组各元素，读取时也要相应地指定这个值，读取时也可只读取部分数据，usecols即用来指定选取的列，unpack设置为True时表示将这些列分开存储。
读写时遇到字符串（如时间）可以通过指定参数converters来转换。
def datestr2num(s):
return datetime.datetime.strptime(str(s, encoding="utf-8"), "%Y-%m-%d").date().weekday()
weeks, numbers = loadtxt("b.txt", converters={0:datestr2num}, unpack=True)
In[253]: weeks
Out[252]: array([ 2.,
2.3 通用函数
用frompyfunc函数可以将一个作用在单一数值的函数映射到作用在数组上的函数：
In[49]: def f(i):
return 2*i
In[50]: ff = frompyfunc(f, 1, 1)
In[52]: ff(a)
array([[0, 2, 4, 6, 8, 10],
[12, 14, 16, 18, 20, 22],
[24, 26, 28, 30, 32, 34],
[36, 38, 40, 42, 44, 46]], dtype=object)
frompyfunc的两个参数分别定义输入参数和输出参数的个数
另外，numpy提供了一些常用的通用函数，如针对加减乘除的add、subtract、multiply和divide。通用函数都有四个方法：reduce、accumulate、reduceat和outer，以add函数为例：
In[64]: add.reduce(a[0, :])
Out[64]: 15
In[65]: add.accumulate(a[0,:])
Out[65]: array([ 0,
6, 10, 15], dtype=int32)
In[69]: add.reduceat(a[0, :], [0, 5, 2, 4])
Out[69]: array([10,
9], dtype=int32)
In[70]: add.outer(a[0, :], a[1, :])
array([[ 6,
9, 10, 11],
9, 10, 11, 12],
9, 10, 11, 12, 13],
[ 9, 10, 11, 12, 13, 14],
[10, 11, 12, 13, 14, 15],
[11, 12, 13, 14, 15, 16]])
可见，reduce是将通用函数递归作用在所有元素上，得到最后结果；accumulate也是递归作用在所有元素上，不过它保留中间结果并返回；reduceat则根据指定的起始点进行累积运算，如果终点小于起点，则返回终点处的值；最后outer则是对两个输入数组的所有元素组合进行运算。
3 科学计算
3.1 统计分析
3.1.1 基本统计分析
average函数可以非常方便地计算加权平均值，或者用mean计算算术平均值：
In[204]: a = array([1, 2])
In[205]: average(a, weights=[1,2])
Out[204]: 1.6667
基本统计分析函数整理如下：
中位数：median
标准差：std
差分：diff
最值：max、min、argmax、argmin（后两个得到最值所在的下标）
3.1.2 随机过程分析
3.2 线性代数
先生成一个各元素是0～1之内的随机数的矩阵：
In[47]: a = mat(fromiter((random.random() for i in range(9)), dtype = float32).reshape(3, 3))
matrix([[ 0.,
[ 0.6454953 ,
0.]], dtype=float32)
接下我们可以对它进行各种线性代数的操作， 如：
In[49]: a.I
matrix([[-10., -14.,
2.7832334 ,
8., -10.]], dtype=float32)
解线性方程组（用点积验证了结果）：
In[59]: b = fromiter((random.random() for i in range(3)), dtype = float32)
Out[60]: array([ 0.,
0.], dtype=float32)
In[61]: linalg.solve(a, b)
Out[61]: array([-5.3072257 ,
3.], dtype=float32)
In[63]: dot(a, _)
Out[63]: matrix([[ 0.,
0.]], dtype=float32)
求特征值和特征向量：
In[64]: linalg.eig(a)
(array([ 1., -0., -0.], dtype=float32),
matrix([[-0.5075314 , -0.,
0.4528676 , -0.],
0., -0.]], dtype=float32))
In[81]: linalg.det(a)
Out[81]: 0.
本文已收录于以下专栏：
相关文章推荐
注：NumPy是Numarray的后继者，用来代替NumArray。SAGE是基于NumPy和其他几个工具所整合成的数学软件包，目标是取代Magma, Maple, Mathematica和Matla...
Python下大多数工具包的安装都很简单，只需要执行 “python setup.py install”命令即可。然而，由于SciPy和numpy这两个科学计算包的依赖关系较多，安装过程较为复杂。网上...
Python科学计算包NumPy在机器学习过程中设计很多线性代数知识，因此会经常使用NumPy函数库。Numpy可以在不同的数据点上执行矩阵形式的数学运算而不需要复杂的循环操作。对于初学者，在安装py...
转自：(Python科学计算包)NumPy文档：8.2矩阵对象，保存在此以学习。
注：NumPy是Numarray的后继者，用来代替NumArray。SAGE是基于NumPy和其他几个工具所整合...
numpy中的数据操作
1，广播：对 形状不同 的数组的运算采取的操作。但是这个输入的数组中必须有一个 某轴长度为1，或者缺 少了一个维度（这个时候会自动的在shape属性前面补上1）。例如：
&&& import n...
他的最新文章
讲师：宋宝华
讲师：何宇健
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)