大家好，我是Sonhhxg_柒，希望你看完之后，能对你有所帮助，不足请指正！共同学习交流

个人主页－ Sonhhxg_柒的博客_CSDN博客

欢迎各位→点赞 + 收藏:star:️ + 留言​

系列专栏 -机器学习【ML】 自然语言处理【NLP】 深度学习【DL】

​ ​

### foreword

✔说明⇢本人讲解主要包括Python、机器学习（ML）、深度学习（DL）、自然语言处理（NLP）等内容。

## 设置

`import numpy as np`

## 基本

```# Scalar
x = np.array(6)
print ("x: ", x)
print ("x ndim: ", x.ndim) # number of dimensions
print ("x shape:", x.shape) # dimensions
print ("x size: ", x.size) # size of elements
print ("x dtype: ", x.dtype) # data type```

```x:  6
x ndim:  0
x shape: ()
x size:  1
x dtype:  int64```

```# Vector
x = np.array([1.3 , 2.2 , 1.7])
print ("x: ", x)
print ("x ndim: ", x.ndim)
print ("x shape:", x.shape)
print ("x size: ", x.size)
print ("x dtype: ", x.dtype) # notice the float datatype```

```x:  [1.3 2.2 1.7]
x ndim:  1
x shape: (3,)
x size:  3
x dtype:  float64```

```# Matrix
x = np.array([[1,2], [3,4]])
print ("x:
", x)
print ("x ndim: ", x.ndim)
print ("x shape:", x.shape)
print ("x size: ", x.size)
print ("x dtype: ", x.dtype)```

```x:
[[1 2]
[3 4]]
x ndim:  2
x shape: (2, 2)
x size:  4
x dtype:  int64```

```# 3-D Tensor
x = np.array([[[1,2],[3,4]],[[5,6],[7,8]]])
print ("x:
", x)
print ("x ndim: ", x.ndim)
print ("x shape:", x.shape)
print ("x size: ", x.size)
print ("x dtype: ", x.dtype)```

```x:
[[[1 2]
[3 4]]
[[5 6]
[7 8]]]
x ndim:  3
x shape: (2, 2, 2)
x size:  8
x dtype:  int64```

NumPy 还带有几个函数，可以让我们快速创建张量。

```# Functions
print ("np.zeros((2,2)):
", np.zeros((2,2)))
print ("np.ones((2,2)):
", np.ones((2,2)))
print ("np.eye((2)):
", np.eye((2))) # identity matrix
print ("np.random.random((2,2)):
", np.random.random((2,2)))```

```np.zeros((2,2)):
[[0. 0.]
[0. 0.]]
np.ones((2,2)):
[[1. 1.]
[1. 1.]]
np.eye((2)):
[[1. 0.]
[0. 1.]]
np.random.random((2,2)):
[[0.19151945 0.62210877]
[0.43772774 0.78535858]]```

## 索引

```# Indexing
x = np.array([1, 2, 3])
print ("x: ", x)
print ("x[0]: ", x[0])
x[0] = 0
print ("x: ", x)```

```x:  [1 2 3]
x[0]:  1
x:  [0 2 3]```

```# Slicing
x = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
print (x)
print ("x column 1: ", x[:, 1])
print ("x row 0: ", x[0, :])
print ("x rows 0,1 & cols 1,2:
", x[0:2, 1:3])```

```[[ 1  2  3  4]
[ 5  6  7  8]
[ 9 10 11 12]]
x column 1:  [ 2  6 10]
x row 0:  [1 2 3 4]
x rows 0,1 & cols 1,2:
[[2 3]
[6 7]]```

```# Integer array indexing
print (x)
rows_to_get = np.array([0, 1, 2])
print ("rows_to_get: ", rows_to_get)
cols_to_get = np.array([0, 2, 1])
print ("cols_to_get: ", cols_to_get)
# Combine sequences above to get values to get
print ("indexed values: ", x[rows_to_get, cols_to_get]) # (0, 0), (1, 2), (2, 1)```

```[[ 1  2  3  4]
[ 5  6  7  8]
[ 9 10 11 12]]
rows_to_get:  [0 1 2]
cols_to_get:  [0 2 1]
indexed values:  [ 1  7 10]```

```# Boolean array indexing
x = np.array([[1, 2], [3, 4], [5, 6]])
print ("x:
", x)
print ("x > 2:
", x > 2)
print ("x[x > 2]:
", x[x > 2])```

```x:
[[1 2]
[3 4]
[5 6]]
x > 2:
[[False False]
[ True  True]
[ True  True]]
x[x > 2]:
[3 4 5 6]```

## 算术

```# Basic math
x = np.array([[1,2], [3,4]], dtype=np.float64)
y = np.array([[1,2], [3,4]], dtype=np.float64)
print ("x + y:
", np.add(x, y)) # or x + y
print ("x - y:
", np.subtract(x, y)) # or x - y
print ("x * y:
", np.multiply(x, y)) # or x * y```

```x + y:
[[2. 4.]
[6. 8.]]
x - y:
[[0. 0.]
[0. 0.]]
x * y:
[[ 1.  4.]
[ 9. 16.]]```

## 点积

```# Dot product
a = np.array([[1,2,3], [4,5,6]], dtype=np.float64) # we can specify dtype
b = np.array([[7,8], [9,10], [11, 12]], dtype=np.float64)
c = a.dot(b)
print (f"{a.shape} · {b.shape} = {c.shape}")
print (c)```

```(2, 3) · (3, 2) = (2, 2)
[[ 58.  64.]
[139. 154.]]```

## 轴操作

```# Sum across a dimension
x = np.array([[1,2],[3,4]])
print (x)
print ("sum all: ", np.sum(x)) # adds all elements
print ("sum axis=0: ", np.sum(x, axis=0)) # sum across rows
print ("sum axis=1: ", np.sum(x, axis=1)) # sum across columns```

```[[1 2]
[3 4]]
sum all:  10
sum axis=0:  [4 6]
sum axis=1:  [3 7]```

```# Min/max
x = np.array([[1,2,3], [4,5,6]])
print ("min: ", x.min())
print ("max: ", x.max())
print ("min axis=0: ", x.min(axis=0))
print ("min axis=1: ", x.min(axis=1))```

```min:  1
max:  6
min axis=0:  [1 2 3]
min axis=1:  [1 4]```

## 播送

```# Broadcasting
x = np.array([1,2]) # vector
y = np.array(3) # scalar
z = x + y
print ("z:
", z)```

```z:
[4 5]```

### 陷阱

```a = np.array((3, 4, 5))
b = np.expand_dims(a, axis=1)
c = a + b```

```a.shape # (3,)
b.shape # (3, 1)
c.shape # (3, 3)
print (c)```

```array([[ 6,  7,  8],
[ 7,  8,  9],
[ 8,  9, 10]])```

```a = a.reshape(-1, 1)
a.shape # (3, 1)
c = a + b
c.shape # (3, 1)
print (c)```

```array([[ 6],
[ 8],
[10]])```

```a = np.array([3, 4, 5])
a.shape # (3,)
a = a.reshape(-1, 1)
a.shape # (3, 1)```

## 转置

```# Transposing
x = np.array([[1,2,3], [4,5,6]])
print ("x:
", x)
print ("x.shape: ", x.shape)
y = np.transpose(x, (1,0)) # flip dimensions at index 0 and 1
print ("y:
", y)
print ("y.shape: ", y.shape)```

```x:
[[1 2 3]
[4 5 6]]
x.shape:  (2, 3)
y:
[[1 4]
[2 5]
[3 6]]
y.shape:  (3, 2)```

## 重塑（reshape）

```# Reshaping
x = np.array([[1,2,3,4,5,6]])
print (x)
print ("x.shape: ", x.shape)
y = np.reshape(x, (2, 3))
print ("y:
", y)
print ("y.shape: ", y.shape)
z = np.reshape(x, (2, -1))
print ("z:
", z)
print ("z.shape: ", z.shape)```

```[[1 2 3 4 5 6]]
x.shape:  (1, 6)
y:
[[1 2 3]
[4 5 6]]
y.shape:  (2, 3)
z:
[[1 2 3]
[4 5 6]]
z.shape:  (2, 3)```

reshape 的工作方式是查看新张量的每个维度，并将我们的原始张量分成那幺多单元。所以这里新张量的索引 0 处的维度是 2，所以我们将原始张量分成 2 个单位，每个单位有 3 个值。

```x = np.array([[[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3]],
[[10, 10, 10, 10], [20, 20, 20, 20], [30, 30, 30, 30]]])
print ("x:
", x)
print ("x.shape: ", x.shape)```

```x:
[[[ 1  1  1  1]
[ 2  2  2  2]
[ 3  3  3  3]]```

[[10 10 10 10] .

[20 20 20 20]

[30 30 30 30]]]

x.shape: (2, 3, 4)

```[[ 1  1  1  1 10 10 10 10]
[ 2  2  2  2 20 20 20 20]
[ 3  3  3  3 30 30 30 30]]```

and not like:

```[[ 1  1  1  1  2  2  2  2]
[ 3  3  3  3 10 10 10 10]
[20 20 20 20 30 30 30 30]]```

```# Unintended reshaping
z_incorrect = np.reshape(x, (x.shape[1], -1))
print ("z_incorrect:
", z_incorrect)
print ("z_incorrect.shape: ", z_incorrect.shape)```

```z_incorrect:
[[ 1 1 1 1 2 2 2 2]
[ 3 3 3 3 10 10 10 10]
[20 20 20 20 30 30 30 30]]
z_incorrect.shape: (3, 8)```

```# Intended reshaping
y = np.transpose(x, (1,0,2))
print ("y:
", y)
print ("y.shape: ", y.shape)
z_correct = np.reshape(y, (y.shape[0], -1))
print ("z_correct:
", z_correct)
print ("z_correct.shape: ", z_correct.shape)```

[[[ 1 1 1 1]

[10 10 10 10]]

[[ 2 2 2 2] [20 20 20 20]]

[[ 3 3 3 3] [30 30 30 30]]]

y.shape: (3, 2, 4)

z_correct: [[ 1 1 1 1 10 10 10 10]

[ 2 2 2 2 20 20 20 20]

[ 3 3 3 3 30 30 30 30]]

z_correct.shape: (3, 8)

## Joining

```x = np.random.random((2, 3))
print (x)
print (x.shape)```

```[[0.79564718 0.73023418 0.92340453]
[0.24929281 0.0513762  0.66149188]]
(2, 3)```

```# Concatenation
y = np.concatenate([x, x], axis=0) # concat on a specified axis
print (y)
print (y.shape)```

```[[0.79564718 0.73023418 0.92340453]
[0.24929281 0.0513762  0.66149188]
[0.79564718 0.73023418 0.92340453]
[0.24929281 0.0513762  0.66149188]]
(4, 3)```

```# Stacking
z = np.stack([x, x], axis=0) # stack on new axis
print (z)
print (z.shape)```

```[[[0.79564718 0.73023418 0.92340453]
[0.24929281 0.0513762  0.66149188]]
[[0.79564718 0.73023418 0.92340453]
[0.24929281 0.0513762  0.66149188]]]
(2, 2, 3)```

## 扩大/缩小

```# Adding dimensions
x = np.array([[1,2,3],[4,5,6]])
print ("x:
", x)
print ("x.shape: ", x.shape)
y = np.expand_dims(x, 1) # expand dim 1
print ("y:
", y)
print ("y.shape: ", y.shape)   # notice extra set of brackets are added```

```x:
[[1 2 3]
[4 5 6]]
x.shape:  (2, 3)
y:
[[[1 2 3]]
[[4 5 6]]]
y.shape:  (2, 1, 3)```

```# Removing dimensions
x = np.array([[[1,2,3]],[[4,5,6]]])
print ("x:
", x)
print ("x.shape: ", x.shape)
y = np.squeeze(x, 1) # squeeze dim 1
print ("y:
", y)
print ("y.shape: ", y.shape)  # notice extra set of brackets are gone```

```x:
[[[1 2 3]]
[[4 5 6]]]
x.shape:  (2, 1, 3)
y:
[[1 2 3]
[4 5 6]]
y.shape:  (2, 3)```