BinnedTimeSeries#

class astropy.timeseries.BinnedTimeSeries(data=None, *, time_bin_start=None, time_bin_end=None, time_bin_size=None, n_bins=None, **kwargs)[源代码]#

基类：BaseTimeSeries

以表格形式表示二进制时间序列数据的类。

BinnedTimeSeries 提供一个类，用于将时间序列表示为以时间单位度量的不同数量的值的集合（有关在特定时间采样的值的时间序列，请参见 TimeSeries 班级）。 BinnedTimeSeries 是 QTable 因此，它提供了所有表可用的标准表管理方法，但也为处理时间序列提供了额外的便利，例如灵活的初始值设定项用于设置时间，以及访问存储箱的开始/中心/结束时间的属性。

另请参见：https://docs.astropy.org/en/stable/timeseries/

参数:

data : numpy ndarray ， dict ， list ， astropy:table-like object ，可选Numpy ndarray，python：dict，python：List，Astery：类桌子对象，可选: 初始化时间序列的数据。这不需要包含可以单独提供的时间，但是如果它包含时间，则它们应该在调用的列中 'time_bin_start' 和 'time_bin_size' 自动识别。
time_bin_start : Time or iterable时间或 Python ：可迭代: 每个垃圾箱开始的时间-可以直接作为 Time 数组或作为初始化 Time 班级。如果给出了这个值，则不应使用剩余的与时间相关的参数。这也可以是标量值，如果 time_bin_size 提供。
time_bin_end : Time or iterable时间或 Python ：可迭代: 每个箱子结束的时间-可以直接作为 Time 数组或作为初始化 Time 班级。如果给出了这个值，则不应使用剩余的与时间相关的参数。只有在 time_bin_start 是一个值数组。如果 time_bin_end 是一个标量，假定时间点是连续的，因此每个点的结束是下一个的开始，并且 time_bin_end 给出最后一个箱子的结束时间。如果 time_bin_end 是一个数组，时间容器不需要是连续的。如果提供了这个论点， time_bin_size 不应提供。
time_bin_size ： TimeDelta 或 Quantity时间增量或数量: 时间单元的大小，可以是标量值（在这种情况下，所有时间单元都将被假定具有相同的持续时间）或值数组（在这种情况下，每个时间段可以具有不同的持续时间）。如果提供了这个论点， time_bin_end 不应提供。
n_bins : intPython ：整型: 序列的时间段数。仅在两者都使用 time_bin_start 和 time_bin_size 提供，并且是标量值。
**kwargs : dict ，可选Python：Dict，可选: 其他关键字参数传递给 QTable .

属性摘要

`ColumnClass`
`colnames`
`dtype`
`groups`
`has_masked_columns`	如果表中有 `MaskedColumn` 柱。
`has_masked_values`	如果表中的列包含被屏蔽的值，则为True。
`has_mixin_columns`	如果表有任何mixin列（定义为不是列子类的列），则为True。
`iloc`	返回一个TableILoc对象，该对象可用于按索引中出现的顺序检索索引行。
`indices`	以TableIndexes对象的形式返回与表的列关联的索引。
`info`
`loc`	返回可用于按索引检索给定数据区域中的行的TableLoc对象。
`loc_indices`	返回一个TableLocIndexes对象，该对象可用于检索与给定表索引键值相对应的行索引。
`mask`
`masked`
`meta`
`pprint_exclude_names`	维护控制打印输出表列可见性的元组。
`pprint_include_names`	维护控制打印输出表列可见性的元组。
`time_bin_center`	所有时间箱子的中心时间。
`time_bin_end`	所有时间容器的结束时间。
`time_bin_size`	所有时间箱子的大小。
`time_bin_start`	所有时间容器的开始时间。
`write`	以指定的格式写出此表对象。

方法总结

`add_column`(col[, index, name, ...])	使用将新列添加到表中 `col` 作为输入。
`add_columns`(cols[, indexes, names, copy, ...])	使用添加表的新列列表 `cols` 数据对象。
`add_index`(colnames[, engine, unique])	在一列或多列之间插入新索引。
`add_row`([vals, mask])	在表的末尾添加新行。
`argsort`([keys, kind, reverse])	返回将根据一个或多个键列对表进行排序的索引。
`as_array`([keep_byteorder, names])	以结构化的形式返回表的新副本np.ndarray公司或者马斯克达雷硕士对象（视情况而定）。
`convert_bytestring_to_unicode` \()	按测试环列转换(数据类型.种类='S'）到unicode(数据类型.种类=“U”）使用UTF-8编码。
`convert_unicode_to_bytestring` \()	转换unicode列(数据类型.种类=“U”）到bytestring(数据类型.种类='S'）使用UTF-8编码。
`copy`([copy_data])	返回表的副本。
`field` \(项目)	返回列 [item] 重新排列兼容性。
`filled`([fill_value])	返回self的副本，并填充掩码值。
`from_pandas`(dataframe[, index, units])	创建 `Table` 从一个 `pandas.DataFrame` 举个例子。
`group_by` \(密钥)	将此表按指定的 `keys` 。
`index_column` \(名称)	返回列的位置索引 `name` .
`index_mode` \(模式)	返回索引模式的上下文管理器。
`insert_row`(index[, vals, mask])	在给定行之前添加新行 `index` 在桌子上的位置。
`items` \()
`itercols` \()	迭代此表的列。
`iterrows`(*names)	迭代表的行，为每行返回一个值的元组。
`keep_columns` \(姓名)	只保留指定的列（删除其他列）。
`keys` \()
`more`([max_lines, max_width, show_name, ...])	使用分页界面交互浏览表。
`pformat`([max_lines, max_width, show_name, ...])	返回的格式化字符串表示形式的行列表
`pformat_all`([max_lines, max_width, ...])	返回的格式化字符串表示形式的行列表
`pprint`([max_lines, max_width, show_name, ...])	打印表的格式化字符串表示形式。
`pprint_all`([max_lines, max_width, ...])	打印整个表的格式化字符串表示形式。
`read`(filename[, time_bin_start_column, ...])	读取并解析文件并返回 `astropy.timeseries.BinnedTimeSeries` .
`remove_column` \(名称)	从表中删除列。
`remove_columns` \(姓名)	从表中删除几列。
`remove_indices` \(列名称)	删除所有涉及给定列的索引。
`remove_row` \(索引)	从表中删除行。
`remove_rows`(row_specifier)	从表中删除行。
`rename_column`(name, new_name)	重命名列。
`rename_columns`(names, new_names)	重命名多个列。
`replace_column`(name, col[, copy])	替换列 `name` 和新的 `col` 对象。
`reverse` \()	反转表行的行顺序。
`round`([decimals])	将数字列舍入到指定的小数位数。
`show_in_browser`([max_lines, jsviewer, ...])	以HTML呈现表格并在web浏览器中显示。
`show_in_notebook`([tableid, css, ...])	以HTML格式呈现表格，并将其显示在IPython笔记本中。
`sort`([keys, kind, reverse])	根据一个或多个键对表进行排序。
`to_pandas`([index, use_nullable_int])	返回一个 `pandas.DataFrame` 举个例子。
`update`(other[, copy])	执行字典样式的更新和合并元数据。
`values` \()
`values_equal` (其他)	表与另一个表、列表或标量的元素级比较。

属性文档

ColumnClass#

colnames#

dtype#

groups#

has_masked_columns#

如果表中有 MaskedColumn 柱。

这不会检查可能有掩码值的mixin列，请使用 has_masked_values 在这种情况下。

has_masked_values#

如果表中的列包含被屏蔽的值，则为True。

对于大型表，这可能相对较慢，因为它需要检查每个列的掩码值。

has_mixin_columns#: 如果表有任何mixin列（定义为不是列子类的列），则为True。

iloc#: 返回一个TableILoc对象，该对象可用于按索引中出现的顺序检索索引行。

indices#: 以TableIndexes对象的形式返回与表的列关联的索引。

info#

loc#: 返回可用于按索引检索给定数据区域中的行的TableLoc对象。请注意，loc和iloc都只适用于单列索引。

loc_indices#: 返回一个TableLocIndexes对象，该对象可用于检索与给定表索引键值相对应的行索引。

mask#

masked#

meta = None#

pprint_exclude_names#

维护控制打印输出表列可见性的元组。

这是从MetaAttribute继承的描述符，因此属性值存储在表META中 ['__attributes__'] 。

这将用于 pprint_include_names 和 pprint_exclude_names 表属性。

pprint_include_names#

维护控制打印输出表列可见性的元组。

这是从MetaAttribute继承的描述符，因此属性值存储在表META中 ['__attributes__'] 。

这将用于 pprint_include_names 和 pprint_exclude_names 表属性。

time_bin_center#: 所有时间箱子的中心时间。

time_bin_end#: 所有时间容器的结束时间。

time_bin_size#: 所有时间箱子的大小。

time_bin_start#: 所有时间容器的开始时间。

write#

以指定的格式写出此表对象。

此函数提供到AstPy统一I/O层的表接口。这允许使用语法以许多受支持的数据格式轻松写入文件，例如：

>>> from astropy.table import Table
>>> dat = Table([[1, 2], [3, 4]], names=('a', 'b'))
>>> dat.write('table.dat', format='ascii')

获取有关可用的编写器的帮助 Table 使用``Help()``方法：：

>>> Table.write.help()  # Get help writing Table and list supported formats
>>> Table.write.help('fits')  # Get detailed help on Table FITS writer
>>> Table.write.list_formats()  # Print list of available formats

这个 serialize_method 有关参数的说明，请参阅 Table serialization methods 。

另请参阅：https://docs.astropy.org/en/stable/io/unified.html

参数:

*args : tuple ，可选Python：元组，可选: 位置参数传递给数据编写器。如果提供，第一个参数是输出文件名。
format : strPython ：字符串: 文件格式说明符。
serialize_method : str ， dict ，可选PYTHON：字符串，PYTHON：DICT，可选: 列的序列化方法说明符。
**kwargs : dict ，可选Python：Dict，可选: 传递给数据编写器的关键字参数。

方法文件

add_column(col, index=None, name=None, rename_duplicate=False, copy=True, default_name=None)#

使用将新列添加到表中 col 作为输入。如果 index 提供，然后在前面插入列 index 否则追加到列的末尾。

这个 col 输入可以是作为 Table 列对象或可以转换。这包括mixin列和scalar或length=1对象，它们被广播以匹配表长度。

要同时添加多个列，请使用 add_columns() 或者干脆打个电话 add_column() 为每一个。这两种方法的性能差别很小。

参数:

col : object对象: 新列的数据对象
index : int 或 NonePYTHON：INT或PYTHON：NONE: 在此位置之前或结尾处插入列（默认）。
name : strPython ：字符串: 列名
rename_duplicate : bool布尔: 如果列名已存在，请取消验证。默认值为False。
copy : bool布尔: 复制新列。默认值为True。
default_name : str 或 NonePYTHON：字符串或PYTHON：无: 如果两者都使用的名称 name 和 col.info.name 不可用。默认为 col{{number_of_columns}} .

实例

创建一个包含两列“a”和“b”的表，然后创建第三列“c”并将其附加到表的末尾：

>>> t = Table([[1, 2], [0.1, 0.2]], names=('a', 'b'))
>>> col_c = Column(name='c', data=['x', 'y'])
>>> t.add_column(col_c)
>>> print(t)
 a   b   c
--- --- ---
  1 0.1   x
  2 0.2   y

在位置1添加列“d”。请注意，列插入到给定索引之前：

>>> t.add_column(['a', 'b'], name='d', index=1)
>>> print(t)
 a   d   b   c
--- --- --- ---
  1   a 0.1   x
  2   b 0.2   y

添加名为“b”的第二列，重命名为“重复”：

>>> t = Table([[1, 2], [0.1, 0.2]], names=('a', 'b'))
>>> t.add_column(1.1, name='b', rename_duplicate=True)
>>> print(t)
 a   b  b_1
--- --- ---
  1 0.1 1.1
  2 0.2 1.1

通过在表中指定未命名的对象或在默认情况下在表中指定未命名的对象或列 name . 名称也可以被重写：

>>> t = Table([[1, 2], [0.1, 0.2]], names=('a', 'b'))
>>> t.add_column(['a', 'b'])
>>> t.add_column(col_c, name='d')
>>> print(t)
 a   b  col2  d
--- --- ---- ---
  1 0.1    a   x
  2 0.2    b   y

add_columns(cols, indexes=None, names=None, copy=True, rename_duplicate=False)#

使用添加表的新列列表 cols 数据对象。如果对应的列表 indexes 提供，然后在每个 index 位置 起初的 列的列表，否则将列追加到列表的末尾。

这个 cols 输入可以包括任何可接受的数据对象 Table 列对象或可以转换。这包括mixin列和scalar或length=1对象，它们被广播以匹配表长度。

从性能的角度来看，调用此方法一次或在新列上循环并调用 add_column() 对于每个列。

参数:

cols : list 的 objectPython：对象列表: 新列的数据对象列表
indexes : list 的 int 或 NonePYTHON：PYTHON列表：INT或PYTHON：NONE: 在此位置之前或结尾处插入列（默认）。
names : list 的 strPYTHON：PYTHON列表：字符串: 列名
copy : bool布尔: 复制新列。默认值为True。
rename_duplicate : bool布尔: 如果新列名与现有列名重复，则取消验证。默认值为False。

参见

astropy.table.hstack, update, replace_column

实例

创建一个包含两列“a”和“b”的表，然后创建列“c”和“d”，并将它们附加到表的末尾：

>>> t = Table([[1, 2], [0.1, 0.2]], names=('a', 'b'))
>>> col_c = Column(name='c', data=['x', 'y'])
>>> col_d = Column(name='d', data=['u', 'v'])
>>> t.add_columns([col_c, col_d])
>>> print(t)
 a   b   c   d
--- --- --- ---
  1 0.1   x   u
  2 0.2   y   v

在位置0添加列“c”，在位置1添加列“d”。请注意，列插入到给定位置之前：

>>> t = Table([[1, 2], [0.1, 0.2]], names=('a', 'b'))
>>> t.add_columns([['x', 'y'], ['u', 'v']], names=['c', 'd'],
...               indexes=[0, 1])
>>> print(t)
 c   a   d   b
--- --- --- ---
  x   1   u 0.1
  y   2   v 0.2

添加第二列“b”和“c”列 rename_duplicate ：：

>>> t = Table([[1, 2], [0.1, 0.2]], names=('a', 'b'))
>>> t.add_columns([[1.1, 1.2], ['x', 'y']], names=('b', 'c'),
...               rename_duplicate=True)
>>> print(t)
 a   b  b_1  c
--- --- --- ---
  1 0.1 1.1  x
  2 0.2 1.2  y

使用默认名称或通过使用 names . 也可以重写名称：

>>> t = Table()
>>> col_b = Column(name='b', data=['u', 'v'])
>>> t.add_columns([[1, 2], col_b])
>>> t.add_columns([[3, 4], col_b], names=['c', 'd'])
>>> print(t)
col0  b   c   d
---- --- --- ---
   1   u   3   u
   2   v   4   v

add_index(colnames, engine=None, unique=False)#

在一列或多列之间插入新索引。如果没有索引，请将此索引作为主表索引。

参数:

colnames : str 或 listPYTHON：字符串或PYTHON：LIST: 要索引的列名（或单个列名）的列表
engine : type or None键入或: 要使用的索引引擎类，或者 SortedArray ， BST ，或 SCEngine 。如果提供的参数为None(缺省情况下)，请使用 SortedArray 。
unique : bool布尔: 索引的值是否必须唯一。默认值为False。

add_row(vals=None, mask=None)#

在表的末尾添加新行。

这个 vals 参数可以是：

序列（如元组或列表）: 列值的顺序与表列的顺序相同。
映射（例如dict）: 与列名对应的键。缺少的值将用np.零列数据类型。
None: 所有值填充np.零列数据类型。

此方法要求表对象“拥有”底层数组数据。特别是不能将行添加到已从现有数组中用copy=False初始化的表中。

这个 mask 属性应提供值的掩码（如果需要）。掩码的类型应与值的类型匹配，即如果 vals 是一个iterable，那么 mask 如果长度相同 vals 是一个映射，那么 mask 应该是字典。

参数:

vals : tuple ， list ， dict 或 NonePYTHON：元组、PYTHON：LIST、PYTHON：DICT或PYTHON：无: 在新行中使用指定的值
mask : tuple ， list ， dict 或 NonePYTHON：元组、PYTHON：LIST、PYTHON：DICT或PYTHON：无: 在新行中使用指定的掩码值

实例

创建一个包含三列“a”、“b”和“c”的表：

>>> t = Table([[1,2],[4,5],[7,8]], names=('a','b','c'))
>>> print(t)
 a   b   c
--- --- ---
  1   4   7
  2   5   8

正在添加一个新行，其中“a”中的条目为“3”，“b”中的条目为6，“c”中的条目为“9”：

>>> t.add_row([3,6,9])
>>> print(t)
  a   b   c
  --- --- ---
  1   4   7
  2   5   8
  3   6   9

argsort(keys=None, kind=None, reverse=False)#

返回将根据一个或多个键列对表进行排序的索引。这简单地称为 numpy.argsort 函数与 order 参数设置为 keys .

参数:

keys : str 或 list 的 strPYTHON：STR或PYTHON：PYTHON列表：STR: 表排序依据的列名
kind{‘快速排序’，‘合并排序’，‘堆排序’，‘稳定’}，可选: 使用的排序算法 numpy.argsort 。
reverse : bool布尔: 按相反顺序排序（默认值=False）

返回:

index_array : ndarray ， intNdarray， Python ：int: 按指定键列对表排序的索引数组。

as_array(keep_byteorder=False, names=None)#

以结构化的形式返回表的新副本np.ndarray公司或者马斯克达雷硕士对象（视情况而定）。

参数:

keep_byteorder : bool ，可选可选的布尔: 默认情况下，返回的数组以本机字节顺序包含所有列。但是，如果此选项是 True 这将保留所有列的字节顺序（如果有非本机列）。
names : list ，可选：PYTHON：列表，可选：: 要为返回的结构化数组包含的列名列表。默认值是包括所有表列。

返回:

table_array : array 或 MaskedArray阵列或掩码阵列: 表的副本作为Numpy结构化数组。ndarray表示未屏蔽或 MaskedArray 为了蒙面。

convert_bytestring_to_unicode()#

按测试环列转换(数据类型.种类='S'）到unicode(数据类型.种类=“U”）使用UTF-8编码。

在内部，这会更改字符串列，以用4字节的UCS-4等效值表示字符串中的每个字符，因此内存效率低下，但允许脚本使用自然语法操作字符串数组。

convert_unicode_to_bytestring()#

转换unicode列(数据类型.种类=“U”）到bytestring(数据类型.种类='S'）使用UTF-8编码。

将unicode字符串数组导出到文件时，可能需要将unicode列编码为bytestrings。

copy(copy_data=True)#

返回表的副本。

参数:

copy_data : bool布尔: 如果 True （默认），复制基础数据数组。否则，请使用相同的数据数组。这个 meta 总是深度复制，而不管 copy_data .

field(item)#: 返回列 [item] 重新排列兼容性。

filled(fill_value=None)#

返回self的副本，并填充掩码值。

中频输入 fill_value 则该值将用于表中的所有屏蔽项。否则个人 fill_value 使用为每个表列定义的。

参数:

fill_value : strPython ：字符串: 如果提供，则 fill_value 用于整个表中的所有屏蔽项。

返回:

filled_table ： Table表: 已填充掩码值的新表

classmethod from_pandas(dataframe, index=False, units=None)#

创建 Table 从一个 pandas.DataFrame 举个例子。

除了转换通用的数字或字符串列之外，这还支持将pandas日期和时间delta列转换为 Time 和 TimeDelta 分别是列。

参数:

数据帧 : pandas.DataFramepandas.DataFrame: Pandas pandas.DataFrame 实例
index : bool布尔: 在返回的表中包含索引列（默认值=False）
单位：dict: 将列名映射到 Unit 。列将在表中具有指定的单位。

返回:

桌子： Table表: A Table （或子类）实例

加薪:

ImportError: 如果没有安装Pandas

实例

我们在这里转换 pandas.DataFrame 实例到 QTable .

>>> import numpy as np
>>> import pandas as pd
>>> from astropy.table import QTable

>>> time = pd.Series(['1998-01-01', '2002-01-01'], dtype='datetime64[ns]')
>>> dt = pd.Series(np.array([1, 300], dtype='timedelta64[s]'))
>>> df = pd.DataFrame({'time': time})
>>> df['dt'] = dt
>>> df['x'] = [3., 4.]
>>> with pd.option_context('display.max_columns', 20):
...     print(df)
        time              dt    x
0 1998-01-01 0 days 00:00:01  3.0
1 2002-01-01 0 days 00:05:00  4.0

>>> QTable.from_pandas(df)
<QTable length=2>
          time              dt       x
          Time          TimeDelta float64
----------------------- --------- -------
1998-01-01T00:00:00.000       1.0     3.0
2002-01-01T00:00:00.000     300.0     4.0

group_by(keys)#

将此表按指定的 keys 。

这将有效地将表拆分为组，这些组对应于 keys 分组对象。输出是一个新的 TableGroups 它包含此表的副本，但按行排序 keys .

这个 keys 输入到 group_by 可以用不同的方式指定：

与表列名对应的字符串或字符串列表

与此表长度相同的Numpy数组（同构或结构化）

Table 和这张桌子一样长

参数:

keys : str ， list 的 str ， numpy array ，或 TablePYTHON：字符串、PYTHON：PYTHON列表：STR、NumPy数组或表: 键分组对象

返回:

out ： Table表: 已设置组的新表

index_column(name)#

返回列的位置索引 name .

参数:

name : strPython ：字符串: 列名

返回:

index : intPython ：整型: 列的位置索引 name .

实例

创建一个包含三列“a”、“b”和“c”的表：

>>> t = Table([[1, 2, 3], [0.1, 0.2, 0.3], ['x', 'y', 'z']],
...           names=('a', 'b', 'c'))
>>> print(t)
 a   b   c
--- --- ---
  1 0.1   x
  2 0.2   y
  3 0.3   z

获取表的列“b”的索引：

>>> t.index_column('b')
1

index_mode(mode)#

返回索引模式的上下文管理器。

参数:

mode : strPython ：字符串: “冻结”、“复制”或“放弃复制”。在“discard_on_copy”模式下，只要复制列或表，就不会复制索引。在'freeze'模式下，只要修改列，就不会修改索引；在上下文退出时，索引会根据列值自动刷新。此模式适用于需要在索引列中进行多次添加或修改的情况。在“copy_on u getitem”模式下，在获取列切片和表切片时复制索引，因此col [i0：i1] 将保留索引。

insert_row(index, vals=None, mask=None)#

在给定行之前添加新行 index 在桌子上的位置。

这个 vals 参数可以是：

序列（如元组或列表）: 列值的顺序与表列的顺序相同。
映射（例如dict）: 与列名对应的键。缺少的值将用np.零列数据类型。
None: 所有值填充np.零列数据类型。

参数:

vals : tuple ， list ， dict 或 NonePYTHON：元组、PYTHON：LIST、PYTHON：DICT或PYTHON：无: 在新行中使用指定的值
mask : tuple ， list ， dict 或 NonePYTHON：元组、PYTHON：LIST、PYTHON：DICT或PYTHON：无: 在新行中使用指定的掩码值

items()#

itercols()#

迭代此表的列。

实例

迭代表中的列：

>>> t = Table([[1], [2]])
>>> for col in t.itercols():
...     print(col)
col0
----
   1
col1
----
   2

使用 itercols() 类似于 for col in t.columns.values() 但在句法上是首选的。

iterrows(*names)#

迭代表的行，为每行返回一个值的元组。

当只需要列的子集时，此方法特别有用。

这个 iterrows 方法可以比使用标准表行迭代（例如。 for row in tbl: )，因为它返回一个新的 ~astropy.table.Row 对象，并访问该行中的列（例如。 row['col0'] )比元组访问慢。

参数:

names : listPython ：列表: 列名列表（如果未提供名称，则默认为所有列）

返回:

rows : iterablePython：可迭代: 迭代器返回行值的元组

实例

创建一个包含三列“a”、“b”和“c”的表：

>>> t = Table({'a': [1, 2, 3],
...            'b': [1.0, 2.5, 3.0],
...            'c': ['x', 'y', 'z']})

要使用列名按行迭代：

>>> for a, c in t.iterrows('a', 'c'):
...     print(a, c)
1 x
2 y
3 z

keep_columns(names)#

只保留指定的列（删除其他列）。

参数:

names : str 或 iterable 的 strPYTHON：STR或PYTHON：可迭代的PYTHON：STR: 要保留的柱子。所有其他列都将被删除。

实例

创建一个包含三列“a”、“b”和“c”的表：

>>> t = Table([[1, 2, 3],[0.1, 0.2, 0.3],['x', 'y', 'z']],
...           names=('a', 'b', 'c'))
>>> print(t)
 a   b   c
--- --- ---
  1 0.1   x
  2 0.2   y
  3 0.3   z

仅保留表的列‘a’：：

>>> t.keep_columns('a')
>>> print(t)
 a
---
  1
  2
  3

保留表中的列‘a’和‘c’：：

>>> t = Table([[1, 2, 3],[0.1, 0.2, 0.3],['x', 'y', 'z']],
...           names=('a', 'b', 'c'))
>>> t.keep_columns(['a', 'c'])
>>> print(t)
 a   c
--- ---
  1   x
  2   y
  3   z

keys()#

more(max_lines=None, max_width=None, show_name=True, show_unit=None, show_dtype=False)#

使用分页界面交互浏览表。

支持的密钥：

f, <space> : forward one page
b : back one page
r : refresh same page
n : next row
p : previous row
< : go to beginning
> : go to end
q : quit browsing
h : print this help

参数:

max_lines : intPython ：整型: 表输出中的最大行数
max_width : int 或 NonePYTHON：INT或PYTHON：NONE: 输出最大字符宽度
show_name : bool布尔: 包括列名的标题行。默认值为True。
show_unit : bool布尔: 包括单位的标题行。默认情况下，仅当一个或多个列具有已定义的单位值时，才显示单位行。
show_dtype : bool布尔: 包括列数据类型标题行。默认值为FALSE。

pformat(max_lines=None, max_width=None, show_name=True, show_unit=None, show_dtype=False, html=False, tableid=None, align=None, tableclass=None)#

返回的格式化字符串表示形式的行列表

桌子。

如果没有值 max_lines 然后使用屏幕终端的高度来设置 max_lines . 如果无法确定终端高度，则从配置项中获取默认值 astropy.conf.max_lines . 如果负值为 max_lines 则没有应用行限制。

同样适用于 max_width 除了配置项是 astropy.conf.max_width .

参数:

max_lines : int 或 NonePYTHON：INT或PYTHON：NONE: 要输出的最大行数
max_width : int 或 NonePYTHON：INT或PYTHON：NONE: 输出最大字符宽度
show_name : bool布尔: 包括列名的标题行。默认值为True。
show_unit : bool布尔: 包括单位的标题行。默认情况下，仅当一个或多个列具有已定义的单位值时，才显示单位行。
show_dtype : bool布尔: 包含列数据类型的标题行。默认值为True。
html : bool布尔: 将输出格式化为HTML表。默认值为False。
tableid : str 或 NonePYTHON：字符串或PYTHON：无: 表的ID标记；仅在设置了html时使用。默认值是“table{id}”，其中id是表对象的唯一整数id，id（self）
align : str 或 list 或 tuple 或 NonePYTHON：STR或PYTHON：LIST或PYTHON：TUPLE或PYTHON：NONE: 列的左/右对齐。所有列的默认值为right（None）。其他允许的值为“>”、“<”、“^”和“0=”分别表示右、左、居中和0填充。可以提供一个字符串列表来对齐具有多个列的表。
tableclass : str 或 list 的 str 或 NonePYTHON：STR或PYTHON：PYTHON：LIST：STR或PYTHON：NONE: 表的CSS类；仅在设置了html时使用。默认值为“无”。

返回:

lines : listPython ：列表: 将表格格式化为字符串列表。

pformat_all(max_lines=-1, max_width=-1, show_name=True, show_unit=None, show_dtype=False, html=False, tableid=None, align=None, tableclass=None)#

返回的格式化字符串表示形式的行列表

整张桌子。

同样适用于 max_width 除了配置项是 astropy.conf.max_width .

参数:

max_lines : int 或 NonePYTHON：INT或PYTHON：NONE: 要输出的最大行数
max_width : int 或 NonePYTHON：INT或PYTHON：NONE: 输出最大字符宽度
show_name : bool布尔: 包括列名的标题行。默认值为True。
show_unit : bool布尔: 包括单位的标题行。默认情况下，仅当一个或多个列具有已定义的单位值时，才显示单位行。
show_dtype : bool布尔: 包含列数据类型的标题行。默认值为True。
html : bool布尔: 将输出格式化为HTML表。默认值为False。
tableid : str 或 NonePYTHON：字符串或PYTHON：无: 表的ID标记；仅在设置了html时使用。默认值是“table{id}”，其中id是表对象的唯一整数id，id（self）
align : str 或 list 或 tuple 或 NonePYTHON：STR或PYTHON：LIST或PYTHON：TUPLE或PYTHON：NONE: 列的左/右对齐。所有列的默认值为right（None）。其他允许的值为“>”、“<”、“^”和“0=”分别表示右、左、居中和0填充。可以提供一个字符串列表来对齐具有多个列的表。
tableclass : str 或 list 的 str 或 NonePYTHON：STR或PYTHON：PYTHON：LIST：STR或PYTHON：NONE: 表的CSS类；仅在设置了html时使用。默认值为“无”。

返回:

lines : listPython ：列表: 将表格格式化为字符串列表。

pprint(max_lines=None, max_width=None, show_name=True, show_unit=None, show_dtype=False, align=None)#

打印表的格式化字符串表示形式。

如果没有值 max_lines 然后使用屏幕终端的高度来设置 max_lines . 如果无法确定终端高度，则从配置项中获取默认值 astropy.conf.max_lines . 如果负值为 max_lines 则没有应用行限制。

除配置项为 astropy.conf.max_width .

参数:

max_lines : int 或 NonePYTHON：INT或PYTHON：NONE: 表输出中的最大行数。
max_width : int 或 NonePYTHON：INT或PYTHON：NONE: 输出的最大字符宽度。
show_name : bool布尔: 包括列名的标题行。默认值为True。
show_unit : bool布尔: 包括单位的标题行。默认情况下，仅当一个或多个列具有已定义的单位值时，才显示单位行。
show_dtype : bool布尔: 包括列数据类型标题行。默认值为FALSE。
align : str 或 list 或 tuple 或 NonePYTHON：STR或PYTHON：LIST或PYTHON：TUPLE或PYTHON：NONE: 列的左/右对齐。所有列的默认值为right（None）。其他允许的值为“>”、“<”、“^”和“0=”分别表示右、左、居中和0填充。可以提供一个字符串列表来对齐具有多个列的表。

pprint_all(max_lines=-1, max_width=-1, show_name=True, show_unit=None, show_dtype=False, align=None)#

打印整个表的格式化字符串表示形式。

此方法与 astropy.table.Table.pprint 除了默认的 max_lines 和 max_width 都是-1，这样默认情况下打印整个表，而不是限制屏幕终端的大小。

参数:

max_lines : int 或 NonePYTHON：INT或PYTHON：NONE: 表输出中的最大行数。
max_width : int 或 NonePYTHON：INT或PYTHON：NONE: 输出的最大字符宽度。
show_name : bool布尔: 包括列名的标题行。默认值为True。
show_unit : bool布尔: 包括单位的标题行。默认情况下，仅当一个或多个列具有已定义的单位值时，才显示单位行。
show_dtype : bool布尔: 包括列数据类型标题行。默认值为FALSE。
align : str 或 list 或 tuple 或 NonePYTHON：STR或PYTHON：LIST或PYTHON：TUPLE或PYTHON：NONE: 列的左/右对齐。所有列的默认值为right（None）。其他允许的值为“>”、“<”、“^”和“0=”分别表示右、左、居中和0填充。可以提供一个字符串列表来对齐具有多个列的表。

classmethod read(filename, time_bin_start_column=None, time_bin_end_column=None, time_bin_size_column=None, time_bin_size_unit=None, time_format=None, time_scale=None, format=None, *args, **kwargs)[源代码]#

读取并解析文件并返回 astropy.timeseries.BinnedTimeSeries .

此方法使用Astropy中的统一I/O基础结构，这使得为各种类定义读写器变得容易(https://docs.astropy.org/en/stable/io/unified.html). 默认情况下，此方法将尝试使用为 astropy.timeseries.BinnedTimeSeries 类-但是，也可以使用 format 关键字指定为 astropy.table.Table 类-在这种情况下，您还需要为包含存储箱开始时间的列提供列名，以及其他列名（有关详细信息，请参阅下面的参数部分）：

>>> from astropy.timeseries.binned import BinnedTimeSeries
>>> ts = BinnedTimeSeries.read('binned.dat', format='ascii.ecsv',
...                            time_bin_start_column='date_start',
...                            time_bin_end_column='date_end')  

参数:

filename : strPython ：字符串: 要分析的文件。
format : strPython ：字符串: 文件格式说明符。
time_bin_start_column : strPython ：字符串: 列的名称以及每个bin的开始时间。
time_bin_end_column : str ，可选Python：字符串，可选: 列的名称以及每个bin的结束时间。此选项或 time_bin_size_column 应指定。
time_bin_size_column : str ，可选Python：字符串，可选: 列的名称以及每个箱子的大小。此选项或 time_bin_end_column 应指定。
time_bin_size_unit ： astropy.units.Unit 可选astropy.units.Unit，可选: 如果 time_bin_size_column 已指定，但未在表中设置单位，则可以手动指定单位。
time_format : str ，可选Python：字符串，可选: 开始列和结束列的时间格式。
time_scale : str ，可选Python：字符串，可选: 开始列和结束列的时间刻度。
*args : tuple ，可选Python：元组，可选: 传递给数据读取器的位置参数。
**kwargs : dict ，可选Python：Dict，可选: 传递给数据读取器的关键字参数。

返回:

out ： astropy.timeseries.binned.BinnedTimeSeriesastropy.timeseries.binned.BinnedTimeSeries: 与文件对应的BinnedTimeSeries。

remove_column(name)#

从表中删除列。

也可以通过以下方式实现：

del table[name]

参数:

name : strPython ：字符串: 要删除的列的名称

实例

创建一个包含三列“a”、“b”和“c”的表：

>>> t = Table([[1, 2, 3], [0.1, 0.2, 0.3], ['x', 'y', 'z']],
...           names=('a', 'b', 'c'))
>>> print(t)
 a   b   c
--- --- ---
  1 0.1   x
  2 0.2   y
  3 0.3   z

从表中删除列“b”：

>>> t.remove_column('b')
>>> print(t)
 a   c
--- ---
  1   x
  2   y
  3   z

要同时删除多个列，请使用“删除列”。

remove_columns(names)#

从表中删除几列。

参数:

names : str 或 iterable 的 strPYTHON：STR或PYTHON：可迭代的PYTHON：STR: 要删除的列的名称

实例

创建一个包含三列“a”、“b”和“c”的表：

>>> t = Table([[1, 2, 3], [0.1, 0.2, 0.3], ['x', 'y', 'z']],
...     names=('a', 'b', 'c'))
>>> print(t)
 a   b   c
--- --- ---
  1 0.1   x
  2 0.2   y
  3 0.3   z

从表中删除列“b”和“c”：

>>> t.remove_columns(['b', 'c'])
>>> print(t)
 a
---
  1
  2
  3

只指定一列也可以。从表中删除列“b”：

>>> t = Table([[1, 2, 3], [0.1, 0.2, 0.3], ['x', 'y', 'z']],
...     names=('a', 'b', 'c'))
>>> t.remove_columns('b')
>>> print(t)
 a   c
--- ---
  1   x
  2   y
  3   z

这与使用remove_column相同。

remove_indices(colname)#

删除所有涉及给定列的索引。如果删除主索引，则新的主索引将是最近添加的剩余索引。

参数:

colname : strPython ：字符串: 列的名称

remove_row(index)#

从表中删除行。

参数:

index : intPython ：整型: 要删除的行的索引

实例

创建一个包含三列“a”、“b”和“c”的表：

>>> t = Table([[1, 2, 3], [0.1, 0.2, 0.3], ['x', 'y', 'z']],
...           names=('a', 'b', 'c'))
>>> print(t)
 a   b   c
--- --- ---
  1 0.1   x
  2 0.2   y
  3 0.3   z

从表中删除行1:：

>>> t.remove_row(1)
>>> print(t)
 a   b   c
--- --- ---
  1 0.1   x
  3 0.3   z

要同时删除多行，请使用remove_rows。

remove_rows(row_specifier)#

从表中删除行。

参数:

row_specifier : slice 或 int 或 array 的 intSLICE或PYTHON：int或数组PYTHON：INT: 要删除的行的规范

实例

创建一个包含三列“a”、“b”和“c”的表：

>>> t = Table([[1, 2, 3], [0.1, 0.2, 0.3], ['x', 'y', 'z']],
...           names=('a', 'b', 'c'))
>>> print(t)
 a   b   c
--- --- ---
  1 0.1   x
  2 0.2   y
  3 0.3   z

从表中删除行0和行2:：

>>> t.remove_rows([0, 2])
>>> print(t)
 a   b   c
--- --- ---
  2 0.2   y

请注意，如果slice操作符扩展到数据之外，则不会出现警告：

>>> t = Table([[1, 2, 3], [0.1, 0.2, 0.3], ['x', 'y', 'z']],
...           names=('a', 'b', 'c'))
>>> t.remove_rows(slice(10, 20, 1))
>>> print(t)
 a   b   c
--- --- ---
  1 0.1   x
  2 0.2   y
  3 0.3   z

rename_column(name, new_name)#

重命名列。

这也可以通过设置 name 属性的属性 info 列的属性：：

table[name].info.name = new_name

参数:

name : strPython ：字符串: 列的当前名称。
new_name : strPython ：字符串: 列的新名称

实例

创建一个包含三列“a”、“b”和“c”的表：

>>> t = Table([[1,2],[3,4],[5,6]], names=('a','b','c'))
>>> print(t)
 a   b   c
--- --- ---
  1   3   5
  2   4   6

将列“a”重命名为“aa”：

>>> t.rename_column('a' , 'aa')
>>> print(t)
 aa  b   c
--- --- ---
  1   3   5
  2   4   6

rename_columns(names, new_names)#

重命名多个列。

参数:

names : list ， tuplePYTHON：列表，PYTHON：元组: 现有列名的列表或元组。
new_names : list ， tuplePYTHON：列表，PYTHON：元组: 新列名的列表或元组。

实例

创建一个包含三列“a”、“b”、“c”的表：

>>> t = Table([[1,2],[3,4],[5,6]], names=('a','b','c'))
>>> print(t)
  a   b   c
 --- --- ---
  1   3   5
  2   4   6

将列“a”重命名为“aa”，将“b”重命名为“bb”：：

>>> names = ('a','b')
>>> new_names = ('aa','bb')
>>> t.rename_columns(names, new_names)
>>> print(t)
 aa  bb   c
--- --- ---
  1   3   5
  2   4   6

replace_column(name, col, copy=True)#

替换列 name 和新的 col 对象。

行为 copy 对于列对象是：-copy=True:具有数据副本和meta深度副本的新类实例-copy=False:具有相同数据和meta的仅键副本的新类实例

对于mixin列：-copy=True:new class instance with copy of data and deep copy of meta-copy=False:原始实例（根本没有副本）

参数:

name : strPython ：字符串: 要替换的列的名称
col : Column or ndarray or sequence列或ndarray或 Python ：序列: 用于替换现有列的新列对象。
copy : bool布尔: 复制输入 col ，默认值为真

参见

add_columns, astropy.table.hstack, update

实例

将列“a”替换为其自身的浮点版本：

>>> t = Table([[1, 2, 3], [0.1, 0.2, 0.3]], names=('a', 'b'))
>>> float_a = t['a'].astype(float)
>>> t.replace_column('a', float_a)

reverse()#

反转表行的行顺序。该表被就地反转，并且没有函数参数。

实例

创建包含三列的表：

>>> t = Table([['Max', 'Jo', 'John'], ['Miller','Miller','Jackson'],
...         [12,15,18]], names=('firstname','name','tel'))
>>> print(t)
firstname   name  tel
--------- ------- ---
      Max  Miller  12
       Jo  Miller  15
     John Jackson  18

反转顺序：

>>> t.reverse()
>>> print(t)
firstname   name  tel
--------- ------- ---
     John Jackson  18
       Jo  Miller  15
      Max  Miller  12

round(decimals=0)#

将数字列舍入到指定的小数位数。非数字列将被忽略。

参数:

小数：int，dict: 列舍入到的小数位数。如果给定dict，则列将舍入到指定为值的数字。如果某一列不在给定的字典中，它将保持不变。

实例

创建三个不同类型的列：

>>> t = Table([[1, 4, 5], [-25.55, 12.123, 85],
...     ['a', 'b', 'c']], names=('a', 'b', 'c'))
>>> print(t)
 a    b     c
--- ------ ---
  1 -25.55   a
  4 12.123   b
  5   85.0   c

四舍五入到0：

>>> t.round(0)
>>> print(t)
 a    b    c
--- ----- ---
  1 -26.0   a
  4  12.0   b
  5  85.0   c

将列“a”四舍五入到小数点后1：

>>> t.round({'a':-1})
>>> print(t)
 a    b    c
--- ----- ---
  0 -26.0   a
  0  12.0   b
  0  85.0   c

show_in_browser(max_lines=5000, jsviewer=False, browser='default', jskwargs={'use_local_files': True}, tableid=None, table_class='display compact', css=None, show_row_index='idx')#

以HTML呈现表格并在web浏览器中显示。

参数:

max_lines : intPython ：整型: 要导出到表的最大行数（默认情况下设置为低以避免内存问题，因为浏览器视图需要在内存中复制表）。负值 max_lines 表示没有行限制。
jsviewer : bool布尔: 如果 True, prepends some javascript headers so that the table is rendered as a DataTables 数据表。这允许在浏览器中搜索和排序。
browser : strPython ：字符串: 任何合法的浏览器名称，例如。 'firefox' ， 'chrome' ， 'safari' （对于mac，您可能需要使用 'open -a "/Applications/Google Chrome.app" {{}}' 对于铬）。如果 'default' ，将使用系统默认浏览器。
jskwargs : dictPython ：词典: 传递给 astropy.table.JSViewer 初始化。默认为 {{'use_local_files': True}} 这意味着JavaScript库将由本地副本提供服务。
tableid : str 或 NonePYTHON：字符串或PYTHON：无: 表的htmlid标记。默认为 table{{id}} ，其中id是表对象id（self）的唯一整数id。
table_class : str 或 NonePYTHON：字符串或PYTHON：无: 包含用于设置表样式的HTML类列表的字符串。默认值是“display compact”，其他可能的值可以在中找到https://www.datatables.net/manual/styleng/classes
css : strPython ：字符串: 声明表格式的有效CSS字符串。默认为 astropy.table.jsviewer.DEFAULT_CSS .
show_row_index : str 或 FalsePYTHON：字符串或PYTHON：FALSE: 如果计算结果不为False，则具有给定名称的列将添加到显示的表的版本中。这个新列显示表本身中行的索引，即使所显示的表被另一列重新排序。请注意，如果已存在具有此名称的列，则将忽略此选项。默认为“idx”。

show_in_notebook(tableid=None, css=None, display_length=50, table_class='astropy-default', show_row_index='idx')#

以HTML格式呈现表格，并将其显示在IPython笔记本中。

参数:

tableid : str 或 NonePYTHON：字符串或PYTHON：无: 表的htmlid标记。默认为 table{{id}}-XXX ，其中id是表对象的唯一整数id，id（self），XXX是一个随机数，以避免多次打印同一个表时发生冲突。
table_class : str 或 NonePYTHON：字符串或PYTHON：无: 包含用于设置表样式的HTML类列表的字符串。特殊的默认字符串（“astropy-default”）表示将从配置项中检索该字符串 astropy.table.default_notebook_table_class . 请注意，这些表类可能会使用引导，因为这是随笔记本一起加载的。看到了吗 this page 对于类列表。
css : strPython ：字符串: 声明表格式的有效CSS字符串。默认为 astropy.table.jsviewer.DEFAULT_CSS_NB .
display_length : int ，可选PYTHON：int，可选: 要显示的数字或行。默认为50。
show_row_index : str 或 FalsePYTHON：字符串或PYTHON：FALSE: 如果计算结果不为False，则具有给定名称的列将添加到显示的表的版本中。这个新列显示表本身中行的索引，即使所显示的表被另一列重新排序。请注意，如果已存在具有此名称的列，则将忽略此选项。默认为“idx”。

笔记

目前，不像 show_in_browser （与 jsviewer=True )，此方法需要访问在线javascript代码库。这是由于现代浏览器对访问本地文件的限制。因此，如果您在脱机时调用此方法（并且没有jquery和jquery.dataTables)jsviewer将无法获得特性。

sort(keys=None, *, kind=None, reverse=False)#

根据一个或多个键对表进行排序。它对现有表进行操作，不返回新表。

参数:

keys : str 或 list 的 strPYTHON：STR或PYTHON：PYTHON列表：STR: 表排序依据的键。如果没有，则使用表的主索引。
kind{‘快速排序’，‘合并排序’，‘堆排序’，‘稳定’}，可选: 使用的排序算法 numpy.argsort 。
reverse : bool布尔: 按相反顺序排序（默认值=False）

实例

创建包含3列的表：

>>> t = Table([['Max', 'Jo', 'John'], ['Miller', 'Miller', 'Jackson'],
...            [12, 15, 18]], names=('firstname', 'name', 'tel'))
>>> print(t)
firstname   name  tel
--------- ------- ---
      Max  Miller  12
       Jo  Miller  15
     John Jackson  18

根据标准排序规则，先“name”再“firstname”：

>>> t.sort(['name', 'firstname'])
>>> print(t)
firstname   name  tel
--------- ------- ---
     John Jackson  18
       Jo  Miller  15
      Max  Miller  12

按照标准排序规则排序，先是“名字”，然后是“电话”，顺序相反：

>>> t.sort(['firstname', 'tel'], reverse=True)
>>> print(t)
firstname   name  tel
--------- ------- ---
      Max  Miller  12
     John Jackson  18
       Jo  Miller  15

to_pandas(index=None, use_nullable_int=True)#

返回一个 pandas.DataFrame 举个例子。

创建的数据帧的索引由 index 争论。为 index=True 还是默认的 None ，如果表上有主键索引，则将为数据帧指定索引 and 如果它对应于一列。如果 index=False 则不指定数据帧索引。如果 index 是表中列的名称，则该列将成为数据帧索引。

除了普通列或屏蔽列之外，它还支持表mixin列，比如Quantity、Time或SkyCoord。在许多情况下，这些对象在pandas中没有类似项，它们将仅使用Column或MaskedColumn转换为“编码”表示。例外是Time或TimeDelta列，它们将使用 np.datetime64 或 np.timedelta64 . 请参见下面的示例。

参数:

index : None ， bool ， strPYTHON：无，布尔，PYTHON：STR: 指定数据帧索引模式
use_nullable_int : bool ，默认为True布尔，默认值=真: 将integer MaskedColumn转换为pandas可为null的整数类型。如果 use_nullable_int=False 或者pandas版本不支持可为null的整数类型（版本<0.24），那么对于缺少的元素，该列将转换为带NaN的float，并发出警告。

返回:

数据帧 : pandas.DataFramepandas.DataFrame: Pandas pandas.DataFrame 实例

加薪:

ImportError: 如果没有安装Pandas
ValueError: 如果表有多维列

实例

在这里，我们将一个包含几个mixin的表转换为 pandas.DataFrame 实例。

>>> import pandas as pd
>>> from astropy.table import QTable
>>> import astropy.units as u
>>> from astropy.time import Time, TimeDelta
>>> from astropy.coordinates import SkyCoord

>>> q = [1, 2] * u.m
>>> tm = Time([1998, 2002], format='jyear')
>>> sc = SkyCoord([5, 6], [7, 8], unit='deg')
>>> dt = TimeDelta([3, 200] * u.s)

>>> t = QTable([q, tm, sc, dt], names=['q', 'tm', 'sc', 'dt'])

>>> df = t.to_pandas(index='tm')
>>> with pd.option_context('display.max_columns', 20):
...     print(df)
              q  sc.ra  sc.dec              dt
tm
1998-01-01  1.0    5.0     7.0 0 days 00:00:03
2002-01-01  2.0    6.0     8.0 0 days 00:03:20

update(other, copy=True)#

执行字典样式的更新和合并元数据。

这一论点 other 必须是一个 Table ，或者可以用来初始化表的东西。列来自(可能已转换) other 都被添加到这个表中。在列名匹配的情况下，此表中的列将替换为 other 。如果 other 是一种 Table 实例，然后 |= 可作为就地更新的替代语法使用 | 可用于将数据合并到新表。

参数:

other : astropy:table-like星形：桌状: 用于更新此表的数据。
copy : bool布尔: 更新的列是否应该是原始列的副本或引用。

参见

add_columns, astropy.table.hstack, replace_column

实例

用另一个表更新一个表：：

>>> t1 = Table({'a': ['foo', 'bar'], 'b': [0., 0.]}, meta={'i': 0})
>>> t2 = Table({'b': [1., 2.], 'c': [7., 11.]}, meta={'n': 2})
>>> t1.update(t2)
>>> t1
<Table length=2>
 a      b       c
str3 float64 float64
---- ------- -------
 foo     1.0     7.0
 bar     2.0    11.0
>>> t1.meta
{'i': 0, 'n': 2}

使用词典更新表：：

>>> t = Table({'a': ['foo', 'bar'], 'b': [0., 0.]})
>>> t.update({'b': [1., 2.]})
>>> t
<Table length=2>
 a      b
str3 float64
---- -------
 foo     1.0
 bar     2.0

values()#

values_equal(other)#

表与另一个表、列表或标量的元素级比较。

返回A Table 包含显示比较结果的布尔值的相同列。

参数:

other : astropy:table-like object 或 list 或 scalarAstPy：表状对象或Python：列表或标量: 对象与表进行比较

实例

比较一张表和另一张表：

>>> t1 = Table([[1, 2], [4, 5], [-7, 8]], names=('a', 'b', 'c'))
>>> t2 = Table([[1, 2], [-4, 5], [7, 8]], names=('a', 'b', 'c'))
>>> t1.values_equal(t2)
<Table length=2>
 a     b     c
bool  bool  bool
---- ----- -----
True False False
True  True  True