Python之Numpy的使用

1.Numpy的特点

1. Numpy底层是使用C语言实现的，速度快。
2. Numpy提供数据结构即数组比Python内置的数据结构访问效率更高。
3. Numpy提供大量的数学函数库。
4. Numpy支持大量高维度数组与矩阵运算。

2.安装Anaconda

1. Anaconda作为一个开源的Python发行版本，包含了conda、Python等众多科学包以及其依赖项。
2. 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数组对象

1. Numpy中最重要的数据结构是数组对象，即numpy.ndarray
2. 数组对象的特点：

• 用于存放同类型元素的集合
• 每个元素在内存中都有相同存储大小的区域

3. 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（）函数

1. 该函数指沿指定的轴分割多个数组
2. numpy.split(ary,indices_or_sections,axis)
3. ary:是要被分割的数组
4. indices_or_seections是一个整数或者数组，如果是整数就用该数平均分割；如果是数组，则为沿着指定轴的切片操作
5. axis:指轴的分割方向，默认为0轴

7.2.2 vsplit（）函数

6. 该函数是指沿垂直方向分割数组，相当于split()函数的axis=0情况
7. numpy.vsplit(ary,indices_or_sections)

7.2.3hsplit（）函数

9. 该函数指沿着水平方向分割数组，相当于split（）函数axis=1的情况
10. 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. 定义:数组与标量或者不同形状的数组进行算术运算时候，就会发生数组广播
2. 数组与标量

• 数组与标量进行算术运算，相当于先将标量广播成相同形状的数组，然后进行算术运算

3. 数组与数组

• 数组与不同形状的数组进行算术运算时，会发生广播，需要遵守以下广播原则

• 先比较形状，再比较维度，后比较对应轴长度

• 如果两个数组维度不相等，会在维度较低数组的形状左侧填充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])

All is well !