python之numpy學習

阿新 • • 發佈：2021-01-12

Numpy是一個用python實現的科學計算的擴充套件程式庫，包括：

1、一個強大的N維陣列物件Array；
2、比較成熟的（廣播）函式庫；
3、用於整合C/C++和Fortran程式碼的工具包；
4、實用的線性代數、傅立葉變換和隨機數生成函式。numpy和稀疏矩陣運算包scipy配合使用更加方便。

NumPy（Numeric Python）提供了許多高階的數值程式設計工具，如：矩陣資料型別、向量處理，以及精密的運算庫。專為進行嚴格的數字處理而產生。多為很多大型金融公司使用，以及核心的科學計算組織如：Lawrence Livermore，NASA用其處理一些本來使用C++，Fortran或Matlab等所做的任務。

1.Numpy基本操作

1.1 列表轉為矩陣

import numpy as np
#np.array生成一個ndarray陣列，ndarray再程式中的別名為array
#np.array()輸出形式為[],元素之間由空格分隔
array = np.array([
    [1,3,5],
    [4,6,9]
])

print(array)
[[1 3 5]
 [4 6 9]]

1.2 維度

print('number of dim:', array.ndim)
number of dim: 2

1.3 行數和列數()

print('shape:',array.shape)
shape: (2, 3)

1.4 元素個數

print('size:',array.size)
size: 6

1.5 ndarray物件的屬性

屬性	說明
.ndim	秩，即軸的數量或者維度的數量
.shape	ndarray物件的尺度，對於矩陣，n行m列
.size	ndarray物件的個數，相當於.shape中n*m的值
.dtype	ndarray物件的元素型別
.itemsize	ndarray物件中每個元素的大小，以位元組為單位

1.6 ndarray物件的元素型別

資料型別	說明
bool	布林型別，True或者False
intc	與C語言中int型別一致，一般是int32或者int64
intp	用於於索引的整數，與C語言中 size_t一致，int32或int64
int8	位元組長度的整數，取值：[-128,127]
int16	16位長度的整數，取值：[-32768,32767]
int32	32位長度的整數，取值：[-2^31,231-1]
int64	64位長度的整數，取值：[-2^63,263-1]
uint8	8位無符號整數，取值：[0,255]
uint16	16位無符號整數，取值：[0,65535]
uint32	32位無符號整數，取值：[0,2^32-1]
uint64	64位無符號整數，取值：[0,2^64-1]
float16	16位半精度浮點數：1位符號位，5位指數，10位尾數
float32	32位半精度浮點數：1位符號位，8位指數，23位尾數
float64	64位半精度浮點數：1位符號位，11位指數，52位尾數
complex64	複數型別，實部和虛部都是32位浮點數
complex128	複數型別，實部和虛部都是64位浮點數

2.Numpy建立array

從列表型別建立陣列

a = np.array([2,23,4])

從元組型別建立陣列

a = np.array((2,23,4))

從列表和元組混合型別建立陣列

a = np.array([2,23,4],[1,2,3],(4,5,6))

使用numpy中函式建立陣列

函式	說明
np. arange（n）	類似 range0函式，返回 ndarray型別，元素從0到n-1
np.ones（ shape）	根據 shape生成一個全1陣列， shape是元組型別
np, zeros（ shape）	根據 shape生成一個全0陣列， shape是元組型別
np. full（shape,vaD）	根據 shape生成一個數組，每個元素值都是val
np. eye（n）	建立一個正方的n*n單位矩陣，對角線為1，其餘為0
np. ones_like（a）	根據陣列a的形狀生成一個全1陣列
np.zeros_like（a）	根據陣列a的形狀生成一個全0陣列
np. full_like（a,va）	根據陣列a的形狀生成一個數組，每個元素值都是val
np. linspaceO	根據起止資料等間距地填充資料，形成陣列
np. concatenate()	將兩個或多個數組合井成一個新的陣列

ndarray陣列的維度變換

說明	方法
reshape（shape）	不改變陣列元素，返回一個 shape形狀的陣列，原陣列不變
resize（shape）	與 reshape功能一致，但修改原陣列
swapaxes（ax1，ax2）	將陣列n個維度中兩個維度進行調換
flatten()	對陣列進行降維，返回摺疊後的一維陣列，原陣列不變

ndarray陣列的型別變換

#astype方法一定會建立新的陣列（原始資料的一個拷貝），即使兩個型別一致。
new a=a. astype（new type）

ndarray陣列向列表的轉換

2.1 一維array建立

import numpy as np
# 一維array
a = np.array([2,23,4], dtype=np.int32) # np.int預設為int32
print(a)
print(a.dtype)
===========================
[ 2 23  4]
int32

2.2 多維array建立

# 多維array
a = np.array([[2,3,4],
              [3,4,5]])
print(a) # 生成2行3列的矩陣
==========================================
[[2 3 4]
 [3 4 5]]

2.3 建立全零陣列(zeros)

a = np.zeros((3,4))
print(a) # 生成3行4列的全零矩陣
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

2.4 建立全1資料(ones)

In [8]:

# 建立全一資料，同時指定資料型別
a = np.ones((3,4),dtype=np.int)
print(a)
[[1 1 1 1]
 [1 1 1 1]
 [1 1 1 1]]

2.5 建立全空陣列(empty)

In [9]:

# 建立全空陣列，其實每個值都是接近於零的數
a = np.empty((3,4))
print(a)
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

2.6 建立連續陣列(arange)

In [10]:

# 建立連續陣列
a = np.arange(10,21,2) # 10-20的資料，步長為2
print(a)
[10 12 14 16 18 20]

2.7 reshape操作

In [11]:

# 使用reshape改變上述資料的形狀
b = a.reshape((2,3))
print(b)
[[10 12 14]
 [16 18 20]]

2.8 建立連續型資料(linspcace)

# 建立線段型資料
a = np.linspace(1,10,20) # 開始端1，結束端10，且分割成20個數據，生成線段
print(a)
[ 1.          1.47368421  1.94736842  2.42105263  2.89473684  3.36842105
  3.84210526  4.31578947  4.78947368  5.26315789  5.73684211  6.21052632
  6.68421053  7.15789474  7.63157895  8.10526316  8.57894737  9.05263158
  9.52631579 10.        ]
  
  #endpoint為false時，生成的陣列不含結束端
  b= np linspace（l, 10， 4， endpoint=False）
  print(b)
  [1.,3.25,5.5,7.75]

2.9 linspace的reshape操作

In [13]:

# 同時也可以reshape
b = a.reshape((5,4))
print(b)
[[ 1.          1.47368421  1.94736842  2.42105263]
 [ 2.89473684  3.36842105  3.84210526  4.31578947]
 [ 4.78947368  5.26315789  5.73684211  6.21052632]
 [ 6.68421053  7.15789474  7.63157895  8.10526316]
 [ 8.57894737  9.05263158  9.52631579 10.        ]]

3.Numpy基本運算

陣列與標量之間的運算

numpy一元函式

numpy二元函式

3.1 一維矩陣運算

In [14]:

import numpy as np
# 一維矩陣運算
a = np.array([10,20,30,40])
b = np.arange(4)
print(a,b)
[10 20 30 40] [0 1 2 3]

In [15]:

c = a - b
print(c)
[10 19 28 37]

In [16]:

print(a*b) # 若用a.dot(b),則為各維之和
[  0  20  60 120]

In [17]:

# 在Numpy中，想要求出矩陣中各個元素的乘方需要依賴雙星符號 **，以二次方舉例，即：
c = b**2
print(c)
[0 1 4 9]

In [18]:

# Numpy中具有很多的數學函式工具
c = np.sin(a)
print(c)
[-0.54402111  0.91294525 -0.98803162  0.74511316]

In [19]:

print(b<2)
[ True  True False False]

In [20]:

a = np.array([1,1,4,3])
b = np.arange(4)
print(a==b)
[False  True False  True]

3.2 多維矩陣運算

In [21]:

a = np.array([[1,1],[0,1]])
b = np.arange(4).reshape((2,2))
print(a)
[[1 1]
 [0 1]]

In [22]:

print(b)
[[0 1]
 [2 3]]

In [23]:

# 多維度矩陣乘法
# 第一種乘法方式:
c = a.dot(b)
print(c)
[[2 4]
 [2 3]]

In [24]:

# 第二種乘法:
c = np.dot(a,b)
print(c)
[[2 4]
 [2 3]]

In [25]:

# 多維矩陣乘法不能直接使用'*'號

a = np.random.random((2,4))

print(np.sum(a))
3.825517216750851

In [26]:

print(np.min(a))
0.09623355767721398

In [27]:

print(np.max(a))
0.7420428188342583

In [28]:

print("a=",a)
a= [[0.48634962 0.74204282 0.09623356 0.69074812]
 [0.60218881 0.52734181 0.41434585 0.26626662]]

如果你需要對行或者列進行查詢運算，

就需要在上述程式碼中為 axis 進行賦值。

當axis的值為0的時候，將會以列作為查詢單元，

當axis的值為1的時候，將會以行作為查詢單元。

In [29]:

print("sum=",np.sum(a,axis=1))
sum= [2.01537412 1.8101431 ]

In [30]:

print("min=",np.min(a,axis=0))
min= [0.48634962 0.52734181 0.09623356 0.26626662]

In [31]:

print("max=",np.max(a,axis=1))
max= [0.74204282 0.60218881]

3.3 基本計算

In [32]:

import numpy as np

A = np.arange(2,14).reshape((3,4))
print(A)
[[ 2  3  4  5]
 [ 6  7  8  9]
 [10 11 12 13]]

In [33]:

# 最小元素索引
print(np.argmin(A)) # 0
0

In [34]:

# 最大元素索引
print(np.argmax(A)) # 11
11

In [35]:

# 求整個矩陣的均值
print(np.mean(A)) # 7.5
7.5

In [36]:

print(np.average(A)) # 7.5
7.5

In [37]:

print(A.mean()) # 7.5
7.5

In [38]:

# 中位數
print(np.median(A)) # 7.5
7.5

In [39]:

# 累加
print(np.cumsum(A))
[ 2  5  9 14 20 27 35 44 54 65 77 90]

In [40]:

# 累差運算
B = np.array([[3,5,9],
              [4,8,10]])
print(np.diff(B))
[[2 4]
 [4 2]]

In [41]:

C = np.array([[0,5,9],
              [4,0,10]])
print(np.nonzero(B))
print(np.nonzero(C))
(array([0, 0, 0, 1, 1, 1], dtype=int64), array([0, 1, 2, 0, 1, 2], dtype=int64))
(array([0, 0, 1, 1], dtype=int64), array([1, 2, 0, 2], dtype=int64))

In [42]:

# 仿照列表排序
A = np.arange(14,2,-1).reshape((3,4)) # -1表示反向遞減一個步長
print(A)
[[14 13 12 11]
 [10  9  8  7]
 [ 6  5  4  3]]

In [43]:

print(np.sort(A))
[[11 12 13 14]
 [ 7  8  9 10]
 [ 3  4  5  6]]

In [44]:

# 矩陣轉置
print(np.transpose(A))
[[14 10  6]
 [13  9  5]
 [12  8  4]
 [11  7  3]]

In [45]:

print(A.T)
[[14 10  6]
 [13  9  5]
 [12  8  4]
 [11  7  3]]

In [46]:

print(A)
[[14 13 12 11]
 [10  9  8  7]
 [ 6  5  4  3]]

In [47]:

print(np.clip(A,5,9))
[[9 9 9 9]
 [9 9 8 7]
 [6 5 5 5]]

clip(Array,Array_min,Array_max)

將Array_min<X<Array_max X表示矩陣A中的數，如果滿足上述關係，則原數不變。

否則，如果X<Array_min，則將矩陣中X變為Array_min;

如果X>Array_max，則將矩陣中X變為Array_max.

4.Numpy索引與切片

一維陣列的索引切片

多維陣列的索引切片

In [48]:

import numpy as np
A = np.arange(3,15)
print(A)
[ 3  4  5  6  7  8  9 10 11 12 13 14]

In [49]:

print(A[3])
6

In [50]:

B = A.reshape(3,4)
print(B)
[[ 3  4  5  6]
 [ 7  8  9 10]
 [11 12 13 14]]

In [51]:

print(B[2])
[11 12 13 14]

In [52]:

print(B[0][2])
5

In [53]:

print(B[0,2])
5

In [54]:

# list切片操作
print(B[1,1:3]) # [8 9] 1:3表示1-2不包含3
[8 9]

In [55]:

for row in B:
    print(row)
[3 4 5 6]
[ 7  8  9 10]
[11 12 13 14]

In [56]:

# 如果要列印列，則進行轉置即可
for column in B.T:
    print(column)
[ 3  7 11]
[ 4  8 12]
[ 5  9 13]
[ 6 10 14]

In [57]:

# 多維轉一維
A = np.arange(3,15).reshape((3,4))
# print(A)
print(A.flatten())
# flat是一個迭代器，本身是一個object屬性
[ 3  4  5  6  7  8  9 10 11 12 13 14]

In [58]:

for item in A.flat:
    print(item)
3
4
5
6
7
8
9
10
11
12
13
14

我們一起來來總結一下，看下面切片取值方式（對應顏色是取出來的結果）：

5.Numpy array合併

5.1 數組合並

In [59]:

import numpy as np
A = np.array([1,1,1])
B = np.array([2,2,2])
print(np.vstack((A,B)))
# vertical stack 上下合併,對括號的兩個整體操作。
[[1 1 1]
 [2 2 2]]

In [60]:

C = np.vstack((A,B))
print(C)
[[1 1 1]
 [2 2 2]]

In [61]:

print(A.shape,B.shape,C.shape)# 從shape中看出A,B均為擁有3項的陣列(數列)
(3,) (3,) (2, 3)

In [62]:

# horizontal stack左右合併
D = np.hstack((A,B))
print(D)
[1 1 1 2 2 2]

In [63]:

print(A.shape,B.shape,D.shape)
# (3,) (3,) (6,)
# 對於A,B這種，為陣列或數列，無法進行轉置，需要藉助其他函式進行轉置
(3,) (3,) (6,)

5.2 陣列轉置為矩陣

In [64]:

print(A[np.newaxis,:]) # [1 1 1]變為[[1 1 1]]
[[1 1 1]]

In [65]:

print(A[np.newaxis,:].shape) # (3,)變為(1, 3)
(1, 3)

In [66]:

print(A[:,np.newaxis])
[[1]
 [1]
 [1]]

5.3 多個矩陣合併

In [67]:

# concatenate的第一個例子
print("------------")
print(A[:,np.newaxis].shape) # (3,1)
------------
(3, 1)

In [68]:

A = A[:,np.newaxis] # 陣列轉為矩陣
B = B[:,np.newaxis] # 陣列轉為矩陣

In [69]:

print(A)
[[1]
 [1]
 [1]]

In [70]:

print(B)
[[2]
 [2]
 [2]]

In [71]:

# axis=0縱向合併
C = np.concatenate((A,B,B,A),axis=0)
print(C)
[[1]
 [1]
 [1]
 [2]
 [2]
 [2]
 [2]
 [2]
 [2]
 [1]
 [1]
 [1]]

In [72]:

# axis=1橫向合併
C = np.concatenate((A,B),axis=1)
print(C)
[[1 2]
 [1 2]
 [1 2]]

5.4 合併例子2

In [73]:

# concatenate的第二個例子
print("-------------")
a = np.arange(8).reshape(2,4)
b = np.arange(8).reshape(2,4)
print(a)
print(b)
print("-------------")
-------------
[[0 1 2 3]
 [4 5 6 7]]
[[0 1 2 3]
 [4 5 6 7]]
-------------

In [74]:

# axis=0多個矩陣縱向合併
c = np.concatenate((a,b),axis=0)
print(c)
[[0 1 2 3]
 [4 5 6 7]
 [0 1 2 3]
 [4 5 6 7]]

In [75]:

# axis=1多個矩陣橫向合併
c = np.concatenate((a,b),axis=1)
print(c)
[[0 1 2 3 0 1 2 3]
 [4 5 6 7 4 5 6 7]]

6.Numpy array分割

6.1 構造3行4列矩陣

In [76]:

import numpy as np
A = np.arange(12).reshape((3,4))
print(A)
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

6.2 等量分割

In [77]:

# 等量分割
# 縱向分割同橫向合併的axis
print(np.split(A, 2, axis=1))
[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11]])]

In [78]:

# 橫向分割同縱向合併的axis
print(np.split(A,3,axis=0))
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]

6.3 不等量分割

In [79]:

print(np.array_split(A,3,axis=1))
[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2],
       [ 6],
       [10]]), array([[ 3],
       [ 7],
       [11]])]

6.4 其他的分割方式

In [80]:

# 橫向分割
print(np.vsplit(A,3)) # 等價於print(np.split(A,3,axis=0))
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]

In [81]:

# 縱向分割
print(np.hsplit(A,2)) # 等價於print(np.split(A,2,axis=1))
[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11]])]

7.Numpy copy與 =

7.1 =賦值方式會帶有關聯性

In [82]:

import numpy as np
# `=`賦值方式會帶有關聯性
a = np.arange(4)
print(a) # [0 1 2 3]
[0 1 2 3]

In [83]:

b = a
c = a
d = b
a[0] = 11
print(a) # [11  1  2  3]
[11  1  2  3]

In [84]:

print(b) # [11  1  2  3]
[11  1  2  3]

In [85]:

print(c) # [11  1  2  3]
[11  1  2  3]

In [86]:

print(d) # [11  1  2  3]
[11  1  2  3]

In [87]:

print(b is a) # True
True

In [88]:

print(c is a) # True
True

In [89]:

print(d is a) # True
True

In [90]:

d[1:3] = [22,33]
print(a) # [11 22 33  3]
[11 22 33  3]

In [91]:

print(b) # [11 22 33  3]
[11 22 33  3]

In [92]:

print(c) # [11 22 33  3]
[11 22 33  3]

7.2 copy()賦值方式沒有關聯性

In [93]:

a = np.arange(4)
print(a) # [0 1 2 3]
[0 1 2 3]

In [94]:

b =a.copy() # deep copy
print(b) # [0 1 2 3]
[0 1 2 3]

In [95]:

a[3] = 44
print(a) # [ 0  1  2 44]
print(b) # [0 1 2 3]

# 此時a與b已經沒有關聯
[ 0  1  2 44]
[0 1 2 3]

8.廣播機制

numpy陣列間的基礎運算是一對一，也就是a.shape==b.shape，但是當兩者不一樣的時候，就會自動觸發廣播機制，如下例子：

In [96]:

from numpy import array
a = array([[ 0, 0, 0],
           [10,10,10],
           [20,20,20],
           [30,30,30]])
b = array([0,1,2])
print(a+b)
[[ 0  1  2]
 [10 11 12]
 [20 21 22]
 [30 31 32]]

為什麼是這個樣子？

這裡以tile模擬上述操作，來回到a.shape==b.shape情況！

In [97]:

# 對[0,1,2]行重複3次，列重複1次
b = np.tile([0,1,2],(4,1))
print(a+b)
[[ 0  1  2]
 [10 11 12]
 [20 21 22]
 [30 31 32]]

到這裡，我們來給出一張圖

也可以看這張圖：

是不是任何情況都可以呢？

當然不是，只有當兩個陣列的trailing dimensions compatible時才會觸發廣播，否則報錯ValueError: frames are not aligned exception。

上面表達意思是尾部維度必須相容！

.常用函式

9.1 np.bincount()

In [98]:

x = np.array([1, 2, 3, 3, 0, 1, 4])
np.bincount(x)

Out[98]:

array([1, 2, 1, 2, 1], dtype=int64)

統計索引出現次數：索引0出現1次，1出現2次，2出現1次，3出現2次，4出現1次

因此通過bincount計算出索引出現次數如下：

上面怎麼得到的？

對於bincount計算嗎，bin的數量比x中最大數多1，例如x最大為4，那麼bin數量為5(index從0到4)，也就會bincount輸出的一維陣列為5個數，bincount中的數又代表什麼？代表的是它的索引值在x中出現的次數！

還是以上述x為例子，當我們設定weights引數時候，結果又是什麼？

這裡假定：

In [99]:

w = np.array([0.3,0.5,0.7,0.6,0.1,-0.9,1])

那麼設定這個w權重後，結果為多少？

In [100]:

np.bincount(x,weights=w)

Out[100]:

array([ 0.1, -0.6,  0.5,  1.3,  1. ])

怎麼計算的？

先對x與w抽取出來：

x --->  [1, 2, 3, 3, 0, 1, 4]

w ---> [0.3,0.5,0.7,0.6,0.1,-0.9,1] 索引 0 出現在x中index=4位置，那麼在w中訪問index=4的位置即可，w[4]=0.1

索引 1 出現在x中index=0與index=5位置，那麼在w中訪問index=0與index=5的位置即可，然後將兩這個加和，計算得：w[0]+w[5]=-0.6 其餘的按照上面的方法即可！

bincount的另外一個引數為minlength，這個引數簡單，可以這麼理解，當所給的bin數量多於實際從x中得到的bin數量後，後面沒有訪問到的設定為0即可。

還是上述x為例：

這裡我們直接設定minlength=7引數，並輸出！

In [101]:

np.bincount(x,weights=w,minlength=7)

Out[101]:

array([ 0.1, -0.6,  0.5,  1.3,  1. ,  0. ,  0. ])

與上面相比多了兩個0，這兩個怎麼會多？

上面知道，這個bin數量為5，index從0到4，那麼當minlength為7的時候，也就是總長為7，index從0到6，多了後面兩位，直接補位為0即可！

9.2 np.argmax()

函式原型為：numpy.argmax(a, axis=None, out=None).

函式表示返回沿軸axis最大值的索引。

In [102]:

x = [[1,3,3],
     [7,5,2]]
print(np.argmax(x))
3

對於這個例子我們知道，7最大，索引位置為3(這個索引按照遞增順序)！

axis屬性

axis=0表示按列操作，也就是對比當前列，找出最大值的索引！

In [103]:

x = [[1,3,3],
     [7,5,2]]
print(np.argmax(x,axis=0))
[1 1 0]

axis=1表示按行操作，也就是對比當前行，找出最大值的索引！

In [104]:

x = [[1,3,3],
     [7,5,2]]
print(np.argmax(x,axis=0))
[1 1 0]

那如果碰到重複最大元素？

返回第一個最大值索引即可！

例如：

In [105]:

x = np.array([1, 3, 2, 3, 0, 1, 0])
print(x.argmax())
1

9.3 上述合併例項

這裡來融合上述兩個函式，舉個例子：

In [106]:

x = np.array([1, 2, 3, 3, 0, 1, 4])
print(np.argmax(np.bincount(x)))
1

最終結果為1，為什麼？

首先通過np.bincount(x)得到的結果是：[1 2 1 2 1]，再根據最後的遇到重複最大值項，則返回第一個最大值的index即可！2的index為1，所以返回1。

9.4 求取精度

In [107]:

np.around([-0.6,1.2798,2.357,9.67,13], decimals=0)#取指定位置的精度

Out[107]:

array([-1.,  1.,  2., 10., 13.])

看到沒，負數進位取絕對值大的！

In [108]:

np.around([1.2798,2.357,9.67,13], decimals=1)

Out[108]:

array([ 1.3,  2.4,  9.7, 13. ])

In [109]:

np.around([1.2798,2.357,9.67,13], decimals=2)

Out[109]:

array([ 1.28,  2.36,  9.67, 13.  ])

從上面可以看出，decimals表示指定保留有效數的位數，當超過5就會進位(此時包含5)！

但是，如果這個引數設定為負數，又表示什麼？

In [110]:

np.around([1,2,5,6,56], decimals=-1)

Out[110]:

array([ 0,  0,  0, 10, 60])

發現沒，當超過5時候(不包含5)，才會進位！-1表示看一位數進位即可，那麼如果改為-2呢，那就得看兩位！

In [111]:

np.around([1,2,5,50,56,190], decimals=-2)

Out[111]:

array([  0,   0,   0,   0, 100, 200])

看到沒，必須看兩位，超過50才會進位，190的話，就看後面兩位，後兩位90超過50，進位，那麼為200！

計算沿指定軸第N維的離散差值

In [112]:

x = np.arange(1 , 16).reshape((3 , 5))
print(x)
[[ 1  2  3  4  5]
 [ 6  7  8  9 10]
 [11 12 13 14 15]]

In [113]:

np.diff(x,axis=1) #預設axis=1

Out[113]:

array([[1, 1, 1, 1],
       [1, 1, 1, 1],
       [1, 1, 1, 1]])

In [114]:

np.diff(x,axis=0)

Out[114]:

array([[5, 5, 5, 5, 5],
       [5, 5, 5, 5, 5]])

取整

In [115]:

np.floor([-0.6,-1.4,-0.1,-1.8,0,1.4,1.7])

Out[115]:

array([-1., -2., -1., -2.,  0.,  1.,  1.])

看到沒，負數取整，跟上述的around一樣，是向左！

取上限

In [116]:

np.ceil([1.2,1.5,1.8,2.1,2.0,-0.5,-0.6,-0.3])

Out[116]:

array([ 2.,  2.,  2.,  3.,  2., -0., -0., -0.])

取上限！找這個小數的最大整數即可！

查詢

利用np.where實現小於0的值用0填充嗎，大於0的數不變！

In [117]:

x = np.array([[1, 0],
       [2, -2],
     [-2, 1]])
print(x)
[[ 1  0]
 [ 2 -2]
 [-2  1]]

In [118]:

np.where(x>0,x,0)

Out[118]:
array([[1, 0],
[2, 0],
[0, 1]])