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 课程结束,例如a numpy 结构化数组是通过添加或删除列或添加新的数据行来轻松修改表结构的能力。此外,完全支持表和列元数据。

Table 不同于 NDData 假设输入数据由同质数据的列组成,其中每个列都有一个唯一的标识符,并且可能包含额外的元数据,例如数据单元、格式和描述。

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

参数
dataNumpy ndarray、dict、list、表格状对象,可选

初始化表的数据。

masked可选的布尔

指定是否屏蔽表。

names可选列表

指定列名。

dtype可选列表

指定列数据类型。

meta可选的

与表关联的元数据。

copy可选的布尔

复制输入数据。如果输入是一个表 meta 无论 copy 参数。默认值为True。

rowsNumpy ndarray,列表列表,可选

表的面向行的数据,而不是 data 争论。

copy_indices可选的布尔

复制输入数据中的所有索引。默认值为True。

units列表、dict、可选

应用于列的单位的列表或dict。

descriptions列表、dict、可选

应用于列的描述的列表或dict。

**kwargs可选的

转换类表对象时的其他关键字参数。

属性摘要

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 

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

read 

write 

方法总结

add_column (COLL) [, index, name, ...] )

使用将新列添加到表中 col 作为输入。

add_columns \(颜色[, indexes, names, copy, ...] )

使用添加表的新列列表 cols 数据对象。

add_index \(列名[, 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 \(数据帧[, index, units] )

创建一个 Table 从A pandas.DataFrame 实例

group_by \(钥匙)

按指定的将此表分组 keys

index_column (姓名)

返回列的位置索引 name .

index_mode \(模式)

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

insert_row \(索引[, vals, mask] )

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

items ()

itercols ()

迭代此表的列。

iterrows * 姓名)

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

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 \(colname)

删除所有涉及给定列的索引。

remove_row \(索引)

从表中删除行。

remove_rows \(行说明符)

从表中删除行。

rename_column \(名称,新名称)

重命名列。

rename_columns \(名称,新名称)

重命名多个列。

replace_column \(姓名,列[, copy] )

替换列 name 和新的 col 对象。

reverse ()

反转表行的行顺序。

round \ [decimals] )

将数字列舍入到指定的小数位数。

show_in_browser \ [max_lines, jsviewer, ...] )

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

show_in_notebook \ [tableid, css, ...] )

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

sort \ [keys, reverse] )

根据一个或多个键对表进行排序。

to_pandas \ [index, use_nullable_int] )

返回A pandas.DataFrame 实例

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
pprint_exclude_names

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

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

这将用于 pprint_include_namespprint_exclude_names 表属性。

pprint_include_names

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

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

这将用于 pprint_include_namespprint_exclude_names 表属性。

read = <astropy.table.connect.TableRead object>
write = <astropy.table.connect.TableWrite object>

方法文件

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对象

新列的数据对象

indexint或无

在此位置之前或结尾处插入列(默认)。

nameSTR

列名

rename_duplicate布尔

如果列名已存在,请取消验证。默认值为False。

copy布尔

复制新列。默认值为True。

default_nameSTR或无

如果两者都使用的名称 namecol.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对象列表

新列的数据对象列表

indexes整型或无型列表

在此位置之前或结尾处插入列(默认)。

namesstr列表

列名

copy布尔

复制新列。默认值为True。

rename_duplicate布尔

如果新列名与现有列名重复,则取消验证。默认值为False。

实例

创建一个包含两列“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)[源代码]

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

参数
colnamesstr或list

要索引的列名(或单个列名)的列表

engine类型或无

要使用的索引引擎类,从SortedArray、BST和SCEngine中选择。如果提供的参数为None(默认情况下),请使用SortedArray。

unique布尔

索引的值是否必须唯一。默认值为False。

add_row(vals=None, mask=None)[源代码]

在表的末尾添加新行。

这个 vals 参数可以是:

序列(如元组或列表)

列值的顺序与表列的顺序相同。

映射(例如dict)

与列名对应的键。缺少的值将用np.零列数据类型。

None

所有值填充np.零列数据类型。

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

这个 mask 属性应提供值的掩码(如果需要)。掩码的类型应与值的类型匹配,即如果 vals 是一个iterable,那么 mask 如果长度相同 vals 是一个映射,那么 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 .

参数
keysstr或str列表

表排序依据的列名

kind{'quicksort','mergesort','heapsort'},可选

排序算法。

reverse布尔

按相反顺序排序(默认值=False)

返回
index_array恩达雷

按指定键列对表排序的索引数组。

as_array(keep_byteorder=False, names=None)[源代码]

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

参数
keep_byteorder可选的布尔

默认情况下,返回的数组以本机字节顺序包含所有列。但是,如果此选项是 True 这将保留所有列的字节顺序(如果有非本机列)。

names列表,可选:

要为返回的结构化数组包含的列名列表。默认值是包括所有表列。

返回
table_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布尔

如果 True (默认),复制基础数据数组。否则,请使用相同的数据数组。这个 meta 总是深度复制,而不管 copy_data .

field(item)[源代码]

返回列 [item] 重新排列兼容性。

filled(fill_value=None)[源代码]

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

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

参数
fill_valueSTR

如果提供,则 fill_value 用于整个表中的所有屏蔽项。

返回
filled_tableTable

已填充掩码值的新表

classmethod from_pandas(dataframe, index=False, units=None)[源代码]

创建一个 Table 从A pandas.DataFrame 实例

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

参数
数据帧 : pandas.DataFramepandas.DataFrame

Pandas pandas.DataFrame 实例

index布尔

在返回的表中包含索引列(默认值=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
         object         object 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、str列表、numpy array或 Tablestr,str的列表,numpy数组,或者

键分组对象

返回
outTable

已设置组的新表

index_column(name)[源代码]

返回列的位置索引 name .

参数
nameSTR

列名

返回
index利息

列的位置索引 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)[源代码]

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

参数
modeSTR

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

insert_row(index, vals=None, mask=None)[源代码]

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

这个 vals 参数可以是:

序列(如元组或列表)

列值的顺序与表列的顺序相同。

映射(例如dict)

与列名对应的键。缺少的值将用np.零列数据类型。

None

所有值填充np.零列数据类型。

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

参数
vals元组、列表、字典或无

在新行中使用指定的值

mask元组、列表、字典或无

在新行中使用指定的掩码值

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列表

列名列表(如果未提供名称,则默认为所有列)

返回
rows可迭代的

迭代器返回行值的元组

实例

创建一个包含三列“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列表

包含要保留的列名称的列表。所有其他列都将被删除。

实例

创建一个包含三列“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利息

表输出中的最大行数

max_widthint或无

输出最大字符宽度

show_name布尔

包括列名的标题行。默认值为True。

show_unit布尔

包括单位的标题行。默认情况下,仅当一个或多个列具有已定义的单位值时,才显示单位行。

show_dtype布尔

包含列数据类型的标题行。默认值为True。

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_linesint或无

要输出的最大行数

max_widthint或无

输出最大字符宽度

show_name布尔

包括列名的标题行。默认值为True。

show_unit布尔

包括单位的标题行。默认情况下,仅当一个或多个列具有已定义的单位值时,才显示单位行。

show_dtype布尔

包含列数据类型的标题行。默认值为True。

html布尔

将输出格式化为HTML表。默认值为False。

tableidSTR或无

表的ID标记;仅在设置了html时使用。默认值是“table{id}”,其中id是表对象的唯一整数id,id(self)

align字符串、列表、元组或无

列的左/右对齐。所有列的默认值为right(None)。其他允许的值为“>”、“<”、“^”和“0=”分别表示右、左、居中和0填充。可以提供一个字符串列表来对齐具有多个列的表。

tableclass字符串或字符串列表或无

表的CSS类;仅在设置了html时使用。默认值为“无”。

返回
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_linesint或无

要输出的最大行数

max_widthint或无

输出最大字符宽度

show_name布尔

包括列名的标题行。默认值为True。

show_unit布尔

包括单位的标题行。默认情况下,仅当一个或多个列具有已定义的单位值时,才显示单位行。

show_dtype布尔

包含列数据类型的标题行。默认值为True。

html布尔

将输出格式化为HTML表。默认值为False。

tableidSTR或无

表的ID标记;仅在设置了html时使用。默认值是“table{id}”,其中id是表对象的唯一整数id,id(self)

align字符串、列表、元组或无

列的左/右对齐。所有列的默认值为right(None)。其他允许的值为“>”、“<”、“^”和“0=”分别表示右、左、居中和0填充。可以提供一个字符串列表来对齐具有多个列的表。

tableclass字符串或字符串列表或无

表的CSS类;仅在设置了html时使用。默认值为“无”。

返回
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_linesint或无

表输出中的最大行数。

max_widthint或无

输出的最大字符宽度。

show_name布尔

包括列名的标题行。默认值为True。

show_unit布尔

包括单位的标题行。默认情况下,仅当一个或多个列具有已定义的单位值时,才显示单位行。

show_dtype布尔

包含列数据类型的标题行。默认值为True。

align字符串、列表、元组或无

列的左/右对齐。所有列的默认值为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_linesmax_width 都是-1,这样默认情况下打印整个表,而不是限制屏幕终端的大小。

参数
max_linesint或无

表输出中的最大行数。

max_widthint或无

输出的最大字符宽度。

show_name布尔

包括列名的标题行。默认值为True。

show_unit布尔

包括单位的标题行。默认情况下,仅当一个或多个列具有已定义的单位值时,才显示单位行。

show_dtype布尔

包含列数据类型的标题行。默认值为True。

align字符串、列表、元组或无

列的左/右对齐。所有列的默认值为right(None)。其他允许的值为“>”、“<”、“^”和“0=”分别表示右、左、居中和0填充。可以提供一个字符串列表来对齐具有多个列的表。

remove_column(name)[源代码]

从表中删除列。

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

del table[name]
参数
nameSTR

要删除的列的名称

实例

创建一个包含三列“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列表

包含要删除的列名称的列表

实例

创建一个包含三列“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)[源代码]

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

参数
colnameSTR

列的名称

remove_row(index)[源代码]

从表中删除行。

参数
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)[源代码]

从表中删除行。

参数
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 列的属性:

table[name].name = new_name

托多:这对混血儿没用

参数
nameSTR

列的当前名称。

new_nameSTR

列的新名称

实例

创建一个包含三列“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列表,元组

现有列名的列表或元组。

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:原始实例(根本没有副本)

参数
nameSTR

要替换的列的名称

colColumnndarray 或序列列或ndarray或序列

用于替换现有列的新列对象。

copy布尔

复制输入 col ,默认值为真

实例

将列“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利息

要导出到表的最大行数(默认情况下设置为低以避免内存问题,因为浏览器视图需要在内存中复制表)。负值 max_lines 表示没有行限制。

jsviewer布尔

如果 True, prepends some javascript headers so that the table is rendered as a DataTables 数据表。这允许在浏览器中搜索和排序。

browserSTR

任何合法的浏览器名称,例如。 'firefox''chrome''safari' (对于mac,您可能需要使用 'open -a "/Applications/Google Chrome.app" {{}}' 对于铬)。如果 'default' ,将使用系统默认浏览器。

jskwargs双关语

传递给 astropy.table.JSViewer 初始化。默认为 {{'use_local_files': True}} 这意味着JavaScript库将由本地副本提供服务。

tableidSTR或无

表的htmlid标记。默认为 table{{id}} ,其中id是表对象id(self)的唯一整数id。

table_classSTR或无

包含用于设置表样式的HTML类列表的字符串。默认值是“display compact”,其他可能的值可以在中找到https://www.datatables.net/manual/styleng/classes

cssSTR

声明表格式的有效CSS字符串。默认为 astropy.table.jsviewer.DEFAULT_CSS .

show_row_indexstr或False

如果计算结果不为False,则具有给定名称的列将添加到显示的表的版本中。这个新列显示表本身中行的索引,即使所显示的表被另一列重新排序。请注意,如果已存在具有此名称的列,则将忽略此选项。默认为“idx”。

show_in_notebook(tableid=None, css=None, display_length=50, table_class='astropy-default', show_row_index='idx')[源代码]

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

参数
tableidSTR或无

表的htmlid标记。默认为 table{{id}}-XXX ,其中id是表对象的唯一整数id,id(self),XXX是一个随机数,以避免多次打印同一个表时发生冲突。

table_classSTR或无

包含用于设置表样式的HTML类列表的字符串。特殊的默认字符串(“astropy-default”)表示将从配置项中检索该字符串 astropy.table.default_notebook_table_class . 请注意,这些表类可能会使用引导,因为这是随笔记本一起加载的。看到了吗 this page 对于类列表。

cssSTR

声明表格式的有效CSS字符串。默认为 astropy.table.jsviewer.DEFAULT_CSS_NB .

display_length可选的

要显示的数字或行。默认为50。

show_row_indexstr或False

如果计算结果不为False,则具有给定名称的列将添加到显示的表的版本中。这个新列显示表本身中行的索引,即使所显示的表被另一列重新排序。请注意,如果已存在具有此名称的列,则将忽略此选项。默认为“idx”。

笔记

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

sort(keys=None, reverse=False)[源代码]

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

参数
keysstr或str列表

表排序依据的键。如果没有,则使用表的主索引。

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)[源代码]

返回A pandas.DataFrame 实例

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

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

参数
index没有,布尔,斯特朗

指定数据帧索引模式

use_nullable_int布尔,默认值=真

将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
values()[源代码]
values_equal(other)[源代码]

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

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

参数
other表状对象、列表或标量

对象与表进行比较

实例

比较一张表和另一张表:

>>> 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