NumPy全基礎學習

前導

準備

• NumPy的安裝準備作業在上篇文章中，點此跳轉
• Python學習，具體參閱Python教程
• 為運行示例，需安裝matplotlib庫，具體看文章的上一篇

學習目標

• 了解NumPy中一維陣列，二維陣列和n維陣列之間的區別
• 了解如何在不使用for回圈的情況下將一些線性代數運算應用于n維陣列
• 了解n維陣列的軸和形狀屬性

---

基礎

簡單介紹

? NumPy的主要物件是齊次多維陣列，它是由非負整數的元組索引的所有型別相同的元素（通常為數字）表，在NumPy中，維度稱為軸，

? 例如：3D空間上的點的坐標[1,2,1]只有一個軸，該軸上有3個元素，所以我們說它的長度為3.

? 在下圖所示的中，陣列有2個軸：第一個軸的長度為2，第二個軸的長度為3（可以理解為2行3列的向量）

[[1.,0.,0.],
[0.,1.,2.]]

NumPy的陣列類別稱為ndarray，

ndarray 物件是用于存放同型別元素的多維陣列，

ndarray 中的每個元素在記憶體中都有相同存盤大小的區域，

創建一個ndarray只需呼叫Numpy的array函式即可：

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

引數說明：

名稱	描述
object	陣列或嵌套的數列
dtype	陣列元素的資料型別，可選
copy	物件是否需要復制，可選
order	創建陣列的樣式，C為行方向，F為列方向，A為任意方向（默認）
subok	默認回傳一個與基型別別一致的陣列
ndmin	指定生成陣列的最小維度

ndarray物件的重要的屬性如下：

• ndarray.ndim

? 陣列的軸(維度)數

• ndarray.shape

? 陣列的維度，這是一個整數元組，指示每個維度中陣列的大小，對于具有n行和m列的矩陣，shape將為(n,m)，因此，shape元組的長度就是軸數，ndim

• ndarray.size

? 陣列元素的總數，這等于shape元素的乘積

• ndarray.dtype

? 一個物件，描述陣列中元素的型別，可以使用標準Python型別創建或指定dtype，另外，NumPy提供了自己的型別，numpy.int32，numpy.int16和numpy.float64是一些示例，

• ndarray.itemsize

? 陣列中每個元素的大小（以位元組為單位），例如，型別為float64元素的陣列具有itemsize 8（= 64/8），而其中型別為complex32中的元素具有itemsize 4（= 32/8），等同于ndarray.dtype.itemsize，

• ndarray.data

? 包含陣列實際元素的緩沖區，通常，我們不需要使用此屬性，因為我們將使用索引工具訪問陣列中的元素，

舉個栗子

import numpy as np
a = np.arange(15).reshape(3,5)
a

---

陣列創建

• 使用array函式

import numpy as np
a = np.array([2,3,4])
a
a.dtype

• 常見的出錯在于，錯誤的使用多個引數呼叫陣列，而不是使用單個序列作為引數，例如：

a = np.array(1,2,3,4)       #錯誤的

a = np.array([1,2,3,4])		#正確的

• array將[序列,序列]轉換為二維陣列，將[序列,序列,序列]轉換為三維陣列，以此類推…

b = np.array([(1,2,3),(4,5,6)])		#這是一個二維陣列
b

• 陣列型別可以在創建時明確的指出

c = np.array([1,2],[3,4],dtype=complex)		#指定陣列的型別為complex
c

• Numpy的一些內置函式

#zeros()    將指定維度的陣列全部置0，默認資料型別為float64,可以設定引數改變型別
a = np.zeros((3,4))
print(a)
print(a.dtype)

#ones()     將指定維度的陣列全部置1，默認資料型別為float64,可以設定引數改變型別
b = np.ones((2,3,4),dtype = np.int16)
print(b)
print(b.dtype)

#empty()     將指定維度的陣列初始化為沒有特定意義的隨機值（內容是隨機的并取決于記憶體狀態的陣列），默認資料型別為float64,可以設定引數改變型別

c = np.empty((2,3))
print(c)
print(c.dtype)

• 更多內置函式

array， zeros， zeros_like， ones， ones_like， empty， empty_like， arange， linspace， numpy.random.Generator.rand， numpy.random.Generator.randn， fromfunction， fromfile

---

輸出陣列

• 簡單介紹下輸出陣列時的規則：

  • 最后一個軸從左到右列印，
  • 倒數第二個從上到下列印，
  • 其余的也從上到下列印，每個切片之間用空行隔開，

• 如果陣列太大無法列印，那么Numpy會自動跳過陣列的中心部分，僅輸出邊角點

print(np.arange(10000))

print(np.arange(10000).reshape(100,100))

• 要禁用此行為并強制NumPy列印整個陣列，可以使用更改列印選項set_printoptions，

import sys
np.set_printoptions(threshold=sys.maxsize)       # 需要匯入sys庫
print(np.arange(10000).reshape(100,100))

---

基本運算

---

算術運算同樣也適用于陣列運算

import numpy as np
a = np.array([20,30,40,50])

b = np.arange(4)
b

c = a - b
c

10*np.sin(a)

a<35

---

與許多矩陣語言不同，乘積運算子*在NumPy中是按元素及進行操作，

在NumPy中可以使用@運算子（Python版本>=3.5）或用dot函式執行矩陣乘積

A = np.array([[1,1],[0,1]])

B = np.array([[2,0],[3,4]])

A*B

A@B

A.dot(B)

---

某些操作（如+=和*=）,是修改現有陣列，而不是創建一個新陣列

rg = np.random.default_rng(1)     # 創建默認的亂數生成的示例
a = np.ones((2,3), dtype=int)     # Int型別的全1向量
b = rg.random((2,3))              #  默認為浮點數
a *= 3
a

b += a
b

a += b        #浮點型別陣列b不會自動轉換為整型

當使用不同型別的陣列進行操作時，結果陣列的型別對應于更通用或更精確的陣列（一種稱為向上轉換的行為），

類似于上述案例中int型別陣列a可以向上轉型為float型別

而float型別的陣列b卻不能轉型為陣列int型別a

---

許多一元運算（例如求和）都作為ndarray該類的方法實作

a = rg.random((2,3))
a

a.sum()

a.min()

a.max()

---

默認情況下，這些操作適用于陣列，就好像它是數字串列一樣，而不管其形狀如何，但是，通過指定axis 引數，您可以沿陣列的指定軸應用操作(通常axis=0表示指定列，axis=1指定行)

b = np.arange(12).reshape(3,4)
b

b.sum(axis=0)      #求每一列的和

b.min(axis=1)      #求每一行的最小值

b.cumsum(axis=1)      #每一行的累積和

---

通用函式

? NumPy提供了熟悉的數學函式，例如sin，cos和exp，在NumPy中，這些被稱為“通用函式”（ufunc），在NumPy中，這些函式在陣列上逐個元素操作，生成陣列作為輸出，

B = np.arange(3)
B

np.exp(B)

np.sqrt(B)

C = np.array([2.,-1.,4.])
np.add(B,C)

更多函式

all， any， apply_along_axis， argmax， argmin， argsort， average， bincount， ceil， clip， conj， corrcoef， cov， cross， cumprod， cumsum， diff， dot， floor， inner， invert， 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

#切片
a[2:5]      #區間為[2,5)  ,  左閉右開

#切片
#array[pos1:pos2:step] = val  指從pos1到pos2-1，沒隔兩個元素設定為val
#例如：
#  a
# array([  0,   1,   8,  27,  64, 125, 216, 343, 512, 729], dtype=int32)
a[:6:2] = 1000              #相當于a[0:6:2]    區間[0,6)     左閉右開
a

a[::-1]         #逆轉陣列

#遍歷迭代
for i in a:
    print(i**2)

多維陣列每個軸可以有一個索引，這些索引以元組給出，并用逗號分割

def f(x,y):
    return 10*x+y
b = np.fromfunction(f,(5,4),dtype=int)     #呼叫f函式，生成5行4列的陣列，引數是陣列的下標，型別為Int
b

b[2,3]

b[0:5,1]        #每行的下標為1的值

b[:,1]          #等效與上面這個案例

b[1:3,:]        #輸出第2行和第三行的每一列

如果提供的索引數少于軸數，則丟失的索引數將視為完整切片:

b[-1]            #未指明列的分片情況，則視為每一列，等效于b[-1,:]

括號中的運算式b[i]被視為i 后跟:表示所需數量的剩余軸實體，

NumPy還允許您使用點寫為 b[i,…]，

點（…)表示為許多冒號，根據需要，以產生一個完整的索引元組，

例如，如果x是具有5個軸的陣列，則

• x[1,2,…]等于x[1,2,:,:,:]，
• x[…,3]到x[:,:,:,:,3]和
• x[4,…,5,:]到x[4,:,:,5,:]，

c = np.array( [[[  0,  1,  2],               # 三維陣列
                [ 10, 12, 13]],
                [[100,101,102],
                 [110,112,113]]])
c.shape

c[1,...]      

c[...,2]

迭代過多維陣列相對于第一軸線完成

# b
# array([[ 0,  1,  2,  3],
#        [10, 11, 12, 13],
#        [20, 21, 22, 23],
#        [30, 31, 32, 33],
#        [40, 41, 42, 43]])
for row in b:
    print(row)

但是，如果要對陣列中的每個元素執行操作，則可以使用flat屬性，該屬性是 陣列中所有元素的 迭代器：

for element in b.flat:
    print(element)

---

操縱形狀

改變陣列的形狀

陣列的形狀是由沿每個軸的元素數確定

a = np.floor(10*rg.random((3,4)))       #np.floor 是將浮點數向下取整
print(a)
print(a.shape,a.dtype)

陣列的形狀可以使用各種命令來更改，

請注意，以下三個命令均回傳修改后的陣列，但不更改原始陣列：

a.ravel()			#回傳一個一維陣列

a.reshape(6,2)        #改變陣列a為6行2列

a.T     #a的轉置

ndarray.resize方法修改了陣列本身：

#a修改前：
#array([[9., 7., 5., 2.],
#       [1., 9., 5., 1.],
#       [6., 7., 6., 9.]])
a.resize((2,6))
a
#a修改后：

如果在改變形狀時將維度改為-1，則會自動計算其他尺寸：

a.reshape(3,-1)      #指定轉換為3行，系統自動計算列數

更多函式：

ndarray.shape， reshape， resize， ravel

---

堆疊在一起的不同陣列

幾個陣列可以沿不同的軸堆疊在一起：

a = np.floor(10*rg.random((2,2)))
print('a=','\n',a)
b = np.floor(10*rg.random((2,2)))
print('b=','\n',b)

np.vstack((a,b))

np.hstack((a,b))

函式column_stack將1維陣列作為列向量堆疊成2維陣列

只有當作用與2維陣列時是與hstack是等效的

from numpy import newaxis
np.column_stack((a,b))			#結果等效于上個案例中np.hstack((a,b))

a = np.array([4.,2.])
b = np.array([3.,8.])
print(np.column_stack((a,b)),'\n')
print(np.hstack((a,b)))               #兩并不相同

a[:,newaxis]         #將a視為一個二維陣列，newaxis字面意思就是新的軸

c = np.array([[1,2],[3,4]])
c[:,:,newaxis]

np.column_stack((a[:,newaxis],b[:,newaxis]))

np.hstack((a[:,newaxis],b[:,newaxis]))

另外，無論輸入陣列是怎樣的，函式row_stack都等效于函式vstack，

實際上，row_stack別名是vstack

print(np.column_stack is np.hstack)
print(np.row_stack is np.vstack)

通常，對于二維以上（不包括二維）的陣列，hstack沿著他們的第二個軸堆疊，vstack沿著他們的第一個軸堆疊

a = np.array([[[1,2],[3,4]],[[5,6],[7,8]]])
b = np.array([[[9,10],[11,12]],[[13,14],[15,16]]])
print(a.shape)
print(np.hstack((a,b)).shape)
np.hstack((a,b))

a = np.array([[[1,2],[3,4]],[[5,6],[7,8]]])
b = np.array([[[9,10],[11,12]],[[13,14],[15,16]]])
print(a.shape)
print(np.vstack((a,b)).shape)
np.vstack((a,b))

注意
在復雜情況下，r_ 和 c_ 杜宇通過一個軸將數字疊加創建陣列時很有用，

他們允許使用（“:”）

np.r_[1:9,1,2,3]

np.c_[np.array([1,2,3]), np.array([4,5,6])]

? 當使用陣列作為引數時，r_和c_在默認行為上類似于vstack和hstack，但是允許一個可選引數給出要連接的軸的編號，

More Information

hstack, vstack, column_stack, concatenate, c_, r_

---

將一個陣列拆分為幾個較小的陣列

使用hsplit，您可以沿陣列的水平軸拆分陣列

方法是指定要回傳的形狀相同的陣列的數量，或者指定要在其后進行劃分的列

a = np.floor(10*rg.random((2,12)))
a

np.hsplit(a,3)        #一分為三

np.hsplit(a,(3,4))      #分別在第三列和第四列后分離

vsplit沿著垂直的軸拆分分

并且array_split循序指定沿著哪個軸拆分

---

副本和視圖

? 副本是一個資料的完整的拷貝，如果我們對副本進行修改，它不會影響到原始資料，物理記憶體不在同一位置，

? 視圖是資料的一個別稱或參考，通過該別稱或參考亦便可訪問、操作原有資料，但原有資料不會產生拷貝，如果我們對視圖進行修改，它會影響到原始資料，物理記憶體在同一位置，

在操作陣列時，有時會將其資料復制到新陣列中，有時不復制，

對于初學者來說，這通常會引起混亂，

有以下三種情況:無復制、視圖或淺復制、副本或深復制

無復制

簡單分配不會復制物件或其資料

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

b = a        #沒有創建新的物件
b is a       #簡單理解為a,b都指向了同一片區域，a、b只是ndarray物件的兩個不同名字而已

Python將可變物件作為參考傳遞，因此函式呼叫不會復制，

def f(x):
    print(id(x))
id(a)               #id是一個物件的唯一的識別符號

f(a)

---

視圖或淺復制

不同的陣列物件可以共享相同的資料，view方法創建一個具有相同資料的新陣列物件，

# a
# a = np.array([[ 0,  1,  2,  3],
#               [ 4,  5,  6,  7],
#               [ 8,  9, 10, 11]])
c = a.view()
c

c is a

c.base is a       #c與a具有相同的視圖

c = c.reshape((2,6))
a.shape                      #修改c的形狀并不能改變a

c[0,4] = 1024
a                   #修改c中的某個值可以修改a   

s = a[ : ,1:3]      
s[:] = 10         #s[:]是s物件的view,s與s[:]有區別，請注意
a

---

副本或深復制

copy方法對陣列及其資料進行完整復制

d = a.copy()            #相當于新建了一個帶有新資料的新陣列
print(d is a)
print(d.base is a)      # d與a不共享任何事情 
d[0,0]=99999
print(a)

如果不再需要原始陣列，有時應該在切片后呼叫復制，

例如，假設a是一個巨大的中間結果，最終結果b只包含a的一小部分，那么在使用切片構造b時需要做一個深度復制:

a = np.arange(int(1e8))
b = a[:100].copy()
del a  # a的記憶體可以被釋放

如果使用b = a[:100]，則a被b參考，即使del a被執行，a也會存在記憶體中，

函式和方法概述

• 陣列創建

  arange， array， copy， empty， empty_like， eye， fromfile， fromfunction， identity， linspace， logspace， mgrid， ogrid， ones， ones_like， r_， zeros， zeros_like

• 轉換

  ndarray.astype， atleast_1d， atleast_2d， atleast_3d， mat

• 操作方式

  array_split， column_stack， concatenate， diagonal， dsplit， dstack， hsplit， hstack， ndarray.item， newaxis， ravel， repeat， reshape， resize， squeeze， swapaxes， take， transpose， vsplit， vstack

• 問題

  all， any， nonzero， where

• 組合排列排序

  argmax， argmin， argsort， max， min， ptp， searchsorted， sort

• 運作方式

  choose， compress， cumprod， cumsum， inner， ndarray.fill， imag， prod， put， putmask， real， sum

• 基本統計

  cov， mean， std， var

• 基本線性代數

  cross， dot， outer， linalg.svd， vdot

---

不太基礎

廣播規則

廣播允許通用函式以一種有意義的方式處理不具有完全相同形狀的輸入，

廣播的第一個規則是，如果所有輸入陣列的維數不相同，則會在較小陣列的形狀前面重復加上一個“1”，直到所有陣列的維數相同，

廣播的第二個規則確保沿某一特定維度大小為1的陣串列現得好像它們具有沿該維度形狀最大的陣列的大小，假設“廣播”陣列的陣列元素沿該維度的值相同，

在應用廣播規則后，所有陣列的大小必須匹配，更多詳情請參閱廣播，

---

高級索引和索引技巧

NumPy提供了比常規Python序列更多的索引功能，

如前所述，除了通過整數和切片建立索引之外，還可以通過整數陣列和布林值陣列對陣列進行索引，

用索引陣列建立索引

a = np.arange(12)**2        
i = np.array([1,1,3,8,5])      #下標陣列
a[i]

j = np.array([[3,4],[7,9]])		#二維索引
a[j]

當索引陣列a是多維的時，一個索引陣列指的是a的第一個維，

下面的示例通過使用調色板將標簽影像轉換為彩色影像來顯示這種行為，

 palette = np.array([[0, 0, 0],         # black
                     [255, 0, 0],       # red
                     [0, 255, 0],       # green
                     [0, 0, 255],       # blue
                     [255, 255, 255]])  # white
 image = np.array([[0, 1, 2, 0],        # 每一個值都對應著palette中的一個顏色
                   [0, 3, 4, 0]])       
# 例如:0-black,1-red,2-green,3-blue,4-white
#image中的第一行[0, 1, 2,0],對應著palette中的四行
#        [  0,   0,   0],
#        [255,   0,   0],
#        [  0, 255,   0],
#        [  0,   0,   0]
 palette[image]

我們還可以為多個維度提供索引，每個維度的索引陣列必須具有相同的形狀，

a = np.arange(12).reshape(3,4)
a

i = np.array([[0,1],[1,2]])          #對應a陣列的橫下標
j = np.array([[2,1],[3,3]])          #對應a陣列的縱下標
a[i,j]                               #i,j必須要有相同的形狀，因為要一一對應
#對應結果a[0,2] = 2,a[1,1]=5......

#2根據廣播規則擴展為
#[2,2]
#[2,2]
a[i,2]

# :相當于
#[[0,0],[0,0]]
#[[1,1],[1,1]]
#[[2,2],[2,2]]
# j 根據廣播規則擴展為
#[[2,1],[3,3]]
#[[2,1],[3,3]]
#[[2,1],[3,3]]
a[:,j]

您還可以將索引與陣列一起用作分配給以下物件的目標：

a = np.arange(5)
print(a)
a[[1,3,4]]=0
print(a)

但是，當索引串列包含重復項時，分配將完成幾次，而留下最后一個值：

a = np.arange(5)
a[[0,0,2]]=[1,2,3]    #執行兩次對a[0]的賦值，最后一次a[0]=2
a

---

用布爾陣列建立索引

當我們使用（整數）索引陣列對陣列進行索引時，我們將提供要選擇的索引串列，對于布爾索引，方法是不同的，

我們顯式選擇陣列中需要哪些項，不需要哪些項，

對于布爾索引，可以想到的最自然的方法是使用形狀與原始陣列相同的布爾陣列：

a = np.arange(12).reshape(3,4)
b = a>4
b

a[b]     #回傳的是一維陣列

這個屬性在分配時也同樣有用

a[b] = 0        所有大于4的都置為0
a

您可以看下面的示例，看看如何使用布爾索引來生成Mandelbrot集的影像：

import numpy as np
import matplotlib.pyplot as plt
def mandelbrot( h,w, maxit=20 ):
    """回傳大小(h,w)的曼德爾布羅特分形影像"""
    y,x = np.ogrid[ -1.4:1.4:h*1j, -2:0.8:w*1j ]   #橫縱坐標,ogrid函式：取[-1.4,1.4),個數為h*1j
    #print(x.shape)   (1,400)
    #print(y.shape)   (400,1)
    c = x+y*1j
    z = c
    #print(c.shape)    (400,400)   c[i,j]=x[i,j]+y[i,j]
    divtime = maxit + np.zeros(z.shape, dtype=int)
    for i in range(maxit):
        z = z**2 + c
        diverge = z*np.conj(z) > 2**2            # 誰是發散的,（conj函式用于回傳復數的共軛值）
        div_now = diverge & (divtime==maxit)  # 誰現在發散,（div_now是一個(400,400)的布林值）
        #print(i,div_now)
        divtime[div_now] = i                  # note when
        z[diverge] = 2                        # 避免分散過多
    
    return divtime
plt.imshow(mandelbrot(400,400))

使用布林值建立索引的第二種方式與整數索引更相似；

對于陣列的每個維度，我們提供一個一維布爾陣列來選擇所需的切片：

a = np.arange(12).reshape(3,4)
print(a)
b1 = np.array([False,True,True])
b2 = np.array([True,False,True,False])
a[b1,:]

a[:,b2]

a[b1,b2]         #好奇怪，不大懂，候補

注意，一維布爾陣列的長度必須與要切片的維度(或軸)的長度一致，在前面的示例中，b1的長度為3 (a中的行數)，而b2(長度為4)適合于索引a的第二個軸(列)，

---

ix_()函式

ix_函式可用于組合不同的向量，得出多個向量的笛卡爾積的映射關系，

例如，如果你想計算所有的a+b*c:

a = np.array([2,3,4,5])
b = np.array([8,5,4])
c = np.array([5,4,6,8,3])
ax,bx,cx = np.ix_(a,b,c)
print(ax,ax.shape,'\n')
print(bx,bx.shape,'\n')
print(cx,cx.shape,'\n')

result = ax+bx*cx
print(result.shape)
result

print(result[3,2,4])
print(a[3]+b[2]*c[4])

另一種方式

與普通的ufunc.reduce相比，這種reduce的優點在于它利用了廣播規則 ，以避免創建一個引數陣列，該引數陣列的大小乘 以輸出的數量乘以向量的數量，

def ufunc_reduce(ufct, *vectors):
    vs = np.ix_(*vectors)
    r = ufct.identity
    for v in vs:
        r = ufct(r,v)
    return r
ufunc_reduce(np.add,a,b,c)

---

用字串索引

結構化陣列是ndarray，其資料型別是由一些更簡單的資料型別組成的，這些簡單資料型別被組織為一系列命名欄位

x = np.array([('Rex', 9, 81.0), ('Fido', 3, 27.0)],
              dtype=[('name', 'U10'), ('age', 'i4'), ('weight', 'f4')])
x

更多請參閱結構化陣列

---

線性代數

簡單的陣列操作

有關更多資訊，請參見numpy檔案夾中的linalg.py

import numpy as np
a = np.array([[1.0,2.0],[3.0,4.0]])

a.transpose()         #轉置

np.linalg.inv(a)      #矩陣求逆

np.linalg.det(a)      #求行列式

u = np.eye(2)    #單位矩陣
u

j = np.array([[0.0, -1.0], [1.0, 0.0]])
j@j               #矩陣相乘

np.trace(u)    #矩陣的跡
#在線性代數中，一個n×n矩陣A的主對角線（從左上方至右下方的對角線）上各個元素的總和被稱為矩陣A的跡（或跡數），一般記作tr(A)，

y = np.array([[5.],[7,]])
np.linalg.solve(a,y)      # 呼叫solve函式求解線性方程
solve函式有兩個引數a和b，a是一個N*N的二維陣列，而b是一個長度為N的一維陣列，solve函式找到一個長度為N的一維陣列x，使得a和x的矩陣乘積正好等于b，陣列x就是多元一次方程組的解

np.linalg.eig(j)       #計算一個方陣的特征值和右特征向量，
#numpy.linalg.eig(a)[source]
#引數：
#a(…，M, M)陣列
#為其計算特征值和正確特征向量的矩陣
#回傳值
#w(…,M)陣列
#特征值，每個根據它的多重性重復，特征值不一定是有序的，得到的陣列將是復雜型別，除非虛部為零，在這種情況下，它將被轉換為實型別，當a為實時，所得到的特征值將為實(0虛部)或以共軛對出現

#v(…，M, M)陣列
#歸一化(單位“length”)特征向量，使列v[:，i]為特征值w[i]對應的特征向量，

---

技巧與竅門

”自動“重塑

a = np.arange(30)
b = a.reshape((2,-1,3))   #-1指“Whatever is needed”
print(b,'\n',b.shape)

---

向量堆疊

我們如何根據一組等大小的行向量構造一個二維陣列?

在MATLAB中這很簡單:如果x和y是相同長度的兩個向量，你只需要做m=[x;y]，

在NumPy中，它通過函式column_stack、dstack、hstack和vstack來作業，這取決于要進行堆疊的維度，例如:

x = np.arange(0,10,2)
y = np.arange(5)
m = np.vstack([x,y])
print(m)
n = np.hstack([x,y])
print(n)

---

直方圖

應用于陣列的 NumPy histogram函式回傳一對向量:陣列的直方圖和bin edges的向量，

注意:matplotlib還有一個用于構建直方圖的函式(在Matlab中稱為hist)，它與NumPy中的函式不同，

主要的區別是pylab.hist自動繪制直方圖，而numpy.histogram只生成資料，

import numpy as np
rg = np.random.default_rng(1)       #設定隨機種子
import matplotlib.pyplot as plt
#正態分布
mu,sigma = 2,0.5     #引數
v = rg.normal(mu,sigma,10000)#滿足正態分布的10000個數
plt.hist(v,bins=50,density=1)   #bins：直方圖的寬度，density:密度
(n,bins)=np.histogram(v,bins=50,density=True)
plt.plot(.5*(bins[1:]+bins[:-1]),n)

---

如果發現問題或有疑問，歡迎下方留言
最新文章請關注個人博客

---

覺得還行的，點個贊和關注支持鼓勵