Numpy函数的使用总结（一）

1.数组创建

1.1创建一维0数组

import numpy as np

arr = np.zeros(10)

1.2查询index

arr[4]

1.3创建[10, 10]的二维0数组

arr = np.zeros((10, 10))
#元素位置查询，查询第二行、第三列的元素
arr[1, 2]
#arr数组中元素的个数
print(arr.size)
#arr数组元素的类型占的字节数
print(arr.itemsize)

1.4创建类似遍历range的数组.arange

#区间为10-48，包头不包尾
arr = np.arange(10, 49)

1.5数组的反转

#arr[start:end:step]
#step=-1位反转
arr = arr[::-1]

1.6利用arange创建二维矩阵，通过reshape

arr = np.arange(1, 10).reshape(3, 3)

1.7生成对角矩阵

#返回一个对角线为 1，其他地方为 0 的二维数组
#eye(N, M=None, k=0, dtype=float, order='C')
#N为int型，M必须与N相同，不写就是默认N
#k：对角线的索引：0（默认）表示主对角线，正值表示上对角线，负值表示下对角线。
#dtype：数据类型
arr = np.eye()

1.8创建一个333的三维矩阵

#维数 * 行数 * 列数
arr = np.random.rand(3, 3, 3)

1.9用随机数创建一个10*10的二维数组

# 通过max和min函数找出最大最小值
arr = np.random.rand(10, 10)
arr.max()
arr.min()

1.10用随机数创建一个10的一维数组

# arr.mean(axis=None, dtype=None, out=None, keepdims=False)
# 返回沿给定轴的数组元素的平均值
arr = np.random.rand(10)
arr.mean()

1.11给定区间随机生成数组

# uniform(low, high, size)
# low：开始
# high：结束
# size：个数或reshape
arr = np.random.uniform(-10, 10, 10)

2.数组的修改与变形

2.1通过索引修改arr数组的元素值

# ones(shape, dtype=None, order='C')
arr = np.ones((10, 10), dtype = int)

# [1:-1]:从第一行/列到最后一行/列，同样包头不包尾
arr[1:-1, 1:-1] = 9

2.2数组填充数值

# ones(shape, dtype=None, order='C')
arr = np.ones((10, 10), dtype = int)
# arr = np.pad(arr, pad_width = 1, mode = 'constant', constant_values= 0)
# array – 要填充的数组。
# pad_width : 填充到每个轴边缘的值的数量，相当于填充的厚度
# mode – 以下字符串值之一或用户提供的函数。
    # 'constant'（默认）具有常量值的填充。
    # 'edge' 填充数组的边值。
    # 'linear_ramp' 填充 end_value 和数组边缘值之间的线性斜坡。
    # 'maximum' Pads 具有沿每个轴的全部或部分向量的最大值。
    # 'mean' 填充所有或部分向量沿每个轴的平均值。
    # 'median' 填充所有或部分向量沿每个轴的中值。
    # 'minimum' Pads 具有沿每个轴的全部或部分向量的最小值。
    # 'reflect' Pads，向量的反射沿每个轴镜像在向量的第一个和最后一个值上。 “对称”焊盘，矢量的反射沿阵列边缘镜像。
    # 'wrap' Pads 沿轴包裹向量。 第一个值用于填充结尾，结束值用于填充开头。
# constant_values：为每个轴设置填充值的值。默认为0，函数中不写也是0
arr = np.pad(arr, pad_width = 1, mode = 'constant', constant_values= 0)

2.3对角线

arr = np.arange(9).reshape(3, 3)
# 取arr的对角线的值
np.diag(arr)
>>[0, 4, 8]

arr = np.arange(9).reshape(3, 3)
# 取arr的对角线上方的值
np.diag(arr, k=1)
>>[1, 5]

arr = np.arange(9).reshape(3, 3)
# 取arr的对角线下方的值
np.diag(arr, k=-1)
>>[3, 7]

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

# k : int, optional
# 对角线的位置。大于零位于对角线上面，小于零则在下面。

# 1+np.arange(4)为一维矩阵，所以返回以其为对角线的二维矩阵
arr = np.diag(1+np.arange(4), k=-1)
print(arr)

2.4数组的复制

# tile(A, reps)
# 参数：
# A – 输入数组。
# reps – 沿每个轴的“A”重复次数
# 返回值：平铺输出数组

# 将这两个数组按行复制出4个[0, 1] [1, 0]
np.title([0, 1], [1, 0], 4)
# 将这两个数组按行和列复制出4个[0, 1] [1, 0]
np.title([0, 1], [1, 0], (4, 4))

2.5标准化处理

标准偏差是均值的平方偏差的平均值的平方根，即std = sqrt(mean(abs(x - x.mean())**2))

arr = np.random.rand(5,5)
# 标准偏差是均值的平方偏差的平均值的平方根，即std = sqrt(mean(abs(x - x.mean())**2)) 
# 平均平方偏差通常计算为x.sum() / N ，其中N = len(x) 。
# np.std(arr, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>)
# arr – 计算这些值的标准偏差。
# axis – 计算标准偏差的一个或多个轴。 默认是计算展平数组的标准偏差。
# axis=0为行操作。默认行操作
# axis=1为列操作
# ddof=0为计算有偏样本标准差
arr = (arr - np.mean(arr) / (np.std(arr)))

2.6设置数组只读

arr = np.array([[1, 2, 3],
			[4, 5, 6]])
arr.flags.writeable = False
# 执行下面代码会报错
arr[0, 0] = 2

2.7替换最大值

arr = np.random.rand(10)
# 将最大值替换为0
# argmax()返回沿给定轴的最大值的索引数组。
arr[arr.argmax()] = 0

2.8防止输出数组省略

# 这行代码是防止省略数组
np.set_printoptions(threshold = np.inf)
# 生成0-5之间10行3列的数组
arr = np.random.randint(0, 5, (10, 3))

3.数组的运算

3.1两个数组相乘

arr_1 = np.arange(0, 15).reshape(5, 3)
arr_2 = np.arange(0, 6).reshape(3, 2)
# 两者相乘
arr_12 = np.dot(arr_1, arr_2)

3.2两个数组相减

arr_1 = np.arange(9).reshape((3, 3))
arr_2 = np.arange(3)
# arr_1 - arr_2
# 需要将arr_2转换成3*3的矩阵
# arr_1的每一行与arr_2相减
arr = np.subtract(arr_1, arr_2)
# **************
# [[0, 0, 0]   *
# [3, 3, 3]    *
# [6, 6, 6]]   *
# **************
# 加上outer后是点对点的减法
arr = np.subtract.outer(arr_1, arr_2)
# ****************
# [[[ 0, -1, -2],  *
# [ 1,  0, -1],    *
# [ 2,  1,  0]],   *
#                  *
#  [[ 3,  2,  1],  *
#   [ 4,  3,  2],  *
#   [ 5,  4,  3]], *
#                  *
#  [[ 6,  5,  4],  *
#   [ 7,  6,  5],  *
#   [ 8,  7,  6]]] *

3.3数组指定区间取反

arr = np.arange(10)
# 指定一维数组的[3,8]取反
arr[(3 <= arr) & (arr <= 8)] *= -1

3.4取整操作

# 两种方法
# copysign(x, y)
# x会转换成后边y的格式
# ceil(x)
# x向上取整
# floor(y)
# y向下取整
# np.copysign(np.ceil(np.abs(arr)), arr)
np.ceil(arr)

3.5随即数组取整操作

arr = np.random.rand(0, 10, 10)
# 1.通过数学运算
arr = arr - arr%1
# 2.通过函数floor，ceil
arr = np.floor(arr)
arr = np.ceil(arr)
# 类型转换
arr.astype(int)

3.6加法运算

np.add(A, B)

3.7除法运算

# A/2
np.divide(A, 2)

3.8取反运算

np.negative(A, out=A)

3.9取相同值

# intersect1d中的为1，不是L
np.intersect1d(arr, arr_1)

3.10间隔取值

# def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0):
# endpoint如果为 True，`stop` 是最后一个样本。 否则，不包括在内。 默认为真。
# retstep为True则输出间隔值

np.linspace(0, 1, 11, endpoint = False)

对一维数组进行排序

arr = np.random.rand(10)
arr.sort()

一维数组中所有值的和

arr = np.arange(10)
np.add.reduce(arr)

3.11内积运算

# 一维数组
arr_1 = np.array([[1, 2, 3]])
arr_2 = np.array([[4, 5, 6]])
arr = np.multiply.outer(arr_1, arr_2)
# 多维数组
A = np.array([[1, 2, 3], [4, 5, 6]])
B = np.array([[1, 2, 3, 4]])
# 内积后shape == (2, 3, 1, 4)
arr = np.multiply.outer(A, B)

3.12计算行列式

arr_1 = np.array([[1, 2],
				[3, 4]])
# 计算行列式值
np.linalg.det(arr_1)
# -2