| | .. include:: references.txt |
| |
|
| | .. _construct_table: |
| |
|
| | Constructing a table |
| | ******************** |
| |
|
| | There is great deal of flexibility in the way that a table can be initially |
| | constructed. Details on the inputs to the |Table| |
| | constructor are in the `Initialization Details`_ section. However, the |
| | easiest way to understand how to make a table is by example. |
| |
|
| | Examples |
| | ======== |
| |
|
| | Much of the flexibility lies in the types of data structures |
| | which can be used to initialize the table data. The examples below show how to |
| | create a table from scratch with no initial data, create a table with a list of |
| | columns, a dictionary of columns, or from `numpy` arrays (either structured or |
| | homogeneous). |
| |
|
| | Setup |
| | |
| | For the following examples you need to import the |Table| and |Column| classes |
| | along with the `numpy` package:: |
| |
|
| | >>> from astropy.table import Table, Column |
| | >>> import numpy as np |
| |
|
| | Creating from scratch |
| | |
| | A Table can be created without any initial input data or even without any |
| | initial columns. This is useful for building tables dynamically if the initial |
| | size, columns, or data are not known. |
| |
|
| | .. Note:: |
| | Adding rows requires making a new copy of the entire |
| | table each time, so in the case of large tables this may be slow. |
| | On the other hand, adding columns is reasonably fast. |
| |
|
| | :: |
| |
|
| | >>> t = Table() |
| | >>> t['a'] = [1, 4] |
| | >>> t['b'] = Column([2.0, 5.0], unit='cm', description='Velocity') |
| | >>> 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')]) |
| |
|
| | Another option for creating a table is using the `~astropy.table.QTable` class. |
| | In this case any `~astropy.units.Quantity` column objects will be stored |
| | natively within the table via the "mixin" column protocol (see `Columns and |
| | Quantities`_ for details):: |
| |
|
| | >>> from astropy.table import QTable |
| | >>> from astropy import units as u |
| | >>> t = QTable() |
| | >>> t['velocity'] = [3, 4] * u.m / u.s |
| | >>> type(t['velocity']) # doctest: +SKIP |
| | astropy.units.quantity.Quantity |
| |
|
| |
|
| | Comment lines |
| | |
| | Comment lines in an ASCII file can be added via the ``'comments'`` key in the |
| | table's metadata. The following will insert two comment lines in the output |
| | ASCII file unless ``comment=False`` is explicitly set in ``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 |
| | |
| | |
| | List of columns |
| | --------------- |
| | A typical case is where you have a number of data columns with the same length |
| | defined in different variables. These might be Python lists or `numpy` arrays |
| | or a mix of the two. These can be used to create a |Table| by putting the column |
| | data variables into a Python list. In this case the column names are not |
| | defined by the input data, so they must either be set using the ``names`` |
| | keyword or they will be auto-generated as ``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 |
| | |
| | **Make a new table using columns from the first table** |
| | |
| | Once you have a |Table| then you can make new table by selecting columns |
| | and putting this into a Python list, e.g. ``[ t['c'], t['a'] ]``:: |
| | |
| | >>> Table([t['c'], t['a']]) |
| | <Table length=2> |
| | c a |
| | str1 int32 |
| | ---- ----- |
| | x 1 |
| | y 4 |
| | |
| | **Make a new table using expressions involving columns** |
| | |
| | The |Column| object is derived from the standard `numpy` array and can be used |
| | directly in arithmetic expressions. This allows for a compact way of making a |
| | new table with modified column values:: |
| | |
| | >>> Table([t['a']**2, t['b'] + 10]) |
| | <Table length=2> |
| | a b |
| | int32 float64 |
| | ----- ------- |
| | 1 12.0 |
| | 16 15.0 |
| | |
| | |
| | **Different types of column data** |
| | |
| | The list input method for |Table| is very flexible since you can use a mix |
| | of different data types to initialize a 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) # doctest: +SKIP |
| | <Table length=2> |
| | col0 col1 [2] axis |
| | int64 int64 str1 |
| | ----- -------- ---- |
| | 1 2 .. 3 x |
| | 4 5 .. 6 y |
| | |
| | |
| | Notice that in the third column the existing column name ``'axis'`` is used. |
| | |
| | |
| | Dict of columns |
| | ---------------- |
| | A dictionary of column data can be used to initialize a |Table|. |
| | |
| | >>> arr = {'a': np.array([1, 4], dtype=np.int32), |
| | ... 'b': [2.0, 5.0], |
| | ... 'c': ['x', 'y']} |
| | >>> |
| | >>> Table(arr) # doctest: +SKIP |
| | <Table length=2> |
| | a c b |
| | int32 str1 float64 |
| | ----- ---- ------- |
| | 1 x 2.0 |
| | 4 y 5.0 |
| | |
| | **Specify the column order and optionally the data types** |
| | :: |
| | |
| | >>> Table(arr, names=('a', 'b', 'c'), dtype=('f8', 'i4', 'S2')) # doctest: +IGNORE_OUTPUT_3 |
| | <Table length=2> |
| | a b c |
| | float64 int32 str2 |
| | ------- ----- ---- |
| | 1.0 2 x |
| | 4.0 5 y |
| | |
| | **Different types of column data** |
| | |
| | The input column data can be any data type that can initialize a |Column| object:: |
| | |
| | >>> arr = {'a': (1, 4), |
| | ... 'b': np.array([[2, 3], [5, 6]]), |
| | ... 'c': Column(['x', 'y'], name='axis')} |
| | >>> Table(arr, names=('a', 'b', 'c')) # doctest: +SKIP |
| | <Table length=2> |
| | a b [2] c |
| | int64 int64 str1 |
| | ----- ------ ---- |
| | 1 2 .. 3 x |
| | 4 5 .. 6 y |
| | |
| | Notice that the key ``'c'`` takes precedence over the existing column name |
| | ``'axis'`` in the third column. Also see that the ``'b'`` column is a vector |
| | column where each row element is itself a 2-element array. |
| | |
| | **Renaming columns is not possible** |
| | :: |
| | |
| | >>> Table(arr, names=('a_new', 'b_new', 'c_new')) |
| | Traceback (most recent call last): |
| | ... |
| | KeyError: 'a_new' |
| | |
| | |
| | Row data |
| | --------- |
| | Row-oriented data can be used to create a table using the ``rows`` |
| | keyword argument. |
| | |
| | **List of data records as list or tuple** |
| | |
| | If you have row-oriented input data such as a list of records, you |
| | need to use the ``rows`` keyword to create a table:: |
| | |
| | >>> 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 |
| | |
| | The data object passed as the ``rows`` argument can be any form which is |
| | parsable by the ``np.rec.fromrecords()`` function. |
| | |
| | **List of dict objects** |
| | |
| | You can also initialize a table with row values. This is constructed as a |
| | list of dict objects. The keys determine the column names:: |
| | |
| | >>> data = [{'a': 5, 'b': 10}, |
| | ... {'a': 15, 'b': 20}] |
| | >>> Table(rows=data) # doctest: +SKIP |
| | <Table length=2> |
| | a b |
| | int64 int64 |
| | ----- ----- |
| | 5 10 |
| | 15 20 |
| | |
| | Every row must have the same set of keys or a ValueError will be thrown:: |
| | |
| | >>> t = Table(rows=[{'a': 5, 'b': 10}, {'a': 15, 'b': 30, 'c': 50}]) |
| | Traceback (most recent call last): |
| | ... |
| | ValueError: Row 0 has no value for column c |
| | |
| | You can also preserve the column order by using ``OrderedDict``. If the first item is an |
| | ``OrderedDict`` then the order is preserved: |
| | |
| | >>> 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 |
| | |
| | **Single row** |
| | |
| | You can also make a new table from a single row of an existing table:: |
| | |
| | >>> a = [1, 4] |
| | >>> b = [2.0, 5.0] |
| | >>> t = Table([a, b], names=('a', 'b')) |
| | >>> t2 = Table(rows=t[1]) |
| | |
| | Remember that a |Row| has effectively a zero length compared to the |
| | newly created |Table| which has a length of one. This is similar to |
| | the difference between a scalar ``1`` (length 0) and an array like |
| | ``np.array([1])`` with length 1. |
| | |
| | .. Note:: |
| | |
| | In the case of input data as a list of dicts or a single Table row, it is |
| | allowed to supply the data as the ``data`` argument since these forms |
| | are always unambiguous. For example ``Table([{'a': 1}, {'a': 2}])`` is |
| | accepted. However, a list of records must always be provided using the |
| | ``rows`` keyword, otherwise it will be interpreted as a list of columns. |
| | |
| | NumPy structured array |
| | ---------------------- |
| | The structured array is the standard mechanism in `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 |
| | <http://cxc.harvard.edu/contrib/asciitable/>`_) will return the table in an |
| | object that is based on the structured array. A structured array can be |
| | created using:: |
| | |
| | >>> arr = np.array([(1, 2.0, 'x'), |
| | ... (4, 5.0, 'y')], |
| | ... dtype=[('a', 'i4'), ('b', 'f8'), ('c', 'S2')]) |
| | |
| | From ``arr`` it is simple to create the corresponding |Table| object:: |
| | |
| | >>> Table(arr) # doctest: +IGNORE_OUTPUT_3 |
| | <Table length=2> |
| | a b c |
| | int32 float64 str2 |
| | ----- ------- ---- |
| | 1 2.0 x |
| | 4 5.0 y |
| | |
| | Note that in the above example and most the following ones we are creating a |
| | table and immediately asking the interactive Python interpreter to print the |
| | table to see what we made. In real code you might do something like:: |
| | |
| | >>> table = Table(arr) |
| | >>> print(table) |
| | a b c |
| | --- --- --- |
| | 1 2.0 x |
| | 4 5.0 y |
| | |
| | **New column names** |
| | |
| | The column names can be changed from the original values by providing the |
| | ``names`` argument:: |
| | |
| | >>> Table(arr, names=('a_new', 'b_new', 'c_new')) # doctest: +IGNORE_OUTPUT_3 |
| | <Table length=2> |
| | a_new b_new c_new |
| | int32 float64 str2 |
| | ----- ------- ----- |
| | 1 2.0 x |
| | 4 5.0 y |
| | |
| | |
| | **New data types** |
| | |
| | Likewise the data type for each column can by changed with ``dtype``:: |
| | |
| | >>> Table(arr, dtype=('f4', 'i4', 'S4')) # doctest: +IGNORE_OUTPUT_3 |
| | <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')) # doctest: +IGNORE_OUTPUT_3 |
| | <Table length=2> |
| | a_new b_new c_new |
| | float32 int32 str4 |
| | ------- ----- ----- |
| | 1.0 2 x |
| | 4.0 5 y |
| | |
| | |
| | NumPy homogeneous array |
| | ----------------------- |
| | A `numpy` 1-d array is treated as a single row table where each element of the |
| | array corresponds to a column:: |
| | |
| | >>> 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 array (where all elements have the same type) can also be |
| | converted into a |Table|. In this case the column names are not specified by |
| | the data and must either be provided by the user or will be automatically |
| | generated as ``col<N>`` where ``<N>`` is the column number. |
| | |
| | **Basic example with automatic column names** |
| | :: |
| | |
| | >>> 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 |
| | |
| | **Column names and types specified** |
| | :: |
| | |
| | >>> Table(arr, names=('a_new', 'b_new', 'c_new'), dtype=('f4', 'i4', 'S4')) # doctest: +IGNORE_OUTPUT_3 |
| | <Table length=2> |
| | a_new b_new c_new |
| | float32 int32 str4 |
| | ------- ----- ----- |
| | 1.0 2 3 |
| | 4.0 5 6 |
| | |
| | **Referencing the original data** |
| | |
| | It is possible to reference the original data for an homogeneous array as long |
| | as the data types are not changed:: |
| | |
| | >>> t = Table(arr, copy=False) |
| | |
| | **Python arrays versus `numpy` arrays as input** |
| | |
| | There is a slightly subtle issue that is important to understand in the way |
| | that |Table| objects are created. Any data input that looks like a Python list |
| | (including a tuple) is considered to be a list of columns. In contrast an |
| | homogeneous `numpy` array input is interpreted as a list of rows:: |
| | |
| | >>> 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 |
| | |
| | This dichotomy is needed to support flexible list input while retaining the |
| | natural interpretation of 2-d `numpy` arrays where the first index corresponds |
| | to data "rows" and the second index corresponds to data "columns". |
| | |
| | From existing table |
| | -------------------- |
| | A new table can be created by selecting a subset of columns in an existing |
| | table:: |
| | |
| | >>> 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 |
| | ------- ------- ------- |
| | |
| | An alternate way to use the ``columns`` attribute (explained in the |
| | `TableColumns`_ section) to initialize a new table. This let's you choose |
| | columns by their numerical index or name and supports slicing syntax:: |
| |
|
| | >>> 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 |
| | |
| |
|
| | To create a copy of an existing table that is empty (has no rows):: |
| |
|
| | >>> 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 |
| | |
| |
|
| | Empty array of a known size |
| | |
| |
|
| | If you do know the size your table will be, but don't know the values in |
| | advance, you can create a zeroed numpy array and build the astropy table from |
| | it:: |
| | |
| | >>> 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 example, you can then fill in this table row-by-row from extracted from another table, or generated on the fly:: |
| | |
| | >>> 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 |
| | |
| | Initialization Details |
| | ====================== |
| | |
| | A table object is created by initializing a |Table| class |
| | object with the following arguments, all of which are optional: |
| | |
| | ``data`` : numpy ndarray, dict, list, or Table |
| | Data to initialize table. |
| | ``names`` : list |
| | Specify column names |
| | ``dtype`` : list |
| | Specify column data types |
| | ``meta`` : dict-like |
| | Meta-Data associated with the table |
| | ``copy`` : boolean |
| | Copy the input data (default=True). |
| | |
| | The following subsections provide further detail on the values and options for |
| | each of the keyword arguments that can be used to create a new |Table| object. |
| | |
| | data |
| | ---- |
| | |
| | The |Table| object can be initialized with several different forms |
| | for the ``data`` argument. |
| | |
| | **numpy ndarray (structured array)** |
| | The base column names are the field names of the ``data`` structured |
| | array. The ``names`` list (optional) can be used to select |
| | particular fields and/or reorder the base names. The ``dtype`` list |
| | (optional) must match the length of ``names`` and is used to |
| | override the existing ``data`` types. |
| | |
| | **numpy ndarray (homogeneous)** |
| | If the ``data`` ndarray is 1-dimensional then it is treated as a single row |
| | table where each element of the array corresponds to a column. |
| | |
| | If the ``data`` ndarray is at least 2-dimensional then the first |
| | (left-most) index corresponds to row number (table length) and the |
| | second index corresponds to column number (table width). Higher |
| | dimensions get absorbed in the shape of each table cell. |
| | |
| | If provided the ``names`` list must match the "width" of the ``data`` |
| | argument. The default for ``names`` is to auto-generate column names |
| | in the form "col<N>". If provided the ``dtype`` list overrides the |
| | base column types and must match the length of ``names``. |
| | |
| | **dict-like** |
| | The keys of the ``data`` object define the base column names. The |
| | corresponding values can be Column objects, numpy arrays, or list-like |
| | objects. The ``names`` list (optional) can be used to select |
| | particular fields and/or reorder the base names. The ``dtype`` list |
| | (optional) must match the length of ``names`` and is used to override |
| | the existing or default data types. |
| | |
| | **list-like** |
| | Each item in the ``data`` list provides a column of data values and |
| | can be a Column object, numpy array, or list-like object. The |
| | ``names`` list defines the name of each column. The names will be |
| | auto-generated if not provided (either from the ``names`` argument or |
| | by Column objects). If provided the ``names`` argument must match the |
| | number of items in the ``data`` list. The optional ``dtype`` list |
| | will override the existing or default data types and must match |
| | ``names`` in length. |
| | |
| | **list-of-dicts** |
| | Similar to Python's builtin ``csv.DictReader``, each item in the |
| | ``data`` list provides a row of data values and must be a dict. The |
| | key values in each dict define the column names and each row must |
| | have identical column names. The ``names`` argument may be supplied |
| | to specify column ordering. If it is not provided, the column order will |
| | default to alphabetical. If the first item is an ``OrderedDict``, then the |
| | column order is preserved. The ``dtype`` list may be specified, and must |
| | correspond to the order of output columns. If any row's keys do no match |
| | the rest of the rows, a ValueError will be thrown. |
| | |
| | **table-like object** |
| | If another table-like object has a ``__astropy_table__`` method then |
| | that object can be used to directly create a ``Table`` object. See |
| | the `Table-like objects`_ section for details. |
| | |
| | **None** |
| | Initialize a zero-length table. If ``names`` and optionally ``dtype`` |
| | are provided then the corresponding columns are created. |
| | |
| | names |
| | ----- |
| | |
| | The ``names`` argument provides a way to specify the table column names or |
| | override the existing ones. By default the column names are either taken |
| | from existing names (for ``ndarray`` or ``Table`` input) or auto-generated |
| | as ``col<N>``. If ``names`` is provided then it must be a list with the |
| | same length as the number of columns. Any list elements with value |
| | ``None`` fall back to the default name. |
| | |
| | In the case where ``data`` is provided as dict of columns, the ``names`` |
| | argument can be supplied to specify the order of columns. The ``names`` list |
| | must then contain each of the keys in the ``data`` dict. If ``names`` is not |
| | supplied then the order of columns in the output table is not determinate. |
| | |
| | dtype |
| | ----- |
| | |
| | The ``dtype`` argument provides a way to specify the table column data |
| | types or override the existing types. By default the types are either |
| | taken from existing types (for ``ndarray`` or ``Table`` input) or |
| | auto-generated by the ``numpy.array()`` routine. If ``dtype`` is provided |
| | then it must be a list with the same length as the number of columns. The |
| | values must be valid ``numpy.dtype`` initializers or ``None``. Any list |
| | elements with value ``None`` fall back to the default type. |
| | |
| | In the case where ``data`` is provided as dict of columns, the ``dtype`` argument |
| | must be accompanied by a corresponding ``names`` argument in order to uniquely |
| | specify the column ordering. |
| | |
| | meta |
| | ---- |
| | |
| | The ``meta`` argument is simply an object that contains meta-data associated |
| | with the table. It is recommended that this object be a dict or |
| | OrderedDict_, but the only firm requirement is that it can be copied with |
| | the standard library ``copy.deepcopy()`` routine. By default ``meta`` is |
| | an empty OrderedDict_. |
| | |
| | copy |
| | ---- |
| | |
| | By default the input ``data`` are copied into a new internal ``np.ndarray`` |
| | object in the Table object. In the case where ``data`` is either an |
| | ``np.ndarray`` object, a ``dict``, or an existing ``Table``, it is possible to use a |
| | reference to the existing data by setting ``copy=False``. This has the |
| | advantage of reducing memory use and being faster. However one should take |
| | care because any modifications to the new Table data will also be seen in the |
| | original input data. See the `Copy versus Reference`_ section for more |
| | information. |
| | |
| | |
| | .. _copy_versus_reference: |
| | |
| | Copy versus Reference |
| | ===================== |
| | |
| | Normally when a new |Table| object is created, the input data are *copied* into |
| | a new internal array object. This ensures that if the new table elements are |
| | modified then the original data will not be affected. However, when creating a |
| | table from a numpy ndarray object (structured or homogeneous) or a dict, it is possible to |
| | disable copying so that instead a memory reference to the original data is |
| | used. This has the advantage of being faster and using less memory. However, |
| | caution must be exercised because the new table data and original data will be |
| | linked, as shown below:: |
| | |
| | >>> 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] |
| | |
| | Note that when referencing the data it is not possible to change the data types |
| | since that operation requires making a copy of the data. In this case an error |
| | occurs:: |
| | |
| | >>> t = Table(arr, copy=False, dtype=('f4', 'i4', 'S4')) |
| | Traceback (most recent call last): |
| | ... |
| | ValueError: Cannot specify dtype when copy=False |
| | |
| | Another caveat in using referenced data is that you if add a new row to the |
| | table then the reference to the original data array is lost and instead the |
| | table will now hold a copy of the original values (in addition to the new row). |
| | |
| | Column and TableColumns classes |
| | =============================== |
| | |
| | There are two classes, |Column| and |TableColumns|, that are useful when |
| | constructing new tables. |
| | |
| | Column |
| | ------ |
| | |
| | A |Column| object can be created as follows, where in all cases the column |
| | ``name`` should be provided as a keyword argument and one can optionally provide |
| | these values: |
| | |
| | ``data`` : list, ndarray or None |
| | Column data values |
| | ``dtype`` : numpy.dtype compatible value |
| | Data type for column |
| | ``description`` : str |
| | Full description of column |
| | ``unit`` : str |
| | Physical unit |
| | ``format`` : str or function |
| | `Format specifier`_ for outputting column values |
| | ``meta`` : dict |
| | Meta-data associated with the column |
| | |
| | Initialization options |
| | ^^^^^^^^^^^^^^^^^^^^^^ |
| | |
| | The column data values, shape, and data type are specified in one of two ways: |
| | |
| | **Provide a ``data`` value but not a ``length`` or ``shape``** |
| | |
| | Examples:: |
| | |
| | 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`` argument can be any value which is an acceptable |
| | fixed-size data-type initializer for the numpy.dtype() method. See |
| | `<https://docs.scipy.org/doc/numpy/reference/arrays.dtypes.html>`_. |
| | Examples include: |
| | |
| | - Python non-string type (float, int, bool) |
| | - Numpy non-string type (e.g. np.float32, np.int64, np.bool) |
| | - Numpy.dtype array-protocol type strings (e.g. 'i4', 'f8', 'S15') |
| | |
| | If no ``dtype`` value is provided then the type is inferred using |
| | ``np.array(data)``. When ``data`` is provided then the ``shape`` |
| | and ``length`` arguments are ignored. |
| | |
| | **Provide ``length`` and optionally ``shape``, but not ``data``** |
| | |
| | Examples:: |
| | |
| | col = Column(name='a', length=5) |
| | col = Column(name='a', dtype=int, length=10, shape=(3,4)) |
| | |
| | The default ``dtype`` is ``np.float64``. The ``shape`` argument is the array shape of a |
| | single cell in the column. The default ``shape`` is () which means a single value in |
| | each element. |
| | |
| | .. note:: |
| | |
| | After setting the type for a column, that type cannot be changed. |
| | If data values of a different type are assigned to the column then they |
| | will be cast to the existing column type. |
| | |
| | .. _table_format_string: |
| | |
| | Format specifier |
| | ^^^^^^^^^^^^^^^^ |
| | |
| | The format specifier controls the output of column values when a table or column |
| | is printed or written to an ASCII table. In the simplest case, it is a string |
| | that can be passed to python's built-in `format |
| | <https://docs.python.org/3/library/functions.html#format>`_ function. For more |
| | complicated formatting, one can also give "old-style" or "new-style" |
| | format strings, or even a function: |
| |
|
| | **Plain format specification** |
| |
|
| | This type of string specifies directly how the value should be formatted, |
| | using a `format specification mini-language |
| | <https://docs.python.org/3/library/string.html#formatspec>`_ that is |
| | quite similar to C. |
| |
|
| | ``".4f"`` will give four digits after the decimal in float format, or |
| |
|
| | ``"6d"`` will give integers in 6-character fields. |
| |
|
| | **Old-style format string** |
| |
|
| | This corresponds to syntax like ``"%.4f" % value`` as documented in |
| | `String formatting operations <https://docs.python.org/3/library/stdtypes.html#string-formatting-operations>`_. |
| |
|
| | ``"%.4f"`` to print four digits after the decimal in float format, or |
| |
|
| | ``"%6d"`` to print an integer in a 6-character wide field. |
| |
|
| | **New-style format string** |
| |
|
| | This corresponds to syntax like ``"{:.4f}".format(value)`` as documented in |
| | `format string syntax |
| | <https://docs.python.org/3/library/string.html#format-string-syntax>`_. |
| |
|
| | ``"{:.4f}"`` to print four digits after the decimal in float format, or |
| |
|
| | ``"{:6d}"`` to print an integer in a 6-character wide field. |
| |
|
| | Note that in either format string case any Python string that formats exactly |
| | one value is valid, so ``{:.4f} angstroms`` or ``Value: %12.2f`` would both |
| | work. |
| |
|
| | **Function** |
| |
|
| | The greatest flexibility can be achieved by setting a formatting function. This |
| | function must accept a single argument (the value) and return a string. In the |
| | following example this is used to make a LaTeX ready output:: |
| |
|
| | >>> t = Table([[1,2],[1.234e9,2.34e-12]], names = ('a','b')) |
| | >>> def latex_exp(value): |
| | ... val = '{0:8.2}'.format(value) |
| | ... mant, exp = val.split('e') |
| | ... # remove leading zeros |
| | ... exp = exp[0] + exp[1:].lstrip('0') |
| | ... return '$ {0} \\times 10^{{ {1} }}$' .format(mant, 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 |
| | |
| |
|
| | Each |Table| object has an attribute ``columns`` which is an ordered dictionary |
| | that stores all of the |Column| objects in the table (see also the `Column`_ |
| | section). Technically the ``columns`` attribute is a |TableColumns| object, |
| | which is an enhanced ordered dictionary that provides easier ways to select |
| | multiple columns. There are a few key points to remember: |
| |
|
| | - A |Table| can be initialized from a |TableColumns| object (copy is always True). |
| | - Selecting multiple columns from a |TableColumns| object returns another |
| | |TableColumns| object. |
| | - Select one column from a |TableColumns| object returns a |Column|. |
| |
|
| | So now look at the ways to select columns from a |TableColumns| object: |
| |
|
| | **Select columns by name** |
| | :: |
| |
|
| | >>> t = Table(names=('a', 'b', 'c', 'd')) |
| |
|
| | >>> t.columns['d', 'c', 'b'] |
| | <TableColumns names=('d','c','b')> |
| |
|
| | **Select columns by index slicing** |
| | :: |
| |
|
| | >>> t.columns[0:2] # Select first two columns |
| | <TableColumns names=('a','b')> |
| |
|
| | >>> t.columns[::-1] # Reverse column order |
| | <TableColumns names=('d','c','b','a')> |
| |
|
| | **Select column by index or name** |
| | :: |
| |
|
| | >>> 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> |
| |
|
| | .. _subclassing_table: |
| |
|
| | Subclassing Table |
| | ================= |
| |
|
| | For some applications it can be useful to subclass the |Table| class in order |
| | to introduce specialized behavior. In addition to subclassing |Table| it is |
| | frequently desirable 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``. |
| |
|
| | The following trivial example overrides all of these with do-nothing |
| | subclasses, but in practice you would override only the necessary subcomponents:: |
| |
|
| | >>> 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 |
| |
|
| |
|
| | Example |
| | |
| |
|
| | As a more practical example, suppose you have a table of data with a certain set of fixed |
| | columns, but you also want to carry an arbitrary dictionary of keyword=value |
| | parameters for each row and then access those values using the same item access |
| | syntax as if they were columns. It is assumed here that the extra parameters |
| | are contained in a numpy object-dtype column named ``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()] |
| |
|
| | Now we put this into action with a trivial |Table| subclass:: |
| |
|
| | >>> class ParamsTable(Table): |
| | ... Row = ParamsRow |
| |
|
| | First make a table and add a couple of rows:: |
| |
|
| | >>> 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) # doctest: +SKIP |
| | a b params |
| | |
| | 1 2.0 {'y': 2.5, 'x': 1.5} |
| | 2 3.0 {'z': 'hello', 'id': 123123} |
| |
|
| | Now see what we have from our specialized ``ParamsRow`` object:: |
| |
|
| | >>> t[0]['y'] |
| | 2.5 |
| | >>> t[1]['id'] |
| | 123123 |
| | >>> t[1].keys() |
| | ['a', 'b', 'id', 'z'] |
| | >>> t[1].values() |
| | [2, 3.0, 123123, 'hello'] |
| |
|
| | To make this example really useful you might want to override |
| | ``Table.__getitem__`` in order to allow table-level access to the parameter |
| | fields. This might look something like:: |
| |
|
| | 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__ ... |
| |
|
| | Columns and Quantities |
| | |
| |
|
| | Astropy `~astropy.units.Quantity` objects can be handled within tables in two |
| | complementary ways. The first method stores the `~astropy.units.Quantity` |
| | object natively within the table via the "mixin" column protocol. See the |
| | sections on :ref:`mixin_columns` and :ref:`quantity_and_qtable` for details, |
| | but in brief the key difference is using the `~astropy.table.QTable` class to |
| | indicate that a `~astropy.units.Quantity` should be stored natively within the |
| | table:: |
| |
|
| | >>> from astropy.table import QTable |
| | >>> from astropy import units as u |
| | >>> t = QTable() |
| | >>> t['velocity'] = [3, 4] * u.m / u.s |
| | >>> type(t['velocity']) # doctest: +SKIP |
| | astropy.units.quantity.Quantity |
| |
|
| | For new code that is quantity-aware we recommend using `~astropy.table.QTable`, |
| | but this may not be possible in all situations (particularly when interfacing |
| | with legacy code that does not handle quantities) and there are |
| | :ref:`details_and_caveats` that apply. In this case use the |
| | `~astropy.table.Table` class, which will convert a `~astropy.units.Quantity` to |
| | a `~astropy.table.Column` object with a ``unit`` attribute:: |
| |
|
| | >>> from astropy.table import Table |
| | >>> t = Table() |
| | >>> t['velocity'] = [3, 4] * u.m / u.s |
| | >>> type(t['velocity']) # doctest: +SKIP |
| | astropy.table.column.Column |
| | >>> t['velocity'].unit |
| | Unit("m / s") |
| |
|
| | To learn more about using standard `~astropy.table.Column` objects with defined |
| | units, see the :ref:`columns_with_units` section. |
| |
|
| |
|
| | Table-like objects |
| | ================== |
| |
|
| | 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]}) # doctest: +SKIP |
| | >>> t = QTable(data, copy=False, strict_copy=True) # doctest: +SKIP |
| |
|
| | 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) |
| |
|
| | Here ``cls`` is the |Table| class or subclass that is being instantiated |
| | (|QTable| in this example), ``copy`` indicates whether a copy of the values in |
| | ``data`` should be provided, and ``**kwargs`` are any extra keyword arguments |
| | which are not valid |Table| init keyword arguments. In the example above, |
| | ``strict_copy=True`` would end up in ``**kwargs`` and get passed to |
| | ``__astropy_table__()``. |
| |
|
| | If ``copy`` is ``True`` then the ``__astropy_table__`` method must ensure that |
| | a copy of the original data is returned. If ``copy`` is ``False`` then a |
| | reference to the table data should returned if possible. If it is not possible |
| | (e.g. the original data are in a Python list or must be otherwise transformed in |
| | memory) then ``__astropy_table__`` method is free to either return a copy or |
| | else raise an exception. This choice depends on the preference of the |
| | implementation. The implementation might choose to allow an additional keyword |
| | argument (e.g. ``strict_copy`` which gets passed via ``**kwargs``) to control the |
| | behavior in this case. |
| |
|
| | As a simple example, imagine a dict-based table class. (Note that |Table| |
| | already can be initialized from a dict-like object, so this is a bit contrived |
| | but does illustrate the principles involved.) Please pay attention to the |
| | method signature:: |
| |
|
| | def __astropy_table__(self, cls, copy, **kwargs): |
| |
|
| | Your class implementation of this must use the ``**kwargs`` technique for |
| | catching keyword arguments at the end. This is to ensure future compatibility |
| | in case additional keywords are added to the internal ``table = |
| | data.__astropy_table__(cls, copy)`` call. Including ``**kwargs`` will prevent |
| | breakage in this case. :: |
| |
|
| | 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('unexpected keyword args {}'.format(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('cannot have copy=False because column {} is ' |
| | 'not an ndarray'.format(name)) |
| |
|
| | return cls(cols, names=names, copy=copy) |
| |
|
