数量#

class astropy.units.quantity.Quantity(value, unit=None, dtype=<class 'numpy.inexact'>, copy=True, order=None, subok=False, ndmin=0)[源代码]#

基类：ndarray

A Quantity 表示具有某个关联单位的数字。

另请参见：https://docs.astropy.org/en/stable/units/quantity.html

参数:

valueNumbers、ndarray、Quantity(python：Sequence)或python：str: 这个量的数值，用单位表示。如果 Quantity 或它们的序列（或任何其他具有 unit 属性），创建一个新的 Quantity 对象，转换为 unit 单位按需要。如果是字符串，则将其转换为数字或 Quantity ，取决于是否有一个单元。
unit : astropy:unit-like占星体：单位状: 表示与输入值相关联的单位的对象。一定是 UnitBase 对象或可由 units 包裹。
dtype : dtype ，可选可选类型: 将保存值的结果Numpy数组或标量的数据类型。如果未提供，则根据输入确定，除非默认情况下将任何整数和(非数量)对象输入转换为浮点数。如果 None ，正常的 numpy.dtype 使用自省，例如防止对整数进行向上转换。
copy : bool ，可选可选的布尔: 如果 True (default), then the value is copied. Otherwise, a copy will only be made if _ _如果值是嵌套序列，或者需要副本来满足显式给定的 ``dtype . （在 False 选项主要用于内部使用，以便在已知已生成副本的情况下加快初始化。小心使用。）
order'C'、'F'、'A'，可选: 指定数组的顺序。如 array . 如果输入是 Quantity 和 copy=False .
subok : bool ，可选可选的布尔: 如果 False （默认），返回的数组将被强制为 Quantity . 否则， Quantity 子类将被传递，或者将使用适合于单元的子类（例如 Dex 对于 u.dex(u.AA) ）
ndmin : int ，可选PYTHON：int，可选: 指定结果数组应具有的最小维数。一个将根据需要添加到满足此要求的形状中。如果输入是 Quantity 和 copy=False 。

加薪:

TypeError: 如果提供的值不是Python数字类型。
TypeError: 如果提供的单位不是 Unit 对象或可解析字符串单元。

笔记

也可以通过将数字或数组与 Unit . 看到了吗https://docs.astropy.org/en/latest/units/

除非 dtype 参数，则整数或(非数量)对象输入将转换为 float 默认情况下。

属性摘要

`cgs`	返回当前 `Quantity` 具有CGS单元的实例。
`equivalencies`	单位转换期间默认应用的等效项列表。
`flat`	数量数组上的一维迭代器。
`info`	用于存储诸如名称、描述、格式等元信息的容器。
`isscalar`	如果 `value` 这个量的值是标量，如果是类似数组的对象，则为False。
`si`	返回当前 `Quantity` 使用国际单位制的实例。
`unit`	A `UnitBase` 表示此量的单位的对象。
`value`	此实例的数值。

方法总结

`all`([axis, out, keepdims, where])	如果所有元素的计算结果都为true，则返回true。
`any`([axis, out, keepdims, where])	如果的任何元素 `a` 计算为真。
`argmax`([axis, out, keepdims])	返回给定轴上最大值的索引。
`argmin`([axis, out, keepdims])	返回沿给定轴的最小值的索引。
`argsort`([axis, kind, order])	返回将对此数组进行排序的索引。
`choose`(choices[, out, mode])	使用索引数组从一组选项中构造新数组。
`decompose`([bases])	生成新的 `Quantity` 单位分解了。
`diff`([n, axis])
`dot`(b[, out])
`dump` \(文件)	未实现，请使用 `.value.dump()` 取而代之的是。
`dumps` \()	未实现，请使用 `.value.dumps()` 取而代之的是。
`ediff1d`([to_end, to_begin])
`fill` \(值)	用标量值填充数组。
`insert`(obj, values[, axis])	在给定索引之前沿给定轴插入值，并返回一个新的 `Quantity` 对象。
`item`(*args)	将数组的元素复制到标量并返回。
`itemset`(*args)	将标量插入数组（如果可能，将标量转换为数组的dtype）
`mean`([axis, dtype, out, keepdims, where])	返回沿给定轴的数组元素的平均值。
`nansum`([axis, out, keepdims, initial, where])	自 5.3 版本弃用.
`put`(indices, values[, mode])	集合 `a.flat[n] = values[n]` 为了所有 `n` 在索引中。
`round`([decimals, out])	返回 `a` 每个元素四舍五入到给定的小数位数。
`searchsorted`(v[, side, sorter])	查找应在a中插入v元素以保持顺序的索引。
`std`([axis, dtype, out, ddof, keepdims, where])	返回数组元素沿给定轴的标准偏差。
`take`(indices[, axis, out, mode])	返回由以下元素组成的数组 `a` 在给定的指数上。
`to`(unit[, equivalencies, copy])	返回一个新的 `Quantity` 具有指定单位的对象。
`to_string`([unit, precision, format, subfmt])	生成数量及其单位的字符串表示形式。
`to_value`([unit, equivalencies])	数值，可能以不同的单位表示。
`tobytes`([order])	未实现，请使用 `.value.tobytes()` 取而代之的是。
`tofile`(fid[, sep, format])	未实现，请使用 `.value.tofile()` 取而代之的是。
`tolist` \()	作为数组返回 `a.ndim` -Python标量的深度嵌套列表。
`tostring`([order])	未实现，请使用 `.value.tostring()` 取而代之的是。
`trace`([offset, axis1, axis2, dtype, out])	沿数组的对角线返回和。
`var`([axis, dtype, out, ddof, keepdims, where])	返回数组元素沿给定轴的方差。

属性文档

cgs#: 返回当前 Quantity 具有CGS单元的实例。结果对象的值将被缩放。

equivalencies#: 单位转换期间默认应用的等效项列表。

flat#

数量数组上的一维迭代器。

返回一个 QuantityIterator 实例，其行为与 flatiter 实例返回者 flat ，与Python的内置迭代器对象类似，但不是其子类。

info#: 用于存储诸如名称、描述、格式等元信息的容器。当对象用作表中的mixin列时，这是必需的，但也可以作为存储元信息的通用方法。

isscalar#: 如果 value 这个量的值是标量，如果是类似数组的对象，则为False。

备注

这与 numpy.isscalar 在那里面 numpy.isscalar 对于零维数组返回False（例如。 np.array(1) )，而这对于数量是正确的，因为数量不能代表真正的numpy标量。

si#: 返回当前 Quantity 使用国际单位制的实例。结果对象的值将被缩放。

unit#: A UnitBase 表示此量的单位的对象。

value#

此实例的数值。

参见

to_value: 取给定单位的数值。

方法文件

all(axis=None, out=None, keepdims=False, *, where=True)[源代码]#

如果所有元素的计算结果都为true，则返回true。

参照 numpy.all 完整文件。

参见

numpy.all: 等效函数

any(axis=None, out=None, keepdims=False, *, where=True)[源代码]#

如果的任何元素 a 计算为真。

参照 numpy.any 完整文件。

参见

numpy.any: 等效函数

argmax(axis=None, out=None, *, keepdims=False)[源代码]#

返回给定轴上最大值的索引。

参照 numpy.argmax 完整文件。

参见

numpy.argmax: 等效函数

argmin(axis=None, out=None, *, keepdims=False)[源代码]#

返回沿给定轴的最小值的索引。

参照 numpy.argmin 有关详细文档。

参见

numpy.argmin: 等效函数

argsort(axis=-1, kind=None, order=None)[源代码]#

返回将对此数组进行排序的索引。

参照 numpy.argsort 完整文件。

参见

numpy.argsort: 等效函数

choose(choices, out=None, mode='raise')[源代码]#

使用索引数组从一组选项中构造新数组。

参照 numpy.choose 完整文件。

参见

numpy.choose: 等效函数

decompose(bases=[])[源代码]#

生成新的 Quantity 单位分解了。分解单元中只有不可约的单元（请参见 astropy.units.UnitBase.decompose ）

参数:

bases : sequence 的 UnitBase ，可选Python：UnitBase的序列，可选: 分解成的基。如果没有提供，分解成任何不可还原的单位。当提供时，分解结果将只包含给定的单元。这将引发一个 UnitsError 如果不可能的话。

返回:

newq ： Quantity数量: 一个新的物体，与这个量相等，单位被分解。

diff(n=1, axis=-1)[源代码]#

dot(b, out=None)[源代码]#

dump(file)[源代码]#: 未实现，请使用 .value.dump() 取而代之的是。

dumps()[源代码]#: 未实现，请使用 .value.dumps() 取而代之的是。

ediff1d(to_end=None, to_begin=None)[源代码]#

fill(value)[源代码]#

用标量值填充数组。

参数:

value : scalar标量: 所有元素 a 将分配此值。

实例

>>> a = np.array([1, 2])
>>> a.fill(0)
>>> a
array([0, 0])
>>> a = np.empty(2)
>>> a.fill(1)
>>> a
array([1.,  1.])

Fill需要标量值，并且始终与为单个数组元素赋值的行为相同。下面是一个罕见的例子，说明了这种区别的重要性：

>>> a = np.array([None, None], dtype=object)
>>> a[0] = np.array(3)
>>> a
array([array(3), None], dtype=object)
>>> a.fill(np.array(3))
>>> a
array([array(3), array(3)], dtype=object)

其中，其他形式的赋值将解包被赋值的数组：

>>> a[...] = np.array(3)
>>> a
array([3, 3], dtype=object)

insert(obj, values, axis=None)[源代码]#

在给定索引之前沿给定轴插入值，并返回一个新的 Quantity 对象。

这是一个薄薄的包裹 numpy.insert 功能。

参数:

obj : int ， slice 或 sequence 的 intPYTHON：INT、SLICE或PYTHON：PYSTORY OF PYSTORY：INT: 定义一个或多个索引的对象， values 插入。
values : array_likeNumpy：ARRAY_LIKE: 要插入的值。如果 values 与数量不同， values 转换为匹配类型。 values 其形状应使其能够适当地广播 values 必须与此数量一致。
axis : int ，可选PYTHON：int，可选: 插入轴 values . 如果 axis 如果为“无”，则在插入之前将数量数组展平。

返回:

out ： Quantity数量: 数量副本 values 插入。请注意，插入操作没有进行到位：将返回一个新的quantity数组。

实例

>>> import astropy.units as u
>>> q = [1, 2] * u.m
>>> q.insert(0, 50 * u.cm)
<Quantity [ 0.5,  1.,  2.] m>

>>> q = [[1, 2], [3, 4]] * u.m
>>> q.insert(1, [10, 20] * u.m, axis=0)
<Quantity [[  1.,  2.],
           [ 10., 20.],
           [  3.,  4.]] m>

>>> q.insert(1, 10 * u.m, axis=1)
<Quantity [[  1., 10.,  2.],
           [  3., 10.,  4.]] m>

item(*args)[源代码]#

将数组的元素复制到标量并返回。

喜欢 item() 除了它总是返回一个 Quantity ，而不是Python标量。

itemset(*args)[源代码]#

将标量插入数组（如果可能，将标量转换为数组的dtype）

必须至少有一个参数，并将最后一个参数定义为 item . 然后， a.itemset(*args) 等于但比 a[args] = item . 该项应为标量值，并且 args 必须选择数组中的单个项 a .

参数:

*args争论: 如果有一个参数：标量，只在case中使用 a 尺寸是1号。如果两个参数：最后一个参数是要设置的值并且必须是标量，则第一个参数指定单个数组元素位置。它不是int就是tuple。

笔记

与索引语法相比， itemset 为将标量放入 ndarray ，如果必须这样做。然而，一般来说，这是不鼓励的：除了其他问题，它使代码的外观复杂化。此外，使用时 itemset （和 item ）在循环内部，请确保将方法分配给局部变量，以避免在每个循环迭代中查找属性。

实例

>>> np.random.seed(123)
>>> x = np.random.randint(9, size=(3, 3))
>>> x
array([[2, 2, 6],
       [1, 3, 6],
       [1, 0, 1]])
>>> x.itemset(4, 0)
>>> x.itemset((2, 2), 9)
>>> x
array([[2, 2, 6],
       [1, 0, 6],
       [1, 0, 9]])

mean(axis=None, dtype=None, out=None, keepdims=False, *, where=True)[源代码]#

返回沿给定轴的数组元素的平均值。

参照 numpy.mean 完整文件。

参见

numpy.mean: 等效函数

nansum(axis=None, out=None, keepdims=False, *, initial=None, where=True)[源代码]#: 自 5.3 版本弃用: Nansum方法已弃用，可能会在未来的版本中删除。请改用np.nansum。

put(indices, values, mode='raise')[源代码]#

集合 a.flat[n] = values[n] 为了所有 n 在索引中。

参照 numpy.put 完整文件。

参见

numpy.put: 等效函数

round(decimals=0, out=None)[源代码]#

返回 a 每个元素四舍五入到给定的小数位数。

参照 numpy.around 完整文件。

参见

numpy.around: 等效函数

searchsorted(v, side='left', sorter=None)[源代码]#

查找应在a中插入v元素以保持顺序的索引。

有关完整文档，请参见 numpy.searchsorted

参见

numpy.searchsorted: 等效函数

std(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True)[源代码]#

返回数组元素沿给定轴的标准偏差。

参照 numpy.std 完整文件。

参见

numpy.std: 等效函数

take(indices, axis=None, out=None, mode='raise')[源代码]#

返回由以下元素组成的数组 a 在给定的指数上。

参照 numpy.take 完整文件。

参见

numpy.take: 等效函数

to(unit, equivalencies=[], copy=True)[源代码]#

返回一个新的 Quantity 具有指定单位的对象。

参数:

unit : astropy:unit-like占星体：单位状: 表示要转换为的单位的对象。一定是 UnitBase 对象或可由 units 包裹。
equivalencies : list 的 tuplePYTHON：PYTHON列表：元组: 如果单位不能直接转换，可尝试的等价对列表。看见等价物。如果未提供或 [] ，将使用类的默认等效项(对于 Quantity ，但可以为子类设置)，如果 None ，则根本不会应用等价物，甚至不会全局或在上下文中应用任何集合。
copy : bool ，可选可选的布尔: 如果 True （默认），然后复制该值。否则，只有在必要时才会制作副本。

参见

to_value: 取给定单位的数值。

to_string(unit=None, precision=None, format=None, subfmt=None)[源代码]#

生成数量及其单位的字符串表示形式。

此函数的行为可以通过 numpy.set_printoptions 函数及其各种关键字。唯一的例外是 threshold 关键字，通过 [units.quantity] 配置项 latex_array_threshold . 这是分开处理的，因为numpy默认值1000对于大多数浏览器来说太大了。

参数:

unit : astropy:unit-like ，可选AstPy：单元式，可选

指定单位。如果未提供，将使用用于初始化数量的单位。

precision : number ，可选数字，可选

十进制精度的级别。如果 None ，或未提供，则将根据NumPy打印选项确定。

format : str ，可选Python：字符串，可选

结果的格式。如果未提供，则返回未修饰的字符串。支持的值包括：

“latex”：返回latex格式的字符串
‘LaTeX_Inline’：返回使用负指数而不是分数的LaTeX格式的字符串

subfmt : str ，可选Python：字符串，可选

结果的子格式。目前，仅用于 format='latex' 和 format='latex_inline' 。支持的值包括：

“inline”：使用 $ ... $ 作为分隔符。
“显示”：使用 $\displaystyle ... $ 作为分隔符。

返回:

str: 包含此数量内容的字符串

to_value(unit=None, equivalencies=[])[源代码]#

数值，可能以不同的单位表示。

参数:

unit : astropy:unit-like ，可选AstPy：单元式，可选: 给出数值的单位。如果不给予或 None ，使用当前单位。
equivalencies : list 的 tuple ，可选PYTHON：PYTHON列表：元组，可选: 单位不可直接转换时要尝试的等价对列表(请参见等价物 )。如果未提供或 [] ，将使用类的默认等效项(对于 Quantity ，但可以为子类设置)。如果 None ，则根本不会应用等价物，甚至不会全局或在上下文中应用任何集合。

返回:

value : ndarray 或 scalarndarray或scalar: 以指定单位表示的值。对于数组，如果不需要单位转换，这将是一个数据视图。

参见

to: 在不同的单元中获取新实例。

tobytes(order='C')[源代码]#: 未实现，请使用 .value.tobytes() 取而代之的是。

tofile(fid, sep='', format='%s')[源代码]#: 未实现，请使用 .value.tofile() 取而代之的是。

tolist()[源代码]#

作为数组返回 a.ndim -Python标量的深度嵌套列表。

以（嵌套的）Python列表的形式返回数组数据的副本。数据项通过 item 功能。

如果 a.ndim 如果是0，那么由于嵌套列表的深度是0，那么它根本就不是一个列表，而是一个简单的Python标量。

参数:

none

返回:

y : object ，或 list 的 object ，或 list 的 list 的 object 或者..。OBJECT，或PYTHON：LIST OF OF OBJECT，或PYTHON：LIST OF PYTHON：LIST OF OF OBJECT，或...: 数组元素的可能嵌套列表。

笔记

数组可以通过 a = np.array(a.tolist()) ，尽管有时可能会失去精度。

实例

对于一维阵列， a.tolist() 几乎和 list(a) 除了 tolist 将numpy标量更改为Python标量：

>>> a = np.uint32([1, 2])
>>> a_list = list(a)
>>> a_list
[1, 2]
>>> type(a_list[0])
<class 'numpy.uint32'>
>>> a_tolist = a.tolist()
>>> a_tolist
[1, 2]
>>> type(a_tolist[0])
<class 'int'>

另外，对于二维阵列， tolist 递归应用：

>>> a = np.array([[1, 2], [3, 4]])
>>> list(a)
[array([1, 2]), array([3, 4])]
>>> a.tolist()
[[1, 2], [3, 4]]

此递归的基本情况是0D数组：

>>> a = np.array(1)
>>> list(a)
Traceback (most recent call last):
  ...
TypeError: iteration over a 0-d array
>>> a.tolist()
1

tostring(order='C')[源代码]#: 未实现，请使用 .value.tostring() 取而代之的是。

trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)[源代码]#

沿数组的对角线返回和。

参照 numpy.trace 完整文件。

参见

numpy.trace: 等效函数

var(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True)[源代码]#

返回数组元素沿给定轴的方差。

参照 numpy.var 完整文件。

参见

numpy.var: 等效函数