numpy基本命令

numpy基本命令 数据创建 1.常量

• numpy.nan：空值
• numpy.inf：正无穷大
• numpy.pi：圆周率
• numpy.e：自然常数 e

2.变量

Python 原生的数据类型相对较少， bool、int、float、str等。这在不需要关心数据在计算机中表示的所有方式的应用中是方便的。然而，对于科学计算，通常需要更多的控制。为了加以区分 numpy 在这些类型名称末尾都加了“_”。

• numpy 的数值类型实际上是 dtype 对象的实例
• 每个内建类型都有一个唯一定义它的字符代码

日期时间：

• 创建时间：time = np.datetime64('2020-03-08 20:00:05')
• 从字符串创建 datetime64 类型时，可以强制指定使用的单位。a = np.datetime64('2020-03', 'D')
• 使用arange()创建 datetime64 数组，用于生成日期范围：a = np.arange('2020-08-01', '2020-08-10', dtype=np.datetime64)
• timedelta64 表示两个 datetime64 之间的差

3.数组

order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘k’ – 元素在内存中的出现顺序

创建方法：

• 一维：a = np.array([0, 1, 2, 3, 4])

• 二维：c = np.array([[11, 12, 13, 14, 15],[16, 17, 18, 19, 20]])

• 三维：d = np.array([[(1.5, 2, 3), (4, 5, 6)], [(3, 2, 1), (4, 5, 6)]])

• array()和asarray()主要区别就是当数据源是ndarray 时，array()仍然会 copy 出一个副本，占用新的内存，asarray()不会。

• fromfunction()，该函数可从函数中创建数组：fromfunction(function, shape, **kwargs)

• 零数组：

  • zeros()函数：返回给定形状和类型的零数组
  • zeros_like()函数：返回与给定数组形状和类型相同的零数组。

• 1 数组

  • ones()函数：返回给定形状和类型的1数组。
  • ones_like()函数：返回与给定数组形状和类型相同的1数组。

• 空数组：

  • empty(shape, dtype=None, order='C')函数：返回一个空数组，数组元素为随机数。
  • empty_like函数：返回与给定数组具有相同形状和类型的新数组。

• eye(N, M=None, k=0, dtype=float, order='C')函数：返回一个对角线上为1，其它地方为零的单位数组。

• identity()函数：返回一个方的单位数组。

• diag()函数：提取数组对角线或根据给的数据构造新的对角数组。def diag(v, k=0)：k：第k个对角线

• full(shape, fill_value, dtype=None, order='C')函数：返回一个常数数组。

• full_like(a, fill_value, dtype=None, order='K', subok=True, shape=None)函数：返回与给定数组具有相同形状和类型的常数数组

• 利用数值范围来创建ndarray:

  • arange([start,] stop[, step,])函数：返回给定间隔内的均匀间隔的值。arange([start,] stop[, step,], dtype=None)
  • linspace(start, stop, num)函数：返回指定间隔内的等间隔数字。
  • logspace(start, stop, num)函数：返回数以对数刻度均匀分布。
  • numpy.random.random() 返回一个由[0,1)内的随机数组成的数组。

• 利用特定结构创建数组：

  • 利用字典结构创建数组
    import numpy as np
    
    personType = np.dtype({
        'names': ['name', 'age', 'weight'],
        'formats': ['U30', 'i8', 'f8']})
    
    a = np.array([('Liming', 24, 63.9), ('Mike', 15, 67.), ('Jan', 34, 45.8)],
                 dtype=personType)
    print(a, type(a))
    # [('Liming', 24, 63.9) ('Mike', 15, 67. ) ('Jan', 34, 45.8)]
    # 
    

数组属性：

• numpy.ndarray.ndim用于返回数组的维数（轴的个数）也称为秩，一维数组的秩为 1，二维数组的秩为 2。
• numpy.ndarray.shape表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)。
• numpy.ndarray.size数组中所有元素的总量，相当于数组的shape中所有元素的乘积
• numpy.ndarray.dtype ndarray 对象的元素类型。
• numpy.ndarray.itemsize以字节的形式返回数组中每一个元素的大小。

数组索引、切片与迭代

在 Numpy 中，尤其是在做数组运算或数组 *** 作时，返回结果不是数组的 副本 就是 视图。

• 赋值运算不会为数组和数组中的任何元素创建副本
• numpy.ndarray.copy() 函数创建一个副本。 对副本数据进行修改，不会影响到原始数据

索引与切片

数组索引机制指的是用方括号（[]）加序号的形式引用单个数组元素，它的用处很多，比如抽取元素，选取数组的几个元素，甚至为其赋一个新值。

• x( [start:stop:step] )：省去第一个数字，numpy 会认为第一个数字是0；如省去第二个数字，numpy 则会认为第二个数字是数组的最大索引值；如省去最后一个数字，它将会被理解为1

• x( [start:stop:step],[start:stop:step] )：通过对每个以逗号分隔的维度执行单独的切片，你可以对多维数组进行切片。

• dots索引：Numpy 允许使用...表示足够多的冒号来构建完整的索引列表。

  • 如果 x 是 5 维数组：x[1,2,...]等于 x[1,2,:,:,:]

• 整数数组索引：x([1,2,3])方括号内传入多个索引值，可以同时选择多个元素。

  • 使用切片索引到numpy数组时，生成的数组视图将始终是原始数组的子数组, 但是整数数组索引，不是其子数组，是形成新的数组。

• 数组遍历迭代：apply_along_axis(func1d, axis, arr):(函数，维度，遍历对象)

• numpy.take(a, indices, axis=None, out=None, mode='raise')沿轴从数组中获取元素。

数组 *** 作

• np.allclose(A,B)：验证数组是否相同

变形

• numpy.ndarray.shape表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)。

• numpy.ndarray.flat 将数组转换为一维的迭代器，可以用for访问数组每一个元素。返回的是视图。

• numpy.ndarray.flatten([order='C']) 将数组的副本转换为一维数组，并返回拷贝。

  • order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘k’ – 元素在内存中的出现顺序

• numpy.ravel(a, order='C')：返回一个扁平数组，默认返回的是视图

  • order=F 就返回拷贝

• numpy.reshape(a, newshape[, order='C'])在不更改数据的情况下为数组赋予新的形状。

• 数组转置：numpy.transpose(a, axes=None)或numpy.ndarray.T

更改维度

• y = x[np.newaxis, :]：给x增加一个维度
• numpy.squeeze(a, axis=None)从数组的形状中删除单维度条目，即把shape中为1的维度去掉。
  • a表示输入的数组；
  • axis用于指定需要删除的维度，但是指定的维度必须为单维度，否则将会报错；

数组拼接

• numpy.concatenate((a1, a2, ...), axis=0, out=None)：数组拼接，不改变维度

  • axis：拼接维度：np.concatenate([x, y], axis=1)或np.concatenate((x, y), axis=1)

• numpy.stack(arrays, axis=0, out=None)：沿着新的轴加入一系列数组（stack为增加维度的拼接）

  • axis：增加维度位置：np.stack([x, y], axis=2)

• numpy.vstack(tup)：垂直（按行）按顺序堆叠数组。不改变维度 numpy.vstack((x,y))

• numpy.hstack(tup)：水平（按列）按顺序堆叠数组。不改变维度 numpy.hstack((x,y))

数组拆分

• numpy.split(ary, indices_or_sections, axis=0) 将一个数组拆分为多个子数组作为 ary 的视图。
• numpy.vsplit(ary, indices_or_sections)： 将数组垂直（按行）拆分为多个子数组。
• numpy.hsplit(ary, indices_or_sections)：将数组水平（按列）拆分为多个子数组。
  • np.split(x, [1, 4])：按数截取，类似[1:4]，截取后两端若无，会有个空数组
  • np.split(x, 3)：将数组截取为3份

数组平铺

• numpy.tile(A, reps)：将原矩阵横向、纵向地复制。np.tile(x, (1, 3)):沿列复制3遍
• numpy.repeat(a, repeats, axis=None)：通过重复形成新数组
  • axis=0，沿着y轴复制，实际上增加了行数。
  • axis=1，沿着x轴复制，实际上增加了列数。
  • a：可以为一个数，也可以为一个矩阵。
  • repeats，可以为一个数，也可以为一个矩阵。
  • axis=None时就会flatten当前矩阵，实际上就是变成了一个行向量。

查找唯一元素

• numpy.unique(ar, return_index=False, return_inverse=False,return_counts=False, axis=None)查找数组的唯一元素，生成只包含唯一元素的新数组
  • return_index：给出唯一值在输入数组第一次输入的索引
  • return_inverse：输入数组各元素值在新生成的唯一数组的索引
  • return_counts：每个唯一值出现在输入数组中的次数

数学函数

广播原则：

• 如果两个数组的维度数dim不相同，那么小维度数组的形状将会在左边补1。
• 如果shape维度不匹配，但是有维度是1，那么可以扩展维度是1的维度匹配另一个数组；
• 如果shape维度不匹配，但是没有任何一个维度是1，则匹配引发错误；

算术运算

• 加：numpy.add(x1, x2, *args, **kwargs)

• 减：numpy.subtract(x1, x2, *args, **kwargs)

• 乘：numpy.multiply(x1, x2, *args, **kwargs)

• 除：numpy.divide(x1, x2, *args, **kwargs)

• 地板除：numpy.floor_divide(x1, x2, *args, **kwargs)

• 幂运算：numpy.power(x1, x2, *args, **kwargs)

• 平方根：numpy.sqrt(x, *args, **kwargs)

• 平方：numpy.square(x, *args, **kwargs)

三角函数：

• numpy.sin(x, *args, **kwargs) 、numpy.cos()、numpy.tan()、numpy.arcsin()、numpy.arccos() 、numpy.arctan()

指数和对数：

• numpy.exp(x, *args, **kwargs) ： e x e^x ex
• numpy.log(x, *args, **kwargs)： l n x lnx lnx
• numpy.exp2(x, *args, **kwargs)： 2 x 2^x 2x
• numpy.log2(x, *args, **kwargs)
• numpy.log10(x, *args, **kwargs)

运算函数：

• numpy.sum(a[, axis=None, dtype=None, out=None, …])：返回给定轴上的数组元素的总和。

• numpy.cumsum(a, axis=None, dtype=None, out=None)：返回给定轴上的数组元素的累加和。

• numpy.prod(a[, axis=None, dtype=None, out=None, …])：返回给定轴上数组元素的乘积。

• numpy.cumprod(a, axis=None, dtype=None, out=None)：返回给定轴上数组元素的累乘。

• numpy.diff(a, n=1, axis=-1, prepend=np._NoValue, append=np._NoValue)：沿着指定轴计算第N维的离散差值。

  • a：输入矩阵
  • n：可选，代表要执行几次差值
  • axis：默认是最后一个

• numpy.around(a, decimals=0, out=None：将数组舍入到给定的小数位数。

• numpy.ceil(x, *args, **kwargs) ：取上限

• numpy.floor(x, *args, **kwargs) ：取下限

• numpy.clip(a, a_min, a_max, out=None, **kwargs):限制数组中的值的大小，超过a_max的设为a_max。

• numpy.abs(x, *args, **kwargs)：绝对值

• numpy.sign(x, *args, **kwargs)：返回数字符号的逐元素指示

逻辑函数

真值测试

• numpy.all(a, axis=None, out=None, keepdims=np._NoValue) 测设沿给定轴的元素是否全为真
• numpy.any(a, axis=None, out=None, keepdims=np._NoValue) 测设沿给定轴的元素是否部分为真

数组 *** 作内容

• numpy.isnan(x, *args, **kwargs) 逐元素测试数组元素是否为NAN，将结果以数组返回
• numpy.logical_not(x, *args, **kwargs)按元素计算 NOT x 的真值。将结果以数组返回
• numpy.logical_and(x1, x2, *args, **kwargs) x1 and x2
• numpy.logical_or(x1, x2, *args, **kwargs)x1 or x2
• numpy.logical_xor(x1, x2, *args, **kwargs)x1 XOR x2(异或)
• numpy.greater(x1, x2, *args, **kwargs) Return the truth value of (x1 > x2) element-wise.
• numpy.greater_equal(x1, x2, *args, **kwargs) Return the truth value of (x1 >= x2) element-wise.
• numpy.equal(x1, x2, *args, **kwargs) Return (x1 == x2) element-wise.
• numpy.not_equal(x1, x2, *args, **kwargs) Return (x1 != x2) element-wise.
• numpy.less(x1, x2, *args, **kwargs) Return the truth value of (x1 < x2) element-wise.
• numpy.less_equal(x1, x2, *args, **kwargs) Return the truth value of (x1 =< x2) element-wise.

排序，搜索和计数

排序

• numpy.sort(a[, axis=-1, kind='quicksort', order=None])

  • axis：排序沿数组的（轴）方向，0表示按行，1表示按列，None表示展开来排序，默认为-1，表示沿最后的轴排序。
  • kind：排序的算法，提供了快排’quicksort’、混排’mergesort’、堆排’heapsort’， 默认为‘quicksort’。
  • order：排序的字段名，可指定字段排序，默认为None。

• numpy.argsort(a[, axis=-1, kind='quicksort', order=None]):对数组沿给定轴执行间接排序，并返回数据的索引数组。这个索引数组用于构造排序后的数组。

• numpy.partition(a, kth, axis=-1, kind='introselect', order=None)以大小排序为kth 的元素为基准，将元素分成两部分，即大于该元素的放在其后面，小于该元素的放在其前面

• numpy.argpartition(a, kth, axis=-1, kind='introselect', order=None)

搜索

• numpy.argmax(a[, axis=None, out=None])返回沿轴最大值的索引

• numpy.argmin(a[, axis=None, out=None])返回沿轴最小值的索引

• numppy.nonzero(a)返回非零元素的下标在对应轴上的值。

  • 只有a中非零元素才会有索引值，那些零值元素没有索引值。

  • 返回一个长度为a.ndim的元组（tuple），元组的每个元素都是一个整数数组（array）

  • 每一个array均是从一个维度上来描述其索引值。比如，如果a是一个二维数组，则tuple包含两个array，第一个array从行维度来描述索引值；第二个array从列维度来描述索引值。

  • 该 np.transpose(np.nonzero(x)) 函数能够描述出每一个非零元素在不同维度的索引值。

  • 通过a[nonzero(a)]得到所有a中的非零值。

    import numpy as np
    x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]])
    y = np.nonzero(x)
    print(y)
    # (array([0, 1, 2, 2], dtype=int64), array([0, 1, 0, 1], dtype=int64))
    print(np.array(y))
    # [[0 1 2 2]
    #  [0 1 0 1]]
    print(np.array(y).shape)  # (2, 4)
    print(np.array(y).ndim)  # 2
    

• numpy.where(condition, [x=None, y=None]) 满足条件condition，输出x，不满足输出y。

  • 只有condition，没有x和y，则输出满足条件 (即非0) 元素的坐标 (等价于numpy.nonzero)。
  • 这里的坐标以tuple的形式给出，通常原数组有多少维，输出的tuple中就包含几个数组，分别对应符合条件元素的各维坐标。

• numpy.searchsorted(a, v[, side='left', sorter=None])查找插入元素后可以保持顺序的索引。

  • a：一维输入数组。当sorter参数为None的时候，a必须为升序数组；否则，sorter不能为空，存放a中元素的index，用于反映a数组的升序排列方式。
  • v：插入a数组的值，可以为单个元素，list或者ndarray。
  • side：查询方向，当为left时，将返回第一个符合条件的元素下标；当为right时，将返回最后一个符合条件的元素下标。
  • sorter：一维数组存放a数组元素的 index，index 对应元素为升序。

计数

• numpy.count_nonzero(a, axis=None) ：返回数组中的非0元素个数。

集合 *** 作

• numpy.in1d(ar1, ar2, assume_unique=False, invert=False):前面的数组是否包含于后面的数组，返回布尔值。返回的值是针对第一个参数的数组的，所以维数和第一个参数一致，布尔值与数组的元素位置也一一对应。

• 求集合交集：numpy.intersect1d(ar1, ar2, assume_unique=False, return_indices=False)

• 求集合并集：numpy.intersect1d(ar1, ar2, assume_unique=False, return_indices=False)

• 求集合并集并唯一化排序：numpy.union1d(ar1, ar2)

• 求集合差集：numpy.setdiff1d(ar1, ar2, assume_unique=False)

• 求集合异或：setxor1d(ar1, ar2, assume_unique=False)

集：numpy.intersect1d(ar1, ar2, assume_unique=False, return_indices=False)

• 求集合并集：numpy.intersect1d(ar1, ar2, assume_unique=False, return_indices=False)
• 求集合并集并唯一化排序：numpy.union1d(ar1, ar2)
• 求集合差集：numpy.setdiff1d(ar1, ar2, assume_unique=False)
• 求集合异或：setxor1d(ar1, ar2, assume_unique=False)