Numpy是Python的一个高性能矩阵运算的科学计算库。它的主要用途是以数组的形式进行数据操作和数学运算，数据分析、机器学习大都是进行数学计算。

Numpy提供多维数组对象以及蒙版数组和矩阵等各种派生对象，用于对数组进行快速便捷的操作，包括数学、逻辑、形状处理、排序、选择、I/O、离散傅里叶变换、基本线性代数、基本统计运算、随机模拟等，Numpy是数据科学中必不可少的工具。

由于Numpy对数据进行量化描述，没有任何显式的循环操作，所以执行速度更快，代码更简洁优雅，出错率更低。

Numpy提供了两个基本的对象：

ndarray：存储数据的多维数组

ufunc：对数据进行处理的函数

1.数据结构

Numpy的ndarray提供了一维到三维的数据结构，下图所示为同构数据多维容器，所有元素必须是相同类型，我们经常用到的是一维和二维数组。

Numpy的数据结构图示：

ndarray对数据向量化，利用隐式逐元素的方式广播机制进行算术运算、逻辑运算、位运算、函数调用等，可以快速、批量地处理数据。

2.创建数据

使用Numpy需要先导入，约定俗成地为它起别名np。

使用np.array可传入一个元组或列表，如果是二维数据，可以使由列表组成的列表或由元组组成的列表等形式。

import numpy as np

np.array([1,2,3])
np.array((1,2,3))
#返回结果都是[1 2 3]

np.array(((1,2),(1,2)))
np.array(([1,2],[1,2]))
np.array([[1,2],[1,2]])
'''返回结果都是：
[[1 2]
 [1 2]]'''

以下是一些常见的数据生成函数：

import numpy as np

np.array([1,2,3])
np.array((1,2,3))
#返回结果都是[1 2 3]

np.array(((1,2),(1,2)))
np.array(([1,2],[1,2]))
np.array([[1,2],[1,2]])
'''返回结果都是：
[[1 2]
 [1 2]]'''


s=np.arange(10)    #生成10个数字，默认步长为1，,[0 1 2 3 4 5 6 7 8 9]
s=np.arange(3,7,0.1)   #生成从3到7（不包含7），步长为0.1的序列数字
'''
[3.  3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 4.  4.1 4.2 4.3 4.4 4.5 4.6 4.7
 4.8 4.9 5.  5.1 5.2 5.3 5.4 5.5 5.6 5.7 5.8 5.9 6.  6.1 6.2 6.3 6.4 6.5
 6.6 6.7 6.8 6.9]'''

s=np.linspace(2.0,3.0,num=5,endpoint=False) #从2到3（不包含3）生成均匀的5个值,每个值之间的间隔一样
#[2.  2.2 2.4 2.6 2.8]
#从起始数到终点数，平均分成几段，每个值都是每段的起点：
s=np.linspace(0,100,num=3,endpoint=False)
#[ 0.         33.33333333 66.66666667]

s=np.linspace(0,60,num=3,endpoint=True)
#如果endpoint参数为True，则返回结果一定包含最终值
#[ 0. 30. 60.]

s=np.random.randn(6,2)  #生成6*2的随机数组
'''
[[ 0.9412104  -1.3360841 ]
 [-2.50008964  0.0978346 ]
 [ 0.95271129  0.19416987]
 [ 1.1880049   0.31011929]
 [-0.66638336  0.99938753]
 [-0.53039672 -0.6286474 ]]'''

s=np.random.randint(10,100,size=(2,3))     #生成指定返回，指定形状的随机数组，这里10,100是取值范围，size是形状，2行3列
'''
[[30 60 23]
 [55 81 94]]'''

#创建值为0的数组
s=np.zeros(6)   #[0. 0. 0. 0. 0. 0.]    #生成6个浮点0
s=np.zeros(6,dtype=int)     #[0 0 0 0 0 0]  6个0均为整数
s=np.zeros(6,dtype='int')     #[0 0 0 0 0 0]  6个0均为整数
'''
[[0 0 0]
 [0 0 0]]'''

s=np.ones(3)    #[1. 1. 1.] #生成指定个数的浮点1
s=np.empty(3)   #[0. 0. 0.]

#创建一份和目标结构相同的0值数组
s=np.zeros_like(np.arange(6))   #[0 0 0 0 0 0]
s=np.ones_like(np.arange(6))    #[1 1 1 1 1 1]
s=np.empty_like(np.arange(7))   #[2 2 0 0 0 0 0]    返回数据很随机


#np.empty()的作用是根据给定的shape和数据类型dtype，返回一个一维或者多维数组，数组的元素不为空，为随机产生的数据
#np.empty(shape,dtype,order)
#shape也就是形状，表示几行几列，比如(2,3)表示2行3列
#dtype数据类型是个可选项，定义返回数组的类型，比如dype=int或者float
#order：{'C','F'}，此参数定义将多维数组存储在主要行或列主要行中的顺序。默认情况下，order参数设置为'C'。规定返回数组元素在内存的存储顺序，可选项。C - rowmajor ; F - columnmajor

#返回一个2x3的浮点数
s=np.empty([2,6],dtype=float,order='F')
'''
[[ 0.09444973  1.22802151 -0.12339779  2.77733152 -0.17654593  0.77310039]
 [ 1.00365908 -2.04439778 -0.32148906 -1.28286932 -1.17040337  0.42034716]]'''


print(s)

3.数据类型

np.int64 #有符号64位整形
np.float32 #标准双精度浮点类型
np.complex #由128位的浮点数组成的复数类型
np.bool #bool类型（True或False）
np.object #Python中的object类型
np.string #固定长度的string类型
np.unicode #固定长度的unicode类型
np.NaN #no.float的子类型
np.nan

4.数组信息

一些获取数组信息的常用方法：

n.shape() # 数组的形状，返回值是一个元组
n.shape = (4, 1) # 改变形状
a = n.reshape((2,2)) # 改变原数组的形状，创建一个新数组
n.dtype # 数据类型
n.ndim # 维度数
n.size # 元素数
np.typeDict # np的所有数据类型

5.统计计算

两个数组间的操作采用行列式的运算规则，示例：

np.array([10, 20, 30, 40])[:3] # 支持类似列表的切片
a = np.array([10, 20, 30, 40])
b = np.array([1, 2, 3, 4])
a+b # array([11, 22, 33, 44])（矩阵相加）
a-1 # array([9, 19, 29, 39])
4*np.sin(a)

# 以下是一些数学函数的例子，还支持非常多的数学函数
a.max() # 40
a.min() # 10
a.sum() # 100
a.std() # 11.180339887498949
a.all() # True
a.cumsum() # array([10, 30, 60, 100])
b.sum(axis=1) # 多维可以指定方向

var()	方差
mean()	求平均数
argmax()	最大值的下标（索引）
argmin()	最小值的下标（索引）

6.其他操作

对数组中的数据按照条件筛选：

s=np.arange(10)
print(s) #[0 1 2 3 4 5 6 7 8 9]
print(s[s>6]) #[7 8 9]

#多重条件筛选，取数组内大于6的偶数
s=np.arange(10)
print(s)    #[0 1 2 3 4 5 6 7 8 9]
print(s[(s>6)&(s%2==0)]) #[8]

#在二维数组中：
数组[0,0:3]	#选择数组的第0行，索引值0到2的元素
数组[0,数组[0]>2]	#选择数组中处于第0行，并且大于2的元素

#选取不同行但相同索引值的元素
数组[[1，3],:][:,[2,3]]	#选取第一行与第三行，索引值为2与3的元素
#先筛选出第一行与第三行的所有元素，再从筛选出的元素中，选择所有行以及索引值是2与3的元素

Numpy通用函数：

能同时对数组中所有元素进行运算的函数

一元函数：abs

sqrt（开方）

exp

log

ceil（向上取整）

floor（向下取整）

round（四舍五入）

rint

trunc（截断浮点值，返回整数部分）

modf（将一个数组拆分成2个数组，第一个数组是原数组的小数部分，第二个数组是原数组的整数部分）

可以x,y=np.modf(数组)#将小数部分返回给X，整数部分返回给y

isnan

isinf

cos

sin

tan

二元函数：add，substract，multiply，divide，power，mod，maximum（取2个数组中对应位置的最大值生成新的数组），mininum

浮点数特殊值：
nan （not a number） 不等于任何浮点数
inf （infinity） 比任何浮点数都大
Numpy中创建特殊值：np.nan np.inf
在数据分析中，nan常被用作表示数据缺失值
判断np.nan==np.nan会返回False
判断np.nan is np.nan会返回True

假如数组中存在nan，判断np.nan in 数组会返回False
np.isnan(数组) #判断数组中所有的值是否为nan，是nan则会在对应元素的位置返回True

0被当成除数，会返回inf（无限大）
移除数组中的inf：
数组[数组!=np.inf] 或者 数组[~np.isinf(数组)] #~表示取反

Numpy随机数：

np.random.randint(起始值，最终值，数量/形状（可选）)

#返回起始值至最终值（不包含最终值）范围内的随机数，默认返回1个随机数，

如果假如第三个参数，也就是数量/形状，可以设置返回的数量或者几行几列，形状要用括号()表示，比如(2,3)表示2行3列，如果形状中有3个参数，比如(2,3,3)那就会创造三维随机数组

s=np.random.randint(1,2) #1

s=np.random.randint(1,2,3) #[1 1 1]

s=np.random.randint(1,2,(2,3))

”’

[[1 1 1]

[1 1 1]]”’

np.random.rand(数量) #返回0到1之间的浮点数，默认返回1个

数组=np.random.randint(1,10,3) #[1 1 1]

s=np.random.choice(数组) #从数组中随机选择一个数

print(s)

随机打乱数组内的排序：

import random

数组=np.random.randint(1,10,10) #[1 1 1]

random.shuffle(数组)

print(数组) #[6 7 8 1 9 4 5 6 9 3]

np.random.uniform(起始值,最终值,个数（可选）) #给定形状产生随机数组 从起始值与最终值之间，按均匀分布取值，然后随机采样？