Python語法學習記錄（17）：python numpy的基本操作

0、NumPy 與 ndarry

NumPy 是 Python 科學計算的基礎包，它專爲進行嚴格的數字處理而產生。

它提供：

• 快速高效的多維數組對象 ndarray；
• 直接對數組執行數學運算及對數組執行元素級計算的函數；
• 線性代數運算、隨機數生成;
• 將 C、C++、Fortran 代碼集成到 Python 的工具等。

它專爲進行嚴格的數字處理而產生。多爲很多大型金融公司使用，以及核心的科學計算組織如：Lawrence Livermore，NASA 用其處理一些本來使用 C++，Fortran 或Matlab 等所做的任務。

ndarray 是一個多維的數組對象，具有矢量算術運算能力和複雜的廣播能力，並具有執行速度快和節省空間的特點。

ndarray 的一個特點是同構：即其中所有元素的類型必須相同。

1、數組屬性查看：類型、尺寸、形狀、維度

import numpy as np  
a1 = np.array([1,2,3,4],dtype=np.complex128)  
print(a1)  
print("數據類型",type(a1))           #打印數組數據類型  
print("數組元素數據類型：",a1.dtype) #打印數組元素數據類型  
print("數組元素總數：",a1.size)      #打印數組尺寸，即數組元素總數  
print("數組形狀：",a1.shape)         #打印數組形狀  
print("數組的維度數目：",a1.ndim)      #打印數組的維度數目  

2、numpy元素中數據存儲方式，數據類型，類型轉換

2.1 查看元素數據存儲類型

dtype=。。。 可作爲參數輸入到之後的類型轉換新array建立函數中，作爲array初始化的參數選擇。

import numpy as np
#指定數據 dtype 
a = np.array([2,23,4],dtype=np.int)
print(a.dtype)
# int 64
a = np.array([2,23,4],dtype=np.int32)
print(a.dtype)
# int32
a = np.array([2,23,4],dtype=np.float)
print(a.dtype)
# float64
a = np.array([2,23,4],dtype=np.float32)
print(a.dtype)
# float32
a = np.array([1,2,3,4],dtype=np.complex128)  
print(a.dtype)
# complex128

2.2 元素數據存儲類型轉換

import numpy as np
# 通過 ndarray 的 astype() 方法進行強制類型轉換
# astype 會創建一份新的數組，即便是指定爲同類型也依然如此
# 浮點數轉換爲整數時小數部分會被捨棄：
a = np.array([2.5,3.1,4.9],dtype=np.float32)
b = a.astype(np.int64)
print(b.dtype)
print(b)
# 如果某字符串類型的數組裏的元素全是數字，也可以通過此方法直接轉換成數值類型
a = np.array(["2.5","3.1","4.9"],dtype=np.float32)
b = a.astype(np.float64)
print(b.dtype)
print(b)

3、List類型與numpy. ndarray類型的互相轉換

array函數接受一切序列類型的對象

import numpy as np
list1 = [1,2,3,4,5] 
#List轉numpy.array:
temp = np.array(list1) 
print(temp)
print("數據類型",type(temp))           #打印數組數據類型  
print("數組元素數據類型：",temp.dtype) #打印數組元素數據類型  
print("數組元素總數：",temp.size)      #打印數組尺寸，即數組元素總數  
print("數組形狀：",temp.shape)         #打印數組形狀  
#numpy.array轉List:
arr = temp.tolist() 
print(arr)
print("數據類型",type(arr))           #打印數組數據類型 

4、創建 ndarray 數組

4.1 方法一：列表轉換

import numpy as np
#創建數組
array = np.array([[1,2,3],[2,3,4]])  #列表轉化爲矩陣
print(array)
print('number of dim:',array.ndim)  # 維度
# number of dim: 2
print('shape :',array.shape)    # 行數和列數
# shape : (2, 3)
print('size:',array.size)   # 元素個數
# size: 6

4.2 zero，ones，empty函數創建特殊數組

zeros() 函數和 ones() 函數這兩個函數分別可以創建指定長度或形狀的全0或全1的 ndarray 數組

empty() 函數這個函數可以創建一個沒有任何具體值的 ndarray 數組，需要注意一點的是，這個函數返回的值不一定是 0，可能是其他未初始化的垃圾值。

import numpy as np
#創建全零數組
a = np.zeros((3,4)) # 數據全爲0，3行4列
print('a:',a)
b = np.zeros(a.shape) # 數據全爲0，3行4列
print('b:',b)
#創建全一數組, 同時也能指定這些特定數據的 dtype:
a = np.ones((3,4),dtype = np.int)   # 數據爲1，3行4列
print('a:',a)
b = np.ones(a.shape) # 數據全爲0，3行4列
print('b:',b)
#創建全空數組, 其實每個值都是接近於零的數:
a = np.empty((3,4)) # 數據爲empty，3行4列
print('a:',a)
b = np.empty(a.shape) # 數據全爲0，3行4列
print('b:',b)

4.3 arrange linspace 創建線性數組

import numpy as np
#用 arange 創建連續數組:
a = np.arange(10,20,2) # 10-19 的數據，2步長
print(a)
#使用 reshape 改變數據的形狀
a = np.arange(12).reshape((3,4))    # 3行4列，0到11
print(a)
#用 linspace 創建線段型數據:
a = np.linspace(1,10,20)    # 開始端1，結束端10，且分割成20個數據，生成線段
print(a)
#同樣也能進行 reshape 工作:
a = np.linspace(1,10,20).reshape((5,4)) # 更改shape
print(a)

5、矩陣的索引與打印

import numpy as np

#一維索引
A = np.arange(3,15)
print('A = ',A)
print('A[3] = ',A[3])    # 6

#二維
A = np.arange(3,15).reshape((3,4))
print('A = ',A)
print('A[2] = ',A[2])   
print('A[2][]2 = ',A[2][2])     
print('A[2,2] = ',A[2,2])  
print('A[1, 1:3] = ',A[1, 1:3])  

print('row = ')
for row in A:
    print(row)
print('column = ')
for column in A.T:
    print(column)

#flatten是一個展開性質的函數，將多維的矩陣進行展開成1行的數列。而flat是一個迭代器，本身是一個object屬性。
print('A.flatten = ',A.flatten())   
print('A.flat ===== 所有元素逐個打印')  
for item in A.flat:
    print(item)

6、矩陣的運算

6.1 基礎運算

import numpy as np
array1 = np.array([[1,2,3],[2,3,4]])  #列表轉化爲矩陣
array2 = np.array([[2,3,4],[3,4,5]])  #列表轉化爲矩陣
# 減法
array3 = array2 - array1
print(array3)
# 加法
array3 = array2 + array1
print(array3)
# 對應元素相乘
array3 = array2 * array1
print(array3)
# 對應元素乘係數
array4 = array1 * 2
print(array4)
# 對應元素次方
array4 = array1 ** 2
print(array4)
# 對應元素正弦
array4 = np.sin(array1)
print(array4)
# 比較符號
array5 = array1>2
print(array5)
# 判斷矩陣是否全部爲正確
print(array5.all())
# 判斷矩陣是否存在正確
print(array5.any())

6.2 點乘

import numpy as np
arr1=np.array([[1,1],[0,1]])
arr2=np.arange(4).reshape((2,2))# 形變
print(arr1)
print(arr2)
# 點乘運算
arr3 = np.dot(arr1,arr2)
print(arr3)

6.3 其他矩陣特徵運算

import numpy as np
A = np.arange(2,14).reshape((3,4)) 
print("A =",A)
print("sum =",np.sum(A,axis=1))
print("min =",np.min(A,axis=0))
print("max =",np.max(A,axis=1))
print("全矩陣mean =",np.average(A))    
print("不同維度mean =",np.average(A,axis=0))    
print("全矩陣mean =",np.mean(A))     
print("不同維度mean =",np.mean(A,axis=1))  
print("中位數 = ",np.median(A))       # 7.5中位數
# argmin() 和 argmax() 兩個函數分別對應着求矩陣中最小元素和最大元素的索引。
# 相應的，在矩陣的12個元素中，最小值即2，對應索引0，最大值爲13，對應索引爲11。 
print("最小值索引",np.argmin(A))    # 0
print("最大值索引",np.argmax(A))    # 11
print("累加矩陣 = ",np.cumsum(A))   #累加函數 （返回的是以爲數組） 生成的矩陣每一個元素均是從原矩陣首項累加到對應項的元素之和
print("累差矩陣 = ",np.diff(A))    #累差運算函數
x,y = np.nonzero(A)    #將所有非零元素的行與列座標分割開，重構成兩個分別關於行和列的矩陣
print("非零行座標 = ",x)
print("非零列座標 = ",y)

6.3 排序、轉置、數值裁剪

import numpy as np
A = np.arange(14,2, -1).reshape((3,4)) 
print("A = ",A)
print("A默認維度排序 = ",np.sort(A))    
print("A其他維度排序 = ",np.sort(A,axis = 0))    
print("A轉置 = ",np.transpose(A))   #轉置
print("A轉置 = ",A.T)#轉置
print("矩陣數值裁剪 = ",np.clip(A,5,9))    #後面的最小值最大值則用於讓函數判斷矩陣中元素是否有比最小值小的或者比最大值大的元素，並將這些指定的元素轉換爲最小值或者最大值。

7、拼接、增減維度、切片、形變重排

7.1 橫縱向的拼接

import numpy as np
A = np.array([1,1,1])
B = np.array([2,2,2])
# vertical stack上下合併
C = np.vstack((A,B))
print(C.shape)
print(C)
# horizontal stack左右合併
D = np.hstack((A,B))       
print(D.shape)
print(D)

A = np.array([[1,1,1],[1,1,1]])
B = np.array([[2,2,2],[2,2,2]])
C = np.concatenate((A,B,B,A),axis=0)
print("(A,B,B,A),axis=0 = ")
print(C)
D = np.concatenate((A,B,B,A),axis=1)
print("(A,B,B,A),axis=1 = ")
print(D)

7.2 矩陣添加或拼接新元素(append或concatenate)

import numpy as np
A = np.array([1,1,1])
B = np.concatenate((A,[100])) # 先將p_變成list形式進行拼接，注意輸入爲一個tuple
C = np.append(B,200) #直接向p_arr裏添加p_
#注意一定不要忘記用賦值覆蓋原p_arr不然不會變
print(B.shape)
print(B)
print(C.shape)
print(C)

7.3 新增維度

import numpy as np

#這樣改變維度的作用往往是將一維的數據轉變成一個矩陣，與代碼後面的權重矩陣進行相乘， 否則單單的數據是不能呢這樣相乘的哦。
A = np.array([1,1,1])
print(type(np.newaxis))
print(np.newaxis==None)#np.newaxis 在使用和功能上等價於 None
print("A:",A)
print("A.shape:",A.shape)
print("A[np.newaxis,:]:",A[np.newaxis,:])
print("A[np.newaxis,:].shape:",A[np.newaxis,:].shape)
print("A[:,np.newaxis]:",A[:,np.newaxis])
print("A[:,np.newaxis].shape:",A[:,np.newaxis].shape)
print("A[np.newaxis,:,np.newaxis].shape:",A[np.newaxis,:,np.newaxis].shape)
# (3,1)

7.4 增減數組維度

import numpy as np
# 假設a的shape爲[1000,128,128]
a = np.random.rand(1000,128,128)
print(a.shape)
# expand_dims爲增加內容爲空的維度
b=np.expand_dims(a,axis=0)
print(b.shape)
b=np.expand_dims(a,axis=1)
print(b.shape)
b=np.expand_dims(a,axis=2)
print(b.shape)
b=np.expand_dims(a,axis=3)
print(b.shape)
# squeeze爲刪除內容爲空的維度
c=np.squeeze(b)
print(c.shape)

7.5 矩陣的切片

import numpy as np
A = np.arange(12).reshape((3, 4))
print("A = ")
print(A)
B1,B2 = np.split(A, 2, axis=1)# 返回的是一個列表  裏面兩個元素分別爲切片後的array矩陣
print(np.split(A, 2, axis=1))
print("B1 = ",B1)
print("B2 = ",B2)
C1,C2,C3 = np.split(A, 3, axis=0)
print(np.split(A, 3, axis=0))
print("C1 = ",C1)
print("C2 = ",C2)
print("C3 = ",C3)

import numpy as np
A = np.arange(12).reshape((3, 4))
D1,D2,D3 = np.array_split(A, 3, axis=1)
print(np.array_split(A, 3, axis=1))
print(D1)
print(D2)
print(D3)
E1,E2,E3 = np.vsplit(A, 3) # 縱向切割
print(np.vsplit(A, 3))
print(E1)
print(E2)
print(E3)
F1,F2 = np.hsplit(A, 2) # 水平切割
print(np.hsplit(A, 2)) 
print(F1)
print(F2)

7.6 reshape，ravel，flatten，transpose，shape，resize更改數組形狀

import numpy as np

a = np.arange(24)
print('a = ',a)
b = a.reshape(2,3,4)
print('reshape = ',b)
# ravel函數 可以將多維數組展平（也就是變回一維）
c = b.ravel()
print('ravel = ',c)
# flatten函數  也是將多維數組展平，與ravel函數的功能相同，不過flatten函數會請求分配內存來保存結果，而ravel函數只是返回數組的一個視圖(view)
c = b.flatten()
print('flatten = ',c)
# 這種做法將直接改變所操作的數組
b.shape = (6,4)
print('重新設置形狀',b)
# transpose函數 將矩陣進行轉置
d = b.transpose()
print("轉置 = ",d)
# resize函數  和reshape函數的功能一樣，但resize會直接修改所操作的數組
# 並且這一步不可以通過賦值來實現，如下所示
b.resize((2,12))
print('resize重新設置形狀',b)

8、random

8.1 numpy.random.randint

numpy.random.randint(low, high=None, size=None, dtype='l')

作用：生成整型隨機數，可以是單個隨機數，也可以是多維的隨機數構成的數組
參數介紹

low：int 型，隨機數的下限

high：int 型，默認爲空，給隨機數設置個上限，即產生的隨機數必須小於high，當此值爲空時，函數生成[0,low)區間內的隨機數

size：int、或ints、或元組，指明生成的隨機數的類型

dtype:可選’int’ ,’int32’，默認爲’l’

np.random.randint(4)
>>1

np.random.randint(4,size=4)
>>array([2, 2, 2, 0])

np.random.randint(4,10,size=6)
>>array([7, 9, 7, 8, 6, 9])

np.random.randint(4,10,size=(2,2),dtype='int32')
>>
array([[7, 4],
       [6, 9]])

8.2 numpy.random.uniform

np.random.uniform(low=0.0, high=1.0, size=None)

作用：可以生成[low,high)中的隨機數，可以是單個值，也可以是一維數組，也可以是多維數組
參數介紹：
low :float型，或者是數組類型的，默認爲0
high:float型，或者是數組類型的，默認爲1
size:int型，或元組，默認爲空

import numpy as np
np.random.uniform()  # 默認爲0到1
>>0.827455693512018

np.random.uniform(1,5)
>>2.93533586182789

np.random.uniform(1,5,4)  #生成一維數組
>>array([ 3.18487512,  1.40233721,  3.17543152,  4.06933042])

np.random.uniform(1,5,(4,3)) #生成4x3的數組
>>array([[ 2.33083328,  1.592934  ,  2.38072   ],
       [ 1.07485686,  4.93224857,  1.42584919],
       [ 3.2667912 ,  4.57868281,  1.53218578],
       [ 4.17965117,  3.63912616,  2.83516143]])

np.random.uniform([1,5],[5,10])  
>>array([ 2.74315143,  9.4701426 ])

8.3 np.random.random_sample的用法

random_sample(size=None)

作用：返回[0,1)之間的浮點型隨機數，通過size控制返回的形狀

np.random.random_sample()
>>0.47108547995356098
type(np.random.random_sample())
>><type 'float'>
np.random.random_sample((5,))
>>array([ 0.30220482,  0.86820401,  0.1654503 ,  0.11659149,  0.54323428])

固定範圍和均值的隨機數組

Three-by-two array of random numbers from [-5, 0):

5 * np.random.random_sample((3, 2)) - 5
>>array([[-3.99149989, -0.52338984],
           [-2.99091858, -0.79479508],
           [-1.23204345, -1.75224494]])

8.4 np.random.rand的用法

rand(d0, d1, …, dn)

作用：返回[0,1)內的浮點數，輸入的d0,d1…dn代表維度信息，沒有輸入時，則返回[0,1)內的一個隨機值

np.random.rand()
>>0.9027797355532956

np.random.rand(3,3)
>>
array([[ 0.47507608,  0.64225621,  0.9926529 ],
       [ 0.95028412,  0.18413813,  0.91879723],
       [ 0.89995217,  0.42356103,  0.81312942]])

np.random.rand(3,3,3)
>>
array([[[ 0.30295904,  0.76346848,  0.33125168],
        [ 0.77845927,  0.75020602,  0.84670385],
        [ 0.2329741 ,  0.65962263,  0.93239286]],

       [[ 0.24575304,  0.9019242 ,  0.62390674],
        [ 0.43663215,  0.93187574,  0.75302239],
        [ 0.62658734,  0.01582182,  0.66478944]],
    
       [[ 0.22152418,  0.51664503,  0.41196781],
        [ 0.47723318,  0.19248885,  0.29699868],
        [ 0.11664651,  0.66718804,  0.39836448]]])

5、np.random.random_integers的用法

random_integers(low, high=None, size=None)

和randint的用法較爲相似,區別在於[low,high]
的右邊界能夠取到，且改函數即將被拋棄，可以使用
np.random.randint(low,high+1)進行代替

總結：

隨機數可以分爲兩大類

一類是浮點型的，常以np.random.uniform爲代表，np.random.rand,np.random.radnom和np.random.random_simple可以看作是np.random.uniform的特例；

另一類是整數型的，以np.random.randint爲代表，也有np.random.random_integers 但是後者將被前者取代

9、排序

numpy.sort() 函數返回輸入數組的排序副本。函數格式如下：

numpy.sort(a, axis, kind, order)

參數說明：

• a: 要排序的數組
• axis: 沿着它排序數組的軸，如果沒有數組會被展開，沿着最後的軸排序， axis=0 按列排序，axis=1 按行排序
• kind: 默認爲’quicksort’（快速排序）
• order: 如果數組包含字段，則是要排序的字段

import numpy as np
a = np.random.randint(0,100,(2,5))
b = np.sort(a,axis = 0)
c = np.sort(a,axis = 1)
d = np.sort(a,axis = 0)[::-1]
e = np.sort(a,axis = 1)[::-1]
print(a)
print(b)
print(c)
print(d)
print(e)

10、最值及其索引

python中找出numpy array數組的最值及其索引
在list列表中，max(list)可以得到list的最大值，list.index(max(list))可以得到最大值對應的索引

但在numpy中的array沒有index方法，取而代之的是where，其又是list沒有的

首先我們可以得到array在全局和每行每列的最大值(最小值同理)

a = np.arange(9).reshape((3,3))
print(a)
print(np.max(a))        #全局最大
print(np.max(a,axis=0)) #每列最大
print(np.max(a,axis=1)) #每行最大
# 然後用where得到最大值的索引，返回值中，前面的array對應行數，後者對應列數
print(np.where(a==np.max(a)))
print(np.where(a==np.max(a,axis=0)))
# 如果array中有相同的最大值，where會將其位置全部給出
a[1,0]=8
print(a)
print(np.where(a==np.max(a)))

11、比較矩陣

11.1 少量數據元素比較

直接使用“==”進行比較

import numpy as np
a = np.array([1,2,3])
b = np.array([1,2,1])
c = (a==b)
print(c)

11.2 數據元素較多的比較

查看輸出結果便變得很麻煩，這時我們可以使用all方法，直接比對a矩陣和b矩陣的所有對應的元素是否相等。

而any（）方法是查看兩矩陣是否有一個對應元素相等。事實上，all（）操作就是對兩個矩陣的比對結果再做一次與運算，而any則是做一次或運算

import numpy as np
a = np.array([1,2,3])
b = np.array([1,2,1])
c = (a==b).all()
# 不全都一樣所以輸出False
print(c)
a = np.array([1,2,3])
b = np.array([1,1,1])
# 有一個一樣所以輸出True
d = (a==b).any()
print(d)

12、指定每個元素保留小數點後多少位

numpy.around(a, decimals=0, out=None)

Evenly round to the given number of decimals.

a : array_likeInput data.

decimals : int, optionalNumber of decimal places to round to (default: 0). If decimals is negative, it specifies the number of positions to the left of the decimal point.

out : ndarray, optionalAlternative output array in which to place the result. It must have the same shape as the expected output, but the type of the output values will be cast if necessary. See doc.ufuncs (Section “Output arguments”) for details.

rounded_array : ndarrayAn array of the same type as a, containing the rounded values. Unless out was specified, a new array is created. A reference to the result is returned.The real and imaginary parts of complex numbers are rounded separately. The result of rounding a float is a float.

equivalent method

ceil, fix, floor, rint, trunc

Notes

For values exactly halfway between rounded decimal values, NumPy rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0, -0.5 and 0.5 round to 0.0, etc. Results may also be surprising due to the inexact representation of decimal fractions in the IEEE floating point standard [R9] and errors introduced when scaling by powers of ten.

Examples

    import numpy as np
    # 默認輸入的時候   演示out的使用
    b = np.zeros(2)
    a = np.around([0.37, 1.64],out = b)
    print(a)
    print(b)
    # 保留1位小數
    a = np.around([0.37, 1.64], decimals=1)
    print(a)
    a = np.around([.5, 1.5, 2.5, 3.5, 4.5])
    print(a)
    # 趨向於最近的整數
    a = np.around([1,2,3,11], decimals=1)
    print(a)
    a = np.around([1,2,3,11], decimals=-1)
    print(a)

12、數據保存與讀取

12.1 np.savetxt() np.loadtxt()

示例

import numpy as np 
l1=np.arange(5) 
l2,l3=l1*2,l1*3 
np.savetxt('001',(l1,l2,l3)) 
a=np.loadtxt('001') 
print(a)

關於如何保存路徑和保持格式

np.savetxt('xxxx/01.txt',a,fmt="%.18f,%.18f",delimiter="\n")

第一個參數可以指定保存的路徑以及文件。fmt="%.18f,%.18f"指定保存的文件格式，delimiter="\n"表示分隔符，這兩個一起生成的文件格式如下

import numpy as np 
a=np.arange(6) 
a = a.reshape(3,2)
np.savetxt('./01.txt',a,fmt="%.1f,%.1f",delimiter="\n")
a=np.loadtxt('./01.txt',delimiter=",") 
print(a)

loadtxt的詳細介紹

savetxt的詳細介紹

9、常用操作

9.1 元素平方和

np.sum(arrayname**2)

9.2 numpy轉換成tensorflow的tensor

import numpy as np
import tensorflow as tf
numpy_test = np.ones(5)
print(numpy_test)
print(numpy_test.shape)
tensor_test = tf.convert_to_tensor(numpy_test)
print(tensor_test)
print(tensor_test.shape)

LAST、未來得及添加的內容

numpy random 生成隨機矩陣

np.random.choice的用法

numpy：np.random.choice的用法

np.random.choice用法中文和樣例詳解

numpy.linspace使用詳解

Numpy 中clip函數的使用

np.max 與 np.maximum

Numpy中stack()，hstack()，vstack()函數詳解

【Python數據分析】Numpy的詳細教程

numpy&pandas莫煩

LASTLAST、編程過程中遇到的一些問題

1、numpy報錯：OSError: Failed to interpret file as a pickle

首先了解pickle的定義：

pickle: 用於python特有的類型和python的數據類型間進行轉換
pickle提供四個功能：dumps,dump,loads,load
pickle可以存儲所有python支持的原生類型（bool,int,float,string,byte,none等），由任何原生類型組成的列表、元組、字典和集合，函數、類、類的實例。
所以這個報錯本質就是數據文件不一致，numpy的loadtxt()和load()的區別

load()代表用Numpy專用的二進制格式保存數據，它們會自動處理元素類型和形狀等信息。一般load讀取的是.npy或者.npz的文件。
loadtxt()主要是用來讀取txt等文件的
以下是loadtxt()的一般用法，最普通的就是loadtxt(“文件名.txt”)

numpy.loadtxt(fname, dtype=, comments=’#’, delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0)
報錯原因是因爲用load()直接讀取txt文件導致讀取不到。改用loadtxt()即可。