Numpy數組（數組的屬性，索引和切片，數組的變形）

Numpy簡述

Numpy是Python中科學計算的基礎包，它是一個Python庫，提供多維數組對象，各種派生對象（如：掩碼數組和矩陣），同時提供對數組/數據的各種操作。

Numpy的數據類型：

名稱	描述
bool_	布爾型數據類型（True 或者 False）
int_	默認的整數類型（類似於 C 語言中的 long，int32 或 int64）
intc	與 C 的 int 類型一樣，一般是 int32 或 int 64
intp	用於索引的整數類型（類似於 C 的 ssize_t，一般情況下仍然是 int32 或 int64）
int8	字節（-128 to 127）
int16	整數（-32768 to 32767）
int32	整數（-2147483648 to 2147483647）
int64	整數（-9223372036854775808 to 9223372036854775807）
uint8	無符號整數（0 to 255）
uint16	無符號整數（0 to 65535）
uint32	無符號整數（0 to 4294967295）
uint64	無符號整數（0 to 18446744073709551615）
float_	float64 類型的簡寫
float16	半精度浮點數，包括：1 個符號位，5 個指數位，10 個尾數位
float32	單精度浮點數，包括：1 個符號位，8 個指數位，23 個尾數位
float64	雙精度浮點數，包括：1 個符號位，11 個指數位，52 個尾數位
complex_	complex128 類型的簡寫，即 128 位複數
complex64	複數，表示雙 32 位浮點數（實數部分和虛數部分）
complex128	複數，表示雙 64 位浮點數（實數部分和虛數部分）

注意：每個內建類型都有一個唯一定義它的字符代碼，如下：

字符	對應類型
b	布爾類型
i	(有符號) 整型
u	無符號整型 integer
f	浮點型
c	複數浮點型
m	timedelta（時間間隔）
M	datetime（日期時間）
O	(Python) 對象
S, a	(byte-)字符串
U	Unicode
V	原始數據 (void)

注：字節順序是通過對數據類型預先設定"<“或”>“來決定的。”<“意味着小端法(最小值存儲在最小的地址，即低位組放在最前面)。”>"意味着大端法(最重要的字節存儲在最小的地址，即高位組放在最前面)。

數組的屬性

1.維度（ndim）

2.形狀（shape）：可以理解成數組各個維度的長度

3.長度（size）：數組存儲元素的總個數

4.數據類型（dtype）：數組的數據類型（數組要求數據必須同一類型）

5.itemsize：每個元素的字節長度

6.nbytes：nbytes=itemsize*size（可以理解爲整個數組佔多大內存）

import numpy as np
a1 = np.random.randint(100,size=10)      #創建一個一維數組
a2 = np.random.randint(100,size=(4,6))   #創建一個4行6列的數組
a3 = np.random.randint(100,size=(2,5,6)) #創建一個三維數組，維度分別是2，5，6
for a in [a1,a2,a3]:
    print("dtype={},ndim={},shape={},size={},itemsize={},nbytes={}".format(a.dtype,a.ndim,a.shape,a.size,a.itemset,a.nbytes))

運行結果：

dtype=int32,ndim=1,shape=(10,),size=10,itemsize=4,nbytes=40
dtype=int32,ndim=2,shape=(4, 6),size=24,itemsize=4,nbytes=96
dtype=int32,ndim=3,shape=(2, 5, 6),size=60,itemsize=4,nbytes=240

輸出結果可以反映數組的信息對照上面的數組的屬性很容易就理解了。

特殊數組的創建

import numpy as np
a = np.empty(3)
print("Empty array:\n ",a)

b = np.zeros([2,3])       #創建多位數組需要將維度填寫在“[]”內部
print("Zeros array:\n",b)

c = np.ones([2,3,4])
print("Ones array:\n",c)

運行結果：

Empty array:
  [2.88995698e+204 2.00416324e-312 3.51086921e+151]
Zeros array:
 [[0. 0. 0.]
 [0. 0. 0.]]
Ones array:
 [[[1. 1. 1. 1.]
  [1. 1. 1. 1.]
  [1. 1. 1. 1.]]

數組的索引和切片

import numpy as np

a = np.random.randint(100,size=10) #創建一個隨機整形數組，大小是10.
print(a)

#numpy數組的索引和list類似
print("a[1]=",a[1])
print("a[-1]=",a[-1])

運行結果：

[68 90 46  9 10 71 47 19 54 57]
a[1]= 90
a[-1]= 57

注意：數組從頭開始第一個的下角標是“0”，而從末尾開始第一個的下角標是“-1”

import numpy as np

a = np.random.randint(100,size=(3,5))

print("a=",a)
print("a[1] = ",a[1])         #輸出下角標位1的行
print("a[1:]=",a[1,:])         #這裏是切片，選出下角標爲1的行從第一個元素到最後一個，和list一樣
print("a[-2]=",a[-2])         #輸出倒數第二行數組
print("a[:2]=",a[:,2])         #輸出下角標位2的一列元素
print("a[2][2]=",a[2][2])     #輸出角標是（2，2）的元素
print("a[-2][-2]=",a[-2][-2]) #輸出角標是倒數第二行倒數第二列的元素

運行結果：

a= [[66  3 17  7 48]
 [30 66 22 62 18]
 [65  9 14 55 84]]
a[1] =  [30 66 22 62 18]
a[1:]= [30 66 22 62 18]
a[-2]= [30 66 22 62 18]
a[:2]= [17 22 14]
a[2][2]= 14
a[-2][-2]= 62

注：切片的基本用法—x[開始:結束:步長]，三個參數決定切片的結果，有些可以省略，如步長如果是“1”便可以不寫

import numpy as np

a = np.arange(1,10)

print("a = ",a)
print("a[3：7]=",a[3,7])        #取得下角標是（3，7）的元素
print("a[1::2]=",a[1::2])      #取得從下角標爲1的元素開始到最後，步長爲2（步長就是間隔幾個取一次）
print("a[:5]=",a[:5])          #取得前五個元素
print("a[5:]=",a[5:])          #取得從第五個到最後的元素
print("a[:-6:-1]=",a[:-6:-1])  #從最後一個開始取到倒數第六個步長是1

運行結果：

a =  [1 2 3 4 5 6 7 8 9]
a[3,7]= [4 5 6 7]
a[1::2]= [2 4 6 8]
a[:5]= [1 2 3 4 5]
a[5:]= [6 7 8 9]
a[:-6:-1]= [9 8 7 6 5]

import numpy as np

a = np.random.randint(10,size=(5,5))

print("a = ","\n",a)
print("a[1:4,1:4]=",a[1:4,1:4])                  #截取多位數組的一段，
print("a[1:4:-1,1:4:-1]=",a[1:5:-1,1:5:-1])      #setp參數可以是負數但是標識逆序。
print("a[::-1,::-1]=\n",a[::-1,::-1])

運行結果：

a =
 [[7 8 0 8 1]
 [6 0 0 9 4]
 [1 8 5 4 0]
 [8 7 7 9 1]
 [9 2 9 0 7]]
a[1:4,1:4]= [[0 0 9]
 [8 5 4]
 [7 7 9]]
a[1:4:-1,1:4:-1]= []
a[::-1,::-1]=
 [[7 0 9 2 9]
 [1 9 7 7 8]
 [0 4 5 8 1]
 [4 9 0 0 6]
 [1 8 0 8 7]]

import numpy as np

a = np.random.randint(10,size=(3,5))

print("a=\n",a)
print("a[1,:]=",a[1,:])         #取得第二行
print("a[::-1,1]=",a[::-1,1])   #取得倒序第二列
print("a[0]=",a[0])             #空的切片可以省略，例如：a[0，：]

運行結果：

a=
 [[8 8 9 8 1]
 [8 7 8 3 6]
 [8 4 4 4 7]]
a[1,:]= [8 7 8 3 6]
a[::-1,1]= [4 7 8]
a[0]= [8 8 9 8 1]

注意：數組切片和list不同，數組切片的結果是源數據的視圖而不是副本。如果又不瞭解的可以去下面的鏈接瞭解一下。

https://www.jianshu.com/p/913a332e4dfc

數組的變形

1.數組的變形可以通過reshape來進行操作，前提是必須前後長度一致

2.也可以通過newaxis關鍵字來完成（newaxis是一個NoneType的內容，其實就是None）

import numpy as np

a = np.arange(1,10).reshape((3,3))

print("a=\n",a)
print("a.shape=",a.shape) #查看數組維度

運行結果：

a=
 [[1 2 3]
 [4 5 6]
 [7 8 9]]
a.shape= (3, 3)

import numpy as np

a1 = np.arange(10)
print("a1=",a1)
print("a1.shape=",a1.shape)

a2 = a1[np.newaxis,:]        #使a2獲得一個行向量
print("a2=",a1)
print("a2.shape=",a2.shape)

a3 = a1[:,np.newaxis]        #使a3獲得一個列向量
print("a3=",a3)
print("a3.shape=",a3.shape)

運行結果：

a1= [0 1 2 3 4 5 6 7 8 9]
a1.shape= (10,)
a2= [0 1 2 3 4 5 6 7 8 9]
a2.shape= (1, 10)
a3= [[0]
 [1]
 [2]
 [3]
 [4]
 [5]
 [6]
 [7]
 [8]
 [9]]
a3.shape= (10, 1)

注意：這裏newaxis只是單純的增加一個維度。