fffffff

eeeee

dddddd

ddddddd

fffffff

ddddddd

ddddd

数组的读取

一、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)