Numpy

什么是Numpy？

NumPy是Python中科学计算的基础软件包。它是一个提供多了维数组对象，多种派生对象（如：掩码数组、矩阵）以及用于快速操作数组的函数及API，它包括数学、逻辑、数组形状变换、排序、选择、I/O 、离散傅立叶变换、基本线性代数、基本统计运算、随机模拟等等。

NumPy中的核心是ndarray对象。ndarray对象是具有相同类型和大小（通常是固定大小）项目的多维容器。可以对其进行索引、切片、形状变换等操作。

关于axis

根据官方的说法，1表示横轴，方向从左到右；0表示纵轴，方向从上到下，即axis=1为横向，axis=0为纵向。

有时候理解为行和列会很容易使用的，但实际不是表示行列

数组

数组内元素的类型需要相同
创建数组大小固定

创建数组

In [1]：

import numpy as np

a = np.array( # 创建一个1x3的一维数组
    [1,2,3]
)
a

Out[1]：

array([1, 2, 3])

In [2]：

type(a) # 数据类型

Out[2]：

numpy.ndarray # 数组类型为ndarray

ndarray对象的属性

ndarray.shape

数组的形状。返回一个元组表示各个维度中数组的大小。

In [3]：

a.shape # 每行元素的个数

Out[3]：

(3,)

In [11]：

b = np.array( # 创建一个2x3的二维数组
    [
        [1,2,3],
        [4,5,6]
    ]
)
b

Out[11]：

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

In [13]：

b.shape # 数组形状即几行几列

Out[13]：

(2, 3)

ndarray.ndim

数组的轴（维度）的个数即几行。维度的数量被称为rank。

In [4]：

a.ndim # 1行，维度即几行

Out[4]：

ndarray.size

数组中元素的总数。等于shape各个元素的乘积。

In [5]：

a.size # 数组中元素的总个数

Out[5]：

ndarray.dtype

一个描述数组中元素类型的对象。

In [6]：

a.dtype # 数组中元素的类型

Out[6]：

dtype('int32')

ndarray.itemsize

数组中每个元素的字节大小。

In [7]：

a.itemsize # 数组中每个元素的字节大小

Out[7]：

ndarray.real

数组的实部

In [8]：

g = np.array(
    [1+2j,2+3j]
)
g.dtype

Out[8]：

dtype('complex128')

In [9]：

g.real

Out[9]：

array([1., 2.])

ndarray.imag

数组的虚部

In [10]：

g.imag

Out[10]：

array([2., 3.])

ndarray的创建方法

nd.array()

In [1]：

import numpy as np

np.array( # 创建一个1x3的一维数组
    [1,2,3]

Out[1]：

array([1, 2, 3])

np.asarray()

array()和asarray()都可以将结构数据转化为ndarray，但是主要区别就是当数据源是ndarray时，array仍然会copy出一个副本，占用新的内存，但asarray不会。

In [14]：

np.asarray([1,2])

Out[14]：

array([1, 2])

In [15]：

np.asarray(np.array([1,2,3]))

Out[15]：

array([1, 2, 3])

np.zeros(shape, dtype=float)

创建一个全为0的数组（ndarray对象）

shape：形状，即创建几行几列的数组
dtype：数组内值得数据类型

In [16]：

np.zeros(5,dtype=int)

Out[16]：

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

In [17]：

np.zeros((5,))

Out[17]：

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

In [18]：

np.zeros((5,5))

Out[18]：

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

np.zeros_like()

传入一个数组作为参数，根据该数组的形状和dtype创建一个全0的ndaray对象

In [19]：

np.zeros_like(
    [
        [1.2,1.3,2],
        [1.2,1.3,2]
    ]
)

Out[19]：

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

np.empty((shape, dtype=float)

类似于np.zeros(),但只分配内存但是不填充任何值

shape：形状，即创建几行几列的数组
dtype：数组内值得数据类型

In [20]：

np.empty(5)

Out[20]：

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

np.empty_like()

同上

略

np.full(shape, fill_value, dtype=None,)

根据指定形状传建一个数组（ndarray对象），并用fill_value的值进行填充

shape：指定ndarray数组的大小、
fill_vallue：填充值，即数组内值全为fill_valule

In [21]：

np.full((3,2),fill_value=5)

Out[21]：

array([[5, 5],
       [5, 5],
       [5, 5]])

np.full_like()

同上

略

np.eye()

传入一个整数N，创建一个N * N的单位矩阵

In [22]：

np.eye(5) # 创建一个5x5的单位矩阵(identity matrix)

Out[22]：

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

np.identity()

传入一个整数N，创建一个N * N的单位矩阵，类似于np.eye()

In [23]：

np.identity(5)

Out[23]：

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

np.random

随机抽样创建数组

rand：产生指定形状的均匀分布的样本值
randn：返回一个或一组样本，具有标准正态分布
randint：从给定的上下限范围内选取随机整数
binomial：产生二项分布的样本值
normal：产生正态（高斯）分布的样本值
beta：生Beta分布的样本值
chisquare：产生卡方分布的样本值
gamma：产生Gamma分布的样本值
uniform：产生在指定范围中均匀分布的样本值
shuffle：一个序列就地随机排列

In [24]：

np.random.rand(3,2)

Out[24]：

array([[0.87739699, 0.62405667],
       [0.05264142, 0.21515255],
       [0.34419254, 0.79204327]])

In [25]：

np.random.randn(3,2)

Out[25]：

array([[-0.71596008, -0.73378479],
       [-0.99908948,  0.70328556],
       [-0.55219447,  0.02029755]])

np.arange(start,stop,step,dtype)

创建一位数组，从start~stop（不包括stop）范围内选取值，步长为step，默认为1

In [26]：

np.arange(5)

Out[26]：

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

In [27]：

np.arange(5,5)

Out[27]：

array([], dtype=int32)

In [28]：

np.arange(1,5,2)

Out[28]：

array([1, 3])

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)

返回一个在指定范围内(start~stop，但不包括stop)指定大小num（默认为50）的一位数组

In [29]：

np.linspace(1,5)

Out[29]：

array([1.        , 1.08163265, 1.16326531, 1.24489796, 1.32653061,
       1.40816327, 1.48979592, 1.57142857, 1.65306122, 1.73469388,
       1.81632653, 1.89795918, 1.97959184, 2.06122449, 2.14285714,
       2.2244898 , 2.30612245, 2.3877551 , 2.46938776, 2.55102041,
       2.63265306, 2.71428571, 2.79591837, 2.87755102, 2.95918367,
       3.04081633, 3.12244898, 3.20408163, 3.28571429, 3.36734694,
       3.44897959, 3.53061224, 3.6122449 , 3.69387755, 3.7755102 ,
       3.85714286, 3.93877551, 4.02040816, 4.10204082, 4.18367347,
       4.26530612, 4.34693878, 4.42857143, 4.51020408, 4.59183673,
       4.67346939, 4.75510204, 4.83673469, 4.91836735, 5.        ])

In [30]：

np.linspace(1,5,2)

Out[30]：

array([1., 5.])

np.fromfunction(function, shape, **kwargs)

通过对每个执行函数来构造一个数组

function：执行函数
shape：数组大小

In [31]:

def mime(a,b):
    return b
np.fromfunction(mime,(3,3))

Out[31]:

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

In [32]:

def mime(a,b):
    return a
np.fromfunction(mime,(3,3))

Out[32]:

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

In [33]:

def add(a,b):
    return a+b
np.fromfunction(add,(3,3))

Out[33]:

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

In [34]:

def dot(a,b):
    return a*b
np.fromfunction(dot,(3,3))

Out[34]:

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

数据类型

所有的数据类型如下表所示：

数据类型

类型代码

说明

int8、uint8

i1、u1

有符号和无符号的8位（1个字节）整形

int16、uint16

i2、u2

有符号和无符号的16位（2个字节）整形

int32、uint32

i4、u4

有符号和无符号的32位（4个字节）整形

int64、uint64

i8、u8

有符号和无符号的64位（8个字节）整形

float16

半精度浮点数

float32

f4或f

标准的单精度浮点数

float64

f8或d

标准的双精度浮点数

float128

f16或g

扩展精度浮点数

bool

存储布尔类型（存储为一个字节）

object

Python对象类型

string_

固定长度的字符串类型（每个字符1个字节）

unicode_

固定长度的unicode类型（字节数由平台决定）

complex64、complex128、complex256

c8、c16、c32

分别用两个32位、64位或128位浮点数表示的复数

注意：int_为int32的简写，float_为float64的简写，complex_为complex128的简写

In [1]:

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

Out[1]:

dtype('int32')

数组运算

In [1]:

import numpy as np

In [2]:

a = np.array([
    [1,2,3],
    [4,5,6],
])
a

Out[2]:

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

数组与标量的算术运算

In [3]:

a * 2

Out[3]:

array([[ 2,  4,  6],
       [ 8, 10, 12]])

加法

In [5]:

a+a

Out[5]:

array([[ 2,  4,  6],
       [ 8, 10, 12]])

减法

In [6]:

a-a # np.subtract(a,a)

Out[6]:

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

除法

In [7]:

a/a # np.divide(a,a)

Out[7]:

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

In [8]:

星乘（*）与点乘（.）

In [8]:

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

In [9]:

a*b # np.multiply(a,b)

Out[9]:

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

In [10]:

np.dot(a,b)
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-10-3339b236d1c5> in <module>
----> 1 np.dot(a,b)

<__array_function__ internals> in dot(*args, **kwargs)

ValueError: shapes (2,3) and (2,3) not aligned: 3 (dim 1) != 2 (dim 0)

In [11]:

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

In [12]:

np.dot(a,b)

Out[12]:

array([[3, 3],
       [3, 3]])

In [13]:

a.dot(b)

Out[13]:

array([[3, 3],
       [3, 3]])

拷贝

完全不拷贝：两个变量公用一个数组，引用的地址都是同一个

In [14]:

a = np.arange(10)
b = a

Out[14]:

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

In [15]:

Out[15]:

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

In [16]:

Out[16]:

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

In [17]:

b[0] = 100
b

Out[17]:

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

In [18]:

Out[18]:

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

浅拷贝：与上有区别，一个数组值会变化会反映在另一个数组上，但是形状不变化

In [21]:

a = np.arange(10)
b = a.view()

In [22]:

Out[22]:

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

In [23]:

Out[23]:

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

In [24]:

b[0] = 500

In [25]:

Out[25]:

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

In [26]:

Out[26]:

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

In [30]:

b.shape = (10,1)
b

Out[30]:

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

In [31]:

Out[31]:

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

深拷贝：创建原数组的副本，副本的任何变化都不会反映在原数组上

In [32]:

a = np.arange(10)
b = a.copy()

In [33]:

b[0] = 500

In [34]:

Out[34]:

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

In [35]:

Out[35]:

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

索引与切片

In [36]:

a = np.arange(36).reshape(6,6)
a

Out[36]:

array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23],
       [24, 25, 26, 27, 28, 29],
       [30, 31, 32, 33, 34, 35]])

取第2,3,4行的数据，注意索引从0开始

In [37]:

a[[1,2,3]]

Out[37]:

array([[ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23]])

取（2,4），（3,5），（4,6）的值

In [39]:

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

Out[39]:

array([ 9, 16, 23])

取第2,3,4行后，再取第4,5,6列的值

In [42]:

a[[1,2,3]][:,[3,4,5]]

Out[42]:

array([[ 9, 10, 11],
       [15, 16, 17],
       [21, 22, 23]])

统计方法 ☆☆☆

In [1]:

import numpy as np

In [2]:

a = np.array([
    [np.NaN,2,3,4],
    [2,np.NaN,4,5],
    [3,4,np.NaN,6]
])

In [3]:

Out[3]:

array([[nan,  2.,  3.,  4.],
       [ 2., nan,  4.,  5.],
       [ 3.,  4., nan,  6.]])

amin(a[, axis, out, keepdims]

返回数组的最小值或沿轴的最小值

见下

amax(a[, axis, out, keepdims])

返回数组的最大值或沿轴的最大值

In [4]:

np.amax(a,axis=0) # axis=0表示列

Out[4]:

array([nan, nan, nan,  6.])

In [5]:

np.amax(a,axis=1) # axis=1表示行

Out[5]:

array([nan, nan, nan])

In [6]:

np.amax(a) # 整个数组

Out[6]:

nan

nanmin(a[, axis, out, keepdims])

返回数组的最小值或沿轴的最小值，忽略任何NAN

见下

nanmax(a[, axis, out, keepdims])

返回数组的最大值或沿轴方向的最大值，忽略任何NAN

In [7]:

np.nanmin(a)

Out[7]:

2.0

In [8]:

np.nanmax(a)

Out[8]:

6.0

median(a[, axis, out, overwrite_input, keepdims])

沿指定轴计算中值

略

####　nanmedian(a[, axis, out, overwrite_input, …])

在忽略NAS的情况下，沿指定的轴计算中值

In [9]:

np.nanmedian(a)

Out[9]:

4.0

average(a[, axis, weights, returned])

计算沿指定轴的加权平均

见下

mean(a[, axis, dtype, out, keepdims])

沿指定的轴计算算术平均值

见下

nanmean(a[, axis, dtype, out, keepdims])

计算沿指定轴的算术平均值，忽略NAN

In [11]:

b = a.copy()
b

Out[11]:

array([[nan,  2.,  3.,  4.],
       [ 2., nan,  4.,  5.],
       [ 3.,  4., nan,  6.]])

In [12]:

b[np.isnan(b)]=np.nanmean(b) # 筛选出所有nan值然后用均值进行替换
b

Out[12]:

array([[3.66666667, 2.        , 3.        , 4.        ],
       [2.        , 3.66666667, 4.        , 5.        ],
       [3.        , 4.        , 3.66666667, 6.        ]])

std(a[, axis, dtype, out, ddof, keepdims])

计算沿指定轴的标准偏差即标准差

见下

nanstd(a[, axis, dtype, out, ddof, keepdims])

计算指定轴上的标准偏差，而忽略NAN

In [14]:

np.nanstd(a)

Out[14]:

1.247219128924647

var(a[, axis, dtype, out, ddof, keepdims])

计算沿指定轴的方差

见下

nanvar(a[, axis, dtype, out, ddof, keepdims])

计算指定轴上的方差，同时忽略NAN

In [15]:

np.nanvar(a)

Out[15]:

1.5555555555555556

形状变换

重塑

ndarray.reshape(shape, order='C')
ndarray.resize()
注意：reshape 函数返回修改后的新对象，而 ndarray.resize 方法修改数组本身
重塑的各个维度上整数的乘积必须等于arr.size
如果想让自动计算某个轴上的大小，可以传入-1

扁平化处理

In [1]:

import numpy as np

a = np.array([[1,2,5],[2,3,5],[3,4,5],[2,3,6]])
a

Out[1]:

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

In [2]:

a.flatten()

Out[2]:

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

In [3]:

b = a.ravel() # flatten()与ravel()都是讲数组变成一维数组，但是flatten会重新创建一个新的对			  # 象，ravel()只是返回一个视图，如果修改了其中的值，原数组也会被修改

In [4]:

b[0] = 100
a

Out[4]:

array([[100,   2,   5],
       [  2,   3,   5],
       [  3,   4,   5],
       [  2,   3,   6]])

数组合并

concatenate

沿着一条轴连接一组（多个）数组。除了与axis对应的轴之外，其它轴必须有相同的形状。

In [1]:

import numpy as np

a = np.array([
    [1,2,3],
    [4,5,6]
])

b = np.array([
    [5,6,7],
    [8,9,10]
])

In [2]:

np.concatenate((a,b),axis=0) # 垂直拼接

Out[2]:

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

In [3]:

np.concatenate((a,b),axis=1) # 将两个二维数组分别转化为一维数组后，在垂直拼接

Out[3]:

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

vstack&row_stack

以追加行的方式对数组进行连接（沿轴0）即垂直方向

In [4]:

np.vstack((a,b))

Out[4]:

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

In [5]:

np.row_stack((a,b))

Out[5]:

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

hstack

以追加列的方式对数组进行连接（沿轴1）即水平方向

In [6]:

np.hstack((a,b))

Out[6]:

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

column_stack

类似于hstack，但是会先将一维数组转换为二维列向量

In [7]:

np.column_stack((a,b))

Out[7]:

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

dstack

以面向“深度”的方式对数组进行叠加

In [8]:

np.dstack((a,b))

Out[8]:

array([[[ 1,  5],
        [ 2,  6],
        [ 3,  7]],

       [[ 4,  8],
        [ 5,  9],
        [ 6, 10]]])

数组拆分

split

沿指定轴在指定的位置拆分数组

In [9]:

c = np.arange(36).reshape(6,-1)
c

Out[9]:

array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23],
       [24, 25, 26, 27, 28, 29],
       [30, 31, 32, 33, 34, 35]])

In [10]:

np.split(c,2,axis=0) # 从第二行开始进行拆分，axis=0代表行方向

Out[10]:

[array([[ 0,  1,  2,  3,  4,  5],
        [ 6,  7,  8,  9, 10, 11],
        [12, 13, 14, 15, 16, 17]]),
 array([[18, 19, 20, 21, 22, 23],
        [24, 25, 26, 27, 28, 29],
        [30, 31, 32, 33, 34, 35]])]

In [11]:

np.split(c,2,axis=1) # 从第二列开始进行拆分，axis=1代表列方向

Out[11]:

[array([[ 0,  1,  2],
        [ 6,  7,  8],
        [12, 13, 14],
        [18, 19, 20],
        [24, 25, 26],
        [30, 31, 32]]),
 array([[ 3,  4,  5],
        [ 9, 10, 11],
        [15, 16, 17],
        [21, 22, 23],
        [27, 28, 29],
        [33, 34, 35]])]

In [12]:

np.split(c,[2,3,4],axis=0) # 第二项参数可以为列表，分别从第二行，第三行，第四行，进行拆分

Out[12]:

[array([[ 0,  1,  2,  3,  4,  5],
        [ 6,  7,  8,  9, 10, 11]]),
 array([[12, 13, 14, 15, 16, 17]]),
 array([[18, 19, 20, 21, 22, 23]]),
 array([[24, 25, 26, 27, 28, 29],
        [30, 31, 32, 33, 34, 35]])]

hsplit、vsplit、dsplit

split的便捷化函数，分别沿轴0、轴1、轴2进行拆分

重复数组

repeat

对数组中的元素进行复制

In [13]:

d = np.arange(5)
d

Out[13]:

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

In [14]:

np.repeat(d,3) # 所有元素都重复3次

Out[14]:

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

In [15]:

np.repeat(d,[1,1,2,5,6]) # 指定每个元素进行重复的次数，列表中的值代表数组中的该位置的元素进行重复的次数

Out[15]:

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

注意在多维数组中，不指定axis轴方向，会扁平化

tile

对整个数组进行复制

In [16]:

np.tile(d,2) # 水平复制

Out[16]:

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

In [17]:

f = np.arange(9).reshape(3,-10)
f

Out[17]:

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

In [18]:

np.tile(f,2) # 水平复制

Out[18]:

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

In [19]:

np.tile(f,(1,2))# 将f数组，变成一个1x2的f构成

Out[19]:

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

In [20]:

np.tile(f,(2,3)) # 将f数组，变成一个2x3的f构成

Out[20]:

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

转置

ndarray数组对象.T即可得到ndarray对象的转置

In [21]:

h = np.arange(25).reshape(5,-1) # 等价于reshape(5,5)
h

Out[21]:

array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19],
       [20, 21, 22, 23, 24]])

In [23]:

h.T # 转置

Out[23]:

array([[ 0,  5, 10, 15, 20],
       [ 1,  6, 11, 16, 21],
       [ 2,  7, 12, 17, 22],
       [ 3,  8, 13, 18, 23],
       [ 4,  9, 14, 19, 24]])

In [24]:

h.transpose() # 转置

Out[24]:

array([[ 0,  5, 10, 15, 20],
       [ 1,  6, 11, 16, 21],
       [ 2,  7, 12, 17, 22],
       [ 3,  8, 13, 18, 23],
       [ 4,  9, 14, 19, 24]])

通用函数☆☆☆

一元ufunc

函数

说明

abs、fabs

计算整数、浮点数或复数的绝对值。对于非复数值，可以使用更快的fabs

sqrt

计算各元素的平方根。相当于arr ** 0.5

square

计算各元素的平方。相当于arr ** 2

exp

计算各元素的指数。相当于e的x次方

log、log10、log2、log1p

分别对应自然对数（底数为e）、底数为10的log、底数为2的log、log(1 + p)

sign

计算各元素的正负号：1（正数）、0（零）、-1（负数）

ceil

计算各元素的ceiling值，即大于等于该值的最小整数

floor

计算各元素的floor值。即小于等于该值的最大整数

rint

将各元素值四舍五入到最接近的整数，保留dtype

modf

将数组的小数和整数部分以两个独立数组的形式返回

isnan

返回一个表示“哪些值是NaN”的布尔型数组

isfinite、isinf

分别返回一个表示“哪些元素是有穷的（非inf，非NaN）”或“哪些元素是无穷的”的布尔型数组

cos、cosh、sin、sinh、tan、tanh

普通型和双曲型三角函数

arccos、arccosh、arcsin、arcsinh、arctan、arctanh

反三角函数

logical_not

计算个元素的not x的真值。相当于-arr

二元ufunc

函数

说明

add

将数组中对应的元素相加

subtract

从第一个数组中减去第二个数组中的元素

multiply

将数组元素相乘

divide、floor_divide

除法或向下取整除法（丢弃余数）

power

对第一个数组中的元素A，根据第二个数组中的相应元素B，计算A的B次方

maximum、fmax

元素级的最大值计算。fmax将忽略NaN

minimum、fmin

元素级的最小值计算。fmin将忽略NaN

mod

元素级别的求模计算（除法的余数）

copysign

将第二个数组中的值得符号复制给第一个数组中的值

greater、greater_equal、less、less_equal、equal、not_equal、

执行元素级的比较运算，最终产生布尔数组。相当于中缀运算符号>、>=、<、<=、==、!=

logical_and、logical_or、logical_xor

执行元素级的真值逻辑运算。相当于中缀运算符&、| 、^

In [24]:

a = np.random.randn(5)
b = np.random.randn(5)

In [25]:

Out[25]:

array([-0.09068035, -0.187416  ,  0.94935988,  2.43188324, -1.71809499])

In [26]:

Out[26]:

array([-0.55215555,  0.49648021,  1.45710124, -1.47626841, -1.38574365])

In [27]:

np.abs(a)

Out[27]:

array([0.09068035, 0.187416  , 0.94935988, 2.43188324, 1.71809499])

In [28]:

np.rint(a)

Out[28]:

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

In [29]:

np.subtract(a,b)

Out[29]:

array([ 0.4614752 , -0.68389622, -0.50774136,  3.90815164, -0.33235134])

搜索和计数☆☆☆

搜索

argmax(a[, axis, out])

返回沿轴的最大值的索引即最大值所在位置的下标

In [1]:

import numpy as np

a = np.arange(36).reshape(6,-1)
a

Out[1]:

array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23],
       [24, 25, 26, 27, 28, 29],
       [30, 31, 32, 33, 34, 35]])

In [2]:

np.argmax(a) # 整个数组其中最大值的下标，以flatten扁平化后的下标进行返回

Out[2]:

In [3]:

np.argmax(a,axis=0) # 每行最大值的下标

Out[3]:

array([5, 5, 5, 5, 5, 5], dtype=int64)

In [4]:

np.argmax(a,axis=1 # 每列最大值的下标

Out[4]:

array([5, 5, 5, 5, 5, 5], dtype=int64)

nanargmax(a[, axis])

返回指定轴上最大值的索引，忽略NAN

略

argmin(a[, axis, out])

返回沿轴的最小值的索引即最小值所在位置的下标

In [5]:

np.argmin(a)

Out[5]:

#####　nanargmin(a[, axis])

返回指定轴上的最小值的索引，忽略NAN

#####　argwhere(a)

返回按元素分组的非零数组元素的索引。

In [8]:

np.argwhere(a>28) # 帅选出条件符合的值得下标即(i,j)

Out[8]:

array([[4, 5],
       [5, 0],
       [5, 1],
       [5, 2],
       [5, 3],
       [5, 4],
       [5, 5]], dtype=int64)

#####　nonzero(a)

返回非零元素的索引，以两个数组的形式进行返回，第一个数组为行下标，第二个数组为列下标

In [9]:

np.nonzero(a)

Out[9]:

(array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
        3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5], dtype=int64),
 array([1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4,
        5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5], dtype=int64))

#####　flatnonzero(a)

返回a的展平版本中非零的索引

In [10]:

np.flatnonzero(a) # 将数组扁平化后也就是变成一维数组后，返回一维                   # 数组的下标

Out[10]:

array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
       18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
       35], dtype=int64)

#####　where(condition, [x, y])☆

返回元素，可以是x或y，具体取决于条件

In [11]:

np.where(a>30) # 与argwehe方法类似，只是where是分别用两个数组，                # 进行存储符合条件的值得行下标以及列下标

Out[11]:

(array([5, 5, 5, 5, 5], dtype=int64), array([1, 2, 3, 4, 5], dtype=int64))

In [12]:

b = np.array([
    1,2,3,4
])
c = np.array([
    'a','b','c','d'
])
condtion = np.array([
    True,False,True,False
])
np.where(condtion,b,c) # 根据condition条件将c中符合的数据替换掉b中相应位置的数据

Out[12]:

array(['1', 'b', '3', 'd'], dtype='<U11')

In [13]:

np.where(a>10,0,a) # 将大于10的值全部替换为0

Out[13]:

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

#####　searchsorted(a, v[, side, sorter])

查找应插入元素以维护顺序的索引

In [14]:

d = np.array([8,15,3,12,5])
f = np.array([3,5,8,12,15])

In [15]:

np.searchsorted(f,7) # 默认先往左插，插入7后，值7的下标位置

Out[15]:

In [16]:

np.searchsorted(f,7,side='right') # 往右插，插入7后，值7的下标位置

Out[16]:

In [17]:

np.searchsorted(f,8)

Out[17]:

In [18]:

np.searchsorted(f,8,side='right')

Out[18]:

#####　extract(condition, arr)

返回满足某些条件的数组元素

####　计数

#####　count_nonzero(a[, axis])

计算数组a中的非零值的数量

In [20]:

np.count_nonzero([[1,2,3,4,5,0],[0,0,0,0,0,1]]) # 统计数组中非0数量

Out[20]:

In [21]:

np.count_nonzero([[1,2,3,4,5,0],[0,0,0,0,0,1]],axis=0) # 统计沿垂直方向的非0数量

Out[21]:

array([1, 1, 1, 1, 1, 1], dtype=int64)

In [22]:

np.count_nonzero([[1,2,3,4,5,0],[0,0,0,0,0,1]],axis=1) # 统计沿水平方向的非0数量

Out[22]:

array([5, 1], dtype=int64)

线性代数

diag(v, k=0)

以一维数组的形式返回方阵的对角线（或非对角线）元素，或将一数组转换为方阵（非对角线元素为0）

In [24]:

np.diag(g) # 以一维数组形式返回对角元素

Out[24]:

array([ 0,  6, 12, 18, 24])

In [25]:

np.diag(g,1)# 返回从下标i=1开始打得对角元素

Out[25]:

In [26]:

Out[26]:

#####　dot(a, b[, out])

两个数组的点积

In [27]:

Out[27]:

#####　trace(a[, offset, axis1, axis2, dtype, out])

计算对角线元素的和

In [28]:

Out[28]:

#####　linalg.det(a)

计算矩阵行列式

In [29]:

Out[29]:

In [30]:

Out[30]:

#####　linalg.inv(a)

计算方阵的逆

In [31]:

Out[31]:

计算均方误差MSE

用numpy进行表示

分别设置相应的预测值以及真实值

In[1]:

Out[1]:

注意进行计算时，需要知道矩阵的状态，才能保证按照公式计算无误

上一页Matplotlib 下一页Pandas

最后更新于 4年前

这有帮助吗？

hashtag什么是Numpy？

hashtag关于axis

hashtag数组

hashtag创建数组

hashtagndarray对象的属性

hashtagndarray.shape

hashtagndarray.ndim

hashtagndarray.size

hashtagndarray.dtype

hashtagndarray.itemsize

hashtagndarray.real

hashtagndarray.imag

hashtagndarray的创建方法

hashtagnd.array()

hashtagnp.asarray()

hashtagnp.zeros(shape, dtype=float)

hashtagnp.zeros_like()

hashtagnp.empty((shape, dtype=float)

hashtagnp.empty_like()

hashtagnp.full(shape, fill_value, dtype=None,)

hashtagnp.full_like()

hashtagnp.eye()

hashtagnp.identity()

hashtagnp.random

hashtagnp.arange(start,stop,step,dtype)

hashtagnp.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)

hashtagnp.fromfunction(function, shape, **kwargs)

hashtag数据类型

hashtag数组运算

hashtag数组与标量的算术运算

hashtag加法

hashtag减法

hashtag除法

hashtag星乘（*）与点乘（.）

hashtag拷贝

hashtag索引与切片

hashtag统计方法 ☆☆☆

hashtagamin(a[, axis, out, keepdims]

hashtagamax(a[, axis, out, keepdims])

hashtagnanmin(a[, axis, out, keepdims])

hashtagnanmax(a[, axis, out, keepdims])

hashtagmedian(a[, axis, out, overwrite_input, keepdims])

hashtagaverage(a[, axis, weights, returned])

hashtagmean(a[, axis, dtype, out, keepdims])

hashtagnanmean(a[, axis, dtype, out, keepdims])

hashtagstd(a[, axis, dtype, out, ddof, keepdims])

hashtagnanstd(a[, axis, dtype, out, ddof, keepdims])

hashtagvar(a[, axis, dtype, out, ddof, keepdims])

hashtagnanvar(a[, axis, dtype, out, ddof, keepdims])

hashtag形状变换

hashtag重塑

hashtag扁平化处理

hashtag数组合并

hashtagconcatenate

hashtagvstack&row_stack

hashtaghstack

hashtagcolumn_stack

hashtagdstack

hashtag数组拆分

hashtagsplit

hashtaghsplit、vsplit、dsplit

hashtag重复数组

hashtagrepeat

hashtagtile

hashtag转置

hashtag通用函数☆☆☆

hashtag搜索和计数☆☆☆

hashtag搜索

hashtagargmax(a[, axis, out])

hashtagnanargmax(a[, axis])

hashtagargmin(a[, axis, out])

hashtag线性代数

hashtagdiag(v, k=0)

什么是Numpy？

关于axis

数组

创建数组

ndarray对象的属性

ndarray.shape

ndarray.ndim

ndarray.size

ndarray.dtype

ndarray.itemsize

ndarray.real

ndarray.imag

ndarray的创建方法

nd.array()

np.asarray()

np.zeros(shape, dtype=float)

np.zeros_like()

np.empty((shape, dtype=float)

np.empty_like()

np.full(shape, fill_value, dtype=None,)

np.full_like()

np.eye()

np.identity()

np.random

np.arange(start,stop,step,dtype)

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)

np.fromfunction(function, shape, **kwargs)

数据类型

数组运算

数组与标量的算术运算

加法

减法

除法

星乘（*）与点乘（.）

拷贝

索引与切片

统计方法 ☆☆☆

amin(a[, axis, out, keepdims]

amax(a[, axis, out, keepdims])

nanmin(a[, axis, out, keepdims])

nanmax(a[, axis, out, keepdims])

median(a[, axis, out, overwrite_input, keepdims])

average(a[, axis, weights, returned])

mean(a[, axis, dtype, out, keepdims])

nanmean(a[, axis, dtype, out, keepdims])

std(a[, axis, dtype, out, ddof, keepdims])

nanstd(a[, axis, dtype, out, ddof, keepdims])

var(a[, axis, dtype, out, ddof, keepdims])

nanvar(a[, axis, dtype, out, ddof, keepdims])

形状变换

重塑

扁平化处理

数组合并

concatenate

vstack&row_stack

hstack

column_stack

dstack

数组拆分

split

hsplit、vsplit、dsplit

重复数组

repeat

tile

转置

通用函数☆☆☆

搜索和计数☆☆☆

搜索

argmax(a[, axis, out])

nanargmax(a[, axis])

argmin(a[, axis, out])

线性代数

diag(v, k=0)