您所在位置： &
&nbsp&&nbsp&nbsp&&nbsp
Mg-%2c2-x-Ti-%2c1%3dy-Ni-%2cx-Mn-%2cy-(O-X-10%2c0-y-1)合金体系性能研究.pdf 76页
本文档一共被下载：
次 ,您可全文免费在线阅读后下载本文档。
下载提示
1.本站不保证该用户上传的文档完整性，不预览、不比对内容而直接下载产生的反悔问题本站不予受理。
2.该文档所得收入(下载+内容+预览三)归上传者、原创者。
3.登录后可充值，立即自动返金币，充值渠道很便利
优秀毕业论文，完美PDF格式，可在线免费浏览全文和下载,支持复制编辑,可为大学生本专业本院系本科专科大专和研究生相关类学生提供毕业论文范文范例指导,也可为要代写发表职称论文提供参考！！！
你可能关注的文档：
··········
··········
@南开大掌硕士掌位论文
环境污染问题和对能源日益增长的需求促进了高能量密度清洁
能源的研究。对比于任何一种可能的替代燃料，在可逆性、储量和
环保等方面，氢能都是上上之选。与储氢合金相关的能源材料因此
成为热点选择之一。其中的镁基合金以其低成本、高能量密度成为
研究关注的重点。
本文以固相扩散法合成Mg：．xNil-yTi。Mn，系列合金，并对该系列
合金的物相、电化学性质(充放电容量、循环伏安性质等)、气固相
反应性能等做了深入的研究。
x射线分析及多重RIETVELD分析证实，该系列合金中存在一
种新相。该相以立方晶系A3BC：的形式(F。，。)存在，其中A对应
Mg，C对应Ni，而B对应Ti及Mn的某种微结构。
实验证实此新相是能够发生吸放氢反应的。新相成为继Mg，Ni
之后发现的另一个能够吸放氢的镁镍合金相。
对于该合金相的进一步研究表明，此新相不管在电化学容量方
面还是在气固相反应方面的表现都极为突出。该合金的某一组分在
VSHgO／Hg)。此结果在圃相扩散法中是已见到报道的最高结果。在
以前的实验中，固相扩散法合成的合金在容量上不尽人意，本论文
的结果是一个突破，为固相扩散法合成的合金应用于电化学打下了
坚实的基础。
同时该系列合金的气固相性能也相当突出，其中一种组份
(MgI90TioloNio．90Mn0
lo)放氢量达到了355．26
H2(s．T．P)／g
从微观结构上考虑，我们将此合金的优越性能归因于其晶格结
构。新相的晶胞体积较之MgzNi大了很多，有利于氢在体相中扩散
的发生，从而有利于吸放氢。同时，合金表面的缺陷对于吸放氢也
有促进作用。
@南开大掌硕士掌位论文
我们在实验中还探索了一种对固相扩散法合成的合金进行后续
处理的方法。用普通的球磨机和较少的时间对固相扩散法得到的样
品进行了球磨处理，我们称之为扩散一球磨处理法(DM，G)。如此
VS．HgO／Hg)。
处理得到的合金电化学容量达到了580mAh／g(．0．5V
就本研究的数据而言，已经可以看到镁基合金实际应用的希望。
未来只要在抗腐蚀性和吸放氢速度方面有大的突破，相信镁氢合金
大规模应用就不会再只是梦想了。
关键词：镁基储氢合金固相扩散法新相电化学性能气固相性能
@南开大掌硕士掌位论文
energyprompt
increasing
thealternative
clean material
density．Regarding
highenergy
正在加载中，请稍后...& 解方程2.5x-1.1=0.9；710x+110x=10；0
本题难度：0.50&&题型：解答题
解方程2.5x-1.1=0.9；&&&&&&&&&&&&&x+x=10；&&&&&&&&&&0.9x÷5=1.8．
来源：学年新人教版六年级（上）期末数学模拟试卷（49） | 【考点】方程的解和解方程．
x=2.5是方程（　　）的解．
A、x÷2.5=2.5B、2.5-x=1C、2.5÷x=1D、2.5x=2.5
用换元法解方程2-3+2-3y=时，如果设x=2-3，那么原方程可化为（　　）
A、2x2-5x+2=0B、x2-5x+1=0C、2x2+5x+2=0D、2x2-5x+1=0
在解方程时，去分母正确的是（　　）
A、（5x-1）=（2x+1）-（2-x）B、2（5x-1）=3（2x+1）-2-xC、10x-1=6x+1-2+xD、2（5x-1）=3（2x+1）-（2-x）
下列方程中，解是-的方程是（　　）
A、x-2=2-xB、2.5x=1.5-0.5xC、x-=-D、x-1=3x
用换元法解下列方程，不恰当的“换元”是（　　）
A、对于方程，设=yB、对于方程x2+3x-2+3x+2=8，设y=x2+3x+2C、对于方程（x+）+（x2+2）=2，设y=D、对于方程2+6=，设y=
解析与答案
（揭秘难题真相，上）
习题“解方程2.5x-1.1=0.9；710x+110x=10；0.9x÷5=1.8．”的学库宝（http://www.xuekubao.com/）教师分析与解答如下所示：
【分析】（1）方程的两边同时加上11再同时除以25即可得解（2）先将原方程变形为45x=10方程的两边同时除以45即可得解（3）方程的两边同时乘上5再同时除以09即可得解．
【解答】解：（1）25x-11=09&nbsp&nbsp&nbsp 25x-11+11=09+11&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp &nbsp 25x=2&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp 25x÷25=2÷25&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp x=08（2）710x+110x=10&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp 45x=10&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp 45x÷45=10÷45&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp x=252（3）09x÷5=18&nbsp&nbsp 09x÷5×5=18×5&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp 09x=9&nbsp&nbsp&nbsp 09x÷09=9÷09&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbspx=10．
【考点】方程的解和解方程．
查看答案和解析
微信扫一扫手机看答案
知识点讲解
经过分析，习题“解方程2.5x-1.1=0.9；710x+110x=10；0”主要考察你对
等考点的理解。
因为篇幅有限，只列出部分考点，详细请访问。
方程的解与解方程
1.方程的解的定义：方程两边左右相等的未知数的值叫做方程的解。 2.解方程：求方程的解的过程叫做解方程。
名师视频同步辅导
1&&&&2&&&&3&&&&4&&&&5&&&&6&&&&7&&&&8&&&&9&&&&10&&&&11&&&&12&&&&13&&&&14&&&&15&&&&
作业互助QQ群：(小学)、(初中)、(高中)209,776被浏览4,433,870分享邀请回答53K615 条评论分享收藏感谢收起18K482 条评论分享收藏感谢收起博客访问： 1767579
博文数量： 191
博客积分： 3184
博客等级： 中校
技术积分： 3927
注册时间：
IT168企业级官微
微信号：IT168qiye
系统架构师大会
微信号：SACC2013
分类： Python/Ruby
迭代多维数组是就第一个轴而言的:
>>> for row in b:
[10 11 12 13]
[20 21 22 23]
[30 31 32 33]
[40 41 42 43]
然而，如果一个人想对每个数组中元素进行运算，我们可以使用flat属性，该属性是数组元素的一个迭代器:
>>> for element in b.flat:
print element,
0 1 2 3 10 11 12 13 20 21 22 23 30 31 32 33 40 41 42 43
更多[], …, newaxis, ndenumerate, indices, index exp 参考
更改数组的形状
一个数组的形状由它每个轴上的元素个数给出：
>>> a = floor(10*random.random((3,4)))
array([[ 7.,
>>> a.shape
一个数组的形状可以被多种命令修改：
>>> a.ravel() # flatten the array
array([ 7.,
>>> a.shape = (6, 2)
>>> a.transpose()
array([[ 7.,
由ravel()展平的数组元素的顺序通常是“C风格”的，就是说，最右边的索引变化得最快，所以元素a[0,0]之后是a[0,1]。如果数组被改变形状(reshape)成其它形状，数组仍然是“C风格”的。NumPy通常创建一个以这个顺序保存数据的数组，所以ravel()将总是不需要复制它的参数。但是如果数组是通过切片其它数组或有不同寻常的选项时，它可能需要被复制。函数reshape()和ravel()还可以被同过一些可选参数构建成FORTRAN风格的数组，即最左边的索引变化最快。
reshape函数改变参数形状并返回它，而resize函数改变数组自身。
array([[ 7.,
>>> a.resize((2,6))
array([[ 7.,
如果在改变形状操作中一个维度被给做-1，其维度将自动被计算
更多 shape, reshape, resize, ravel 参考
组合(stack)不同的数组
几种方法可以沿不同轴将数组堆叠在一起：
>>> a = floor(10*random.random((2,2)))
array([[ 1.,
>>> b = floor(10*random.random((2,2)))
array([[ 3.,
>>> vstack((a,b))
array([[ 1.,
>>> hstack((a,b))
array([[ 1.,
函数column_stack以列将一维数组合成二维数组，它等同与vstack对一维数组。
>>> column_stack((a,b))
# With 2D arrays
array([[ 1.,
>>> a=array([4.,2.])
>>> b=array([2.,8.])
>>> a[:,newaxis]
# This allows to have a 2D columns vector
array([[ 4.],
>>> column_stack((a[:,newaxis],b[:,newaxis]))
array([[ 4.,
>>> vstack((a[:,newaxis],b[:,newaxis])) # The behavior of vstack is different
array([[ 4.],
row_stack函数，另一方面，将一维数组以行组合成二维数组。
对那些维度比二维更高的数组，hstack沿着第二个轴组合，vstack沿着第一个轴组合,concatenate允许可选参数给出组合时沿着的轴。
在复杂情况下，r_[]和c_[]对创建沿着一个方向组合的数很有用，它们允许范围符号(“:”):
>>> r_[1:4,0,4]
array([1, 2, 3, 0, 4])
当使用数组作为参数时，r_和c_的默认行为和vstack和hstack很像，但是允许可选的参数给出组合所沿着的轴的代号。
更多函数hstack , vstack, column_stack , row_stack , concatenate , c_ , r_ 参见.
将一个数组分割(split)成几个小数组
使用hsplit你能将数组沿着它的水平轴分割，或者指定返回相同形状数组的个数，或者指定在哪些列后发生分割:
>>> a = floor(10*random.random((2,12)))
array([[ 8.,
>>> hsplit(a,3)
# Split a into 3
[array([[ 8.,
9.]]), array([[ 0.,
5.]]), array([[ 0.,
>>> hsplit(a,(3,4))
# Split a after the third and the fourth column
[array([[ 8.,
2.]]), array([[ 9.],
[ 9.]]), array([[ 0.,
vsplit沿着纵向的轴分割，array split允许指定沿哪个轴分割。
复制和视图
当运算和处理数组时，它们的数据有时被拷贝到新的数组有时不是。这通常是新手的困惑之源。这有三种情况:
完全不拷贝
简单的赋值不拷贝数组对象或它们的数据。
>>> a = arange(12)
# no new object is created
>>> b is a
# a and b are two names for the same ndarray object
>>> b.shape = 3,4
# changes the shape of a
>>> a.shape
Python 传递不定对象作为参考，所以函数调用不拷贝数组。
>>> def f(x):
print id(x)
# id is a unique identifier of an object
视图(view)和浅复制
不同的数组对象分享同一个数据。视图方法创造一个新的数组对象指向同一数据。
>>> c = a.view()
>>> c is a
>>> c.base is a
# c is a view of the data owned by a
>>> c.flags.owndata
>>> c.shape = 2,6
# a's shape doesn't change
>>> a.shape
>>> c[0,4] = 1234
# a's data changes
切片数组返回它的一个视图：
>>> s = a[ : , 1:3]
# spac could also be written "s = a[:,1:3]"
>>> s[:] = 10
# s[:] is a view of s. Note the difference between s=10 and s[:]=10
这个复制方法完全复制数组和它的数据。
>>> d = a.copy()
# a new array object with new data is created
>>> d is a
>>> d.base is a
# d doesn't share anything with a
>>> d[0,0] = 9999
函数和方法(method)总览
这是个NumPy函数和方法分类排列目录。这些名字链接到,你可以看到这些函数起作用。
arange, array, copy, empty, empty_like, eye, fromfile, fromfunction, identity, linspace, logspace, mgrid, ogrid, ones, ones_like, r , zeros, zeros_like
astype, atleast 1d, atleast 2d, atleast 3d, mat
array split, column stack, concatenate, diagonal, dsplit, dstack, hsplit, hstack, item, newaxis, ravel, repeat, reshape, resize, squeeze, swapaxes, take, transpose, vsplit, vstack
all, any, nonzero, where
argmax, argmin, argsort, max, min, ptp, searchsorted, sort
choose, compress, cumprod, cumsum, inner, fill, imag, prod, put, putmask, real, sum
cov, mean, std, var
基本线性代数
cross, dot, outer, svd, vdot
广播法则(rule)
广播法则能使通用函数有意义地处理不具有相同形状的输入。
广播第一法则是，如果所有的输入数组维度不都相同，一个“1”将被重复地添加在维度较小的数组上直至所有的数组拥有一样的维度。
广播第二法则确定长度为1的数组沿着特殊的方向表现地好像它有沿着那个方向最大形状的大小。对数组来说，沿着那个维度的数组元素的值理应相同。
应用广播法则之后，所有数组的大小必须匹配。更多细节可以从这个找到。
花哨的索引和索引技巧
NumPy比普通Python序列提供更多的索引功能。除了索引整数和切片，正如我们之前看到的，数组可以被整数数组和布尔数组索引。
通过数组索引
>>> a = arange(12)**2
# the first 12 square numbers
>>> i = array( [ 1,1,3,8,5 ] )
# an array of indices
# the elements of a at the positions i
array([ 1,
9, 64, 25])
>>> j = array( [ [ 3, 4], [ 9, 7 ] ] )
# a bidimensional array of indices
# the same shape as j
array([[ 9, 16],
[81, 49]])
当被索引数组a是多维的时，每一个唯一的索引数列指向a的第一维[^5]。以下示例通过将图片标签用调色版转换成色彩图像展示了这种行为。
>>> palette = array( [ [0,0,0],
[255,0,0],
[0,255,0],
[0,0,255],
[255,255,255] ] )
>>> image = array( [ [ 0, 1, 2, 0 ],
# each value corresponds to a color in the palette
[ 0, 3, 4, 0 ]
>>> palette[image]
# the (2,4,3) color image
[255, 255, 255],
我们也可以给出不不止一维的索引，每一维的索引数组必须有相同的形状。
>>> a = arange(12).reshape(3,4)
array([[ 0,
9, 10, 11]])
>>> i = array( [ [0,1],
# indices for the first dim of a
>>> j = array( [ [2,1],
# indices for the second dim
>>> a[i,j]
# i and j must have equal shape
array([[ 2,
[ 7, 11]])
>>> a[i,2]
array([[ 2,
[ 6, 10]])
>>> a[:,j]
# i.e., a[ : , j]
array([[[ 2,
[11, 11]]])
自然，我们可以把i和j放到序列中(比如说列表)然后通过list索引。
>>> l = [i,j]
# equivalent to a[i,j]
array([[ 2,
[ 7, 11]])
然而，我们不能把i和j放在一个数组中，因为这个数组将被解释成索引a的第一维。
>>> s = array( [i,j] )
# not what we want
---------------------------------------------------------------------------
IndexError
Traceback (most recent call last)
----> 1 a[s]
IndexError: index (3) out of range (0<=index>>
>>> a[tuple(s)]
# same as a[i,j]
array([[ 2,
[ 7, 11]])
另一个常用的数组索引用法是搜索时间序列最大值。
>>> time = linspace(20, 145, 5)
# time scale
>>> data = sin(arange(20)).reshape(5,4)
# 4 time-dependent series
array([[ 0.
[-0.7568025 , -0., -0.2794155 ,
0.6569866 ],
0., -0., -0.],
[-0., -0., -0.,
>>> ind = data.argmax(axis=0)
# index of the maxima for each series
array([2, 0, 3, 1])
>>> time_max = time[ ind]
# times corresponding to the maxima
>>> data_max = data[ind, xrange(data.shape[1])] # => data[ind[0],0], data[ind[1],1]...
>>> time_max
>>> data_max
array([ 0.,
0.6569866 ])
>>> all(data_max == data.max(axis=0))
你也可以使用数组索引作为目标来赋值：
>>> a = arange(5)
array([0, 1, 2, 3, 4])
>>> a[[1,3,4]] = 0
array([0, 0, 2, 0, 0])
然而，当一个索引列表包含重复时，赋值被多次完成，保留最后的值：
>>> a = arange(5)
>>> a[[0,0,2]]=[1,2,3]
array([2, 1, 3, 3, 4])
这足够合理，但是小心如果你想用Python的+=结构，可能结果并非你所期望：
>>> a = arange(5)
>>> a[[0,0,2]]+=1
array([1, 1, 3, 3, 4])
即使0在索引列表中出现两次，索引为0的元素仅仅增加一次。这是因为Python要求a+=1和a=a+1等同。
通过布尔数组索引
当我们使用整数数组索引数组时，我们提供一个索引列表去选择。通过布尔数组索引的方法是不同的我们显式地选择数组中我们想要和不想要的元素。
我们能想到的使用布尔数组的索引最自然方式就是使用和原数组一样形状的布尔数组。
>>> a = arange(12).reshape(3,4)
>>> b = a > 4
# b is a boolean with a's shape
array([[False, False, False, False],
[False, True, True, True],
[True, True, True, True]], dtype=bool)
# 1d array with the selected elements
array([ 5,
9, 10, 11])
这个属性在赋值时非常有用：
>>> a[b] = 0
# All elements of 'a' higher than 4 become 0
array([[0, 1, 2, 3],
[4, 0, 0, 0],
[0, 0, 0, 0]])
你可以参考看看如何使用布尔索引来生成曼德博集合的图像。
第二种通过布尔来索引的方法更近似于整数索引；对数组的每个维度我们给一个一维布尔数组来选择我们想要的切片。
>>> a = arange(12).reshape(3,4)
>>> b1 = array([False,True,True])
# first dim selection
>>> b2 = array([True,False,True,False])
# second dim selection
>>> a[b1,:]
# selecting rows
array([[ 4,
9, 10, 11]])
# same thing
array([[ 4,
9, 10, 11]])
>>> a[:,b2]
# selecting columns
array([[ 0,
[ 8, 10]])
>>> a[b1,b2]
# a weird thing to do
array([ 4, 10])
注意一维数组的长度必须和你想要切片的维度或轴的长度一致，在之前的例子中，b1是一个秩为1长度为三的数组(a的行数)，b2(长度为4)与a的第二秩(列)相一致。
ix_函数可以为了获得的结果而用来结合不同向量。例如，如果你想要用所有向量a、b和c元素组成的三元组来计算a+b*c：
>>> a = array([2,3,4,5])
>>> b = array([8,5,4])
>>> c = array([5,4,6,8,3])
>>> ax,bx,cx = ix_(a,b,c)
array([[[2]],
array([[[8],
array([[[5, 4, 6, 8, 3]]])
>>> ax.shape, bx.shape, cx.shape
((4, 1, 1), (1, 3, 1), (1, 1, 5))
>>> result = ax+bx*cx
>>> result
array([[[42, 34, 50, 66, 26],
[27, 22, 32, 42, 17],
[22, 18, 26, 34, 14]],
[[43, 35, 51, 67, 27],
[28, 23, 33, 43, 18],
[23, 19, 27, 35, 15]],
[[44, 36, 52, 68, 28],
[29, 24, 34, 44, 19],
[24, 20, 28, 36, 16]],
[[45, 37, 53, 69, 29],
[30, 25, 35, 45, 20],
[25, 21, 29, 37, 17]]])
>>> result[3,2,4]
>>> a[3]+b[2]*c[4]
你也可以实行如下简化：
def ufunc_reduce(ufct, *vectors):
vs = ix_(*vectors)
r = ufct.identity
for v in vs:
r = ufct(r,v)
然后这样使用它：
>>> ufunc_reduce(add,a,b,c)
array([[[15, 14, 16, 18, 13],
[12, 11, 13, 15, 10],
[11, 10, 12, 14,
[[16, 15, 17, 19, 14],
[13, 12, 14, 16, 11],
[12, 11, 13, 15, 10]],
[[17, 16, 18, 20, 15],
[14, 13, 15, 17, 12],
[13, 12, 14, 16, 11]],
[[18, 17, 19, 21, 16],
[15, 14, 16, 18, 13],
[14, 13, 15, 17, 12]]])
这个reduce与ufunc.reduce(比如说add.reduce)相比的优势在于它利用了广播法则，避免了创建一个输出大小乘以向量个数的参数数组。
用字符串索引
继续前进，基本线性代数包含在这里。
简单数组运算
参考numpy文件夹中的linalg.py获得更多信息
>>> from numpy import *
>>> from numpy.linalg import *
>>> a = array([[1.0, 2.0], [3.0, 4.0]])
>>> print a
>>> a.transpose()
array([[ 1.,
>>> inv(a)
array([[-2. ,
[ 1.5, -0.5]])
>>> u = eye(2) # unit 2x2 "eye" represents "I"
array([[ 1.,
>>> j = array([[0.0, -1.0], [1.0, 0.0]])
>>> dot (j, j) # matrix product
array([[-1.,
[ 0., -1.]])
>>> trace(u)
>>> y = array([[5.], [7.]])
>>> solve(a, y)
array([[-3.],
>>> eig(j)
(array([ 0.+1.j,
array([[ 0..j,
Parameters:
square matrix
The eigenvalues, each repeated according to its multiplicity.
The normalized (unit "length") eigenvectors, such that the
column ``v[:,i]`` is the eigenvector corresponding to the
eigenvalue ``w[i]`` .
这是一个关于矩阵类的简短介绍。
>>> A = matrix('1.0 2.0; 3.0 4.0')
>>> type(A)
# file where class is defined
# transpose
>>> X = matrix('5.0 7.0')
>>> Y = X.T
>>> print A*Y
# matrix multiplication
>>> print A.I
[ 1.5 -0.5]]
>>> solve(A, Y)
# solving linear equation
matrix([[-3.],
索引：比较矩阵和二维数组
注意NumPy中数组和矩阵有些重要的区别。NumPy提供了两个基本的对象：一个N维数组对象和一个通用函数对象。其它对象都是建构在它们之上的。特别的，矩阵是继承自NumPy数组对象的二维数组对象。对数组和矩阵，索引都必须包含合适的一个或多个这些组合：整数标量、省略号(ellipses)、整数列表;布尔值，整数或布尔值构成的元组，和一个一维整数或布尔值数组。矩阵可以被用作矩阵的索引，但是通常需要数组、列表或者其它形式来完成这个任务。
像平常在Python中一样，索引是从0开始的。传统上我们用矩形的行和列表示一个二维数组或矩阵，其中沿着0轴的方向被穿过的称作行，沿着1轴的方向被穿过的是列。
让我们创建数组和矩阵用来切片：
>>> A = arange(12)
array([ 0,
9, 10, 11])
>>> A.shape = (3,4)
>>> M = mat(A.copy())
>>> print type(A),"
>>> print A
>>> print M
现在，让我们简单的切几片。基本的切片使用切片对象或整数。例如，A[:]和M[:]的求值将表现得和Python索引很相似。然而要注意很重要的一点就是NumPy切片数组不创建数据的副本;切片提供统一数据的视图。
>>> print A[:]; print A[:].shape
>>> print M[:]; print M[:].shape
现在有些和Python索引不同的了：你可以同时使用逗号分割索引来沿着多个轴索引。
>>> print A[:,1]; print A[:,1].shape
>>> print M[:,1]; print M[:,1].shape
注意最后两个结果的不同。对二维数组使用一个冒号产生一个一维数组，然而矩阵产生了一个二维矩阵。例如，一个M[2,:]切片产生了一个形状为(1,4)的矩阵，相比之下，一个数组的切片总是产生一个最低可能维度的数组。例如，如果C是一个三维数组，C[...,1]产生一个二维的数组而C[1,:,1]产生一个一维数组。从这时开始，如果相应的矩阵切片结果是相同的话，我们将只展示数组切片的结果。
假如我们想要一个数组的第一列和第三列，一种方法是使用列表切片：
>>> A[:,[1,3]]
array([[ 1,
[ 9, 11]])
稍微复杂点的方法是使用take()方法(method):
>>> A[:,].take([1,3],axis=1)
array([[ 1,
[ 9, 11]])
如果我们想跳过第一行，我们可以这样：
>>> A[1:,].take([1,3],axis=1)
array([[ 5,
[ 9, 11]])
或者我们仅仅使用A[1:,[1,3]]。还有一种方法是通过矩阵向量积(叉积)。
>>> A[ix_((1,2),(1,3))]
array([[ 5,
[ 9, 11]])
为了读者的方便，在次写下之前的矩阵：
>>> A[ix_((1,2),(1,3))]
array([[ 5,
[ 9, 11]])
现在让我们做些更复杂的。比如说我们想要保留第一行大于1的列。一种方法是创建布尔索引：
>>> A[0,:]>1
array([False, False, True, True], dtype=bool)
>>> A[:,A[0,:]>1]
array([[ 2,
[10, 11]])
就是我们想要的！但是索引矩阵没这么方便。
>>> M[0,:]>1
matrix([[False, False, True, True]], dtype=bool)
>>> M[:,M[0,:]>1]
matrix([[2, 3]])
这个过程的问题是用“矩阵切片”来切片产生一个矩阵，但是矩阵有个方便的A属性，它的值是数组呈现的。所以我们仅仅做以下替代：
>>> M[:,M.A[0,:]>1]
matrix([[ 2,
[10, 11]])
如果我们想要在矩阵两个方向有条件地切片，我们必须稍微调整策略，代之以：
>>> A[A[:,0]>2,A[0,:]>1]
array([ 6, 11])
>>> M[M.A[:,0]>2,M.A[0,:]>1]
matrix([[ 6, 11]])
我们需要使用向量积ix_:
>>> A[ix_(A[:,0]>2,A[0,:]>1)]
array([[ 6,
[10, 11]])
>>> M[ix_(M.A[:,0]>2,M.A[0,:]>1)]
matrix([[ 6,
[10, 11]])
技巧和提示
下面我们给出简短和有用的提示。
“自动”改变形状
更改数组的维度，你可以省略一个尺寸，它将被自动推导出来。
>>> a = arange(30)
>>> a.shape = 2,-1,3
# -1 means "whatever is needed"
>>> a.shape
array([[[ 0,
[ 9, 10, 11],
[12, 13, 14]],
[[15, 16, 17],
[18, 19, 20],
[21, 22, 23],
[24, 25, 26],
[27, 28, 29]]])
向量组合(stacking)
我们如何用两个相同尺寸的行向量列表构建一个二维数组？在MATLAB中这非常简单：如果x和y是两个相同长度的向量，你仅仅需要做m=[x;y]。在NumPy中这个过程通过函数column_stack、dstack、hstack和vstack来完成，取决于你想要在那个维度上组合。例如：
x = arange(0,10,2)
# x=([0,2,4,6,8])
y = arange(5)
# y=([0,1,2,3,4])
m = vstack([x,y])
# m=([[0,2,4,6,8],
[0,1,2,3,4]])
xy = hstack([x,y])
# xy =([0,2,4,6,8,0,1,2,3,4])
二维以上这些函数背后的逻辑会很奇怪。
参考并且在这里添加你的新发现: )
直方图(histogram)
NumPy中histogram函数应用到一个数组返回一对变量：直方图数组和箱式向量。注意：matplotlib也有一个用来建立直方图的函数(叫作hist,正如matlab中一样)与NumPy中的不同。主要的差别是pylab.hist自动绘制直方图，而numpy.histogram仅仅产生数据。
import numpy
import pylab
# Build a vector of 10000 normal deviates with variance 0.5^2 and mean 2
mu, sigma = 2, 0.5
v = numpy.random.normal(mu,sigma,10000)
# Plot a normalized histogram with 50 bins
pylab.hist(v, bins=50, normed=1)
# matplotlib version (plot)
pylab.show()
# Compute the histogram with numpy and then plot it
(n, bins) = numpy.histogram(v, bins=50, normed=True)
# NumPy version (no plot)
pylab.plot(.5*(bins[1:]+bins[:-1]), n)
pylab.show()
阅读(62554) | 评论(0) | 转发(12) |
给主人留下些什么吧！~~
请登录后评论。