numpy函数笔记

np.isin用法

np.isin(a,b) 用于判定a中的元素在b中是否出现过，如果出现过返回True,否则返回False,最终结果为一个形状和a一模一样的数组。（注意：这里的a和b是像数组类型就行，比如列表的话，传入进去之后，numpy会自动将其转化为numpy数组）
但是当参数invert被设置为True时，情况恰好相反，如果a中元素在b中没有出现则返回True,如果出现了则返回False.

import numpy as np

# 这里使用reshape是为了验证是否对高维数组适用，返回一个和a形状一样的数组

a=np.array([1,3,7]).reshape(3,1)

b=np.arange(9).reshape(3,3)

# a 中的元素是否在b中，如果在b中显示True

Np_No_invert=np.isin(a, b, invert=False)

print("Np_No_invert\n",Np_No_invert)

# a 中的元素是否在b中，如果设置了invert=True,则情况恰恰相反，即a中元素在b中则返回False

Np_invert=np.isin(a, b, invert=True)

print("Np_invert\n",Np_invert)

# Np_No_invert

#  [[ True]

#  [ True]

#  [ True]]

# Np_invert

#  [[False]

#  [False]

#  [False]]

numpy.cumsum()

numpy.cumsum(a, axis=None, dtype=None, out=None)

axis=0，按照行累加。

axis=1，按照列累加。

axis不给定具体值，就把numpy数组当成一个一维数组。

注意这里的行和列和普通认为的不一样，只要认定为是往哪一个轴进行相加。

也就是按照指定维度进行相加

例子如下：

a

Out[6]:

array([[-0.94525613, -0.84632869,  0.65120093],

       [ 0.11813225,  0.22240677, -1.6212242 ],

       [-0.80511744,  1.04439191, -1.45651271]])

np.cumsum(a,1)

Out[8]:

array([[-0.94525613, -1.79158482, -1.14038389],

       [ 0.11813225,  0.34053902, -1.28068518],

       [-0.80511744,  0.23927446, -1.21723825]])

np.around 和np.round四舍五入

这两个函数的功能是一样的，np.round内部调用的就是np.around。

np.around 返回四舍五入后的值，可指定精度。

around(a, decimals=0, out=None)

a 输入数组

decimals 要舍入的小数位数。默认值为0。如果为负，整数将四舍五入到小数点左侧的位置

import numpy as np

n = np.array([-0.746, 4.6, 9.4, 7.447, 10.455, 11.555])

around1 = np.around(n)

print(around1)  # [ -1.   5.   9.   7.  10.  12.]

around2 = np.around(n, decimals=1)

print(around2)  # [ -0.7   4.6   9.4   7.4  10.5  11.6]

around3 = np.around(n, decimals=-1)

print(around3)  # [ -0.   0.  10.  10.  10.  10.]

a=np.random.randn(3,3)

a

Out[6]:

array([[-0.94525613, -0.84632869,  0.65120093],

       [ 0.11813225,  0.22240677, -1.6212242 ],

       [-0.80511744,  1.04439191, -1.45651271]])

np.round(a,2)

Out[7]:

array([[-0.95, -0.85,  0.65],

       [ 0.12,  0.22, -1.62],

       [-0.81,  1.04, -1.46]])

np.floor 向下取整

np.floor 返回不大于输入参数的最大整数。即对于输入值 x ，将返回最大的整数 i ，使得 i <= x。注意在Python中，向下取整总是从 0 舍入。

import numpy as np

n = np.array([-1.7, -2.5, -0.2, 0.6, 1.2, 2.7, 11])

floor = np.floor(n)

print(floor)  # [ -2.  -3.  -1.   0.   1.   2.  11.]

np.ceil 向上取整

np.ceil 函数返回输入值的上限，即对于输入 x ，返回最小的整数 i ，使得 i> = x。

import numpy as np

n = np.array([-1.7, -2.5, -0.2, 0.6, 1.2, 2.7, 11])

ceil = np.ceil(n)

print(ceil)  # [ -1.  -2.  -0.   1.   2.   3.  11.]

NumPy中的diag函数

NumPy包中的内置diag函数很有意思。

假设创建一个1维数组a，和一个3*3数组b：

import numpy as np

a = np.arange(1, 4)

b = np.arange(1, 10).reshape(3, 3)

结果如下：

>>> a

array([1, 2, 3])

>>> b

array([[1, 2, 3],

       [4, 5, 6],

       [7, 8, 9]])

使用diag函数，看一看结果：

>>> np.diag(a)

array([[1, 0, 0],

       [0, 2, 0],

       [0, 0, 3]])

>>> np.diag(b)

array([1, 5, 9])

可以发现，当 np.diag(array) 中

array是一个1维数组时，结果形成一个以一维数组为对角线元素的矩阵

array是一个二维矩阵时，结果输出矩阵的对角线元素

np.set_printoptions函数

设置打印选项。也就是指定如何打印numpy数组，如何显示numpy数组。

这些选项确定浮点数、数组和其他 NumPy 对象的显示方式。

参数解释

precision：int 或无，可选

浮点输出的精度位数（默认 8）。如果浮点模式不是固定的，则可能是"无"，以打印尽可能多的数字以唯一指定值。
threshold：int，可选

触发汇总而不是完全 repr 的数组元素总数（默认 1000）。要始终使用完整重供而不汇总，请传递sys.maxsize。
edgeitems :int，可选

每个维度的开头和末尾汇总中的数组项数（默认值 3）。
linewidth：int，可选

用于插入换行符/行数（默认为 75）。
suppress :布尔，可选

如果为 True，则始终使用固定点表示法打印浮点编号，在这种情况下，当前精度中等于零的数字将打印为零。如果 False，则当最小数字的绝对值为 < 1e-4 或最大绝对值与最小值的比率为 > 1e3 时，则使用科学表示法。默认值为 False。
nanstr： str，可选

浮点非数字（默认 nan）的字符串表示形式。
infstr :str，可选

浮点无穷大的字符串表示形式（默认 inf）。
sign :字符串，"-"，"+"或""，可选

控制浮点类型的符号的打印。如果为"+"，请始终打印正值的符号。如果 ''，则始终在正值的符号位置打印空格（空白字符）。如果为"-"，则省略正值的符号字符。（默认为"-"）
formatter :调用的字典，可选

如果不是"无"，则键应指示相应格式函数应用于的类型。可调用项应返回字符串。未指定的类型（由其相应的键）由默认格式器处理。可设置可处理的单个类型包括：
- "布尔"
- "int"
- "时间德尔塔" ： anumpy.timedelta64
- "日期时间"： anumpy.datetime64
- "浮动"
- "长浮"：128位浮子
- "复杂漂浮"
- "长共体浮"：由两个128位浮子组成
- "数字"：类型和numpy.string_``numpy.unicode_
- "对象"：np.object_数组
- "str" ：所有其他字符串
可用于同时设置一组类型的其他键包括：
- "全部"：设置所有类型
- "int_kind"：设置"int"
- "float_kind"：设置"浮动"和"长浮"
- "complex_kind"：设置"复杂浮"和"长复杂浮"
- "str_kind"：设置"str"和"numpystr"
**floatmode : **str，可选

控制浮点类型的精度选项的解释。可以采取以下值（默认maxprec_equal）：
- "固定"：始终打印精确分数数字，
  
  即使这样打印的数字数会超过唯一指定值所需的数字。
- "唯一"：打印所需的最小小数数字
  
  以唯一方式表示每个值。不同的元素可能具有不同的数字数。精度选项的值将被忽略。
- "maxprec"：以最精确的小数打印，但如果
  
  元素可以唯一表示，数字较少，只能用这么多数字打印它。
- "maxprec_equal"：以最精确的小数打印，
  
  但是，如果数组中的每个元素都可以以相同数量的较少数字的唯一表示，则所有元素都使用该数字。

官方文档例子

可以设置浮点精度：

>>>

>>> np.set_printoptions(precision=4)

>>> np.array([1.123456789])

[1.1235]

可以总结长数组：

>>>

>>> np.set_printoptions(threshold=5)

>>> np.arange(10)

array([0, 1, 2, ..., 7, 8, 9])

小结果可以抑制：

>>>

>>> eps = np.finfo(float).eps

>>> x = np.arange(4.)

>>> x**2 - (x + eps)**2

array([-4.9304e-32, -4.4409e-16,  0.0000e+00,  0.0000e+00])

>>> np.set_printoptions(suppress=True)

>>> x**2 - (x + eps)**2

array([-0., -0.,  0.,  0.])

自定义格式可用于根据需要显示数组元素：

>>>

>>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)})

>>> x = np.arange(3)

>>> x

array([int: 0, int: -1, int: -2])

>>> np.set_printoptions()  # formatter gets reset

>>> x

array([0, 1, 2])

若要放回默认选项，可以使用：

>>>

>>> np.set_printoptions(edgeitems=3, infstr='inf',

... linewidth=75, nanstr='nan', precision=8,

... suppress=False, threshold=1000, formatter=None)

此外，若要临时覆盖选项，请使用打印选项作为上下文管理器：

>>>

>>> with np.printoptions(precision=2, suppress=True, threshold=5):

...     np.linspace(0, 10, 10)

array([ 0.  ,  1.11,  2.22, ...,  7.78,  8.89, 10.  ])

np.vdot点积函数

矩阵点积为两个矩阵对应元素乘积之和

定义两个矩阵a和b

#定义两个矩阵

a=np.array([[4,3],[5,6]])

b=np.array([[10,11],[12,13]])

print("a")

print(a)

print("b")

print(b)

输出结果：

a

[[4 3]

 [5 6]]

b

[[10 11]

 [12 13]]

使用vdot函数计算a和b的点积

#矩阵点积 vdot函数,

#矩阵点积计算公式：两个矩阵对应位置元素乘积之和

c=np.vdot(a,b)

print("c")

print(c)

输出结果：

c

211

np.nonzero(a)

返回：数组a中非零元素的索引值数组

import numpy as np

a = np.random.uniform(-10, 10, 4)

print(a)

    [ 2.69869382 -8.87937198  4.70100555  1.87901029]

b = np.nonzero(a)

print(b)

    (array([0, 1, 2, 3], dtype=int64),)

#a是一维数组，有4个非零元素，返回4个非零元素的序号

a = [[0, 1, 1],

       [1, 0, 1],

       [1, 1, 0]]

print(a)

    [[0, 1, 1], [1, 0, 1], [1, 1, 0]]

b = np.nonzero(a)

print(b)

    (array([0, 0, 1, 1, 2, 2], dtype=int64), array([1, 2, 0, 2, 0, 1], dtype=int64))

    #a是二维数组，array长度为6，即a有6个非零元素，第一个array是对非零元素的row描述，

    #第二个array是对col的描述。索引元组b一直都是二维数组

print(np.transpose(b))

    [[0 1]

     [0 2]

     [1 0]

     [1 2]

     [2 0]

     [2 1]]

    #调用transpose转置索引序号b元组，非零元素的序号[0，1]，即第0行，第一列，以此类推。

np.amin(a，axis=k)

返回：一维数组a中的最小值，二维数组需通过axis指定行或列，获取行或列的最小值，如不指定，则是所有元素的最小值

import numpy as np

a = [[0, 1, 2],

     [1, 0, 3],

     [1, 4, 0]]

a1 = np.asarray(a, dtype = np.float32)

print(a1[np.nonzero(a1)])

    [ 1.  2.  1.  3.  1.  4.]

    #使用a[np.nonzero(a)]获取a中所有非零值，变一维数组，但需要将a转换成array

print(np.amin(a1[np.nonzero(a1)]))

    1.0

    #获取数组的最小值

#把a1中等于0的值换成a1数组中的最小值

a1[a1==0] = np.amin(a1[np.nonzero(a1)])

print('a1 = ', a1)

    a1 =  [[ 1.  1.  2.]

           [ 1.  1.  3.]

           [ 1.  4.  1.]]

np.amax(a, axis=k)

返回：一维数组a中的最大值，二维数组需通过axis指定行或列，获取行或列的最大值，如不指定，则是所有元素的最大值

import numpy as np

a = [[1,4,7],

     [2,5,8],

     [3,6,9]]

b = np.amax(a, axis=0)

print(b)

b = [3,6,9]

秒客网

numpy函数笔记（持续更新）