• Numpy基本属性

  import numpy as np
  
  # 生成一个2*3的矩阵
  array = np.array([[1, 2, 3], [4, 5, 6]])
  
  print(array)
  # 获取矩阵维度
  print("获取矩阵维度：", array.ndim)
  # 获取矩阵大小
  print("获取矩阵大小：", array.size)
  # 获取矩阵形状 行*列
  print("获取矩阵形状：", array.shape)

结果：
[[1 2 3]
 [4 5 6]]
获取矩阵维度： 2
获取矩阵大小： 6
获取矩阵形状： (2, 3)

• Numpy数据类型

Numpy数据类型和Python的数据类型和常见的数据类型差不多

| 序号 | 数据类型 | 描述 |
| :--: | :----------- | :----------------------------------------------------------: |
| 1 | bool_ | 布尔型数据类型（True 或者 False） |
| 2 | int_ | 默认的整数类型（类似C语言long，int32 或 int64） |
| 3 | intc | 与 C 语言的 int 类型相似，一般是 int32 或 int64 |
| 4 | intp | 用于索引的整数类型（类似于 C 的 ssize_t，通常是 int32 或 int64） |
| 5 | int8 | 字节（-128 到 127） |
| 6 | int16 | 整数（-32768 到 32767） |
| 7 | int32 | 整数（-2147483648 到 2147483647） |
| 8 | int64 | 整数（-9223372036854775808 到 9223372036854775807） |
| 9 | uint8 | 无符号整数（0 到 255） |
| 10 | uint16 | 无符号整数（0 到 65535） |
| 11 | uint32 | 无符号整数（0 到 4294967295） |
| 12 | uint64 | 无符号整数（0 到 18446744073709551615） |
| 13 | float_ | float64 类型的简写 |
| 14 | float16 | 半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位 |
| 15 | float32 | 单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位 |
| 16 | float64 | 双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位 |
| 17 | complex_ | complex128 类型，即 128 位复数 |
| 18 | complex64 | 复数，双 32 位浮点数（实数部分和虚数部分） |
| 19 | complex128 | 复数，双 64 位浮点数（实数部分和虚数部分） |

  # 生成一个2*3的整形矩阵
  array = np.array([[1, 2, 3], [4, 5, 6]],dtype=np.float64)
  # 打印矩阵数据类型
  print(array.dtype)
  
  #结果：
  #矩阵数据类型： float64

• Numpy的生成

  import numpy as np
  
  # 生成一个2*3的全为0的矩阵
  a = np.zeros((2, 3),dtype=np.int64)
  print("2*3的全0矩阵：\n",a)
  
  # 范围生成，范围为[10,22），步长为2的矩阵
  a2 = np.arange(10,22,2)
  print("范围生成：\n",a2)
  
  # 生成一个[1,10]范围内等距的5个数字
  a3 = np.linspace(0,10,5)
  print("范围内等距的5个数字：\n",a3)

# 结果：
2*3的全0矩阵：
 [[0 0 0]
 [0 0 0]]
范围生成：
 [10 12 14 16 18 20]
等距的5个数字：
 [ 0.   2.5  5.   7.5 10. ]

• Numpy数据运算

  import numpy as np
  
  # 生成一个矩阵
  a = np.array([10, 20, 30, 40])
  # 生成[1,5)，步长为1的矩阵
  b = np.arange(1, 5, 1)
  print("a矩阵：", a)
  print("b矩阵：", b)
  
  print("a与b相对应位置元素逐个相加:", a + b)
  print("a与b相对应位置元素逐个相减:", a - b)
  print("a与b相对应位置元素逐个相乘:", a * b)
  print("a与b进行矩阵相乘：", a.dot(b))
  
  print("a矩阵各元素对应弧度制的正弦值：", np.sin(a))
  print("a中元素是否<30：", a < 30)
  
  print("a中元素求和：", np.sum(a))
  print("a中元素最小值：", np.min(a))
  print("a中元素最大值：", np.max(a))
  c = np.array([[1, 2, 3], [4, 5, 6]])
  # aixs=0表示列操作 aixs=1表示行操作
  print("c中元素每行的最大值：", np.max(c, axis=1))
  print("c中元素每列的最大值：", np.max(c, axis=0))

# 结果：
a矩阵： [10 20 30 40]
b矩阵： [1 2 3 4]
a与b相对应位置元素逐个相加: [11 22 33 44]
a与b相对应位置元素逐个相减: [ 9 18 27 36]
a与b相对应位置元素逐个相乘: [ 10  40  90 160]
a与b进行矩阵相乘： 300
a矩阵各元素对应弧度制的正弦值： [-0.54402111  0.91294525 -0.98803162  0.74511316]
a中元素<30： [ True  True False False]
a中元素求和： 100
a中元素最小值： 10
a中元素最大值： 40
c中元素每列的最大值： [4 5 6]
c中元素每行的最大值： [3 6]

import numpy as np

array = np.arange(15).reshape(3, 5)
print(array)
print("最大值：", np.argmax(array))
print("最小值：", np.argmin(array))
print("前缀和：", np.cumsum(array))
print("差分：", np.diff(array))
print("非0元素的位置\n", np.nonzero(array))
print("排序：\n", np.sort(array))
# 转置也可以用array.T
print("转置：\n", np.transpose(array))
# 小于5 的用5填充，大于9的用9填充
print("clip测试：\n", np.clip(array, 5, 9))

# 原矩阵
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]
# 最大值： 14
# 最小值： 0
# 前缀和： 
[  0   1   3   6  10  15  21  28  36  45  55  66  78  91 105]
#差分：
[[1 1 1 1]
 [1 1 1 1]
 [1 1 1 1]]
# 非0元素的位置，第一个数组表示横坐标，第二个表示纵坐标
 (array([0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2]), array([1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4]))
# 排序：
 [[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]
# 转置：
 [[ 0  5 10]
 [ 1  6 11]
 [ 2  7 12]
 [ 3  8 13]
 [ 4  9 14]]
# clip测试：
 [[5 5 5 5 5]
 [5 6 7 8 9]
 [9 9 9 9 9]]

• 索引（基本上同python原生列表一样）

  import numpy as np
  
  array = np.arange(15).reshape(3, 5)
  # 原矩阵
  print(array)
  # 第(0,1)位置矩阵
  print("第(0,1)位置矩阵：", array[0, 1])
  # 第0行矩阵
  print("第0行矩阵", array[0, :])
  # 第0列矩阵
  print("第0列矩阵",array[:, 0])
  # 逐元素打印1
  for i in np.nditer(array):
      print(i)
  # 逐元素打印2
  for i in array.flat:
      print(i)

# 原矩阵
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]
# 第(0,1)位置矩阵： 1
# 第0行矩阵 [0 1 2 3 4]
# 第0列矩阵 [ 0  5 10]
# 逐元素打印
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 迭代器打印
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 矩阵合并

  • 上下合并vstack （垂直）
  • 左右合并 hstack（水平）
  • 数列变成矩阵（横向变纵向），A[:,np.newaxis] 改变维度

• 矩阵分割

  import numpy as np
  
  array = np.arange(12).reshape(3, 4)
  print(array)
  # 上下分割
  print("上下分割：", np.split(array, 3, axis=0))
  print("上下分割：", np.vsplit(array, 3))
  #左右分割
  print("左右分割1：", np.split(array, 2, axis=1))
  print("上下分割2：", np.hsplit(array, 2))
  # 不均等分割
  print("不均等分割：",np.array_split(array, 2, axis=0))

# 原数组
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
# 上下分割：
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
# 上下分割：
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
# 左右分割1：
[array([[0, 1], [4, 5],[8, 9]]), array([[ 2,  3],[ 6,  7],[10, 11]])]
#上下分割2：
[array([[0, 1], [4, 5], [8, 9]]), array([[ 2,  3], [ 6,  7], [10, 11]])]
# 不均等分割：
[array([[0, 1, 2, 3], [4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]

• 深拷贝和浅拷贝（同Java的深浅拷贝）

  import numpy as np
  # 浅拷贝，只会创建一个引用过去，而不会重新new对象
  a = np.arange(3)
  b = a
  print("a:", a) # a: [0 1 2]
  print("b:", b) # b: [0 1 2]
  a[0] = 100
  print("a:", a) # a: [100   1   2]
  print("b:", b) # b: [100   1   2]
  
  # 深拷贝，里面的所有对象会重新新建
  a = np.arange(3)
  b = a.copy()
  print("a:", a) # a: [0 1 2]
  print("b:", b) # b: [0 1 2]
  a[0] = 100
  print("a:", a) # a: [100   1   2]
  print("b:", b) # b: [0 1 2]