Numpy

Numpy是科学计算基础库，提供大量科学计算相关功能，比如数据统计，随机数生成等。其提供最核心类型为多维数组（ndarray），支持大量的维度数组与矩阵计算，Numpy支持向量处理nadrry对象，提高程序运算速度

安装模块
pip install numpy

测试：

import numpy as np
a = np.arange(10)
print(a)
print(type(a))

import numpy as np
#创建数组
a = np.arange(10)
print(a)
print(type(a))
print(np.sqrt(a))

数组的创建

array创建

numpy模块的array函数可以生成多维数组。例如，需要生成二维数组，需要将array函数传递到一个列表类型的参数。每个列表元素是一维的ndarray类型数组，作为二维数组的行。另外，通过ndarray类的shape属性可以获得数组的每一个元素个数（数组形式），也可以通过shape形式获得每一个元素的个数，其中n是维度，从0开始

语法格式如下：

numpy.array(object,dtype=None,copy=True,order=None,subok=False,ndmin=0)

#导入numpy
import numpy as np
#创建一维数组
a = np.array([1,2,3,4])
print(a)
print(type(a))
#二维
b = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(b)
print(type(b))
#三维
c=np.array([[[1,2,3],[4,5,6],[7,8,9]]])
print(c)
print(type(c))
#detype设置数据类型
d =np.array([3,4,5],dtype=float)
print(d)
print(type(d))
#nidmin设置数组维度
e =np.array([3,4,5],dtype=float,ndmin =3)
print(e)
print(type(e))

arange创建

使用arange创建数值范围并返回ndarray对象，格式如下：
numpy.arange(start,stop,step,dtype)

#导入numpy
import numpy as np
#range创建列表
#顾头不顾尾
a = list(range(1,10))
print(a)
b=list(range(10))
print(b)
c=list(range(1,10,3))#1~10，步长为3
print(c)
#arrange创建数组
a = np.arange(1,10)
print(a)
b = np.arange(1,10,3)
print(b)
#dtype设置数据类型
c = np.arange(1,20,4,dtype=float)
print(c)

随机数创建

①random

numpy.random.random(size=None)
该方法返回[0.0,1.0）范围的随机数

#导入numpy
import numpy as np
#size默认一维的，size=5个元素
a = np.random.random(size=5)
print(a)
print(type(a))
#创建二维数组,size=行和列
b =np.random.random(size=(3,5))
print(b)
print(type(b))
c =np.random.random(size=(2,3,5))
print(c)
print(type(c))

②randint

numpy.random.randint(low, high=None, size=None, dtype=None)
该方法返回整型的随机数

#导入numpy
import numpy as np
#生成0~5之间的随机一维整数
a = np.random.randint(6,size=10)
print(a)
print(type(a))
#生成5~10的随机二维整数数组4行3列
b =np.random.randint(5,11,size=(4,3))
print(b)
print(type(b))
#三维，小数类型
c =np.random.randint(5,11,size=(2,4,3),dtype=np.int32)
print(c)
print(type(c))

③randn

numpy.random.randn(d0,d1...dn)

该方法返回是一组样本，具有标准正态分布（期望为0，方差为1）
dn表格为每个维度
返回值为指定维度的array

#导入numpy
import numpy as np

a= np.random.randn(4)
print(a)
print(type(a))

#二维数组2行3列
b=np.random.randn(2,3)
print(b)
print(type(b))

c=np.random.randn(2,3,4)
print(c)
print(type(c))

④指定方差

numpy.random.normal(loc=0.0, scale=1.0, size=None)

正态分布（高斯分布）loc：期望 sacle：方差 size：形状
print(np.random.normal(loc,sacle=4,size=(2,2,3)))

#导入numpy
import numpy as np

a= np.random.normal(size=5)
print(a)
print(type(a))

#指定期望和方差 期望,方差（标准差），二维
b= np.random.normal(loc=2,scale=3,size=(3,4))
print(b)
print(type(b))

ndarray对象

numpy最重要的特点是其N位数组的对象ndarray，它是一系列同类型数据的集合，一0位下标开始进行集合中元素的索引

• ndarray对象是用于存放同类型元素的多维数组
• ndarray中的每个元素在内存中都有相同存储大小的区域
• ndarray内存由以下内容组成:
  • 一个指向数据（内存或内存映射文件中的一块数据）的指针
  • 数据类型或dtype，描述在数组中的固定大小值的格子
  • 一个表示数组形状（shape）的元组，表示个维度大小的元组

NumPy的数组中比较重要ndarray对象属性有：

#导入numpy
import numpy as np

#array创建一维
a = np.array([1,2,3,4])
print(a)

#arrange创建二维
b=np.arange(4,10)
print(b)

#random创建二维
c=np.random.randint(4,10,size=(2,3))
print(c)
#random创建三维
d = np.random.randn(2,3,4)
print(d)

#ndim维度
print('ndim:',a.ndim,b.ndim,c.ndim,d.ndim)
#shape维度
print('shape:',a.shape,b.shape,c.shape,d.shape)
#detype数据类型
print('dtype:',a.dtype,b.dtype,c.dtype,d.dtype)
#size元素的总个数
print('size:',a.size,b.size,c.size,d.size)
#itemsize，每个元素所占的字节
print('itemsize:',a.itemsize,b.itemsize,c.itemsize,d.itemsize)

其他方式创建

ndarray数组除了可以使用底层ndarray构造器创建外，也可以同个以下几种方式创建：

zeros创建指定大小的数组，数组元素以0来填充

numpy.zeros(shape,dtype=float,order='C')

#导入numpy
import numpy as np

#5个数
x =np.zeros(5)
print(x)

#设置为整型
y = np.zeros((5),dtype=int)
print(y)

z=np.zeros((2,3))
print(z)

numpy.ones创建指定形状的数组，数组元素以1来填充
numpy.ones(shape,dtype = None,oreder ='C')

import numpy as np

a = np.ones(10)
print(a)

b=np.ones((2,5),dtype=int)
print(b)

numpy.empty方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组，里面的元素的值是之前内存的值：
numpy.empty(shape,dtype=float,order='C')

import numpy as np

a = np.empty(5)
print(a)

b=np.empty((2,3))
print(b)

linsapce函数用于创建一个一维数组，数组是一个等差数列构成的，格式如下：

np.linesapce(start, stop, num=50, endpoint=True, retstep=False, dtype=None):

import numpy as np

a = np.linspace(1,10,10)
print(a)

b = np.linspace(5,20,5,endpoint=True)
print(b)

c = np.linspace(5,20,5,endpoint=False)
print(c)

numpy.logspace函数用于创建一个等比数列,格式如下：

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

import numpy as np

a = np.logspace(0,9,10,base=2)
print(a)

切片和索引

ndarray对象的内容可以通过索引或切片来访问和修改，与python中的list的操作一样。
ndarry数组可以基于0~n的下标进行索引，并设置start，stop及step参数进行，从原数组中切割出一个新数组

一维数中的应用

#导入numpy
import numpy as np


a = np.arange(10)
print(a)
#正索引
print('索引0处的元素',a[0]);
print('索引5处的元素',a[5]);
#负索引
print('访问最后一个元素',a[-1]);
print('访问倒数第三个元素',a[-3]);

#切片正向索引[start:stop:step]
print(a[:]) #从开始到结尾
print(a[3:])#从索引3开始
print(a[3:5])# 从索引3开始到索引4[start.stop]结尾
print(a[1:7:2])#从索引1开始到索引6，步长为2

#切片负向索引
print(a[::1])
print(a[-5:-2])

二维数中的应用

#导入numpy
import numpy as np


a = np.arange(1,13)
print(a)
print("----------------------------")
#对一维数组修改形状成二维数组（4,3）
a = a.reshape(4,3)
print(a)
print("----------------------------")
#获取第三行
print('第三行是数组下标为2的:{0}'.format(a[2]))
print("----------------------------")
print('第二行第三列:{0}'.format(a[1][2]))

#二维数组切片
#格式：[行：列]
# [start:stop:step,start:stop:step]
print("-------获取所有行，列-------------")
print(a[:,:])
print("--------所有行，第二列------------")
print(a[:,1])
print("--------所有行，第1,2列------------")
print(a[:,0:2])
print("--------奇数行，所有列------------")
print(a[::2,:])

import numpy as np


a = np.arange(1,13)
a = a.reshape(4,3)
print(a)
print("--------坐标获取第二行第三列[行，列]---------")
print(a[1][2])
print("--------方法二：a[行，列]---------")
print(a[1,2])
print("--------同时获取2行3列，3行1列---------")
print(a[1,2],a[2,0])
print("--------放到数组中：---------")
print(np.array([a[1,2],a[2,0]]))
#负索引
print("--------最后一行---------")
print(a[-1])
print("--------行倒序---------")
print(a[::-1])
print("--------行列倒序---------")
print(a[::-1,::-1])

切片数组的复制

import numpy as np

print("------------创建二维数组------------")
a = np.arange(1,13).reshape(3,4)
print(a)
print("------------获取1，2行；1,2列------------")
print(a[:2,:2])
print("------------修改了原数组浅拷贝-----------")
sub_a=(a[:2,:2])
sub_a[0][0]=100
print(sub_a)
print(a)#原数组也改变了
print("------------numpy，copy不修改原数组,深拷贝-----------")

sub_aa =np.copy(a[:2,:2])
print(sub_aa)
print("------------修改----------")
sub_aa[0,0]=200
print(a)#原数组没改变

改变数组的维度

处理数组是一项重要工作就是改变数组的维度，包含提高数组的维度和降低数组的维度，还包括数组的转置，例如reshape可以将一维转为二维、三维或者多维，通过revel方法或flatten方法可以将多维数组转为一维数组，改变数组的维度还可以直接设置Numpy数组的shape属性，通过resize方法也可以改变数组的维度

import numpy as np

a =np.arange(1,13)
print("------a.reshape方法---------------")
print("------二维---------------")
b=a.reshape(3,4)
print(b)
print("------三维---------------")
c=a.reshape(2,2,3)
print(c)
print("------np.reshape方法-------------")
print("------二维---------------")
bb = np.reshape(a,(3,4))
print(bb)
print("------三维---------------")
cc=np.reshape(a,(2,2,3))
print(cc)

import numpy as np

a =np.arange(1,13)
bb = np.reshape(a,(3,4))
print(bb)
print("----------方法一--------------")
a = bb.reshape(12)
print(a)
print("----------方法二（-1）--------------")
d = bb.reshape(-1)
print(d)
print("----------方法三revel--------------")
e = bb.ravel()
print(e)
print("----------方法四flatten--------------")
f =bb.flatten()
print(a)

数组的拼接

水平数组组合

通过hstack函数可以将两个或多个数组水平组合形成一个数组
数组A
0 1 2
3 4 5
数组B
6 7 8
9 10 11
使用hstack函数将两个数组水平组合的代码如下
hstack(A,B)
返回的结果
0 1 2 6 7 8
3 4 5 9 10 11

垂直数组组合

通过vstack函数可以将两个或多个数组垂直组合起来形成一个数组
数组A
0 1 2
3 4 5
数组B
6 7 8
9 10 11
使用vstack函数将两个数组水平组合的代码如下:
vstack(A,B)
返回的结果:
0 1 2
3 4 5
6 7 8
9 10 11

concatenate

连接现有轴的数组序列
numpy.concatenate(a1,a2,...),axis
a1,a1…：相同类型的数组
axis：沿着它连接数组的轴，默认为0

import numpy as np

a = np.array([[1,2,3],[4,5,6]])
b=np.array([[11,12,13],[14,15,16]])
print(a)
print(b)

print("--------hstack水平------------------")
r =np.hstack((a,b))
print(r)
print("--------vstack水平------------------")
s = np.vstack((a,b))
print(s)
print("--------concatenate------------------")
print("默认axis=0，垂直方向拼接 相当于vstack")
m=np.concatenate((a,b),axis=0)
print(m)
print("--------axis=1,相当于hstack-----------------")
n = np.concatenate((a,b),axis=1)
print(n)

print("--------三维数组情况------------------")
aa =np.arange(1,13).reshape(1,2,6)
bb=np.arange(101,113).reshape(1,2,6)
print("-------aa-----------------")
print(aa,aa.shape)
print("-------bb----------------")
print(bb,bb.shape)
print("------三维，axis=0----------------")
x = np.concatenate((aa,bb),axis=0)
print(x,x.shape)
print("------三维，axis=1----------------")
y = np.concatenate((aa,bb),axis=1)
print(y,y.shape)
print("------三维，axis=2----------------")
z = np.concatenate((aa,bb),axis=2)
print(z,z.shape)

数组的分隔

split分隔
numpy.split(ary,indices_or_section,axis)
ary：被分割的数组
indices_or_section：如果是一个整数，就用该数平均分切，如果是一个数组，为沿轴切分的位置
axis：沿着哪个维度进行切向，默认为0，横向切分，为1时，纵向切分

import numpy as np
print("----------一维：--------------")
a = np.arange(1,13)
print("----------传递整数，平均分为4分--------------")
x = np.split(a,4)
print(x)
print("----------传递数组，按位置分隔0~4,4~5,5后面--------------")
x = np.split(a,[4,6])
print(x)

import numpy as np

print("----------二维：--------------")
a = np.arange(1,17).reshape(4,4)
print(a)
print("---------axis=0垂直方向(行分隔) 平均分隔2--------------")
b,w=np.split(a,2,axis=0)
print(b)
print(w)
print("---------axis=0垂直方向(行分隔) 数组传入分三部分--------------")

b,w,k=np.split(a,[2,3],axis=0)
print(b)
print(w)
print(k)

print("---------axis=1水平方向(列分隔) 平均分隔2--------------")
b,w=np.split(a,2,axis=1)
print(b)
print(w)

print("---------axis=1水平方向(行分隔) 数组传入分2部分--------------")
w,k=np.split(a,[3],axis=1)
print(w)
print(k)

水平分隔数组

分隔数组是组合数组的逆过程，与组合数组一样，分隔数组也分为水平分隔数组和垂直分隔数组。水平分隔数组与水平组合数组对应。水平组合数组是将两个或多个数组水平进行收尾相接，而水平分隔是将已经水平组合到一起的数组再分开

使用hsplit函数可以水平分隔数组，该数组有两个参数，第一个参数表示待分隔的数组，第二个参数表示要将数组分隔成几个小数组。

数组X
1 2 3 4 5 6
7 8 9 10 11 12
np.hsplit(X,2)
分隔的结果
1 2 3 4 5 6
7 8 9 10 11 12

垂直分隔数组

垂直分隔数组是垂直组合数组的逆过程。垂直数组组合是将两个或多个数组垂直进首尾相接，而垂直分隔数组是将已经垂直组合到一起的数组再分开
使vsplit函数可以垂直分隔数组，该数组有两个参数，第一个参数表示待分隔的数组，第二个数组表示将数组垂直分隔成几个小数组。
数组X
1 2 3
4 5 6
7 8 9
10 11 12
np.vsplit(X,2)
分隔的结果
12 3
4 5 6

7 8 9
10 11 12

import numpy as np

a = np.arange(1,17).reshape(4,4)
print(a)
print("--------hsplit------------")
r,w =np.hsplit(a,2)
print(r)
print(w)
print("--------hsplit-位置分两部分-----------")
r,w=np.hsplit(a,[3])
print(r)
print(w)

print("--------vsplit------------")
r,w =np.vsplit(a,2)
print(r)
print(w)
print("--------vsplit--位置分两部分----------")
r,w =np.vsplit(a,[3])
print(r)
print(w)

数组的转置

import numpy as np

a = np.arange(1,25).reshape(8,3)
print(a,a.shape)
print("-----方法yi:transpose转置a[i][j]——>a[j][i]-------------")
b=a.transpose()
print(b,b.shape)
print("-----方法二:.T")
print(a.T,a.shape)
print("-----方法三np.transpose(a)-------------")
c=np.transpose(a)
print(c,c.shape)

import numpy as np
print("------------三维---------------")
a = np.arange(1,25).reshape(2,3,4)
print(a,a.shape)

print("-----对于三维a[i][j][k]进行转置默认为i与k交换---------------")
b=np.transpose(a)
print(b,b.shape)

#官方：>> > x = np.ones((1, 2, 3))
#官方：>> > np.transpose(x, (1, 0, 2)).shape

#原本是(2,3,4)，经过（1,2,0）的顺序转置得到（3,4,2）
c =np.transpose(a,(1,2,0))
print(c,c.shape)

算术函数

如果参与运算的两个对象都是ndarray，并且形状相同，那么对位彼此之间进行（+-*/）运算。NumPy算术函数包含简单的加减乘除add(),subtract(),multiply()和divide()

import numpy as np

a = np.arange(9).reshape(3,3)
b=np.array([10,10,10])
print("---------加法---方法一--------")
print(np.add(a,b))
print("--------方法二-----------")
print(a+b)
print("---------减法---方法一--------")
print(np.subtract(b,a))
print(b-a)
print("---------乘法--------")
y=np.empty((3,3),dtype=np.int32)
#a的每个元素都x10，存放到y的空的数组里面
np.multiply(a,10,out=y)
print(y)

数学函数

NumPy提供了标准的三角函数：sin()，cos()，tan()

import numpy as np


a=np.array([0,30,60,90])
print(np.sin(a))
print(np.cos(a))
print(np.tan(a))

around()返回四舍五入

numpy.around(a,decimals)

import numpy as np

print("-------around四舍五入------------------")
a = np.array([1.0 ,  4.55, 123,   0.567,  25.332])
print('around',np.around(a))
print("-------ceil向上取整------------------")
print('ceil',np.ceil(a))
print("-------floor向下取整------------------")
print('floor',np.floor(a))

聚合函数

NumPy提供了很多统计函数，用于从数组中查找最小元素，最大元素，百分位标准差和方差等。

import numpy as np

print("-------power--------------")
a =np.arange(1,13).reshape(3,4)
print(a)
print("pow:",np.power(a,2))

print("-------power中out的使用--------------")
x = np.arange(5)
y=np.zeros(10)
np.power(2,x,out=y[:5])
print(y)

import numpy as np

print("------median-中位数---一维----------")
#1.对数组排序[1,2,3,4,6]
#数组中元素为偶数，中位数指：中间两个数的平均值
#数组中元素个数为奇数，中位数指中间的那个数
a =np.array([4,3,6,2,2,1])
print(np.median(a))

print("------median二维--要同过axis指定轴--------")
a=np.arange(1,13).reshape(3,4)
print(a)
print('垂直方向',np.median(a,axis=0))
print('水平方向',np.median(a,axis=1))

import numpy as np

print("------mean-平均数---一维----------")

a =np.array([4,3,6,2,2,1])
print(np.mean(a))


print("------mean二维--要同过axis指定轴--------")
a=np.arange(1,13).reshape(3,4)
print(a)
print('axis=0,垂直方向',np.mean(a,axis=0))
print('axis=0,水平方向',np.mean(a,axis=1))

import numpy as np


a= np.array([4,3,5,2,5,2])
print('sum',np.sum(a))
print('max',np.max(a))
print('min',np.min(a))
print('argmin',np.argmin(a))
print('argmax',np.argmax(a))