Numpy常用函数用法大全

Numpy常用函数用法大全目录

A
array 创建一个np数组
arange 返回指定范围内的数组
argmax 返回沿轴axis最大值的索引

B
bincount 返回数组中的值中索引出现的次数

C
copysign 将b中各元素的符号赋值给数组a的对应元素

D
dot 矩阵运算

E
exp e的N次方

F
full 返回给定形状和类型的新数组，填充fill_value

G
gradient 返回N维数组的梯度

H
hsplit 通过指定要返回的相同shape的array的数量，或者通过指定分割应该发生之后的列来沿着其横轴拆分原array

I
isnan 测试NaN的元素，并将结果作为布尔数组返回

L
log e的指数
linspace 在指定的间隔内返回均匀间隔的数字

M
max 数组中最大的键

R
reshape 不改变数据同时改变数据格式
random.choice 随机分布一个数组
random.randn 返回一个或一组样本，具有标准正态分布

S
sum 每个数组各个键的总和

v
vsplit 沿着垂直轴分割，其分割方式与hsplit用法相同

Z
zeros_like 生成0填充形状和传入数组相同的数组
zeros 返回来一个给定形状和类型的用0填充的数组

---

Numpy.array(p_object, dtype=None, ndmin=0)

1. p_object :array_like，数组，对象，其方法返回一个数组或任何(嵌套的)序列。

2. dtype：data-type，数据类型，可选，数组所需的数据类型，默认最小类型序列。

3. ndmin：int，最小维数，可选，默认0。

import numpy as np

// p_object

a, b = [1, 2], {3, 4}

np.array(a) // [1 2]

np.array(b) // {3, 4}

// dtype 转换元素类型

np.array([1, 2], dtype=str) // ['1' '2']

// ndmin 设置2会嵌套一层维度

a = [1,8,4,1,3,4,5]

np.array(a, ndmin=2) // [[1 8 4 1 3 4 5]]

---

Numpy.arange([start, ]stop, [step, ]dtype=None)

1. start：number，可选，开始，默认的起始值是0。

2. stop：number，可选，结束。

3. step：number，可选，间隔。

4. dtype: dtype，可选，输出数组的类型，默认推断类型。

import numpy as np

// 一个参数3.0结束

np.arange(3.0) // [0. 1. 2.]

// 两个参数3开始6结束

np.arange(3, 7) // [3 4 5 6]

// dtype转换类型

np.arange(3, 7, dtype=float) // [3. 4. 5. 6.]

// 三个参数3.0开始6.0结束，间隔0.5

np.arange(3.0, 7.0, 0.5) // [3.  3.5 4.  4.5 5.  5.5 6.  6.5]

---

numpy.dot(a, b)

1. a，数组1

2. b，数组2

import numpy as np

a = [[1, 0], [0, 1]]

b = [[4, 1], [2, 2]]

np.dot(a, b)

// [[4 1]

[2 2]]

4 = 1 * 4 + 0 * 2

1 = 1 * 1 + 0 * 2

2 = 0 * 4 + 1 * 2

2 = 0 * 1 + 1 * 2

---

numpy.exp(x)

1. a，数组1或int

import numpy as np

np.exp(1)

// 2.718281828459045

// e的n次方

np.exp([1,2])

// [2.71828183 7.3890561 ] e的1 2 次方

---

np.log()

1. a，数组1或int

import numpy as np

np.log(np.exp(4))

// 4.0

// e的指数

---

x.reshape() 不改变数据同时改变数据格式

1. a，数组1或int

import numpy as np

np.arange(6).reshape((3, 2))

// [[0 1]

[2 3]

[4 5]]

---

np.sum() 每个数组各个键的总和

1. a，数组1或int

import numpy as np

np.sum([1,3,4])

// 8

---

np.max() 返回数组最大值

1. a，数组1或int

import numpy as np

np.max([2,5,6,7])

// 7

---

np.zeros_like() 生成0填充形状和传入数组相同的数组

import numpy as np

np.zeros_like([2,3])

// [0 0]

---

np.random.choice() 随机分布一个数组

import numpy as np

# 参数

# 是从a中以概率p，随机选择size个, p没有指定的时候相当于是一致的分布

# replace 如果是False的话，3个值不一样

np.random.choice(a=5, size=3, replace=False, p=None)

// [4 1 2]

np.random.choice(a=5, size=2, replace=False, p=[0.2, 0.1, 0.3, 0.4, 0.0])

// [3 2] 4的概率为0

---

np.linspace() 在指定的间隔内返回均匀间隔的数字

import numpy as np

# 也就是说生成 2 到 3 之间，每个元素的左右±数一致，也就是等差数，并且生成5个

np.linspace(2.0, 3.0, num=5)

# array([ 2.  ,  2.25,  2.5 ,  2.75,  3.  ])

# endpoint=false表示不包含3.0，默认true

np.linspace(2.0, 3.0, num=5, endpoint=False)

# array([ 2. ,  2.2,  2.4,  2.6,  2.8])

# true返回间距数0.25，默认false

np.linspace(2.0, 3.0, num=5, retstep=True)

# (array([ 2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)

---

np.argmax() 返回沿轴axis最大值的索引

a = [[0, 1, 2], [3, 4, 5]]

np.argmax(a)

# 5

np.argmax(a, axis=0) # 0代表列

# array([1, 1, 1])

np.argmax(a, axis=1)# 1代表行

# array([2, 2])

---

np.zeros() 返回来一个给定形状和类型的用0填充的数组

np.zeros(5)

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

np.zeros((5,), dtype=np.int)

# array([0, 0, 0, 0, 0])

np.zeros((2, 1))

# array([[ 0.],

#    [ 0.]])

a = (2,2)

np.zeros(a)

# array([[ 0., 0.],

#    [ 0., 0.]])

---

np.bincount() 返回数组中的值中索引出现的次数

# x中最大的数为7，那么它的索引值为0-7

x = np.array([0, 1, 1, 3, 2, 1, 7, 7])

# 索引0出现了1次，索引1出现了3次,索引2出现了1次,索引3出现了1次,索引4出现了0次,索引7出现了2次

np.bincount(x)

#因此，输出结果为：array([1, 3, 1, 1, 0, 0, 0, 2])

---

np.copysign() 将b中各元素的符号赋值给数组a的对应元素

np.copysign(1.3, -1)

# -1.3

1/np.copysign(0, 1)

# inf

1/np.copysign(0, -1)

# -inf

---

np.full() 返回给定形状和类型的新数组，填充fill_value

np.full((2, 2), np.inf)

# array([[ inf,  inf],

#        [ inf,  inf]])

np.full((2, 2), 10)

# array([[10, 10],

#        [10, 10]])

---

np.gradient() 返回N维数组的梯度

f = np.array([1, 2, 4, 7, 11, 16], dtype=float)

np.gradient(f)

# array([ 1. ,  1.5,  2.5,  3.5,  4.5,  5. ])

np.gradient(f, 2)

# array([ 0.5 ,  0.75,  1.25,  1.75,  2.25,  2.5 ])

---

np.hsplit() 通过指定要返回的相同shape的array的数量，或者通过指定分割应该发生之后的列来沿着其横轴拆分原

import numpy as np

harr = np.floor(10 * np.random.random((2, 6)))

print(harr)

print(np.hsplit(harr, 3))

# 原array：

[[ 8.  5.  0.  2.  3.  8.]

[ 0.  2.  9.  5.  8.  2.]]

# 拆分后：

[array([[ 8.,  5.],

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

        [ 9.,  5.]]), array([[ 3.,  8.],

        [ 8.,  2.]])]

---

np.isnan() 测试NaN的元素，并将结果作为布尔数组返回

np.isnan(np.nan)

# True

>>> np.isnan(np.inf)

# False

np.isnan([np.log(-1.),1.,np.log(0)])

# array([ True, False, False], dtype=bool)

---

np.vsplit() 沿着垂直轴分割，其分割方式与hsplit用法相同

varr = np.arange(16).reshape([4,4])

print(varr)

print(np.vsplit(varr, 2))

# 原array为：

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

      [ 4,  5,  6,  7],

      [ 8,  9, 10, 11],

      [12, 13, 14, 15]])

# 拆分后：

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

      [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],

      [12, 13, 14, 15]])]

---

np.random.randn() 返回一个或一组样本，具有标准正态分布

np.random.randn(2,4)

# array([[ 0.27795239, -2.57882503,  0.3817649 ,  1.42367345],

#      [-1.16724625, -0.22408299,  0.63006614, -0.41714538]])