numpy

時間 2019-11-24

標籤 numpy 简体版

原文原文鏈接

1、Numpy概述

NumPy 是 Numerical Python 的簡稱，是高性能計算和數據分析的基礎包。包含了多維數組以及多維數組的操做。html

Numeric，即 NumPy 的前身，是由 Jim Hugunin 開發的。Jim也開發了另外一個包 Numarray，它擁有一些額外的功能。java

2005 年，Travis Oliphant 經過將 Numarray 的功能集成到 Numeric 包中來建立 NumPy 包。node

1.1 Numpy簡介

Numpy相比於 Python 內建的庫和數據類型有如下特性：python

強大、靈活的多維數組對象及豐富的操做
C 實現，執行效率高
線性代數、傅里葉變換、豐富的隨機數功能
複雜的（廣播）功能

NumPy 一般與 SciPy (Scientific Python) 和 Matplotlib（繪圖庫）一塊兒使用。這種組合普遍用於替代 MatLab，是一個流行的技術計算平臺。Python + Numpy 做爲 MatLab 的替代方案，現在被視爲一種更加現代和完整的編程語言。shell

1.2 Numpy的安裝

方法一：
標準的 Python 發行版不會與 NumPy 模塊捆綁在一塊兒。一個輕量級的替代方法是使用流行的Python 包安裝程序 pip 來安裝 NumPy。
在 CMD 或命令行中執行: pip install numpy編程

方法二： （推薦）
可是實際在 Windows 系統中的安裝，多數時候會出現各種須要編譯或缺少相關依賴的問題，因爲在 Python 的編程基礎部分已經提過，建議你們使用 Anaconda 的 Python 發行版，這個發行版已經提早爲咱們安裝了各種的科學計算須要的第三方包。咱們直接使用就能夠了。api

如下全部都是基於Anaconda數組

2、 Numpy-Ndarray對象

Numpy 的核心是 ndarray 對象，這個對象封裝了同質數據類型的n維數組。（數組，即爲有序的元素序列）架構

ndarray 是 n-dimension-array 的簡寫。dom

Numpy 約定俗成的導入方式以下：

import numpy as np

#所有行都能輸出
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = "all"

2.1 建立Ndarray

基本的 ndarray 是使用 NumPy 中的數組函數建立的，以下所示：
array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)

2.1.1 np.array 能夠把 list，tuple，array 或者其餘的序列模式的數據轉建立爲新的 ndarray

#建立一維數組
arr = np.array([3, 5, 0.7, -4, 6.2, 0])
arr


#array([ 3. ,  5. ,  0.7, -4. ,  6.2,  0. ])

#建立二維數組
arr2 = np.array([[5,6,7,8,9],[4,3,2,1,0]])
arr2

#array([[5, 6, 7, 8, 9],
#          [4, 3, 2, 1, 0]])

arr3 = np.array([1,2,3,4,5], ndmin=2) #ndmin是指明數組維度
arr3


#array([[1, 2, 3, 4, 5]])

2.2 numpy的ndarray 與 python原生array有什麼區別

NumPy 數組在建立時有固定的大小，不一樣於Python列表（能夠動態增加）。更改ndarray的大小將建立一個新的數組並刪除原始數據。
NumPy 數組中的元素都須要具備相同的數據類型，所以在存儲器中將具備相同的大小。數組的元素若是也是數組（能夠是 Python 的原生 array，也能夠是 ndarray）的狀況下，則構成了多維數組。

2.2.1 Numpy 的矢量化（向量化）功能

若是想要將一個2-D數組 a 的每一個元素與長度相同的另一個數組 b 中相應位置的元素相乘
使用 Python 原生的數組實現以下：

a = [[1, 2, 3], [5, 7, 8], [4, 5, 6]]
b = [[6, 2, 1], [2, 3, 1], [4, 5, 6]]
a
b

# [[1, 2, 3], [5, 7, 8], [4, 5, 6]]
# [[6, 2, 1], [2, 3, 1], [4, 5, 6]]

## c=a*b #這樣寫能夠麼？ 確定不行，只能循環遍歷
#寫一個代碼實現對應元素相乘

c = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
for i in range(3):
    for j in range(3):
        c[i][j] = a[i][j]*b[i][j]
c

#[[6, 4, 3], [10, 21, 8], [16, 25, 36]]

使用numpy實現a與b的對應元素相乘

a1 = np.array(a)
b1 = np.array(b)
a
b

# array([[1, 2, 3],
#        [5, 7, 8],
#        [4, 5, 6]])
# 
# array([[6, 2, 1],
#        [2, 3, 1],
#        [4, 5, 6]])

c1=a1*b1
c1

# array([[ 6,  4,  3],
#        [10, 21,  8],
#        [16, 25, 36]])

#其他初等運算都可，這裏再也不一一舉例，下面這些運算都是能夠的
# a1
# a1 + 5
# a1 * 3
# a1 ** 2

矢量化代碼有不少優勢，其中包括：

矢量化代碼更簡潔易讀
更少的代碼行一般意味着更少的錯誤
執行效率高，運行速度快

2.3 數據類型 (dtype)

Numpy 中的數組比 Python 原生中的數組（只支持整數類型與浮點類型）強大的一點就是它支持更多的數據類型。
但對於咱們非開發者而言，只須要知道經常使用的幾個類型就夠用了。須要注意的是，在 Numpy 當中的數據都是有位數限制的，包括整數。當數據過長時就有可能出現數據截斷或者數據溢出。

2.3.1 基本數據類型

Numpy 常見的基本數據類型以下：

數據類型	描述
bool_	布爾（True或False），存儲爲一個字節
int_	默認整數類型（一般爲int64或int32）
intc	與C int（一般爲int32或int64）相同
intp	用於索引的整數（與C ssize_t相同；一般爲int32或int64）
int8	字節（-128到127）
int16	整數（-32768到32767）
int32	整數（-2147483648至2147483647）
int64	整數（-9223372036854775808至9223372036854775807）
uint8	無符號整數（0到255）
uint16	無符號整數（0到65535）
uint32	無符號整數（0至4294967295）
uint64	無符號整數（0至18446744073709551615）
float_	float64的簡寫。
float16	半精度浮點：符號位，5位指數，10位尾數
float32	單精度浮點：符號位，8位指數，23位尾數
float64	雙精度浮點：符號位，11位指數，52位尾數
complex_	complex128的簡寫。
complex64	複數，由兩個32位浮點（實數和虛數份量）
complex128	複數，由兩個64位浮點（實數和虛數份量）

不一樣於 Python 列表，NumPy 要求數組必須包含同一類型的數據

a = np.array([3.14, 4, 2, 3])
a
#array([3.14, 4.  , 2.  , 3.  ])

a.dtype
#dtype('float64')

b = np.array([3.14, 4, 2, 4], dtype='intc')
b
#array([3, 4, 2, 4], dtype=int32)

b.dtype
#dtype('int32')

關於數據溢出的問題，上面的數據類型若是不知足所需的內存要求，怎會返回一些無用數據，具體不作討論

2.3.2 類型轉換——.astype()方法（首選）

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

#array([3.14, 4.  , 2.  , 3.  ])

a.astype(np.bool)
#array([ True,  True,  True,  True])

a.astype(np.int32)
#array([3, 4, 2, 3])

a.astype('str')
#array(['3.14', '4.0', '2.0', '3.0'], dtype='<U32')

2.3.3 經常使用的數組

（1）全0數組——np.zeros()

np.zeros(5) #默認是float型
#array([0., 0., 0., 0., 0.])

np.zeros((3, 3), dtype="int")
#array([[0, 0, 0],
#         [0, 0, 0],
#         [0, 0, 0]])

np.zeros((3,2,4), dtype=np.float)
# array([[[0., 0., 0., 0.],
#         [0., 0., 0., 0.]],
# 
#        [[0., 0., 0., 0.],
#         [0., 0., 0., 0.]],
# 
#        [[0., 0., 0., 0.],
#         [0., 0., 0., 0.]]])

（2）全1數組——np.ones()

np.ones(3) #默認float型
#array([1., 1., 1.])

#與np.zeros雷同

（3）全爲相同值的數組——np.full()

np.full((2,3),5)
# array([[5, 5, 5],
#        [5, 5, 5]])

np.full((2,3),[[1,2,3],[2,3,4]])#前面的（2,3）是指生成兩行三列
# array([[1, 2, 3],
#        [2, 3, 4]])

（4）單位矩陣——np.eye()

np.eye(5,dtype='int') #默認float型
# array([[1, 0, 0, 0, 0],
#        [0, 1, 0, 0, 0],
#        [0, 0, 1, 0, 0],
#        [0, 0, 0, 1, 0],
#        [0, 0, 0, 0, 1]])

np.eye(3,5)
# array([[1., 0., 0., 0., 0.],
#        [0., 1., 0., 0., 0.],
#        [0., 0., 1., 0., 0.]])

（5）按照某一數組的形狀生成ndarray——np.ones_like np.zeros_like np.full_like

a = [[2,1,3],[4,3,2]]
np.ones_like(a)
np.zeros_like(a)
np.full_like(a,3)

# array([[1, 1, 1],
#        [1, 1, 1]])
# 
# array([[0, 0, 0],
#        [0, 0, 0]])
# 
# array([[3, 3, 3],
#        [3, 3, 3]])

（6）建立一個初始化的數組——np.empty()

np.empty(6)#爲何這裏會有數字顯示呢？
#array([ 3. ,  5. ,  0.7, -4. ,  6.2,  0. ])
#初始化的數據無心義

np.empty([5])
#array([3. , 5. , 0.7, 4. , 6.2])

a = np.empty([2,3])
a
# array([[ 3. ,  5. ,  0.7],
#        [-4. ,  6.2,  0. ]])

（7）建立對角矩陣——np.diag()

np.diag([1,2,3,4,5]) #對角Diagonal
# array([[1, 0, 0, 0, 0],
#        [0, 2, 0, 0, 0],
#        [0, 0, 3, 0, 0],
#        [0, 0, 0, 4, 0],
#        [0, 0, 0, 0, 5]])

np.diag([1,2,3,'a'],2) #最後一個參數表示偏移量，正數向右上角偏移，負數向最下角偏移
# array([['', '', '1', '', '', ''],
#        ['', '', '', '2', '', ''],
#        ['', '', '', '', '3', ''],
#        ['', '', '', '', '', 'a'],
#        ['', '', '', '', '', ''],
#        ['', '', '', '', '', '']], dtype='<U11')

np.diag([1,2,3,'a'],-2)
# array([['', '', '', '', '', ''],
#        ['', '', '', '', '', ''],
#        ['1', '', '', '', '', ''],
#        ['', '2', '', '', '', ''],
#        ['', '', '3', '', '', ''],
#        ['', '', '', 'a', '', '']], dtype='<U11')

np.diag(np.array([1, 2, 3, 4]))
# array([[1, 0, 0, 0],
#        [0, 2, 0, 0],
#        [0, 0, 3, 0],
#        [0, 0, 0, 4]])
#顯然傳入列表或者ndarray對象均可以

（8）設置空值——np.nan

np.nan
#nan

（9）隨機數組——np.random

np.random.randint(1, 10, (3, 6))#生成一個整數的3行6列的數組，範圍[1,10）
# array([[4, 5, 6, 4, 2, 6],
#        [6, 1, 2, 1, 1, 9],
#        [2, 5, 8, 4, 5, 8]])

np.random.randn(4, 2) #np.random.standard_normal的簡寫形式
# array([[-0.72149333,  0.16869444],
#        [ 0.18478612, -0.41606474],
#        [-0.25209803, -0.23236144],
#        [-0.04885846, -0.36685169]])
# 裏面的數值知足標準正態分佈，等價於 np.random.standard_normal((4,2))

np.random.normal(4, 2, (5, 3)) #均值, 標準差, 形狀
# array([[ 5.05443727,  6.20571937,  4.34760661],
#        [-2.23781087,  3.82506235,  2.42951026],
#        [ 7.18431897,  8.53642108,  2.27927855],
#        [ 3.85618724,  5.23093731,  4.40823762],
#        [ 2.71784975,  8.04125715,  6.94961183]])

# 設置隨機數種子, 拆開發現很差使, 必須放在一塊兒纔好使
np.random.seed(200)
c = np.random.randn(2, 3)
c
# array([[-1.45094825,  1.91095313,  0.71187915],
#        [-0.24773829,  0.36146623, -0.03294967]])
#它的功能至關於只隨機產生一次隨機數，之後調用都是第一次執行的結果

（10）建立一個線性序列的數組——np.arange

np.arange(0, 16, 2)
np.arange(16)
np.arange(0, 16, 4)
# array([ 0,  2,  4,  6,  8, 10, 12, 14])
# 
# array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15])
# 
# array([ 0,  4,  8, 12])
#前兩個是範圍，後一個是步長

np.linspace(1, 101, 5, dtype=int) #起始值，結束值，樣本數
#array([  1,  26,  51,  76, 101])

np.linspace(1, 101, 5, endpoint=False)
#array([ 1., 21., 41., 61., 81.])

a = np.arange(30).reshape(6,5)
a
# array([[ 0,  1,  2,  3,  4],
#        [ 5,  6,  7,  8,  9],
#        [10, 11, 12, 13, 14],
#        [15, 16, 17, 18, 19],
#        [20, 21, 22, 23, 24],
#        [25, 26, 27, 28, 29]])

2.3.4 數組屬性

ndarray.shape 返回一個包含數組維度的元祖
ndarray.dtype 返回數組元素的類型
ndarray.ndim 返回數組的維數
ndarray.itemsize 返回數組中每一個元素的字節單位長度

#爲了確保你們都能生成同樣的數組, 咱們先設置隨機數種子
np.random.seed(123)
x1 = np.random.randint(10, size=6) # 一維數組
x2 = np.random.randint(10, size=(3, 4)) # 二維數組
x3 = np.random.randint(10, size=(3, 4, 5)) # 三維數組
x1
x2
x3

# array([2, 2, 6, 1, 3, 9])
# 
# array([[6, 1, 0, 1],
#        [9, 0, 0, 9],
#        [3, 4, 0, 0]])
# 
# array([[[4, 1, 7, 3, 2],
#         [4, 7, 2, 4, 8],
#         [0, 7, 9, 3, 4],
#         [6, 1, 5, 6, 2]],
# 
#        [[1, 8, 3, 5, 0],
#         [2, 6, 2, 4, 4],
#         [6, 3, 0, 6, 4],
#         [7, 6, 7, 1, 5]],
# 
#        [[7, 9, 2, 4, 8],
#         [1, 2, 1, 1, 3],
#         [5, 9, 0, 8, 1],
#         [6, 3, 3, 5, 9]]])

（1）查看數據的形狀——np.shape

#查看數據的形狀
x1.shape
x2.shape
x3.shape

# (6,)
# 
# (3, 4)
# 
# (3, 4, 5)
#形狀以元祖形式返回

（2）查看維度——np.ndim

#查看維度
x1.ndim
x2.ndim
x3.ndim

# 1
# 
# 2
# 
# 3

（3）統計數組中全部的元素個數——np.size

#查看元素個數
x1.size
x2.size
x3.size

# 6
# 
# 12
# 
# 60

（4）查看數組中元素類型——np.dtype

#查看數組中元素類型
x1.dtype
x2.dtype
x3.dtype

# dtype('int32')
# 
# dtype('int32')
# 
# dtype('int32')

（5）查看數組中每一個元素的字節單位長度——np.itemsize

#查看數組中每一個元素的字節單位長度
x1.itemsize
x2.itemsize
x3.itemsize

# 4
# 
# 4
# 
# 4

# 數組的 dtype 爲 int8（一個字節）
x = np.array([1,2,3,4,5], dtype = np.int8)
x.itemsize

#1

x = np.array([1,2,3,4,5], dtype = np.float64)
x.itemsize

#8

2.3.5 數組的維度變換

ndarray.reshape 返回調整shape後的數組（不改變原數組）
ndarray.resize 返回調整shape後的數組（改變原數組）
ndarray.swapaxes 返回調換兩個維度後的數組
ndarray.flatten 對數組進行降維，返回摺疊後的一維數組

（1）改變數組形狀，返回新的ndarray對象，即不改變原數組——ndarray.reshape

m = np.random.randint(1, 100,(2, 3, 4))
m
# array([[[99,  4, 12,  4],
#         [95,  7, 10, 88],
#         [15, 84, 71, 13]],
# 
#        [[55, 28, 39, 18],
#         [62, 75, 66, 48],
#         [17,  6, 87, 47]]]

m.reshape(6,4) #不改變原數組
# array([[99,  4, 12,  4],
#        [95,  7, 10, 88],
#        [15, 84, 71, 13],
#        [55, 28, 39, 18],
#        [62, 75, 66, 48],
#        [17,  6, 87, 47]])
#三維變成了兩維，但原數組不發生改變，返回的是新的ndarray對象

m
# array([[[99,  4, 12,  4],
#         [95,  7, 10, 88],
#         [15, 84, 71, 13]],
# 
#        [[55, 28, 39, 18],
#         [62, 75, 66, 48],
#         [17,  6, 87, 47]]]

（2）改變數組形狀,但改變了原數組——ndarray.resize

m
# array([[[99,  4, 12,  4],
#         [95,  7, 10, 88],
#         [15, 84, 71, 13]],
# 
#        [[55, 28, 39, 18],
#         [62, 75, 66, 48],
#         [17,  6, 87, 47]]]

m.resize(6,4) #改變原數組
m
# array([[99,  4, 12,  4],
#        [95,  7, 10, 88],
#        [15, 84, 71, 13],
#        [55, 28, 39, 18],
#        [62, 75, 66, 48],
#        [17,  6, 87, 47]])

（3）將二維數組的兩個維度調換,但不改變了原數組——ndarray.swapaxes(1,0)

m
# array([[99,  4, 12,  4],
#        [95,  7, 10, 88],
#        [15, 84, 71, 13],
#        [55, 28, 39, 18],
#        [62, 75, 66, 48],
#        [17,  6, 87, 47]])

n = m.swapaxes(1,0) #將兩個維度調換,不改變原數組
n
# array([[99, 95, 15, 55, 62, 17],
#        [ 4,  7, 84, 28, 75,  6],
#        [12, 10, 71, 39, 66, 87],
#        [ 4, 88, 13, 18, 48, 47]])

（4）所有轉爲一行m.reshape(1,-1)或者m.flatten（），或者一列m.reshape(-1,1)

m
# array([[99,  4, 12,  4],
#        [95,  7, 10, 88],
#        [15, 84, 71, 13],
#        [55, 28, 39, 18],
#        [62, 75, 66, 48],
#        [17,  6, 87, 47]])

m.reshape(1,-1)
# array([[99,  4, 12,  4, 95,  7, 10, 88, 15, 84, 71, 13, 55, 28, 39, 18,
#         62, 75, 66, 48, 17,  6, 87, 47]])

m.reshape(-1,1)
# array([[99],
#        [ 4],
#        [12],
#        [ 4],
#        [95],
#        [ 7],
#        [10],
#        [88],
#        [15],
#        [84],
#        [71],
#        [13],
#        [55],
#        [28],
#        [39],
#        [18],
#        [62],
#        [75],
#        [66],
#        [48],
#        [17],
#        [ 6],
#        [87],
#        [47]])

m.flatten() #與.reshape(1,-1)做用相同
# array([99,  4, 12,  4, 95,  7, 10, 88, 15, 84, 71, 13, 55, 28, 39, 18, 62,
#        75, 66, 48, 17,  6, 87, 47])

2.3.6 數組的類型變換

ndarray.astype 更改數組的類型

ndarray..tolist 將數組變爲列表

（1）更改數組中元素的類型——ndarray.astype

m
# array([[99,  4, 12,  4],
#        [95,  7, 10, 88],
#        [15, 84, 71, 13],
#        [55, 28, 39, 18],
#        [62, 75, 66, 48],
#        [17,  6, 87, 47]])

p = m.astype(np.float32) #不改變原數組
p
# array([[99.,  4., 12.,  4.],
#        [95.,  7., 10., 88.],
#        [15., 84., 71., 13.],
#        [55., 28., 39., 18.],
#        [62., 75., 66., 48.],
#        [17.,  6., 87., 47.]], dtype=float32)

m.dtype
p.dtype
# dtype('int32')
# 
# dtype('float32')

（2）將數組變爲列表——ndarray.tolist

m
# array([[99,  4, 12,  4],
#        [95,  7, 10, 88],
#        [15, 84, 71, 13],
#        [55, 28, 39, 18],
#        [62, 75, 66, 48],
#        [17,  6, 87, 47]])

q = m.tolist() #不改變原數組
q
# [[99, 4, 12, 4],
#  [95, 7, 10, 88],
#  [15, 84, 71, 13],
#  [55, 28, 39, 18],
#  [62, 75, 66, 48],
#  [17, 6, 87, 47]]

type(m)
type(q)
# numpy.ndarray
# 
# list

3、 NumPy - 切片和索引

ndarray 對象的內容能夠經過索引或切片來訪問和修改，就像 Python 的內置容器對象同樣。
ndarray 對象中的元素遵循基於零的索引。有三種可用的索引方法類型：字段訪問，基本切片和高級索引。
基本切片是 Python 中基本切片概念到 n 維的擴展。經過將 start，stop 和 step 參數提供給內置的 slice 函數來構造一個 Python slice 對象。此 slice 對象被傳遞給數組來提取數組的一部分。

3.1 基本索引與切片——規則 [start : stop : step]

arr = np.arange(10)
arr
#array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

arr[3] #找到索引爲3的元素
#3

arr[:2] #截取前兩個元素，返回的依然是ndarray結構
#array([0, 1])

arr[2:8:2]#從索引2開始，一直到索引8，但娶不到索引8，步長爲2
#array([2, 4, 6])

#這裏須要注意的是：ndarray 的索引方式和 Python 內置的 list 有所不一樣，核心在於 #ndarray 的索引獲取的是一個視圖而非複製

arr[4:7] = 888
arr
#array([  0,   1,   2,   3, 888, 888, 888,   7,   8,   9])

arr_ps = arr[4:8]
arr_ps
#array([888, 888, 888,   7])

arr_ps[1:3] = 555
print(arr_ps)
print(arr)
# [888 555 555   7]
# [  0   1   2   3 888 555 555   7   8   9]

#若是須要獲得一個複製，須要顯式的制定獲取一個副本：
arr_cp = arr[4:8].copy()
arr_cp[:] = 77
print(arr_cp)
print(arr)
# [77 77 77 77]       淺拷貝，沒有改變原來的元素，說明是新開闢了內存空間來儲存
# [  0   1   2   3 888 555 555   7   8   9]

3.2 多維數組的基本索引切片

arr2d = np.array([[1,2,3],[4,5,6],[7,8,9]])
arr2d
# array([[1, 2, 3],
#        [4, 5, 6],
#        [7, 8, 9]])

arr2d[1]
#array([4, 5, 6])

arr2d[1:]
# array([[4, 5, 6],
#        [7, 8, 9]])

arr2d[0][2]
#3

arr2d[0,2] #能夠用列表的序列來索引多維數組中的元素
#3

#切片還能夠包括省略號 ... ，來使選擇元組的長度與數組的維度相同。若是在行位置使用##省略 號，它將返回包含行中元素的 ndarray：（通常不用的）

arr2d[1:,...]
# array([[4, 5, 6],
#        [7, 8, 9]])

arr2d[...,:1]
# array([[1],
#        [4],
#        [7]])

#固然，也可使用 : 來使用默認的從開始到包含結束的位置的索引：
arr2d[:,:1]  #這種方式用的更多
# array([[1],
#        [4],
#        [7]])

#對於更高維度的，也可使用索引和切片，可是不易於理解和查看：
arr3d = np.arange(1,13).reshape((2,2,3))
arr3d
# array([[[ 1,  2,  3],
#         [ 4,  5,  6]],
# 
#        [[ 7,  8,  9],
#         [10, 11, 12]]])

arr3d[0]
# array([[1, 2, 3],
#        [4, 5, 6]])

arr3d[1,0]
#array([7, 8, 9])

arr3d[1,0,2]
#9

3.3 整數索引

~若是一個 ndarray 是非元組序列，數據類型爲整數或布爾值的 ndarray，或者至少一個元素爲序列對象的元組，咱們就可以用它來索引 ndarray。高級索引始終返回數據的副本。與此相反，切片只提供了一個視圖。
~整數索引就是兩種高級索引的類型之一，另外一個高級索引方式爲布爾值索引。
~整數索引有助於基於 N 維索引來獲取數組中任意元素。每一個整數數組表示該維度的下標值。當索引的元素個數就是目標 ndarray 的維度時，會變得至關直接。如下示例獲取了 ndarray 對象中每一行指定列的一個元素。所以，行索引包含全部行號，列索引指定要選擇的元素。

x = np.array([[1, 2], [3, 4], [5, 6]])
x
# array([[1, 2],
#        [3, 4],
#        [5, 6]])

#該結果包括數組中 (0,0) ，(1,1) 和 (2,0) 位置處的元素。
#但若是你須要的是按數字對行列同時進行索引的而不是索引單個值的話，應當使用下面的#方式：
x[np.ix_([0,1,2],[0,1,0])]
# array([[1, 2, 1],
#        [3, 4, 3],
#        [5, 6, 5]])

#解讀，x[np.ix_([0,1,2],[0,1,0])]中的([0,1,2],[0,1,0])]中[0,1,2]時行，後面是列，#一一對應就會索引出一個3*3的數組

#也能夠利用數字索引生成一樣維度的數組：
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
x
# array([[ 0,  1,  2],
#        [ 3,  4,  5],
#        [ 6,  7,  8],
#        [ 9, 10, 11]])

x[[[0,0],[3,3]],     
  [[0,2],[0,2]]]

# array([[ 0,  2],    #好好想一想爲何是這麼個結果？？
#        [ 9, 11]])

3.4 布爾索引

當結果對象是布爾運算（例如比較運算符）的結果時，將使用此類型的高級索引。

x = np.arange(12).reshape(4,3)
x
# array([[ 0,  1,  2],
#        [ 3,  4,  5],
#        [ 6,  7,  8],
#        [ 9, 10, 11]])

x > 5
# array([[False, False, False],
#        [False, False, False],
#        [ True,  True,  True],
#        [ True,  True,  True]])

x[x > 5]    #將以前的布爾數組進行索引，並將返回結果轉化爲一維數組
#array([ 6,  7,  8,  9, 10, 11])

a = np.array([np.nan,1,2,np.nan,3,4,5])
a
#array([nan,  1.,  2., nan,  3.,  4.,  5.])

b = np.isnan(a)   #判斷a中的元素是不是空值
b
#array([ True, False, False,  True, False, False, False])

a[np.isnan(a)]   #去除a中的控制nan
a
#array([nan, nan])

a[~np.isnan(a)]  #取出a中的全部非空元素，這是至關經典的方法
#array([1., 2., 3., 4., 5.])

a = np.array([1, 2+6j, 5, 3.5+5j])
print(a)
print(a[np.iscomplex(a)])   #取出a中的複數
# [1. +0.j 2. +6.j 5. +0.j 3.5+5.j]
# [2. +6.j 3.5+5.j]

4、Numpy-數組切分組合

幾種方法能夠沿不一樣軸將數組堆疊在一塊兒：

np.vstack 沿縱軸拼接
np.hstack 沿橫軸拼接
np.row_stack 以行將數組拼接（等同於np.vstack）
np.column_stack 以列將數組拼接（等同於np.hstack）
np.concatenate 將數組以某一軸進行拼接（axis需人爲設定）

4.1 np.vstack 沿縱軸拼接

a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
print(a)
print(b)
# [[1 2]
#  [3 4]]
# [[11 12]
#  [13 14]]

np.vstack((a,b))
# array([[ 1,  2],
#        [ 3,  4],
#        [11, 12],
#        [13, 14]])

4.2 np.hstack 沿橫軸拼接

a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
print(a)
print(b)
# [[1 2]
#  [3 4]]
# [[11 12]
#  [13 14]]

np.hstack((a,b))
# array([[ 1,  2, 11, 12],
#        [ 3,  4, 13, 14]])

4.3 np.row_stack 以行將數組拼接（等同於np.vstack）

a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
print(a)
print(b)
# [[1 2]
#  [3 4]]
# [[11 12]
#  [13 14]]

np.row_stack((a,b))
# array([[ 1,  2],
#        [ 3,  4],
#        [11, 12],
#        [13, 14]])

4.4 np.column_stack 以列將數組拼接（等同於np.hstack）

a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
print(a)
print(b)
# [[1 2]
#  [3 4]]
# [[11 12]
#  [13 14]]

np.column_stack((a,b))
# array([[ 1,  2, 11, 12],
#        [ 3,  4, 13, 14]])

4.5 np.concatenate 將數組以某一軸進行拼接（axis需人爲設定）

a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
print(a)
print(b)
# [[1 2]
#  [3 4]]
# [[11 12]
#  [13 14]]

np.concatenate((a,b),axis=1)
# array([[ 1,  2, 11, 12],
#        [ 3,  4, 13, 14]])

np.concatenate((a,b),axis=0)
# array([[ 1,  2],
#        [ 3,  4],
#        [11, 12],
#        [13, 14]])

4.6 np.hsplit 縱向進行分割

a = np.arange(24).reshape(3,8)
a
# array([[ 0,  1,  2,  3,  4,  5,  6,  7],
#        [ 8,  9, 10, 11, 12, 13, 14, 15],
#        [16, 17, 18, 19, 20, 21, 22, 23]])

for i in np.hsplit(a,2): #保持行不變以列來分，若是隻填一個數據，會平均分，若是不能
    print(i)             #平均分，就會報錯
    print('*'*20)
# [[ 0  1  2  3]
#  [ 8  9 10 11]
#  [16 17 18 19]]
# ********************
# [[ 4  5  6  7]
#  [12 13 14 15]
#  [20 21 22 23]]
# ********************

for i in np.hsplit(a,(3,5)):#這種表示，先分出3列，再分出5列，但這5列裏又包含以前
    print(i)                       #的3列，因而第二部分只會有兩列
    print('*'*20)
# [[ 0  1  2]
#  [ 8  9 10]
#  [16 17 18]]
# ********************
# [[ 3  4]
#  [11 12]
#  [19 20]]
# ********************
# [[ 5  6  7]
#  [13 14 15]
#  [21 22 23]]
# ********************

4.7 np.vsplit 橫向進行分割

a = np.arange(24).reshape(3,8)
a
# array([[ 0,  1,  2,  3,  4,  5,  6,  7],
#        [ 8,  9, 10, 11, 12, 13, 14, 15],
#        [16, 17, 18, 19, 20, 21, 22, 23]])

for i in np.vsplit(a,3):   #平均分紅3行
    print(i)
    print('*'*20)
# [[0 1 2 3 4 5 6 7]]
# ********************
# [[ 8  9 10 11 12 13 14 15]]
# ********************
# [[16 17 18 19 20 21 22 23]]
# ********************

#和上面的np.hsplit類似，很少做討論

4.8 np.array_split 按指定軸進行分割

a = np.arange(24).reshape(3,8)
a
# array([[ 0,  1,  2,  3,  4,  5,  6,  7],
#        [ 8,  9, 10, 11, 12, 13, 14, 15],
#        [16, 17, 18, 19, 20, 21, 22, 23]])

for i in np.array_split(a,3,axis=1):
    print(i)
    print('*'*20)
# [[ 0  1  2]
#  [ 8  9 10]
#  [16 17 18]]
# ********************
# [[ 3  4  5]
#  [11 12 13]
#  [19 20 21]]
# ********************
# [[ 6  7]
#  [14 15]
#  [22 23]]
# ********************

for i in np.array_split(a,3,axis=0):
    print(i)
    print('*'*20)
# [[0 1 2 3 4 5 6 7]]
# ********************
# [[ 8  9 10 11 12 13 14 15]]
# ********************
# [[16 17 18 19 20 21 22 23]]
# ********************

5、 NumPy-廣播

術語廣播是指 NumPy 在算術運算期間處理不一樣形狀的數組的能力。對數組的算術運算一般在相應的元素上進行。若是兩個陣列具備徹底相同的形狀，則這些操做被無縫執行。

若是兩個數組的維數不相同，則元素到元素的操做是不可能的。然而，在 NumPy 中仍然能夠對形狀不類似的數組進行操做，由於它擁有廣播功能。較小的數組會廣播到較大數組的大小，以便使它們的形狀可兼容。

若是知足如下條件之一，那麼數組被稱爲可廣播的。

數組擁有相同形狀。
數組擁有相同的維數，且某一個或多個維度長度爲 1 。
數組擁有極少的維度，能夠在其前面追加長度爲 1 的維度，使上述條件成立

給出廣播示意圖:

#形狀相同的廣播：
np.arange(3)
#array([0, 1, 2])

a = np.ones((3,3))
print(a.ndim)
print(a.shape)
print(a)
# 2
# (3, 3)
# [[1. 1. 1.]
#  [1. 1. 1.]
#  [1. 1. 1.]]

print(a+a)
# [[2. 2. 2.]
#  [2. 2. 2.]
#  [2. 2. 2.]]

#相同維度，但其中某一個或多個維度長度爲 1 的廣播:
b = np.arange(3).reshape(1,3)
print(b.ndim)
print(b.shape)
print(b)
# 2
# (1, 3)
# [[0 1 2]]

print(a+b)
# [[1. 2. 3.]
#  [1. 2. 3.]
#  [1. 2. 3.]]

c = np.arange(3).reshape(3,1)
print(c.ndim)
print(c.shape)
print(c)
# 2
# (3, 1)
# [[0]
#  [1]
#  [2]]

print(a+c)
# [[1. 1. 1.]
#  [2. 2. 2.]
#  [3. 3. 3.]]

#較少的維度，默認在其前面追加長度爲 1 的維度：
d = np.arange(3)
print(d.ndim)
print(d.shape)
print(d)
# 1
# (3,)
# [0 1 2]

print(a + d)
# [[1. 2. 3.]
#  [1. 2. 3.]
#  [1. 2. 3.]]

#若是是標量的話，會廣播整個數組上：
 print(a * 3)
# [[3. 3. 3.]
#  [3. 3. 3.]
#  [3. 3. 3.]]

print(c * 3)
# [[0]
#  [3]
#  [6]]

print(d * 3)
#[0 3 6]

6、numpy運算

6.1 算數運算

用於執行算術運算（如 add() ，subtract() ，multiply() 和 divide() ）的輸入數組必須具有相同的形狀或符合數組廣播規則。
經常使用數學運算函數：

a = np.arange(9, dtype = np.float_).reshape(3,3)
b = np.array([10,11,12])
a
b
# array([[0., 1., 2.],
#        [3., 4., 5.],
#        [6., 7., 8.]])
# 
# array([10, 11, 12])

#執行數組的加法
print(np.add(a, b))
print(a+b)
# [[10. 12. 14.]
#  [13. 15. 17.]
#  [16. 18. 20.]]
# [[10. 12. 14.]
#  [13. 15. 17.]
#  [16. 18. 20.]]
#其他運算相似

numpy.reciprocal() 此函數返回參數逐元素的倒數，因爲 Python 處理整數除法的方式，對於絕對值大於 1 的整數元素，結果始終爲 0，對於整數 0，則發出溢出警告。

a = np.arange(0,5,0.3)
a
# array([0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8, 2.1, 2.4, 2.7, 3. , 3.3, 3.6,
#        3.9, 4.2, 4.5, 4.8])

print(np.reciprocal(a))
# [       inf 3.33333333 1.66666667 1.11111111 0.83333333 0.66666667
#  0.55555556 0.47619048 0.41666667 0.37037037 0.33333333 0.3030303
#  0.27777778 0.25641026 0.23809524 0.22222222 0.20833333]
# D:\anaconda\lib\site-packages\ipykernel_launcher.py:1: RuntimeWarning: 
#divide by zero encountered in reciprocal
#   """Entry point for launching an IPython kernel.

b = np.arange(1,5,1,dtype='int64')
print(b)
#[1 2 3 4]

#執行指數函數
np.exp(b)
np.exp2(b)
np.expm1(b) #返回np.exp(b)-1
# array([ 2.71828183,  7.3890561 , 20.08553692, 54.59815003])
# Out[155]:
# array([ 2.,  4.,  8., 16.])
# Out[155]:
# array([ 1.71828183,  6.3890561 , 19.08553692, 53.59815003])

#執行冪函數
np.power(3,b) #3的b次方
np.power(b,3) #b的3次方
# array([ 3,  9, 27, 81], dtype=int64)
# 
# array([ 1,  8, 27, 64], dtype=int64)

#numpy.mod() 此函數返回輸入數組中相應元素的除法餘數。函數 numpy.remainder() #也產生相同的結果。

a = np.array([10,20,30])
b = np.array([3,5,7])
print(a)
print(b)
# [10 20 30]
# [3 5 7]

print(np.mod(a,b))
print(np.remainder(a,b))
# [1 0 2]
# [1 0 2]

如下函數用於對含有複數的數組執行操做:

numpy.real() 返回複數類型參數的實部。
numpy.imag() 返回複數類型參數的虛部。
numpy.conj() 返回經過改變虛部的符號而得到的共軛複數。
numpy.angle() 返回複數參數的角度。函數的參數是 degree 。若是爲 true，返回的角度以角度制來表示，不然爲以弧度制來表示。

a = np.array([-5.6j, 0.2j, 11. , 1+1j])
print(a)
#[-0.-5.6j  0.+0.2j 11.+0.j   1.+1.j ]

print(np.real(a)) #實部
print(np.imag(a)) #虛部
# [-0.  0. 11.  1.]
# [-5.6  0.2  0.   1. ]

print(np.conj(a)) #求a的共軛複數
#[-0.+5.6j  0.-0.2j 11.-0.j   1.-1.j ]

print(np.angle(a,deg=True))  #角度
print(np.angle(a,deg=False)) #弧度
# [-90.  90.   0.  45.]
# [-1.57079633  1.57079633  0.          0.78539816]

#執行三角函數
a = np.array([0,30,45,60,90])
print(np.sin(a * np.pi/180))
#[0.         0.5        0.70710678 0.8660254  1.        ]

補充 numpy.around() numpy.floor() numpy.ceil()

#numpy.around() 這個函數返回四捨五入到所需精度的值。decimals 表示要舍入的小數位##數。默認值爲 0。若是 爲負，整數將四捨五入到小數點左側的位置

a = np.array([1.0,5.55, 123, 0.567, 25.532])
print(a)
print(np.around(a))
print(np.around(a, decimals = 1))
print(np.around(a, decimals = -1))
# [  1.      5.55  123.      0.567  25.532]
# [  1.   6. 123.   1.  26.]
# [  1.    5.6 123.    0.6  25.5]
# [  0.  10. 120.   0.  30.]

#同 Python 內置同樣，在進行舍入操做時須要注意二進制小數的精度問題
np.around(2.5)
#2.0      爲何？？？？這個就有點意思了

#numpy.floor() 向下取整
#此函數返回不大於輸入參數的最大整數。即標量 x 的下限是最大的整數 i ，使得 i <= x。注#意 在 Python 中，向下取整老是從 0 舍入。

a = np.array([-1.7, 1.5, -0.2, 0.6, 10])
print(np.floor(a))

#[-2.  1. -1.  0. 10.]

#numpy.ceil()向上取整
#本函數返回輸入值的上限，即，標量 x 的上限是最小的整數 i ，使得 i> = x。
a = np.array([-1.7, 1.5, -0.2, 0.6, 10])
print(np.ceil(a))
#[-1.  2. -0.  1. 10.]

6.2 字符串函數

6.2.1 鏈接兩個數組中對應位置上的字符串—numpy.char.add()

#函數執行按元素的字符串鏈接：
a = np.array([["Hello"],["Hi"]])
print(a.dtype)
print(a)
# <U5
# [['Hello']
#  ['Hi']]

b = np.array([["abc"],["xyz"]])
print(b.dtype)
print(b)
# <U3
# [['abc']
#  ['xyz']]

print(np.char.add(a,b))
# [['Helloabc']
#  ['Hixyz']]

c = np.array(["abc", "def", "ghi"])
print(c.dtype)
print(c)
# <U3
# ['abc' 'def' 'ghi']

print(np.char.add(c, "嗯哼 ~?"))
#['abc嗯哼 ~?' 'def嗯哼 ~?' 'ghi嗯哼 ~?']

6.2.2 返回按元素多重鏈接後的字符串—numpy.char.multiply()

print(np.char.multiply('Hello ',3))
#Hello Hello Hello

print(np.char.multiply(a, 3))
# [['HelloHelloHello']
#  ['HiHiHi']]

6.2.3 此函數返回所需寬度的數組，以便輸入字符串位於中心，並使用 fillchar 在左側和右側進行填充—numpy.char.center()

np.char.center('hello', 20,fillchar = '*')
#array('*******hello********', dtype='<U20')

6.2.4 函數返回字符串的副本，其中第一個字母大寫—numpy.char.capitalize()

print(np.char.capitalize('hello world'))
#Hello world

e = np.array(['hello world', "how are you?"])
print(np.char.capitalize(e))
#['Hello world' 'How are you?']

6.2.5 將字符串的每一個單詞的第一個字母轉換爲大寫—numpy.char.title()

print(np.char.title('hello how are you?'))
#Hello How Are You?

print(np.char.title(e))
#['Hello World' 'How Are You?']

6.2.6 數組元素轉換爲小寫—numpy.char.lower()

#numpy.char.lower()
#函數返回一個數組，其元素轉換爲小寫。它對每一個元素調用 str.lower：

f = np.array(['HELLO','WORLD'])
print(np.char.lower(f))
#['hello' 'world']

6.2.7 數組元素轉換爲大寫—numpy.char.upper()

#numpy.char.upper()
#函數返回一個數組，其元素轉換爲大寫。它對每一個元素調用 str.upper：

print(np.char.upper('world'))
#WORLD

print(np.char.upper(e))
#['HELLO WORLD' 'HOW ARE YOU?']

6.2.8 指定分隔符對字符串進行分割，並返回數組列表—numpy.char.split()

# numpy.char.split()
#此函數返回輸入字符串中的單詞列表。默認狀況下，空格用做分隔符。不然，指定的分隔符字符用於分割字符串：

print(np.char.split(e))
#[list(['hello', 'world']) list(['how', 'are', 'you?'])]

print(np.char.split ('TutorialsPoint,Hyderabad,Telangana', sep = ','))
#['TutorialsPoint', 'Hyderabad', 'Telangana']

6.2.9 返回元素中的行列表，以換行符分割—numpy.char.splitlines()

# numpy.char.splitlines()
# 函數返回數組中元素的單詞列表，以換行符分割：
# '\n'，'\r'，'\r\n' 都被當作換行符處理。

print(np.char.splitlines('hello\nhow are you?'))
#['hello', 'how are you?']

a = np.array(['123', '456', 'abc', 'zxc', '789', 'ooo'])
b = a.reshape(3,2)
print(b)
# [['123' '456']
#  ['abc' 'zxc']
#  ['789' 'ooo']]

print(np.char.splitlines(b))
# [[list(['123']) list(['456'])]
#  [list(['abc']) list(['zxc'])]
#  [list(['789']) list(['ooo'])]]

6.2.10 移除元素開頭或者結尾處的特定字符—numpy.char.strip()

#numpy.char.strip()
#函數返回數組的副本，其中元素移除了開頭或結尾處的特定字符：

print(np.char.strip('ashok arora','a'))  #去除首位的a
print(np.char.strip(['arora','admin','java'],'a'))
#shok aror
#['ror' 'dmin' 'jav']

6.2.11 經過指定分隔符來鏈接數組中的元素—numpy.char.join()

#numpy.char.join()
#這個函數返回一個字符串，其中單個字符由特定的分隔符鏈接：

print(np.char.join(':','dmy'))
print(np.char.join([':','-'],['dmy','ymd']))
#d:m:y
#['d:m:y' 'y-m-d']

6.2.12 使用新字符串替換字符串中選定子字符串—numpy.char.replace()

#numpy.char.replace()
#這個函數返回字符串副本，其中全部字符序列的出現位置都被另外一個給定的字符序列取代：

print(np.char.replace('she is a bad girl', 'is', 'was'))
#she was a bad girl

6.3 統計函數

NumPy有不少有用的統計函數，用於從數組中給定的元素中查找最小，最大，百分標準差和方差等。

經常使用統計函數
numpy.amin()	從給定數組中的元素沿指定軸返回最小值
numpy.amax()	從給定數組中的元素沿指定軸返回最大值
numpy.ptp()	返回沿軸的值的極差（最大值 - 最小值）
numpy.percentile()	返回特定軸的百分位數
numpy.median()	返回數組中值
numpy.mean()	返回數組的算術平均值
numpy.average()	返回數組的加權平均值
numpy.std()	返回數組的標準差
numpy.var()	返回數組的方差

6.3.1 從給定數組中的元素沿指定軸返回最小值—numpy.amin()

a = np.array([[3,7,5],[8,4,3],[2,4,9]])
print(a)
# [[3 7 5]
#  [8 4 3]
#  [2 4 9]]

print(np.amin(a))    #返回數組中的最小值
print(np.amin(a,axis=0)) #返回每一列中的最小值
print(np.amin(a,axis=1)) #返回沒一行中的最小值
# 2
# [2 4 3]
# [3 3 2]

6.3.2 從給定數組中的元素沿指定軸返回最大值—numpy.amax()

a = np.array([[3,7,5],[8,4,3],[2,4,9]])
print(a)
# [[3 7 5]
#  [8 4 3]
#  [2 4 9]]

print(np.amax(a))  #返回數組中的最大值
print(np.amax(a, 0)) #返回每一列當中的最大值
print(np.amax(a, 1)) #返回每一行當中的最大值
# 9
# [8 7 9]
# [7 8 9]

6.3.3 返回沿軸的值的極差（最大值 - 最小值）—numpy.ptp()

a = np.array([[3,7,5],[8,4,3],[2,4,9]])
print(a)
# [[3 7 5]
#  [8 4 3]
#  [2 4 9]]

print(np.ptp(a))  #返回整個數組中的最大值-最小值
print(np.ptp(a, 0)) #返回每一列中的最大值-最小值
print(np.ptp(a, 1)) #返回每一行中的最大值-最小值
# 7 
# [6 3 6]
# [4 5 7]

6.3.4 百分位數—numpy.percentile()

百分位數是統計中使用的度量，表示小於這個值得觀察值佔某個百分比。函數numpy.percentile() 接受如下參數。
numpy.percentile(a, q, axis)

a 輸入數組
q 要計算的百分位數，在 0 ~ 100 之間
axis 沿着它計算百分位數的軸

a = np.array([[30,40,70],[80,20,10],[50,90,60]])
print(a)
# [[30 40 70]
#  [80 20 10]
#  [50 90 60]]

print(np.percentile(a,50))
print(np.percentile(a,50, axis = 0))
print(np.percentile(a,50, axis = 1))
# 50.0
# [50. 40. 60.]
# [40. 20. 60.]

關於百分位數的原理：

而後查了下它的實現原理：

  首先將你的輸入數組進行從小到大排序，而後計算:

(n−1)∗p=i+j (n-1)*p = i + j(n−1)∗p=i+j

  其中n爲數組元素的個數，將計算結果的整數部分用i表示，小數部分用j來表示。則最終的percentile值爲：

res=(1−j)∗array[i]+j∗array[i+1] res = (1-j) * array[i] + j * array[i+1]res=(1−j)∗array[i]+j∗array[i+1]

6.3.5 用於計算數組 a 中元素的中位數（中值）—numpy.median()

#numpy.median()
#中值定義爲將數據樣本的上半部分與下半部分分開的值。

a = np.array([[30,65,70],[80,95,10],[50,90,60]])
print(a)
# [[30 65 70]
#  [80 95 10]
#  [50 90 60]]

print(np.median(a))
print(np.median(a, axis = 0))  #返回每一列的中值
print(np.median(a, axis = 1))
# 65.0
# [50. 90. 60.]
# [65. 80. 60.]

6.3.6 返回數組中元素的算術平均值—numpy.mean()

#numpy.mean()
#算術平均值是沿軸的元素的總和除以元素的數量。函數返回數組中元素的算術平均值。若是提#供了軸，則沿其計算。

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

print(np.mean(a))
print(np.mean(a, axis = 0))
print(np.mean(a, axis = 1))
# 3.6666666666666665
# [2.66666667 3.66666667 4.66666667]
# [2. 4. 5.]

6.3.7 返回數組中元素的加權平均值—numpy.average()

# numpy.average()
# 加權平均值是由每一個份量乘以反映其重要性的因子獲得的平均值。函數根據在另外一個數組中給出的各自的權重計算數組中元素的加權平均值。該函數能夠接受一個軸參數。若是沒有指定軸，則數組會被展開。
# 考慮數組 [1,2,3,4] 和相應的權重 [4,3,2,1] ，經過將相應元素的乘積相加，並將和除以權重的和，來計算加權平均值。
# 加權平均值 = (1*4+2*3+3*2+4*1)/(4+3+2+1)

a = np.array([1,2,3,4])
print(a)
# [1 2 3 4]

#不指定權重時至關於 mean 函數
print(np.average(a)) #默認權重是[1, 1, 1, 1]
#2.5

wts = np.array([4,3,2,1])
print(np.average(a,weights = wts))
#2.0

#若是 returned 參數設爲 true，則會返回權重的和
print(np.average([1,2,3,4],weights=[4,3,2,1], returned=True))  20/10
#(2.0, 10.0)      #以元祖形式返回（加權平均， 權重之和）

6.3.8 返回數組的標準差—numpy.std()

#numpy.std()
#標準差是與均值的誤差的平方的平均值的平方根。標準差公式以下： std = sqrt(mean((x - #x.mean())**2))

print(np.std([1,2,3,4]))
#1.118033988749895

6.3.9 返回數組的方差—numpy.var()

print(np.var([1,2,3,4]))
#1.25

6.4 排序、搜索和計數函數

6.4.1 返回輸入數組的排序副本默認對行進行升序—numpy.sort()

#numpy.sort()函數返回輸入數組的排序副本。 默認對行進行升序

a = np.array([[3,7],[9,1]])
print(a)
# [[3 7]
#  [9 1]]

print(np.sort(a)) #默認對每行進行升序
# [[3 7]
#  [1 9]]

print(np.sort(a, axis = 0)) #axis = 0表示對列進行排序
# [[3 1]
#  [9 7]]

6.4.2 返回的是數組值從小到大的索引值—numpy.argsort()

#numpy.argsort()
#函數對輸入數組沿給定軸執行間接排序，並使用指定排序類型返回數據的索引數組。這個索引 #數組用於構造排序後的數組。 返回數組升序後的原來數組的索引

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

y = np.argsort(x)
print(y)
#[1 2 0]

print(x[y])
#[1, 2, 3]

6.4.3 用於對多個序列進行排序—numpy.lexsort()

這個函數就有點意思了，剛看的時候徹底不明白是怎麼排序的

#numpy.lexsort()
#函數使用鍵序列執行間接排序。鍵能夠看做是電子表格中的一列。該函數返回一個索引數組，#使用它能夠得到排序數據。注意，最後一個鍵剛好是 sort 的主鍵。

a = [1,5,1,4,3,4,4] # First column
b = [9,4,0,4,0,2,1] # Second column
ind = np.lexsort((b,a)) # Sort by a, then by b
print(ind)
#[2 0 4 6 5 3 1]
#關於該函數的實現過程，第一步先對後面的a進行從小到大的排序[1 1 3 4 4 4 5]，獲得索引[0 2 4 3 5 6 1]
#可是前面兩個[1 1]，是同樣的，這這時按照對應的索引[0 2]取出中的[9 0],對此進行排序[0 9]意味着要把
#[0 2]變成[2 0],後面的[4 4 4]同樣的




[(a[i],b[i]) for i in ind] #列表推導式
#[(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)]

6.4.4 沿給定軸返回最大元素的索引—numpy.argmax() 最小—numpy.argmin()

a = np.array([[30,40,70],[80,20,10],[50,90,60]])
print(a)
# [[30 40 70]
#  [80 20 10]
#  [50 90 60]]

print(np.argmax(a)) #應該是返回在全部元素的第幾個位置
#7

print(a.flatten()) #將數組轉化爲一行
a.flatten()[7]
#90

np.argmax(a, axis = 0) #按列來求
np.argmax(a, axis = 1) #按行來求

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

6.4.5 返回輸入數組中非零元素的索引—numpy.nonzero()

a = np.array([[30,40,0],[0,20,10],[50,0,60]])
print(a)
# [[30 40  0]
#  [ 0 20 10]
#  [50  0 60]

print(np.nonzero(a)) #兩個是分別按照axis=0,axis=1返回的索引 第一個數組是行，第二
                     #個數組是列！

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

a[np.nonzero(a)] # 挑選出非零元素  至關經典
#array([30, 40, 20, 10, 50, 60])

6.4.6 返回輸入數組中知足給定條件的元素的索引—numpy.where()

x = np.arange(9.).reshape(3, 3)
print(x)
# [[0. 1. 2.]
#  [3. 4. 5.]
#  [6. 7. 8.]]]

print(np.where(x > 3))
#(array([1, 1, 2, 2, 2], dtype=int64), array([1, 2, 0, 1, 2], dtype=int64))

x[np.where(x>3)]
#array([4., 5., 6., 7., 8.])

a = np.array([1,2,3,4,5])
b = np.array([5,4,3,2,1])
print(np.where(a > b, a, b)) #返回a, b中的較大值
#[5 4 3 4 5]

6.4.7 返回知足任何條件的元素—numpy.extract()

x = np.arange(9.).reshape(3, 3)
print(x)
# [[0. 1. 2.]
#  [3. 4. 5.]
#  [6. 7. 8.]]

condition = np.mod(x,2) == 0
print(condition)
# [[ True False  True]
#  [False  True False]
#  [ True False  True]]

np.extract(condition, x)
#array([0., 2., 4., 6., 8.])

6.5 轉置

Numpy 的轉置能夠按照你的須要對數組的軸進行轉換

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

arr.T
# array([[ 0,  5, 10],
#        [ 1,  6, 11],
#        [ 2,  7, 12],
#        [ 3,  8, 13],
#        [ 4,  9, 14]])

#須要注意的是，轉置只能發生在二維及以上的維度的數組上生效，一維的數組只有一個維度是 #不能夠轉置的。 一維的怎麼辦？np.reshape(1,-1)變成二維，再轉置

a = np.arange(7)
print(a.shape)
print(a.ndim)
print(a)
# (7,)
# 1
# [0 1 2 3 4 5 6]

a.T
#array([0, 1, 2, 3, 4, 5, 6])

6.6 惟一化和集合邏輯

6.6.1 去掉數組中重複的元素—np.unique()

#字符串去重
names = np.array(['Atom', 'Lucy', 'Kid', 'Atom', 'Kid', 'Atom'])
print(names)
print(np.unique(names))
# ['Atom' 'Lucy' 'Kid' 'Atom' 'Kid' 'Atom']
# ['Atom' 'Kid' 'Lucy']

#整數去重
ints = np.array([1,2,3,4,2,4,3,5])
print(ints)
print(np.unique(ints))
# [1 2 3 4 2 4 3 5]
# [1 2 3 4 5]

#布爾值去重
bools = np.array([False, True, True, False])
print(bools)
print(np.unique(bools))
# [False  True  True False]
# [False  True]

6.6.2 驗證元素是否在給定序列中—np.in1d()

#布爾值的any()和all()函數
bools = np.array([False, True, True, False])
bools.any() #有一個True就返回True
bools.all() #全部都爲True才返回True
# True
# 
# False

val_1 = np.array([4,5,6,2,5,7,4,0])
val_2 = np.array([1,2,3,4,7,8,4,3])
# 驗證 val_1 中的元素是否在給出的序列中
np.in1d(val_1, [0, 5, 7])
#array([False,  True, False, False,  True,  True, False,  True])

6.6.3 求交集—np.intersect1d()

val_1 = np.array([4,5,6,2,5,7,4,0])
val_2 = np.array([1,2,3,4,7,8,4,3])
#求交集
np.intersect1d(val_1, val_2)

#array([2, 4, 7])

6.6.4 求並集—np.union1d()

val_1 = np.array([4,5,6,2,5,7,4,0])
val_2 = np.array([1,2,3,4,7,8,4,3])
#求並集
np.union1d(val_1,val_2)

#array([0, 1, 2, 3, 4, 5, 6, 7, 8])

6.6.5 求差集—np.setdiff1d()

# 求差集 假設有集合A和B，全部屬於A且不屬於B的元素的集合被稱爲A與B的差集 =A - AB
np.setdiff1d(val_1, val_2)
np.setdiff1d(val_2, val_1)

# array([0, 5, 6])

# array([1, 3, 8])

7、NumPy - 矩陣庫

NumPy 包包含一個 Matrix 庫 numpy.matlib 。此模塊的函數返回矩陣而不是返回 ndarray對象。

7.1 導入矩陣庫

import numpy.matlib

7.2 返回一個新的矩陣，且不初始化元素—matlib.empty()

# matlib.empty()
# 函數返回一個新的矩陣，且不初始化元素。裏面的初始化數據無心義

m = np.matlib.empty((2,2))
type(m)
m
# #numpy.matrixlib.defmatrix.matrix
# Out[42]:
# matrix([[4.24399158e-314, 8.48798317e-314],
#         [1.06099790e-313, 1.48539705e-313]])

7.3 返回以0填充的矩陣—numpy.matlib.zeros()

np.matlib.zeros((2,2))

# matrix([[0., 0.],
#         [0., 0.]]

7.4 返回以1填充的矩陣—numpy.matlib.ones()

np.matlib.ones((5,5))

# # #matrix([[1., 1., 1., 1., 1.],
#            [1., 1., 1., 1., 1.],
#            [1., 1., 1., 1., 1.],
#            [1., 1., 1., 1., 1.],
#            [1., 1., 1., 1., 1.]])

7.5 返回一個矩陣，對角線元素爲 1，其餘位置爲零—numpy.matlib.eye()

np.matlib.eye(n = 3, M = 3, k = 0, dtype = float)
#n: 返回矩陣的行數
# M: 返回矩陣的列數，默認爲 n
# k: 對角線的索引
# dtype: 數據類型

# matrix([[1., 0., 0.],
#         [0., 1., 0.],
#         [0., 0., 1.]])

np.matlib.eye(n = 3, M = 3, k = 1, dtype = float)
# matrix([[0., 1., 0.],
#         [0., 0., 1.],
#         [0., 0., 0.]])

np.matlib.eye(n = 3, M = 4, k = 1, dtype = float)
# matrix([[0., 1., 0., 0.],
#         [0., 0., 1., 0.],
#         [0., 0., 0., 1.]])

7.6 返回給定大小的單位矩陣。單位矩陣是主對角線元素都爲 1 的方陣—numpy.matlib.identity()

np.matlib.identity(5, dtype = float)
# matrix([[1., 0., 0., 0., 0.],
#         [0., 1., 0., 0., 0.],
#         [0., 0., 1., 0., 0.],
#         [0., 0., 0., 1., 0.],
#         [0., 0., 0., 0., 1.]])

7.7 返回給定大小的填充隨機值的矩陣—numpy.matlib.rand()

np.matlib.rand(3,3)

# matrix([[0.15307052, 0.69552953, 0.31876643],
#         [0.6919703 , 0.55438325, 0.38895057],
#         [0.92513249, 0.84167   , 0.35739757]])

注意，矩陣老是二維的，而 ndarray 是一個 n 維數組。兩個對象都是可互換的，可是兩個對象並非相同的

8、 NumPy - 線性代數

NumPy 包包含 numpy.linalg 模塊，提供線性代數所需的全部功能。

numpy.dot() 返回兩個數組的點積
numpy.vdot() 返回兩個向量的點積
numpy.inner() 返回一維數組的向量內積
numpy.matmul() 返回兩個數組的矩陣乘積
numpy.linalg.det() 計算輸入矩陣的行列式
numpy.linalg.solve() 求解矩陣形式的線性方程的解
numpy.linalg.inv() 計算矩陣的逆

8.1 返回兩個數組的點積—numpy.dot() （二維數組的點積就是矩陣的乘積）

#numpy.dot()
#此函數返回兩個數組的點積。對於二維向量，其等效於矩陣乘法。對於一維數組，它是向量的 #內積。對於 N 維數組，它是 a 的最後一個軸上的和與 b 的倒數第二個軸的乘積。

a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
print(a)
print(b)

#  [[1 2]
#  [3 4]]
# [[11 12]
#  [13 14]]

np.dot(a,b)

# array([[37, 40],
#        [85, 92]])

#在較新版本中支持了以 @ 符號來表示矩陣的乘法
print(a @ b)

# array([[37, 40],
#        [85, 92]])

8.2 返回兩個向量的點積—numpy.vdot()

#numpy.vdot()
#此函數返回兩個向量的點積。若是第一個參數是複數，那麼它的共軛複數會用於計算。若是參#數是多維數組，它會被展開。相同位置的元素相乘再求和

a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
print(a)
print(b)

# [[1 2]
#  [3 4]]
# [[11 12]
#  [13 14]]

np.vdot(a,b)  # 點積就是對應位置相乘再求和

#130

a = np.array([1,2,3,4])
b = np.array([11,12,13,14]).reshape(4,1)
print(a)
print(b)

#[1 2 3 4]
# [[11]
#  [12]
#  [13]
#  [14]]

np.vdot(a,b)

#130

8.3 返回一維數組的向量內積。對於更高的維度，它返回最後一個軸上的乘積的和—numpy.inner()

print(np.inner(np.array([1,2,3]),
               np.array([0,1,0])) ) #等價於1*0+2*1+3*0

#2

a = np.array([[1,2], [3,4]])
b = np.array([[11, 12], [13, 14]])
print(a)
print(b)

# [[1 2]
#  [3 4]]
# [[11 12]
#  [13 14]]

np.inner(a, b)
# array([[35, 41],
#        [81, 95]])

#上面的例子中，內積計算以下：
#1∗11+2∗121∗11+2∗12 ,  1∗13+2∗141∗13+2∗14 
#3∗11+4∗123∗11+4∗12 ,  3∗13+4∗143∗13+4∗14

8.4 返回兩個數組的矩陣乘積—numpy.matmul()

#numpy.matmul()
#函數返回兩個數組的矩陣乘積。雖然它返回二維數組的正常乘積，但若是任一參數的維數大於 #2，則將其視爲存在於最後兩個索引的矩陣的棧，並進行相應廣播。另外一方面，若是任一參數#是一 維數組，則經過在其維度上附加 1 來將其提高爲矩陣，並在乘法以後被去除。

# 對於二維數組，它就是矩陣乘法
a = [[1,0],[0,1]]
b = [[4,1],[2,2]]
print(a)
print(b)
print(np.matmul(a,b))

# [[1, 0], [0, 1]]
# [[4, 1], [2, 2]]
# [[4 1]
#  [2 2]]

# 二維和一維運算
a = [[1,0],[0,1]]
b = [1,2]
print(np.matmul(a,b))
print(np.matmul(b,a))

# [1 2]
# [1 2]

 # 維度大於二的數組
a = np.arange(8).reshape(2,2,2)
b = np.arange(4).reshape(2,2)
print(np.matmul(a,b))

# [[[ 2  3]
#   [ 6 11]]
# 
#  [[10 19]
#   [14 27]]]

8.5 計算輸入矩陣的行列式—numpy.linalg.det()

#numpy.linalg.det()
#函數計算輸入矩陣的行列式。行列式在線性代數中是很是有用的值。

a = np.array([[1,2], [3,4]])
print(a)
np.linalg.det(a)

# [[1 2]
#  [3 4]]

# -2.0000000000000004

b = np.array([[6,1,1], [4, -2, 5], [2,8,7]])
print(b)
np.linalg.det(b)

# [[ 6  1  1]
#  [ 4 -2  5]
#  [ 2  8  7]]
# 
# -306.0

8.6 求出矩陣形式的線性方程的解—numpy.linalg.solve()

若是矩陣成爲 A 、X 和 B ，方程變爲：AX = B

A = np.array([[1,1,1],[0,2,5],[2,5,-1]])
B = np.array([6,-4,27])
print(A)
print(B)

# [[ 1  1  1]
#  [ 0  2  5]
#  [ 2  5 -1]]
# [ 6 -4 27]

X = np.linalg.solve(A, B)
print(X)

#[ 5.  3. -2.]

np.allclose(np.dot(A,X),B) #判斷二者是否相等
#True

8.7 計算矩陣的逆—numpy.linalg.inv()

x = np.array([[1,2],[3,4]])
y = np.linalg.inv(x)
print(x)
print(y)

# [[1 2]
#  [3 4]]
# [[-2.   1. ]
#  [ 1.5 -0.5]]

print(x.dot(y))   #A*A^{-1}    等於單位陣

# [[1.00000000e+00 1.11022302e-16]
#  [0.00000000e+00 1.00000000e+00]]

9、NumPy - IO

ndarray 對象能夠保存到磁盤文件並從磁盤文件加載。可用的 IO 功能有：

load() 和 save() 函數處理 NumPy 二進制文件（帶 npy 擴展名）
loadtxt() 和 savetxt() 函數處理正常的文本文件

NumPy 爲 ndarray 對象引入了一個簡單的文件格式。這個 npy 文件在磁盤文件中，存儲重建ndarray 所需的數據、圖形、dtype 和其餘信息，以便正確獲取數組，即便該文件在具備不一樣架構的另外一臺機器上。

9.1 將輸入數組存儲在具備 npy 擴展名的磁盤文件中—numpy.save()

a = np.array([1,2,3,4,5])
np.save('outfile222',a)

爲了從 outfile.npy 重建數組，請使用 load() 函數

b = np.load('outfile222.npy')
print(b)

#[1 2 3 4 5]

9.2 以簡單文本文件格式存儲和獲取數組數據—savetxt()和loadtx()

a = np.array([1,2,3,4,5])
np.savetxt('out.txt',a)
b = np.loadtxt('out.txt')
print(b)

#[1. 2. 3. 4. 5.]

savetxt() 和 loadtxt() 函數接受附加的可選參數，例如頁首，頁尾和分隔符。

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。

numpy

1、Numpy概述

1.1 Numpy簡介

1.2 Numpy的安裝

2、 Numpy-Ndarray對象

2.1 建立Ndarray

2.1.1 np.array 能夠把 list，tuple，array 或者其餘的序列模式的數據轉建立爲新的 ndarray

2.2 numpy的ndarray 與 python原生array有什麼區別

2.2.1 Numpy 的矢量化（向量化）功能

2.3 數據類型 (dtype)

2.3.1 基本數據類型

2.3.2 類型轉換——.astype()方法（首選）

2.3.3 經常使用的數組

（1）全0數組——np.zeros()

（2）全1數組——np.ones()

（3）全爲相同值的數組——np.full()

（4）單位矩陣——np.eye()

（5）按照某一數組的形狀生成ndarray——np.ones_like np.zeros_like np.full_like

（6）建立一個初始化的數組——np.empty()

（7）建立對角矩陣——np.diag()

（8）設置空值——np.nan

（9）隨機數組——np.random

（10）建立一個線性序列的數組——np.arange

2.3.4 數組屬性

（1）查看數據的形狀——np.shape

（2）查看維度——np.ndim

（3）統計數組中全部的元素個數——np.size

（4）查看數組中元素類型——np.dtype

（5）查看數組中每一個元素的字節單位長度——np.itemsize

2.3.5 數組的維度變換

（1）改變數組形狀，返回新的ndarray對象，即不改變原數組——ndarray.reshape

（2）改變數組形狀,但改變了原數組——ndarray.resize

（3）將二維數組的兩個維度調換,但不改變了原數組——ndarray.swapaxes(1,0)

（4）所有轉爲一行m.reshape(1,-1)或者m.flatten（），或者一列m.reshape(-1,1)

2.3.6 數組的類型變換

（1）更改數組中元素的類型——ndarray.astype

（2）將數組變爲列表——ndarray.tolist

3、 NumPy - 切片和索引

3.1 基本索引與切片——規則 [start : stop : step]

3.2 多維數組的基本索引切片

3.3 整數索引

3.4 布爾索引

4、Numpy-數組切分組合

4.1 np.vstack 沿縱軸拼接

4.2 np.hstack 沿橫軸拼接

4.3 np.row_stack 以行將數組拼接（等同於np.vstack）

4.4 np.column_stack 以列將數組拼接（等同於np.hstack）

4.5 np.concatenate 將數組以某一軸進行拼接（axis需人爲設定）

4.6 np.hsplit 縱向進行分割

4.7 np.vsplit 橫向進行分割

4.8 np.array_split 按指定軸進行分割

5、 NumPy-廣播

6、numpy運算

6.1 算數運算

補充 numpy.around() numpy.floor() numpy.ceil()

6.2 字符串函數

6.2.1 鏈接兩個數組中對應位置上的字符串—numpy.char.add()

6.2.2 返回按元素多重鏈接後的字符串—numpy.char.multiply()

6.2.3 此函數返回所需寬度的數組，以便輸入字符串位於中心，並使用 fillchar 在左側和右側進行填充—numpy.char.center()

6.2.4 函數返回字符串的副本，其中第一個字母大寫—numpy.char.capitalize()

6.2.5 將字符串的每一個單詞的第一個字母轉換爲大寫—numpy.char.title()

6.2.6 數組元素轉換爲小寫—numpy.char.lower()

6.2.7 數組元素轉換爲大寫—numpy.char.upper()

6.2.8 指定分隔符對字符串進行分割，並返回數組列表—numpy.char.split()

6.2.9 返回元素中的行列表，以換行符分割—numpy.char.splitlines()

6.2.10 移除元素開頭或者結尾處的特定字符—numpy.char.strip()

6.2.11 經過指定分隔符來鏈接數組中的元素—numpy.char.join()

6.2.12 使用新字符串替換字符串中選定子字符串—numpy.char.replace()

6.3 統計函數

6.3.1 從給定數組中的元素沿指定軸返回最小值—numpy.amin()

6.3.2 從給定數組中的元素沿指定軸返回最大值—numpy.amax()

6.3.3 返回沿軸的值的極差（最大值 - 最小值）—numpy.ptp()

6.3.4 百分位數—numpy.percentile()

6.3.5 用於計算數組 a 中元素的中位數（中值）—numpy.median()

6.3.6 返回數組中元素的算術平均值—numpy.mean()

6.3.7 返回數組中元素的加權平均值—numpy.average()

6.3.8 返回數組的標準差—numpy.std()

6.3.9 返回數組的方差—numpy.var()

6.4 排序、搜索和計數函數

6.4.1 返回輸入數組的排序副本 默認對行進行升序—numpy.sort()

6.4.1 返回輸入數組的排序副本默認對行進行升序—numpy.sort()