表を構築する

最初にテーブルを構築する方式には大きな柔軟性がある.入力については Table そして QTable 構造関数位置 Initialization Details 一節です。しかしながら、テーブルをどのように作成するかを理解する最も良い方法は、例を通過することである。

実例.

柔軟性は，表データを初期化するために利用可能なデータ構造タイプに大きく依存する.以下の例は、初期データのないテーブルを最初から作成する方法と、リスト、列辞書、または作成テーブルからどのように使用するかを示しています。 numpy 配列(構造化または同構造).

布設.

For the following examples you need to import the QTable, Table, and Column classes along with the 単位と数量 (astropy.units ） package and the numpy package:

>>> from astropy.table import QTable, Table, Column
>>> from astropy import units as u
>>> import numpy as np

最初から作る

テーブルは、初期入力データがなくても初期列がない場合に作成することができる。初期サイズ，列，またはデータが未知であれば，これは動的に表を構築するのに有用である.

注釈

行を追加するたびにテーブル全体の新しいコピーを作成する必要があるため、大型テーブルの場合、このプロセスが遅くなる可能性があります。一方，追加列は速い.

>>> t = Table()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0]
>>> t['c'] = ['x', 'y']

>>> t = Table(names=('a', 'b', 'c'), dtype=('f4', 'i4', 'S2'))
>>> t.add_row((1, 2.0, 'x'))
>>> t.add_row((4, 5.0, 'y'))

>>> t = Table(dtype=[('a', 'f4'), ('b', 'i4'), ('c', 'S2')])

データ列がそれに関連する物理ユニットを持っている場合は、使用をお勧めします QTable 級友たち。これにより，この列をネイティブ列としてテーブルに格納することができる. Quantity 全力を尽くしたのは 単位と数量 (astropy.units ） テーブルに座る。**

>>> t = QTable()
>>> t['a'] = [1, 4]
>>> t['b'] = [2.0, 5.0] * u.cm / u.s
>>> t['c'] = ['x', 'y']
>>> type(t['b'])
<class 'astropy.units.quantity.Quantity'>

列のリスト

典型的には，異なる変数に同じ長さのデータ列が多く定義されている.これらはPythonリストや numpy 配列または両者の混合。これらは作成に使うことができます Table 列データ変数をPythonリストに入れます。この場合，列名は入力データによって定義されないため，使用しなければならない. names キーワードでなければ自動的に生成されます col<N> それがそうです。

>>> a = np.array([1, 4], dtype=np.int32)
>>> b = [2.0, 5.0]
>>> c = ['x', 'y']
>>> t = Table([a, b, c], names=('a', 'b', 'c'))
>>> t
<Table length=2>
  a      b     c
int32 float64 str1
----- ------- ----
    1     2.0    x
    4     5.0    y

最初の表の列を使用して新しい表を作成する

もしあなたが1つ持ったら Table そして、列を選択してPythonリストに入れることができます(例えば、 [ t['c'], t['a'] ] )：

>>> Table([t['c'], t['a']])
<Table length=2>
 c     a
str1 int32
---- -----
   x     1
   y     4

列に関する式を使用して新しい表を作成する

♪the Column 対象派生自己標準 numpy 配列は，算術式で直接用いることができる.これにより、修正された列値を有する新しいテーブルをコンパクトな方法で作成することができる。

>>> Table([t['a']**2, t['b'] + 10])
<Table length=2>
  a      b
int32 float64
----- -------
    1    12.0
   16    15.0

異なるタイプの列データ

本発明は、リスト入力方法を開示する。 Table 表を初期化するために異なるデータタイプを混合して使用することができるので、非常に柔軟です。

>>> a = (1, 4)
>>> b = np.array([[2, 3], [5, 6]])  # vector column
>>> c = Column(['x', 'y'], name='axis')
>>> arr = (a, b, c)
>>> Table(arr)  
<Table length=2>
 col0 col1 [2] axis
int64  int64   str1
----- -------- ----
    1   2 .. 3    x
    4   5 .. 6    y

なお、第3列では、既存の列名 'axis' 全部使っています。

作った辞書

列データ辞書は初期化に使用することができる Table それがそうです。

>>> arr = {'a': np.array([1, 4], dtype=np.int32),
...        'b': [2.0, 5.0],
...        'c': ['x', 'y']}
>>>
>>> Table(arr)  
<Table length=2>
  a    c      b
int32 str1 float64
----- ---- -------
    1    x     2.0
    4    y     5.0

列順序およびデータタイプの指定(オプション) **

>>> Table(arr, names=('a', 'b', 'c'), dtype=('f8', 'i4', 'S2'))  
<Table length=2>
   a      b    c
float64 int32 str2
------- ----- ----
    1.0     2    x
    4.0     5    y

異なるタイプの列データ

入力列データは任意に初期化することができます Column 対象：：

>>> arr = {'a': (1, 4),
...        'b': np.array([[2, 3], [5, 6]]),
...        'c': Column(['x', 'y'], name='axis')}
>>> Table(arr, names=('a', 'b', 'c'))  
<Table length=2>
  a   b [2]   c
int64 int64  str1
----- ------ ----
    1 2 .. 3    x
    4 5 .. 6    y

注意してください、鍵 'c' 既存の列名を優先する 'axis' 第三欄にあります。また注意してください。 'b' 列は、各行要素自体が2つの要素からなる配列であるベクトル列である。

重任することはできない **

>>> Table(arr, names=('a_new', 'b_new', 'c_new'))
Traceback (most recent call last):
  ...
KeyError: 'a_new'

行データ.

行指向のデータはご利用いただけます rows キーワードパラメータ。

リストまたはタプルの形態のデータレコードリスト

行指向の入力データ(レコードリストのような)があれば、使用する必要があります rows 表を作成するキーワード：

>>> data_rows = [(1, 2.0, 'x'),
...              (4, 5.0, 'y'),
...              (5, 8.2, 'z')]
>>> t = Table(rows=data_rows, names=('a', 'b', 'c'))
>>> print(t)
 a   b   c
--- --- ---
  1 2.0   x
  4 5.0   y
  5 8.2   z

として rows パラメータは np.rec.fromrecords() 機能します。

DICTオブジェクトリスト

また、行値初期化テーブルを使用することができます。これはDICTオブジェクトのリストとして構成されている.キー決定列名：

>>> data = [{'a': 5, 'b': 10},
...         {'a': 15, 'b': 20}]
>>> t = Table(rows=data)
>>> print(t)
 a   b
--- ---
  5  10
 15  20

1行または複数行にキーが欠落している場合、対応する値は欠落(マスク)：としてマークされる。

>>> t = Table(rows=[{'a': 5, 'b': 10}, {'a': 15, 'c': 50}])
>>> print(t)
 a   b   c
--- --- ---
  5  10  --
 15  --  50

以下の命令を用いて列順序を保持することも可能である. OrderedDict それがそうです。もし最初のプロジェクトが OrderedDict 順番を保留します

>>> from collections import OrderedDict
>>> row1 = OrderedDict([('b', 1), ('a', 0)])
>>> row2 = OrderedDict([('b', 11), ('a', 10)])
>>> rows = [row1, row2]
>>> Table(rows=rows, dtype=('i4', 'i4'))
<Table length=2>
  b     a
int32 int32
----- -----
    1     0
   11    10

単行.

既存のフォームの単行から新しいフォームを作成することもできます：

>>> a = [1, 4]
>>> b = [2.0, 5.0]
>>> t = Table([a, b], names=('a', 'b'))
>>> t2 = Table(rows=t[1])

覚えておいてください Row 新たに作成された Table その長さは1です。これはスカラー間の違いに似ている 1 (長さ0)と1つの配列、例えば np.array([1]) 長さは1である.

注釈

入力データを辞書リストまたは単一として Table はい、データを data このような形はいつも曖昧ではないからです例えば Table([{{'a': 1}}, {{'a': 2}}]) 受け入れられています。しかし、常に使わなければなりません rows キーワード、そうでなければ、それは列のリストとして解釈されるだろう。

NumPy構造化配列

構造化配列は中の標準機構である. `numpy ` for storing heterogeneous table data. Most scientific I/O packages that read table files (e.g., astropy.io.fits, astropy.io.votable, and asciitable) 構造化配列に基づくオブジェクトに表を返す.構造化配列は、以下のコマンドを使用して作成することができる：

>>> arr = np.array([(1, 2.0, 'x'),
...                 (4, 5.0, 'y')],
...                dtype=[('a', 'i4'), ('b', 'f8'), ('c', 'S2')])

従 arr それに応じたものを作ることができます Table 対象：：

>>> Table(arr)  
<Table length=2>
  a      b     c
int32 float64 str2
----- ------- ----
    1     2.0    x
    4     5.0    y

上の例とほとんどの下の例では、表を作成し、対話型Pythonインタプリタにこのテーブルを印刷して、私たちが何を生成したのかを確認することを直ちに要求します。実際のコードでは、以下の動作が実行される場合があります。

>>> table = Table(arr)
>>> print(table)
 a   b   c
--- --- ---
  1 2.0   x
  4 5.0   y

新列名.

列名は元の値から変更できます。方法は提供されます。 names 論拠：：

>>> Table(arr, names=('a_new', 'b_new', 'c_new'))  
<Table length=2>
a_new  b_new  c_new
int32 float64  str2
----- ------- -----
    1     2.0     x
    4     5.0     y

新しいデータタイプ

同様に，以下のコマンドを用いて列ごとのデータタイプを変更することができる. dtype **

>>> Table(arr, dtype=('f4', 'i4', 'S4'))  
<Table length=2>
   a      b    c
float32 int32 str4
------- ----- ----
    1.0     2    x
    4.0     5    y

>>> Table(arr, names=('a_new', 'b_new', 'c_new'), dtype=('f4', 'i4', 'S4'))  
<Table length=2>
 a_new  b_new c_new
float32 int32  str4
------- ----- -----
    1.0     2     x
    4.0     5     y

NumPyアイソフォーム

A `numpy `1 D配列は、単一行テーブルとみなされ、配列の各要素は列に対応する：

>>> Table(np.array([1, 2, 3]), names=['a', 'b', 'c'], dtype=('i8', 'i8', 'i8'))
<Table length=1>
  a     b     c
int64 int64 int64
----- ----- -----
    1     2     3

A `numpy 2 D配列(すべての要素が同じタイプを有する)に変換することもできる |Table| それがそうです。この場合，列名はデータによって指定されるのではなく，ユーザが提供しなければならないか，あるいは自動的に生成される. ``col<N>` どこだ？ <N> 列番号です。

自動列名の基本例 **

>>> arr = np.array([[1, 2, 3],
...                 [4, 5, 6]], dtype=np.int32)
>>> Table(arr)
<Table length=2>
 col0  col1  col2
int32 int32 int32
----- ----- -----
    1     2     3
    4     5     6

指定された列名とタイプ **

>>> Table(arr, names=('a_new', 'b_new', 'c_new'), dtype=('f4', 'i4', 'S4'))  
<Table length=2>
 a_new  b_new c_new
float32 int32  str4
------- ----- -----
    1.0     2     3
    4.0     5     6

元のデータを引用する

データタイプが変化しない限り、同種の配列の元のデータを参照することができる：

>>> t = Table(arr, copy=False)

Python arrays versus ```numpy``` arrays as input

少し微妙な問題があります理解しなければならないのは Table オブジェクトを作成します。Pythonリスト(タプルを含む)のように見えるすべてのデータ入力は、列のリストとみなされます。対照的に同質化したのは `numpy `配列入力は行リストとして解釈される：：

>>> arr = [[1, 2, 3],
...        [4, 5, 6]]
>>> np_arr = np.array(arr)

>>> print(Table(arr))    # Two columns, three rows
col0 col1
---- ----
   1    4
   2    5
   3    6

>>> print(Table(np_arr))  # Three columns, two rows
col0 col1 col2
---- ---- ----
   1    2    3
   4    5    6

2 Dの自然な解釈を残しながら柔軟なリスト入力をサポートするためにはこの二分法が必要である `numpy `配列であって、第1のインデックスはデータ“行”に対応し、第2のインデックスはデータ“列”に対応する。

既存の表から

新しいテーブルは、既存のテーブル内の列のサブセットを選択することによって作成することができる：

>>> t = Table(names=('a', 'b', 'c'))
>>> t['c', 'b', 'a']  # Makes a copy of the data
<Table length=0>
   c       b       a
float64 float64 float64
------- ------- -------

方法のもう一つの使用方法。 columns 属性(ある) TableColumns 節)に新しい表を初期化する.これにより、列の数字インデックスまたは名前に応じて列を選択し、スライス文法をサポートすることができます。

>>> Table(t.columns[0:2])
<Table length=0>
   a       b
float64 float64
------- -------

>>> Table([t.columns[0], t.columns['c']])
<Table length=0>
   a       c
float64 float64
------- -------

空(行なし)の既存テーブルのコピーを作成するには、以下の動作を実行してください。

>>> t = Table([[1.0, 2.3], [2.1, 3]], names=['x', 'y'])
>>> t
<Table length=2>
   x       y
float64 float64
------- -------
    1.0     2.1
    2.3     3.0

>>> tcopy = t[:0].copy()
>>> tcopy
<Table length=0>
   x       y
float64 float64
------- -------

既知の大きさの空配列

もしあなたが確かに表の大きさを知っていますが、これらの値を事前に知らなければ、ゼロにすることができます numpy 配列して生成する astropy その中の表：

>>> N = 3
>>> dtype = [('a', 'i4'), ('b', 'f8'), ('c', 'bool')]
>>> t = Table(data=np.zeros(N, dtype=dtype))
>>> t
<Table length=3>
  a      b      c
int32 float64  bool
----- ------- -----
    0     0.0 False
    0     0.0 False
    0     0.0 False

例えば、このテーブルは、その後、別のテーブルから抽出された値または動的に生成された値を使用してプログレッシブに充填されてもよい：

>>> for i in range(len(t)):
...     t[i] = (i, 2.5*i, i % 2)
>>> t
<Table length=3>
  a      b      c
int32 float64  bool
----- ------- -----
    0     0.0 False
    1     2.5  True
    2     5.0 False

パンダデータフレーム

以下の部分について パンダセットとドッキングします 初期化の方法について提供します Table 使用 pandas.DataFrame via the from_pandas class method. This provides a convenient way to take advantage of the many I/O and table manipulation methods in pandas それがそうです。

注釈行.

ASCIIファイル中のコメント行は 'comments' 表のメタデータを入力する.以下のコードは、出力ASCIIファイルに2つの注釈行を挿入します。 comment=False 明示的設定 write() **

>>> import sys
>>> from astropy.table import Table
>>> t = Table(names=('a', 'b', 'c'), dtype=('f4', 'i4', 'S2'))
>>> t.add_row((1, 2.0, 'x'))
>>> t.meta['comments'] = ['Here is my explanatory text. This is awesome.',
...                       'Second comment line.']
>>> t.write(sys.stdout, format='ascii')
# Here is my explanatory text. This is awesome.
# Second comment line.
a b c
1.0 2 x

詳細を初期化する

表オブジェクトは初期化により Table 以下のパラメータを有するクラスオブジェクトは、これらのすべてのパラメータがオプションである：

dataNumpy ndarray、dict、List、Tableまたはtable-likeオブジェクト、オプション

初期化表のデータをお願いします。

maskedブル値、オプション

表がマスクされているかどうかを指定する.

namesリスト、オプション

列名を指定する。

dtypeリスト、オプション

列データタイプを指定します。

metaDICT、オプション

表に関連するメタデータ.

copyブル値、オプション

入力データをコピーする。入力が表であれば meta いつもコピーされています copy パラメータです。デフォルト値はTrueである.

rowsNumpy ndarray、リスト、オプション

表の行指向データは data 論争する。

copy_indicesブル値、オプション

入力データ中のすべてのインデックスをコピーする.デフォルト値はTrueである.

unitsリスト、辞書、オプション

列の単位リストや辞書に適用する.

descriptionsリスト、辞書、オプション

列の説明リストや辞書に適用する.

**kwargsDICT、オプション

表状オブジェクトを変換する際のキーワードパラメータを付加する.

サブ部分は、新しいキーワードパラメータを作成するために使用可能な各キーワードパラメータの値およびオプションに関するより多くの詳細な情報を提供する Table 物体です。

データ.データ

♪the Table オブジェクトは以下のような異なる形式で初期化することができる. data 論争する。

``numpy`` ndarray (structured array)

基本列名は data 構造化配列.♪the names リスト(オプション)は、特定のフィールドを選択し、および/または基本名を再順序付けするために使用されてもよい。♪the dtype リスト(オプション)の長さは names 既存のものを書き換えるために使われています data タイプです。

``numpy`` ndarray (homogeneous)

もし data Ndarrayは1次元であり、配列の各要素が1つの列に対応する単行テーブルとみなされる。

もし data Ndarrayは少なくとも2次元であり、第1の(最も左の)インデックスは行番号(テーブル長)に対応し、第2のインデックスは列番号(テーブル幅)に対応する。各フォームメタ格の形状はより高い次元を吸収している.

提供すれば names リストは data 論争する。のデフォルト設定 names フォームに列名を自動生成する col<N> それがそうです。提供すれば dtype Listは基本列タイプをカバーし、必ず names それがそうです。

dict-like

のキーワードです。 data オブジェクトは基本列名を定義する.その値は Column 相手は、 numpy 配列または類似リストのオブジェクト。♪the names リスト(オプション)は、特定のフィールドを選択し、および/または基本名を再順序付けするために使用されてもよい。♪the dtype リスト(オプション)の長さは names 既存またはデフォルトのデータ·タイプをカバーするために使用されます。

list-like

すべての項目 data Listがデータ値を提供する列は、 Column 相手は、 numpy 配列または類似リストのオブジェクト。♪the names リストは列ごとの名前を定義する.名前が提供されていない場合は、名前が自動的に生成されます(スレーブ names パラメータや押し Column 対象)。提供すれば names パラメータは data リストです。任意選択. dtype リストは既存またはデフォルトのデータタイプをカバーし、一致しなければなりません。 names 長さの上にあります。

list-of-dicts

Pythonの内蔵のようなものです csv.DictReader すべての項目 data Listはデータ値を1行提供し、辞書でなければならない。各辞書のキー値は列名を定義し、各行は同じ列名を有していなければならない。♪the names 列ソートを指定するためにパラメータを提供することができる.提供されていない場合、列順序はデフォルトでアルファベット順序となる。もし最初のプロジェクトが OrderedDict また，列順序を保持する.♪the dtype リストを指定することができ，出力列の順序に対応しなければならない.いずれの行の鍵が残りの行と一致しなければ，ValueErrorが投げられる.

table-like object

他の類似表のオブジェクトが __astropy_table__ 方法は、オブジェクトを使用して直接作成することができます Table 相手。ご参照ください Table-like objects 詳しい情報を部分的に知っています。

None

ゼロ長テーブルを初期化します。もし…。 names 任意に dtype 対応する列を作成します。

名

♪the names パラメータは、テーブル名を指定するか、または既存の列名を上書きする方法を提供する。デフォルトの場合、列名は既存の名前から取られる(場合は ndarray あるいは…。 Table 入力したり自動生成したりすることができます col<N> それがそうです。もし names これは，長さが列数と同じリストでなければならない.値を持つリスト要素は None デフォルトの名前に戻ります。

以下の場合 data 列辞書の形で提供されています names 列の順序を指定するためにパラメータを提供することができる.♪the names リストに含まれなければなりません data ディクト。もし…。 names この場合，出力表中の列順序は決定されない.

D型.

♪the dtype パラメータは、リストデータのタイプを指定するか、または既存のタイプを書き換える方法を提供する。デフォルトの場合、これらのタイプは、既存のタイプから取られるか(場合) ndarray あるいは…。 Table 入力)または numpy.array() 日常的な仕事。もし…。 dtype これは，長さが列数と同じリストでなければならない.値は有効でなければならない numpy.dtype 初期値設定項または None それがそうです。値を持つリスト要素は None デフォルトタイプに戻ります。

以下の場合 data 列辞書の形で提供されています dtype パラメータはそれに対応しなければならない names 列順序を一意に指定するためにパラメータを指定する.

メタ.

♪the meta パラメータは，表に関連するメタデータを含むオブジェクトである.この対象を辞書や OrderedDict, しかし唯一の明確な要求は標準ライブラリと一緒にコピーできるということです copy.deepcopy() 日常的な仕事。デフォルトの場合、 meta 空だった OrderedDict.

コピー.コピー

デフォルトの場合、入力 data 新しい内部にコピーされます np.ndarray 対象中の Table 相手。以下の場合 data これは np.ndarray 対象は、 dict あるいは既存の Table 既存のデータへの参照は、設定によって使用することができる copy=False それがそうです。これは，メモリ使用を削減し，より高速であるという利点がある.しかし、あなたは気をつけなければなりません。新しいのには Table 元の入力データにもデータが見られる.ご参照ください Copy versus Reference 部分的にもっと情報を知っています。

はい。

このパラメータは、行シーケンスの形態でデータを提供することを可能にする。 data キーワードは、通常、データが一連の列であると仮定する。♪the Row data 一部は詳細な情報を提供している。

copy_indices

テーブルインデックスが定義された別のテーブルからテーブルを初期化する場合、このオプションは、テーブルのコピーを可能にする。 もしなければ インデックスのコピーを設定することで copy_indices=False それがそうです。デフォルトの場合、インデックスをコピーします。

職場.職場.

これにより、テーブルを作成する際に1つまたは複数の列の単位を設定することができる。入力は、表中の各列に対応する単位値リストであってもよい(使用 None あるいは…。 '' 無単位を表す)、または dict これは列名を指定する単位を提供する.例えば：

>>> from astropy.table import QTable
>>> dat = [[1, 2], ['hello', 'world']]
>>> qt = QTable(dat, names=['a', 'b'], units=(u.m, None))
>>> qt = QTable(dat, names=['a', 'b'], units={'a': u.m})

説明する.

これにより、テーブルを作成する際に1つまたは複数の列の説明を設定することができる。入力は、テーブルの各列に対応する記述値リストであってもよい(使用 None 無説明のための)、または dict これは列名を指定する説明を提供する.その働き方と units 上の例です。

複製と引用

一般的に新しいのは Table オブジェクトは，入力データは コピーされました 新しい内部配列オブジェクトに変換する.これは、新しいテーブル要素が修正される場合、元のデータが影響を受けないことを保証する。しかし私たちが numpy Ndarrayオブジェクト(構造化または同構造)またはDICTでは、元のデータへのメモリ参照を使用するように変更するために、複製を無効にすることができる。このようにする利点は，より高速であり，使用メモリが少ないことである.しかし，次の図に示すように，新たなテーブルデータとオリジナルデータがリンクされていることに注意されたい.

>>> arr = np.array([(1, 2.0, 'x'),
...                 (4, 5.0, 'y')],
...                dtype=[('a', 'i8'), ('b', 'f8'), ('c', 'S2')])
>>> print(arr['a'])  # column "a" of the input array
[1 4]
>>> t = Table(arr, copy=False)
>>> t['a'][1] = 99
>>> print(arr['a'])  # arr['a'] got changed when we modified t['a']
[ 1 99]

データを参照する場合、データをコピーする必要があるので、データタイプを変更することは不可能であることに留意されたい。この場合、エラーが発生します：

>>> t = Table(arr, copy=False, dtype=('f4', 'i4', 'S4'))
Traceback (most recent call last):
  ...
ValueError: Cannot specify dtype when copy=False

参照データを使用する別の注意事項は、表に新しい行が追加されると、元のデータ配列への参照が失われ、元の値のコピーが保持される(新しい行を除いて)表現されることである。

ColumnとTable Columnsクラス

2つのクラスがあります Column そして TableColumns これらは新しい表を構築する際に有用である.

列

A Column オブジェクトは以下のように作成することができ、すべての場合、列 name キーワードパラメータとして提供されるべきであり、以下の値を提供することを選択することができます。

dataリスト、ndarray、またはなし

列データ値。

dtypeNumpy.dtype互換値

列のデータタイプ。

description応力.応力

列の完全な記述。

unit応力.応力

物理ユニットです。

format文字列や関数

Format specifier 列値を出力するために用いられる.

metaディクト！

列に関連するメタデータ.

初期化オプション

列データ値、形状、データタイプは、以下の2つの方法のうちの1つによって指定される。

Provide a ``data`` value but not a ``length`` or ``shape``

例：

col = Column([1, 2], name='a')  # shape=(2,)
col = Column([[1, 2], [3, 4]], name='a')  # shape=(2, 2)
col = Column([1, 2], name='a', dtype=float)
col = Column(np.array([1, 2]), name='a')
col = Column(['hello', 'world'], name='a')

♪the dtype パラメータは、許容可能な固定サイズデータタイプの初期値設定項である任意の値であってもよい。 numpy.dtype() 方法です。参考資料をご参照ください data type objects それがそうです。例は以下のとおりである.

• Python非文字列タイプ(浮動小数点型、整数型、ブール型)。

• numpy 非文字列タイプ(例えばnp.float 32，np.int 64)である.

• numpy.dtype 配列プロトコルタイプ文字列(例えば、‘i 4’，‘f 8’，‘s 15’).

もしなければ dtype 値は使用する np.array(data) それがそうです。いつ？ data 提供されると shape そして length パラメータは無視される.

Provide ``length`` and optionally ``shape``, but not ``data``

例：

col = Column(name='a', length=5)
col = Column(name='a', dtype=int, length=10, shape=(3,4))

デフォルト設定 dtype はい。 np.float64 それがそうです。♪the shape パラメータは列中の個々のセルの配列形状である.デフォルト設定 shape Is()は，各要素に1つの値しかないことを表す.

注釈

列のタイプを設定すると、このタイプは変更できません。異なるタイプのデータ値が列に割り当てられた場合、それらは既存の列タイプに変換される。

書式説明子

フォームまたは列がASCIIフォームに印刷または書き込まれると、フォーマット説明子は列値の出力を制御する。最も簡単な場合にはPython内蔵文字列に渡すことができます format 機能します。より複雑なフォーマットについては、“old style”または“new style”フォーマットの文字列を与えることもでき、関数を与えることもできる：

普通格式仕様

このタイプの文字列は、どのように使用すべきかを直接指定します format specification mini-language これはCとです。

".4f" 浮動小数点形式の小数点以下で4桁、または

"6d" 整数は、6文字のフィールドに提供される。

旧型形式文字列

これは次のような文法に対応する "%.4f" % value 中で述べたとおり printf-style String Formatting それがそうです。

"%.4f" 小数点以下の4桁を浮動小数点形式で印刷するには

"%6d" 6文字幅のフィールドに整数を印刷するには、以下の操作を実行してください。

新しいスタイル形式文字列

これは次のような文法に対応する "{{:.4f}}".format(value) 中で述べたとおり format string syntax それがそうです。

"{{:.4f}}" 小数点以下の4桁を浮動小数点形式で印刷するには

"{{:6d}}" 6文字幅のフィールドに整数を印刷するには、以下の操作を実行してください。

いずれのフォーマット文字列の場合も、1つの値フォーマットのみを設定するPython文字列が有効であるため、 {{:.4f}} angstroms あるいは…。 Value: %12.2f どちらも効果があります

Function

フォーマット機能を設定することで最大の柔軟性を実現することができる.この関数は，単一のパラメータ(値)を受け取り，文字列を返さなければならない.以下の例では、これは、LaTeX準備出力を生成するために使用される。

>>> t = Table([[1,2],[1.234e9,2.34e-12]], names = ('a','b'))
>>> def latex_exp(value):
...     val = f'{value:8.2}'
...     mant, exp = val.split('e')
...     # remove leading zeros
...     exp = exp[0] + exp[1:].lstrip('0')
...     return f'$ {mant} \\times 10^{{ {exp} }}$'
>>> t['b'].format = latex_exp
>>> t['a'].format = '.4f'
>>> import sys
>>> t.write(sys.stdout, format='latex')
\begin{table}
\begin{tabular}{cc}
a & b \\
1.0000 & $  1.2 \times 10^{ +9 }$ \\
2.0000 & $  2.3 \times 10^{ -12 }$ \\
\end{tabular}
\end{table}

TableColumns

個々 Table オブジェクトには属性があります columns これは規則的な辞書で全てを保存しています Column 表中のオブジェクト(別途参照) Column 第(1)項。技術的には columns 属性は1つです TableColumns 拡張された秩序辞書であるオブジェクトであり、より簡単に多列を選択する方法を提供する。覚えておくべき重要な点がいくつかあります

• A Table できるのは TableColumns オブジェクト(Copyは常にTrue)。

• リストから複数の列を選択する TableColumns オブジェクトは別のものに戻る TableColumns 物体です。

• リストから一列を選ぶ TableColumns オブジェクトが1つに戻る Column それがそうです。

ではこれを見てみましょう TableColumns 目標：

名前別に列を選択する **

>>> t = Table(names=('a', 'b', 'c', 'd'))

>>> t.columns['d', 'c', 'b']
<TableColumns names=('d','c','b')>

インデックススライスにより列を選択する **

>>> t.columns[0:2]  # Select first two columns
<TableColumns names=('a','b')>

>>> t.columns[::-1]  # Reverse column order
<TableColumns names=('d','c','b','a')>

索引または名称別に列を選択する **

>>> t.columns[1]  # Choose columns by index
<Column name='b' dtype='float64' length=0>

>>> t.columns['b']  # Choose column by name
<Column name='b' dtype='float64' length=0>

サブクラス化表

いくつかのアプリケーションでは Table クラスは専門化行為を導入する.ここでは，カスタム表属性の追加と内部クラスオブジェクトの変更という2つの特定の用例をサブクラス化する2つの特定の用例について議論する.

カスタム表のプロパティの追加

有用である可能性のある簡単なカスタマイズは、表オブジェクトに新しい属性を追加することです。既存の表オブジェクトに属性を設定することを阻止することは何もありません t.foo = 'hello' それがそうです。しかし，この属性は一時的であり，表に対してスライス，複製，酸洗を行うと，その属性が失われるためである.逆に、本例に示すように、持続的な属性を追加することができます。

from astropy.table import Table, TableAttribute

class MyTable(Table):
    foo = TableAttribute()
    bar = TableAttribute(default=[])
    baz = TableAttribute(default=1)

t = MyTable([[1, 2]], foo='foo')
t.bar.append(2.0)
t.baz = 'baz'

いくつかのポイントは

• 表作成時にカスタム属性を設定してもよいし、設定対象属性の常用文法を用いてカスタム属性を設定してもよい。

• カスタム属性は常にデフォルト値を持つか，クラス定義で明示的に設定するか，または None それがそうです。

• 属性値は表に格納されている meta 辞書です。これは，複製，スライス，シーケンス化(例えば，酸洗やECSV ASCIIファイルへの書き込み)によって不変である機構である.

内部クラスオブジェクトの変更行為

It is also possible to change the behavior of the internal class objects which are contained or created by a Table. This includes rows, columns, formatting, and the columns container. In order to do this the subclass needs to declare what class to use (if it is different from the built-in version). This is done by specifying one or more of the class attributes Row, Column, MaskedColumn, TableColumns, or TableFormatter.

以下の簡単な例は、これらのサブクラスのすべてを何もしないサブクラスでカバーしていますが、実際には必要なサブコンポーネントのみをカバーする必要があります。

>>> from astropy.table import Table, Row, Column, MaskedColumn, TableColumns, TableFormatter

>>> class MyRow(Row): pass
>>> class MyColumn(Column): pass
>>> class MyMaskedColumn(MaskedColumn): pass
>>> class MyTableColumns(TableColumns): pass
>>> class MyTableFormatter(TableFormatter): pass

>>> class MyTable(Table):
...     """
...     Custom subclass of astropy.table.Table
...     """
...     Row = MyRow  # Use MyRow to create a row object
...     Column = MyColumn  # Column
...     MaskedColumn = MyMaskedColumn  # Masked Column
...     TableColumns = MyTableColumns  # Ordered dict holding Column objects
...     TableFormatter = MyTableFormatter  # Controls table output

例を引く

より実際的な例として、特定の固定列を含むデータテーブルがあると仮定しますが、行ごとに任意のキーワード=値パラメータ辞書を搬送し、その後、それらが列であるように、同じ項目アクセス構文を使用してこれらの値にアクセスすることも望まれます。ここでは余分なパラメータが含まれていると仮定する. numpy Object-dtype列という名前のものです params **

>>> from astropy.table import Table, Row
>>> class ParamsRow(Row):
...    """
...    Row class that allows access to an arbitrary dict of parameters
...    stored as a dict object in the ``params`` column.
...    """
...    def __getitem__(self, item):
...        if item not in self.colnames:
...            return super().__getitem__('params')[item]
...        else:
...            return super().__getitem__(item)
...
...    def keys(self):
...        out = [name for name in self.colnames if name != 'params']
...        params = [key.lower() for key in sorted(self['params'])]
...        return out + params
...
...    def values(self):
...        return [self[key] for key in self.keys()]

今私たちは些細なことでこのことを行動に移しています Table サブクラス：：

>>> class ParamsTable(Table):
...     Row = ParamsRow

まず表を作成していくつかの行を追加します：

>>> t = ParamsTable(names=['a', 'b', 'params'], dtype=['i', 'f', 'O'])
>>> t.add_row((1, 2.0, {'x': 1.5, 'y': 2.5}))
>>> t.add_row((2, 3.0, {'z': 'hello', 'id': 123123}))
>>> print(t)  
 a   b             params
--- --- ----------------------------
  1 2.0         {'y': 2.5, 'x': 1.5}
  2 3.0 {'z': 'hello', 'id': 123123}

私たちの専門家から何を得たか見てみましょう ParamsRow 対象：：

>>> t[0]['y']
2.5
>>> t[1]['id']
123123
>>> t[1].keys()
['a', 'b', 'id', 'z']
>>> t[1].values()
[2, 3.0, 123123, 'hello']

この例を本当に有用にするためには、書き換える必要があるかもしれません Table.__getitem__ テーブルレベルがパラメータフィールドにアクセスすることを可能にするために。これは似ているかもしれません

class ParamsTable(table.Table):
    Row = ParamsRow

    def __getitem__(self, item):
        if isinstance(item, str):
            if item in self.colnames:
                return self.columns[item]
            else:
                # If item is not a column name then create a new MaskedArray
                # corresponding to self['params'][item] for each row.  This
                # might not exist in some rows so mark as masked (missing) in
                # those cases.
                mask = np.zeros(len(self), dtype=np.bool_)
                item = item.upper()
                values = [params.get(item) for params in self['params']]
                for ii, value in enumerate(values):
                    if value is None:
                        mask[ii] = True
                        values[ii] = ''
                return self.MaskedColumn(name=item, data=values, mask=mask)

        # ... and then the rest of the original __getitem__ ...

欄と数

astropy Quantity オブジェクトは、2つの相補的な方法で表中で処理することができる。最初の方法は保存されています Quantity オブジェクトは“Mixin”列プロトコルにより表中でネイティブ操作を行う.ご参照ください 混合柱 そして 数量と数量表 詳細な情報を得るには簡単に言うと重要な違いは QTable 指示するように指示する. Quantity 表にはネイティブ方式で格納されています：

>>> from astropy.table import QTable
>>> from astropy import units as u
>>> t = QTable()
>>> t['velocity'] = [3, 4] * u.m / u.s
>>> type(t['velocity'])  
astropy.units.quantity.Quantity

数量知覚の新しいコードについては、使用をお勧めします QTable しかし，これはすべての場合に可能であるわけではなく(特に数のレガシーコードを処理しない場合には)，存在する. 詳細情報と注意事項 これは適用されます。この場合は、ご利用ください Table クラスは1つの Quantity 1つまで Column オブジェクト、そして使用 unit 属性：：

>>> from astropy.table import Table
>>> t = Table()
>>> t['velocity'] = [3, 4] * u.m / u.s
>>> type(t['velocity'])  
astropy.table.column.Column
>>> t['velocity'].unit
Unit("m / s")

使用基準に関する詳細を知るためには、以下の操作を実行してください Column 定義された単位を持つオブジェクトは、参照してください 単位付き柱 一節です。

机状物体

In order to improve interoperability between different table classes, an astropy Table object can be created directly from any other table-like object that provides an __astropy_table__ method. In this case the __astropy_table__ method will be called as follows:

>>> data = SomeOtherTableClass({'a': [1, 2], 'b': [3, 4]})  
>>> t = QTable(data, copy=False, strict_copy=True)  

Internally the following call will be made to ask the data object to return a representation of itself as an astropy Table, respecting the copy preference of the original call to QTable():

data.__astropy_table__(cls, copy, **kwargs)

ここ、ここ cls はい。 Table インスタンス化されているクラスまたはサブクラス( QTable この例では)、 copy 指示中の値のコピーがあるかどうか data 提供すべきであり **kwargs 無効な追加キーワードパラメータがあるかどうか Table _init_() キーワードパラメータ。上の例では strict_copy=True 最終的には **kwargs 伝えられています __astropy_table__() それがそうです。

もし copy はい。 True そして…。 __astropy_table__ 方法は、元のデータのコピーを返すことを保証しなければならない。もし…。 copy はい。 False では，可能であれば，表データの参照を返すべきである.これが不可能である場合(例えば、元のデータがPythonリストにあるか、または他の方法でメモリに変換されなければならない)。 __astropy_table__ 方法は、コピーを自由に返したり、異常を引き起こすことができる。この選択は、実装された最初のオプションに依存する。この実装は、追加を可能にするキーワードパラメータ(例えば、)を選択することができる。 strict_copy それは通過します **kwargs )は、この場合の行動を制御する。

簡明な例として、辞書に基づく表類があると仮定する。(注意してください、 Table Dictのような対象から初期化できるようになっているので、これは少しわざとらしいですが、確かに扱っている原則を説明しています)。方法サインに注意してください：

def __astropy_table__(self, cls, copy, **kwargs):

あなたのクラス実現は必ず使用しなければなりません **kwargs 最後にキーワードパラメータを捕捉する技術.これは将来他のキーワードを内部に追加することを確保するためです table = data.__astropy_table__(cls, copy) 電話します。含まれています **kwargs この場合破損を防ぐことができます。**

class DictTable(dict):
    """
    Trivial "table" class that just uses a dict to hold columns.
    This does not actually implement anything useful that makes
    this a table.

    The non-standard ``strict_copy=False`` keyword arg here will be passed
    via the **kwargs of Table __init__().
    """

    def __astropy_table__(self, cls, copy, strict_copy=False, **kwargs):
        """
        Return an astropy Table of type ``cls``.

        Parameters
        ----------
        cls : type
             Astropy ``Table`` class or subclass.
        copy : bool
             Copy input data (True) or return a reference (False).
        strict_copy : bool, optional
             Raise an exception if copy is False but reference is not
             possible.
        **kwargs : dict, optional
             Additional keyword args (ignored currently).
        """
        if kwargs:
            warnings.warn(f'unexpected keyword args {kwargs}')

        cols = list(self.values())
        names = list(self.keys())

        # If returning a reference to existing data (copy=False) and
        # strict_copy=True, make sure that each column is a numpy ndarray.
        # If a column is a Python list or tuple then it must be copied for
        # representation in an astropy Table.

        if not copy and strict_copy:
            for name, col in zip(names, cols):
                if not isinstance(col, np.ndarray):
                    raise ValueError(f'cannot have copy=False because column {name} is '
                                     'not an ndarray')

        return cls(cols, names=names, copy=copy)