NumPy数值计算

NumPy的两类基本对象：

• ndarray ： 存储单一数据类型的多维数组
• ufunc ： 能够对数组进行处理的函数

NumPy导入

import numpy as np

NumPy多维数组

创建数组对象

1. 使用 array 函数创建数组对象

np.array(object,dtype,ndmin)
#object:接收array,表示想要创建的数组
#dtype:表示数据所需的数据类型，未给定则选择保存对象所需的最小类型，默认None
#ndmin:指定生成数组应具有的最小维数，默认None

在array函数中指定dtype

w3=np.array([1,2,3,4],dtype='float64')
print(w3)
print(w3.dtype)
#输出：
# [1,2,3,4]
# float64

2.专门创建数组的函数

• arange

#使用arange创建数组
a = np.arange(0,1,0.1)
#起始值、终止值、步长

• linspace

a = np.linspace(0,1,5)
#起始值、终止值、元素个数

• logspace（类似linspace, 但创建的是等比数列）

a = np.logspace(0,1,5)
#生成1~10的具有五个元素的等比数列
#logspace的参数中，起始位和终止位代表的是10的幂

• zeros

#使用zeros函数创建全0数组
np.zeros(4)
#[0. 0. 0. 0.]
np.zeros([3,3])
#[[0. 0. 0.][0. 0. 0.][0. 0. 0.]]

• ones

np.ones(4)
#[1. 1. 1. 1.]

• diag

#diag创建对角矩阵
np.diag([1,2,3,4])

ndarray对象属性和数据转换

属性	说明
ndim	秩，即数据轴的个数
shape	数组的维数
size	数组元素个数
dtype	数据类型
itemsize	数组中每个元素的字节大小

• 查看数组的属性

a=np.array([1,2,3],[4,5,6])
print('秩为：',a.ndim)

• 设置数组的shape属性

a.shape=3,2
print(a)
#输出：[[1,2],[3,4],[5,6]]

• 数组的类型转换

arr1=np.arange(6)
print(arr1.dtype)
arr2=arr1.astype(np.float64)
print(arr.dtype)
#输出：int32,float64
#通过 astype 来改变数组的数据类型

生成随机数

np.random.randint(low,high=None,size=None)

生成[0,1]的随机数组

np.random.rand(5)
#1*5随机矩阵
np.random.rand(4,2)
#4*2随机矩阵

函数	说明
seed	确定随机数生成器的种子
permutation	返回一个序列的随机排列或返回一个随机排列的范围
shuffle	对一个序列进行随机排序
binomial	产生二项分布的随机数
normal	产生正态分布的随机数
beta	产生beta分布的随机数
chisquare	产生卡方分布的随机数
gamma	产生gamma分布的随机数
uniform	产生在[0,1)中均匀分布的随机数

数组变换

• 数组重塑（不改变原来的数组）

1. 改变数组维度

arr1=np.arange(8)
arr2=arr1.reshape(4,2)

#reshape中一个参数设为-1，表示数组的维度可以通过数据本身来判断
arr1=np.arange(12)
arr2=arr1.reshape(2,-1)
#重塑成两行的矩阵

2. 数据散开

arr1=np.arange(12).reshape(3,4)
arr2=arr1.ravel()
#将数据散开成一行

• 数组合并

arr1=np.arange(6).reshape(3,2)
arr2=arr1*2
#横向合并
arr3=np.hstack((arr1,arr2))
#纵向合并
arr3=np.vstack((arr1,arr2))
##横纵
arr3=np.concatenate((arr1,arr2),axis=1)#横向合并
arr3=np.concatenate((arr1,arr2),axis=0)#纵向合并

• 数组分割

arr=np.arange(16).reshape(4，4)
#横向分割
arr1=np.hsplit(arr,2)
#纵向分割
arr2=np.vsplit(arr,2)
##横纵
arr3=np.split((arr1,arr2),axis=1)#横向分割
arr3=np.split((arr1,arr2),axis=0)#纵向分割

• 数组的转置和轴对换

arr=np.arange(6).reshape(3,2)
#transpose转置
arr1=arr.transpose((1,0))
#T属性转置
arr2=arr.T
#swapaxes实现轴对换
arr3=arr.swapaxes(0,1)

数组的索引和切片

Numpy中通过数组的索引和切片进行数组元素的选取

一维数组的索引

（类似列表）

1. 索引

arr=np.arange(10)
#[0,1,2,3,4,5,6,7,8,9]
arr[2]
#2
arr[-1]
#9
arr[1:4]
#[1,2,3]

数组的切片返回的是原始数组的视图，不产生新数据

2. 复制

arr1=arr[-4:-1].copy()
#[6,7,8]

多维数组的索引

1. 多维数组的索引

arr=np.arange(12).reshape(3,4)
print(arr[0,1:3])
#索引第0行第1-2列的元素
print(arr[:,2])
#索引第2列元素

2. 访问多维数组

arr=np.arange(12).reshape(3,4)
arr1=arr[(0,1),(1,3)]
#从两个序列的对应位置取出两个整数来组成下标：[1,7]
arr2=arr[1:2,(0,2,3)]
#索引第一行中0，2，3列元素[[4 6 7]]
mask=np.array([1,0,1],dtype=np.bool)
arr3=arr[mask,1]
#mask是一个布尔数组，索引第0，2行中第一列的元素

数组的运算

数组和标量间的运算

#数组元素的追加
a=[1,2,3]
b=[]
for o in a:
	b.append(i*i)
print('b数组：',b)
wy=np.array([1,2,3])
c=wy*2
print('c数组：'c)
#b数组：[1,4,9]
#c数组：[2,4,6]

ufunc函数

1. 常用的ufunc函数：

运算	符号
四则运算	+、-、*、/、**
比较运算	>、<、==、>=、<=、！=
逻辑运算	np.any ; np.all

2. ufunc函数的广播机制
   （广播指的是不同形状的数组之间执行运算的方式）

• 遵循的原则
  （1）所有的输入数组都向其中shape最长的数组看齐，shape中不足的部分都通过在前面加1补齐
  （2）输出数组的shape是输入数组shape的各个轴上的最大值
  （3）如果输入数组的某个轴和输出数组的对应轴的长度相同或者其长度为1时，这个数组能够用来计算，否则出错
  （4）当数组的某个轴的长度为1时，沿着此轴运算时都用此轴上的第一组值

arr1=np.array([[0,0,0],[1,1,1],[2,2,2]])
arr2=np.array([1,2,3])
print(arr1+arr2)
#[[1,2,3],[2,3,4],[3,4,5]]

条件逻辑运算

np.where(condition,x,y)
#满足条件输出x;不满足输出y

#where中若只有条件，没有x和y，则输出满足条件的元素的坐标（以tuple形式给出）
import numpy as np
w=np.array([2,5,6,3,10])
print(np.where(w>4))
#(array([1, 2, 4], dtype=int64),)

数组读/写

读写二进制文件

（1）np.load(“文件名.npy”):从二进制的文件中读取数据
（2）np.save("文件名[.npy]"，arr)：以二进制的格式保存数据

a=np.array(1,13).reshape(3.4)
print(a)
np.save('arr.npy',a)
c=np.load('arr.npy')
print(c)

##多个数组保存
a=np.array([[1,2,3],[4,5,6]])
b=np.arange(0,1.0,0.1)
c=np.sin(b)  #长度为10
np.savez('result.npz',a,b,sin_array=c)
r=np.load('result.npz')
r['arr_0']  #数组a

读写文本文件

（1）np.loadtxt("../tmp/arr.tex",delimiter=","):把文件加载到一个二维数组中
（2）np.savetext("../tmp/arr.tex",arr,fmt="%d",delimiter=",")：将二维数组写到某种分隔符隔开的文本文件中
（3）np.genfromtext(../tmp/arr.tex",delimiter=",")：结构化数组和缺失数据

a=np.arange(0,12,0.5).reshape(4,-1)
np.savetxt("a1-out.txt",a)  
#默认按照'%.18e'格式保存数值
np.loadtxt("a1-out.txt")
np.savetxt("a2-out.txt",a,fmt="%d",delimiter=",")
#改为保存为整数，以逗号分隔
np.loadtxt("a2-out.txt",delimiter=",")
#读入的时候也需要指定逗号分隔

读取csv文件

loadtxt(fname,dtype=,comments='#',delimiter=None,converters=None,skiprows=0,usecols=None,unpack=False,ndmin=0,encoding='bytes'`在这里插入代码片`)

主要参数及说明

参数	说明
fname	str,读取的CSV文件名
delimiter	str，数据的分隔符
usecols	tuple（元组）,执行加载数据文件中的哪些列
unpack	bool，是否将加载的数据拆分成多个组，Ture表示拆
skiprows	int，跳过多少行，一般用于跳过前几行描述性文字
encoding	bytes，编码格式

NumPy中的数据统计与分析

排序

1. 直接排序（对数据直接进行的排序）

numpy.sort(a,axis,kind,order)
#a：要排序的数组
#axis：axis=1横轴排序，axis=0纵轴排序，axis=None将数组平坦化之后进行排序
#kind：排序算法，默认未 quicksort
#order：如果数组包含字段，则是要排序的字段

2. 间接排序（根据一个或多个键值对数据集进行排序）
   (在给定一个或多个键时，得到一个由整数构成的索引数组)

arr=np.array([7,9,5,2,9,4,3,1,4,3])
arr.argsort()
#[7,3,6,9,5,8,2,0,1,4]

a=np.array([7,2,1,4])
b=np.array([5,2,6,7])
c=np.array([5,2,4,6])
d=np.lexsort((a,b,c))
print("排序后：",list(zip(a[d],b[d],c[d])))
#排序后：[(2,2,2),(1,6,4),(7,5,5),(4,7,6)]

重复数据与去重

1.数组内去重

np.unique(array)
#去重
np.tile(A,reps)
#重复数据，A表示要重复的数组，reps表示重复次数
np.repeat(a,reps,axis=None)
#a表示要重复的数组元素，axis=0表示按行进行元素重复，axis=1表示按列进行元素重复

常用统计函数

函数	功能
np.sum()	数组的和
np.sum(arr,axis=0)	数组纵轴的和
np.sum(arr,axis=1)	数组横轴的和
np.mean()	数组的均值
np.mean(arr,axis=1)	数组横轴的均值
np.std()	数组的标准差
np.std(arr,axis=1)	数组横轴的标准差
np.var	数组的方差
np.max	数组的最大值