numpy 簡介
In [227]:
import numpy as np
In [ ]:
# NumPy是Python中科學計算的基礎軟件包。
# 它是一個提供多了維數組對象，多種派生對象（如：掩碼數組、矩陣）以及用於快速操做數組的函數及API，
# 它包括數學、邏輯、數組形狀變換、排序、選擇、I/O 、離散傅立葉變換、基本線性代數、基本統計運算、隨機模擬等等。
# NumPy包的核心是ndarray對象。
# 它封裝了python原生的同數據類型的n維數組，爲了保證其性能優良，其中有許多操做都是代碼在本地進行編譯後執行的。
# NumPy數組 和 標準Python Array（數組） 之間 的區別
# NumPy數組在建立時具備固定的大小，與Python的原生數組對象（能夠動態增加）不一樣。 更改ndarray的大小將建立一個新數組並刪除原來的數組。
# NumPy數組中的元素都須要具備相同的數據類型，所以在內存中的大小相同。 例外狀況：Python的原生數組裏包含了NumPy的對象的時候，
# 這種狀況下就容許不一樣大小元素的數組。
# 安裝
# python -m pip install --user numpy scipy matplotlib ipython jupyter pandas sympy nose
In [2]:
# NumPy的主要對象是同類型的多維數組。它是一張表，全部元素（一般是數字）的類型都相同，並經過正整數元組索引。在NumPy中，維度稱爲軸。
# 軸的數目爲rank。
# [1, 2, 1] 是rank爲1的數組，由於它具備一個軸。該軸的長度爲3
t1 = [[ 1., 0., 0.],
[ 0., 1., 2.]]
# t1 有兩個軸 第一個軸（維度）的長度爲2，第二個軸（維度）的長度爲3。
In [3]:
# 主要屬性
# ndarray.ndim：數組的軸（維度）的個數。在Python世界中，維度的數量被稱爲rank。
# ndarray.shape：數組的維度。這是一個整數的元組，表示每一個維度中數組的大小。對於有n行和m列的矩陣，shape將是(n,m)。所以，
# shape元組的長度就是rank或維度的個數 ndim。
# ndarray.size：數組元素的總數。這等於shape的元素的乘積。
# ndarray.dtype：一個描述數組中元素類型的對象。可使用標準的Python類型建立或指定dtype。另外NumPy提供它本身的類型。
# 例如numpy.int3二、numpy.int16和numpy.float64。
# ndarray.itemsize：數組中每一個元素的字節大小。例如，元素爲 float64 類型的數組的 itemsize 爲8（=64/8），而 complex32 類型的數組的
# itemsize 爲4（=32/8）。它等於 ndarray.dtype.itemsize 。
# ndarray.data：該緩衝區包含數組的實際元素。一般，咱們不須要使用此屬性，由於咱們將使用索引訪問數組中的元素。
In [50]:
# 建立數組
In [228]:
# 1. 用普通的python列表建立數組
a1 = np.array([1,2,3])
print(a1.ndim)
print(a1.dtype)
print(a1.size)
print(a1.shape)
a1
Out[228]:
In [9]:
a2 = a1 = np.array([[1,2,3], [3,4,5]], dtype='int')
a2
Out[9]:
In [12]:
print(a2.ndim)
print(a2.dtype)
print(a2.size)
print(a2.shape)
In [ ]:
# 用 nunpy 內置的方法來建立數組
In [18]:
#np.zeros(shape, dtype=None, order='C')
#建立shape是3x5的全1(默認浮點型)數組
a3= np.zeros((3,5), order='C')
a3
Out[18]:
In [17]:
#np.zeros(shape, dtype=None, order='C')
#建立shape是3x5的全1(默認浮點型)數組
a4 = np.ones((3,5))
a4
Out[17]:
In [19]:
#np.eye(N, M=None, k=0, dtype=<class 'float'>, order='C')
#建立一個形狀爲 N x N 的單位矩陣（二維數組）
a5 = np.eye(3)
a5
Out[19]:
In [21]:
#empty(shape, dtype=float, order='C')
#建立一個形狀爲shape的未初始化數組，值爲隨機值
a6 =np.empty(5, dtype='int')
Out[21]:
In [23]:
a7 = np.empty((3,4))
a7
Out[23]:
In [34]:
#np.full(shape, fill_value, dtype=None, order='C')
#建立shape是3x5的(默認浮點型)數組，值fill_value都是3.14
a7 = np.full((3,5),5)
a7
Out[34]:
In [35]:
# 使用 arange 來建立
# arange([start,] stop[, step,], dtype=None)
a8 = np.arange(0,20,5)
a8
Out[35]:
In [230]:
# 使用linspace 來建立
# np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
a9= np.linspace(10,20,6)
a9
Out[230]:
In [233]:
# reshape
a10 = a9.reshape(2,3)
a10
Out[233]:
In [51]:
# 形狀 和操做
In [236]:
aa = np.arange(20).reshape(4,5)
aa
Out[236]:
In [237]:
print(aa.shape)
print(aa.size)
In [43]:
aa.reshape(5,4) # 不改變數組自己
Out[43]:
In [44]:
aa
Out[44]:
In [45]:
aa.ravel() # 不改變數組自己
Out[45]:
In [46]:
aa
Out[46]:
In [238]:
aa
Out[238]:
In [239]:
aa.resize(5,4) # 改變數組自己
In [240]:
aa
Out[240]:
In [241]:
aa.reshape(5,-1) #reshape操做中將維度指定爲-1，則會自動計算其餘維度
Out[241]:
In [52]:
# 將不一樣的數組堆疊在一塊兒
In [243]:
aa = np.floor(10*np.random.random((2,2)))
aa
Out[243]:
In [244]:
bb = np.floor(10*np.random.random((2,2)))
bb
Out[244]:
In [245]:
xx = np.vstack((aa,bb))
xx
Out[245]:
In [246]:
np.hstack((aa, bb))
Out[246]:
In [60]:
# numpy 切片和索引
In [61]:
a = np.arange(10)
a
Out[61]:
In [67]:
s = slice(2,7,2)
print(a[s])
In [68]:
b = a[2:7:2]
b
Out[68]:
In [250]:
aa = np.floor(10*np.random.random((2,12)))
aa
Out[250]:
In [258]:
aa
Out[258]:
In [259]:
np.hsplit(aa,3) # 平均分紅3份
Out[259]:
In [260]:
np.hsplit(aa,(3,4)) # 0-3 3-4 4-
Out[260]:
In [73]:
# 分割
aa = np.random.randint(1, 50,size=(7,7))
aa
Out[73]:
In [74]:
# np.split(arr,index,axis)
# arr 爲被切分的數組
# index(整數或者數組)
# 若是是一個整數 就把當前數組平均分紅index份，若是數組的size不能被index整除則報錯，
# 若是爲一個數組，則沿的數組的軸線進行切分,好比:[2, 3] 則會被切割成[:2],[2:3],[3:]
# axis 爲切分的方向 默認爲0 橫向 1爲豎向
np.split(aa, [2,4,6], axis=1)
Out[74]:
In [75]:
aa
Out[75]:
In [76]:
aa[5]
Out[76]:
In [77]:
aa[5,3]
Out[77]:
In [78]:
aa[5:]
Out[78]:
In [79]:
aa[:,1:2]
Out[79]:
In [261]:
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print(a)
print("-----------------")
print (a[...,1]) # 第2列元素
print("-----------------")
print (a[1,...]) # 第2行元素
print("-----------------")
print (a[...,1:]) # 第2列及剩下的全部元素
# 三個點（ ... ）表示產生完整索引元組所需的冒號。例如，若是 x 是rank爲的5數組（即，它具備5個軸），則
# x[1,2,...] 等於 x[1,2,:,:,:]。
# x[...,3] 等效於 x[:,:,:,:,3]。
In [263]:
# 整數數組索引
# 實例獲取數組中(0,0)，(1,1)和(2,0)位置處的元素。
x = np.array([[1, 2], [3, 4], [5, 6]])
print(x)
print('--------------')
y = x[[0,1,2], [0,1,0]]
print (y)
In [85]:
#獲取了 4X3 數組中的四個角的元素。 行索引是 [0,0] 和 [3,3]，而列索引是 [0,2] 和 [0,2]。
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
print ('咱們的數組是：' )
print (x)
print ('\n')
rows = np.array([[0,0],[3,3]])
cols = np.array([[0,2],[0,2]])
y = x[rows,cols]
print ('這個數組的四個角元素是：')
print (y)
In [264]:
# 布爾索引
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
print ('咱們的數組是：')
print (x)
print ('\n')
# 如今咱們會打印出大於 5 的元素
print ('大於 5 的元素是：')
print(x>5)
print (x[x > 5])
In [86]:
a = np.array([np.nan, 1,2,np.nan,3,4,5])
print (a[~np.isnan(a)])
In [92]:
np.nan == np.nan
Out[92]:
In [93]:
# 花式索引
# 花式索引指的是利用整數數組進行索引。
# 花式索引根據索引數組的值做爲目標數組的某個軸的下標來取值。對於使用一維整型數組做爲索引，若是目標是一維數組，
# 那麼索引的結果就是對應位置的元素；若是目標是二維數組，那麼就是對應下標的行。
# 花式索引跟切片不同，它老是將數據複製到新數組中。
# 一、傳入順序索引數組
In [265]:
x=np.arange(32).reshape((8,4))
print(x)
print('--------------------')
print (x[[4,2,1,7]])
In [266]:
x=np.arange(32).reshape((8,4))
print (x[[-4,-2,-1,-7]])
In [268]:
print (x[([1,5,7,2],[0,3,1,2])])
In [270]:
print (x[np.ix_([1,5,7,2],[0,3,1,2])])
In [226]:
x = np.array([[1,2],[3,4],[5,6]])
print(x)
print('-----------')
print(x[[0,1]])
print('-------------')
print(x[[0,1],[0,1]])
print('------------------')
# 使用numpy.ix_()函數加強可讀性
print (x[np.ix_([0,1],[0,1])])
print('--------------')
x[[0,1],[0,1]] = [0,0]
print(x) # [[0,2],[3,0],[5,6]]
In [271]:
# 迭代數組
In [273]:
# 迭代
a = np.arange(6).reshape(2,3)
print ('原始數組是：')
print (a)
print ('\n')
print ('迭代輸出元素：')
for x in np.nditer(a):
print (x, end=", " )
print ('\n')
In [275]:
# for x in np.nditer(a, order='F'):Fortran order，便是列序優先；
# for x in np.nditer(a.T, order='C'):C order，便是行序優先；
a = np.arange(6).reshape(2,3)
print(a)
print('------------')
print(a.T)
for x in np.nditer(a, order ='C'):
print (x, end=", " )
print ('\n')
In [117]:
for i in a:
print(i)
In [123]:
# 修改數組中元素的值
# nditer 對象有另外一個可選參數 op_flags。 默認狀況下，nditer 將視待迭代遍歷的數組爲只讀對象（read-only），爲了在遍歷數組的同時，
# 實現對數組元素值得修改，必須指定 read-write 或者 write-only 的模式。
a = np.arange(0,60,5)
a = a.reshape(3,4)
print ('原始數組是：')
print (a)
print ('\n')
for x in np.nditer(a, op_flags=['readwrite']):
x[...]=2*x
print ('修改後的數組是：')
print (a)
In [124]:
# numpy.ndarray.flat 是一個數組元素迭代器，實例以下:
a = np.arange(9).reshape(3,3)
print ('原始數組：')
for row in a:
print (row)
#對數組中每一個元素都進行處理，可使用flat屬性，該屬性是一個數組元素迭代器：
print ('迭代後的數組：')
for element in a.flat:
print (element)
In [125]:
# 數組操做
# numpy.ndarray.flatten 返回一份數組拷貝，對拷貝所作的修改不會影響原始數組，格式以下：
# ndarray.flatten(order='C')
# order：'C' -- 按行，'F' -- 按列，'A' -- 原順序，'K' -- 元素在內存中的出現順序。
a = np.arange(8).reshape(2,4)
print ('原數組：')
print (a)
print ('\n')
# 默認按行
print ('展開的數組：')
print (a.flatten())
print ('\n')
print ('以 F 風格順序展開的數組：')
print (a.flatten(order = 'F'))
In [127]:
# 翻轉數組
In [276]:
# numpy.transpose 函數用於對換數組的維度 numpy.ndarray.T 相似 numpy.transpose
a = np.arange(12).reshape(3,4)
print ('原數組：')
print (a )
print ('\n')
print ('對換數組：')
print (np.transpose(a))
print('-------------------')
print(a.T)
In [134]:
# 軸的理解
In [277]:
a = np.array([[78, 34, 87, 25, 83], [25, 67, 97, 22, 13], [78, 43, 87, 45, 89]])
print(a)
print('-------------------')
print(a.max(axis=0))
print(a.max(axis=1))
#axis=0就是豎軸的數據 axis=1就是橫軸的
In [278]:
a = np.array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]])
print(a.shape)
print(a)
print('--------------')
print(a.max(axis=0))
print('-----------')
print(a.max(axis=1))
print('-------------')
print(a.max(axis=2))
# 這裏的最大值就是把一個一維數組當成了一個元素
In [279]:
# numpy.rollaxis 函數向後滾動特定的軸到一個特定位置
# numpy.rollaxis(arr, axis, start)
# arr：數組
# axis：要向後滾動的軸，其它軸的相對位置不會改變
# start：默認爲零，表示完整的滾動。會滾動到特定位置。
# 建立了三維的 ndarray
a = np.arange(8).reshape(2,2,2)
print ('原數組：')
print (a)
print ('\n')
# 將軸 2 滾動到軸 0（寬度到深度）
# 程序運行np.rollaxis(a, 2)時,講軸2滾動到了軸0前面,其餘軸相對2軸位置不變(start默認0),數組下標排序由0,1,2變成了1,2,0
print ('調用 rollaxis 函數：')
print (np.rollaxis(a,2))
# 將軸 0 滾動到軸 1：（寬度到高度）
print ('\n')
print ('調用 rollaxis 函數：')
print (np.rollaxis(a,2,1))
In [136]:
# numpy.swapaxes 函數用於交換數組的兩個軸 numpy.swapaxes(arr, axis1, axis2)
# arr：輸入的數組
# axis1：對應第一個軸的整數
# axis2：對應第二個軸的整數
# 建立了三維的 ndarray
a = np.arange(8).reshape(2,2,2)
print ('原數組：')
print (a)
print ('\n')
# 如今交換軸 0（深度方向）到軸 2（寬度方向）
print ('調用 swapaxes 函數後的數組：')
print (np.swapaxes(a, 2, 0))
In [137]:
# 隨機數組
In [280]:
# 隨機建立 指定形狀的數組 0-1之間的數
np.random.rand(5)
Out[280]:
In [281]:
np.random.rand(5,5, 5)
Out[281]:
In [282]:
# 隨機獲取指定範圍的一個數
np.random.uniform(0,100)
Out[282]:
In [283]:
# 隨機獲取指定範圍的一個整數
np.random.randint(0,52)
Out[283]:
In [284]:
np.random.randint(0,20,size=(3,4))
Out[284]:
In [144]:
np.random.randint(0,20,size=(5,4))
Out[144]:
In [145]:
# np.random.choice(F,N,P)
# 從0-F範圍裏面去N個數(不包含N)，P表示機率
np.random.choice(2,2)
Out[145]:
In [288]:
a1 = np.random.choice(5,3,p=[0.2,0,0.5,0.3,0])
a1
Out[288]:
In [150]:
b = np.random.randint(0,20,size=(5,4))
print(b)
In [151]:
np.random.shuffle(b)
print(b)
In [152]:
# 計算
In [153]:
a = [1,2,3,4]
b= np.array(a,dtype='float')
b
Out[153]:
In [154]:
b+1
Out[154]:
In [155]:
b
Out[155]:
In [156]:
a = np.array([1,3,5,7])
a
Out[156]:
In [157]:
# 同緯度且個數相同的數組相加
a+b
Out[157]:
In [289]:
# 數組a中大於3的數就會顯示True小於3的數就會顯示False
a[a>3]
Out[289]:
In [159]:
print(a)
a[a>3]
Out[159]:
In [161]:
c = np.array([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15])
c
Out[161]:
In [290]:
# 求出c中大於5且爲偶數的元素
c[(c>5) & (c%2==0)]
Out[290]:
In [292]:
d=np.array([1.1,2.2,3.3,4.4,5.5,6.6,7.7])
d
Out[292]:
In [294]:
# 向上取整
print(np.ceil(d))
# 向下取整
print(np.floor(d))
# 絕對值
print(np.abs(d))
# 開方
print(np.sqrt(b))
# 分別去除小數部分和整數部分
print('------------------')
print(np.modf(d))
# e爲底的指數函數
print(np.exp(d))
print(np.log(d))
# 四捨五入
print(np.round(d))
print('------------------')
print(np.rint(d))
# 向0取整
print(np.trunc(d))
# 是否不等於任何整數
print(np.isnan(d))
#
print(np.cos(b))
print(np.sin(b))
print(np.tan(b))
# 上述操做 對普通列表 也實用
In [295]:
print(d)
print('-------------------------')
# 求和
print(d.sum())
# 平均值
print(d.mean())
# 等差數列
print(d.cumsum())
# 標準差
print(d.std())
# 方差
print(d.var())
# 最小值
print(d.min())
#最大值
print(d.max())
print('---------------')
# 最大值索引
print(d.argmin())
# 最小值索引
print(d.argmax())
In [297]:
a = np.array( [20,30,40,50] )
b = np.arange( 4 )
print(a)
print('-----')
print(b)
In [298]:
c = a-b
c
Out[298]:
In [174]:
b**2
Out[174]:
In [175]:
10*np.sin(a)
Out[175]:
In [307]:
# 與許多矩陣語言不一樣，乘法運算符 * 的運算在NumPy數組中是元素級別的。矩陣乘積可使用 dot 函數或方法執行
a = np.array( [[1,1,1],[0,1,1]] )
a
Out[307]:
In [317]:
b = np.array( [[2,0], [3,4], [1,1] ])
b
Out[317]:
In [315]:
a*b
Out[315]:
In [318]:
a.dot(b)
Out[318]:
In [319]:
a = np.ones((2,3), dtype=int)
a
Out[319]:
In [320]:
a*=3
a
Out[320]:
In [322]:
b = np.random.randint(0,6, size=(2,3))
b
Out[322]:
In [323]:
b+=a
b
Out[323]:
In [325]:
print(a)
print(b)
a+=b
a
Out[325]:
In [ ]:
# 複製和視圖
In [ ]:
# NumPy中，數組的複製有三種方式：
# Python通用的地址複製：經過 b = a 複製 a 的值，b 與 a 指向同一地址，改變 b 同時也改變 a。
# 經過視圖ndarray.view()僅複製值，當對 c 值進行改變會改變 a 的對應的值，而改變 c 的 shape 不改變 a 的 shape。
# ndarray.copy() 進行的完整的拷貝，產生一份徹底相同的獨立的複製。
In [210]:
a = np.arange(12)
a
Out[210]:
In [211]:
b=a
a is b
Out[211]:
In [212]:
c = a.view()
c
Out[212]:
In [326]:
a is c
Out[326]:
In [216]:
c.shape = 2,6
c
Out[216]:
In [217]:
c [0,0] = 55
a
Out[217]:
In [218]:
d = a.copy()
d is a
Out[218]:
In [219]:
d
Out[219]:
In [221]:
d.shape = 2,6
d
Out[221]:
In [222]:
d[1,1] = 22
a
Out[222]:
In [ ]:
In [ ]:
相關文章
- 1. Numpy庫簡介
- 2. Numpy入門(一)：Numpy簡介
- 3. Numpy 多維數組簡介
- 4. Python-numpy庫的簡介
- 5. python-numpy 簡介與練習
- 6. 01-numpy基礎簡介
- 7. Numpy的簡單介紹
- 8. Numpy的簡單介紹及安裝
- 9. Numpy與Pandas一句話簡介
- 10. Python NumPy介紹
- 更多相關文章...
- • Scala 簡介 - Scala教程
- • AJAX 簡介 - PHP教程
- • Github 簡明教程
- • Java Agent入門實戰（一）-Instrumentation介紹與使用
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. Numpy庫簡介
- 2. Numpy入門(一)：Numpy簡介
- 3. Numpy 多維數組簡介
- 4. Python-numpy庫的簡介
- 5. python-numpy 簡介與練習
- 6. 01-numpy基礎簡介
- 7. Numpy的簡單介紹
- 8. Numpy的簡單介紹及安裝
- 9. Numpy與Pandas一句話簡介
- 10. Python NumPy介紹