python numpy 学习
例子
>>>
import
numpy as np
>>> a
=
np.arange(
15
).reshape(
3
,
5
)
>>> a
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
>>> a.shape
(3, 5)
>>> a.ndim
2
>>> a.dtype.name
'int64'
>>> a.itemsize
8
>>> a.size
15
>>> type(a)
<type 'numpy.ndarray'>
>>> b = np.array([6, 7, 8])
>>> b
array([6, 7, 8])
>>> type(b)
<type 'numpy.ndarray'>
创建数组
这里有多种创建数组的方法。
例如,你可以通过一个Python内置的列表或者元组函数创建一个数组。产生的数组的类型由序列中的元素的类型推导出来的。
>>> import numpy as np
>>> a = np.array([2,3,4])
>>> a
array([2, 3, 4])
>>> a.dtype
dtype('int64')
>>> b = np.array([1.2, 3.5, 5.1])
>>> b.dtype
dtype('float64')
通常,数组的元素是起初是未知的,但是排列大小是已知的。因此,numpy提供了一些函数在创建数组的时候初始化占位符的内容。这样使扩展数组以及运算成本最小化。
函数zeros创建一个全是0的数组,ones创建一个全是1的数组,empty创建一个初始内容根据内存状态而随即的随即内容。默认情况下,这些创建的数组的dtype都是float64
>>> np.zeros( (3,4) )
array([[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.]])
>>> np.ones( (2,3,4), dtype=np.int16 ) # dtype 也能自定义
array([[[ 1, 1, 1, 1],
[ 1, 1, 1, 1],
[ 1, 1, 1, 1]],
[[ 1, 1, 1, 1],
[ 1, 1, 1, 1],
[ 1, 1, 1, 1]]], dtype=int16)
>>> np.empty( (2,3) ) # 未初始化,内容不一致
array([[ 3.73603959e-262, 6.02658058e-154, 6.55490914e-260],
[ 5.30498948e-313, 3.14673309e-307, 1.00000000e+000]])
创建一个数字序列,numpy提供一个类似range的函数,返回数组而不是列表
>>> np.arange( 10, 30, 5 )
array([10, 15, 20, 25])
>>> np.arange( 0, 2, 0.3 ) # 接受浮点型实参
array([ 0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])
当arange传入浮点型实参的时候,它通常不能预测元素的数量,主要因为浮点类型的精度。因此,更好的办法是通过linspace函数接收一个实参作为我们想要得到的元素数量。
>>> from numpy import pi
>>> np.linspace( 0, 2, 9 ) # 从0到2一个9个元素
array([ 0. , 0.25, 0.5 , 0.75, 1. , 1.25, 1.5 , 1.75, 2. ])
>>> x = np.linspace( 0, 2*pi, 100 ) # 有时非常有用
>>> f = np.sin(x)
更多内容参考:
array, zeros, zeros_like, ones, ones_like, empty, empty_like, arange, linspace, numpy.random.rand, numpy.random.randn, fromfunction, fromfile
打印数组
当你打印数组的时候,numpy的显示类似于嵌套的列表,但是诚信以下布局。
一维的轴从左到右打印
二维的轴自上至下打印
二维以后的轴自上至下打印,每个切片通过空格与写一个隔开
>>> a = np.arange(6) # 一维数组
>>> print(a)
[0 1 2 3 4 5]
>>>
>>> b = np.arange(12).reshape(4,3) # 二维数组
>>> print(b)
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
>>>
>>> c = np.arange(24).reshape(2,3,4) # 三维数组
>>> print(c)
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
点击这里,查看更多与reshape的细节
如果一个数组过于庞大,numpy会自动的跳过中间的一些内容,只打印四端。
>>> print(np.arange(10000))
[ 0 1 2 ..., 9997 9998 9999]
>>>
>>> print(np.arange(10000).reshape(100,100))
[[ 0 1 2 ..., 97 98 99]
[ 100 101 102 ..., 197 198 199]
[ 200 201 202 ..., 297 298 299]
...,
[9700 9701 9702 ..., 9797 9798 9799]
[9800 9801 9802 ..., 9897 9898 9899]
[9900 9901 9902 ..., 9997 9998 9999]]
如果希望强制打印所有内容,可以更改打印参数。
>>> np.set_printoptions(threshold='nan')
基本运算
数组的算术运算时机遇每个元素的,一个新的数组被创建并且填充运算结果
>>> a = np.array( [20,30,40,50] )
>>> b = np.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*np.sin(a)
array([ 9.12945251, -9.88031624, 7.4511316 , -2.62374854])
>>> a<35
array([ True, True, False, False], dtype=bool)
不像其他矩阵语言,乘积运算符*在numpy数组中是按元素的,矩阵积可以通过dot函数或者方法执行
>>> A = np.array( [[1,1],
... [0,1]] )
>>> B = np.array( [[2,0],
... [3,4]] )
>>> A*B # 按元素乘积
array([[2, 0],
[0, 4]])
>>> A.dot(B) # 矩阵积
array([[5, 4],
[3, 4]])
>>> np.dot(A, B) # 另一种矩阵积
array([[5, 4],
[3, 4]])
其他运算,如+=及*=,直接在原有基础上修改而不是创建新的对象
>>> a = np.ones((2,3), dtype=int)
>>> b = np.random.random((2,3))
>>> a *= 3
>>> a
array([[3, 3, 3],
[3, 3, 3]])
>>> b += a
>>> b
array([[ 3.417022 , 3.72032449, 3.00011437],
[ 3.30233257, 3.14675589, 3.09233859]])
>>> a += b # b is not automatically converted to integer type
Traceback (most recent call last):
...
TypeError: Cannot cast ufunc add output from dtype('float64') to dtype('int64') with casting rule 'same_kind'
Traceback (most recent call last):
...
TypeError: Cannot cast ufunc add output from dtype('float64') to dtype('int64') with casting rule 'same_kind'
注:其实上面再不同的python版本会不一样,2.7.9不会出错
当两个不同类型的数组进行运算的时候,运算结果的数组会趋向于更复杂的?(不懂)
>>>
>>> a = np.ones(3, dtype=np.int32)
>>> b = np.linspace(0,pi,3)
>>> b.dtype.name
'float64'
>>> c = a+b
>>> c
array([ 1. , 2.57079633, 4.14159265])
>>> c.dtype.name
'float64'
>>> d = np.exp(c*1j)
>>> d
array([ 0.54030231+0.84147098j, -0.84147098+0.54030231j,
-0.54030231-0.84147098j])
>>> d.dtype.name
'complex128'
许多的一元的运算,例如计算所有元素之和,被封装成一个ndarray类
>>> a = np.random.random((2,3))
>>> a
array([[ 0.18626021, 0.34556073, 0.39676747],
[ 0.53881673, 0.41919451, 0.6852195 ]])
>>> a.sum()
2.5718191614547998
>>> a.min()
0.1862602113776709
>>> a.max()
0.6852195003967595
默认情况下,这些运算可以应用于数组,就像列表中的数值,而不是它的shapes,然而,通过指定它的轴线参数,你可以把运算应用到单独的其中一轴上。
>>> b = np.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]])
注:二维数组,axis=0取竖直方向,axis=1取水平方向 (axis二维以上求指教!!!不会)
通用函数
Numpy提供常见的数学函数,如sin,cos,exp。
在numpy中,这些被称为universal functions(ufunc),在numpy内部,这些函数按元素在数组中计算,产生一个数组作为输出
>>> B = np.arange(3)
>>> B
array([0, 1, 2])
>>> np.exp(B)
array([ 1. , 2.71828183, 7.3890561 ])
>>> np.sqrt(B)
array([ 0. , 1. , 1.41421356])
>>> C = np.array([2., -1., 4.])
>>> np.add(B, C)
array([ 2., 0., 6.])
其他函数
all, any, apply_along_axis, argmax, argmin, argsort, average, bincount, ceil, clip, conj, corrcoef, cov, cross, cumprod, cumsum, diff, dot, floor, inner, inv, lexsort, max, maximum, mean, median, min, minimum, nonzero, outer, prod, re, round, sort, std, sum, trace, transpose, var, vdot, vectorize, where
索引,切片,迭代
一维数组能被索引,切片,迭代,非常像列表以及python中的其他序列
>>> a = np.arange(10)**3
>>> a
array([ 0, 1, 8, 27, 64, 125, 216, 343, 512, 729])
>>> a[2]
8
>>> a[2:5]
array([ 8, 27, 64])
>>> a[:6:2] = -1000 # 从0到6启动每隔“第二位”对于-1000
>>> a
array([-1000, 1, -1000, 27, -1000, 125, 216, 343, 512, 729])
>>> a[ : :-1] # reversed a
array([ 729, 512, 343, 216, 125, -1000, 27, -1000, 1, -1000])
>>> for i in a:
... print(i**(1/3.))
...
nan
1.0
nan
3.0
nan
5.0
6.0
7.0
8.0
9.0
多维数组每个轴线都有索引。这些索引由一个逗号分隔的元组给出。
>>> def f(x,y):
... return 10*x+y
...
>>> b = np.fromfunction(f,(5,4),dtype=int)
>>> b
array([[ 0, 1, 2, 3],
[10, 11, 12, 13],
[20, 21, 22, 23],
[30, 31, 32, 33],
[40, 41, 42, 43]])
>>> b[2,3]
23
>>> b[0:5, 1] # b的每行中的第2列
array([ 1, 11, 21, 31, 41])
>>> b[ : ,1] # 与上面一样
array([ 1, 11, 21, 31, 41])
>>> b[1:3, : ] # 1到3行所有列
array([[10, 11, 12, 13],
[20, 21, 22, 23]])
当索引值数量比轴的数量少的时候,缺失的索引会被切片“:”补全
>>> b[-1] # 相当于b[-1,:]
array([40, 41, 42, 43])
在b[i]括号里的表达式会当成i以及跟上足够的很多的“:”,代表剩下的轴。Numpy也允许你听过点来写,如b[i,....]