-
数组的读取
一、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()。
查看全部
举报