亚洲在线久爱草,狠狠天天香蕉网,天天搞日日干久草,伊人亚洲日本欧美

數組的讀取

一、load()函數

讀取“.npy”和“.npz”文件中的數組

numpy.load(file,mmap_mode,allow_pickle,fix_imports)

mmap_mode表示內存的映射模式，即在讀取較大的NumPy數組時的模式，默認情況下是None

二、代碼練習

import numpy as np

a2 = np.load("array_save.npy")

print(a2)

print("------------------------------")

arr = np.load('array_savez.npz')

print(arr['array_a1'])

print("------------------------------")

print(arr['array_a2'])

print("------------------------------")

print(arr['array_a3'])

print("------------------------------")

arr1 = np.load('array_savez_compressed.npz')

print(arr1['array_a1'])

print("------------------------------")

print(arr1['array_a2'])

print("------------------------------")

print(arr1['array_a3'])

數組的保存

一、save()函數

該函數可以將一個數組保存至后綴名為“.npy”的二進制文件中

numpy.save(file,arr,allow_pickle=True,fix_imports=True)

file表示文件名/文件路徑

arr表示要存儲的數組

allow_pickle為布爾值，表示是否允許使用pickle來保存數組對象

fix_imports為布爾值，表示是否允許在Pyhton2中讀取Python3保存的數據

二、savez()函數

該函數可以將多個數組保存到未壓縮的后綴名未“.npz”的二進制文件中?

numpy.savez(file,array_a1=a1,array_a2=a2,...array_an)

file表示文件名/文件路徑

array_a1=a1,array_a2=a2,...array_an表示需要儲存的多個數組

三、savez_compressed()函數

該函數可以將多個數組保存到壓縮的后綴名為“.npz”的二進制文件中

numpy.savez_compressed(file)

file表示文件名/文件路徑

四、代碼練習

import numpy as np

# %% save()

a2 = np.array([[1,2,3],

? ? ? ? ? ? ? ?[4,5,6],

? ? ? ? ? ? ? ?[7,8,9]])

np.save("array_save", a2)

# %% savez()

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

a2 = np.array([[4,5,6],

? ? ? ? ? ? ? ?[7,8,9]])

a3 = np.array([10,11,12])

np.savez("array_savez",array_a1=a1,array_a2=a2,array_a3=a3)

# %% savez_compressed()

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

a2 = np.array([[4,5,6],

? ? ? ? ? ? ? ?[7,8,9]])

a3 = np.array([10,11,12])

np.savez_compressed("array_savez_compressed",array_a1=a1,array_a2=a2,array_a3=a3)

聚合函數

一、求和

1、使用Numpy中sum()函數

numpy.sum(a,axis=None

2、使用Numpy中nansum()函數，該函數忽略NaN

numpy.nansum(a,axis=None)

3、使用數組對象的sum()方法

numpy.ndarray.sum(axis=None)

二、求最大值

1、使用NumPy中amax()函數

numpy.amax(a,axis=None)

2、使用NumPy中nanmax()函數，該函數忽略NaN

numpy.nanmax(a,axis=Nome)

3、使用數組對象的max()方法

numpy.naarray.max(axis=None)

三、求最小值

1、使用NumPy中amin()函數

numpy.amin(a,axis=None)

2、使用NumPy中nanmin()函數，該函數忽略NaN

numpy.nanmin(a,axis=Nome)

3、使用數組對象的min()方法

numpy.naarray.min(axis=None)

四、求平均值

1、使用NumPy中mean()函數

numpy.mean(a,axis=None)

2、使用NumPy中nanmean()函數，該函數忽略NaN

numpy.nanmean(a,axis=Nome)

3、使用數組對象的mean()方法

numpy.naarray.mean(axis=None)

五、求加權平均值

1、使用NumPy中average()函數

numpy.average(a,axis=None,weights=None)

weights表示權重

六、代碼練習

import numpy as np

# %% 求和

a1 = np.array([[1,2],

? ? ? ? ? ? ? ?[3,4]])

print(np.sum(a1))

print(np.sum(a1,axis=1))

print(a1.sum(axis=1))

print("-------------------------")

a2 = np.array([[1,2],

? ? ? ? ? ? ? ?[3,np.nan]])

print(np.nansum(a2))

print(np.nansum(a2,axis=1))

# %% 求最大值

a1 = np.array([[1,2],

? ? ? ? ? ? ? ?[3,4]])

print(np.amax(a1))

print(np.amax(a1,axis=1))

print(a1.max(axis=1))

print("--------------------------")

a1 = np.array([[1,2],

? ? ? ? ? ? ? ?[np.nan,4]])

print(np.nanmax(a1))

print(np.nanmax(a1,axis=1))

# %% 求最小值

a1 = np.array([[1,2],

? ? ? ? ? ? ? ?[3,4]])

print(np.amin(a1))

print(np.amin(a1,axis=1))

print(a1.min(axis=0))

print("---------------------------")

a1 = np.array([[1,np.nan],

? ? ? ? ? ? ? ?[3,4]])

print(np.nanmin(a1))

print(np.nanmin(a1,axis=1))

# %% 求平均值

a1 = np.array([[1,2],

? ? ? ? ? ? ? ?[3,4]])

print(np.mean(a1))

print(np.mean(a1,axis=1))

print(a1.mean(axis=0))

print("------------------------------")

a1 = np.array([[np.nan,2],

? ? ? ? ? ? ? ?[3,4]])

print(np.nanmean(a1))

print(np.nanmean(a1,axis=0))

# %% 求加權平均值

a1 = np.array([[1,2],

? ? ? ? ? ? ? ?[3,4]])

print(np.mean(a1))

print(np.average(a1,weights=[[0.4,0.2],[0.2,0.2]]))

排序函數

一、sort()函數

1、按照軸對數組進行排序，即軸排序

numpy.sort(a,axis=-1,kind='quicksort',order=None)

2、a表示要排序的數組

3、axis表示排序的軸索引，默認是-1，表示最后一個軸

4、kind表示排序類型。quicksort:快速排序，為默認值，速度最快建議使用；mergesort:歸并排序；heapsort:堆排序。

5、order表示排序字段。

二、argsort()函數

1、按照軸對數組進行排序索引，即軸排序索引

numpy.argsort(a,axis=-1,kind='quicksort',order-None)

2、a表示要排序的數組

3、axis表示排序的軸索引，默認是-1，表示最后一個軸

4、kind表示排序類型。quicksort:快速排序，為默認值，速度最快建議使用；mergesort:歸并排序；heapsort:堆排序。

5、order表示排序字段。

三、代碼練習

import numpy as np

# %% sort()

a1 = np.random.randint(0,10,size=(4,5))

b1 = np.sort(a1)

print(a1)

print("-------------------------------")

print(b1)

print("-------------------------------")

b2 = np.sort(a1,axis=0)

print(b2)

# %% argsort()

a1 = np.random.randint(0,10,size=(4,5))

b1 = np.argsort(a1)

print(a1)

print("-------------------------------")

print(b1)

print("-------------------------------")

b2 = np.argsort(a1,axis=0)

print(b2)

隨機數函數

一、rand()函數

1、該函數返回[0.0,1.0)的隨機浮點數，即大于等于0.0，且小于1.0的隨機浮點數。

numpy.random.rand(d0,d1,...,dn)

2、d0,d1,...dn表示數組的形狀。

二、randint()函數

1、該函數返回[low,high)的隨機整數，如果high省略，則返回[0,low)的隨機整數。

numpy.random.randint(low,high,size,dtype)

2、size表示數組的形狀，需要傳元組

3、dtype數據類型

三、normal()函數

1、該函數返回正態分布隨機數

numpy.random.normal(loc,scale,size)

2、loc表示平均值

3、scale表示標準差

4、size表示數組的形狀，需要傳元組

四、randn()函數

1、該函數返回標準正態分布隨機數，即平均數為0，標準差1的正太分布隨機數

numpy.random.randn(d0,d1,...,dn)

2、d0,d1,...dn表示數組的形狀。

五，代碼練習

import numpy as np

# %% rand()

a1 = np.random.rand(10)

print(a1)

print("----------------------------")

a2 = np.random.rand(3,4)

print(a2)

# %% randint()

a1 = np.random.randint(3,7,(5,))

print(a1)

print("----------------------------")

a2 = np.random.randint(6,size=(3,3))

print(a2)

# %% normal()

a1 = np.random.normal(10,3,(3,5))

print(a1)

# %% randn()

a1 = np.random.randn(3,4)

print(a1)

數組廣播

數組與標量或者不同形狀的數組進行算術的時候，就會發生數組廣播

一、數組與標量

數組與標量進行算術運算，相當于先將標量廣播成相同形狀的數組，然后再進行算術運算。

二、數組與數組

數組與不同形狀的數組進行算術運算時，會發生廣播，需遵守以下廣播原則

1、先比較形狀，再比較維度，最后比較對應軸長度。

2、如果兩個數組維度不相等，會在維度較低數組的形狀左側填充1，直到維度與高維數組相等。

3、如果兩個數組維度相等時，要么對應軸的長度相同，要么其中一個軸長度為1，則兼容的數組可以廣播，長度為1的軸會被擴展。

三、代碼練習

import numpy as np

# %% 數組與標量廣播

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

print(a1+2)

# %% 數組與數組廣播

a1 = np.array([1,2])

b1 = np.array([[3,4],

? ? ? ? ? ? ? [5,6]])

print(a1+b1)

print("---------------------")

a2 = np.array([[1,2]])

b2 = np.array([[3],

? ? ? ? ? ? ? ?[4]])

print(a2+b2)

print("---------------------")

# %% 數組與數組（不兼容）

a2 = np.array([[1,2]])

b2 = np.array([[3,4,5],

? ? ? ? ? ? ? ?[6,7,8]])

print(a2+b2)

數組的算數運算

一、數組對象可以使用Python原生的算術運算符

二、代碼練習

import numpy as np

# %% 一維數組的算術運算

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

b1 = np.array([4,5,6])

print(a1+b1)

print(a1**b1)

print(a1**2)

# %% 二維數組的算術運算

a2 = np.array([[1,2],

? ? ? ? ? ? ? ?[3,4]])

b2 = np.array([[5,6],

? ? ? ? ? ? ? ?[7,8]])

print(a2+b2)

print(a2+2)

分割數組

一、split()函數

1、該函數指沿指定的軸分割多個數組

numpy.split(ary,indices_or_sections,axis)

2、ary是要被分割的數組

3、indices_or_sections是一個整數或數組，如果是整數就用該數平均分割；如果是數組，則為沿指定軸的切片操作

4、axis指軸的分割方向，默認為0軸。

二、vsplit()函數

1、該函數指沿垂直方向分割數組，相當于split()函數axis=0情況

numpy.vsplit(ary,indices_or_sections)

2、ary是要被分割的數組

3、indices_or_sections是一個整數或數組，如果是整數就用該數平均分割；如果是數組，則為沿指定軸的切片操作

三、hsplit()函數

1、該函數指沿水平方向分割數組，相當于split()函數axis=1情況

numpy.hsplit(ary,indices_or_sections)

2、ary是要被分割的數組

3、indices_or_sections是一個整數或數組，如果是整數就用該數平均分

四、代碼練習

# %% split()函數分割一維數組（整數）

import numpy as np

a1=np.arange(9)

b1=np.split(a1, 3)

print(b1)

print("--------------------------")

# %% split()函數分割一維數組（數組）

a1 = np.arange(9)

sections=np.array([4,7])

b1 = np.split(a1,sections)

print(b1)

print("--------------------------")

# %% split()函數和vsplit()函數分割二維數組（整數）

a2=np.array([[1,2,3,4],

? ? ? ? ? ? ?[5,6,7,8],

? ? ? ? ? ? ?[9,10,11,12],

? ? ? ? ? ? ?[13,14,15,16]])

b2=np.split(a2, 4)

print(b2)

print("--------------------------")

b3 = np.vsplit(a2, 4)

print(b3)

# %% split()函數和hsplit()函數分割二維數組（數組）

a2=np.array([[1,2,3,4],

? ? ? ? ? ? ?[5,6,7,8],

? ? ? ? ? ? ?[9,10,11,12],

? ? ? ? ? ? ?[13,14,15,16]])

sections=np.array([1,2])

b2=np.split(a2,sections,axis=1)

print(b2)

print("--------------------------")

b3=np.hsplit(a2,sections)

print(b3)

連接數組

一、concatenate()函數

1、該函數指沿指定的軸連接多個數組

numpy.concatenate((a1,a2,...),axis)

2、a1,a2是要連接的數組。注意，除了指定軸外，其他軸元素個數必須相同。

3、axis是沿指定軸的索引，默認為0軸。

二、vstack()函數

1、沿垂直堆疊多個數組，相當于concatenate()函數axis=0情況

numpy.vstack((a1,a2))

2、注意，1軸上元素個數相同

三、hstack()函數

1、沿水平堆疊多個數組，相當于concatenate()函數axis=1情況

numpy.hstack((a1,a2))

2、注意，0軸上元素個數相同

四、代碼練習

# %% concatenate()函數連接

import numpy as np

a=np.array([[1,2],

? ? ? ? ? ?[3,4]])

b=np.array([[5,6]])

ab=np.concatenate((a, b,))

print(ab)

print("-----------------------------")

a1=np.array([[1,2],

? ? ? ? ? ? ?[3,4]])

b1=np.array([[5,6]])

bt=b1.T

ab1 = np.concatenate((a, bt),axis=1)

print(ab1)

print("-----------------------------")

# %% vstack()函數連接

a=np.array([[1,2],

? ? ? ? ? ?[3,4]])

b=np.array([[5,6]])

ab = np.vstack((a,b))

print(ab)

print("-----------------------------")

# %% hstack()函數連接

a=np.array([[1,2],

? ? ? ? ? ?[3,4]])

b=np.array([[5,6]])

bt=b.T

ab=np.hstack((a,bt))

print(ab)

四、花式索引

1、什么是花式索引

索引為整數列表

索引為一維整數數組

索引為二維整數數組

2、注意事項

注：花式索引返回的新數組與花式索引數組形狀相同

注：花式索引返回的新數組與布爾索引類似，屬于深層復制

注：二維數組上每一個軸的索引數組形狀相同

3、代碼練習

import numpy as np

# %% 一維數組的花式索引

a1 = np.array([1,2,3,4,5,6,7,8,9])

b = [0,1,2,3]

print(a1[b])

b1 = np.array([0,1,2,3])

print(a1[b1])

c = np.array([[4,5],

? ? ? ? ? ? ? [6,7]])

print(a1[c])

# %% 二維數組的花式索引

a2 = np.array([[1,2,3],

? ? ? ? ? ? ? ?[4,5,6],

? ? ? ? ? ? ? ?[7,8,9]])

m = [1,2]

n = [0,1]

print(a2[m,n])

print(a2[m][n])

print("--------------------")

m = np.array([1,2])

n = np.array([0,1])

print(a2[m,n])

print("--------------------")

m = np.array([[1,1],

? ? ? ? ? ? ?[2,0]])

n = np.array([[1,0],

? ? ? ? ? ? ?[1,0]])

print(a2[m,n])

print("--------------------")

m = [1,2]

print(a2[m,2])

m = np.array([1,2])

print(a2[m,2])

m = np.array([[1,1],

? ? ? ? ? ? ? [2,0]])

print(a2[m,2])

三、布爾索引

注：布爾索引必須與要索引的數組形狀相同，否則會引發IndexError錯誤。

注：布爾索引返回的新數組是原數組的副本，與原數組不共享相同的數據空間，即新數組的修改不會影響原數組，這是所謂的深層復制。

注：布爾索引返回的一定是一維數組

代碼練習：

import numpy as np

# %% 一維數組的布爾索引

a1 = np.array([1,2,3,4])

b1 = np.array([True,False,True,False])

print(a1[b1])

# %% 二維數組的布爾索引

a2 = np.array([[1,2,3],

? ? ? ? ? ? ? ?[4,5,6],

? ? ? ? ? ? ? ?[7,8,9]])

b2 = np.array([[True,False,True],

? ? ? ? ? ? ? ?[True,False,True],

? ? ? ? ? ? ? ?[True,False,True],])

print(a2[b2])

print(a2[b2].shape)

# %% 深層復制和淺層復制

# %% 布爾索引

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

b3 = np.array([True,False,True])

c3 = a3[b3]

print(c3)

c3[1] = 100

print(a3)

print(c3)

## %% 切片訪問

a4 = np.array([7,8,9])

b4 = np.array([False,True,True])

c4 = a4[1:]

print(c4)

c4[1] = 100

print(c4)

print(a4)

二、切片訪問

1、一維數組的切片訪問

一維數組切片訪問宇Python內置序列類型切片訪問一樣

注意：切片包括start起始位置元素，不包括end結束位置元素。

2、二維數組的切片訪問

3、代碼練習

import numpy as np

# %% 一維數組切片

a = np.array([1,3,5,7,9])

print(a[1:3].shape)

print(a[:3])

print(a[1:])

print(a[:])

print(a[1:-1])

print(a[1:-1:2])

# %% 二維數組切片

b = np.array([[1,2,3],

? ? ? ? ? ? ? [4,5,6],

? ? ? ? ? ? ? [7,8,9]])

print(b[0:2,1:2])

print(b[0:2,1:2].shape)

print(b[:2,1:])

print(b[1:,1].shape)

print(b[1:2,1].shape)

三種函數

一、一維數組的索引訪問

一維數組索引訪問與Python內置序列類型索引訪問一樣

二、二維數組索引訪問

?

代碼聯系：

import numpy as np

# %%?一維數組的索引訪問 ?

a = np.array([1, 2, 3, 4, 5])

print(a[4], a[-1])

# %% 二維數組的索引訪問

b = np.array([[1, 3, 5, 7],

? ? ? ? ? ? ? [2, 4, 6, 8],

? ? ? ? ? ? ? [7, 8, 9, 10]])

print(b[2][3],b[2,3],b[-1,-1])

1、ones()函數

根據指定的形狀和數據類型生成全為1的數組

numpy.ones(shape,dtype=None)

shape：數組的形狀

2、zeros()函數

根據指定的形狀和數據類型生成全為0的數組

numpy.zeros(shape,dtype = None)

shape：數組的形狀

3、full()函數

根據指定的形狀和數據類型生成數組，并用指定數據填充

numpy.full(shape,fill_value,dtype=None)

shape：數組的形狀

fill_value：指定填充的數據

4、identity()函數

創建單位矩陣（即對角線元素為1，其他元素為0的矩陣）

numpy.identity(n, dtype = None)

n：數組的形狀

創建多維數組代碼：

import numpy as np

# %% noes()

a = np.ones([2, 3],dtype=np.int32)

print(a)

# %% zeros()

b = np.zeros([3, 4])

print(b)

# %% full()

c = np.full([2, 3],10)

print(c)

# %% identity()

d = np.identity(6)

print(d)

一、數組的軸

二維數組有兩個軸，軸索引分別為0和1

二、數組轉置

我們可以使用數組對象的屬性T，將數組進行轉置。

import numpy as np

lt = [[1, 3, 5],

? ? ? [2, 4, 6]]

a = np.array(lt)

print(a)

b = a.T

print(b)

其他創建數組的函數：

1、arange()函數

我們可以使用arange()函數創建數值范圍并返回數組對象

numpy.arange(start,stop,step,dtype)

start：開始值，默認值為0，包含開始值

stop：結束值，不包含結束值

step：步長，默認值為1，該值可以為負數

dtype：數組元素類型

2、linspace()函數

我們可以使用linspace()函數創建等差數組

numpy.linspace(start,stop,num,endpoint,retstep,dtype)

start：開始值，默認值為0，包含開始值

stop：結束值，不包含結束值

num：設置生成元素個數

endpoint：設置是否包含結束值，False不包含，True包含，默認是True。

retstep：設置是否返回步長（即公差），False不返回，默認值是False，True是返回，當值為True時，返回值是二元組，包括數組和步長。

dtype：數組元素類型

3、logspace()函數

我們可以使用logspace()函數創建等比數組

numpy.logspace(start,stop,num,endpoint,base,dtype)

start：開始值，值為base**start

stop：結束值，值為base**stop

num：設置生成元素個數

endpoint：設置是否包含結束值，False不包含，True包含，默認是True。

base：底數

dtype：數組元素類型

創建數組代碼：

# %% 初始值0，結束值不為10，步長1

a = np.arange(10)

print(a)

# %% 初始值1，結束值不為10，步長2

b = np.arange(start = 1, stop = 10, step = 2)

print(b)

# %% 將數據類型改為雙精度浮點型'f8'

c = np.arange(start = 1, stop = 10, step = 2, dtype = np.float64)

print(c)

# %% 初始值0，結束值不為-10，步長-3

d = np.arange(0, -10, -3)

print(d)

# %% 初始值0，結束值10，個數9

e = np.linspace(0,10,9)

print(e)

# %% 結束值不為10，個數9

f = np.linspace(0, 10, 10, endpoint=False)

print(f)

# %% setsetp設置True

g = np.linspace(0, 10, 10, endpoint = False, retstep=True)

print("{0}-{1}-{2}".format(g, g[0], g[1]))

# %% 初始值10**0，結束值10**3，個數4

h = np.logspace(0, 3, 4)

print(h)

# %% base = 2， 個數4

i = np.logspace(0, 3, 4, base = 2)

print(i)

# %% 結束值不為2**3

k = np.logspace(0, 3, 3, base = 2, endpoint = False)

print(k)

數據類型轉換代碼：

import numpy as np

?

a = np.array([1,3,5,7],dtype = np.int64) ??#轉換數據類型，類型代碼需要寫成字符串#dtype = “i8”

?

print(a,a.dtype) ?????????#打印數據及數據類型

import numpy as np

# %% 這是第一段一維數組

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

print(a)

# %% 這是第二段二維數組

b = np.array([[1,2,3],

? ? ? ? ? ? ? [4,5,6],

? ? ? ? ? ? ? [7,8,9]])

print(b)

什么是NumPy：

一、NumPy是一個開源的Python數據分析和科學計算庫。

二、Numpy是Pandas（數據分析）、SciPy（科學計算）、Matplotlip（繪圖庫）的基礎。

三、NumPy的官網是https://numpy.org/

NumPy的特點：

一、NumPy底層是使用C語言實現的，速度快。

二、NumPy提供數據結構（數組）比Python內置數據結構訪問效率更高。

三、支持大量高維度數組與矩陣運算。

四、提供大量的數學函數庫。

一、Python的內置數據結構：字符串、列表、元組、集合、字典。

二、序列的索引和切片訪問的相關操作。

三、列表、集合、字典的推導式。

四、Lambda表達式。

五、Python函數式編程的基礎函數：filter()、map()、reduce()。