文章目录
1.Numpy的特点
- Numpy底层是使用C语言实现的，速度快。
- Numpy提供数据结构即数组比Python内置的数据结构访问效率更高。
- Numpy提供大量的数学函数库。
- Numpy支持大量高维度数组与矩阵运算。
2.安装Anaconda
- Anaconda作为一个开源的Python发行版本，包含了conda、Python等众多科学包以及其依赖项。
- Anaconda官网：https://www.anaconda.com
这里我们选择python3.7和64位操作系统
3.Python的开发工具
Python shell、Python IDLE、IPython shell、Spyder（推荐使用）、Jupyter Notebook、Sublime Text、Pycharm、Eclipse Pydev插件、Visual Studio Code
推荐使用Spyder（可以使Numpy数组可视化表现出来）
4.一维数组
4.1数组对象
4.1.1数组对象的特点
- 用于存放同类型元素的集合
- 每个元素在内存中都有相同存储大小的区域
4.1.2数组的创建
4.2创建一维数组
4.2.1数组对象
- Numpy中最重要的数据结构是数组对象，即numpy.ndarray
- 数组对象的特点：
- 用于存放同类型元素的集合
- 每个元素在内存中都有相同存储大小的区域
- array（）函数
通过numpy.array(object) ， 其中参数object类型可以是列表或者元组
注：
数组只可以保存相同类型的数据，二列表可以保存任何类型的数据
4.4.2数组的数据类型
- 整型
- 浮点型
- 复数
- 字符串
- 布尔型
import numpy as np
a=np.array([1,2,3,4],dtype=np.int64)
print(a,a.dtype)
4.4.3创建一维数组的其它函数
- aranger()函数
我们可以使用arange（）函数创建数值范围并返回数组对象
numpy.arange(start,stop,step,dtype)
- start：开始值，默认为0，包含开始值
- stop：结束值，不包含结束值
- step：步长，默认值为1，该值可以为负数
- dtype：数组元素类型
- linspace（）函数
我们可以使用linspace（）函数创建等差数组
numpy.linspace(start,stop,num,endpoint,retstep,dtype)
- num:设置生成的元素个数
- endpoint：设置是否包含结束值，False是不包含，True是包含，默认值是True
- restep：设置是否返回步长（即公差），False是不反回，默认值是False，True是返回，当值为True时，返回值是二元组，包括数组和步长
- logspace（）函数
我们可以使用logsapce（）函数创建等比数组
numpy.logspace(start,stop,num,endpoint,base,dtype)
- start：开始值，值为base**start
- stop：结束值，值为base**stop
- base：底数
# %% 初始值为0，结束值不为10，步长1
import numpy as np
a=np.arange(10)
print(a)
# %%初始值为1，结束值不为10，步长为2
b=np.arange(start=1,stop=10,step=2)
print(b)
# %%将数据类型改为双精度浮点型‘f8’
c=np.arange(1,10,2,dtype=np.float64)
print(c,c.dtype)
# %%初始值为1，结束值不为-10，步长-3
d=np.arange(1,-10,-3)
print(d)
# %%初始值为0，结束为10，个数9
e=np.linspace(0,10,9)
print(e)
# %%结束值不为10，个数10
f=np.linspace(0,10,10,endpoint=False)
print(f)
# %%初始值为10**0 结束值为10**3，个数4
g=np.logspace(0,3,4)
print(g)
# %%base=2 个数4
h=np.logspace(0,3,4,base=2)
print(h)
5.二维数组
5.1创建二维数组
numpy.array(object),参数object类型可以是列表或者元组
import numpy as np
a=np.array([[1,2,3],[4,5,6]])
print(a)
5.2数组的轴
- 二维数组有两个轴，轴索引分别为0和1
5.3数组的转置T
import numpy as np
a=[[1,2,3],[4,5,6]]
b=np.array(a)
print(b)
# %% 转置
c=b.T
print(c)
5.4二维数组的其他创建方式
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)
fill_value：指定填充的数据
4.identity（）函数
创建单位矩阵（即对角线元素为1，其他元素为0的矩阵）
numpy.identity(n,dtype=None)
n :数组的形状
# %% ones()
import numpy as np
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)
6.数组的访问
6.1索引访问
- 一维数组的索引访问 --------ndarray[index]
- 二维数组的索引访问
- ndarray[所在0轴索引][所在1轴索引]
- ndarray[所在0轴索引,所在1轴索引]
# %%一维数组的索引访问
import numpy as np
a=np.array([1,2,3,4,5])
print(a[4],a[-1])
# %%二维数组的索引和访问 输出为9
b=np.array([[1,2,3],[4,5,6],[7,8,9]])
print(b[2][2])
# %% 或者print(b[2,2])
6.2切片访问
- 一维数组的切片访问
- ndarray[start:end]
- ndarray[start：end:step]
一维数组切片访问与Python内置序列类型切片访问一样
注：切片包括start位置元素，但不包括end位置元素
-
二维数组的切片访问
-
ndarray[所在0轴切片，所在1轴切片]
# %% 一维数组的切片访问方式
import numpy as np
a=np.array([1,2,3,4])
print(a[1:3])
# %%输出2，3
print([:3])
# %% 输出1，2，3
print([1:])
# %%输出2，3，4
print([:])
# %%输出1，2，3，4
print(a[1:-1])
# %% 输出2，3
# %%二维数组的切片方式
b=np.array([[1,2,3],
[4,5,6],
[7,8,9]])
print(b[0:2,1:2],shape)
# %%输出（2，1）
print(b[:2,1:])
# %% 输出[[2,3],[5,6]]
6.3布尔索引
1.布尔索引必须与要索引的数组形状相同，否则会发生IndexError错误
2.不二索引返回的新数组是原来数组的副本，与原数组不共享相同的数据空间，即新数组的修改不会改变原数组（深层复制）
# %%一维数组的布尔索引
import numpy as np
a1=np.array([1,2,3,4])
b1=np.array([True,False,True,False])
print(a1[b1])
# %% 输出结果[1,3]
# %%二维数组的布尔索引
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])
# %% 输出结果[1,3,4,6,7,9]
# %%深层复制和浅层复制
a3=np.array([1,2,3])
b3=np.array([False,True,True])
c=a3[b3]
print(c)
# %% 输出[2,3]
c[1]=100
print(c)
# %% 输出[2,100]
print(a3)
# %% 输出[1,2,3]
6.4花式索引
- 花式索引返回的新数组与花式索引数组形状相同
- 花式索引返回的新数组与布尔索引类似，属于深层复制
- 二维数组上的每一个轴的索引数组形状相同
# %% 一维数组的花式索引
import numpy as np
a1=np.array([1,2,3,4,5,6])
b=[1,2,3,4]
print(a1[b])
# %% 输出结果为[2,3,4,5]
c=np.array([1,2,3,4])
print(a1[c])
# %% 输出结果为[2,3,4,5]
d=np.array([[1,2],
[3,4])
print(a1[d])
# %% 输出结果为[[2,3]
[4,5]]
# %%二维数组的花式索引
a2=np.array([[1,2,3],
[4,5,6],
[7,8,9]])
m=[1,2]
n=[0,1]
print(a2[m,n])
# %% 输出结果为[4,8]
7.数组的操作
7.1 连接数组
- concatenate（）函数
该函数指沿指定的轴连接多个数组
numpy.concatenate((a1,a2,a3…,),axis)
-
a1,a2是要连接的数组。注意，除了指定轴外，其它轴元素的个数必须相同
-
axis是沿指定轴的索引，默认为0轴。
-
vstack（）函数
-
沿垂直堆叠多个数组，相当于concatenate()函数axis=0的情况
numpy.vstack((a1,a2))
注：1轴上元素个数相同 -
hstack（）函数
-
沿水平堆叠多个数组，相当于concatenate()函数axis=1的情况
numpy.hstack((a1,a2))
注：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)
# %% 输出结果为 [[1,2]
[3,4]
[5,6]]
# %% vstack（）
a=np.array([[1,2],
[3,4]])
b=np.array([[5,6]])
ab=np.vstack((a,b))
print(ab)
# %% 输出结果为 [[1,2]
[3,4]
[5,6]]
# %% 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 5]
[3 4 6]]
7.2分割数组
7.2.1 split（）函数
- 该函数指沿指定的轴分割多个数组
- numpy.split(ary,indices_or_sections,axis)
- ary:是要被分割的数组
- indices_or_seections是一个整数或者数组，如果是整数就用该数平均分割；如果是数组，则为沿着指定轴的切片操作
- axis:指轴的分割方向，默认为0轴
7.2.2 vsplit（）函数
- 该函数是指沿垂直方向分割数组，相当于split()函数的axis=0情况
- numpy.vsplit(ary,indices_or_sections)
7.2.3hsplit（）函数
- 该函数指沿着水平方向分割数组，相当于split（）函数axis=1的情况
- numpy.hsplit（ary,indices_or_sections）
# %% split() 一维数组（整数）
import numpy as np
a1=np.array([0,1,2,3,4,5,6,7,8])
b1=np.split(a1,3)
ptint(b1)
# %% 输出结果[array([0,1,2],array([3,4,5]),array([6,7,8])]
# %% split() 一维数组（数组）
a1=np.arange(9)
sections=np.array([4,7])
b1=np.split(a1,sections)
print(b1)
# %% 输出结果[array([0,1,2,3]),array([4,5,6]),array([7,8])]
# %% split()二位数组(整数)
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)
# %% 输出结果为array([[1,2,3,4]]),array([[5,6,7,8]]),array([[9,10,11,12]]),array([[13,14,15,16]])
# %% split()二位数组(数组)
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)
print(b2)
# %% 输出结果为
array([[1,2,3,4]]),array([[5,6,7,8]]),array([[9,10,11,12],[13,14,15,16]])
# %% 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)
b3=np.vsplit(a2,4)
print(b3)
7.3 数组的算术运算
| 运算符 | 描述 |
|---|---|
| + | 加 |
| - | 减法 |
| * | 乘法 |
| / | 除法 |
| // | 乘整除，返回商的整数部分 |
| % | 取余 |
| ** | 次幂 |
7.4数组的广播
- 定义:数组与标量或者不同形状的数组进行算术运算时候，就会发生数组广播
- 数组与标量
- 数组与标量进行算术运算，相当于先将标量广播成相同形状的数组，然后进行算术运算
- 数组与数组
-
数组与不同形状的数组进行算术运算时，会发生广播，需要遵守以下广播原则
-
先比较形状，再比较维度，后比较对应轴长度
-
如果两个数组维度不相等，会在维度较低数组的形状左侧填充1，直到维度与高维数组相等
-
如果两个数组维度相等时，要么对应轴的长度相同，要么其中一个轴的长度为1，则兼容的数组可以广播，长度为1的轴会被扩展。
# %% 数组与标量
import numpy as np
a1=np.array([1,3,5])
print(a1+2)
% ## 输出结果：[3,5,7]
# %% 数组与数组
a1=np.array([1,2])
b2=np.array([[3,4],
[5,6]])
print(a1+b2)
# %% 输出结果：[[4,6
8.常用的统计函数
8.1随机数函数
-
rand()函数
该函数返回[0.0,1.0）的随机浮点数，即大于等于0.0，且小于1.0的随机浮点数
numpy.random.rand(d0,d1,…dn) -
randint()函数
该函数返回[low,high)的随机整数，如果high省略，则返回[0,low)的随机整数
numpy.random.randint(low,high,size,dtype)
size:表示数组的形状 -
normal()函数
该函数返回正态分布随机数
numpy.random.normal(loc,scale,size)
loc:表示平均值
scale:表示标准差 -
randn()函数
该函数返回标准正态分布随机数，即平均数为0，标准差为1的正态分布随机数
numpy.random.randn(d0,d1,d2…dn)
# %%rand()
import numpy as np
a1=np.random.rand(10)
print(a1)
a2=np.random.rand(3,4)
print(a2)
# %% randint()
a1=np.random.randint(3,size=(5,))
print(a1)
# %% normal()
a2=np.random.normal(10,3,(3,4))
print(a2)
# %% randn()
a2=np.random.randn(3,4)
print(a2)
8.2排序函数
-
sort()函数
按照轴对数组行排序，即轴排序
numpy.sort(a,axis=-1,kind=‘quicksort’,order=None) -
a:表示要排序的数组
-
axis:表示排序的轴索引，默认为-1，表示最后一个轴
-
kind:表示排序类型，quicksort：快速排序，为默认值，速度最快，mergesort：归并排序，heapsort：堆排序
-
order:表示排序字段
-
argsort()函数
-
按照轴对数组进行排序索引，即轴排序索引
-
numpy.argsort(a,axis=-1,kind=‘quicksort’,order=None)
# %% sort()
import numpy as np
a1=np.random.randint(0,10,size=(3,4))
print(a1)
a2=np.sort()
b2=np.sort(a2,axis=-1)
print(b2)
c2=np.sort(a2,axis=0)
print(C2)
# %% argsort()
a2=np.random.randint(0,10,size(3,4))
print(a2)
b2=np.argsort(a2)
print(b2)
8.3聚合函数
-
求和
-
使用Numpy中sum（）函数
numpy.sum(a,axis=None) -
使用Numpy中nansum（）函数，该函数忽略NaN
numpy.nansum(a,axis=None) -
使用数组对象的sum()方法
numpy.ndarray.sum(axis=None) -
求最大值
-
使用Numpy中的amax（）函数
numpy.amax(a,axis=None) -
使用Numpy中nanamax（）函数，该函数忽略NaN
numpy.nanamax(a,axis=None) -
使用数组对象的max()方法
numpy.ndarray.max(axis=None) -
求最小值
-
使用Numpy中的amin（）函数
numpy.amim(a,axis=None) -
使用Numpy中nanamin（）函数，该函数忽略NaN
numpy.nanamax(a,axis=None) -
使用数组对象的min()方法
numpy.ndarray.min(axis=None) -
求平均值
-
使用Numpy中的mean（）函数
numpy.mean(a,axis=None) -
使用Numpy中nanmean（）函数，该函数忽略NaN
numpy.nanmean(a,axis=None) -
使用数组对象的mean()方法
numpy.ndarray.mean(axis=None) -
求加权平均值
-
使用Numpy中的average（）函数
numpy.average(a,axis=None,weight=None)
weight表示权重
9.数据读取和保存
9.1数组的保存
- save（）函数
该函数可以将一个数组保存到后缀名为“.npy”的二进制文件中
numpy.save(file,arr,allow_pickle=True,fix_imports=True)
file:表示文件名/文件路径
arr:表示要存储的数组
allow_pickle：为布尔值，表示否允许使用pickle来保存数组对象
fix_imports:为布尔值，表示是允许在python2中读取python3保存的数据 - savez（）函数
该函数可以将多个数组保存到未压缩的后缀名为“.npz”的二进制文件中
numpy.savez(file) - savez_compressed（）函数
该函数可以将多个数组保存到压缩的后缀名为“.npz"的二进制文件中
numpy.savez_compressed(file)
# %% save（）
import numpy as np
a1=np.array([[1,2,3],
[4,5,6],
[7,8,9]])
np.save('array_save',a1)
# %% savez()
a1=np.array([[1,2,3],
[4,5,6],
[7,8,9]])
a2=np.array([1,2,3,4,5,6,7])
np.savez('array_saveZ',array_a1=a1,array_a2=a2)
# %% savez_compressed（）
a1=np.array([[1,2,3],
[4,5,6],
[7,8,9]])
a2=np.array([1,2,3,4,5,6,7])
np.savez_compressed('array_savez_compressed',array_a1=a1,array_a2=a2)
9.2数组的读取
- 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)
a3=np.load('array_savez.npz')
print(a3[array_a1])
print(a3[array_a2])
a4=np.load('array_savez_conpressed.npz')
print(a4[array_a1])
print(a4[array_a2])
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
