<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Introduction — PyTables 3.0.0 documentation</title>
<link rel="stylesheet" href="../_static/cloud.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<link rel="stylesheet" href="../" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../',
VERSION: '3.0.0',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<script type="text/javascript" src="../_static/jquery.cookie.js"></script>
<script type="text/javascript" src="../_static/toggle_sections.js"></script>
<script type="text/javascript" src="../_static/toggle_sidebar.js"></script>
<link rel="shortcut icon" href="../_static/favicon.ico"/>
<link rel="top" title="PyTables 3.0.0 documentation" href="../index.html" />
<link rel="up" title="PyTables User’s Guide" href="index.html" />
<link rel="next" title="Installation" href="installation.html" />
<link rel="prev" title="PyTables User’s Guide" href="index.html" />
</head>
<body>
<div class="relbar-top">
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="../py-modindex.html" title="Python Module Index"
>modules</a> </li>
<li class="right" >
<a href="../np-modindex.html" title="Python Module Index"
>modules</a> </li>
<li class="right" >
<a href="installation.html" title="Installation"
accesskey="N">next</a> </li>
<li class="right" >
<a href="index.html" title="PyTables User’s Guide"
accesskey="P">previous</a> </li>
<li><a href="../index.html">PyTables 3.0.0 documentation</a> »</li>
<li><a href="index.html" accesskey="U">PyTables User’s Guide</a> »</li>
</ul>
</div>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="introduction">
<h1>Introduction<a class="headerlink" href="#introduction" title="Permalink to this headline">¶</a></h1>
<blockquote class="epigraph">
<div><p>La sabiduría no vale la pena si no es posible servirse de ella para
inventar una nueva manera de preparar los garbanzos.</p>
<p>[Wisdom isn’t worth anything if you can’t use it to come up with a new
way to cook garbanzos.]</p>
<p class="attribution">—Gabriel García Márquez, A wise Catalan in <em>“Cien años de soledad”</em></p>
</div></blockquote>
<p>The goal of PyTables is to enable the end user to manipulate easily data
<em>tables</em> and <em>array</em> objects in a hierarchical structure. The foundation of
the underlying hierarchical data organization is the excellent HDF5 library
(see <a class="reference internal" href="bibliography.html#hdfg1"><em>[HDGF1]</em></a>).</p>
<p>It should be noted that this package is not intended to serve as a complete
wrapper for the entire HDF5 API, but only to provide a flexible, <em>very
pythonic</em> tool to deal with (arbitrarily) large amounts of data (typically
bigger than available memory) in tables and arrays organized in a
hierarchical and persistent disk storage structure.</p>
<p>A table is defined as a collection of records whose values are stored in
<em>fixed-length</em> fields. All records have the same structure and all values in
each field have the same <em>data type</em>. The terms <em>fixed-length</em> and strict
<em>data types</em> may seem to be a strange requirement for an interpreted language
like Python, but they serve a useful function if the goal is to save very
large quantities of data (such as is generated by many data acquisition
systems, Internet services or scientific applications, for example) in an
efficient manner that reduces demand on CPU time and I/O.</p>
<p>In order to emulate in Python records mapped to HDF5 C structs PyTables
implements a special class so as to easily define all its fields and other
properties. PyTables also provides a powerful interface to mine data in
tables. Records in tables are also known in the HDF5 naming scheme as
<em>compound</em> data types.</p>
<p>For example, you can define arbitrary tables in Python simply by declaring a
class with named fields and type information, such as in the following
example:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="k">class</span> <span class="nc">Particle</span><span class="p">(</span><span class="n">IsDescription</span><span class="p">):</span>
<span class="n">name</span> <span class="o">=</span> <span class="n">StringCol</span><span class="p">(</span><span class="mi">16</span><span class="p">)</span> <span class="c"># 16-character String</span>
<span class="n">idnumber</span> <span class="o">=</span> <span class="n">Int64Col</span><span class="p">()</span> <span class="c"># signed 64-bit integer</span>
<span class="n">ADCcount</span> <span class="o">=</span> <span class="n">UInt16Col</span><span class="p">()</span> <span class="c"># unsigned short integer</span>
<span class="n">TDCcount</span> <span class="o">=</span> <span class="n">UInt8Col</span><span class="p">()</span> <span class="c"># unsigned byte</span>
<span class="n">grid_i</span> <span class="o">=</span> <span class="n">Int32Col</span><span class="p">()</span> <span class="c"># integer</span>
<span class="n">grid_j</span> <span class="o">=</span> <span class="n">Int32Col</span><span class="p">()</span> <span class="c"># integer</span>
<span class="c"># A sub-structure (nested data-type)</span>
<span class="k">class</span> <span class="nc">Properties</span><span class="p">(</span><span class="n">IsDescription</span><span class="p">):</span>
<span class="n">pressure</span> <span class="o">=</span> <span class="n">Float32Col</span><span class="p">(</span><span class="n">shape</span><span class="o">=</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">))</span> <span class="c"># 2-D float array (single-precision)</span>
<span class="n">energy</span> <span class="o">=</span> <span class="n">Float64Col</span><span class="p">(</span><span class="n">shape</span><span class="o">=</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">))</span> <span class="c"># 3-D float array (double-precision)</span>
</pre></div>
</div>
<p>You then pass this class to the table constructor, fill its rows with your
values, and save (arbitrarily large) collections of them to a file for
persistent storage. After that, the data can be retrieved and post-processed
quite easily with PyTables or even with another HDF5 application (in C,
Fortran, Java or whatever language that provides a library to interface with
HDF5).</p>
<p>Other important entities in PyTables are <em>array</em> objects, which are analogous
to tables with the difference that all of their components are homogeneous.
They come in different flavors, like <em>generic</em> (they provide a quick and fast
way to deal with for numerical arrays), <em>enlargeable</em> (arrays can be extended
along a single dimension) and <em>variable length</em> (each row in the array can
have a different number of elements).</p>
<p>The next section describes the most interesting capabilities of PyTables.</p>
<div class="section" id="main-features">
<h2>Main Features<a class="headerlink" href="#main-features" title="Permalink to this headline">¶</a></h2>
<p>PyTables takes advantage of the object orientation and introspection
capabilities offered by Python, the powerful data management features of
HDF5, and NumPy’s flexibility and Numexpr’s high-performance manipulation of
large sets of objects organized in a grid-like fashion to provide these
features:</p>
<ul class="simple">
<li><em>Support for table entities:</em> You can tailor your data adding or deleting
records in your tables. Large numbers of rows (up to 2**63, much more than
will fit into memory) are supported as well.</li>
<li><em>Multidimensional and nested table cells:</em> You can declare a column to
consist of values having any number of dimensions besides scalars, which is
the only dimensionality allowed by the majority of relational databases.
You can even declare columns that are made of other columns (of different
types).</li>
<li><em>Indexing support for columns of tables:</em>
Very useful if you have large tables and you want to quickly look up for
values in columns satisfying some criteria.</li>
<li><em>Support for numerical arrays:</em>
NumPy (see <a class="reference internal" href="bibliography.html#numpy"><em>[NUMPY]</em></a>) arrays can be used as a useful
complement of tables to store homogeneous data.</li>
<li><em>Enlargeable arrays:</em> You can add new
elements to existing arrays on disk in any dimension you want (but only
one). Besides, you are able to access just a slice of your datasets by
using the powerful extended slicing mechanism, without need to load all
your complete dataset in memory.</li>
<li><em>Variable length arrays:</em> The number of elements in these arrays can vary
from row to row. This provides a lot of flexibility when dealing with
complex data.</li>
<li><em>Supports a hierarchical data model:</em>
Allows the user to clearly structure all data. PyTables builds up an
<em>object tree</em> in memory that replicates the underlying file data structure.
Access to objects in the file is achieved by walking through and
manipulating this object tree.
Besides, this object tree is built in a lazy way, for efficiency purposes.</li>
<li><em>User defined metadata:</em> Besides
supporting system metadata (like the number of rows of a table, shape,
flavor, etc.) the user may specify arbitrary metadata (as for example, room
temperature, or protocol for IP traffic that was collected) that complement
the meaning of actual data.</li>
<li><em>Ability to read/modify generic HDF5 files:</em> PyTables can access a wide
range of objects in generic HDF5 files, like compound type datasets (that
can be mapped to Table objects), homogeneous datasets (that can be mapped
to Array objects) or variable length record datasets (that can be mapped to
VLArray objects). Besides, if a dataset is not supported, it will be mapped
to a special UnImplemented class (see <a class="reference internal" href="libref/helper_classes.html#unimplementedclassdescr"><em>The UnImplemented class</em></a>), that
will let the user see that the data is there, although it will be
unreachable (still, you will be able to access the attributes and some
metadata in the dataset). With that, PyTables probably can access and
<em>modify</em> most of the HDF5 files out there.</li>
<li><em>Data compression:</em> Supports data compression (using the <em>Zlib</em>, <em>LZO</em>,
<em>bzip2</em> and <em>Blosc</em> compression libraries) out of the box. This is
important when you have repetitive data patterns and don’t want to spend
time searching for an optimized way to store them (saving you time spent
analyzing your data organization).</li>
<li><em>High performance I/O:</em> On modern systems storing large amounts of data,
tables and array objects can be read and written at a speed only limited by
the performance of the underlying I/O subsystem. Moreover, if your data is
compressible, even that limit is surmountable!</li>
<li><em>Support of files bigger than 2 GB:</em>
PyTables automatically inherits this capability from the underlying HDF5
library (assuming your platform supports the C long long integer, or, on
Windows, __int64).</li>
<li><em>Architecture-independent:</em> PyTables has been carefully coded (as HDF5
itself) with little-endian/big-endian byte ordering issues in mind. So, you
can write a file on a big-endian machine (like a Sparc or MIPS) and read it
on other little-endian machine (like an Intel or Alpha) without problems.
In addition, it has been tested successfully with 64 bit platforms
(Intel-64, AMD-64, PowerPC-G5, MIPS, UltraSparc) using code generated with
64 bit aware compilers.</li>
</ul>
</div>
<div class="section" id="the-object-tree">
<span id="objecttreesection"></span><h2>The Object Tree<a class="headerlink" href="#the-object-tree" title="Permalink to this headline">¶</a></h2>
<p>The hierarchical model of the underlying HDF5 library allows PyTables to
manage tables and arrays in a tree-like structure. In order to achieve this,
an <em>object tree</em> entity is <em>dynamically</em> created imitating the HDF5 structure
on disk. The HDF5 objects are read by walking through this object tree. You
can get a good picture of what kind of data is kept in the object by
examining the <em>metadata</em> nodes.</p>
<p>The different nodes in the object tree are instances of PyTables classes.
There are several types of classes, but the most important ones are the Node,
Group and Leaf classes. All nodes in a PyTables tree are instances of the
Node class. The Group and Leaf classes are descendants of Node. Group
instances (referred to as <em>groups</em> from now on) are a grouping structure
containing instances of zero or more groups or leaves, together with
supplementary metadata. Leaf instances (referred to as <em>leaves</em>) are
containers for actual data and can not contain further groups or leaves. The
Table, Array, CArray, EArray, VLArray and UnImplemented classes are
descendants of Leaf, and inherit all its properties.</p>
<p>Working with groups and leaves is similar in many ways to working with
directories and files on a Unix filesystem, i.e. a node (file or directory)
is always a <em>child</em> of one and only one group (directory), its <em>parent group</em>
<a class="footnote-reference" href="#id5" id="id1">[1]</a>.
Inside of that group, the node is accessed by its <em>name</em>. As is the case with
Unix directories and files, objects in the object tree are often referenced
by giving their full (absolute) path names. In PyTables this full path can be
specified either as string (such as ‘/subgroup2/table3’, using / as a
parent/child separator) or as a complete object path written in a format
known as the <em>natural name</em> schema (such as file.root.subgroup2.table3).</p>
<p>Support for <em>natural naming</em> is a key aspect of PyTables. It means that the
names of instance variables of the node objects are the same as the names of
its children <a class="footnote-reference" href="#id6" id="id2">[2]</a>. This is very <em>Pythonic</em> and intuitive in many cases. Check
the tutorial <a class="reference internal" href="tutorials.html#readingandselectingusage"><em>Reading (and selecting) data in a table</em></a> for usage examples.</p>
<p>You should also be aware that not all the data present in a file is loaded
into the object tree. The <em>metadata</em> (i.e. special data that describes the
structure of the actual data) is loaded only when the user want to access to
it (see later). Moreover, the actual data is not read until she request it
(by calling a method on a particular node). Using the object tree (the
metadata) you can retrieve information about the objects on disk such as
table names, titles, column names, data types in columns, numbers of rows,
or, in the case of arrays, their shapes, typecodes, etc. You can also search
through the tree for specific kinds of data then read it and process it. In a
certain sense, you can think of PyTables as a tool that applies the same
introspection capabilities of Python objects to large amounts of data in
persistent storage.</p>
<p>It is worth noting that PyTables sports a <em>metadata cache system</em> that loads
nodes <em>lazily</em> (i.e. on-demand), and unloads nodes that have not been used
for some time (following a <em>Least Recently Used</em> schema). It is important to
stress out that the nodes enter the cache after they have been unreferenced
(in the sense of Python reference counting), and that they can be revived (by
referencing them again) directly from the cache without performing the
de-serialization process from disk. This feature allows dealing with files
with large hierarchies very quickly and with low memory consumption, while
retaining all the powerful browsing capabilities of the previous
implementation of the object tree. See <a class="reference internal" href="bibliography.html#optim"><em>[OPTIM]</em></a> for more facts
about the advantages introduced by this new metadata cache system.</p>
<p>To better understand the dynamic nature of this object tree entity, let’s
start with a sample PyTables script (which you can find in
examples/objecttree.py) to create an HDF5 file:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="kn">from</span> <span class="nn">tables</span> <span class="kn">import</span> <span class="o">*</span>
<span class="k">class</span> <span class="nc">Particle</span><span class="p">(</span><span class="n">IsDescription</span><span class="p">):</span>
<span class="n">identity</span> <span class="o">=</span> <span class="n">StringCol</span><span class="p">(</span><span class="n">itemsize</span><span class="o">=</span><span class="mi">22</span><span class="p">,</span> <span class="n">dflt</span><span class="o">=</span><span class="s">" "</span><span class="p">,</span> <span class="n">pos</span><span class="o">=</span><span class="mi">0</span><span class="p">)</span> <span class="c"># character String</span>
<span class="n">idnumber</span> <span class="o">=</span> <span class="n">Int16Col</span><span class="p">(</span><span class="n">dflt</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">pos</span> <span class="o">=</span> <span class="mi">1</span><span class="p">)</span> <span class="c"># short integer</span>
<span class="n">speed</span> <span class="o">=</span> <span class="n">Float32Col</span><span class="p">(</span><span class="n">dflt</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">pos</span> <span class="o">=</span> <span class="mi">2</span><span class="p">)</span> <span class="c"># single-precision</span>
<span class="c"># Open a file in "w"rite mode</span>
<span class="n">fileh</span> <span class="o">=</span> <span class="n">open_file</span><span class="p">(</span><span class="s">"objecttree.h5"</span><span class="p">,</span> <span class="n">mode</span> <span class="o">=</span> <span class="s">"w"</span><span class="p">)</span>
<span class="c"># Get the HDF5 root group</span>
<span class="n">root</span> <span class="o">=</span> <span class="n">fileh</span><span class="o">.</span><span class="n">root</span>
<span class="c"># Create the groups</span>
<span class="n">group1</span> <span class="o">=</span> <span class="n">fileh</span><span class="o">.</span><span class="n">create_group</span><span class="p">(</span><span class="n">root</span><span class="p">,</span> <span class="s">"group1"</span><span class="p">)</span>
<span class="n">group2</span> <span class="o">=</span> <span class="n">fileh</span><span class="o">.</span><span class="n">create_group</span><span class="p">(</span><span class="n">root</span><span class="p">,</span> <span class="s">"group2"</span><span class="p">)</span>
<span class="c"># Now, create an array in root group</span>
<span class="n">array1</span> <span class="o">=</span> <span class="n">fileh</span><span class="o">.</span><span class="n">create_array</span><span class="p">(</span><span class="n">root</span><span class="p">,</span> <span class="s">"array1"</span><span class="p">,</span> <span class="p">[</span><span class="s">"string"</span><span class="p">,</span> <span class="s">"array"</span><span class="p">],</span> <span class="s">"String array"</span><span class="p">)</span>
<span class="c"># Create 2 new tables in group1</span>
<span class="n">table1</span> <span class="o">=</span> <span class="n">fileh</span><span class="o">.</span><span class="n">create_table</span><span class="p">(</span><span class="n">group1</span><span class="p">,</span> <span class="s">"table1"</span><span class="p">,</span> <span class="n">Particle</span><span class="p">)</span>
<span class="n">table2</span> <span class="o">=</span> <span class="n">fileh</span><span class="o">.</span><span class="n">create_table</span><span class="p">(</span><span class="s">"/group2"</span><span class="p">,</span> <span class="s">"table2"</span><span class="p">,</span> <span class="n">Particle</span><span class="p">)</span>
<span class="c"># Create the last table in group2</span>
<span class="n">array2</span> <span class="o">=</span> <span class="n">fileh</span><span class="o">.</span><span class="n">create_array</span><span class="p">(</span><span class="s">"/group1"</span><span class="p">,</span> <span class="s">"array2"</span><span class="p">,</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">])</span>
<span class="c"># Now, fill the tables</span>
<span class="k">for</span> <span class="n">table</span> <span class="ow">in</span> <span class="p">(</span><span class="n">table1</span><span class="p">,</span> <span class="n">table2</span><span class="p">):</span>
<span class="c"># Get the record object associated with the table:</span>
<span class="n">row</span> <span class="o">=</span> <span class="n">table</span><span class="o">.</span><span class="n">row</span>
<span class="c"># Fill the table with 10 records</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">xrange</span><span class="p">(</span><span class="mi">10</span><span class="p">):</span>
<span class="c"># First, assign the values to the Particle record</span>
<span class="n">row</span><span class="p">[</span><span class="s">'identity'</span><span class="p">]</span> <span class="o">=</span> <span class="s">'This is particle: </span><span class="si">%2d</span><span class="s">'</span> <span class="o">%</span> <span class="p">(</span><span class="n">i</span><span class="p">)</span>
<span class="n">row</span><span class="p">[</span><span class="s">'idnumber'</span><span class="p">]</span> <span class="o">=</span> <span class="n">i</span>
<span class="n">row</span><span class="p">[</span><span class="s">'speed'</span><span class="p">]</span> <span class="o">=</span> <span class="n">i</span> <span class="o">*</span> <span class="mf">2.</span>
<span class="c"># This injects the Record values</span>
<span class="n">row</span><span class="o">.</span><span class="n">append</span><span class="p">()</span>
<span class="c"># Flush the table buffers</span>
<span class="n">table</span><span class="o">.</span><span class="n">flush</span><span class="p">()</span>
<span class="c"># Finally, close the file (this also will flush all the remaining buffers!)</span>
<span class="n">fileh</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
</pre></div>
</div>
<p>This small program creates a simple HDF5 file called objecttree.h5 with the
structure that appears in <a class="reference internal" href="#objecttree-h5"><em>Figure 1</em></a> <a class="footnote-reference" href="#id7" id="id3">[3]</a>.
When the file is created, the metadata in the object tree is updated in
memory while the actual data is saved to disk. When you close the file the
object tree is no longer available. However, when you reopen this file the
object tree will be reconstructed in memory from the metadata on disk (this
is done in a lazy way, in order to load only the objects that are required by
the user), allowing you to work with it in exactly the same way as when you
originally created it.</p>
<div class="figure align-center" id="objecttree-h5">
<img alt="../_images/objecttree-h5.png" src="../_images/objecttree-h5.png" />
<p class="caption"><strong>Figure 1: An HDF5 example with 2 subgroups, 2 tables and 1 array.</strong></p>
</div>
<p>In <a class="reference internal" href="#objecttree"><em>Figure2</em></a>, you can see an example of the object tree
created when the above objecttree.h5 file is read (in fact, such an object
tree is always created when reading any supported generic HDF5 file).
It is worthwhile to take your time to understand it <a class="footnote-reference" href="#id8" id="id4">[4]</a>.
It will help you understand the relationships of in-memory PyTables objects.</p>
<div class="figure align-center" id="objecttree">
<img src="../_images/objecttree.svg" width="100%" /><p class="caption"><strong>Figure 2: A PyTables object tree example.</strong></p>
</div>
<hr class="docutils" />
<table class="docutils footnote" frame="void" id="id5" rules="none">
<colgroup><col class="label" /><col /></colgroup>
<tbody valign="top">
<tr><td class="label"><a class="fn-backref" href="#id1">[1]</a></td><td>PyTables does not support hard links - for the moment.</td></tr>
</tbody>
</table>
<table class="docutils footnote" frame="void" id="id6" rules="none">
<colgroup><col class="label" /><col /></colgroup>
<tbody valign="top">
<tr><td class="label"><a class="fn-backref" href="#id2">[2]</a></td><td>I got this simple but powerful idea from the excellent Objectify
module by David Mertz (see <a class="reference internal" href="bibliography.html#mertz"><em>[MERTZ]</em></a>).</td></tr>
</tbody>
</table>
<table class="docutils footnote" frame="void" id="id7" rules="none">
<colgroup><col class="label" /><col /></colgroup>
<tbody valign="top">
<tr><td class="label"><a class="fn-backref" href="#id3">[3]</a></td><td>We have used ViTables (see <a class="reference internal" href="bibliography.html#vitables"><em>[VITABLES]</em></a>) in order to
create this snapshot.</td></tr>
</tbody>
</table>
<table class="docutils footnote" frame="void" id="id8" rules="none">
<colgroup><col class="label" /><col /></colgroup>
<tbody valign="top">
<tr><td class="label"><a class="fn-backref" href="#id4">[4]</a></td><td>Bear in mind, however, that this diagram is <em>not</em> a standard UML class
diagram; it is rather meant to show the connections between the
PyTables objects and some of its most important attributes and
methods.</td></tr>
</tbody>
</table>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<p class="logo"><a href="../index.html">
<img class="logo" src="../_static/logo-pytables-small.png" alt="Logo"/>
</a></p>
<h3><a href="../index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">Introduction</a><ul>
<li><a class="reference internal" href="#main-features">Main Features</a></li>
<li><a class="reference internal" href="#the-object-tree">The Object Tree</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="index.html"
title="previous chapter">PyTables User’s Guide</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="installation.html"
title="next chapter">Installation</a></p>
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../_sources/usersguide/introduction.txt"
rel="nofollow">Show Source</a></li>
</ul>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="../search.html" method="get">
<input type="text" name="q" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="relbar-bottom">
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="../py-modindex.html" title="Python Module Index"
>modules</a> </li>
<li class="right" >
<a href="../np-modindex.html" title="Python Module Index"
>modules</a> </li>
<li class="right" >
<a href="installation.html" title="Installation"
>next</a> </li>
<li class="right" >
<a href="index.html" title="PyTables User’s Guide"
>previous</a> </li>
<li><a href="../index.html">PyTables 3.0.0 documentation</a> »</li>
<li><a href="index.html" >PyTables User’s Guide</a> »</li>
</ul>
</div>
</div>
<div class="footer">
© Copyright 2011-2013, PyTables maintainers.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
</div>
<!-- cloud_sptheme 1.3 -->
</body>
</html>
