机器学习三剑客之Numpy

Numpy简单创建数组

import numpy as np

a = [1, 2, 3]
b = np.array(a)
c = np.array([[0, 1, 2, 10],
               [12, 13, 100, 101],
               [102, 110, 112, 113]], int)
print(c)
print(b)

创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：

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

 创建数值为1的数组：

Numpy.ones(参数 1：shape，数组的形状；参数 2：dtype， 数值类型)

array_one = np.ones((10, 10), dtype=np.int)
print(array_one)

创建数值为0的数组：

Numpy.zeros(参数 1：shape，数组的形状；参数 2：dtype， 数值类型)

array_zero = np.zeros((10, 10),  dtype=np.float)
print(array_zero)

创建指定数值的数组：

Numpy.full(参数 1：shape，数组的形状； 参数 2：constant value，数组填充的常数值；参数 3：dtype， 数值类型)

array_full = np.full((10, 10), 5)
print(array_full)

创建单位矩阵：

Numpy.eye(参数 1：N，方阵的维度)

array_eye = np.eye(5)
print(array_eye)

创建对角矩阵：

Numpy.diag：以一维数组的形式返回方阵的对角线（或非对角线）元素，或将一维数组转换成方阵（非对角线元素为0）.两种功能角色转变取决于输入的v。

参数详解：

    v : array_like.

如果v是2D数组，返回k位置的对角线。

如果v是1D数组，返回一个v作为k位置对角线的2维数组。

    k : int, optional

对角线的位置，大于零位于对角线上面，小于零则在下面。

x = np.arange(9).reshape((3,3))
print(x)
print(np.diag(x))
print(np.diag(x, k=1)) 
print(np.diag(x, k=-1))
print(np.diag(np.diag(x)))

Numpy创建随机数组（np.random）：

均匀分布：

创建指定形状的数组，数值范围在0~1之间：

array_rand = np.random.rand(10, 10)
print(array_rand)
print(array_rand.ndim)

创建指定范围内的一个数：Numpy.random.uniform(low, high, size=None)：

array_uniform = np.random.uniform(0, 100, 5)
print(array_uniform)

 也可以直接指定多为数组：

array_uniform = np.random.uniform(0, 100, (4, 5))
print(array_uniform)

创建指定范围的一个整数：Numpy.random.randint(low, high, size=None)：

array_randint = np.random.randint(0, 100, 10)
print(array_randint)

 也可以直接指定多为数组：

array_randint = np.random.randint(0, 100, (4, 5))
print(array_randint)

重新组织数组顺序： np.random.shuffle(x)

一维和多维数组都可以

Numpy.arange(start, stop, step)：

创建一个秩为1的array，其中包含位于半开区间[start, stop)内并均匀分布的值，step表示两个相邻值之间的差。 

array_arange = np.arange(1, 20, 2, dtype=np.int)
print(array_arange)

Numpy.linspace(start, stop, N)：

创建N个在闭区间[start, stop]内均匀分布的值。

array_linspace = np.linspace(1, 20, 10)
print(array_linspace)

正态分布

创建给定均值、标准差、维度的正态分布：Numpy.random.normal(loc, scale, size)：

参数的意义为：

loc：float 此概率分布的均值（对应着整个分布的中心centre）

scale：float 此概率分布的标准差（对应于分布的宽度，scale越大越矮胖，scale越小，越瘦高）

size：int or tuple of ints 输出的shape，默认为None，只输出一个值

# 正态生成4行5列的二位数组
array_normal = np.random.normal(loc=1.75, scale=0.1, size=[4, 5])
print(array_normal)
print(array_normal.ndim)

 我们更经常会用到的np.random.randn(size)所谓标准正态分布（μ=0,σ=1），对应于np.random.normal(loc=0, scale=1, size)。

Numpy数组操作：

数组的索引

array[start : end]

array[start:]

array[:end]

# 截取第0至第3行，第2至第4列（从第0行第0列算起）
after_array = array_normal[:3, 2:4]
print(after_array)

数组的复制

Numpy.copy(参数 1：数组)：创建给定array的一个副本，还可当做方法用。

import numpy as np

after_array = array_normal[:3, 2:4].copy()
copy_array = np.copy(array_normal[:, 2:4])

数组排序

Numpy.sort：

(参数 1：a，数组；参数 2：axis=0/1，0表示行1表示列)：np.sort()作为函数使用时，不更改被排序的原始array；array.sort()作为方法使用时，会对原始array修改为排序后数组array

import numpy as np

# 整体排序
np.sort(array_normal)
# 仅行排序
np.sort(array_normal, axis=0)
# 仅列排序
np.sort(array_normal, axis=1)

 Numpy.argsort：

将列表中的元素从小到大排列，提取其对应的index(索引)，然后输出到y。如果是二维数组则添加axis指定是按照行来排还是列来排。

数组唯一元素

Numpy.unique(参数 1：a，数组；参数 2：return_index=True/False，新列表元素在旧列表中的位置；参数 3：return_inverse=True/False，旧列表元素在新列表中的位置；参数 4：return_counts，元素的数量；参数 5：axis=0/1，0表示行1表示列)：查找array中的唯一元素。

import numpy as np

print("提取唯一元素", np.unique(array_normal))
print("提取唯一元素", np.unique(array_normal, return_index=True))
print("提取唯一元素", np.unique(array_normal, return_counts=True))
print("提取唯一元素", np.unique(array_normal, return_index=True, return_inverse=True, axis=0))

数组的改变

数组转置

array_normal.T

arr.transpose()

reshape()：

把指定的数组改变形状，但是元素个数不变；有返回值，即不对原始多维数组进行修改。

X=np.array([1,2,3,4,5,6,7,8])
 
X_2=X.reshape((2,4)) #retuen a 2*4 2-dim array
X_3=X.reshape((2,2,2)) # retuen a 2*2*2 3-dim array
 
print("X:\n",X)
print("X_2:\n",X_2)
print("X_3:\n",X_3)

>>>
X:
 [1 2 3 4 5 6 7 8]
X_2:
 [[1 2 3 4]
 [5 6 7 8]]
X_3:
 [[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]

resize()：

把指定的数组改变形状，但是元素个数可变，不足补0；resize有两种使用方式，一种是没有返回值的，直接对原始的数据进行修改，还有一种用法是有返回值的，所以不会修改原有的数组值。

有返回值，不对原始数据进行修改

import numpy as np

X=np.array([[1,2,3,4],
              [5,6,7,8],
              [9,10,11,12]])
 
X_new=np.resize(X,(3,3)) # do not change the original X
print("X:\n",X)  #original X
print("X_new:\n",X_new) # new X

>>>
X:
 [[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
X_new:
 [[1 2 3]
 [4 5 6]
 [7 8 9]]

无返回值，直接修改原始数组的大小

import numpy as np

X=np.array([[1,2,3,4],
              [5,6,7,8],
              [9,10,11,12]])
 
X_2=X.resize((3,3))  #change the original X ,and do not return a value
print("X:\n",X)  # change the original X
print("X_2:\n",X_2) # return None

>>>
X:
 [[1 2 3]
 [4 5 6]
 [7 8 9]]
X_2:
 None

*Numpy计算

条件运算

Numpy.where(condition, x, y)：

三目运算满足condition，为x；不满足condition，则为y

score = np.array([[80, 88], [82, 81], [84, 75], [86, 83], [75, 81]])
# 如果数值小于80，替换为0，如果大于等于80，替换为90
re_score = np.where(score < 80, 0, 90)
print(re_score)

布尔型索引 

array[array>10 & array<20]

# 布尔型索引：按条件截取/设置
arr[arr>2] = 0
np.where(arr > 5, 5, 0)

统计运算

指定轴最大值：

amax(参数1：数组；参数2：axis=0/1，0表示行1表示列)

import numpy as np

# 求整个矩阵的最大值
result = np.amax(score)
print(result)
# 求每一列的最大值（0表示列）
result = np.amax(score, axis=0)
print(result)
# 求每一行的最大值（1表示行）
result = np.amax(score, axis=1)
print(result)

指定轴最小值：

amin(参数1：数组；参数2：axis=0/1，0表示行1表示列)

# 求整个矩阵的最小值
result = np.amin(score)
print(result)
# 求每一列的最小值（0表示行）
result = np.amin(score, axis=0)
print(result)
# 求每一行的最小值（1表示列）
result = np.amin(score, axis=1)
print(result)

指定轴平均值：

mean(参数1：数组；参数2：axis=0/1，0表示行1表示列；参数3：dtype，输出数据类型)

# 求整个矩阵的平均值
result = np.mean(score, dtype=np.int)
print(result)
# 求每一列的平均值（0表示行）
result = np.mean(score, axis=0)
print(result)
# 求每一行的平均值（1表示列）
result = np.mean(score, axis=1)
print(result)

指定轴方差：

std(参数1：数组；参数2：axis=0/1，0表示行1表示列；参数3：dtype，输出数据类型)

import numpy as np

# 求整个矩阵的方差
result = np.std(score)
print(result)
# 求每一列的方差（0表示列）
result = np.std(score, axis=0)
print(result)
# 求每一行的方差（1表示行）
result = np.st

求和：

Numpy.sum()

求中值：

Numpy.median()

数组运算

数组与数的运算（加、减、乘、除、取整、取模）

import numpy as np

# 循环数组行和列，每一个数值都加5
score[:, :] = score[:, :]+5
print(score)
# 循环数组行和列，每一个数值都减5
score[:, :] = score[:, :]-5
print(score)
# 循环数组行和列，每一个数值都乘以5
score[:, :] = score[:, :]*5
print(score)
# 循环数组行和列，每一个数值都除以5
score[:, :] = score[:, :]/5
print(score)
# 循环数组行和列，每一个数值除以5取整
score[:, :] = score[:, :] // 5
print(score)
# 循环数组行和列，每一个数值除以5取模
score[:, :] = score[:, :] % 5
print(score)

数组间运算

（加、减、乘、除），前提是两个数组的shape一样

加：“+”或者np.add(a, b)

减：“-”或者np.subtract(a, b)

乘：“*”或者np.multiply(a, b)

除：“/”或者np.divide(a, b)

import numpy as np

c = score + score
d = score - score
e = score * score
# 分母数组保证每个数值不能为0
b = score / score

Numpy.intersect1d(参数 1：数组a；参数 2：数组b)：

查找两个数组中的相同元素

Numpy.setdiff1d(参数 1：数组a；参数 2：数组b)：

查找在数组a中不在数组b中的元素

Numpy.union1d(参数 1：数组a；参数 2：数组b)：

查找两个数组的并集元素

矩阵运算（一种特殊的二维数组）

计算规则

（M行，N列）*（N行，Z列）=（M行，Z列）

st_score = np.array([[80, 88], [82, 81], [84, 75], [86, 83], [75, 81]])
# 平时成绩占40% 期末成绩占60%, 计算结果
q = np.array([[0.4], [0.6]])
result = np.dot(st_score, q)
print(result)

矩阵拼接

矩阵垂直拼接（前提两个两个矩阵列数相同，行数随意）：vstack(参数：tuple)

v1 = [[0, 1, 2, 3, 4, 5],
       [6, 7, 8, 9, 10, 11]]
v2 = [[12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23],
       [18, 19, 20, 21, 22, 23]]
result = np.vstack((v1, v2))
print(result)

矩阵水平拼接（前提两个两个矩阵行数相同，列数随意）：

hstack(参数：tuple)

import numpy as np

v1 = [[0, 1, 2, 3, 4, 5],
      [6, 7, 8, 9, 10, 11]]
v2 = [[12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23]]
result = np.hstack((v1, v2))
print(result)

矩阵删除：

Numpy.delete(参数 1：a，数组；参数 2：elements，删除的对象；参数 3：axis=0/1) 

import numpy as np

OriginalY = np.array([[1, 2, 3],
                     [4, 5, 6],
                     [7, 8, 9]])
print(np.delete(OriginalY, [0, 2]))
print(np.delete(OriginalY, [0, 2], axis=0))
print(np.delete(OriginalY, [0, 2], axis=1))

矩阵添加：

Numpy.append(参数 1：array，数组；参数 2： elements，添加元素；参数 3： axis=0/1)

import numpy as np

OriginalY = np.array([[1, 2, 3],
                     [4, 5, 6],
                      [7, 8, 9]])
# 末尾添加元素
print(np.append(OriginalY, [0, 2]))
# 最后一行添加一行
print(np.append(OriginalY, [[0, 2, 11]], axis=0))
# 最后一列添加一列（注意添加元素格式）
print(np.append(OriginalY, [[0], [2], [11]], axis=1))

矩阵插入：

Numpy.insert(参数 1：array，数组；参数 2：index，插入位置索引；参数 3： elements，添加元素；参数 4： axis=0/1) 

OriginalY = np.array([[1, 2, 3],
                      [4, 5, 6],
                      [7, 8, 9]])
print(np.insert(OriginalY, 1, [11, 12, 10]))
print(np.insert(OriginalY, 1, [[11, 12, 10]], axis=0))
# 在列索引1的位置插入（注意元素格式，跟添加格式不同）
print(np.insert(OriginalY, 1, [[11, 12, 10]], axis=1))

文件加载

np.loadtxt(fname,dtype,comments='#',delimiter=None,skiprows=0,usecols=None)

fname:读取的文件、文件名

dtype：数据类型

comments：注释

delimiter：分隔符，默认是空格

skiprows：跳过前几行读取，默认是0

usecols：读取哪些列，usecols=（1， 2， 5）读取第1,2,5列，默认所有列

广播

b = np.arange(0, 51, 10).reshape(6, 1) + np.arange(6)