Numpy基礎(chǔ)知識總結(jié)

數(shù)組創(chuàng)建

  1. 創(chuàng)建數(shù)組的方法：

    1. 從其他Python結(jié)構(gòu)轉(zhuǎn)換（例如:列表，元組）
    2. 內(nèi)在的numpy數(shù)組創(chuàng)建對象（例如，arange，ones，zeros等）
    3. 通過使用字符串或緩沖區(qū)從原始字節(jié)創(chuàng)建數(shù)組
    4. 使用特殊庫函數(shù)（例如，隨機）

  2. 將Python array_like對象轉(zhuǎn)換為Numpy數(shù)組

    Python中以類數(shù)組結(jié)構(gòu)排列的數(shù)字數(shù)據(jù)可以通過使用array()函數(shù)轉(zhuǎn)換為數(shù)組。最明顯的例子是列表和元組。使用array(深拷貝),asarray（淺拷貝）方法。

    # python列表創(chuàng)建數(shù)組
a = [1,2,3]
b = np.array(a)
b ---> array([1,2,3])
# python元組創(chuàng)建數(shù)組
c = (1,2,3)
d = np.array(c)
d ---> array([1,2,3])

  3. 內(nèi)在的numpy數(shù)組創(chuàng)建

    np.ones(shape, dtype=None, order='C')：創(chuàng)建一個填充了具有指定形狀的1值的數(shù)組。默認的dtype是float64。

    ones = np.ones((3,4))
ones ---> array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])
默認dtype('float64')

    np.zeros(shape, dtype=None, order='C'): 創(chuàng)建一個填充了具有指定形狀的0值的數(shù)組。默認的dtype是float64。

    zeros = np.zeros((3,4))
ones ---> array([[0., 0., 0., 0.],
       [0., 0., 0., 0.],
       [0., 0., 0., 0.]])
默認dtype('float64')

    np.arange(start,stop,step,dtype): 創(chuàng)建具有定期遞增值的數(shù)組。

    參數(shù) 描述
    start 起始值,默認為0
    stop 終止值（不包含)
    step 兩值的間隔,默認為1
    dtype 數(shù)據(jù)類型 
    arange = np.arange(10,20,2)
arange  --->array([10, 12, 14, 16, 18])

arange = np.arange(10,20,2,dtype=np.float64)
arange  --->array([10., 12., 14., 16., 18.])

    np.linspace(start, stop, num, endpoint, retstep, dtype): 創(chuàng)建具有指定數(shù)量元素的數(shù)組，并在指定的開始值和結(jié)束值之間平均間隔。

    參數(shù) 描述
    start 起始值
    stop 終止值,如果endpoint為True,包含stop值
    num 生成的等間隔樣例數(shù)量,默認50
    endpoint 是否包含stop值,默認True
    retstep 如果為True，返回樣例，以及連續(xù)數(shù)字之間的步長
    dtype 數(shù)據(jù)類型 
li = np.linspace(2,20,8)
li --->array([ 2.        ,  4.57142857,  7.14285714,  9.71428571, 12.28571429,
       14.85714286, 17.42857143, 20.        ])

li = np.linspace(2,20,8,retstep=True)
li --->(array([ 2.        ,  4.57142857,  7.14285714,  9.71428571, 12.28571429,
        14.85714286, 17.42857143, 20.        ]), 2.5714285714285716) # 包含樣例

np.logspace(start, stop, num, endpoint, base, dtype):此函數(shù)返回一個ndarray對象，其中包含在對數(shù)刻度上均勻分布的數(shù)字。 刻度的開始和結(jié)束端點是某個底數(shù)的冪，通常為 10。

參數(shù) 描述
start 起始值:base ** start
stop 終止值:base ** stop
num 生成的等間隔樣例數(shù)量,默認50
endpoint 是否包含stop值,默認True
base base對數(shù)空間的底數(shù),默認為10
dtype 數(shù)據(jù)類型 
# 對數(shù)空間為10
log_num = np.logspace(1,2,num=10)
log_num --->array([ 10.        ,  12.91549665,  16.68100537,  21.5443469 ,
        27.82559402,  35.93813664,  46.41588834,  59.94842503,
        77.42636827, 100.        ])
#對數(shù)空間為2
log_num = np.logspace(1,2,num=10, base=2)
log_num --->array([2.        , 2.16011948, 2.33305808, 2.5198421 , 2.72158   ,
       2.93946898, 3.1748021 , 3.42897593, 3.70349885, 4.        ])

  1. 通過使用字符串或緩沖區(qū)從原始字節(jié)創(chuàng)建數(shù)組

    np.frombuffer(buffer, dtype = float, count = -1, offset = 0):此函數(shù)將緩沖區(qū)解釋為一維數(shù)組。 暴露緩沖區(qū)接口的任何對象都用作參數(shù)來返回ndarray。

    參數(shù) 描述
    buffer 任何暴露緩沖區(qū)借口的對象
    dtype 返回數(shù)組的數(shù)據(jù)類型，默認為float
    count 需要讀取的數(shù)據(jù)數(shù)量，默認為-1，讀取所有數(shù)據(jù)
    offset offset 需要讀取的起始位置，默認為0 
    s =  b'Hello World' 
a = np.frombuffer(s, dtype =  'S1')  
a --->array([b'H', b'e', b'l', b'l', b'o', b' ', b'W', b'o', b'r', b'l', b'd'],
      dtype='|S1')

    np.fromiter(iterable, dtype, count = -1):此函數(shù)從任何可迭代對象構(gòu)建一個ndarray對象，返回一個新的一維數(shù)組。

    序號 參數(shù)及描述
    iterable 任何可迭代對象
    dtype 返回數(shù)組的數(shù)據(jù)類型
    count 需要讀取的數(shù)據(jù)數(shù)量，默認為-1，讀取所有數(shù)據(jù) 
    ls = range(5)
it = iter(ls)
x = np.fromiter(it, dtype='i1')
x --->array([0, 1, 2, 3, 4], dtype=int8)

  2. 使用特殊庫函數(shù)（例如，隨機random）

    使用np.random創(chuàng)建隨機數(shù)組。

    均勻分布

    np.random.rand(d0,d1,...,dn):根據(jù)給定的維度生成[0, 1)之間的隨機數(shù),dn每個維度, 若沒有參數(shù)，則生成一個數(shù).

    np.random.rand() #隨機生成一個數(shù)
#0.5726008714564191
np.random.rand(2) #隨機生成一個一維數(shù)組
#array([0.61949677, 0.06182977])
np.random.rand(3,2)
"""array([[0.73937337, 0.34386129],
       [0.89393313, 0.09146219],
       [0.97990048, 0.49450004]])"""

    np.random.randint(low,high=None,size=None,dtype='l'):生成取值區(qū)間為[low, high)的隨機整數(shù)，若沒有輸入?yún)?shù)high則取值區(qū)間為[0, low),

    low:最小值,

    high:最大值,

    size:數(shù)組維度大小，dtype:np.int

    np.random.randint(3,size=3) #生成3個[0,3)之間的整數(shù)
#array([2, 0, 1])
np.random.randint(1,5) #size=None,生成一個[1,5)之間隨機的一個整數(shù)
# 4
np.random.randint(1,5,size=(3,2)) #生成一個二維數(shù)組
"""array([[1, 3],
       [1, 2],
       [2, 4]])"""

    np.random.uniform(low=0.0, high=1.0, size=None) :生成取值區(qū)間為[low,high) 的浮點數(shù),默認取值范圍[0,1.0).

    low:最小值,float型,

    high:最大值，float型,

    size:數(shù)組維度大小，int型或tuple，

    沒有參數(shù)時，則生成一個數(shù)。

    np.random.uniform() #隨機生成一個0-1.0的隨機數(shù)
#0.1726402474971156
np.random.uniform(size=(3,2)) #隨機生成一個數(shù)據(jù)是0 - 1.0的二維數(shù)組
"""array([[0.72540688, 0.47681299],
       [0.90533783, 0.78988655],
       [0.47050509, 0.55306498]])"""
np.random.uniform(-1,1,size=10) #隨機生成一個-1 - 1 的10個數(shù)的一維數(shù)組
"""array([-0.42469769,  0.66898184,  0.12269022,  0.59821852, -0.47739708,
       -0.85804074,  0.2332269 , -0.18532177, -0.04431914,  0.25257431])"""

    正態(tài)分布

    [圖片上傳失敗...(image-343155-1673530550373)]

    np.random.randn(d0,d1,....,dn):從標準正態(tài)分布中返回一個(d0d1 …* dn)維樣本值.dn每個維度, 若沒有參數(shù)，則生成一個數(shù)

    np.random.randn() #隨機生成一個數(shù)
#-0.6828353877094375
np.random.randn(1) #隨機生成一個一維數(shù)組
#array([-0.27862247])
np.random.randn(3,2) #隨機二維數(shù)組的數(shù)組
"""array([[-1.22491603,  1.49204094],
       [-0.17640881, -0.81221251],
       [-0.66017166, -0.18555491]])"""

    np.random.normal(loc=0.0, scale=1.0, size=None): 從正態(tài)分布中返回樣本值.

    loc：float此概率分布的均值,對應(yīng)著整個分布的中心centre.

    scale：float此概率分布的標準差,對應(yīng)于分布的寬度，scale越大越矮胖，scale越小，越瘦高

    size：int or tuple

    輸出的shape，默認為None，只輸出一個值

    np.random.normal()#生成一個隨機數(shù)，size=None
#-0.11276293905334074
np.random.normal(size=1)#生成一個一維數(shù)組
#array([0.20337865])
np.random.normal(1,3,size=(3,2))
"""array([[4.58915271, 3.11798389],
       [3.04339931, 1.13752776],
       [1.64524515, 2.19528162]])
"""

    np.random.standard_normal(size=None):返回一個指定形狀的標準正態(tài)分布的數(shù)組

    np.random.standard_normal()#生成一個隨機數(shù)
#-1.0320902045776343
np.random.standard_normal((3,2))
"""array([[-0.32021508,  1.09101575],
       [ 0.79058298,  1.34311915],
       [ 0.80387764,  1.72679853]])"""

  3. 知識點補充

    1. 均勻分布

      是概率統(tǒng)計中的重要分布之一。是對稱概率分布，在相同長度間隔的分布概率是等可能的,均勻分布由兩個參數(shù)a和b定義，它們是數(shù)軸上的最小值和最大值，通?？s寫為U（a，b）。均勻分布在自然情況下極為罕見，而人工栽培的有一定株行距的植物群落即是均勻分布。

    2. 正態(tài)分布

      正態(tài)分布是一種概率分布。正態(tài)分布是具有兩個參數(shù)μ和σ的連續(xù)型隨機變量的分布，第一參數(shù)μ是服從正態(tài)分布的隨機變量的均值，第二個參數(shù)σ是此隨機變量的標準差，所以正態(tài)分布記作N(μ，σ )。

      μ決定了正態(tài)分布的位置，與μ越近，被取到的概率就越大，反之越小。σ描述的是正態(tài)分布的離散程度。σ越大，數(shù)據(jù)分布越分散曲線越扁平；σ越小，數(shù)據(jù)分布越集中曲線越陡峭。[圖片上傳失敗...(image-b3e108-1673530550374)]

      1. 標準差

        在概率統(tǒng)計中最常使用作為統(tǒng)計分布程度（statisticaldispersion）上的測量。標準差定義是總體各單位標準值與其平均數(shù)離差平方的算術(shù)平均數(shù)的平方根。它反映組內(nèi)個體間的離散程度。簡單來說，標準差是一組數(shù)據(jù)平均值分散程度的一種度量。一個較大的標準差，代表大部分數(shù)值和其平均值之間差異較大；一個較小的標準差，代表這些數(shù)值較接近平均值。

        [圖片上傳失敗...(image-5bdce7-1673530550374)]

      2. 方差

        在概率論和統(tǒng)計方差衡量隨機變量或一組數(shù)據(jù)時離散程度的度量。概率論中方差用來度量隨機變量和其數(shù)學期望（即均值）之間的偏離程度。統(tǒng)計中的方差（樣本方差）是各個數(shù)據(jù)分別與其平均數(shù)之差的平方的和的平均數(shù)

        [圖片上傳失敗...(image-93fe36-1673530550374)][圖片上傳失敗...(image-435df9-1673530550374)]

  4. 案例

    隨機生成5組不同日期產(chǎn)品的內(nèi)徑尺寸(mm),一組10個產(chǎn)品。

    數(shù)量:5*10=50

    隨機生成產(chǎn)品內(nèi)徑尺寸，服從正態(tài)分布,均值25，方差0.2

    insider_dimension = np.random.normal(25,0.2,size=(5,10))
insider_dimension
"""array([[24.77932034, 25.09216143, 24.98151027, 25.25425569, 25.06858384,
        24.80284698, 25.36932156, 24.89354909, 24.97998914, 24.95034899],
       [25.36538522, 24.90967666, 24.89776366, 24.99716099, 25.19111566,
        24.95791022, 25.17159946, 24.88894164, 25.2616871 , 24.72602432],
       [24.8335387 , 24.94511824, 25.234648  , 25.02720878, 24.67977384,
        25.39512587, 24.83408903, 24.9939906 , 25.03388191, 25.2789348 ],
       [24.70520956, 24.95986831, 24.61549957, 24.90316804, 25.1648354 ,
        24.82632398, 25.03309053, 24.68034673, 25.27200361, 24.98097997],
       [25.29596002, 24.95591159, 25.38686463, 24.9376919 , 25.04607681,
        25.02220415, 24.99493607, 25.00036926, 25.11806958, 24.77333334]])
"""

Numpy數(shù)組形狀和類型修改

  1. np.reshape(a,newshape,order='C'):原數(shù)組size不變的前提下，改變原數(shù)組的形狀

    參數(shù) 描述
    a array_like要重新整形的數(shù)組
    newshape int或int的tuple ，新的形狀應(yīng)該和原始形狀兼容如果是整數(shù)，則結(jié)果將是該長度的1-D數(shù)組。一個形狀維度可以是-1。在這種情況下，從數(shù)組的長度和其余維度推斷該值
    order {'C', 'F', 'A'} 'C' -- 按行，'F' -- 按列，'A' -- 原順序。

    ndarray.reshape(shape,order='C')：原數(shù)組size不變的前提下,返回包含具有新形狀的相同數(shù)據(jù)的數(shù)組,與自由函數(shù)不同np.reshape，此方法ndarray允許將shape參數(shù)的元素作為單獨的參數(shù)傳遞。

    #ndarray.reshape方法
#隨機生成一個數(shù)組
arr1 = np.random.rand(3,4)
""" 
array([[0.40919593, 0.53439411, 0.17478334, 0.88506119],
       [0.52465668, 0.40275561, 0.85389365, 0.69344744],
       [0.06308938, 0.24195379, 0.43457003, 0.5855962 ]])
"""
print(arr2.reshape(2,6)) #默認按行
"""
[[0.40919593 0.53439411 0.17478334 0.88506119 0.52465668 0.40275561]
 [0.85389365 0.69344744 0.06308938 0.24195379 0.43457003 0.5855962 ]]
 """
print(arr2.reshape(6,2,order='F')) #按列
"""
[[0.40919593 0.17478334]
 [0.52465668 0.85389365]
 [0.06308938 0.43457003]
 [0.53439411 0.88506119]
 [0.40275561 0.69344744]
 [0.24195379 0.5855962 ]]
"""

# np.reshape函數(shù)
np.reshape(arr2,(-1,3)) # -1從數(shù)組的長度和其余維度推斷該值
"""
array([[0.40919593, 0.53439411, 0.17478334],
       [0.88506119, 0.52465668, 0.40275561],
       [0.85389365, 0.69344744, 0.06308938],
       [0.24195379, 0.43457003, 0.5855962 ]])
"""
#在轉(zhuǎn)換形狀的時候，一定要注意元素的個數(shù)，不能發(fā)生改變！

  2. np.resize(a,new_shape):改變原數(shù)組的形狀和大小，與reshape不同的是可以改變數(shù)組的size。如果新數(shù)組大于原始數(shù)組，則新數(shù)組將填充a的重復(fù)副本。

    參數(shù) 描述
    a array_like要重新整形的數(shù)組
    new_shape int或int的tuple

    ndarray.resize(new_shape):就地更改數(shù)組的形狀和大小，會對原值進行修改并且返回的是None

    #ndarray.resize
#縮小數(shù)組
a = np.array([[0, 1], [2, 3]])
a.resize(2,1)
"""
array([[0],
       [1]])
       """
#擴展數(shù)組 缺少的數(shù)據(jù)用 0 填充
b = np.array([[0, 1], [2, 3]])
b.resize(2,3)
"""
array([[0, 1, 2],
       [3, 0, 0]])
"""

#np.resize
#縮小數(shù)組
a=np.array([[0,1],[2,3]])
np.resize(a(1,2))
# array([[0, 1]])  a的值沒有變化

#擴展數(shù)組 缺少的數(shù)據(jù)將由填充原數(shù)組的重復(fù)副本
b=np.array([[0,1],[2,3]])
np.resize(b,(3,3))
"""
array([[0, 1, 2],
       [3, 0, 1],
       [2, 3, 0]])
"""

  3. .T:將原shape為（n，m）的數(shù)組轉(zhuǎn)置為（m，n），把數(shù)組的行和列進行互換，一維數(shù)組轉(zhuǎn)置不變。

    arr3 = np.arange(12).reshape(3,4)
arr3.T
"""
array([[ 0,  4,  8],
       [ 1,  5,  9],
       [ 2,  6, 10],
       [ 3,  7, 11]])
"""

  4. ndarray.astype(type):強制轉(zhuǎn)換為指定的類型。

    one = np.ones((3,4))
one
"""
array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])
"""
one.dtype
#dtype('float64')
one.astype(np.int64)
"""
array([[1, 1, 1, 1],
       [1, 1, 1, 1],
       [1, 1, 1, 1]], dtype=int64)
"""
n1 = np.array(['1','2','3'],dtype=np.string_)
n1.astype(np.int64)
#array([1, 2, 3], dtype=int64)

#如果將浮點數(shù)轉(zhuǎn)為整數(shù),那么小數(shù)部分會被截斷
n2 = np.random.uniform(1,5,size=(3,4))
n2
"""
array([[2.54847297, 1.47540363, 3.19716644, 2.88852565],
       [4.35936498, 4.14153717, 4.28468383, 2.98894034],
       [3.34067248, 2.73983194, 4.21287495, 1.30903491]])
"""
n2.astype(np.int64)
"""
array([[2, 1, 3, 2],
       [4, 4, 4, 2],
       [3, 2, 4, 1]], dtype=int64)
"""

Numpy數(shù)組基本索引與切片

  1. ndarray對象的內(nèi)容可以通過索引或切片來獲取和修改，就像 Python 的內(nèi)置容器對象一樣。

  2. 一維數(shù)組:一維數(shù)組比較簡單,看起來和python列表很類似。

    a = np.arange(10)
a ---> array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
#索引
a[0] --->0
a[-1] --->9
#切片
a[2:5] --->array([2, 3, 4])
a[1::2] --->array([1, 3, 5, 7, 9])  #切片參數(shù)(start:stop:step)不包括終止索引
#賦值
a[2:5]=88 --->array([ 0,  1, 88, 88, 88,  5,  6,  7,  8,  9])
#copy
#淺copy
b = a[2:5]
b[:] = 666
a ---> array([  0,   1, 666, 666, 666,   5,   6,   7,   8,   9])
#深copy
c = a[2:5].copy()
c[:] = 888
a --->array([  0,   1, 666, 666, 666,   5,   6,   7,   8,   9])

    深copy新建一個對象重新分配內(nèi)存地址，復(fù)制對象內(nèi)容。淺copy不重新分配內(nèi)存地址，內(nèi)容指向之前的內(nèi)存地址。淺copy如果對象中有引用其他的對象，如果對這個子對象進行修改，子對象的內(nèi)容就會發(fā)生更改。

    數(shù)組的切片是原數(shù)組的視圖，數(shù)據(jù)并不是被復(fù)制，任何對于視圖的修改都會反映到原數(shù)組，想要復(fù)制數(shù)組的切片必須顯示地復(fù)制這個數(shù)組，使用copy()函數(shù)

  3. 二維數(shù)組:每個索引值對應(yīng)的元素不在是一個值，而是一個一維數(shù)組

    arr1 = np.array([[1,2,3],[4,5,6],[7,8,9]])
#索引
arr1[1] --->array([4, 5, 6]) #獲取的一個一維數(shù)組
arr1[1][1] ---> 5 #通過遞歸的方式。獲取一個值，第一個索引獲取到一維數(shù)組，第二個索引獲取到值
arr1[1, 1] ---> 5 #使用逗號,分割列表去獲取單個元素

#切片
arr1[:2] --->array([[1, 2, 3],
       [4, 5, 6]])  # 數(shù)組沿著行進行切片
arr1[:2, :2] ---> array([[1, 2],
       [4, 5]]) #多組切片 獲取前兩行前兩列
arr1[:,:1] --->array([[1],
       [4],
       [7]]) #選取第一列 ，單獨一個: 獲取整個軸的數(shù)組

#切片和索引混合，可以得到低緯度的切片(數(shù)組降維)
arr1[1,:2] --->array([4, 5]) #選取第二行,前兩列
arr1[:2,0] --->array([1, 4]) #選取第二列，前兩行

  4. 多維數(shù)組

    arr2=np.array([[[1,2,3],[4,5,6]], [[7,8,9],[10,11,12]]])
"""
array([[[ 1,  2,  3],
        [ 4,  5,  6]],

       [[ 7,  8,  9],
        [10, 11, 12]],

       [[13, 14, 15],
        [16, 17, 18]]])"""
#索引
arr2[0] --->array([[1, 2, 3],
       [4, 5, 6]]) #獲得一個二維數(shù)組 獲取第1層
arr2[0,0] --->array([1, 2, 3]) #獲得一個一維數(shù)組 獲取第1層的第1行
arr2[0,0,0] ---> 1 #獲得一個值

#切片
arr2[:2] ---> array([[[ 1,  2,  3],
        [ 4,  5,  6]],

       [[ 7,  8,  9],
        [10, 11, 12]]]) # 獲取前兩層
arr2[:2,:1] --->array([[[1, 2, 3]],

       [[7, 8, 9]]]) # 獲取前兩層，第一行
arr2[:2,:1,:2] --->array([[[1, 2]],

       [[7, 8]]]) # 獲取前兩層的，第一行的前兩列

#切片和索引
arr2[:,1] --->array([[ 4,  5,  6],
       [10, 11, 12],
       [16, 17, 18]]) # 獲取所有層的第二行
arr2[:,1,1] --->array([ 5, 11, 17]) #獲取所有層的第2行的第2列
arr2[:2,:2,2] --->array([[ 3,  6],
       [ 9, 12]]) #獲取所有層的前2行的第3列

Numpy數(shù)組廣播

  1. 廣播:廣播描述了算法如何在不同形狀的數(shù)組之間的運算。

  2. Numpy數(shù)組算術(shù)

    arr1 = np.random.randint(10,size=(3,4))
arr1
"""
array([[2, 1, 0, 0],
       [9, 5, 1, 7],
       [8, 1, 5, 4]])
"""

arr1 * 2  #最簡單的廣播，標量和數(shù)組組合,標量值2，被廣播給乘法運算中的所有其他元素
"""
array([[ 4,  2,  0,  0],
       [18, 10,  2, 14],
       [16,  2, 10,  8]])
"""

arr1 * arr1 #相同尺寸的數(shù)組運算
"""
array([[ 4,  1,  0,  0],
       [81, 25,  1, 49],
       [64,  1, 25, 16]])
"""

#在前面邏輯運算的時候我們已經(jīng)講過了，同尺寸的數(shù)組可以比較，得到的是一個布爾數(shù)組

  3. 廣播的規(guī)則:對于每個結(jié)尾維度(從尾部開始),軸的長度都匹配或者相對應(yīng)的軸一方長度是1，那么則認為可以兼容廣播的，廣播會在丟失的或在長度為1的軸上進行。

    arr1 = np.arange(12).reshape(4,3)
arr1
"""
array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 9, 10, 11]])
"""

arr2 = np.array([1,2,3])
arr2
"""
array([1, 2, 3])
"""

arr3 = arr1 + arr2
arr3
"""
array([[ 1,  3,  5],
       [ 4,  6,  8],
       [ 7,  9, 11],
       [10, 12, 14]])
"""

arr1.shape
(4,3)
arr2.shape
(3,)
#滿足我們廣播規(guī)則,從尾部開始軸的長度匹配,廣播是兼容的,廣播在丟失的軸上進行。
#案例中丟失的是0軸,按'列'進行廣播，一維數(shù)組沿0軸進行廣播


    arr4 = np.arange(1,5).reshape(4,1)
arr4
"""
array([[1],
       [2],
       [3],
       [4]])
"""
arr5 = arr1+arr4
arr5
"""
array([[ 1,  2,  3],
       [ 5,  6,  7],
       [ 9, 10, 11],
       [13, 14, 15]])
"""
arr1,shape
(4,3)
arr5.shape
(4,1)
#滿足廣播規(guī)則,從尾部開始，軸的長度一方為1,廣播在缺失的軸上進行廣播
#案例中丟失的是1軸,按'行'進行廣播沿著軸1對二維數(shù)組進行廣播

    [圖片上傳失敗...(image-63eed1-1673530550374)]

[圖片上傳失敗...(image-5b3114-1673530550374)]

[圖片上傳失敗...(image-94401b-1673530550374)]

總結(jié)

  1. 操作兩個數(shù)組，先比較數(shù)組的shape：a.維度相等，b.相對應(yīng)的軸長度為1

  2. 所有輸入數(shù)組都向其中shape最長的數(shù)組看齊，shape中不足的部分都通過在前面加1補齊

  3. 輸出數(shù)組的shape是輸入數(shù)組shape的各個軸上的最大值

Numpy排序和唯一值

  1. sort():排序,和python列表類型類似,Numpy數(shù)組可以使用sort方法排序

    #一維數(shù)組
arr1 = np.random.randn(6)
arr1
"""
array([[18, 21],
       [30, 30],
       [18, 24],
"""
#sort方法進行排序
arr1.sort()
arr1
"""
array([-1.68364397, -1.17897152, -1.10061833, -0.80371391, -0.23651728,
        0.51205633])
"""

#二維
arr2 = np.random.randn(4,3)
arr2
"""
array([[ 0.25385474,  0.37914431,  0.57455817],
       [ 0.72876383,  0.16524266,  2.00815275],
       [ 1.03371677,  1.650364  ,  0.00470761],
       [-1.42358426,  0.89041625, -2.15399045]])
"""
arr2.sort()#默認按行
"""
array([[ 0.25385474,  0.37914431,  0.57455817],
       [ 0.16524266,  0.72876383,  2.00815275],
       [ 0.00470761,  1.03371677,  1.650364  ],
       [-2.15399045, -1.42358426,  0.89041625]])
"""
arr2.sort(axis=0) #指定0軸
arr2
"""
array([[-2.15399045, -1.42358426,  0.57455817],
       [ 0.00470761,  0.37914431,  0.89041625],
       [ 0.16524266,  0.72876383,  1.650364  ],
       [ 0.25385474,  1.03371677,  2.00815275]])
"""
#對于多維數(shù)組可以指定axis值，沿著軸對每一個一維數(shù)據(jù)進行排序

  2. np.unique:返回的是數(shù)組中唯一值排序后的數(shù)組

    arr3 = np.array([1,2,3,1,2,3])
arr3
# array([1, 2, 3, 1, 2, 3])

np.unique(arr3)
#array([1, 2, 3])

arr4 = np.array([[1,2,3],[2,3,4]])
np.unique(arr4)
#array([1, 2, 3, 4])

  3. np.in1d:檢查一個數(shù)組中的值是否在另外一個數(shù)組中，并返回一個布爾數(shù)組.

    np.in1d(arr3,[1,2])
#array([ True,  True, False,  True,  True, False])
np.in1d(arr4,[1,3])
#array([ True, False,  True, False,  True, False])

Numpy矩陣乘法

  1. 場景：

    #模擬6位學生成績（平時成績0.3和期末成績0.7）,求總成績
arr1 = np.random.randint(80,100,size=(6,2))
arr1
"""
array([[88, 91],
       [95, 82],
       [87, 82],
       [97, 97],
       [99, 82],
       [99, 94]])
"""
arr2 =  np.array([0.3,0.7])
arr2
"""
array([0.3, 0.7])
"""
arr1 * arr2 #不符合我們需求
"""
array([[26.4, 63.7],
       [28.5, 57.4],
       [26.1, 57.4],
       [29.1, 67.9],
       [29.7, 57.4],
       [29.7, 65.8]])
"""
arr3 = np.array([[0.3],[0.7]])
"""
array([[0.3],
       [0.7]])
"""
arr1*arr3  #不滿足我們數(shù)組的廣播

#那怎么求了？矩陣乘法

  2. 矩陣:矩陣和array的區(qū)別,矩陣必須是二維的,但是array可以是多維

    np.mat():將數(shù)組類型轉(zhuǎn)化為矩陣類型

    np.mat(arr1)
"""
matrix([[88, 91],
        [95, 82],
        [87, 82],
        [97, 97],
        [99, 82],
        [99, 94]])
"""

  3. 矩陣乘法

    (m,p) * (p,n) = (m,n)

    [圖片上傳失敗...(image-2b1609-1673530550374)]

  4. np.dot()：

    np.dot(arr1,arr3)
"""
array([[90.1],
       [85.9],
       [83.5],
       [97. ],
       [87.1],
       [95.5]])
"""

  5. 案例:

    """矩陣A：某公司有四個工廠，分布在不同地區(qū)，同時三種產(chǎn)品，產(chǎn)量（單位；t）,矩陣B：第一列表示三種產(chǎn)品的單件利潤，第二列表示三種產(chǎn)品的單件體積。求工廠利潤和四個工廠產(chǎn)品體積"""
arr1 = np.random.randint(1,5,size=(4,3))
arr1
#四個工廠，三種產(chǎn)品，四行分別代表四個工廠，三列分別代表三種產(chǎn)品的產(chǎn)量
"""
array([[3, 3, 1],
       [4, 2, 4],
       [2, 4, 2],
       [2, 3, 1]])
"""
arr2 = np.random.randint(1,5,size=(3,2))
arr2
"""
array([[4, 3],
       [1, 3],
       [3, 3]])
"""

np.dot(arr1,arr2)
"""
array([[18, 21],
       [30, 30],
       [18, 24],
       [14, 18]])
"""

  6. 邏輯運算

    1. 比較運算符 >, >=, <, <=, ==, != ，比較運算符，返回的是一個布爾數(shù)組。

    2. 邏輯運算符與:&, 或:|,非:~

    3. 二元通用函數(shù)與:logical_and, 或:logical_or, 非:lodical_not

      #比較運算符
#向量化
arr1 = np.random.randn(4,3)
arr1
"""
array([[-0.11644283,  0.26881624, -0.636891  ],
       [ 0.41491463,  0.75958032, -0.79139132],
       [-0.65056162, -1.65086047,  0.30840633],
       [ 0.44048015,  2.60792486, -1.2136428 ]])
"""
arr1 < 1
"""
array([[ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True],
       [ True, False,  True]])
"""
#數(shù)組與數(shù)組比較
arr2 = np.random.randn(4,3)
arr2
"""
array([[ 1.07975731,  0.48405982,  0.83102948],
       [ 0.25161364, -0.84813959,  0.30692867],
       [ 0.67593645,  2.11885395,  0.52587073],
       [-0.82323498,  0.87254439, -0.55737282]])
"""
arr1 > arr2
"""
array([[False, False, False],
       [ True,  True, False],
       [False, False, False],
       [ True,  True, False]])
"""

      #邏輯運算符
(arr1>-0.5) & (arr1<0.5)
"""
array([[ True,  True, False],
       [ True, False, False],
       [False, False,  True],
       [ True, False, False]])
"""
(arr1>-0.5) | (arr1<0.5)
"""
array([[ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True]])
"""
~(arr1>0)
"""
array([[ True, False,  True],
       [False, False,  True],
       [ True,  True, False],
       [False, False,  True]])
"""

      #二元通用函數(shù)
np.logical_and(arr1>-0.5 , arr1<0.5)
"""
array([[ True,  True, False],
       [ True, False, False],
       [False, False,  True],
       [ True, False, False]])
"""
np.logical_or(arr1>-0.5 , arr1<0.5)
"""
array([[ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True]])
"""
np.logical_not(arr1>-0.5)
"""
array([[False, False,  True],
       [False, False,  True],
       [ True,  True, False],
       [False, False,  True]])
"""

  7. np.where(condition, x, y):是三元表達式 x if condition else y的向量化。如果是True,輸出x,相反,False，輸出y。傳遞給np.where的數(shù)組可以是同等大小的數(shù)組，也可以是標量。

    #1.
np.where([[True,False], [True,True]],   #condition
             [[1,2], [3,4]],            #x
             [[9,8], [7,6]])            #y
"""
array([[1, 8],
       [3, 4]])
"""
# 2.
np.where(arr1>0) #只有條件 (condition)，沒有x和y，則輸出滿足條件 (即非0) 元素的坐標。這里的坐標以tuple的形式給出，通常原數(shù)組有多少維，輸出的tuple中就包含幾個數(shù)組，分別對應(yīng)符合條件元素的各維坐標。
"""
(array([0, 1, 1, 2, 3, 3], dtype=int64),
 array([1, 0, 1, 2, 0, 1], dtype=int64))
"""
# 3. 典型用法,標量和數(shù)組聯(lián)合，進行值的替換
np.where(arr1>0,1,-1)
"""
array([[-1,  1, -1],
       [ 1,  1, -1],
       [-1, -1,  1],
       [ 1,  1, -1]])
"""

  8. any(),all()方法: 這兩個方法可以快速檢查布爾數(shù)組,any():檢查數(shù)組中是否至少有一個True, all():檢查是否每個值都為True.

    (arr1 <1).sum() # True的個數(shù)
11

(arr1<1).any()
True

np.all((arr1<1))
False
# 這兩個方法同時也可以適用于非布爾數(shù)組，非0的 元素就會按True處理

Numpy數(shù)組合并,分割,元素重復(fù)

  1. np.concatenate

    arr1 = np.arange(1,7).reshape(2,3)
arr1
"""
array([[1, 2, 3],
       [4, 5, 6]])
"""

arr2 = np.arange(7,13).reshape(2,3)
arr2
"""
array([[ 7,  8,  9],
       [10, 11, 12]])
"""

np.concatenate((arr1,arr2)) #默認axis=0
"""
array([[ 1,  2,  3],
       [ 4,  5,  6],
       [ 7,  8,  9],
       [10, 11, 12]])
"""
np.concatenate((arr1,arr2),axis=1) #指定axis=1
"""
array([[ 1,  2,  3,  7,  8,  9],
       [ 4,  5,  6, 10, 11, 12]])
"""

  2. np.vstack

    np.vstack((arr1,arr2)) #沿著軸0合并數(shù)組
"""
array([[ 1,  2,  3],
       [ 4,  5,  6],
       [ 7,  8,  9],
       [10, 11, 12]])
"""

  3. np.hstack

    np.hstack((arr1,arr2))  #沿著軸1合并數(shù)組
"""
array([[ 1,  2,  3,  7,  8,  9],
       [ 4,  5,  6, 10, 11, 12]])
"""

  4. np.split

    arr3 = np.random.randn(5,3)
arr3
"""
array([[-1.62753568,  0.09844282,  0.24826172],
       [-0.51082413,  1.02423446, -0.82945161],
       [ 0.68448996,  0.1510686 ,  1.25115637],
       [ 1.68088646,  0.35070315, -0.74911414],
       [ 1.05348859,  1.28620817,  0.1522841 ]])
"""
np.split(arr3,[1,3]) #默認按 0軸分割， [1,3]表示數(shù)組拆分時，按索引位置拆分
"""
[array([[-1.62753568,  0.09844282,  0.24826172]]),
 array([[-0.51082413,  1.02423446, -0.82945161],
        [ 0.68448996,  0.1510686 ,  1.25115637]]),
 array([[ 1.68088646,  0.35070315, -0.74911414],
        [ 1.05348859,  1.28620817,  0.1522841 ]])]
"""

np.split(arr3,[1,2],axis=1) #指定1軸分割
"""
[array([[-1.62753568],
        [-0.51082413],
        [ 0.68448996],
        [ 1.68088646],
        [ 1.05348859]]), array([[0.09844282],
        [1.02423446],
        [0.1510686 ],
        [0.35070315],
        [1.28620817]]), array([[ 0.24826172],
        [-0.82945161],
        [ 1.25115637],
        [-0.74911414],
        [ 0.1522841 ]])]
"""
np.split(arr3,5) # 5表示把數(shù)組分割成5組，只能是均等分割
"""
[array([[-1.62753568,  0.09844282,  0.24826172]]),
 array([[-0.51082413,  1.02423446, -0.82945161]]),
 array([[0.68448996, 0.1510686 , 1.25115637]]),
 array([[ 1.68088646,  0.35070315, -0.74911414]]),
 array([[1.05348859, 1.28620817, 0.1522841 ]])]
"""
#ValueError: array split does not result in an equal division,不是均等分割報這個錯

  5. np.array_split:和split的區(qū)別是，可以不均等分割

    np.array_split(arr3,3) 
"""
[array([[-1.62753568,  0.09844282,  0.24826172],
        [-0.51082413,  1.02423446, -0.82945161]]),
 array([[ 0.68448996,  0.1510686 ,  1.25115637],
        [ 1.68088646,  0.35070315, -0.74911414]]),
 array([[1.05348859, 1.28620817, 0.1522841 ]])]
"""

  6. np.hsplit

    np.hsplit(arr3,[1,2])
"""
[array([[-1.62753568],
        [-0.51082413],
        [ 0.68448996],
        [ 1.68088646],
        [ 1.05348859]]), array([[0.09844282],
        [1.02423446],
        [0.1510686 ],
        [0.35070315],
        [1.28620817]]), array([[ 0.24826172],
        [-0.82945161],
        [ 1.25115637],
        [-0.74911414],
        [ 0.1522841 ]])]
 """

  7. np.vsplit

    np.vsplit(arr3,[1,3])
"""
[array([[-1.62753568,  0.09844282,  0.24826172]]),
 array([[-0.51082413,  1.02423446, -0.82945161],
        [ 0.68448996,  0.1510686 ,  1.25115637]]),
 array([[ 1.68088646,  0.35070315, -0.74911414],
        [ 1.05348859,  1.28620817,  0.1522841 ]])]
"""

  8. repeat：按照給定的次數(shù)，對數(shù)組的元素進行復(fù)制

    arr = np.arange(3)
a = arr.repeat(3) #傳入一個整數(shù),元素重復(fù)相應(yīng)的次數(shù)
a
#array([0, 0, 0, 1, 1, 1, 2, 2, 2])
b = arr.repeat([2,2,3]) #傳入一個整數(shù)數(shù)組,每個元素會重復(fù)相應(yīng)的不同次數(shù)
b
#array([0, 0, 1, 1, 2, 2, 2]) 

#多維
arr = np.random.rand(4,3)
arr
"""
array([[0.43173965, 0.26514662, 0.77984414],
       [0.13906945, 0.25396541, 0.77220584],
       [0.57093281, 0.97762641, 0.68158357],
       [0.7133476 , 0.32654828, 0.02919563]])
"""

arr.repeat(2,axis=0) #指定軸0，也可以指定軸1
"""
array([[0.43173965, 0.26514662, 0.77984414],
       [0.43173965, 0.26514662, 0.77984414],
       [0.13906945, 0.25396541, 0.77220584],
       [0.13906945, 0.25396541, 0.77220584],
       [0.57093281, 0.97762641, 0.68158357],
       [0.57093281, 0.97762641, 0.68158357],
       [0.7133476 , 0.32654828, 0.02919563],
       [0.7133476 , 0.32654828, 0.02919563]])
"""

arr.repeat([1,2,3,4],axis=0) #傳入整數(shù)數(shù)組,整數(shù)數(shù)組長度要和軸的長度匹配
"""
array([[0.43173965, 0.26514662, 0.77984414],
       [0.13906945, 0.25396541, 0.77220584],
       [0.13906945, 0.25396541, 0.77220584],
       [0.57093281, 0.97762641, 0.68158357],
       [0.57093281, 0.97762641, 0.68158357],
       [0.57093281, 0.97762641, 0.68158357],
       [0.7133476 , 0.32654828, 0.02919563],
       [0.7133476 , 0.32654828, 0.02919563],
       [0.7133476 , 0.32654828, 0.02919563],
       [0.7133476 , 0.32654828, 0.02919563]])
"""

arr.repeat([1,2,3],axis=1)
"""
array([[0.43173965, 0.26514662, 0.26514662, 0.77984414, 0.77984414,
        0.77984414],
       [0.13906945, 0.25396541, 0.25396541, 0.77220584, 0.77220584,
        0.77220584],
       [0.57093281, 0.97762641, 0.97762641, 0.68158357, 0.68158357,
        0.68158357],
       [0.7133476 , 0.32654828, 0.32654828, 0.02919563, 0.02919563,
        0.02919563]])
"""

Numpy數(shù)學統(tǒng)計運算

基礎(chǔ)數(shù)組統(tǒng)計方法

方法 描述
sum 總和
mean 平均數(shù)
std 標準差
var 方差
min 最小值
max 最大值
argmin 最小值的位置
argmax 最大值的位置 
#我們可以調(diào)用實例方法,也可以使用頂層的Numpy函數(shù),
arr2 = np.random.randn(4,3)
arr2
"""
array([[ 1.15329974,  2.02817106, -0.12567425],
       [-1.30186382,  0.71690951,  1.42288858],
       [ 0.31400007, -1.16320146,  1.48839135],
       [ 0.34372291, -0.87491238, -1.53228751]])
"""
arr2.sum() #np.sum(arr2)
#2.4694438093171573
arr2.mean()
# 0.20578698410976312
np.argmin(arr2)
# 11
arr2.argmax()
# 1

#指定軸進行運算
#axis:參數(shù)用于計算給定軸的統(tǒng)計值,形成一個下降一維度的數(shù)組
# axis=1按行 axis=0按列
arr2.max(axis=1)
#array([2.02817106, 1.42288858, 1.48839135, 0.34372291])
arr2.max(axis=0)
#array([1.15329974, 2.02817106, 1.48839135])
np.argmin(arr2,axis=1)
#array([2, 0, 1, 2], dtype=int64)
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容