例子
>>>
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,....]