一矢量

矢量是指一堆數造成的集合python

多維數組也叫作矢量化計算數組

單獨一個數叫作標量app

二多維數組

numpy 對多維數組的定義:

用numpy.ndarray類 (n表明n個數,d表明dimision維度)函數

Ndarray自己是一個類, 由這個類實例化出來的對象,就是多維數組佈局

多維數組也是一個對象性能

建立多維數組對象的方法:ui

1> numpy.arange(起始,終止,步長)編碼

他是經過numpy來訪問. 是一個numpy裏的函數spa

它返回的數組是一個等差數列的一維數組code

2> numpy.array()

這個array不是類,是numpy裏的函數

在numpy.array() 函數的括號裏,能夠輸入任何可被解釋成數組的容器,(列表或元組)

3> 獲取數組元素類型的方法:
```
d = np.array([[1,2,3],[4,5,6]])
方法一: type(d[0][0])  #==>python取類型的方法
方法二: d.dtype  #==> numpy 取類型的方法
```
4> int 32表明4個字節的整數型

爲何是int32?

在定義時未指定具體類型,而如今使用4個字節整形正好能保存d的數據,

因此default缺省值就是4個字節..

5> <U1 的意義
```
g=np.array(['1','2','3'])
print(g.dtype)    # <U1
print(type(g[0]))  #<class 'numpy.str_'>
```
- Unicode 每一個編碼佔4個字節. 由高低之分. 分爲小端序和大端序
- 'U' 表明是 unicode編碼
- '< ' 表示小端序
- '1' 表明每一個字符串中只有一個字符
6> 'numpy.str_' 的含義
- str 表明字符串
- _ 和python的字符串做爲區分
7> 手動指定類型的寫法
```
G=np.array(['1','2','3'],dtype=np.int32)
print(G.dtype)  #int32
H=G.astype(np.str_)
print(H.dtype)  #<U11
```
- '只要設置手動指定類型,它的數據類型就作自動轉換了.雖然值是字符串,可是咱們指定目標類型是整形int32,因此它的類型是int 32'
- 場景: 若要改回字符串格式,用 astype 函數
- <U11 解釋: 類型被再次改回來時,內存中回預留一些空間,

注: 全部和類型轉換有關的其實都不是類型轉換,都是複製,而後按新的類型複製一份, 可是 ,源是不變的

dtype 是屬性 ,用來取元素的類型

8> 關於維度的屬性

d = np.array([[1,2,3],[4,5,6]])
print(d.shape)  #(2, 3)  2行 3列

shape屬性 :

shape屬性的值是一個元組類型,一個元組內包含多個元素,分別是從高到低來表示每一個維度的數.. 即高緯度到低緯度

若是有頁行列

頁: 最高維度

行: 次之

列: 最低

9> arrange 和 array 均可以建立數組,有時候能夠混合用

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

用shape屬性能夠看到維度

Numpy 中多用二維數組,三維不多用

10> 元素索引

元素索引是從 0  開始的

數組[索引]
數組[行索引][列索引]
數組[頁索引][行索引][列索引]

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

for i in range(a.shape[0]):  # 0 是逐頁
    for j in range(a.shape[1]): # 1 是逐行
        for k in range(a.shape[2]):   # 2 是逐列
            print(a[i][j][k])

三 Numpy的內置類型和自定義類型

內置類型

a) 優勢: 可指定數據類型所佔內存是多少可靈活變化 b) 缺點: 由於具備靈活可變性, 因此會犧牲性能, (須要留出足夠空間) 沒法使用固定內存地址的計算方法, 只能用動態完成, 由於有關地址的運算就會佔用運行時間注: 在numpy裏爲每一種類型提供了固定的大小,因此有關地址運算徹底能夠經過類型來肯定. Numpy定義了一套本身獨立的數據類型體系.. 數據類型有固定的長度,字節數都是固定的.. 例 : Numpy.bool 一個布爾佔一個字節有符號版本( 正負數 ): Int8 1字節有符號類型 Int16 2字節有符號類型 Int32 4字節有符號類型無符號版本( 只有正數 ): Uint8 1字節無符號類型 Uint16 2字節無符號類型 Uint32 4字節無符號類型浮點類型: Float16 2字節浮點型有符號 Float32 4字節浮點型有符號 Float64 8字節浮點型有符號複數類型( 實部和虛部都用2個4字節浮點型表示 ): Complex64 8字節複數類型 Complex128 16字節複數類型注: 1複數 = 2個浮點型的組合字符串類型: Str_ 字符串沒有規定多少字節, 由於字符串類型取決與字符串 unicode 的長度字符串的長度根據字符串包含的字符決定注: lunicode = 4 個字節能夠用 dtype 和 astype 來設置類型轉換

自定義類型

直接使用內置類型的原始名

使用緊湊類型格式 ( 類型編碼字符串 ) 簡化操做: 能夠用更少的字符串來表示

全稱	簡化格式
Numpy.int8	i1
Int16	i2
Uint32	U4
Float64	F8
Complex128	c16

多字節的整數存在大小端序多字節整數能夠加上字節序前綴前綴類型 :
'<' 小端序低數位低地址 '=' 系統默認, 不能人爲指定 '>' 大端序低樹位高地址

注: 有時爲了防止因某個代碼功能在不一樣處理器上移植帶來的兼容性問題,因此強制加上了'< ' 和 '> '
```
import numpy as np

a=np.array([('ABC',[1,2,3])],dtype={'names':['name','scores'],'formats':['U3','3i4']})
print(a)  #[('ABC', [1, 2, 3])]
print(a[0]['name'])   #ABC
print(a[0]['scores'][0])  #1
print(a[0]['scores'][1])    #2
print(a[0]['scores'][2])    #3
```

b=np.array([0x1234],dtype=('u2',{'低數位':('u1',0),'高數位':('u1',1)})) # <u2 小端序 > 大端序 print('{:x}'.format(b[0])) #以16進制輸出b裏的第0號元素 print('{:x},{:x}'.format(b['低數位'][0],b['高數位'][0])) ```

關於字節序:

不需添加字節序的數據類型: 單字節整數, 布爾值, 複數類型, 浮點數

其餘狀況: Numpy.str_ => U+字符數

Unicode 自己就是多字節整數, 一個unicode可看做一個uint32,也存在大小端序

Numpy.bool => b

注: numpy提供的是python的封裝, 用自定義類型的方法能夠完成一個元素不一樣類型的訪問; 或把一個元素用不一樣類型來組合,彌補了numpy數組元素同質的狀況..

四切片

與python類似

數組[起始: 終止: 步長]

能夠針對多維數組來切片

缺省起始: 首元素( 步長爲正 ) , 尾元素( 步長爲負 ) ->逆向

缺省終止: 尾後( 步長爲正 ) , 首前( 步長爲負 )

缺省步長: 1

a = np.arange(1,10)
print(a)  #[1 2 3 4 5 6 7 8 9]
print(a[:3])   #[1 2 3]
print(a[3:6])  #[4 5 6]
print(a[6:])   #[7 8 9]
print(a[:-4:-1])  #[9 8 7]
print(a[...])    #[1 2 3 4 5 6 7 8 9]
print(a[:])    #[1 2 3 4 5 6 7 8 9]
print(a[1::3])  #[2 5 8]

b=np.arange(1,25).reshape(2,3,4)
print(b)
# print(b[:,0,0])  # [ 1 13]
# print(b[0,:,:])
# print(b[0,1,::2])  #[5 7]
# print(b[-1,1:,2:])
# print(b[:,1:,1])
print(b[1,1,::2])  #[17 19]

一個或一個以上缺省值切片:

a[...] a[ : ]

五改變維度

分爲 4 種方式

視圖變維 :

針對一個數組對象獲取不一樣維度的視圖

方法: 數組.reshape(新維度) -> 數組新維度視圖

數組.ravel() -> 數組的一維視圖
```
import numpy as np

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

b=a.reshape(2,4)
print(b)   #[[1 2 3 4] [5 6 7 8]]

c=b.ravel()
print(c)   #[1 2 3 4 5 6 7 8]
```
複製變維度 ( 不一樣維度的拷貝 ): 針對一個數組對象獲取不一樣維度的副本方法: flatten() -> 數組的覺得副本功能: 在得到原數據實例的同時得到拷貝, 也就是副本
```
d=b.flatten()
print(d)   #[1 2 3 4 5 6 7 8]  複製成一維

e=b.reshape(2,2,2).copy()
print(e)
```

就地變維數組. shape = ( 新維度 ) 等價於數組. resize( 新維度 )

a=np.array([np.arange(1,9)])
a.shape = (2,2,2)
# a.resize =(2,2,2) 
print(a)  #變成一個新的2頁2行2列的三維數組

視圖轉置 ( 線性代數的概念 ) 可理解爲行列互換數組. transpose( ) ->數組的轉置視圖等價於

數組. T -> 轉置視圖屬性
```
a=np.array([np.arange(1,9)])
a.shape = (4,2)  #a是4行2列
g = a.transpose()
print(g)
# [[1 3 5 7]
#  [2 4 6 8]]

print(np.array([a]).T)  #先轉成多維數組,再轉置
print(a.reshape(-1,1))   # -1 無效值
```
注: 裝置必須是二維的數組才能夠

六組合和拆分
- 垂直組合 :
numpy.vstack( ( 上下) ) 棧
- 垂直拆分 :
numpy.vsplit( 數組 , 份數 )

列: a,b=np.vsplit( c , 2 )

c 表明是被拆的變量 2 表明的是拆分紅2 份
```
import numpy as np

a=np.arange(11,20).reshape(3,3)
print(a)
b=np.arange(21,30).reshape(3,3)
print(b)
c=np.vstack((a,b))
print(c)

l,h=np.vsplit(c,2)
print(l,h,sep='\n')  #把c 拆分紅 l 和 h 兩個
```
- 水平組合 :
numpy.hstack( ( 左右) ) 棧
- 水平拆分 :
numpy.hsplit( 數組 , 份數 )

列: a,b=np.vsplit( c , 2 )

c 表明是被拆的變量 2 表明的是拆分紅2 份
```
import numpy as np

a=np.arange(11,20).reshape(3,3)
print(a)
b=np.arange(21,30).reshape(3,3)
print(b)
c=np.hstack((a,b))
print(c)
l,h=np.hsplit(c,2)
print(l,h,sep='\n')
```
- 深度組合和深度拆分
  
  numpy.dstack( ( 前後 ) ) 棧
  
  numpy.dsplit( 數組 , 份數 )
```
c=np.dstack((a,b))
print(c)
l,h=np.dsplit(c,2)
print(l,h,sep='\n')
```
深度組合:
1. 先後佈局,用第三個垂直於平面來截線 , 截到的這部分就以數組的形式組合起來, 構成一個三位數組
2. 這三個截面就是三個頁 , 每一個頁都有一個二維數組來自於對應的行 , 同時還作了轉置 , 截到的行轉爲列
深度拆分:
1. a, b = np.dsplit( c , 2)
2. print( a.T [ 0 ] . T , b.T [ 0 ] . T ,sep='\n') #T [ 0 ] . T轉置取0號元素再轉置
  
  注: 深度拆分如要恢復成二維數組的樣式,需手工來操做
  
  行 / 列組合
3. 特色: 只能組合不能拆分
  
  numpy.row_stack( ( 上下 ) ) 等價於 numpy.vstack
  
  numpy.column_stack( ( 左右 ) ) 等價於 numpy.hstack
  
  numpy.column_stack( ( 左右 ) ) 簡略寫法 np.c_[左右]

七回顧 ndarray屬性

dtype 元素類型
shape 數組維度
T 轉置視圖
ndim 維度數
size 元素數 . 針對一維數組等價於python的 len()
npytes 元素的總字節數
len () 永遠獲得shape裏的第一個元素 *** size** 獲得的是shape裏的乘積
itemize 元素的字節數即一個元素佔多少字節
flat 扁平迭代器獲得的是一個迭代對象 ,能夠進行迭代遍歷
tolist 數組改列表
imag 虛部數組
real 實部數組

*****numpy也有append 函數方法 ,可是必須有返回值

import numpy as np

a=np.array([
    [1+1j,2+4j,3+6j],
    [1+1j,2+4j,3+6j],
    [1+1j,2+4j,3+6j]
])
print(a.dtype)  #complex128 16個字節 8位是實部 8位是虛部
print(a.shape)   #3行3列
print(a.ndim)    #2維
print(a.size,len(a))   # 9個元素  3 列
print(a.itemsize)  # 每一個元素佔16個字節
print(a.nbytes)  # 144個字節  16* 9
print(a.T)
print(a.real,a.imag,sep='\n')   # 取實部和虛部
for i in a.flat:   #flat 扁平迭代器
    print(i)
# ----------------------------------------------------------
#列 :
def fun(z,zz):
    z.append(zz)
    return z
x=np.array([1,2,3])
y=40
# x=fun(x,y) #會報錯 由於數組沒有append方法
x=fun(x.tolist(),y)
print(x)  #[1, 2, 3, 40]

y=np.append(x,50)
print(y)    #[ 1  2  3 40 50]

人工智能入門--Numpy

一 矢量

二 多維數組

三 Numpy的內置類型和自定義類型

內置類型

自定義類型

四 切片

五 改變維度

六 組合和拆分

七 回顧 ndarray屬性

一矢量

二多維數組

四切片

五改變維度

六組合和拆分

七回顧 ndarray屬性