­

numpy函數筆記（持續更新）

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]
Tags:

VirMach 便宜 VPS

QNews

QNews