python-----numpy介绍

1 numpy简介

numpy是python用于快速处理大型矩阵的科学计算库，numpy允许在python中做向量和矩阵的运算。numpy的主要对象是同质多维数组，也就是在一个元素表中，元素的类型都是相同的。
numpy的数组类称为ndarray,别名为array。numpy.array与标准python库类array.array不一样，标准库类中只能处理一维数组并且功能相对较少。
例子1.1 查看numpy版本
输入

import numpy
print(numpy._version_)

输出：1.13.1

ndarray对象属性

属性	含义
T	转置，与self.transpose()相同，如果维度小于2，返回self
size	数组中元素个数，等于shape元素的乘积
itemsize	该属性等价于ndarray.dtype.itemsize
dtype	数组元素的数组类型对象
ndim	数组的轴的数量
shape	数组的维度
data	该缓冲区包含了数组是实际元素
flat	返回数组的一维迭代器
imag	返回数组的虚部
real	返回数组的实部
nbytes	数组中所有元素的字节长度

例子1.2 初始numpy
输入：

import numpy as np
a=np.random.random(5);
print(type(a))

输出：
<class ‘numpy.ndarray’>

输入：

print(a.shape)

输出：
(5,)

输入：

print(a)

输出：
[0.74362598 0.0712265 0.07792622 0.89811625 0.35490374]

例子1.2说明通过np.randm.random(5)生成一个浮点数组，类型为numpy.ndarray，a.shape显示a的长度为5，最终生成的结果为[0.74362598 0.0712265 0.07792622 0.89811625 0.35490374]。

2 numpy数组类型

对于科学计算来说，python自带的整型、浮点型和复数类型远远不够，因此numpy添加了许多数据类型。
numpy数据类型

类型	描述规则
bool	用一位储存的布尔类型
inti	由所在平台决定其精度的整数
int8	整数，范围-128至127
int16	整数，范围-32768至32767
int32	整数，范围-232至232-1
int64	整数，范围-264至264-1
unit8	整数，范围0至255
unit16	整数，范围0至65535
unit32	无符号整数，范围0至232-1
uint64	整数，范围0至264-1
float16	半精度浮点数（16位），其中用1位表示正负号，5位表示指数，10位表示尾数
float32	单精度浮点数（32位），其中用1位表示正负号，8位表示指数，23位表示尾数
float64或float	双精度浮点数（64位），其中用1位表示正负号，11位表示指数，52位表示尾数
complex32	复数，分别用两个32位浮点数表示实部和虚部
complex64	复数，分别用两个64位浮点数表示实部和虚部

在使用numpy的过程中，可以使用dtype来指定数据类型，也可以使用astype（）来指定。

例子1.3 numpy数据类型操作
输入：

#指定数据类型
print(np.array(10,dtype=int))

输出：
10

输入：

#指定数据类型
print(np.array(10).astype(float))

输出：
10.0

例子1.4查看numpy的数据类型
输入：

print(set(np.typeDict.values()))

输出：
{<class ‘numpy.float16’>, <class ‘numpy.complex128’>, <class ‘numpy.bytes_’>, <class ‘numpy.uint16’>, <class ‘numpy.complex64’>, <class ‘numpy.complex128’>, <class ‘numpy.timedelta64’>, <class ‘numpy.int32’>, <class ‘numpy.float64’>, <class ‘numpy.uint8’>, <class ‘numpy.void’>, <class ‘numpy.int64’>, <class ‘numpy.uint32’>, <class ‘numpy.object_’>, <class ‘numpy.int8’>, <class ‘numpy.int32’>, <class ‘numpy.uint64’>, <class ‘numpy.int16’>, <class ‘numpy.uint32’>, <class ‘numpy.str_’>, <class ‘numpy.datetime64’>, <class ‘numpy.float32’>, <class ‘numpy.bool_’>, <class ‘numpy.float64’>}

3 numpy创建数组

3.1 通过列表或元组转化

在python内建对象中，数组有3种形式：列表（list）、元组（tuple）、字典（dict）。具体形式如下。
list：[1,2,3]
tuple:(1,2,3)
dict:{a:1,b:2}
在numpy中，使用numpy.array将列表或元组转换为ndarray数组。其方法为：
numpy.array(object,dtype=none,copy=ture,order=none,sunok=false,ndmin=0)
相关参数如下。
object：输入对象列表、元组等。
dtype：数据类型。如果未给出，则类型为被保存对象所需的最小类型。
copy：布尔类型，默认为ture，表示复制对象。
order：顺序。
subok：布尔类型，表示子类是否被传递
例子1.4 numpy.array创建数组
输入：

import numpy as np
a=np.array([[1,2],[7,8,9]])
print(type(a))
print(a)

输出：

<class ‘numpy.ndarray’>
[list([1, 2]) list([7, 8, 9])]

3.2 arange函数创建数组

arange()的功能是在给定区间内创建等差数组，多用于迭代，arange类似于range，两者的区别主要在返回值上，arange返回的是list，而range返回的是一个数组。
（1）range函数为range（start,stop[,step]）,根据start和stop指定的范围以及step设定的步长，生成一个序列，函数返回的是一个range object。

1. start：计数从start开始，默认是从0开始，例如range(5)等价于range(0,5)。
2. stop：计数到end结束，但不包括stop，例如range（0，5）是[0,1,2,3,4]。
3. step：每次跳跃的间距，默认为1且不支持步长为小数。

（2）arange函数为arange（start=none,stop=none,step=none,dype=none）,根据start和stop指定的范围以及step设定的步长，生成一个ndarray。

1. start与stop参数同range。
2. step：步长支持小数。
3. dtype：可选参数，可以设置返回ndarray的值类型。
   例子1.5 arange案例
   输入：

import numpy as np
a=np.arange(10)
print(a)
a2=np.arange(1,3,0.1)
print(a2)

输出：
[0 1 2 3 4 5 6 7 8 9]
[1. 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2. 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9]

3.3 linspace生成等差数列

linspace同于在指定区间返回间隔均匀的值，其方法为：
numpy.linspace(start,stop,num=50,endpoint=ture,retstep=false,dtype=None)

1. start：序列的起始值。
2. stop：序列的结束值。
3. num：生成的样本数，默认值为50。
4. endpoint：布尔值，如果为ture，则最后一个样本包含在序列内。
5. retstep：布尔值，如果为ture，返回间距。
6. dtype：数组的类型。
   例子1.6 linspace案例
   输入

import numpy as np
a=np.linspace(start=0,stop=10,num=10,endpoint=True)
print(a)
print(a.shape)

输出：
[ 0. 1.11111111 2.22222222 3.33333333 4.44444444 5.55555556 6.66666667 7.77777778 8.88888889 10. ]
(10,)

输入

import numpy as np
a=np.linspace(start=0,stop=10,num=10,endpoint=False)
print(a)
print(a.shape)

输出：
[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
(10,)

3.4 logspace生成等差数列

logspace同于在指定区间生成等比数列，其方法为：
numpy.logspace(start,stop,num=50,endpoint=ture,base=10,dtype=None)

1. start：基底base的start次幂作为左边界。
2. stop：基底base的stop次幂作为左边界。
3. num：生成的样本数，默认值为50。
4. endpoint：布尔值，如果为ture，则最后一个样本包含在序列内。
5. base：基底，如取对数的时候log的下标。
6. dtype：数组的类型。
   例子1.7 linspace案例
   输入

#生成首位是10的0次方。末尾是10的2次方，包含10个数
import numpy as np
a=np.logspace(start=0,stop=2,num=10,endpoint=True)
print(a)
print(a.shape)

输出：
[ 1. 1.66810054 2.7825594 4.64158883 7.74263683
12.91549665 21.5443469 35.93813664 59.94842503 100. ]
(10,)

3.5 ones与zeros系列函数

（1）ones：返回一个全是1 的数组。函数形式：
ones（shape,dtype=None,order=‘C’）

1. shape：定义返回数组的形状，形如（2，3）或2。
2. dtype：数据类型，可选。返回数组的数据类型，例如numpy.int8、默认numpy.float64。
3. order：{‘C’,‘F’},规定返回数组元素在内存的储存顺序。例如C（C语言）-row-major；F（Fortran）-column-major。
   例子1.8 ones案例
   输入：

import numpy as np
a=np.ones(4)
b=np.ones((4,),dtype=np.int)
c=np.ones((2,1))
s=(2,2)
d=np.ones(s)
v=np.array([[1,2,3],[4,5,6]])
e=np.ones_like(a)
print("a={}\nb={}\nc={}\nd={}\ne={}".format(a,b,c,d,e))

输出：
a=[1. 1. 1. 1.]
b=[1 1 1 1]
c=[[1.]
[1.]]
d=[[1. 1.]
[1. 1.]]
e=[1. 1. 1. 1.]

（2）zeros：返回一个全是0的数组。函数形式：
ones（shape,dtype=None,order=‘C’），参数同ones。
例子1.9 zeros案例
输入：

import numpy as np
a=np.zeros(4)
b=np.zeros((4,),dtype=np.int)
c=np.zeros((2,1))
s=(2,2)
d=np.zeros(s)
e=np.zeros((2,),dtype=[('x','i4'),('y','i4')])
x=np.arange(8)
x=x.reshape((2,4))
f=np.zeros_like(x)
v=np.array([[1,2,3],[4,5,6]])
e=np.ones_like(a)
print("a={}\nb={}\nc={}\nd={}\ne={}\nf={}".format(a,b,c,d,e,f))

输出：
a=[0. 0. 0. 0.]
b=[0 0 0 0]
c=[[0.]
[0.]]
d=[[0. 0.]
[0. 0.]]
e=[1. 1. 1. 1.]
f=[[0 0 0 0]
[0 0 0 0]]
（3）empty：返回一个新的空数组。函数形式：
empty（shape,dtype=None,order=‘C’）参数同ones。
（4）eye：依据给定的参数，生成K个对角线的元素为1、其他元素为0的数组。函数形式：eye（N,M=None,K=0,dtype=float)

1. N：整数，返回数组的行数
2. M：整数，返回数组的列数。如果不赋值，则默认等于N。
3. k：整数，可选对角线序列号，例如0对应主对角线，正数对应upper diagonal，负数对应lower diagonal。
4. dtype：可选返回数组的数据类型。
   例子1.10 eye案例
   输入：

import numpy as np
a=np.eye(4,dtype=np.int)
b=np.eye(4,k=1)
print("a={}\nb={}".format(a,b))

输出：
a=[[1 0 0 0]
[0 1 0 0]
[0 0 1 0]
[0 0 0 1]]
b=[[0. 1. 0. 0.]
[0. 0. 1. 0.]
[0. 0. 0. 1.]
[0. 0. 0. 0.]]
（5）identity：依据给定的参数，一个n维单位方阵。函数形式：
identity（n,dtype=None）参数同ones。
例子1.11 identity案例
输入：

import numpy as np
a=np.identity(3)
print(a)

输出：
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]