Numpy 入门（一）

1.掌握Numpy数组对象ndarray

2.掌握Numpy矩阵与通用函数

3.利用Numpy进行统计分析

创建数组对象

1.数组属性：ndarray(数组)是存储单一数据类型的多维数组

属性	说明
ndim	返回int。表示数组维数
shape	返回tuple。表示数组的尺寸，对于n行m列的矩阵，形状为（n，m）
size	返回int。表示数组的元素总数，等于数组形状的乘积
dtype	返回data-ytpe。描述数组中元素的类型
itemsize	返回int。表示数组中每个元素的大小

2.数组创建

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

参数说明：

object：数组
公开数组接口的任何对象，__array__方法返回数组的对象，或任何（嵌套）序列。

dtype ： 数据类型，可选
数组所需的数据类型。如果没有给出，那么类型将被确定为保持序列中的对象所需的最小类型，默认为None。
此参数只能用于“upcast”数组。对于向下转换，请使用.astype(t)方法。

copy ： bool，可选
如果为true（默认值），则复制对象，
否则，只有当__array__返回副本，obj是嵌套序列，或者需要副本来满足任何其他要求（dtype，顺序等）时，才会进行复制。

order ： bool类型
指定阵列的内存布局。

ndmin ： int
接收int。
指定生成的数组应具有的最小维数。默认为None，根据需要，将根据需要预先设置形状。

import numpy as np
arr1=np.array([1,2,3,4])
print(arr1)

[1 2 3 4]

arr2=np.array([[1,2,3,4],[7,8,9,10],[11,12,13,14]]) # 创建二维数组
print(arr2)

[[ 1  2  3  4]
 [ 7  8  9 10]
 [11 12 13 14]]

print("创建的数组维度是：",arr2.shape) # 查看数组结构 (3行，4列)

创建的数组维度是： (3, 4)

arr2.dtype  # 查看数组类型

dtype('int32')

arr2.size  # 查看数组元素个数

12

arr2.itemsize  # 查看数组中每个元素的大小

4

arr2.shape= 4,3  # 重新设置shape
arr2.shape

(4, 3)

arr2

array([[ 1,  2,  3],
       [ 4,  7,  8],
       [ 9, 10, 11],
       [12, 13, 14]])

使用arange函数创建数组
arange非常类似range函数，两者的区别仅仅是arange返回的是一个数据，而range返回的是list。

[i for i in range(0,5,2)]

[0, 2, 4]

# 若需要生成[ 0.   0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9]

range(0,1,0.1)    # 注意：range中的设置步长的参数 不能使float

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-20-1e20c6016c6e> in <module>
      1 # 若需要生成[ 0.   0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9]
      2 
----> 3 range(0,1,0.1)    # 注意：range中的设置步长的参数 不能使float


TypeError: 'float' object cannot be interpreted as an integer

arrange()函数

函数说明：arange([start,] stop[, step,], dtype=None)
根据start与stop指定的范围以及step设定的步长，生成一个 ndarray。 dtype : dtype

np.arange(3)

array([0, 1, 2])

np.arange(3.0)

array([0., 1., 2.])

np.arange(3,7,2)

array([3, 5])

np.arange(0,1,0.1)

array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])

使用linspace函数创建数组
np.linspace主要用来创建等差数列。

np.linspace(0,1,12) 

array([0.        , 0.09090909, 0.18181818, 0.27272727, 0.36363636,
       0.45454545, 0.54545455, 0.63636364, 0.72727273, 0.81818182,
       0.90909091, 1.        ])

**使用logspace函数创建数组**   
np.logspace主要用来创建等比数列。

np.logspace(0,2,20)

array([  1.        ,   1.27427499,   1.62377674,   2.06913808,
         2.6366509 ,   3.35981829,   4.2813324 ,   5.45559478,
         6.95192796,   8.8586679 ,  11.28837892,  14.38449888,
        18.32980711,  23.35721469,  29.76351442,  37.92690191,
        48.32930239,  61.58482111,  78.47599704, 100.        ])

使用zeros函数创建数组
返回来一个给定形状和类型的用0填充的数组；

np.zeros((2,3))

array([[0., 0., 0.],
       [0., 0., 0.]])

使用eye函数创建数组
返回的是一个二维2的数组(N,M)，对角线的地方为1，其余的地方为0.

np.eye(3)

array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])

**使用diag函数创建数组**   
返回：一个对角矩阵。对角矩阵是仅在主对角线上有值的方形矩阵。

np.diag([1,2,3,4])  # 表示一个四阶对角矩阵，其主对角线上的元素为1，2，3，4其它元素都是零 

array([[1, 0, 0, 0],
       [0, 2, 0, 0],
       [0, 0, 3, 0],
       [0, 0, 0, 4]])

**使用ones函数创建数组**   
返回来一个给定形状和类型的用1填充的数组；

np.ones((5,3))

array([[1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.],
       [1., 1., 1.]])

数组数据类型

类型	描述
bool	布尔类型（值为Ture或False）
inti	由所在平台决定其精度的整数（一般为int32或int64）
int8	整数，范围 -128至127
int16	整数，范围 -32769至32767
int32	整数，范围 -231至232-1

np.float64(42)  # 整形转换为浮点型

42.0

np.float(True)  # 布尔型转换为浮点型

1.0

np.float(False)  # 布尔型转换为浮点型

0.0

np.bool(42)  # 整形转换为布尔型

True

np.bool(0)  # 整形转换为布尔型

False

在使用array函数创建数组时，数组的数据类型默认为是浮点型，可以预先指定数据类型

a=np.array([1,2,3,4],dtype=float)

a.dtype

dtype('float64')

b=np.array([1,2,3,4])

b.dtype

dtype('int32')

random

numpy.random.random()　
生成随机浮点数,默认为生成一个随机的浮点数，范围是在0.0到1.0之间，也可以通过参数size设置返回数据的size;
注意是半开区间 [0.0, 1.0) 内的随机浮点数

x= np.random.random((3,3))

x

array([[0.79380854, 0.8658594 , 0.10515032],
       [0.61299442, 0.4141855 , 0.20268232],
       [0.52782164, 0.53417544, 0.95799718]])

np.random.randint(start, stop, size = shape)
会创建一个具有给定形状的 ndarray，其中包含在半开区间 [start, stop) 内的随机整数。

x= np.random.randint(4,15,size=(3,2))

x

array([[11, 10],
       [ 9, 13],
       [ 8,  7]])

通过索引访问数组

arr=np.arange(10)

arr

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

arr[0]

0

arr[-1]

9

arr[0:-1]

array([0, 1, 2, 3, 4, 5, 6, 7, 8])

arr[:5]

array([0, 1, 2, 3, 4])

arr[1:-1:2]

array([1, 3, 5, 7])

arr[5:1:-2]

array([5, 3])

arr=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])

arr

array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12],
       [13, 14, 15, 16]])

arr[3]

array([13, 14, 15, 16])

arr[0]

array([1, 2, 3, 4])

arr[1,3]  # （第1行，第3列） 注意行列都是从0开始的

8

arr[0,0:4]  # 索引第0行中第3列和第4列的元素

array([1, 2, 3, 4])

arr[1:,2:] # 索引第2行和第4行中第3到4列的元素

array([[ 7,  8],
       [11, 12],
       [15, 16]])

arr[(0,1,2),(1,2,3)]
# 索引(0,1),(1,2),(2,3)的元素

array([ 2,  7, 12])

arr[1:,(1,2,3)]  # 索引2,3行中第0,2,3列的元素

array([[ 6,  7,  8],
       [10, 11, 12],
       [14, 15, 16]])

改变数组形状

arr=np.arange(12)

arr

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

arr.reshape(3,4) # 设置数组形状

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

arr.reshape(3,4).ndim   # 返回数组维度，2维数组

2

使用 ravel函数展平数组

arr.ravel()

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

使用 flatten函数展平数组

arr.flatten()  # 横向展平

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

arr.flatten('F')  # 纵向展平

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

arr1=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])

arr1

array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12],
       [13, 14, 15, 16]])

arr1.flatten('F')  # 纵向展平

array([ 1,  5,  9, 13,  2,  6, 10, 14,  3,  7, 11, 15,  4,  8, 12, 16])

arr2=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])

arr2

array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12],
       [13, 14, 15, 16]])

arr.flatten()  # 横向展平

array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16])

创建numpy矩阵

使用mat函数创建矩阵:

m1=np.mat("123;456;789")

m1

matrix([[123],
        [456],
        [789]])

使用matrix函数创建矩阵

m2=np.matrix([[123],[456],[789]])

m2

matrix([[123],
        [456],
        [789]])

使用bmat函数合成矩阵

np.bmat("arr1 arr2;arr1 arr2")

matrix([[ 1,  2,  3,  4,  1,  2,  3,  4],
        [ 5,  6,  7,  8,  5,  6,  7,  8],
        [ 9, 10, 11, 12,  9, 10, 11, 12],
        [13, 14, 15, 16, 13, 14, 15, 16],
        [ 1,  2,  3,  4,  1,  2,  3,  4],
        [ 5,  6,  7,  8,  5,  6,  7,  8],
        [ 9, 10, 11, 12,  9, 10, 11, 12],
        [13, 14, 15, 16, 13, 14, 15, 16]])

矩阵运算

矩阵与数相乘：m1*3

m1*3

matrix([[ 369],
        [1368],
        [2367]])

矩阵相加减：m1+或-m2

m1+m2

matrix([[ 246],
        [ 912],
        [1578]])

m1-m2

matrix([[0],
        [0],
        [0]])

矩阵相乘：m1*m2

# m1*m2

矩阵对应元素相乘：np.multiply(m1,m2)

np.multiply(m1,m2)

matrix([[ 15129],
        [207936],
        [622521]])

矩阵特有属性：

属性	说明
T	返回自身的转置
H	返回自身的共轭转置
I	返回自身的逆矩阵
A	返回自身数据的2维数组的一个视图

ufunc函数

是一种能够对数组中所有元素进行操作的函数

四则运算
比较运算
逻辑运算：np.any函数表示逻辑“or”,np.all函数表示逻辑“and”，运算结果返回布尔值。

ufunc函数的广播机制

广播是指不同形状的数组之间执行算术运算的方式，需要遵循4个原则

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

numpy文件读写

numpy文件读写主要有二进制文件的读写和文件列表形式的数据读写两种形式

save函数是以二进制的格式保存数据。np.save(‘文件路径’,arr)

load函数是从二进制的文件中读取数据。np.load(‘文件路径’)

savez函数可以将多个数据保存到一个文件中。np.savez(‘文件路径’,arr1,arr2)

存储时可以省略扩展名，但读取时不能省略扩展名

读取文本格式的数据

savetx函数是将数组写到某种分隔符隔开的文本文件中
np.savetx(“文件路径”,arr,fmt="%d",delimiter=",")

loadtxt函数执行的是把文件加载到一个二维数组中
np.loadtxt(“文件路径”,delimiter=",")

genfromtxt函数面向的是结构化数组和缺失数据
np.genfromtxt(“文件路径”,delimiter=",")

排序

sort函数，最常用
arr.sort()

也可以指定一个axis参数，使得sort函数可以沿着指定轴对数据集进行排序
axis=1 为沿着横轴排序
axis=0 为沿着纵轴排序

argsort函数返回值为重新排序值的下标。arr.argsort()

lexsort函数返回值是按照最后一个传入数据排序的。np.lexsort((a,b,c))

去重与重复数据

unique函数可以找出数组中的唯一值并返回已排序的结果

tile函数，主要有两个参数，参数“A”指定重复的数组，参数“reps”指定重复的次数
np.tile(A,reps)

repeat函数主要有三个参数，，参数“a”是需要重复的数组元素，参数“repeats”是重复的次数，
“axis”是指定沿着哪个轴进行重复
np.repeat(a,repeats,axis=None)

区别：tile函数是对数组进行重复操作，repeat函数是对数组中的每个元素进行重复操作

常用的统计函数

函数	说明
sum	计算数值的和
mean	计算数组均值
std	计算数组标准差
var	计算数组方差
min	计算数组最小值
max	计算数组最大值
argmix	返回数组最小元素的索引
argmax	返回数组最大元素的索引
cumsum	计算所有元素的累计和
cumprod	计算所有元素的累计积