表#
- class astropy.table.Table(data=None, masked=False, names=None, dtype=None, meta=None, copy=True, rows=None, copy_indices=True, units=None, descriptions=None, **kwargs)[源代码]#
基类：
object表示异构数据表的类。
Table为异构表格数据提供一个类。由Table课程结束，例如anumpy结构化数组是通过添加或删除列或添加新的数据行来轻松修改表结构的能力。此外，完全支持表和列元数据。Table不同于NDData假设输入数据由同质数据的列组成，其中每个列都有一个唯一的标识符，并且可能包含额外的元数据，例如数据单元、格式和描述。另请参见：https://docs.astropy.org/en/stable/table/
- 参数:
- data :
numpyndarray，dict，list， astropy:table-likeobject，可选Numpy ndarray，python：dict，python：List，Astery：类桌子对象，可选 初始化表的数据。
- masked : bool ，可选可选的布尔
指定是否屏蔽表。
- names :
list，可选Python：列表，可选 指定列名。
- dtype :
list，可选Python：列表，可选 指定列数据类型。
- meta :
dict，可选Python：Dict，可选 与表关联的元数据。
- copy : bool ，可选可选的布尔
复制输入数据。如果输入是一个表
meta无论copy参数。默认值为True。- rows :
numpyndarray，list的list，可选NumPy ndarray，python：python列表：list，可选 表的面向行的数据，而不是
data争论。- copy_indices : bool ，可选可选的布尔
复制输入数据中的所有索引。默认值为True。
- units :
list，dict，可选PYTHON：列表，PYTHON：DICT，可选 应用于列的单位的列表或dict。
- descriptions :
list，dict，可选PYTHON：列表，PYTHON：DICT，可选 应用于列的描述的列表或dict。
- **kwargs :
dict，可选Python：Dict，可选 转换类表对象时的其他关键字参数。
- data :
属性摘要
如果表中有
MaskedColumn柱。如果表中的列包含被屏蔽的值，则为True。
如果表有任何mixin列（定义为不是列子类的列），则为True。
返回一个TableILoc对象，该对象可用于按索引中出现的顺序检索索引行。
以TableIndexes对象的形式返回与表的列关联的索引。
返回可用于按索引检索给定数据区域中的行的TableLoc对象。
返回一个TableLocIndexes对象，该对象可用于检索与给定表索引键值相对应的行索引。
维护控制打印输出表列可见性的元组。
维护控制打印输出表列可见性的元组。
读取和分析数据表，并以表的形式返回。
以指定的格式写出此表对象。
方法总结
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公司或者马斯克达雷硕士对象（视情况而定）。
按测试环列转换(数据类型.种类='S'）到unicode(数据类型.种类=“U”）使用UTF-8编码。
转换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, ...])打印整个表的格式化字符串表示形式。
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表属性。
- read#
读取和分析数据表，并以表的形式返回。
此函数提供到AstPy统一I/O层的表接口。这允许使用以下语法轻松读取许多受支持的数据格式的文件：
>>> from astropy.table import Table >>> dat = Table.read('table.dat', format='ascii') >>> events = Table.read('events.fits', format='fits')
获取有关可供阅读的读者的帮助
Table使用``Help()``方法：：>>> Table.read.help() # Get help reading Table and list supported formats >>> Table.read.help('fits') # Get detailed help on Table FITS reader >>> Table.read.list_formats() # Print list of available formats
另请参阅：https://docs.astropy.org/en/stable/io/unified.html
- 参数:
- 返回:
- out ：
Table表 文件内容对应的表
- out ：
- 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 。
方法文件
- 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()为每一个。这两种方法的性能差别很小。- 参数:
实例
创建一个包含两列“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()对于每个列。- 参数:
实例
创建一个包含两列“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。
- colnames :
- add_row(vals=None, mask=None)[源代码]#
在表的末尾添加新行。
这个
vals参数可以是：- 序列（如元组或列表）
列值的顺序与表列的顺序相同。
- 映射（例如dict）
与列名对应的键。缺少的值将用np.零列数据类型。
None所有值填充np.零列数据类型。
此方法要求表对象“拥有”底层数组数据。特别是不能将行添加到已从现有数组中用copy=False初始化的表中。
这个
mask属性应提供值的掩码（如果需要）。掩码的类型应与值的类型匹配，即如果vals是一个iterable，那么mask如果长度相同vals是一个映射，那么mask应该是字典。- 参数:
实例
创建一个包含三列“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.
- as_array(keep_byteorder=False, names=None)[源代码]#
以结构化的形式返回表的新副本np.ndarray公司或者马斯克达雷硕士对象（视情况而定）。
- 参数:
- 返回:
- table_array :
array或MaskedArray阵列或掩码阵列 表的副本作为Numpy结构化数组。ndarray表示未屏蔽或
MaskedArray为了蒙面。
- table_array :
- 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。
- filled(fill_value=None)[源代码]#
返回self的副本，并填充掩码值。
中频输入
fill_value则该值将用于表中的所有屏蔽项。否则个人fill_value使用为每个表列定义的。
- 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。列将在表中具有指定的单位。
- 数据帧 :
- 返回:
- 加薪:
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和这张桌子一样长
- index_column(name)[源代码]#
返回列的位置索引
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] 将保留索引。
- mode :
- insert_row(index, vals=None, mask=None)[源代码]#
在给定行之前添加新行
index在桌子上的位置。这个
vals参数可以是：- 序列（如元组或列表）
列值的顺序与表列的顺序相同。
- 映射（例如dict）
与列名对应的键。缺少的值将用np.零列数据类型。
None所有值填充np.零列数据类型。
这个
mask属性应提供值的掩码（如果需要）。掩码的类型应与值的类型匹配，即如果vals是一个iterable，那么mask如果长度相同vals是一个映射，那么mask应该是字典。
- 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'])比元组访问慢。实例
创建一个包含三列“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)[源代码]#
只保留指定的列（删除其他列）。
实例
创建一个包含三列“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
- 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
- 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时使用。默认值为“无”。
- max_lines :
- 返回:
- lines :
listPython ：列表 将表格格式化为字符串列表。
- lines :
- 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_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时使用。默认值为“无”。
- max_lines :
- 返回:
- lines :
listPython ：列表 将表格格式化为字符串列表。
- lines :
- 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填充。可以提供一个字符串列表来对齐具有多个列的表。
- max_lines :
- 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填充。可以提供一个字符串列表来对齐具有多个列的表。
- max_lines :
- remove_column(name)[源代码]#
从表中删除列。
也可以通过以下方式实现：
del table[name]
- 参数:
- name :
strPython ：字符串 要删除的列的名称
- 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.remove_column('b') >>> print(t) a c --- --- 1 x 2 y 3 z
要同时删除多个列，请使用“删除列”。
- remove_columns(names)[源代码]#
从表中删除几列。
实例
创建一个包含三列“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 ：字符串 列的名称
- colname :
- remove_row(index)[源代码]#
从表中删除行。
- 参数:
- index :
intPython ：整型 要删除的行的索引
- index :
实例
创建一个包含三列“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)[源代码]#
从表中删除行。
实例
创建一个包含三列“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
实例
创建一个包含三列“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)[源代码]#
重命名多个列。
- 参数:
实例
创建一个包含三列“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:原始实例（根本没有副本）
- 参数:
实例
将列“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”。
- max_lines :
- 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”。
- tableid :
笔记
目前，不像
show_in_browser（与jsviewer=True)，此方法需要访问在线javascript代码库。这是由于现代浏览器对访问本地文件的限制。因此，如果您在脱机时调用此方法（并且没有jquery和jquery.dataTables)jsviewer将无法获得特性。
- sort(keys=None, *, kind=None, reverse=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. 请参见下面的示例。- 参数:
- 返回:
- 数据帧 :
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布尔
更新的列是否应该是原始列的副本或引用。
实例
用另一个表更新一个表：：
>>> 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_equal(other)[源代码]#
表与另一个表、列表或标量的元素级比较。
返回A
Table包含显示比较结果的布尔值的相同列。- 参数:
- other : astropy:table-like
object或list或 scalarAstPy：表状对象或Python：列表或标量 对象与表进行比较
- other : astropy:table-like
实例
比较一张表和另一张表：
>>> 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