numpy函数笔记（持续更新）

zoukankan html css js c++ java

numpy函数笔记（持续更新）
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
",Np_No_invert)
# a 中的元素是否在b中，如果设置了invert=True,则情况恰恰相反，即a中元素在b中则返回False
Np_invert=np.isin(a, b, invert=True)
print("Np_invert
",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]
```
保持对优秀的热情
查看全文

相关阅读:
libgdx学习记录21——Box2d物理引擎之碰撞Contact、冲量Impulse、关节Joint
libgdx学习记录20——多线程MultiThread资源处理
 上google的方法
 libgdx学习记录19——图片动态打包PixmapPacker
libgdx学习记录18——Box2d物理引擎
 libgdx学习记录17——照相机Camera
libgdx学习记录16——资源加载器AssetManager
libgdx学习记录15——音乐Music播放
 "_ACFacebookAppIdKey"
IPhone之模型对象归档

原文地址：https://www.cnblogs.com/luckforefforts/p/13663504.html

numpy函数笔记（持续更新）

numpy函数笔记

np.isin用法

numpy.cumsum()

np.around 和np.round四舍五入

np.floor 向下取整

np.ceil 向上取整

NumPy中的diag函数

np.set_printoptions函数

参数解释

官方文档例子

np.vdot点积函数

定义两个矩阵a和b

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

np.nonzero(a)

np.amin(a，axis=k)

np.amax(a, axis=k)