概念

Axis

  • 用途

    • 用来说明维度,第几个维度
  • 取值

    0
    row, 行
    1
    column, 列
    2
    panel, 层
    -1
    last, 最后一维
  • 使用场景

    • np.stack

      • axis 直接指定堆叠操作的维度,其它维度,依次用单个元素的 shape 成员取代
      • 0 – 把数据在不同的行之间堆叠

        • 即 np.vstack
      • 1 – 在列上堆叠

        • 即 np.hstack
      • 2 – 在层上堆叠
    • pd.DataFrame.apply

      • 0 – 向下, 沿着第 0 维度,不同的行,即作用到一整列
      • 1 – 向右, 沿着第 1 维度,不同的列,即作用到一整行

创建数组

  • np.arange

    • start, stop, step
  • np.linspace

    • start, stop, count
  • np.logspace

    • start, stop, count
    • 基数 base 默认为 10

向量

建立

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

数乘

直接运算,对应元素简单相乘。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
import numpy as np
a = [1, 2]
b = [3, 4]

a = np.array(a)
b = np.array(b)

c = a * b
# c = [3, 8]

assert np.multiply(a, b) == a * b
  • 运算符: *

点积

1
assert np.doc(a, b)  == a @ b
  • 运算符: @

叉积

1
np.cross(a, b)
  • 运算符: 没有运算符

二维向量

返回值是,只包含一个整数的 np.array

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import numpy as np
a = [1, 2]
b = [3, 4]

a = np.array(a)
b = np.array(b)

c = np.cross(a, b)
# c--> np.array(-2)
c.tolist()  # int type, -2
  • 取值方法

    1
    
    ret_val.tolist()

三维向量

返回值,就是与 a, b 垂直的向量 c

1
2
3
4
5
6
7
8
9
import numpy as np
a = [1, 2, 0]
b = [3, 4, 0]

a = np.array(a)
b = np.array(b)

c = np.cross(a, b)
# c--> np.array([0, 0, -2])

展开数组 np.ravel

把 数组(二维或多维)展开成一维

参数

  • order

    • 取值

      • 'C': C 语言形式,行为主,按行展开
      • 'F': Fortran 语言形式,列为主,按列展开

最小估二乘法

numpy.linalg.lstsq(A, b)

打印不全问题

1
2
3
import numpy as np

np.set_printoptions(threshold = 1e6)     #  threshold表示输出数组的元素数目

解方程

scipy.optimize.fsolve

  • 起始点

    • 可以是单个值

       1
       2
       3
       4
       5
       6
       7
       8
       9
      10
      
      from scipy import optimize
      
      
      def fun(x):
          return x**2 -4
      
      
      if __name__ == '__main__':
          solution = optimize.fsolve(fun, 4)
          print(solution)
    • 也可以是一个 list

       1
       2
       3
       4
       5
       6
       7
       8
       9
      10
      
      from scipy import optimize
      import numpy as np
      
      def fun(x):
          return np.power(x, 2) - 4
      
      
      if __name__ == '__main__':
          solution = optimize.fsolve(fun, np.array([-4, 4]))
          print(solution)
      • 注意

        • 这里在方程函数中,使用的是 numpy 支持的运算符
        • 原因

          • 当输入起始值为 list 时,scipy “内部会转换成 numpy.ndarray” 来处理,
          • (x**2): 会被认为是 numpy 的非法操作

            • 矩阵乘法(numpy shape 不满足要求)

Warning

  • 多个起始值

    • 并不一定能找到多个合法的解

验证合法 numpy.isclose

  • np.isclose(result_input, correct_array)

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    
    from scipy.optimize import fsolve
    
    def func(x):
        return [x[0] * np.cos(x[1]) - 4,
                x[1] * x[0] - x[1] - 5]
    
    
    >>> root = fsolve(func, [1, 1])
    >>> root
    array([6.50409711, 0.90841421])
    >>> np.isclose(func(root), [0.0, 0.0])  # func(root) should be almost 0.0.
    array([ True,  True])

scipy.optimize.root

  • 更好的接口,返回值有判断

注意

  • np.stack 特别消耗时间

稀疏矩阵 scipy.sparse

线性代数

创建矩阵

  • 单位阵

    • np.eye(size)

      1
      2
      3
      4
      
      np.eye(2)
      
      [[1, 0]
       [0, 1]]
  • 方块阵

    • np.bmat(str_or_array)

      • str:

        • '1,2,3;4,5,6'
        • 'A,B;C,D'
        • [[A,B],[C,D]]

          • ABCD 是已有矩阵
  • 普通阵

    • np.matrix(str_or_array, copy=True)

      • 创建拷贝
    • np.mat(str_or_array)

      • 不支持 'A;B' 方块阵写法
      • 仅支持 '1,2;3,4'

大小端转换

  • arr.byteswap()
  • 数据表示法,大端 vs 小端 转换
  • 大端

    • 通常概念

      • 低位字节存高位数据
      • 高位字节存低位数据
      • 类似正常的数字书写习惯
  • 小端

    • 与大端相反
  • 注意

    • 大端小端针对的是字节之间的顺序
    • 字节内部还是通常的存储顺序

shape 修改

  • 可以直接修改 shape 属性

    • eg:

       1
       2
       3
       4
       5
       6
       7
       8
       9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      
      In [236]: a.shape
      Out[236]: (4,)
      
      In [237]: a.shape = (2,3)
      ---------------------------------------------------------------------------
      ValueError                                Traceback (most recent call last)
      <ipython-input-237-0f2a8a8d403e> in <module>
      ----> 1 a.shape = (2,3)
      
      ValueError: cannot reshape array of size 4 into shape (2,3)
      
      In [238]: a.shape = (2,2)
      
      In [239]: a
      Out[239]:
      array([[0, 1],
             [2, 3]])
      
      In [240]: a.shape
      Out[240]: (2, 2)
  • arr.reshape(*shape)

创建完全拷贝

  • arr.view()

点积 np.dot

  • 向量

    • 对应元素相乘,再加和
  • 二维矩阵

    • 即矩阵的乘法
    • 等价于 np.matmul(A, B)

元素大小

  • arr.itemsize

    • 即单个元素所占字节数

帮助 np.info

  • numpy 对象,打印简略信息
  • 非 numpy 对象,类似 help(obj)

数据类型转换

  • astype() 方法

    • arr.astype(np.uint8)

磁盘文件映射 np.memmap

范德蒙德行列式 np.vander(your_vector)

判断相等

  • np.all(arrA == arrB)

判断近似相等

查找

  • np.where(x_want == X_array)
  • 返回 index

    • eg:

      • X_array[np.where(x_want == X_arrary)]

去重, 类似 set()

  • np.unique(arr)

内存连续性 np.ascontiguousarray(arr)

参考: np.ascontiguousarray()详解 - 回忆瞬间 - 博客园

功能:让 arr 在内存中连续

为什么有这个功能: 因为各种操作,导致 arr 的存储状态变得不连续

  • arr 默认行连续,列不连续
  • 转置 transpose 导致连续性改变
  • 切片 slice 导致连续性改变

因此,需要 np.ascontiguousarray 恢复 arr 的内存连续性

np.dtype

dtype 对象

参考:Data type objects (dtype) — NumPy v1.21 Manual

属性:

  • dtype.itemsize: 字节数据量
  • dtype.name: dtype 的名称

    1
    2
    3
    
    x = np.dtype([('a', np.int32, 8), ('b', np.float64, 6)])
    x.name
    'void640'

创建

  • 单个类型格式

    • 只有类型

      type
      
      • eg:

        • np.uint8

          1
          
          np.dtype(np.uint8)
    • 不指定名称

      (type, size)
      
      • eg:

        • (np.uint8, 3)
        • (np.void, 4)
    • 指定名称

      (name, type, size)
      (name, type)
      
      • eg:

        • ("identity", np.uint8, 4)
        • ("grades", np.float32, 3)
        • ("identity", np.uint64)
        • 代码例子

          1
          
          np.dtype([("grades", np.float32, 3)])
      • 注意

        • 制定名称的 单个 dtype 不能单独使用
        • 必须组合成复合类型才能使用
    • 解释

      • type : numpy 内部规定的类型

        • np.uint8
        • np.int8
        • np.bool_
        • np.void 空类型
      • size : 制作的 dtype 包含几个 type,即由 size 个 type 合成

        • 数字类型,eg: 1, 2, 3
      • name : 制作的 type 的名称

        • string 类型
        • eg: "grades", "family name"
  • 复合类型

    • List[单个类型]
    • eg:

      • [(np.uint8, 4), (np.bool_, 2)]
      • 代码

        1
        
        np.dtype([(np.uint8, 4), (np.bool_, 2)])
  • 嵌套类型

    • [List[List[单个类型]], 单个类型]
    • 代码

      1
      2
      3
      
      np.dtype([
          ("id", np.uint32,1),
          [(np.uint8, 4), (np.bool_, 2)]])

view

ndarray.view

返回一个 view 对象

两种用法:

  • arr.view()

    • 返回一个 dtype 不变的 view
  • arr.view(some_dtype)

    • 原 dtype 修改 新 dtype,制作一个 view

np.unique(arr)

参考:numpy.unique — NumPy v1.21 Manual 用途:去重 默认返回值

特殊参数:

  • return_index=False

    • 对应 unique 元素的位置
  • return_counts=False

    • 对应 unique 元素的重复次数
  • return_inverse=False

    • 用于重建 arr

索引查找

np.argmax(arr, axis=None)

ref: numpy.argmax — NumPy v1.21 Manual

作用:返回最大元素的 index

np.argmin(arr)

作用:返回最小元素的 index

转置 transpose()

  1. array.T
  2. 向 transpose 转置赋值

    • 赋值的结果会作用于原有的对象
    • eg: arr.T[2, 3] = 2, 向原有数据的 3 行 2 列赋值

展平 flatten()

方法:

  • array.flattern()array.ravel() 是相同的函数

属性

  • array.flat 是一个展平的数据迭代器

np.atleast_1d() 标量转向量

  • 如果是标量,转换成向量
  • 如果原来就是向量,保持不变

shape 变换 array.reshape()

修改逻辑:

  1. 原有的数据变形

    • -> [*第一行数据, *第二行数据]
    • 即原有数据先按行展开成一维,第一行的不同列,第二行的不同列
  2. 数据按新的 newshape 构建新的结构

    • -> [先排布第一行,再排布第二行, …]

参数:

  • newshape

    • 单个整数:vector
    • tuple: –> (row, column)
    • 特殊值 -1: 表示根据实际大小自动推断

例子:

1
2
3
4
5
In [75]: np.array([[1,2,3], [4,5,6]]).reshape(3,2)
Out[75]:
array([[1, 2],
       [3, 4],
       [5, 6]])

shape -1 的例子:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
>>> a = np.array([[1,2,3], [4,5,6]])
>>> np.reshape(a, 6)
array([1, 2, 3, 4, 5, 6])
>>> np.reshape(a, 6, order='F')
array([1, 4, 2, 5, 3, 6])

>>> np.reshape(a, (3,-1))       # the unspecified value is inferred to be 2
array([[1, 2],
       [3, 4],
       [5, 6]])

np.clip 把数值限定在给定的区间内

1
2
3
4
5
6
7
8
In [76]: np.clip(1000, 1, 100)
Out[76]: 100

In [77]: np.clip(-1000, 1, 100)
Out[77]: 1

In [78]: np.clip([-1000, 50], 1, 100)
Out[78]: array([ 1, 50])