numpy函式筆記

np.isin用法

np.isin(a,b) 用于判定a中的元素在b中是否出現過，如果出現過回傳True,否則回傳False,最終結果為一個形狀和a一模一樣的陣列，（注意：這里的a和b是像陣列型別就行，比如串列的話，傳入進去之后，numpy會自動將其轉化為numpy陣列）
但是當引數invert被設定為True時，情況恰好相反，如果a中元素在b中沒有出現則回傳True,如果出現了則回傳False.

import numpy as np
# 這里使用reshape是為了驗證是否對高維陣列適用，回傳一個和a形狀一樣的陣列
a=np.array([1,3,7]).reshape(3,1)
b=np.arange(9).reshape(3,3)
# a 中的元素是否在b中，如果在b中顯示True
Np_No_invert=np.isin(a, b, invert=False)
print("Np_No_invert\n",Np_No_invert)
# a 中的元素是否在b中，如果設定了invert=True,則情況恰恰相反，即a中元素在b中則回傳False
Np_invert=np.isin(a, b, invert=True)
print("Np_invert\n",Np_invert)
# Np_No_invert
#  [[ True]
#  [ True]
#  [ True]]
# Np_invert
#  [[False]
#  [False]
#  [False]]

numpy.cumsum()

numpy.cumsum(a, axis=None, dtype=None, out=None)
axis=0，按照行累加，
axis=1，按照列累加，
axis不給定具體值，就把numpy陣列當成一個一維陣列，

注意這里的行和列和普通認為的不一樣，只要認定為是往哪一個軸進行相加，

也就是按照指定維度進行相加

例子如下：

a
Out[6]: 
array([[-0.94525613, -0.84632869,  0.65120093],
       [ 0.11813225,  0.22240677, -1.6212242 ],
       [-0.80511744,  1.04439191, -1.45651271]])
np.cumsum(a,1)
Out[8]: 
array([[-0.94525613, -1.79158482, -1.14038389],
       [ 0.11813225,  0.34053902, -1.28068518],
       [-0.80511744,  0.23927446, -1.21723825]])

np.around 和np.round四舍五入

這兩個函式的功能是一樣的，np.round內部呼叫的就是np.around，

np.around 回傳四舍五入后的值，可指定精度，

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

a 輸入陣列

decimals 要舍入的小數位數，默認值為0，如果為負，整數將四舍五入到小數點左側的位置

import numpy as np
 
n = np.array([-0.746, 4.6, 9.4, 7.447, 10.455, 11.555])
 
around1 = np.around(n)
print(around1)  # [ -1.   5.   9.   7.  10.  12.]
 
around2 = np.around(n, decimals=1)
print(around2)  # [ -0.7   4.6   9.4   7.4  10.5  11.6]
 
around3 = np.around(n, decimals=-1)
print(around3)  # [ -0.   0.  10.  10.  10.  10.]

a=np.random.randn(3,3)
a
Out[6]: 
array([[-0.94525613, -0.84632869,  0.65120093],
       [ 0.11813225,  0.22240677, -1.6212242 ],
       [-0.80511744,  1.04439191, -1.45651271]])
np.round(a,2)
Out[7]: 
array([[-0.95, -0.85,  0.65],
       [ 0.12,  0.22, -1.62],
       [-0.81,  1.04, -1.46]])

np.floor 向下取整

np.floor 回傳不大于輸入引數的最大整數，即對于輸入值 x ，將回傳最大的整數 i ，使得 i <= x，注意在Python中，向下取整總是從 0 舍入，

import numpy as np
 
n = np.array([-1.7, -2.5, -0.2, 0.6, 1.2, 2.7, 11])
 
floor = np.floor(n)
print(floor)  # [ -2.  -3.  -1.   0.   1.   2.  11.]

np.ceil 向上取整

np.ceil 函式回傳輸入值的上限，即對于輸入 x ，回傳最小的整數 i ，使得 i> = x，

import numpy as np
 
n = np.array([-1.7, -2.5, -0.2, 0.6, 1.2, 2.7, 11])
 
ceil = np.ceil(n)
print(ceil)  # [ -1.  -2.  -0.   1.   2.   3.  11.]

NumPy中的diag函式

NumPy包中的內置diag函式很有意思，

假設創建一個1維陣列a，和一個3*3陣列b：

import numpy as np
a = np.arange(1, 4)
b = np.arange(1, 10).reshape(3, 3)

結果如下：

>>> a
array([1, 2, 3])
>>> b
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

使用diag函式，看一看結果：

>>> np.diag(a)
array([[1, 0, 0],
       [0, 2, 0],
       [0, 0, 3]])
>>> np.diag(b)
array([1, 5, 9])

可以發現，當 np.diag(array) 中

array是一個1維陣列時，結果形成一個以一維陣列為對角線元素的矩陣

array是一個二維矩陣時，結果輸出矩陣的對角線元素

np.set_printoptions函式

設定列印選項，也就是指定如何列印numpy陣列，如何顯示numpy陣列，

這些選項確定浮點數、陣列和其他 NumPy 物件的顯示方式，

引數解釋

precision：int 或無，可選

浮點輸出的精度位數（默認 8），如果浮點模式不是固定的，則可能是"無"，以列印盡可能多的數字以唯一指定值，
threshold：int，可選

觸發匯總而不是完全 repr 的陣列元素總數（默認 1000），要始終使用完整重供而不匯總，請傳遞sys.maxsize，
edgeitems :int，可選

每個維度的開頭和末尾匯總中的陣列項數（默認值 3），
linewidth：int，可選

用于插入換行符/行數（默認為 75），
suppress :布爾，可選

如果為 True，則始終使用固定點表示法列印浮點編號，在這種情況下，當前精度中等于零的數字將列印為零，如果 False，則當最小數字的絕對值為 < 1e-4 或最大絕對值與最小值的比率為 > 1e3 時，則使用科學表示法，默認值為 False，
nanstr： str，可選

浮點非數字（默認 nan）的字串表示形式，
infstr :str，可選

浮點無窮大的字串表示形式（默認 inf），
sign :字串，"-"，"+"或""，可選

控制浮點型別的符號的列印，如果為"+"，請始終列印正值的符號，如果 ''，則始終在正值的符號位置列印空格（空白字符），如果為"-"，則省略正值的符號字符，（默認為"-"）
formatter :呼叫的字典，可選

如果不是"無"，則鍵應指示相應格式函式應用于的型別，可呼叫項應回傳字串，未指定的型別（由其相應的鍵）由默認格式器處理，可設定可處理的單個型別包括：
- "布爾"
- "int"
- "時間德爾塔" ： anumpy.timedelta64
- "日期時間"： anumpy.datetime64
- "浮動"
- "長浮"：128位浮子
- "復雜漂浮"
- "長共體浮"：由兩個128位浮子組成
- "數字"：型別和numpy.string_``numpy.unicode_
- "物件"：np.object_陣列
- "str" ：所有其他字串
可用于同時設定一組型別的其他鍵包括：
- "全部"：設定所有型別
- "int_kind"：設定"int"
- "float_kind"：設定"浮動"和"長浮"
- "complex_kind"：設定"復雜浮"和"長復雜浮"
- "str_kind"：設定"str"和"numpystr"
**floatmode : **str，可選

控制浮點型別的精度選項的解釋，可以采取以下值（默認maxprec_equal）：
- "固定"：始終列印精確分數數字，
  
  即使這樣列印的數字數會超過唯一指定值所需的數字，
- "唯一"：列印所需的最小小數數字
  
  以唯一方式表示每個值，不同的元素可能具有不同的數字數，精度選項的值將被忽略，
- "maxprec"：以最精確的小數列印，但如果
  
  元素可以唯一表示，數字較少，只能用這么多數字列印它，
- "maxprec_equal"：以最精確的小數列印，
  
  但是，如果陣列中的每個元素都可以以相同數量的較少數字的唯一表示，則所有元素都使用該數字，

官方檔案例子

可以設定浮點精度：

>>>

>>> np.set_printoptions(precision=4)
>>> np.array([1.123456789])
[1.1235]

可以總結長陣列：

>>>

>>> np.set_printoptions(threshold=5)
>>> np.arange(10)
array([0, 1, 2, ..., 7, 8, 9])

小結果可以抑制：

>>>

>>> eps = np.finfo(float).eps
>>> x = np.arange(4.)
>>> x**2 - (x + eps)**2
array([-4.9304e-32, -4.4409e-16,  0.0000e+00,  0.0000e+00])
>>> np.set_printoptions(suppress=True)
>>> x**2 - (x + eps)**2
array([-0., -0.,  0.,  0.])

自定義格式可用于根據需要顯示陣列元素：

>>>

>>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)})
>>> x = np.arange(3)
>>> x
array([int: 0, int: -1, int: -2])
>>> np.set_printoptions()  # formatter gets reset
>>> x
array([0, 1, 2])

若要放回默認選項，可以使用：

>>>

>>> np.set_printoptions(edgeitems=3, infstr='inf',
... linewidth=75, nanstr='nan', precision=8,
... suppress=False, threshold=1000, formatter=None)

此外，若要臨時覆寫選項，請使用列印選項作為背景關系管理器：

>>>

>>> with np.printoptions(precision=2, suppress=True, threshold=5):
...     np.linspace(0, 10, 10)
array([ 0.  ,  1.11,  2.22, ...,  7.78,  8.89, 10.  ])

np.vdot點積函式

矩陣點積為兩個矩陣對應元素乘積之和

定義兩個矩陣a和b

#定義兩個矩陣
a=np.array([[4,3],[5,6]])
b=np.array([[10,11],[12,13]])
print("a")
print(a)
print("b")
print(b)
 
輸出結果：
a
[[4 3]
 [5 6]]
b
[[10 11]
 [12 13]]

使用vdot函式計算a和b的點積

#矩陣點積 vdot函式,
#矩陣點積計算公式：兩個矩陣對應位置元素乘積之和
c=np.vdot(a,b)
print("c")
print(c)
 
輸出結果：
c
211

np.nonzero(a)

回傳：陣列a中非零元素的索引值陣列

import numpy as np
a = np.random.uniform(-10, 10, 4)
print(a)
    [ 2.69869382 -8.87937198  4.70100555  1.87901029]
b = np.nonzero(a)
print(b)
    (array([0, 1, 2, 3], dtype=int64),)
#a是一維陣列，有4個非零元素，回傳4個非零元素的序號
 
a = [[0, 1, 1],
       [1, 0, 1],
       [1, 1, 0]]
print(a)
    [[0, 1, 1], [1, 0, 1], [1, 1, 0]]
b = np.nonzero(a)
print(b)
    (array([0, 0, 1, 1, 2, 2], dtype=int64), array([1, 2, 0, 2, 0, 1], dtype=int64))
    #a是二維陣列，array長度為6，即a有6個非零元素，第一個array是對非零元素的row描述，
    #第二個array是對col的描述，索引元組b一直都是二維陣列
print(np.transpose(b))
    [[0 1]
     [0 2]
     [1 0]
     [1 2]
     [2 0]
     [2 1]]
    #呼叫transpose轉置索引序號b元組，非零元素的序號[0，1]，即第0行，第一列，以此類推，

np.amin(a，axis=k)

回傳：一維陣列a中的最小值，二維陣列需通過axis指定行或列，獲取行或列的最小值，如不指定，則是所有元素的最小值

import numpy as np
 
a = [[0, 1, 2],
     [1, 0, 3],
     [1, 4, 0]]
a1 = np.asarray(a, dtype = np.float32)
print(a1[np.nonzero(a1)])
    [ 1.  2.  1.  3.  1.  4.]
    #使用a[np.nonzero(a)]獲取a中所有非零值，變一維陣列，但需要將a轉換成array
print(np.amin(a1[np.nonzero(a1)]))
    1.0
    #獲取陣列的最小值
 
#把a1中等于0的值換成a1陣列中的最小值
a1[a1==0] = np.amin(a1[np.nonzero(a1)])
print('a1 = ', a1)
    a1 =  [[ 1.  1.  2.]
           [ 1.  1.  3.]
           [ 1.  4.  1.]]

np.amax(a, axis=k)

回傳：一維陣列a中的最大值，二維陣列需通過axis指定行或列，獲取行或列的最大值，如不指定，則是所有元素的最大值

import numpy as np
 
a = [[1,4,7],
     [2,5,8],
     [3,6,9]]
b = np.amax(a, axis=0)
print(b)
 
b = [3,6,9]

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/29148.html

標籤：其他

上一篇：unity生成android apk檔案檢測不到sdk版本

下一篇：unity中的Slider洗掉handle扔能拖動

numpy函式筆記（持續更新）