import numpy as np

1 ones

       ones(shape[, dtype, order])

    依据给定形状和类型(shape[, dtype, order])返回一个新的元素全部为1的数组。

       参数:
       shape:int或者ints元组;定义返回数组的形状,形如:(2, 3)或2。
       dtype:数据类型,可选。
       返回数组的数据类型,例如:numpy.int8、默认numpy.float64
       order:{‘C’, ‘F’},可选,返回数组为多维时,元素在内存的排列方式是按C语言还是Fortran语言顺序(row- or columnwise)。
       输出:ndarray给定形状,数据类型的数组。

>>> np.ones(5)
    array([ 1.,  1.,  1.,  1.,  1.])

>>> np.ones((5,), dtype=np.int)
    array([1, 1, 1, 1, 1])

>>> np.ones((2, 1))
    array([[ 1.],
           [ 1.]])

>>> s = (2,2)
>>> np.ones(s)
    array([[ 1.,  1.],
           [ 1.,  1.]])


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

2 zeros

       zeros(shape[, dtype, order])

       参数:
       shape:int或者ints元组;定义返回数组的形状,形如:(2, 3)或2。
       dtype:数据类型,可选。
       返回数组的数据类型,例如:numpy.int8、默认numpy.float64
       order:{‘C’, ‘F’},可选,返回数组为多维时,元素在内存的排列方式是按C语言还是Fortran语言顺序(row- or columnwise)。
       输出:ndarray给定形状,数据类型的数组。

       与1 ones用法大致相同。

3 eye

      eye(N[, M, k, dtype]) 

       返回一个对角线元素为1,其他元素为0的二维数组。  
       参数:
      N : 整数返回数组的行数;
      M : 整数,可选返回数组的列数。如果不赋值的话,默认等于N;
      k : 整数, 可选对角线序列号: 0 对应主对角线;,整数对应upper diagonal,负数对应lower diagonal;
      dtype : dtype, 可选,返回数组的数据类型
      I : ndarray (N,M)该数组第k个对角线的元素为1,其他元素为0。

np.eye(2,dtype=int)生成的array=
[[1 0]
 [0 1]]

np.eye(3,k=1)生成的array=
[[ 0.  1.  0.]
 [ 0.  0.  1.]
 [ 0.  0.  0.]]

4 size

size():计算数组和矩阵所有数据的个数 
a = np.array([[1,2,3],[4,5,6]]) 
np.size(a),返回值为 6 
np.size(a,1),返回值为 3

5 shape

shape ():得到矩阵每维的大小 
np. shape (a),返回值为 (2,3)

另外要注意的是,shape和size既可以作为函数,也可以作为ndarray的属性 
a.size,返回值为 6, 
a.shape,返回值为 (2,3)

6 empty

    empty(shape[, dtype, order])

    依据给定形状和类型(shape[, dtype, order])返回一个新的空数组

   参数:

    shape : 整数或者整型元组定义返回数组的形状;
    dtype : 数据类型,可选定义返回数组的类型。
    order : {‘C’, ‘F’}, 可选规定返回数组元素在内存的存储顺序:C(C语言)-rowmajor;F(Fortran)column-major。

7 empty_like(a)

      依据给定数组(a)的形状和类型返回一个新的空数组

8 reshape()

   numpy.reshape(anewshapeorder='C')

      reshape()是数组对象中的方法,用于在不改变数据内容的情况下,改变数组的形状。

      参数:

      a : 数组——需要处理的数据。

      newshape : 新的格式——整数或整数数组,如(2,3)表示2行3列。新的形状应该与原来的形状兼容,即行数和列数相乘后等于a中元素的数量。如果是整数,则结果将是长度的一维数组,所以这个整数必须等于a中元素数量。若这里是一个整数数组,那么其中一个数据可以为-1。在这种情况下,这个个值python会自动从根据第二个数值和剩余维度推断出来。

       order : 可选范围——{‘C’, ‘F’, ‘A’}。使用索引顺序读取a的元素,并按照索引顺序将元素放到变换后的的数组中。“C”指的是用类C写的读/索引顺序的元素,横着读,横着写,优先读/写一行。“F”是指用FORTRAN类索引顺序读/写元素,竖着读,竖着写,优先读/写一列。注意,“C”和“F”选项不考虑底层数组的内存布局,只引用索引的顺序。“A”竖着读,横着写。这里可能听起来有点模糊,下面会给出示例。如果不进行order参数的设置,默认为C

import numpy as np
from numpy import random as nr
r=nr.randint(0,10,size=(4,3))
r1=r
r2=r
r3=r
r1=r1.reshape((3,4),order='F')
r2=r2.reshape((3,4),order='A')
r3=r3.reshape((3,4),order='C')
print(r)
print(r1)
print(r2)
print(r3)

结果:

>>>r
array([[1, 6, 2],
       [6, 1, 9],
       [6, 3, 2],
       [9, 1, 5]])

>>>r1
array([[1, 9, 3, 9],
       [6, 6, 1, 2],
       [6, 1, 2, 5]])

>>>r2
array([[1, 6, 2, 6],
       [1, 9, 6, 3],
       [2, 9, 1, 5]])

>>>r3
array([[1, 6, 2, 6],
       [1, 9, 6, 3],
       [2, 9, 1, 5]])
r=r1
r1=r.reshape((-1,1),order='C')
r2=r.reshape((-1,1),order='F')
r3=r.reshape((-1,1),order='A')
print(r1)
print(r2)
print(r3)

结果:

>>>r1
array([[1],
       [9],
       [3],
       [9],
       [6],
       [6],
       [1],
       [2],
       [6],
       [1],
       [2],
       [5]])

>>>r2
array([[1],
       [6],
       [6],
       [9],
       [6],
       [1],
       [3],
       [1],
       [2],
       [9],
       [2],
       [5]])

>>>r3
array([[1],
       [6],
       [6],
       [9],
       [6],
       [1],
       [3],
       [1],
       [2],
       [9],
       [2],
       [5]])

9 arrange()函数

    arange([start,] stop[, step,], dtype=None)

     函数说明:根据start与stop指定的范围以及step设定的步长,生成一个 ndarray。 dtype : dtype

    与range()对比:

  • range()返回的是range object,而np.nrange()返回的是numpy.ndarray() 

  • range尽可用于迭代,而np.nrange作用远不止于此,它是一个序列,可被当做向量使用。

  • range()不支持步长为小数,np.arange()支持步长为小数

  • 两者都可用于迭代

  • 两者都有三个参数,以第一个参数为起点,第三个参数为步长,截止到第二个参数之前的不包括第二个参数的数据序列 
    某种意义上,和STL中由迭代器组成的区间是一样的,即左闭右开的区间。[first, last)或者不加严谨地写作[first:step:last)

>>> np.arange(1, 5)
array([1, 2, 3, 4])

>>>np.arange(1, 5, .5)
array([ 1. ,  1.5,  2. ,  2.5,  3. ,  3.5,  4. ,  4.5])

>>for i in np.arange(1, 5):
...    print(i)
1
2
3
4

10 stack(),hstack(),vstack()

10.1 stack()

通过axis=0或1,对value进行堆积。

当axis=0时

输出:d ==> [[1, 2, 3, 4], [5, 6, 7, 8]]
    d[1, 1] ==> 6

当axis=1时

输出:d ==> [[1, 5],[2, 6],[3, 7],[4, 8]]
    d[1, 1] ==> 6

numpy中list的查找格式为list_one[row, column];如果写成list[row, :]代表取row那一行

python中list的查找格式为list[row][column]

10.2 hstack(value)

        value必须具有相同的数据结构,数据类型不限,可以是python的列表或者元祖,或者是numpy列表,hstack会将多个value(value_one, value_two)的相同维度的数值组合在一起,并以同value同样的数据结构返回numpy数组。

它其实就是水平(按列顺序)把数组给堆叠起来,vstack()函数正好和它相反。

输出:[1, 2, 3, 4, 5, 6]

输出:[[1, 1], [2, 2], [3, 3]]

import numpy as np
a=[1,2,3]
b=[4,5,6]
print(np.hstack((a,b)))

输出:[1 2 3 4 5 6 ]
import numpy as np
a=[[1],[2],[3]]
b=[[1],[2],[3]]
c=[[1],[2],[3]]
d=[[1],[2],[3]]
print(np.hstack((a,b,c,d)))

输出:
[[1 1 1 1]
 [2 2 2 2]
 [3 3 3 3]]

10.3 vstack()函数 

函数原型:vstack(tup) ,参数tup可以是元组,列表,或者numpy数组,返回结果为numpy的数组。看下面的代码体会它的含义。

import numpy as np
a=[1,2,3]
b=[4,5,6]
print(np.vstack((a,b)))

输出:
[[1 2 3]
 [4 5 6]]
import numpy as np
a=[[1],[2],[3]]
b=[[1],[2],[3]]
c=[[1],[2],[3]]
d=[[1],[2],[3]]
print(np.vstack((a,b,c,d)))

输出:
[[1]
 [2]
 [3]
 [1]
 [2]
 [3]
 [1]
 [2]
 [3]
 [1]
 [2]
 [3]]

它是垂直(按照行顺序)的把数组给堆叠起来。

11 矩阵乘法 np.dot, np.multiply, *

11.1 np.dot

同线性代数中矩阵乘法的定义,np.dot(A, B):对于二维矩阵,计算真正意义上的矩阵乘积,同线性代数中矩阵乘法的定义。对于一维矩阵,计算两者的内积。见如下Python代码:

import numpy as np

# 2-D array: 2 x 3
two_dim_matrix_one = np.array([[1, 2, 3], [4, 5, 6]])
# 2-D array: 3 x 2
two_dim_matrix_two = np.array([[1, 2], [3, 4], [5, 6]])
two_multi_res = np.dot(two_dim_matrix_one, two_dim_matrix_two)
print('two_multi_res: %s' %(two_multi_res))

# 1-D array
one_dim_vec_one = np.array([1, 2, 3])
one_dim_vec_two = np.array([4, 5, 6])
one_result_res = np.dot(one_dim_vec_one, one_dim_vec_two)
print('one_result_res: %s' %(one_result_res))

结果:

two_multi_res: [[22 28]
                [49 64]]
one_result_res: 32

11.2 np.multiply(), 或 *

在Python中,实现对应元素相乘,有2种方式,一个是np.multiply(),另外一个是*。见如下Python代码:

import numpy as np

# 2-D array: 2 x 3
two_dim_matrix_one = np.array([[1, 2, 3], [4, 5, 6]])
another_two_dim_matrix_one = np.array([[7, 8, 9], [4, 7, 1]])

# 对应元素相乘 element-wise product
element_wise = two_dim_matrix_one * another_two_dim_matrix_one
print('element wise product: %s' %(element_wise))

# 对应元素相乘 element-wise product
element_wise_2 = np.multiply(two_dim_matrix_one, another_two_dim_matrix_one)
print('element wise product: %s' % (element_wise_2))

结果如下:

element wise product: [[ 7 16 27]
 [16 35  6]]
element wise product: [[ 7 16 27]
 [16 35  6]]

12 transpose

12.1 二维

对于二维 ndarray,transpose在不指定参数是默认是矩阵转置。

x = np.arange(4).reshape((2,2))
import numpy as np
x.transpose()

结果:
#x 为:
array([[0, 1],
       [2, 3]])

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

如果指定参数,有如下相应结果: 

x.transpose((0,1))

# x 没有变化
array([[0, 1],
       [2, 3]])
x.transpose((1,0))

# x 转置了
array([[0, 2],
       [1, 3]])

对于x,因为:

x[0][0] == 0
x[0][1] == 1
x[1][0] == 2
x[1][1] == 3

不妨设第一个方括号“[]”为 0轴 ,第二个方括号为 1轴 ,则x可在 0-1坐标系 下表示如下: 

numpy-LMLPHP

因为 x.transpose((0,1)) 表示按照原坐标轴改变序列,也就是保持不变

而 x.transpose((1,0)) 表示交换 ‘0轴’ 和 ‘1轴’,所以就得到如下图所示结果:

numpy-LMLPHP

注意,任何时候你都要保持清醒,告诉自己第一个方括号“[]”为 0轴 ,第二个方括号为 1轴 
此时,transpose转换关系就清晰了。

12.2 三维

import numpy as np

# A是array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15])
A = np.arange(16)

# 将A变换为三维矩阵
A = A.reshape(2,2,4)
print(A)

结果:
A = array([[[ 0,  1,  2,  3],
            [ 4,  5,  6,  7]],

           [[ 8,  9, 10, 11],
            [12, 13, 14, 15]]])

对上述的A表示成如下三维坐标的形式:

numpy-LMLPHP

A.transpose((0,1,2))  #保持A不变
A.transpose((1,0,2))  #将 0轴 和 1轴 交换

结果:
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7]],
       [[ 8,  9, 10, 11],
        [12, 13, 14, 15]]])
array([[[ 0,  1,  2,  3],
        [ 8,  9, 10, 11]],
       [[ 4,  5,  6,  7],
        [12, 13, 14, 15]]])

13 单目运算函数

np.max: 返回最大值
np.argmax: 返回最大的值的序号
np.min: 返回最小值
np.argmin: 返回最小的值的序号
np.absolute: 计算绝对值,np.absolute(a) 或者 np.abs(a),对于非复数的数组,np.fabs 速度更快
np.exp: 计算 e 的指数
np.sqrt: 计算平方根
np.square: 计算平方
np.log, np.log10, np.log2, np.log1p: 分别为以 e, 10, 2 为底取 log, 和 log(1 + x)
np.sign: 取数值的正负号
np.ceil: 计算比每一个元素大或相等的最小的整数
np.floor: 计算比每一个元素小或相等的最大的整数
np.rint: 近似到最近的整数
np.clip(a, a_min, a_max, out=None): 返回一个 ndarray, 其元素的值如果小于min,就会被min值替代;如果大于max,就会被max值替代
np.modf: 返回一个 tuple, 包含两个数组, 一个是小数部分, 一个是整数部分
np.cos, np.cosh, np.sin, np.sinh, np.tan, np.tanh, np.arccos, np.arccosh, np.arcsin, np.arcsinh, np.arctan, np.arctanh: 三角函数和反三角函数

14 any()和all()

     any(iterables)all(iterables)对于检查两个对象相等时非常实用,但是要注意,anyall是python内置函数,同时numpy也有自己实现的anyall,功能与python内置的一样,只不过把numpy.ndarray类型加进去了。因为python内置的对高于1维的ndarray没法理解,所以numpy基于的计算最好用numpy自己实现的anyall。 

14.1 any()

本质上讲,any()实现了或(OR)运算,而all()实现了与(AND)运算。

对于any(iterables),如果可迭代对象iterables中任意存在每一个元素True则返回True。特例:若可迭代对象为空,比如空列表[],则返回False

14.2 all

        对于all(iterables),如果可迭代对象iterables中所有元素都为True则返回True。特例:若可迭代对象为空,比如空列表[],则返回True。 

 

 

 

 

 

 

参考:

Python之Numpy库常用函数大全(含注释)https://www.cnblogs.com/TensorSense/p/6795995.html

NumPy基础--常用函数:https://blog.csdn.net/stefanie927/article/details/78066717

https://www.jianshu.com/p/71dc9d2a7772

 

 

 

 

 

10-07 18:40