前面学习怎么样查看numpy的版本号，这才是刚刚开始，现在来开始更深入地学习一下它，否则以后会很麻烦的，更加看不懂那些例子的代码了。
一个用python实现的科学计算包。包括：
1、一个强大的N维数组对象Array；
2、比较成熟的（广播）函数库；
3、用于整合C/C++和Fortran代码的工具包；
4、实用的线性代数、傅里叶变换和随机数生成函数。
numpy和稀疏矩阵运算包scipy配合使用更加方便。NumPy（Numeric Python）提供了许多高级的数值编程工具，如：矩阵数据类型、矢量处理，以及精密的运算库。专为进行严格的数字处理而产生。多为很多大型金融公司使用，以及核心的科学计算组织如：Lawrence Livermore，NASA用其处理一些本来使用C++，Fortran或Matlab等所做的任务。
NumPy的主要对象是同种元素的多维数组。这是一个所有的元素都是一种类型、通过一个正整数元组索引的元素表格(通常是元素是数字)。在NumPy中维度(dimensions)叫做轴(axes)，轴的个数叫做秩(rank)。
例如，在3D空间一个点的坐标 [1, 2, 3] 是一个秩为1的数组，因为它只有一个轴。那个轴长度为3.又例如，在以下例子中，数组的秩为2(它有两个维度).第一个维度长度为2,第二个维度长度为3.
[[ 1., 0., 0.],
[ 0., 1., 2.]]
NumPy的数组类被称作 ndarray 。通常被称作数组。注意numpy.array和标准Python库类array.array并不相同，后者只处理一维数组和提供少量功能。更多重要ndarray对象属性有：
ndarray.ndim
数组轴的个数，在python的世界中，轴的个数被称作秩
ndarray.shape
数组的维度。这是一个指示数组在每个维度上大小的整数元组。例如一个n排m列的矩阵，它的shape属性将是(2,3),这个元组的长度显然是秩，即维度或者ndim属性
ndarray.size
数组元素的总个数，等于shape属性中元组元素的乘积。
ndarray.dtype
一个用来描述数组中元素类型的对象，可以通过创造或指定dtype使用标准Python类型。另外NumPy提供它自己的数据类型。
ndarray.itemsize
数组中每个元素的字节大小。例如，一个元素类型为float64的数组itemsiz属性值为8(=64/8),又如，一个元素类型为complex32的数组item属性为4(=32/8).
ndarray.data
包含实际数组元素的缓冲区，通常我们不需要使用这个属性，因为我们总是通过索引来使用数组中的元素。
下面来学习一个小例子：
#python 3.5.3 蔡军生
#http://edu.csdn.net/course/detail/2592
#
import numpy as np
a = np.arange(15).reshape(3, 5)
print(a) #显示数组
print(a.shape) #多少行多少列
print(a.ndim) #维度
print(a.dtype.name) #元素类型名称
print(a.itemsize) #每一项的大小
print(a.size) #数组总个数
print(type(a)) #数组类型
b = np.array([6, 7, 8]) #创建数组
print(b)
print(type(b))输出结果如下：
====================== RESTART: D:/AI/sample/tf_1.4.py ======================
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
(3, 5)
2
int32
4
15
<class 'numpy.ndarray'>
[6 7 8]
<class 'numpy.ndarray'>
>>>
用列表来创建数组：
#python 3.5.3 蔡军生
#http://edu.csdn.net/course/detail/2592
#
import numpy as np
#使用列表创建数组
a = np.array( [2,3,4] )
print(a)
#使用列表的元组来创建二维数组
b = np.array( [ (1.5,2,3), (4,5,6) ] )
print(b)
#使用列表的元组来创建三维数组
c = np.array( [ (1.5,2,3), (4,5,6) , (7,8,9)] )
print(c)结果输出如下：
====================== RESTART: D:/AI/sample/tf_1.5.py ======================
[2 3 4]
[[ 1.5 2. 3. ]
[ 4. 5. 6. ]]
[[ 1.5 2. 3. ]
[ 4. 5. 6. ]
[ 7. 8. 9. ]]
>>>
在创建数组时，也可以指定数组元素的类型。同时，由于很多时候，并不知道值是什么，这样就需要创建一个空的数组。比如下面的例子：
#python 3.5.3 蔡军生
#http://edu.csdn.net/course/detail/2592
#
import numpy as np
#使用创建数组时指定类型
c = np.array( [ [1,2], [3,4] ], dtype=complex )
print(c)
#
d = np.zeros( (3, 4) )
print(d)
e = np.ones( (2,3,4), dtype=np.int16 )
print(e)
f = np.empty( (2,3) )
print(f)结果输出如下：
====================== RESTART: D:/AI/sample/tf_1.6.py ======================
[[ 1.+0.j 2.+0.j]
[ 3.+0.j 4.+0.j]]
[[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]
[ 0. 0. 0. 0.]]
[[[1 1 1 1]
[1 1 1 1]
[1 1 1 1]]
[[1 1 1 1]
[1 1 1 1]
[1 1 1 1]]]
[[ 0. 0. 0.]
[ 0. 0. 0.]]
>>>
为了创建一些序数数组，那么使用列表就不是那么方便了，因而numpy提供创建的函数arange，它与range是相似的功能，使用如下：
#python 3.5.3 蔡军生
#http://edu.csdn.net/course/detail/2592
#
import numpy as np
#使用函数arange创建等距离的数组
a = np.arange( 10, 30, 5 )
print(a)
a = np.arange( 10, 30, 1 )
print(a)
a = np.arange( 10, 30, 2.2 )
print(a)结果输出如下：
====================== RESTART: D:/AI/sample/tf_1.7.py ======================
[10 15 20 25]
[10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29]
[ 10. 12.2 14.4 16.6 18.8 21. 23.2 25.4 27.6 29.8]
>>>
可见函数arange是类似于python的range函数，通过指定开始值、终值和步长来创建一维数组，注意数组不包括终值。
如果想改变这些一维数组，比如改为多维数组，但参数的元素内容不改变：
#python 3.5.3 蔡军生
#http://edu.csdn.net/course/detail/2592
#
import numpy as np
#使用函数arange创建等距离的数组
a = np.arange( 10, 30, 5 )
print(a)
a = np.arange( 10, 30, 1 )
print(a)
print(a.reshape(5,4))====================== RESTART: D:/AI/sample/tf_1.8.py ======================
[10 15 20 25]
[10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29]
[[10 11 12 13]
[14 15 16 17]
[18 19 20 21]
[22 23 24 25]
[26 27 28 29]]
>>>
numpy.random.rand(d0, d1, ..., dn)
产生多维指定值的随机值数组。创建一个给定类型的数组，将其填充在一个均匀分布的随机样本[0, 1)中
参数:
d0, d1, ..., dn : int, 类型可选
返回数组的大小，都应该是正的。如果没有给定类型，将要返回float类型数组。
返回值:
输出: 数组, 维数 (d0, d1, ..., dn)的随机值
例子如下：
#python 3.5.3 蔡军生
#http://edu.csdn.net/course/detail/2592
#
import numpy as np
#生成随机数组
a = np.random.rand(100)
print(a)====================== RESTART: D:/AI/sample/tf_1.8.py ======================
[ 0.36756623 0.57475991 0.11576291 0.19575305 0.22775931 0.02877083
0.87709383 0.82610854 0.95336226 0.33116793 0.41715486 0.41567563
0.93325899 0.82980251 0.2641698 0.0230075 0.16021737 0.89062266
0.53174089 0.88560318 0.1020577 0.51347666 0.20543881 0.68847073
0.67691318 0.73267761 0.02955434 0.33115342 0.57108833 0.89842244
0.29627328 0.44781693 0.27565271 0.9583813 0.69200277 0.86579612
0.1317431 0.5361843 0.23088806 0.43096172 0.30871722 0.21351671
0.35913488 0.64517815 0.14824364 0.02528712 0.02719144 0.87200391
0.1873583 0.06465166 0.59395243 0.1620941 0.00949225 0.6715625
0.01759062 0.48881549 0.48537134 0.73747324 0.76030959 0.00108733
0.34658235 0.98244906 0.90418067 0.09229615 0.17773136 0.59418644
0.10831246 0.09145009 0.27159286 0.86183618 0.97369326 0.38035745
0.46369083 0.69789643 0.81394915 0.62409341 0.33483406 0.41672463
0.18458513 0.06065934 0.57065936 0.63319788 0.35979201 0.35651482
0.07786763 0.27354799 0.51581137 0.58519992 0.41066551 0.85583774
0.85858194 0.65743586 0.69588964 0.3069319 0.33913916 0.27590068
0.7522814 0.95541998 0.66847512 0.28899663]
>>>
接着下来，我们玩玩numpy的数值数据类型转换。很多时候我们用numpy从文本文件读取数据作为numpy的数组，默认的dtype是float64。
但是有些场合我们希望有些数据列作为整数。如果直接改dtype=‘int‘的话，就会出错！原因如上，数组长度翻倍了！！！
#python 3.5.3 蔡军生
#http://edu.csdn.net/course/detail/2592
#
import numpy as np
#生成随机数组
a = np.random.rand(100)
print(a)
print(a.dtype)
#改变为float32
b = a.astype(np.float32)
print(b.dtype)====================== RESTART: D:/AI/sample/tf_1.9.py ======================
[ 0.77584611 0.52876856 0.19706401 0.61832623 0.0089896 0.41983348
0.10492766 0.97979312 0.69085108 0.86499159 0.39013642 0.44552474
0.8411643 0.56789924 0.65441475 0.11682472 0.16229718 0.71352883
0.1733354 0.73853152 0.46474821 0.33760637 0.5414772 0.19916713
0.14423215 0.76983785 0.19381022 0.01049321 0.67666048 0.92127875
0.8633769 0.21072991 0.20734093 0.35363864 0.38049275 0.34297788
0.90490519 0.90183218 0.86001555 0.17732802 0.52309872 0.22432887
0.99750198 0.19645552 0.89341424 0.64855031 0.01390069 0.87379732
0.22368021 0.26585213 0.60843939 0.74559994 0.58640495 0.47085835
0.87439869 0.28302425 0.58262191 0.03047021 0.63725987 0.39903248
0.77868351 0.45142109 0.7013175 0.58332084 0.53226347 0.24446232
0.95680714 0.56208046 0.38283968 0.98809987 0.81956823 0.48170822
0.86376422 0.3113668 0.71538988 0.78346935 0.76092989 0.79074284
0.0656774 0.30367193 0.01220948 0.92957712 0.11030973 0.37887348
0.87261566 0.06345908 0.38160215 0.32552959 0.69877511 0.1403288
0.65962466 0.64203195 0.45085474 0.82267962 0.8207419 0.90103881
0.08011825 0.27774951 0.95322617 0.74773234]
float64
float32
>>>
到这里，已经基本了解numpy的使用了。接着下来，继续学习下数组的乘法：
基本运算
数组的算术运算是按元素的。新的数组被创建并且被结果填充。
>>> a = array( [20,30,40,50] )
>>> b = arange( 4 )
>>> b
array([0, 1, 2, 3])
>>> c = a-b
>>> c
array([20, 29, 38, 47])
>>> b**2
array([0, 1, 4, 9])
>>> 10*sin(a)
array([ 9.12945251, -9.88031624, 7.4511316 , -2.62374854])
>>> a<35
array([True, True, False, False], dtype=bool)
不像许多矩阵语言，NumPy中的乘法运算符 * 指示按元素计算，矩阵乘法可以使用 dot 函数或创建矩阵对象实现(参见教程中的矩阵章节)
>>> A = array( [[1,1],
... [0,1]] )
>>> B = array( [[2,0],
... [3,4]] )
>>> A*B # elementwise product
array([[2, 0],
[0, 4]])
>>> dot(A,B) # matrix product
array([[5, 4],
[3, 4]])
有些操作符像 += 和 *= 被用来更改已存在数组而不创建一个新的数组。
>>> a = ones((2,3), dtype=int)
>>> b = random.random((2,3))
>>> a *= 3
>>> a
array([[3, 3, 3],
[3, 3, 3]])
>>> b += a
>>> b
array([[ 3.69092703, 3.8324276 , 3.0114541 ],
[ 3.18679111, 3.3039349 , 3.37600289]])
>>> a += b # b is converted to integer type
>>> a
array([[6, 6, 6],
[6, 6, 6]])
当运算的是不同类型的数组时，结果数组和更普遍和精确的已知(这种行为叫做upcast)。
>>> a = ones(3, dtype=int32)
>>> b = linspace(0,pi,3)
>>> b.dtype.name
'float64'
>>> c = a+b
>>> c
array([ 1. , 2.57079633, 4.14159265])
>>> c.dtype.name
'float64'
>>> d = exp(c*1j)
>>> d
array([ 0.54030231+0.84147098j, -0.84147098+0.54030231j,
-0.54030231-0.84147098j])
>>> d.dtype.name
'complex128' 许多非数组运算，如计算数组所有元素之和，被作为ndarray类的方法实现
>>> a = random.random((2,3))
>>> a
array([[ 0.6903007 , 0.39168346, 0.16524769],
[ 0.48819875, 0.77188505, 0.94792155]])
>>> a.sum()
3.4552372100521485
>>> a.min()
0.16524768654743593
>>> a.max()
0.9479215542670073
这些运算默认应用到数组好像它就是一个数字组成的列表，无关数组的形状。然而，指定 axis 参数你可以吧运算应用到数组指定的轴上：
>>> b = arange(12).reshape(3,4)
>>> b
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
>>>
>>> b.sum(axis=0) # sum of each column
array([12, 15, 18, 21])
>>>
>>> b.min(axis=1) # min of each row
array([0, 4, 8])
>>>
>>> b.cumsum(axis=1) # cumulative sum along each row
array([[ 0, 1, 3, 6],
[ 4, 9, 15, 22],
[ 8, 17, 27, 38]])
扫一扫
879
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
