diff --git a/Changelog b/Changelog
index 1ce3bc90a..eca828891 100644
--- a/Changelog
+++ b/Changelog
@@ -19,6 +19,12 @@
  * fix loading of enum type names (issue #775).
  * make sure missing_value applies only to scaled short integers if
    auto-scaling is on (issue #777).
+ * automatically create views of compound types with character arrays as 
+   numpy strings (issue #773).  Can be disabled using
+   'set_auto_chartostring(False)'. Numpy structured
+   array dtypes with 'SN' string subtypes can now be used to
+   define netcdf compound types (they get converted to ('S1',N)
+   character array types automatically).
  
 
  version 1.3.1 (tag v1.3.1rel)
diff --git a/README.md b/README.md
index e3401baf7..49303d157 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# netcdf4-python
+# [netcdf4-python](http://http://unidata.github.io/netcdf4-python)
 [Python](http://python.org)/[numpy](http://numpy.org) interface to the netCDF [C library](https://github.com/Unidata/netcdf-c).
 
 [![Linux Build Status](https://travis-ci.org/Unidata/netcdf4-python.svg?branch=master)](https://travis-ci.org/Unidata/netcdf4-python)
diff --git a/docs/netCDF4/index.html b/docs/netCDF4/index.html
index 7ded24464..9cc026087 100644
--- a/docs/netCDF4/index.html
+++ b/docs/netCDF4/index.html
@@ -858,6 +858,71 @@
 
   </style>
 
+  <style type="text/css">
+  .codehilite .hll { background-color: #ffffcc }
+.codehilite  { background: #f8f8f8; }
+.codehilite .c { color: #408080; font-style: italic } /* Comment */
+.codehilite .err { border: 1px solid #FF0000 } /* Error */
+.codehilite .k { color: #008000; font-weight: bold } /* Keyword */
+.codehilite .o { color: #666666 } /* Operator */
+.codehilite .cm { color: #408080; font-style: italic } /* Comment.Multiline */
+.codehilite .cp { color: #BC7A00 } /* Comment.Preproc */
+.codehilite .c1 { color: #408080; font-style: italic } /* Comment.Single */
+.codehilite .cs { color: #408080; font-style: italic } /* Comment.Special */
+.codehilite .gd { color: #A00000 } /* Generic.Deleted */
+.codehilite .ge { font-style: italic } /* Generic.Emph */
+.codehilite .gr { color: #FF0000 } /* Generic.Error */
+.codehilite .gh { color: #000080; font-weight: bold } /* Generic.Heading */
+.codehilite .gi { color: #00A000 } /* Generic.Inserted */
+.codehilite .go { color: #888888 } /* Generic.Output */
+.codehilite .gp { color: #000080; font-weight: bold } /* Generic.Prompt */
+.codehilite .gs { font-weight: bold } /* Generic.Strong */
+.codehilite .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
+.codehilite .gt { color: #0044DD } /* Generic.Traceback */
+.codehilite .kc { color: #008000; font-weight: bold } /* Keyword.Constant */
+.codehilite .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */
+.codehilite .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */
+.codehilite .kp { color: #008000 } /* Keyword.Pseudo */
+.codehilite .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */
+.codehilite .kt { color: #B00040 } /* Keyword.Type */
+.codehilite .m { color: #666666 } /* Literal.Number */
+.codehilite .s { color: #BA2121 } /* Literal.String */
+.codehilite .na { color: #7D9029 } /* Name.Attribute */
+.codehilite .nb { color: #008000 } /* Name.Builtin */
+.codehilite .nc { color: #0000FF; font-weight: bold } /* Name.Class */
+.codehilite .no { color: #880000 } /* Name.Constant */
+.codehilite .nd { color: #AA22FF } /* Name.Decorator */
+.codehilite .ni { color: #999999; font-weight: bold } /* Name.Entity */
+.codehilite .ne { color: #D2413A; font-weight: bold } /* Name.Exception */
+.codehilite .nf { color: #0000FF } /* Name.Function */
+.codehilite .nl { color: #A0A000 } /* Name.Label */
+.codehilite .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */
+.codehilite .nt { color: #008000; font-weight: bold } /* Name.Tag */
+.codehilite .nv { color: #19177C } /* Name.Variable */
+.codehilite .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */
+.codehilite .w { color: #bbbbbb } /* Text.Whitespace */
+.codehilite .mb { color: #666666 } /* Literal.Number.Bin */
+.codehilite .mf { color: #666666 } /* Literal.Number.Float */
+.codehilite .mh { color: #666666 } /* Literal.Number.Hex */
+.codehilite .mi { color: #666666 } /* Literal.Number.Integer */
+.codehilite .mo { color: #666666 } /* Literal.Number.Oct */
+.codehilite .sb { color: #BA2121 } /* Literal.String.Backtick */
+.codehilite .sc { color: #BA2121 } /* Literal.String.Char */
+.codehilite .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */
+.codehilite .s2 { color: #BA2121 } /* Literal.String.Double */
+.codehilite .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */
+.codehilite .sh { color: #BA2121 } /* Literal.String.Heredoc */
+.codehilite .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */
+.codehilite .sx { color: #008000 } /* Literal.String.Other */
+.codehilite .sr { color: #BB6688 } /* Literal.String.Regex */
+.codehilite .s1 { color: #BA2121 } /* Literal.String.Single */
+.codehilite .ss { color: #19177C } /* Literal.String.Symbol */
+.codehilite .bp { color: #008000 } /* Name.Builtin.Pseudo */
+.codehilite .vc { color: #19177C } /* Name.Variable.Class */
+.codehilite .vg { color: #19177C } /* Name.Variable.Global */
+.codehilite .vi { color: #19177C } /* Name.Variable.Instance */
+.codehilite .il { color: #666666 } /* Literal.Number.Integer.Long */
+  </style>
 
   <style type="text/css">
   
@@ -1300,6 +1365,7 @@ <h1>Tutorial</h1>
 <li><a href="#section11">Variable-length (vlen) data types.</a></li>
 <li><a href="#section12">Enum data type.</a></li>
 <li><a href="#section13">Parallel IO.</a></li>
+<li><a href="#section14">Dealing with strings</a></li>
 </ol>
 <h2><div id='section1'>1) Creating/Opening/Closing a netCDF file.</h2>
 <p>To create a netCDF file from python, you simply call the <a href="#netCDF4.Dataset"><code>Dataset</code></a>
@@ -1329,13 +1395,14 @@ <h2><div id='section1'>1) Creating/Opening/Closing a netCDF file.</h2>
 accomplished via the <a href="#netCDF4.Dataset.close"><code>close</code></a> method of the <a href="#netCDF4.Dataset"><code>Dataset</code></a>
 instance.</p>
 <p>Here's an example:</p>
-<pre><code>:::python
-&gt;&gt;&gt; from netCDF4 import Dataset
-&gt;&gt;&gt; rootgrp = Dataset("test.nc", "w", format="NETCDF4")
-&gt;&gt;&gt; print rootgrp.data_model
-NETCDF4
-&gt;&gt;&gt; rootgrp.close()
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">netCDF4</span> <span class="kn">import</span> <span class="n">Dataset</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">rootgrp</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s">&quot;test.nc&quot;</span><span class="p">,</span> <span class="s">&quot;w&quot;</span><span class="p">,</span> <span class="n">format</span><span class="o">=</span><span class="s">&quot;NETCDF4&quot;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">data_model</span>
+<span class="n">NETCDF4</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
+</pre></div>
+
+
 <p>Remote <a href="http://opendap.org">OPeNDAP</a>-hosted datasets can be accessed for
 reading over http if a URL is provided to the <a href="#netCDF4.Dataset"><code>Dataset</code></a> constructor instead of a
 filename.  However, this requires that the netCDF library be built with
@@ -1355,16 +1422,17 @@ <h2><div id='section2'>2) Groups in a netCDF file.</h2>
 the <code>groups</code> dictionary attribute of the <a href="#netCDF4.Dataset"><code>Dataset</code></a> instance.  Only
 <code>NETCDF4</code> formatted files support Groups, if you try to create a Group
 in a netCDF 3 file you will get an error message.</p>
-<pre><code>:::python
-&gt;&gt;&gt; rootgrp = Dataset("test.nc", "a")
-&gt;&gt;&gt; fcstgrp = rootgrp.createGroup("forecasts")
-&gt;&gt;&gt; analgrp = rootgrp.createGroup("analyses")
-&gt;&gt;&gt; print rootgrp.groups
-OrderedDict([("forecasts", 
-              &lt;netCDF4._netCDF4.Group object at 0x1b4b7b0&gt;),
-             ("analyses", 
-              &lt;netCDF4._netCDF4.Group object at 0x1b4b970&gt;)])
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">rootgrp</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s">&quot;test.nc&quot;</span><span class="p">,</span> <span class="s">&quot;a&quot;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">fcstgrp</span> <span class="o">=</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">createGroup</span><span class="p">(</span><span class="s">&quot;forecasts&quot;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">analgrp</span> <span class="o">=</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">createGroup</span><span class="p">(</span><span class="s">&quot;analyses&quot;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">groups</span>
+<span class="n">OrderedDict</span><span class="p">([(</span><span class="s">&quot;forecasts&quot;</span><span class="p">,</span> 
+              <span class="o">&lt;</span><span class="n">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Group</span> <span class="nb">object</span> <span class="n">at</span> <span class="mh">0x1b4b7b0</span><span class="o">&gt;</span><span class="p">),</span>
+             <span class="p">(</span><span class="s">&quot;analyses&quot;</span><span class="p">,</span> 
+              <span class="o">&lt;</span><span class="n">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Group</span> <span class="nb">object</span> <span class="n">at</span> <span class="mh">0x1b4b970</span><span class="o">&gt;</span><span class="p">)])</span>
+</pre></div>
+
+
 <p>Groups can exist within groups in a <a href="#netCDF4.Dataset"><code>Dataset</code></a>, just as directories
 exist within directories in a unix filesystem. Each <a href="#netCDF4.Group"><code>Group</code></a> instance
 has a <code>groups</code> attribute dictionary containing all of the group
@@ -1372,10 +1440,11 @@ <h2><div id='section2'>2) Groups in a netCDF file.</h2>
 <code>path</code> attribute that contains a simulated unix directory path to
 that group.  To simplify the creation of nested groups, you can
 use a unix-like path as an argument to <a href="#netCDF4.Dataset.createGroup"><code>createGroup</code></a>.</p>
-<pre><code>:::python
-&gt;&gt;&gt; fcstgrp1 = rootgrp.createGroup("/forecasts/model1")
-&gt;&gt;&gt; fcstgrp2 = rootgrp.createGroup("/forecasts/model2")
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">fcstgrp1</span> <span class="o">=</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">createGroup</span><span class="p">(</span><span class="s">&quot;/forecasts/model1&quot;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">fcstgrp2</span> <span class="o">=</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">createGroup</span><span class="p">(</span><span class="s">&quot;/forecasts/model2&quot;</span><span class="p">)</span>
+</pre></div>
+
+
 <p>If any of the intermediate elements of the path do not exist, they are created,
 just as with the unix command <code>'mkdir -p'</code>. If you try to create a group
 that already exists, no error will be raised, and the existing group will be 
@@ -1384,43 +1453,44 @@ <h2><div id='section2'>2) Groups in a netCDF file.</h2>
 <a href="#netCDF4.Dataset"><code>Dataset</code></a>. The function <code>walktree</code> is a Python generator that is used
 to walk the directory tree. Note that printing the <a href="#netCDF4.Dataset"><code>Dataset</code></a> or <a href="#netCDF4.Group"><code>Group</code></a>
 object yields summary information about it's contents.</p>
-<pre><code>:::python
-&gt;&gt;&gt; def walktree(top):
-&gt;&gt;&gt;     values = top.groups.values()
-&gt;&gt;&gt;     yield values
-&gt;&gt;&gt;     for value in top.groups.values():
-&gt;&gt;&gt;         for children in walktree(value):
-&gt;&gt;&gt;             yield children
-&gt;&gt;&gt; print rootgrp
-&gt;&gt;&gt; for children in walktree(rootgrp):
-&gt;&gt;&gt;      for child in children:
-&gt;&gt;&gt;          print child
-&lt;type "netCDF4._netCDF4.Dataset"&gt;
-root group (NETCDF4 file format):
-    dimensions:
-    variables:
-    groups: forecasts, analyses
-&lt;type "netCDF4._netCDF4.Group"&gt;
-group /forecasts:
-    dimensions:
-    variables:
-    groups: model1, model2
-&lt;type "netCDF4._netCDF4.Group"&gt;
-group /analyses:
-    dimensions:
-    variables:
-    groups:
-&lt;type "netCDF4._netCDF4.Group"&gt;
-group /forecasts/model1:
-    dimensions:
-    variables:
-    groups:
-&lt;type "netCDF4._netCDF4.Group"&gt;
-group /forecasts/model2:
-    dimensions:
-    variables:
-    groups:
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">def</span> <span class="nf">walktree</span><span class="p">(</span><span class="n">top</span><span class="p">):</span>
+<span class="o">&gt;&gt;&gt;</span>     <span class="n">values</span> <span class="o">=</span> <span class="n">top</span><span class="o">.</span><span class="n">groups</span><span class="o">.</span><span class="n">values</span><span class="p">()</span>
+<span class="o">&gt;&gt;&gt;</span>     <span class="k">yield</span> <span class="n">values</span>
+<span class="o">&gt;&gt;&gt;</span>     <span class="k">for</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">top</span><span class="o">.</span><span class="n">groups</span><span class="o">.</span><span class="n">values</span><span class="p">():</span>
+<span class="o">&gt;&gt;&gt;</span>         <span class="k">for</span> <span class="n">children</span> <span class="ow">in</span> <span class="n">walktree</span><span class="p">(</span><span class="n">value</span><span class="p">):</span>
+<span class="o">&gt;&gt;&gt;</span>             <span class="k">yield</span> <span class="n">children</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">rootgrp</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">for</span> <span class="n">children</span> <span class="ow">in</span> <span class="n">walktree</span><span class="p">(</span><span class="n">rootgrp</span><span class="p">):</span>
+<span class="o">&gt;&gt;&gt;</span>      <span class="k">for</span> <span class="n">child</span> <span class="ow">in</span> <span class="n">children</span><span class="p">:</span>
+<span class="o">&gt;&gt;&gt;</span>          <span class="k">print</span> <span class="n">child</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&quot;netCDF4._netCDF4.Dataset&quot;</span><span class="o">&gt;</span>
+<span class="n">root</span> <span class="n">group</span> <span class="p">(</span><span class="n">NETCDF4</span> <span class="nb">file</span> <span class="n">format</span><span class="p">):</span>
+    <span class="n">dimensions</span><span class="p">:</span>
+    <span class="n">variables</span><span class="p">:</span>
+    <span class="n">groups</span><span class="p">:</span> <span class="n">forecasts</span><span class="p">,</span> <span class="n">analyses</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&quot;netCDF4._netCDF4.Group&quot;</span><span class="o">&gt;</span>
+<span class="n">group</span> <span class="o">/</span><span class="n">forecasts</span><span class="p">:</span>
+    <span class="n">dimensions</span><span class="p">:</span>
+    <span class="n">variables</span><span class="p">:</span>
+    <span class="n">groups</span><span class="p">:</span> <span class="n">model1</span><span class="p">,</span> <span class="n">model2</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&quot;netCDF4._netCDF4.Group&quot;</span><span class="o">&gt;</span>
+<span class="n">group</span> <span class="o">/</span><span class="n">analyses</span><span class="p">:</span>
+    <span class="n">dimensions</span><span class="p">:</span>
+    <span class="n">variables</span><span class="p">:</span>
+    <span class="n">groups</span><span class="p">:</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&quot;netCDF4._netCDF4.Group&quot;</span><span class="o">&gt;</span>
+<span class="n">group</span> <span class="o">/</span><span class="n">forecasts</span><span class="o">/</span><span class="n">model1</span><span class="p">:</span>
+    <span class="n">dimensions</span><span class="p">:</span>
+    <span class="n">variables</span><span class="p">:</span>
+    <span class="n">groups</span><span class="p">:</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&quot;netCDF4._netCDF4.Group&quot;</span><span class="o">&gt;</span>
+<span class="n">group</span> <span class="o">/</span><span class="n">forecasts</span><span class="o">/</span><span class="n">model2</span><span class="p">:</span>
+    <span class="n">dimensions</span><span class="p">:</span>
+    <span class="n">variables</span><span class="p">:</span>
+    <span class="n">groups</span><span class="p">:</span>
+</pre></div>
+
+
 <h2><div id='section3'>3) Dimensions in a netCDF file.</h2>
 <p>netCDF defines the sizes of all variables in terms of dimensions, so
 before any variables can be created the dimensions they use must be
@@ -1434,44 +1504,48 @@ <h2><div id='section3'>3) Dimensions in a netCDF file.</h2>
 <code>level</code> dimensions are unlimited.  Having more than one unlimited
 dimension is a new netCDF 4 feature, in netCDF 3 files there may be only
 one, and it must be the first (leftmost) dimension of the variable.</p>
-<pre><code>:::python
-&gt;&gt;&gt; level = rootgrp.createDimension("level", None)
-&gt;&gt;&gt; time = rootgrp.createDimension("time", None)
-&gt;&gt;&gt; lat = rootgrp.createDimension("lat", 73)
-&gt;&gt;&gt; lon = rootgrp.createDimension("lon", 144)
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">level</span> <span class="o">=</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s">&quot;level&quot;</span><span class="p">,</span> <span class="bp">None</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">time</span> <span class="o">=</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s">&quot;time&quot;</span><span class="p">,</span> <span class="bp">None</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">lat</span> <span class="o">=</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s">&quot;lat&quot;</span><span class="p">,</span> <span class="mi">73</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">lon</span> <span class="o">=</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s">&quot;lon&quot;</span><span class="p">,</span> <span class="mi">144</span><span class="p">)</span>
+</pre></div>
+
+
 <p>All of the <a href="#netCDF4.Dimension"><code>Dimension</code></a> instances are stored in a python dictionary.</p>
-<pre><code>:::python
-&gt;&gt;&gt; print rootgrp.dimensions
-OrderedDict([("level", &lt;netCDF4._netCDF4.Dimension object at 0x1b48030&gt;),
-             ("time", &lt;netCDF4._netCDF4.Dimension object at 0x1b481c0&gt;),
-             ("lat", &lt;netCDF4._netCDF4.Dimension object at 0x1b480f8&gt;),
-             ("lon", &lt;netCDF4._netCDF4.Dimension object at 0x1b48a08&gt;)])
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">dimensions</span>
+<span class="n">OrderedDict</span><span class="p">([(</span><span class="s">&quot;level&quot;</span><span class="p">,</span> <span class="o">&lt;</span><span class="n">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Dimension</span> <span class="nb">object</span> <span class="n">at</span> <span class="mh">0x1b48030</span><span class="o">&gt;</span><span class="p">),</span>
+             <span class="p">(</span><span class="s">&quot;time&quot;</span><span class="p">,</span> <span class="o">&lt;</span><span class="n">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Dimension</span> <span class="nb">object</span> <span class="n">at</span> <span class="mh">0x1b481c0</span><span class="o">&gt;</span><span class="p">),</span>
+             <span class="p">(</span><span class="s">&quot;lat&quot;</span><span class="p">,</span> <span class="o">&lt;</span><span class="n">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Dimension</span> <span class="nb">object</span> <span class="n">at</span> <span class="mh">0x1b480f8</span><span class="o">&gt;</span><span class="p">),</span>
+             <span class="p">(</span><span class="s">&quot;lon&quot;</span><span class="p">,</span> <span class="o">&lt;</span><span class="n">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Dimension</span> <span class="nb">object</span> <span class="n">at</span> <span class="mh">0x1b48a08</span><span class="o">&gt;</span><span class="p">)])</span>
+</pre></div>
+
+
 <p>Calling the python <code>len</code> function with a <a href="#netCDF4.Dimension"><code>Dimension</code></a> instance returns
 the current size of that dimension.
 The <a href="#netCDF4.Dimension.isunlimited"><code>isunlimited</code></a> method of a <a href="#netCDF4.Dimension"><code>Dimension</code></a> instance
 can be used to determine if the dimensions is unlimited, or appendable.</p>
-<pre><code>:::python
-&gt;&gt;&gt; print len(lon)
-144
-&gt;&gt;&gt; print lon.isunlimited()
-False
-&gt;&gt;&gt; print time.isunlimited()
-True
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="nb">len</span><span class="p">(</span><span class="n">lon</span><span class="p">)</span>
+<span class="mi">144</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">lon</span><span class="o">.</span><span class="n">isunlimited</span><span class="p">()</span>
+<span class="bp">False</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">time</span><span class="o">.</span><span class="n">isunlimited</span><span class="p">()</span>
+<span class="bp">True</span>
+</pre></div>
+
+
 <p>Printing the <a href="#netCDF4.Dimension"><code>Dimension</code></a> object
 provides useful summary info, including the name and length of the dimension,
 and whether it is unlimited.</p>
-<pre><code>:::python
-&gt;&gt;&gt; for dimobj in rootgrp.dimensions.values():
-&gt;&gt;&gt;    print dimobj
-&lt;type "netCDF4._netCDF4.Dimension"&gt; (unlimited): name = "level", size = 0
-&lt;type "netCDF4._netCDF4.Dimension"&gt; (unlimited): name = "time", size = 0
-&lt;type "netCDF4._netCDF4.Dimension"&gt;: name = "lat", size = 73
-&lt;type "netCDF4._netCDF4.Dimension"&gt;: name = "lon", size = 144
-&lt;type "netCDF4._netCDF4.Dimension"&gt; (unlimited): name = "time", size = 0
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">for</span> <span class="n">dimobj</span> <span class="ow">in</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">dimensions</span><span class="o">.</span><span class="n">values</span><span class="p">():</span>
+<span class="o">&gt;&gt;&gt;</span>    <span class="k">print</span> <span class="n">dimobj</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&quot;netCDF4._netCDF4.Dimension&quot;</span><span class="o">&gt;</span> <span class="p">(</span><span class="n">unlimited</span><span class="p">):</span> <span class="n">name</span> <span class="o">=</span> <span class="s">&quot;level&quot;</span><span class="p">,</span> <span class="n">size</span> <span class="o">=</span> <span class="mi">0</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&quot;netCDF4._netCDF4.Dimension&quot;</span><span class="o">&gt;</span> <span class="p">(</span><span class="n">unlimited</span><span class="p">):</span> <span class="n">name</span> <span class="o">=</span> <span class="s">&quot;time&quot;</span><span class="p">,</span> <span class="n">size</span> <span class="o">=</span> <span class="mi">0</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&quot;netCDF4._netCDF4.Dimension&quot;</span><span class="o">&gt;</span><span class="p">:</span> <span class="n">name</span> <span class="o">=</span> <span class="s">&quot;lat&quot;</span><span class="p">,</span> <span class="n">size</span> <span class="o">=</span> <span class="mi">73</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&quot;netCDF4._netCDF4.Dimension&quot;</span><span class="o">&gt;</span><span class="p">:</span> <span class="n">name</span> <span class="o">=</span> <span class="s">&quot;lon&quot;</span><span class="p">,</span> <span class="n">size</span> <span class="o">=</span> <span class="mi">144</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&quot;netCDF4._netCDF4.Dimension&quot;</span><span class="o">&gt;</span> <span class="p">(</span><span class="n">unlimited</span><span class="p">):</span> <span class="n">name</span> <span class="o">=</span> <span class="s">&quot;time&quot;</span><span class="p">,</span> <span class="n">size</span> <span class="o">=</span> <span class="mi">0</span>
+</pre></div>
+
+
 <p><a href="#netCDF4.Dimension"><code>Dimension</code></a> names can be changed using the
 <code>netCDF4.Datatset.renameDimension</code> method of a <a href="#netCDF4.Dataset"><code>Dataset</code></a> or
 <a href="#netCDF4.Group"><code>Group</code></a> instance.</p>
@@ -1505,56 +1579,61 @@ <h2><div id='section4'>4) Variables in a netCDF file.</h2>
 coordinate variables. The <a href="#netCDF4.Dataset.createVariable"><code>createVariable</code></a>
 method returns an instance of the <a href="#netCDF4.Variable"><code>Variable</code></a> class whose methods can be
 used later to access and set variable data and attributes.</p>
-<pre><code>:::python
-&gt;&gt;&gt; times = rootgrp.createVariable("time","f8",("time",))
-&gt;&gt;&gt; levels = rootgrp.createVariable("level","i4",("level",))
-&gt;&gt;&gt; latitudes = rootgrp.createVariable("lat","f4",("lat",))
-&gt;&gt;&gt; longitudes = rootgrp.createVariable("lon","f4",("lon",))
-&gt;&gt;&gt; # two dimensions unlimited
-&gt;&gt;&gt; temp = rootgrp.createVariable("temp","f4",("time","level","lat","lon",))
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">times</span> <span class="o">=</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">&quot;time&quot;</span><span class="p">,</span><span class="s">&quot;f8&quot;</span><span class="p">,(</span><span class="s">&quot;time&quot;</span><span class="p">,))</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">levels</span> <span class="o">=</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">&quot;level&quot;</span><span class="p">,</span><span class="s">&quot;i4&quot;</span><span class="p">,(</span><span class="s">&quot;level&quot;</span><span class="p">,))</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">latitudes</span> <span class="o">=</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">&quot;lat&quot;</span><span class="p">,</span><span class="s">&quot;f4&quot;</span><span class="p">,(</span><span class="s">&quot;lat&quot;</span><span class="p">,))</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">longitudes</span> <span class="o">=</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">&quot;lon&quot;</span><span class="p">,</span><span class="s">&quot;f4&quot;</span><span class="p">,(</span><span class="s">&quot;lon&quot;</span><span class="p">,))</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># two dimensions unlimited</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">temp</span> <span class="o">=</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">&quot;temp&quot;</span><span class="p">,</span><span class="s">&quot;f4&quot;</span><span class="p">,(</span><span class="s">&quot;time&quot;</span><span class="p">,</span><span class="s">&quot;level&quot;</span><span class="p">,</span><span class="s">&quot;lat&quot;</span><span class="p">,</span><span class="s">&quot;lon&quot;</span><span class="p">,))</span>
+</pre></div>
+
+
 <p>To get summary info on a <a href="#netCDF4.Variable"><code>Variable</code></a> instance in an interactive session, just print it.</p>
-<pre><code>:::python
-&gt;&gt;&gt; print temp
-&lt;type "netCDF4._netCDF4.Variable"&gt;
-float32 temp(time, level, lat, lon)
-    least_significant_digit: 3
-    units: K
-unlimited dimensions: time, level
-current shape = (0, 0, 73, 144)
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">temp</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&quot;netCDF4._netCDF4.Variable&quot;</span><span class="o">&gt;</span>
+<span class="n">float32</span> <span class="n">temp</span><span class="p">(</span><span class="n">time</span><span class="p">,</span> <span class="n">level</span><span class="p">,</span> <span class="n">lat</span><span class="p">,</span> <span class="n">lon</span><span class="p">)</span>
+    <span class="n">least_significant_digit</span><span class="p">:</span> <span class="mi">3</span>
+    <span class="n">units</span><span class="p">:</span> <span class="n">K</span>
+<span class="n">unlimited</span> <span class="n">dimensions</span><span class="p">:</span> <span class="n">time</span><span class="p">,</span> <span class="n">level</span>
+<span class="n">current</span> <span class="n">shape</span> <span class="o">=</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">73</span><span class="p">,</span> <span class="mi">144</span><span class="p">)</span>
+</pre></div>
+
+
 <p>You can use a path to create a Variable inside a hierarchy of groups.</p>
-<pre><code>:::python
-&gt;&gt;&gt; ftemp = rootgrp.createVariable("/forecasts/model1/temp","f4",("time","level","lat","lon",))
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">ftemp</span> <span class="o">=</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">&quot;/forecasts/model1/temp&quot;</span><span class="p">,</span><span class="s">&quot;f4&quot;</span><span class="p">,(</span><span class="s">&quot;time&quot;</span><span class="p">,</span><span class="s">&quot;level&quot;</span><span class="p">,</span><span class="s">&quot;lat&quot;</span><span class="p">,</span><span class="s">&quot;lon&quot;</span><span class="p">,))</span>
+</pre></div>
+
+
 <p>If the intermediate groups do not yet exist, they will be created.</p>
 <p>You can also query a <a href="#netCDF4.Dataset"><code>Dataset</code></a> or <a href="#netCDF4.Group"><code>Group</code></a> instance directly to obtain <a href="#netCDF4.Group"><code>Group</code></a> or 
 <a href="#netCDF4.Variable"><code>Variable</code></a> instances using paths.</p>
-<pre><code>:::python
-&gt;&gt;&gt; print rootgrp["/forecasts/model1"] # a Group instance
-&lt;type "netCDF4._netCDF4.Group"&gt;
-group /forecasts/model1:
-    dimensions(sizes):
-    variables(dimensions): float32 temp(time,level,lat,lon)
-    groups:
-&gt;&gt;&gt; print rootgrp["/forecasts/model1/temp"] # a Variable instance
-&lt;type "netCDF4._netCDF4.Variable"&gt;
-float32 temp(time, level, lat, lon)
-path = /forecasts/model1
-unlimited dimensions: time, level
-current shape = (0, 0, 73, 144)
-filling on, default _FillValue of 9.96920996839e+36 used
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">rootgrp</span><span class="p">[</span><span class="s">&quot;/forecasts/model1&quot;</span><span class="p">]</span> <span class="c"># a Group instance</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&quot;netCDF4._netCDF4.Group&quot;</span><span class="o">&gt;</span>
+<span class="n">group</span> <span class="o">/</span><span class="n">forecasts</span><span class="o">/</span><span class="n">model1</span><span class="p">:</span>
+    <span class="n">dimensions</span><span class="p">(</span><span class="n">sizes</span><span class="p">):</span>
+    <span class="n">variables</span><span class="p">(</span><span class="n">dimensions</span><span class="p">):</span> <span class="n">float32</span> <span class="n">temp</span><span class="p">(</span><span class="n">time</span><span class="p">,</span><span class="n">level</span><span class="p">,</span><span class="n">lat</span><span class="p">,</span><span class="n">lon</span><span class="p">)</span>
+    <span class="n">groups</span><span class="p">:</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">rootgrp</span><span class="p">[</span><span class="s">&quot;/forecasts/model1/temp&quot;</span><span class="p">]</span> <span class="c"># a Variable instance</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&quot;netCDF4._netCDF4.Variable&quot;</span><span class="o">&gt;</span>
+<span class="n">float32</span> <span class="n">temp</span><span class="p">(</span><span class="n">time</span><span class="p">,</span> <span class="n">level</span><span class="p">,</span> <span class="n">lat</span><span class="p">,</span> <span class="n">lon</span><span class="p">)</span>
+<span class="n">path</span> <span class="o">=</span> <span class="o">/</span><span class="n">forecasts</span><span class="o">/</span><span class="n">model1</span>
+<span class="n">unlimited</span> <span class="n">dimensions</span><span class="p">:</span> <span class="n">time</span><span class="p">,</span> <span class="n">level</span>
+<span class="n">current</span> <span class="n">shape</span> <span class="o">=</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">73</span><span class="p">,</span> <span class="mi">144</span><span class="p">)</span>
+<span class="n">filling</span> <span class="n">on</span><span class="p">,</span> <span class="n">default</span> <span class="n">_FillValue</span> <span class="n">of</span> <span class="mf">9.96920996839e+36</span> <span class="n">used</span>
+</pre></div>
+
+
 <p>All of the variables in the <a href="#netCDF4.Dataset"><code>Dataset</code></a> or <a href="#netCDF4.Group"><code>Group</code></a> are stored in a
 Python dictionary, in the same way as the dimensions:</p>
-<pre><code>:::python
-&gt;&gt;&gt; print rootgrp.variables
-OrderedDict([("time", &lt;netCDF4.Variable object at 0x1b4ba70&gt;),
-             ("level", &lt;netCDF4.Variable object at 0x1b4bab0&gt;),
-             ("lat", &lt;netCDF4.Variable object at 0x1b4baf0&gt;),
-             ("lon", &lt;netCDF4.Variable object at 0x1b4bb30&gt;),
-             ("temp", &lt;netCDF4.Variable object at 0x1b4bb70&gt;)])
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">variables</span>
+<span class="n">OrderedDict</span><span class="p">([(</span><span class="s">&quot;time&quot;</span><span class="p">,</span> <span class="o">&lt;</span><span class="n">netCDF4</span><span class="o">.</span><span class="n">Variable</span> <span class="nb">object</span> <span class="n">at</span> <span class="mh">0x1b4ba70</span><span class="o">&gt;</span><span class="p">),</span>
+             <span class="p">(</span><span class="s">&quot;level&quot;</span><span class="p">,</span> <span class="o">&lt;</span><span class="n">netCDF4</span><span class="o">.</span><span class="n">Variable</span> <span class="nb">object</span> <span class="n">at</span> <span class="mh">0x1b4bab0</span><span class="o">&gt;</span><span class="p">),</span>
+             <span class="p">(</span><span class="s">&quot;lat&quot;</span><span class="p">,</span> <span class="o">&lt;</span><span class="n">netCDF4</span><span class="o">.</span><span class="n">Variable</span> <span class="nb">object</span> <span class="n">at</span> <span class="mh">0x1b4baf0</span><span class="o">&gt;</span><span class="p">),</span>
+             <span class="p">(</span><span class="s">&quot;lon&quot;</span><span class="p">,</span> <span class="o">&lt;</span><span class="n">netCDF4</span><span class="o">.</span><span class="n">Variable</span> <span class="nb">object</span> <span class="n">at</span> <span class="mh">0x1b4bb30</span><span class="o">&gt;</span><span class="p">),</span>
+             <span class="p">(</span><span class="s">&quot;temp&quot;</span><span class="p">,</span> <span class="o">&lt;</span><span class="n">netCDF4</span><span class="o">.</span><span class="n">Variable</span> <span class="nb">object</span> <span class="n">at</span> <span class="mh">0x1b4bb70</span><span class="o">&gt;</span><span class="p">)])</span>
+</pre></div>
+
+
 <p><a href="#netCDF4.Variable"><code>Variable</code></a> names can be changed using the
 <a href="#netCDF4.Dataset.renameVariable"><code>renameVariable</code></a> method of a <a href="#netCDF4.Dataset"><code>Dataset</code></a>
 instance.</p>
@@ -1567,87 +1646,93 @@ <h2><div id='section5'>5) Attributes in a netCDF file.</h2>
 attributes are set by assigning values to <a href="#netCDF4.Variable"><code>Variable</code></a> instances
 variables. Attributes can be strings, numbers or sequences. Returning to
 our example,</p>
-<pre><code>:::python
-&gt;&gt;&gt; import time
-&gt;&gt;&gt; rootgrp.description = "bogus example script"
-&gt;&gt;&gt; rootgrp.history = "Created " + time.ctime(time.time())
-&gt;&gt;&gt; rootgrp.source = "netCDF4 python module tutorial"
-&gt;&gt;&gt; latitudes.units = "degrees north"
-&gt;&gt;&gt; longitudes.units = "degrees east"
-&gt;&gt;&gt; levels.units = "hPa"
-&gt;&gt;&gt; temp.units = "K"
-&gt;&gt;&gt; times.units = "hours since 0001-01-01 00:00:00.0"
-&gt;&gt;&gt; times.calendar = "gregorian"
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="kn">import</span> <span class="nn">time</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">description</span> <span class="o">=</span> <span class="s">&quot;bogus example script&quot;</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">history</span> <span class="o">=</span> <span class="s">&quot;Created &quot;</span> <span class="o">+</span> <span class="n">time</span><span class="o">.</span><span class="n">ctime</span><span class="p">(</span><span class="n">time</span><span class="o">.</span><span class="n">time</span><span class="p">())</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">source</span> <span class="o">=</span> <span class="s">&quot;netCDF4 python module tutorial&quot;</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">latitudes</span><span class="o">.</span><span class="n">units</span> <span class="o">=</span> <span class="s">&quot;degrees north&quot;</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">longitudes</span><span class="o">.</span><span class="n">units</span> <span class="o">=</span> <span class="s">&quot;degrees east&quot;</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">levels</span><span class="o">.</span><span class="n">units</span> <span class="o">=</span> <span class="s">&quot;hPa&quot;</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">temp</span><span class="o">.</span><span class="n">units</span> <span class="o">=</span> <span class="s">&quot;K&quot;</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">times</span><span class="o">.</span><span class="n">units</span> <span class="o">=</span> <span class="s">&quot;hours since 0001-01-01 00:00:00.0&quot;</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">times</span><span class="o">.</span><span class="n">calendar</span> <span class="o">=</span> <span class="s">&quot;gregorian&quot;</span>
+</pre></div>
+
+
 <p>The <a href="#netCDF4.Dataset.ncattrs"><code>ncattrs</code></a> method of a <a href="#netCDF4.Dataset"><code>Dataset</code></a>, <a href="#netCDF4.Group"><code>Group</code></a> or
 <a href="#netCDF4.Variable"><code>Variable</code></a> instance can be used to retrieve the names of all the netCDF
 attributes. This method is provided as a convenience, since using the
 built-in <code>dir</code> Python function will return a bunch of private methods
 and attributes that cannot (or should not) be modified by the user.</p>
-<pre><code>:::python
-&gt;&gt;&gt; for name in rootgrp.ncattrs():
-&gt;&gt;&gt;     print "Global attr", name, "=", getattr(rootgrp,name)
-Global attr description = bogus example script
-Global attr history = Created Mon Nov  7 10.30:56 2005
-Global attr source = netCDF4 python module tutorial
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">ncattrs</span><span class="p">():</span>
+<span class="o">&gt;&gt;&gt;</span>     <span class="k">print</span> <span class="s">&quot;Global attr&quot;</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="s">&quot;=&quot;</span><span class="p">,</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">rootgrp</span><span class="p">,</span><span class="n">name</span><span class="p">)</span>
+<span class="n">Global</span> <span class="n">attr</span> <span class="n">description</span> <span class="o">=</span> <span class="n">bogus</span> <span class="n">example</span> <span class="n">script</span>
+<span class="n">Global</span> <span class="n">attr</span> <span class="n">history</span> <span class="o">=</span> <span class="n">Created</span> <span class="n">Mon</span> <span class="n">Nov</span>  <span class="mi">7</span> <span class="mf">10.30</span><span class="p">:</span><span class="mi">56</span> <span class="mi">2005</span>
+<span class="n">Global</span> <span class="n">attr</span> <span class="n">source</span> <span class="o">=</span> <span class="n">netCDF4</span> <span class="n">python</span> <span class="n">module</span> <span class="n">tutorial</span>
+</pre></div>
+
+
 <p>The <code>__dict__</code> attribute of a <a href="#netCDF4.Dataset"><code>Dataset</code></a>, <a href="#netCDF4.Group"><code>Group</code></a> or <a href="#netCDF4.Variable"><code>Variable</code></a>
 instance provides all the netCDF attribute name/value pairs in a python
 dictionary:</p>
-<pre><code>:::python
-&gt;&gt;&gt; print rootgrp.__dict__
-OrderedDict([(u"description", u"bogus example script"),
-             (u"history", u"Created Thu Mar  3 19:30:33 2011"),
-             (u"source", u"netCDF4 python module tutorial")])
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">__dict__</span>
+<span class="n">OrderedDict</span><span class="p">([(</span><span class="s">u&quot;description&quot;</span><span class="p">,</span> <span class="s">u&quot;bogus example script&quot;</span><span class="p">),</span>
+             <span class="p">(</span><span class="s">u&quot;history&quot;</span><span class="p">,</span> <span class="s">u&quot;Created Thu Mar  3 19:30:33 2011&quot;</span><span class="p">),</span>
+             <span class="p">(</span><span class="s">u&quot;source&quot;</span><span class="p">,</span> <span class="s">u&quot;netCDF4 python module tutorial&quot;</span><span class="p">)])</span>
+</pre></div>
+
+
 <p>Attributes can be deleted from a netCDF <a href="#netCDF4.Dataset"><code>Dataset</code></a>, <a href="#netCDF4.Group"><code>Group</code></a> or
 <a href="#netCDF4.Variable"><code>Variable</code></a> using the python <code>del</code> statement (i.e. <code>del grp.foo</code>
 removes the attribute <code>foo</code> the the group <code>grp</code>).</p>
 <h2><div id='section6'>6) Writing data to and retrieving data from a netCDF variable.</h2>
 <p>Now that you have a netCDF <a href="#netCDF4.Variable"><code>Variable</code></a> instance, how do you put data
 into it? You can just treat it like an array and assign data to a slice.</p>
-<pre><code>:::python
-&gt;&gt;&gt; import numpy
-&gt;&gt;&gt; lats =  numpy.arange(-90,91,2.5)
-&gt;&gt;&gt; lons =  numpy.arange(-180,180,2.5)
-&gt;&gt;&gt; latitudes[:] = lats
-&gt;&gt;&gt; longitudes[:] = lons
-&gt;&gt;&gt; print "latitudes =\n",latitudes[:]
-latitudes =
-[-90.  -87.5 -85.  -82.5 -80.  -77.5 -75.  -72.5 -70.  -67.5 -65.  -62.5
- -60.  -57.5 -55.  -52.5 -50.  -47.5 -45.  -42.5 -40.  -37.5 -35.  -32.5
- -30.  -27.5 -25.  -22.5 -20.  -17.5 -15.  -12.5 -10.   -7.5  -5.   -2.5
-   0.    2.5   5.    7.5  10.   12.5  15.   17.5  20.   22.5  25.   27.5
-  30.   32.5  35.   37.5  40.   42.5  45.   47.5  50.   52.5  55.   57.5
-  60.   62.5  65.   67.5  70.   72.5  75.   77.5  80.   82.5  85.   87.5
-  90. ]
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="kn">import</span> <span class="nn">numpy</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">lats</span> <span class="o">=</span>  <span class="n">numpy</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="o">-</span><span class="mi">90</span><span class="p">,</span><span class="mi">91</span><span class="p">,</span><span class="mf">2.5</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">lons</span> <span class="o">=</span>  <span class="n">numpy</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="o">-</span><span class="mi">180</span><span class="p">,</span><span class="mi">180</span><span class="p">,</span><span class="mf">2.5</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">latitudes</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">lats</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">longitudes</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">lons</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="s">&quot;latitudes =</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">,</span><span class="n">latitudes</span><span class="p">[:]</span>
+<span class="n">latitudes</span> <span class="o">=</span>
+<span class="p">[</span><span class="o">-</span><span class="mf">90.</span>  <span class="o">-</span><span class="mf">87.5</span> <span class="o">-</span><span class="mf">85.</span>  <span class="o">-</span><span class="mf">82.5</span> <span class="o">-</span><span class="mf">80.</span>  <span class="o">-</span><span class="mf">77.5</span> <span class="o">-</span><span class="mf">75.</span>  <span class="o">-</span><span class="mf">72.5</span> <span class="o">-</span><span class="mf">70.</span>  <span class="o">-</span><span class="mf">67.5</span> <span class="o">-</span><span class="mf">65.</span>  <span class="o">-</span><span class="mf">62.5</span>
+ <span class="o">-</span><span class="mf">60.</span>  <span class="o">-</span><span class="mf">57.5</span> <span class="o">-</span><span class="mf">55.</span>  <span class="o">-</span><span class="mf">52.5</span> <span class="o">-</span><span class="mf">50.</span>  <span class="o">-</span><span class="mf">47.5</span> <span class="o">-</span><span class="mf">45.</span>  <span class="o">-</span><span class="mf">42.5</span> <span class="o">-</span><span class="mf">40.</span>  <span class="o">-</span><span class="mf">37.5</span> <span class="o">-</span><span class="mf">35.</span>  <span class="o">-</span><span class="mf">32.5</span>
+ <span class="o">-</span><span class="mf">30.</span>  <span class="o">-</span><span class="mf">27.5</span> <span class="o">-</span><span class="mf">25.</span>  <span class="o">-</span><span class="mf">22.5</span> <span class="o">-</span><span class="mf">20.</span>  <span class="o">-</span><span class="mf">17.5</span> <span class="o">-</span><span class="mf">15.</span>  <span class="o">-</span><span class="mf">12.5</span> <span class="o">-</span><span class="mf">10.</span>   <span class="o">-</span><span class="mf">7.5</span>  <span class="o">-</span><span class="mf">5.</span>   <span class="o">-</span><span class="mf">2.5</span>
+   <span class="mf">0.</span>    <span class="mf">2.5</span>   <span class="mf">5.</span>    <span class="mf">7.5</span>  <span class="mf">10.</span>   <span class="mf">12.5</span>  <span class="mf">15.</span>   <span class="mf">17.5</span>  <span class="mf">20.</span>   <span class="mf">22.5</span>  <span class="mf">25.</span>   <span class="mf">27.5</span>
+  <span class="mf">30.</span>   <span class="mf">32.5</span>  <span class="mf">35.</span>   <span class="mf">37.5</span>  <span class="mf">40.</span>   <span class="mf">42.5</span>  <span class="mf">45.</span>   <span class="mf">47.5</span>  <span class="mf">50.</span>   <span class="mf">52.5</span>  <span class="mf">55.</span>   <span class="mf">57.5</span>
+  <span class="mf">60.</span>   <span class="mf">62.5</span>  <span class="mf">65.</span>   <span class="mf">67.5</span>  <span class="mf">70.</span>   <span class="mf">72.5</span>  <span class="mf">75.</span>   <span class="mf">77.5</span>  <span class="mf">80.</span>   <span class="mf">82.5</span>  <span class="mf">85.</span>   <span class="mf">87.5</span>
+  <span class="mf">90.</span> <span class="p">]</span>
+</pre></div>
+
+
 <p>Unlike NumPy's array objects, netCDF <a href="#netCDF4.Variable"><code>Variable</code></a>
 objects with unlimited dimensions will grow along those dimensions if you
 assign data outside the currently defined range of indices.</p>
-<pre><code>:::python
-&gt;&gt;&gt; # append along two unlimited dimensions by assigning to slice.
-&gt;&gt;&gt; nlats = len(rootgrp.dimensions["lat"])
-&gt;&gt;&gt; nlons = len(rootgrp.dimensions["lon"])
-&gt;&gt;&gt; print "temp shape before adding data = ",temp.shape
-temp shape before adding data =  (0, 0, 73, 144)
-&gt;&gt;&gt;
-&gt;&gt;&gt; from numpy.random import uniform
-&gt;&gt;&gt; temp[0:5,0:10,:,:] = uniform(size=(5,10,nlats,nlons))
-&gt;&gt;&gt; print "temp shape after adding data = ",temp.shape
-temp shape after adding data =  (6, 10, 73, 144)
-&gt;&gt;&gt;
-&gt;&gt;&gt; # levels have grown, but no values yet assigned.
-&gt;&gt;&gt; print "levels shape after adding pressure data = ",levels.shape
-levels shape after adding pressure data =  (10,)
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="c"># append along two unlimited dimensions by assigning to slice.</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">nlats</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">rootgrp</span><span class="o">.</span><span class="n">dimensions</span><span class="p">[</span><span class="s">&quot;lat&quot;</span><span class="p">])</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">nlons</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">rootgrp</span><span class="o">.</span><span class="n">dimensions</span><span class="p">[</span><span class="s">&quot;lon&quot;</span><span class="p">])</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="s">&quot;temp shape before adding data = &quot;</span><span class="p">,</span><span class="n">temp</span><span class="o">.</span><span class="n">shape</span>
+<span class="n">temp</span> <span class="n">shape</span> <span class="n">before</span> <span class="n">adding</span> <span class="n">data</span> <span class="o">=</span>  <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">73</span><span class="p">,</span> <span class="mi">144</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">numpy.random</span> <span class="kn">import</span> <span class="n">uniform</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">temp</span><span class="p">[</span><span class="mi">0</span><span class="p">:</span><span class="mi">5</span><span class="p">,</span><span class="mi">0</span><span class="p">:</span><span class="mi">10</span><span class="p">,:,:]</span> <span class="o">=</span> <span class="n">uniform</span><span class="p">(</span><span class="n">size</span><span class="o">=</span><span class="p">(</span><span class="mi">5</span><span class="p">,</span><span class="mi">10</span><span class="p">,</span><span class="n">nlats</span><span class="p">,</span><span class="n">nlons</span><span class="p">))</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="s">&quot;temp shape after adding data = &quot;</span><span class="p">,</span><span class="n">temp</span><span class="o">.</span><span class="n">shape</span>
+<span class="n">temp</span> <span class="n">shape</span> <span class="n">after</span> <span class="n">adding</span> <span class="n">data</span> <span class="o">=</span>  <span class="p">(</span><span class="mi">6</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">73</span><span class="p">,</span> <span class="mi">144</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># levels have grown, but no values yet assigned.</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="s">&quot;levels shape after adding pressure data = &quot;</span><span class="p">,</span><span class="n">levels</span><span class="o">.</span><span class="n">shape</span>
+<span class="n">levels</span> <span class="n">shape</span> <span class="n">after</span> <span class="n">adding</span> <span class="n">pressure</span> <span class="n">data</span> <span class="o">=</span>  <span class="p">(</span><span class="mi">10</span><span class="p">,)</span>
+</pre></div>
+
+
 <p>Note that the size of the levels variable grows when data is appended
 along the <code>level</code> dimension of the variable <code>temp</code>, even though no
 data has yet been assigned to levels.</p>
-<pre><code>:::python
-&gt;&gt;&gt; # now, assign data to levels dimension variable.
-&gt;&gt;&gt; levels[:] =  [1000.,850.,700.,500.,300.,250.,200.,150.,100.,50.]
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="c"># now, assign data to levels dimension variable.</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">levels</span><span class="p">[:]</span> <span class="o">=</span>  <span class="p">[</span><span class="mf">1000.</span><span class="p">,</span><span class="mf">850.</span><span class="p">,</span><span class="mf">700.</span><span class="p">,</span><span class="mf">500.</span><span class="p">,</span><span class="mf">300.</span><span class="p">,</span><span class="mf">250.</span><span class="p">,</span><span class="mf">200.</span><span class="p">,</span><span class="mf">150.</span><span class="p">,</span><span class="mf">100.</span><span class="p">,</span><span class="mf">50.</span><span class="p">]</span>
+</pre></div>
+
+
 <p>However, that there are some differences between NumPy and netCDF
 variable slicing rules. Slices behave as usual, being specified as a
 <code>start:stop:step</code> triplet. Using a scalar integer index <code>i</code> takes the ith
@@ -1656,9 +1741,10 @@ <h2><div id='section6'>6) Writing data to and retrieving data from a netCDF vari
 than for numpy arrays.  Only 1-d boolean arrays and integer sequences are
 allowed, and these indices work independently along each dimension (similar
 to the way vector subscripts work in fortran).  This means that</p>
-<pre><code>:::python
-&gt;&gt;&gt; temp[0, 0, [0,1,2,3], [0,1,2,3]]
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">temp</span><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</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="p">[</span><span class="mi">0</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>
+</pre></div>
+
+
 <p>returns an array of shape (4,4) when slicing a netCDF variable, but for a
 numpy array it returns an array of shape (4,).
 Similarly, a netCDF variable of shape <code>(2,3,4,5)</code> indexed
@@ -1671,16 +1757,18 @@ <h2><div id='section6'>6) Writing data to and retrieving data from a netCDF vari
 it provides a very powerful way to extract data from multidimensional netCDF
 variables by using logical operations on the dimension arrays to create slices.</p>
 <p>For example,</p>
-<pre><code>:::python
-&gt;&gt;&gt; tempdat = temp[::2, [1,3,6], lats&gt;0, lons&gt;0]
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">tempdat</span> <span class="o">=</span> <span class="n">temp</span><span class="p">[::</span><span class="mi">2</span><span class="p">,</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">6</span><span class="p">],</span> <span class="n">lats</span><span class="o">&gt;</span><span class="mi">0</span><span class="p">,</span> <span class="n">lons</span><span class="o">&gt;</span><span class="mi">0</span><span class="p">]</span>
+</pre></div>
+
+
 <p>will extract time indices 0,2 and 4, pressure levels
 850, 500 and 200 hPa, all Northern Hemisphere latitudes and Eastern
 Hemisphere longitudes, resulting in a numpy array of shape  (3, 3, 36, 71).</p>
-<pre><code>:::python
-&gt;&gt;&gt; print "shape of fancy temp slice = ",tempdat.shape
-shape of fancy temp slice =  (3, 3, 36, 71)
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="s">&quot;shape of fancy temp slice = &quot;</span><span class="p">,</span><span class="n">tempdat</span><span class="o">.</span><span class="n">shape</span>
+<span class="n">shape</span> <span class="n">of</span> <span class="n">fancy</span> <span class="n">temp</span> <span class="nb">slice</span> <span class="o">=</span>  <span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">36</span><span class="p">,</span> <span class="mi">71</span><span class="p">)</span>
+</pre></div>
+
+
 <p><strong><em>Special note for scalar variables</em></strong>: To extract data from a scalar variable
 <code>v</code> with no associated dimensions, use <code>np.asarray(v)</code> or <code>v[...]</code>. The result
 will be a numpy scalar array.</p>
@@ -1692,24 +1780,25 @@ <h2><div id='section7'>7) Dealing with time coordinates.</h2>
 awkward to deal with, without a utility to convert the values to and
 from calendar dates.  The function called <a href="#netCDF4.num2date"><code>num2date</code></a> and <a href="#netCDF4.date2num"><code>date2num</code></a> are
 provided with this package to do just that (starting with version 1.3.2, the 
-<a href="https://github.com/Unidata/netcdftime">netcdftime</a> package must be installed
+<a href="https://unidata.github.io/netcdftime">netcdftime</a> package must be installed
 separately).  Here's an example of how they
 can be used:</p>
-<pre><code>:::python
-&gt;&gt;&gt; # fill in times.
-&gt;&gt;&gt; from datetime import datetime, timedelta
-&gt;&gt;&gt; from netCDF4 import num2date, date2num
-&gt;&gt;&gt; dates = [datetime(2001,3,1)+n*timedelta(hours=12) for n in range(temp.shape[0])]
-&gt;&gt;&gt; times[:] = date2num(dates,units=times.units,calendar=times.calendar)
-&gt;&gt;&gt; print "time values (in units %s): " % times.units+"\n",times[:]
-time values (in units hours since January 1, 0001):
-[ 17533056.  17533068.  17533080.  17533092.  17533104.]
-&gt;&gt;&gt; dates = num2date(times[:],units=times.units,calendar=times.calendar)
-&gt;&gt;&gt; print "dates corresponding to time values:\n",dates
-dates corresponding to time values:
-[2001-03-01 00:00:00 2001-03-01 12:00:00 2001-03-02 00:00:00
- 2001-03-02 12:00:00 2001-03-03 00:00:00]
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="c"># fill in times.</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">datetime</span> <span class="kn">import</span> <span class="n">datetime</span><span class="p">,</span> <span class="n">timedelta</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">netCDF4</span> <span class="kn">import</span> <span class="n">num2date</span><span class="p">,</span> <span class="n">date2num</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">dates</span> <span class="o">=</span> <span class="p">[</span><span class="n">datetime</span><span class="p">(</span><span class="mi">2001</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">1</span><span class="p">)</span><span class="o">+</span><span class="n">n</span><span class="o">*</span><span class="n">timedelta</span><span class="p">(</span><span class="n">hours</span><span class="o">=</span><span class="mi">12</span><span class="p">)</span> <span class="k">for</span> <span class="n">n</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">temp</span><span class="o">.</span><span class="n">shape</span><span class="p">[</span><span class="mi">0</span><span class="p">])]</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">times</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">date2num</span><span class="p">(</span><span class="n">dates</span><span class="p">,</span><span class="n">units</span><span class="o">=</span><span class="n">times</span><span class="o">.</span><span class="n">units</span><span class="p">,</span><span class="n">calendar</span><span class="o">=</span><span class="n">times</span><span class="o">.</span><span class="n">calendar</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="s">&quot;time values (in units </span><span class="si">%s</span><span class="s">): &quot;</span> <span class="o">%</span> <span class="n">times</span><span class="o">.</span><span class="n">units</span><span class="o">+</span><span class="s">&quot;</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">,</span><span class="n">times</span><span class="p">[:]</span>
+<span class="n">time</span> <span class="n">values</span> <span class="p">(</span><span class="ow">in</span> <span class="n">units</span> <span class="n">hours</span> <span class="n">since</span> <span class="n">January</span> <span class="mi">1</span><span class="p">,</span> <span class="mo">0001</span><span class="p">):</span>
+<span class="p">[</span> <span class="mf">17533056.</span>  <span class="mf">17533068.</span>  <span class="mf">17533080.</span>  <span class="mf">17533092.</span>  <span class="mf">17533104.</span><span class="p">]</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">dates</span> <span class="o">=</span> <span class="n">num2date</span><span class="p">(</span><span class="n">times</span><span class="p">[:],</span><span class="n">units</span><span class="o">=</span><span class="n">times</span><span class="o">.</span><span class="n">units</span><span class="p">,</span><span class="n">calendar</span><span class="o">=</span><span class="n">times</span><span class="o">.</span><span class="n">calendar</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="s">&quot;dates corresponding to time values:</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">,</span><span class="n">dates</span>
+<span class="n">dates</span> <span class="n">corresponding</span> <span class="n">to</span> <span class="n">time</span> <span class="n">values</span><span class="p">:</span>
+<span class="p">[</span><span class="mi">2001</span><span class="o">-</span><span class="mo">03</span><span class="o">-</span><span class="mo">01</span> <span class="mo">00</span><span class="p">:</span><span class="mo">00</span><span class="p">:</span><span class="mo">00</span> <span class="mi">2001</span><span class="o">-</span><span class="mo">03</span><span class="o">-</span><span class="mo">01</span> <span class="mi">12</span><span class="p">:</span><span class="mo">00</span><span class="p">:</span><span class="mo">00</span> <span class="mi">2001</span><span class="o">-</span><span class="mo">03</span><span class="o">-</span><span class="mo">02</span> <span class="mo">00</span><span class="p">:</span><span class="mo">00</span><span class="p">:</span><span class="mo">00</span>
+ <span class="mi">2001</span><span class="o">-</span><span class="mo">03</span><span class="o">-</span><span class="mo">02</span> <span class="mi">12</span><span class="p">:</span><span class="mo">00</span><span class="p">:</span><span class="mo">00</span> <span class="mi">2001</span><span class="o">-</span><span class="mo">03</span><span class="o">-</span><span class="mo">03</span> <span class="mo">00</span><span class="p">:</span><span class="mo">00</span><span class="p">:</span><span class="mo">00</span><span class="p">]</span>
+</pre></div>
+
+
 <p><a href="#netCDF4.num2date"><code>num2date</code></a> converts numeric values of time in the specified <code>units</code>
 and <code>calendar</code> to datetime objects, and <a href="#netCDF4.date2num"><code>date2num</code></a> does the reverse.
 All the calendars currently defined in the
@@ -1730,24 +1819,26 @@ <h2><div id='section8'>8) Reading data from a multi-file netCDF dataset.</h2>
 must in be in <code>NETCDF3_64BIT_OFFSET</code>, <code>NETCDF3_64BIT_DATA</code>, <code>NETCDF3_CLASSIC</code> or
 <code>NETCDF4_CLASSIC</code> format (<code>NETCDF4</code> formatted multi-file
 datasets are not supported).</p>
-<pre><code>:::python
-&gt;&gt;&gt; for nf in range(10):
-&gt;&gt;&gt;     f = Dataset("mftest%s.nc" % nf,"w")
-&gt;&gt;&gt;     f.createDimension("x",None)
-&gt;&gt;&gt;     x = f.createVariable("x","i",("x",))
-&gt;&gt;&gt;     x[0:10] = numpy.arange(nf*10,10*(nf+1))
-&gt;&gt;&gt;     f.close()
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">for</span> <span class="n">nf</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">10</span><span class="p">):</span>
+<span class="o">&gt;&gt;&gt;</span>     <span class="n">f</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s">&quot;mftest</span><span class="si">%s</span><span class="s">.nc&quot;</span> <span class="o">%</span> <span class="n">nf</span><span class="p">,</span><span class="s">&quot;w&quot;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span>     <span class="n">f</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s">&quot;x&quot;</span><span class="p">,</span><span class="bp">None</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span>     <span class="n">x</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">&quot;x&quot;</span><span class="p">,</span><span class="s">&quot;i&quot;</span><span class="p">,(</span><span class="s">&quot;x&quot;</span><span class="p">,))</span>
+<span class="o">&gt;&gt;&gt;</span>     <span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">:</span><span class="mi">10</span><span class="p">]</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="n">nf</span><span class="o">*</span><span class="mi">10</span><span class="p">,</span><span class="mi">10</span><span class="o">*</span><span class="p">(</span><span class="n">nf</span><span class="o">+</span><span class="mi">1</span><span class="p">))</span>
+<span class="o">&gt;&gt;&gt;</span>     <span class="n">f</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
+</pre></div>
+
+
 <p>Now read all the files back in at once with <a href="#netCDF4.MFDataset"><code>MFDataset</code></a></p>
-<pre><code>:::python
-&gt;&gt;&gt; from netCDF4 import MFDataset
-&gt;&gt;&gt; f = MFDataset("mftest*nc")
-&gt;&gt;&gt; print f.variables["x"][:]
-[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
- 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
- 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
- 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99]
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">netCDF4</span> <span class="kn">import</span> <span class="n">MFDataset</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">f</span> <span class="o">=</span> <span class="n">MFDataset</span><span class="p">(</span><span class="s">&quot;mftest*nc&quot;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">f</span><span class="o">.</span><span class="n">variables</span><span class="p">[</span><span class="s">&quot;x&quot;</span><span class="p">][:]</span>
+<span class="p">[</span> <span class="mi">0</span>  <span class="mi">1</span>  <span class="mi">2</span>  <span class="mi">3</span>  <span class="mi">4</span>  <span class="mi">5</span>  <span class="mi">6</span>  <span class="mi">7</span>  <span class="mi">8</span>  <span class="mi">9</span> <span class="mi">10</span> <span class="mi">11</span> <span class="mi">12</span> <span class="mi">13</span> <span class="mi">14</span> <span class="mi">15</span> <span class="mi">16</span> <span class="mi">17</span> <span class="mi">18</span> <span class="mi">19</span> <span class="mi">20</span> <span class="mi">21</span> <span class="mi">22</span> <span class="mi">23</span> <span class="mi">24</span>
+ <span class="mi">25</span> <span class="mi">26</span> <span class="mi">27</span> <span class="mi">28</span> <span class="mi">29</span> <span class="mi">30</span> <span class="mi">31</span> <span class="mi">32</span> <span class="mi">33</span> <span class="mi">34</span> <span class="mi">35</span> <span class="mi">36</span> <span class="mi">37</span> <span class="mi">38</span> <span class="mi">39</span> <span class="mi">40</span> <span class="mi">41</span> <span class="mi">42</span> <span class="mi">43</span> <span class="mi">44</span> <span class="mi">45</span> <span class="mi">46</span> <span class="mi">47</span> <span class="mi">48</span> <span class="mi">49</span>
+ <span class="mi">50</span> <span class="mi">51</span> <span class="mi">52</span> <span class="mi">53</span> <span class="mi">54</span> <span class="mi">55</span> <span class="mi">56</span> <span class="mi">57</span> <span class="mi">58</span> <span class="mi">59</span> <span class="mi">60</span> <span class="mi">61</span> <span class="mi">62</span> <span class="mi">63</span> <span class="mi">64</span> <span class="mi">65</span> <span class="mi">66</span> <span class="mi">67</span> <span class="mi">68</span> <span class="mi">69</span> <span class="mi">70</span> <span class="mi">71</span> <span class="mi">72</span> <span class="mi">73</span> <span class="mi">74</span>
+ <span class="mi">75</span> <span class="mi">76</span> <span class="mi">77</span> <span class="mi">78</span> <span class="mi">79</span> <span class="mi">80</span> <span class="mi">81</span> <span class="mi">82</span> <span class="mi">83</span> <span class="mi">84</span> <span class="mi">85</span> <span class="mi">86</span> <span class="mi">87</span> <span class="mi">88</span> <span class="mi">89</span> <span class="mi">90</span> <span class="mi">91</span> <span class="mi">92</span> <span class="mi">93</span> <span class="mi">94</span> <span class="mi">95</span> <span class="mi">96</span> <span class="mi">97</span> <span class="mi">98</span> <span class="mi">99</span><span class="p">]</span>
+</pre></div>
+
+
 <p>Note that <a href="#netCDF4.MFDataset"><code>MFDataset</code></a> can only be used to read, not write, multi-file
 datasets.</p>
 <h2><div id='section9'>9) Efficient compression of netCDF variables.</h2>
@@ -1786,17 +1877,20 @@ <h2><div id='section9'>9) Efficient compression of netCDF variables.</h2>
 'lossy' instead of 'lossless', that is some precision in the data is
 sacrificed for the sake of disk space.</p>
 <p>In our example, try replacing the line</p>
-<pre><code>:::python
-&gt;&gt;&gt; temp = rootgrp.createVariable("temp","f4",("time","level","lat","lon",))
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">temp</span> <span class="o">=</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">&quot;temp&quot;</span><span class="p">,</span><span class="s">&quot;f4&quot;</span><span class="p">,(</span><span class="s">&quot;time&quot;</span><span class="p">,</span><span class="s">&quot;level&quot;</span><span class="p">,</span><span class="s">&quot;lat&quot;</span><span class="p">,</span><span class="s">&quot;lon&quot;</span><span class="p">,))</span>
+</pre></div>
+
+
 <p>with</p>
-<pre><code>:::python
-&gt;&gt;&gt; temp = dataset.createVariable("temp","f4",("time","level","lat","lon",),zlib=True)
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">temp</span> <span class="o">=</span> <span class="n">dataset</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">&quot;temp&quot;</span><span class="p">,</span><span class="s">&quot;f4&quot;</span><span class="p">,(</span><span class="s">&quot;time&quot;</span><span class="p">,</span><span class="s">&quot;level&quot;</span><span class="p">,</span><span class="s">&quot;lat&quot;</span><span class="p">,</span><span class="s">&quot;lon&quot;</span><span class="p">,),</span><span class="n">zlib</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
+</pre></div>
+
+
 <p>and then</p>
-<pre><code>:::python
-&gt;&gt;&gt; temp = dataset.createVariable("temp","f4",("time","level","lat","lon",),zlib=True,least_significant_digit=3)
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">temp</span> <span class="o">=</span> <span class="n">dataset</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">&quot;temp&quot;</span><span class="p">,</span><span class="s">&quot;f4&quot;</span><span class="p">,(</span><span class="s">&quot;time&quot;</span><span class="p">,</span><span class="s">&quot;level&quot;</span><span class="p">,</span><span class="s">&quot;lat&quot;</span><span class="p">,</span><span class="s">&quot;lon&quot;</span><span class="p">,),</span><span class="n">zlib</span><span class="o">=</span><span class="bp">True</span><span class="p">,</span><span class="n">least_significant_digit</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
+</pre></div>
+
+
 <p>and see how much smaller the resulting files are.</p>
 <h2><div id='section10'>10) Beyond homogeneous arrays of a fixed type - compound data types.</h2>
 <p>Compound data types map directly to numpy structured (a.k.a 'record')
@@ -1812,34 +1906,35 @@ <h2><div id='section10'>10) Beyond homogeneous arrays of a fixed type - compound
 <a href="#netCDF4.Dataset.createCompoundType"><code>createCompoundType</code></a> method of a <a href="#netCDF4.Dataset"><code>Dataset</code></a> or <a href="#netCDF4.Group"><code>Group</code></a> instance.
 Since there is no native complex data type in netcdf, compound types are handy
 for storing numpy complex arrays.  Here's an example:</p>
-<pre><code>:::python
-&gt;&gt;&gt; f = Dataset("complex.nc","w")
-&gt;&gt;&gt; size = 3 # length of 1-d complex array
-&gt;&gt;&gt; # create sample complex data.
-&gt;&gt;&gt; datac = numpy.exp(1j*(1.+numpy.linspace(0, numpy.pi, size)))
-&gt;&gt;&gt; # create complex128 compound data type.
-&gt;&gt;&gt; complex128 = numpy.dtype([("real",numpy.float64),("imag",numpy.float64)])
-&gt;&gt;&gt; complex128_t = f.createCompoundType(complex128,"complex128")
-&gt;&gt;&gt; # create a variable with this data type, write some data to it.
-&gt;&gt;&gt; f.createDimension("x_dim",None)
-&gt;&gt;&gt; v = f.createVariable("cmplx_var",complex128_t,"x_dim")
-&gt;&gt;&gt; data = numpy.empty(size,complex128) # numpy structured array
-&gt;&gt;&gt; data["real"] = datac.real; data["imag"] = datac.imag
-&gt;&gt;&gt; v[:] = data # write numpy structured array to netcdf compound var
-&gt;&gt;&gt; # close and reopen the file, check the contents.
-&gt;&gt;&gt; f.close(); f = Dataset("complex.nc")
-&gt;&gt;&gt; v = f.variables["cmplx_var"]
-&gt;&gt;&gt; datain = v[:] # read in all the data into a numpy structured array
-&gt;&gt;&gt; # create an empty numpy complex array
-&gt;&gt;&gt; datac2 = numpy.empty(datain.shape,numpy.complex128)
-&gt;&gt;&gt; # .. fill it with contents of structured array.
-&gt;&gt;&gt; datac2.real = datain["real"]; datac2.imag = datain["imag"]
-&gt;&gt;&gt; print datac.dtype,datac # original data
-complex128 [ 0.54030231+0.84147098j -0.84147098+0.54030231j  -0.54030231-0.84147098j]
-&gt;&gt;&gt;
-&gt;&gt;&gt; print datac2.dtype,datac2 # data from file
-complex128 [ 0.54030231+0.84147098j -0.84147098+0.54030231j  -0.54030231-0.84147098j]
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">f</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s">&quot;complex.nc&quot;</span><span class="p">,</span><span class="s">&quot;w&quot;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">size</span> <span class="o">=</span> <span class="mi">3</span> <span class="c"># length of 1-d complex array</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># create sample complex data.</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">datac</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">exp</span><span class="p">(</span><span class="mi">1j</span><span class="o">*</span><span class="p">(</span><span class="mf">1.</span><span class="o">+</span><span class="n">numpy</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="n">numpy</span><span class="o">.</span><span class="n">pi</span><span class="p">,</span> <span class="n">size</span><span class="p">)))</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># create complex128 compound data type.</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">complex128</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">dtype</span><span class="p">([(</span><span class="s">&quot;real&quot;</span><span class="p">,</span><span class="n">numpy</span><span class="o">.</span><span class="n">float64</span><span class="p">),(</span><span class="s">&quot;imag&quot;</span><span class="p">,</span><span class="n">numpy</span><span class="o">.</span><span class="n">float64</span><span class="p">)])</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">complex128_t</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="n">createCompoundType</span><span class="p">(</span><span class="n">complex128</span><span class="p">,</span><span class="s">&quot;complex128&quot;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># create a variable with this data type, write some data to it.</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">f</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s">&quot;x_dim&quot;</span><span class="p">,</span><span class="bp">None</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">v</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">&quot;cmplx_var&quot;</span><span class="p">,</span><span class="n">complex128_t</span><span class="p">,</span><span class="s">&quot;x_dim&quot;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">data</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">empty</span><span class="p">(</span><span class="n">size</span><span class="p">,</span><span class="n">complex128</span><span class="p">)</span> <span class="c"># numpy structured array</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">data</span><span class="p">[</span><span class="s">&quot;real&quot;</span><span class="p">]</span> <span class="o">=</span> <span class="n">datac</span><span class="o">.</span><span class="n">real</span><span class="p">;</span> <span class="n">data</span><span class="p">[</span><span class="s">&quot;imag&quot;</span><span class="p">]</span> <span class="o">=</span> <span class="n">datac</span><span class="o">.</span><span class="n">imag</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">v</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">data</span> <span class="c"># write numpy structured array to netcdf compound var</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># close and reopen the file, check the contents.</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">f</span><span class="o">.</span><span class="n">close</span><span class="p">();</span> <span class="n">f</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s">&quot;complex.nc&quot;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">v</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="n">variables</span><span class="p">[</span><span class="s">&quot;cmplx_var&quot;</span><span class="p">]</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">datain</span> <span class="o">=</span> <span class="n">v</span><span class="p">[:]</span> <span class="c"># read in all the data into a numpy structured array</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># create an empty numpy complex array</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">datac2</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">empty</span><span class="p">(</span><span class="n">datain</span><span class="o">.</span><span class="n">shape</span><span class="p">,</span><span class="n">numpy</span><span class="o">.</span><span class="n">complex128</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># .. fill it with contents of structured array.</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">datac2</span><span class="o">.</span><span class="n">real</span> <span class="o">=</span> <span class="n">datain</span><span class="p">[</span><span class="s">&quot;real&quot;</span><span class="p">];</span> <span class="n">datac2</span><span class="o">.</span><span class="n">imag</span> <span class="o">=</span> <span class="n">datain</span><span class="p">[</span><span class="s">&quot;imag&quot;</span><span class="p">]</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">datac</span><span class="o">.</span><span class="n">dtype</span><span class="p">,</span><span class="n">datac</span> <span class="c"># original data</span>
+<span class="n">complex128</span> <span class="p">[</span> <span class="mf">0.54030231</span><span class="o">+</span><span class="mf">0.84147098j</span> <span class="o">-</span><span class="mf">0.84147098</span><span class="o">+</span><span class="mf">0.54030231j</span>  <span class="o">-</span><span class="mf">0.54030231</span><span class="o">-</span><span class="mf">0.84147098j</span><span class="p">]</span>
+<span class="o">&gt;&gt;&gt;</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">datac2</span><span class="o">.</span><span class="n">dtype</span><span class="p">,</span><span class="n">datac2</span> <span class="c"># data from file</span>
+<span class="n">complex128</span> <span class="p">[</span> <span class="mf">0.54030231</span><span class="o">+</span><span class="mf">0.84147098j</span> <span class="o">-</span><span class="mf">0.84147098</span><span class="o">+</span><span class="mf">0.54030231j</span>  <span class="o">-</span><span class="mf">0.54030231</span><span class="o">-</span><span class="mf">0.84147098j</span><span class="p">]</span>
+</pre></div>
+
+
 <p>Compound types can be nested, but you must create the 'inner'
 ones first. All possible numpy structured arrays cannot be
 represented as Compound variables - an error message will be
@@ -1847,43 +1942,46 @@ <h2><div id='section10'>10) Beyond homogeneous arrays of a fixed type - compound
 All of the compound types defined for a <a href="#netCDF4.Dataset"><code>Dataset</code></a> or <a href="#netCDF4.Group"><code>Group</code></a> are stored 
 in a Python dictionary, just like variables and dimensions. As always, printing
 objects gives useful summary information in an interactive session:</p>
-<pre><code>:::python
-&gt;&gt;&gt; print f
-&lt;type "netCDF4._netCDF4.Dataset"&gt;
-root group (NETCDF4 file format):
-    dimensions: x_dim
-    variables: cmplx_var
-    groups:
-&lt;type "netCDF4._netCDF4.Variable"&gt;
-&gt;&gt;&gt; print f.variables["cmplx_var"]
-compound cmplx_var(x_dim)
-compound data type: [("real", "&lt;f8"), ("imag", "&lt;f8")]
-unlimited dimensions: x_dim
-current shape = (3,)
-&gt;&gt;&gt; print f.cmptypes
-OrderedDict([("complex128", &lt;netCDF4.CompoundType object at 0x1029eb7e8&gt;)])
-&gt;&gt;&gt; print f.cmptypes["complex128"]
-&lt;type "netCDF4._netCDF4.CompoundType"&gt;: name = "complex128", numpy dtype = [(u"real","&lt;f8"), (u"imag", "&lt;f8")]
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">f</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&quot;netCDF4._netCDF4.Dataset&quot;</span><span class="o">&gt;</span>
+<span class="n">root</span> <span class="n">group</span> <span class="p">(</span><span class="n">NETCDF4</span> <span class="nb">file</span> <span class="n">format</span><span class="p">):</span>
+    <span class="n">dimensions</span><span class="p">:</span> <span class="n">x_dim</span>
+    <span class="n">variables</span><span class="p">:</span> <span class="n">cmplx_var</span>
+    <span class="n">groups</span><span class="p">:</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&quot;netCDF4._netCDF4.Variable&quot;</span><span class="o">&gt;</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">f</span><span class="o">.</span><span class="n">variables</span><span class="p">[</span><span class="s">&quot;cmplx_var&quot;</span><span class="p">]</span>
+<span class="n">compound</span> <span class="n">cmplx_var</span><span class="p">(</span><span class="n">x_dim</span><span class="p">)</span>
+<span class="n">compound</span> <span class="n">data</span> <span class="nb">type</span><span class="p">:</span> <span class="p">[(</span><span class="s">&quot;real&quot;</span><span class="p">,</span> <span class="s">&quot;&lt;f8&quot;</span><span class="p">),</span> <span class="p">(</span><span class="s">&quot;imag&quot;</span><span class="p">,</span> <span class="s">&quot;&lt;f8&quot;</span><span class="p">)]</span>
+<span class="n">unlimited</span> <span class="n">dimensions</span><span class="p">:</span> <span class="n">x_dim</span>
+<span class="n">current</span> <span class="n">shape</span> <span class="o">=</span> <span class="p">(</span><span class="mi">3</span><span class="p">,)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">f</span><span class="o">.</span><span class="n">cmptypes</span>
+<span class="n">OrderedDict</span><span class="p">([(</span><span class="s">&quot;complex128&quot;</span><span class="p">,</span> <span class="o">&lt;</span><span class="n">netCDF4</span><span class="o">.</span><span class="n">CompoundType</span> <span class="nb">object</span> <span class="n">at</span> <span class="mh">0x1029eb7e8</span><span class="o">&gt;</span><span class="p">)])</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">f</span><span class="o">.</span><span class="n">cmptypes</span><span class="p">[</span><span class="s">&quot;complex128&quot;</span><span class="p">]</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&quot;netCDF4._netCDF4.CompoundType&quot;</span><span class="o">&gt;</span><span class="p">:</span> <span class="n">name</span> <span class="o">=</span> <span class="s">&quot;complex128&quot;</span><span class="p">,</span> <span class="n">numpy</span> <span class="n">dtype</span> <span class="o">=</span> <span class="p">[(</span><span class="s">u&quot;real&quot;</span><span class="p">,</span><span class="s">&quot;&lt;f8&quot;</span><span class="p">),</span> <span class="p">(</span><span class="s">u&quot;imag&quot;</span><span class="p">,</span> <span class="s">&quot;&lt;f8&quot;</span><span class="p">)]</span>
+</pre></div>
+
+
 <h2><div id='section11'>11) Variable-length (vlen) data types.</h2>
 <p>NetCDF 4 has support for variable-length or "ragged" arrays.  These are arrays
 of variable length sequences having the same type. To create a variable-length
 data type, use the <a href="#netCDF4.Dataset.createVLType"><code>createVLType</code></a> method
 method of a <a href="#netCDF4.Dataset"><code>Dataset</code></a> or <a href="#netCDF4.Group"><code>Group</code></a> instance.</p>
-<pre><code>:::python
-&gt;&gt;&gt; f = Dataset("tst_vlen.nc","w")
-&gt;&gt;&gt; vlen_t = f.createVLType(numpy.int32, "phony_vlen")
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">f</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s">&quot;tst_vlen.nc&quot;</span><span class="p">,</span><span class="s">&quot;w&quot;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">vlen_t</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="n">createVLType</span><span class="p">(</span><span class="n">numpy</span><span class="o">.</span><span class="n">int32</span><span class="p">,</span> <span class="s">&quot;phony_vlen&quot;</span><span class="p">)</span>
+</pre></div>
+
+
 <p>The numpy datatype of the variable-length sequences and the name of the
 new datatype must be specified. Any of the primitive datatypes can be
 used (signed and unsigned integers, 32 and 64 bit floats, and characters),
 but compound data types cannot.
 A new variable can then be created using this datatype.</p>
-<pre><code>:::python
-&gt;&gt;&gt; x = f.createDimension("x",3)
-&gt;&gt;&gt; y = f.createDimension("y",4)
-&gt;&gt;&gt; vlvar = f.createVariable("phony_vlen_var", vlen_t, ("y","x"))
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">x</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s">&quot;x&quot;</span><span class="p">,</span><span class="mi">3</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">y</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s">&quot;y&quot;</span><span class="p">,</span><span class="mi">4</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">vlvar</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">&quot;phony_vlen_var&quot;</span><span class="p">,</span> <span class="n">vlen_t</span><span class="p">,</span> <span class="p">(</span><span class="s">&quot;y&quot;</span><span class="p">,</span><span class="s">&quot;x&quot;</span><span class="p">))</span>
+</pre></div>
+
+
 <p>Since there is no native vlen datatype in numpy, vlen arrays are represented
 in python as object arrays (arrays of dtype <code>object</code>). These are arrays whose
 elements are Python object pointers, and can contain any type of python object.
@@ -1891,70 +1989,73 @@ <h2><div id='section11'>11) Variable-length (vlen) data types.</h2>
 but of varying length.
 In this case, they contain 1-D numpy <code>int32</code> arrays of random length between
 1 and 10.</p>
-<pre><code>:::python
-&gt;&gt;&gt; import random
-&gt;&gt;&gt; data = numpy.empty(len(y)*len(x),object)
-&gt;&gt;&gt; for n in range(len(y)*len(x)):
-&gt;&gt;&gt;    data[n] = numpy.arange(random.randint(1,10),dtype="int32")+1
-&gt;&gt;&gt; data = numpy.reshape(data,(len(y),len(x)))
-&gt;&gt;&gt; vlvar[:] = data
-&gt;&gt;&gt; print "vlen variable =\n",vlvar[:]
-vlen variable =
-[[[ 1  2  3  4  5  6  7  8  9 10] [1 2 3 4 5] [1 2 3 4 5 6 7 8]]
- [[1 2 3 4 5 6 7] [1 2 3 4 5 6] [1 2 3 4 5]]
- [[1 2 3 4 5] [1 2 3 4] [1]]
- [[ 1  2  3  4  5  6  7  8  9 10] [ 1  2  3  4  5  6  7  8  9 10]
-  [1 2 3 4 5 6 7 8]]]
-&gt;&gt;&gt; print f
-&lt;type "netCDF4._netCDF4.Dataset"&gt;
-root group (NETCDF4 file format):
-    dimensions: x, y
-    variables: phony_vlen_var
-    groups:
-&gt;&gt;&gt; print f.variables["phony_vlen_var"]
-&lt;type "netCDF4._netCDF4.Variable"&gt;
-vlen phony_vlen_var(y, x)
-vlen data type: int32
-unlimited dimensions:
-current shape = (4, 3)
-&gt;&gt;&gt; print f.VLtypes["phony_vlen"]
-&lt;type "netCDF4._netCDF4.VLType"&gt;: name = "phony_vlen", numpy dtype = int32
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="kn">import</span> <span class="nn">random</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">data</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">empty</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">y</span><span class="p">)</span><span class="o">*</span><span class="nb">len</span><span class="p">(</span><span class="n">x</span><span class="p">),</span><span class="nb">object</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">for</span> <span class="n">n</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">y</span><span class="p">)</span><span class="o">*</span><span class="nb">len</span><span class="p">(</span><span class="n">x</span><span class="p">)):</span>
+<span class="o">&gt;&gt;&gt;</span>    <span class="n">data</span><span class="p">[</span><span class="n">n</span><span class="p">]</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="n">random</span><span class="o">.</span><span class="n">randint</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">10</span><span class="p">),</span><span class="n">dtype</span><span class="o">=</span><span class="s">&quot;int32&quot;</span><span class="p">)</span><span class="o">+</span><span class="mi">1</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">data</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="n">data</span><span class="p">,(</span><span class="nb">len</span><span class="p">(</span><span class="n">y</span><span class="p">),</span><span class="nb">len</span><span class="p">(</span><span class="n">x</span><span class="p">)))</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">vlvar</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">data</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="s">&quot;vlen variable =</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">,</span><span class="n">vlvar</span><span class="p">[:]</span>
+<span class="n">vlen</span> <span class="n">variable</span> <span class="o">=</span>
+<span class="p">[[[</span> <span class="mi">1</span>  <span class="mi">2</span>  <span class="mi">3</span>  <span class="mi">4</span>  <span class="mi">5</span>  <span class="mi">6</span>  <span class="mi">7</span>  <span class="mi">8</span>  <span class="mi">9</span> <span class="mi">10</span><span class="p">]</span> <span class="p">[</span><span class="mi">1</span> <span class="mi">2</span> <span class="mi">3</span> <span class="mi">4</span> <span class="mi">5</span><span class="p">]</span> <span class="p">[</span><span class="mi">1</span> <span class="mi">2</span> <span class="mi">3</span> <span class="mi">4</span> <span class="mi">5</span> <span class="mi">6</span> <span class="mi">7</span> <span class="mi">8</span><span class="p">]]</span>
+ <span class="p">[[</span><span class="mi">1</span> <span class="mi">2</span> <span class="mi">3</span> <span class="mi">4</span> <span class="mi">5</span> <span class="mi">6</span> <span class="mi">7</span><span class="p">]</span> <span class="p">[</span><span class="mi">1</span> <span class="mi">2</span> <span class="mi">3</span> <span class="mi">4</span> <span class="mi">5</span> <span class="mi">6</span><span class="p">]</span> <span class="p">[</span><span class="mi">1</span> <span class="mi">2</span> <span class="mi">3</span> <span class="mi">4</span> <span class="mi">5</span><span class="p">]]</span>
+ <span class="p">[[</span><span class="mi">1</span> <span class="mi">2</span> <span class="mi">3</span> <span class="mi">4</span> <span class="mi">5</span><span class="p">]</span> <span class="p">[</span><span class="mi">1</span> <span class="mi">2</span> <span class="mi">3</span> <span class="mi">4</span><span class="p">]</span> <span class="p">[</span><span class="mi">1</span><span class="p">]]</span>
+ <span class="p">[[</span> <span class="mi">1</span>  <span class="mi">2</span>  <span class="mi">3</span>  <span class="mi">4</span>  <span class="mi">5</span>  <span class="mi">6</span>  <span class="mi">7</span>  <span class="mi">8</span>  <span class="mi">9</span> <span class="mi">10</span><span class="p">]</span> <span class="p">[</span> <span class="mi">1</span>  <span class="mi">2</span>  <span class="mi">3</span>  <span class="mi">4</span>  <span class="mi">5</span>  <span class="mi">6</span>  <span class="mi">7</span>  <span class="mi">8</span>  <span class="mi">9</span> <span class="mi">10</span><span class="p">]</span>
+  <span class="p">[</span><span class="mi">1</span> <span class="mi">2</span> <span class="mi">3</span> <span class="mi">4</span> <span class="mi">5</span> <span class="mi">6</span> <span class="mi">7</span> <span class="mi">8</span><span class="p">]]]</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">f</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&quot;netCDF4._netCDF4.Dataset&quot;</span><span class="o">&gt;</span>
+<span class="n">root</span> <span class="n">group</span> <span class="p">(</span><span class="n">NETCDF4</span> <span class="nb">file</span> <span class="n">format</span><span class="p">):</span>
+    <span class="n">dimensions</span><span class="p">:</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span>
+    <span class="n">variables</span><span class="p">:</span> <span class="n">phony_vlen_var</span>
+    <span class="n">groups</span><span class="p">:</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">f</span><span class="o">.</span><span class="n">variables</span><span class="p">[</span><span class="s">&quot;phony_vlen_var&quot;</span><span class="p">]</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&quot;netCDF4._netCDF4.Variable&quot;</span><span class="o">&gt;</span>
+<span class="n">vlen</span> <span class="n">phony_vlen_var</span><span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="n">x</span><span class="p">)</span>
+<span class="n">vlen</span> <span class="n">data</span> <span class="nb">type</span><span class="p">:</span> <span class="n">int32</span>
+<span class="n">unlimited</span> <span class="n">dimensions</span><span class="p">:</span>
+<span class="n">current</span> <span class="n">shape</span> <span class="o">=</span> <span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">f</span><span class="o">.</span><span class="n">VLtypes</span><span class="p">[</span><span class="s">&quot;phony_vlen&quot;</span><span class="p">]</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&quot;netCDF4._netCDF4.VLType&quot;</span><span class="o">&gt;</span><span class="p">:</span> <span class="n">name</span> <span class="o">=</span> <span class="s">&quot;phony_vlen&quot;</span><span class="p">,</span> <span class="n">numpy</span> <span class="n">dtype</span> <span class="o">=</span> <span class="n">int32</span>
+</pre></div>
+
+
 <p>Numpy object arrays containing python strings can also be written as vlen
 variables,  For vlen strings, you don't need to create a vlen data type.
 Instead, simply use the python <code>str</code> builtin (or a numpy string datatype
 with fixed length greater than 1) when calling the
 <a href="#netCDF4.Dataset.createVariable"><code>createVariable</code></a> method.</p>
-<pre><code>:::python
-&gt;&gt;&gt; z = f.createDimension("z",10)
-&gt;&gt;&gt; strvar = rootgrp.createVariable("strvar", str, "z")
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">z</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s">&quot;z&quot;</span><span class="p">,</span><span class="mi">10</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">strvar</span> <span class="o">=</span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">&quot;strvar&quot;</span><span class="p">,</span> <span class="nb">str</span><span class="p">,</span> <span class="s">&quot;z&quot;</span><span class="p">)</span>
+</pre></div>
+
+
 <p>In this example, an object array is filled with random python strings with
 random lengths between 2 and 12 characters, and the data in the object
 array is assigned to the vlen string variable.</p>
-<pre><code>:::python
-&gt;&gt;&gt; chars = "1234567890aabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
-&gt;&gt;&gt; data = numpy.empty(10,"O")
-&gt;&gt;&gt; for n in range(10):
-&gt;&gt;&gt;     stringlen = random.randint(2,12)
-&gt;&gt;&gt;     data[n] = "".join([random.choice(chars) for i in range(stringlen)])
-&gt;&gt;&gt; strvar[:] = data
-&gt;&gt;&gt; print "variable-length string variable:\n",strvar[:]
-variable-length string variable:
-[aDy29jPt 5DS9X8 jd7aplD b8t4RM jHh8hq KtaPWF9cQj Q1hHN5WoXSiT MMxsVeq tdLUzvVTzj]
-&gt;&gt;&gt; print f
-&lt;type "netCDF4._netCDF4.Dataset"&gt;
-root group (NETCDF4 file format):
-    dimensions: x, y, z
-    variables: phony_vlen_var, strvar
-    groups:
-&gt;&gt;&gt; print f.variables["strvar"]
-&lt;type "netCDF4._netCDF4.Variable"&gt;
-vlen strvar(z)
-vlen data type: &lt;type "str"&gt;
-unlimited dimensions:
-current size = (10,)
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">chars</span> <span class="o">=</span> <span class="s">&quot;1234567890aabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ&quot;</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">data</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">empty</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span><span class="s">&quot;O&quot;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">for</span> <span class="n">n</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">10</span><span class="p">):</span>
+<span class="o">&gt;&gt;&gt;</span>     <span class="n">stringlen</span> <span class="o">=</span> <span class="n">random</span><span class="o">.</span><span class="n">randint</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">12</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span>     <span class="n">data</span><span class="p">[</span><span class="n">n</span><span class="p">]</span> <span class="o">=</span> <span class="s">&quot;&quot;</span><span class="o">.</span><span class="n">join</span><span class="p">([</span><span class="n">random</span><span class="o">.</span><span class="n">choice</span><span class="p">(</span><span class="n">chars</span><span class="p">)</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">stringlen</span><span class="p">)])</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">strvar</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">data</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="s">&quot;variable-length string variable:</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">,</span><span class="n">strvar</span><span class="p">[:]</span>
+<span class="n">variable</span><span class="o">-</span><span class="n">length</span> <span class="n">string</span> <span class="n">variable</span><span class="p">:</span>
+<span class="p">[</span><span class="n">aDy29jPt</span> <span class="mi">5</span><span class="n">DS9X8</span> <span class="n">jd7aplD</span> <span class="n">b8t4RM</span> <span class="n">jHh8hq</span> <span class="n">KtaPWF9cQj</span> <span class="n">Q1hHN5WoXSiT</span> <span class="n">MMxsVeq</span> <span class="n">tdLUzvVTzj</span><span class="p">]</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">f</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&quot;netCDF4._netCDF4.Dataset&quot;</span><span class="o">&gt;</span>
+<span class="n">root</span> <span class="n">group</span> <span class="p">(</span><span class="n">NETCDF4</span> <span class="nb">file</span> <span class="n">format</span><span class="p">):</span>
+    <span class="n">dimensions</span><span class="p">:</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">z</span>
+    <span class="n">variables</span><span class="p">:</span> <span class="n">phony_vlen_var</span><span class="p">,</span> <span class="n">strvar</span>
+    <span class="n">groups</span><span class="p">:</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">f</span><span class="o">.</span><span class="n">variables</span><span class="p">[</span><span class="s">&quot;strvar&quot;</span><span class="p">]</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&quot;netCDF4._netCDF4.Variable&quot;</span><span class="o">&gt;</span>
+<span class="n">vlen</span> <span class="n">strvar</span><span class="p">(</span><span class="n">z</span><span class="p">)</span>
+<span class="n">vlen</span> <span class="n">data</span> <span class="nb">type</span><span class="p">:</span> <span class="o">&lt;</span><span class="nb">type</span> <span class="s">&quot;str&quot;</span><span class="o">&gt;</span>
+<span class="n">unlimited</span> <span class="n">dimensions</span><span class="p">:</span>
+<span class="n">current</span> <span class="n">size</span> <span class="o">=</span> <span class="p">(</span><span class="mi">10</span><span class="p">,)</span>
+</pre></div>
+
+
 <p>It is also possible to set contents of vlen string variables with numpy arrays
 of any string or unicode data type. Note, however, that accessing the contents
 of such variables will always return numpy arrays with dtype <code>object</code>.</p>
@@ -1966,100 +2067,105 @@ <h2><div id='section12'>12) Enum data type.</h2>
 The base integer data type and a python dictionary describing the allowed
 values and their names are used to define an Enum data type using
 <a href="#netCDF4.Dataset.createEnumType"><code>createEnumType</code></a>.</p>
-<pre><code>:::python
-&gt;&gt;&gt; nc = Dataset('clouds.nc','w')
-&gt;&gt;&gt; # python dict with allowed values and their names.
-&gt;&gt;&gt; enum_dict = {u'Altocumulus': 7, u'Missing': 255, 
-&gt;&gt;&gt; u'Stratus': 2, u'Clear': 0,
-&gt;&gt;&gt; u'Nimbostratus': 6, u'Cumulus': 4, u'Altostratus': 5,
-&gt;&gt;&gt; u'Cumulonimbus': 1, u'Stratocumulus': 3}
-&gt;&gt;&gt; # create the Enum type called 'cloud_t'.
-&gt;&gt;&gt; cloud_type = nc.createEnumType(numpy.uint8,'cloud_t',enum_dict)
-&gt;&gt;&gt; print cloud_type
-&lt;type 'netCDF4._netCDF4.EnumType'&gt;: name = 'cloud_t',
-numpy dtype = uint8, fields/values ={u'Cumulus': 4,
-u'Altocumulus': 7, u'Missing': 255,
-u'Stratus': 2, u'Clear': 0,
-u'Cumulonimbus': 1, u'Stratocumulus': 3,
-u'Nimbostratus': 6, u'Altostratus': 5}
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">nc</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s">&#39;clouds.nc&#39;</span><span class="p">,</span><span class="s">&#39;w&#39;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># python dict with allowed values and their names.</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">enum_dict</span> <span class="o">=</span> <span class="p">{</span><span class="s">u&#39;Altocumulus&#39;</span><span class="p">:</span> <span class="mi">7</span><span class="p">,</span> <span class="s">u&#39;Missing&#39;</span><span class="p">:</span> <span class="mi">255</span><span class="p">,</span> 
+<span class="o">&gt;&gt;&gt;</span> <span class="s">u&#39;Stratus&#39;</span><span class="p">:</span> <span class="mi">2</span><span class="p">,</span> <span class="s">u&#39;Clear&#39;</span><span class="p">:</span> <span class="mi">0</span><span class="p">,</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="s">u&#39;Nimbostratus&#39;</span><span class="p">:</span> <span class="mi">6</span><span class="p">,</span> <span class="s">u&#39;Cumulus&#39;</span><span class="p">:</span> <span class="mi">4</span><span class="p">,</span> <span class="s">u&#39;Altostratus&#39;</span><span class="p">:</span> <span class="mi">5</span><span class="p">,</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="s">u&#39;Cumulonimbus&#39;</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="s">u&#39;Stratocumulus&#39;</span><span class="p">:</span> <span class="mi">3</span><span class="p">}</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># create the Enum type called &#39;cloud_t&#39;.</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">cloud_type</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">createEnumType</span><span class="p">(</span><span class="n">numpy</span><span class="o">.</span><span class="n">uint8</span><span class="p">,</span><span class="s">&#39;cloud_t&#39;</span><span class="p">,</span><span class="n">enum_dict</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">cloud_type</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&#39;netCDF4._netCDF4.EnumType&#39;</span><span class="o">&gt;</span><span class="p">:</span> <span class="n">name</span> <span class="o">=</span> <span class="s">&#39;cloud_t&#39;</span><span class="p">,</span>
+<span class="n">numpy</span> <span class="n">dtype</span> <span class="o">=</span> <span class="n">uint8</span><span class="p">,</span> <span class="n">fields</span><span class="o">/</span><span class="n">values</span> <span class="o">=</span><span class="p">{</span><span class="s">u&#39;Cumulus&#39;</span><span class="p">:</span> <span class="mi">4</span><span class="p">,</span>
+<span class="s">u&#39;Altocumulus&#39;</span><span class="p">:</span> <span class="mi">7</span><span class="p">,</span> <span class="s">u&#39;Missing&#39;</span><span class="p">:</span> <span class="mi">255</span><span class="p">,</span>
+<span class="s">u&#39;Stratus&#39;</span><span class="p">:</span> <span class="mi">2</span><span class="p">,</span> <span class="s">u&#39;Clear&#39;</span><span class="p">:</span> <span class="mi">0</span><span class="p">,</span>
+<span class="s">u&#39;Cumulonimbus&#39;</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="s">u&#39;Stratocumulus&#39;</span><span class="p">:</span> <span class="mi">3</span><span class="p">,</span>
+<span class="s">u&#39;Nimbostratus&#39;</span><span class="p">:</span> <span class="mi">6</span><span class="p">,</span> <span class="s">u&#39;Altostratus&#39;</span><span class="p">:</span> <span class="mi">5</span><span class="p">}</span>
+</pre></div>
+
+
 <p>A new variable can be created in the usual way using this data type.
 Integer data is written to the variable that represents the named
 cloud types in enum_dict. A <code>ValueError</code> will be raised if an attempt
 is made to write an integer value not associated with one of the
 specified names.</p>
-<pre><code>:::python
-&gt;&gt;&gt; time = nc.createDimension('time',None)
-&gt;&gt;&gt; # create a 1d variable of type 'cloud_type'.
-&gt;&gt;&gt; # The fill_value is set to the 'Missing' named value.
-&gt;&gt;&gt; cloud_var =
-&gt;&gt;&gt; nc.createVariable('primary_cloud',cloud_type,'time',
-&gt;&gt;&gt; fill_value=enum_dict['Missing'])
-&gt;&gt;&gt; # write some data to the variable.
-&gt;&gt;&gt; cloud_var[:] = [enum_dict['Clear'],enum_dict['Stratus'],
-&gt;&gt;&gt; enum_dict['Cumulus'],enum_dict['Missing'],
-&gt;&gt;&gt; enum_dict['Cumulonimbus']]
-&gt;&gt;&gt; nc.close()
-&gt;&gt;&gt; # reopen the file, read the data.
-&gt;&gt;&gt; nc = Dataset('clouds.nc')
-&gt;&gt;&gt; cloud_var = nc.variables['primary_cloud']
-&gt;&gt;&gt; print cloud_var
-&lt;type 'netCDF4._netCDF4.Variable'&gt;
-enum primary_cloud(time)
-    _FillValue: 255
-enum data type: uint8
-unlimited dimensions: time
-current shape = (5,)
-&gt;&gt;&gt; print cloud_var.datatype.enum_dict
-{u'Altocumulus': 7, u'Missing': 255, u'Stratus': 2,
-u'Clear': 0, u'Nimbostratus': 6, u'Cumulus': 4,
-u'Altostratus': 5, u'Cumulonimbus': 1,
-u'Stratocumulus': 3}
-&gt;&gt;&gt; print cloud_var[:]
-[0 2 4 -- 1]
-&gt;&gt;&gt; nc.close()
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">time</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s">&#39;time&#39;</span><span class="p">,</span><span class="bp">None</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># create a 1d variable of type &#39;cloud_type&#39;.</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># The fill_value is set to the &#39;Missing&#39; named value.</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">cloud_var</span> <span class="o">=</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">nc</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">&#39;primary_cloud&#39;</span><span class="p">,</span><span class="n">cloud_type</span><span class="p">,</span><span class="s">&#39;time&#39;</span><span class="p">,</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">fill_value</span><span class="o">=</span><span class="n">enum_dict</span><span class="p">[</span><span class="s">&#39;Missing&#39;</span><span class="p">])</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># write some data to the variable.</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">cloud_var</span><span class="p">[:]</span> <span class="o">=</span> <span class="p">[</span><span class="n">enum_dict</span><span class="p">[</span><span class="s">&#39;Clear&#39;</span><span class="p">],</span><span class="n">enum_dict</span><span class="p">[</span><span class="s">&#39;Stratus&#39;</span><span class="p">],</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">enum_dict</span><span class="p">[</span><span class="s">&#39;Cumulus&#39;</span><span class="p">],</span><span class="n">enum_dict</span><span class="p">[</span><span class="s">&#39;Missing&#39;</span><span class="p">],</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">enum_dict</span><span class="p">[</span><span class="s">&#39;Cumulonimbus&#39;</span><span class="p">]]</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">nc</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># reopen the file, read the data.</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">nc</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s">&#39;clouds.nc&#39;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">cloud_var</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">variables</span><span class="p">[</span><span class="s">&#39;primary_cloud&#39;</span><span class="p">]</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">cloud_var</span>
+<span class="o">&lt;</span><span class="nb">type</span> <span class="s">&#39;netCDF4._netCDF4.Variable&#39;</span><span class="o">&gt;</span>
+<span class="n">enum</span> <span class="n">primary_cloud</span><span class="p">(</span><span class="n">time</span><span class="p">)</span>
+    <span class="n">_FillValue</span><span class="p">:</span> <span class="mi">255</span>
+<span class="n">enum</span> <span class="n">data</span> <span class="nb">type</span><span class="p">:</span> <span class="n">uint8</span>
+<span class="n">unlimited</span> <span class="n">dimensions</span><span class="p">:</span> <span class="n">time</span>
+<span class="n">current</span> <span class="n">shape</span> <span class="o">=</span> <span class="p">(</span><span class="mi">5</span><span class="p">,)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">cloud_var</span><span class="o">.</span><span class="n">datatype</span><span class="o">.</span><span class="n">enum_dict</span>
+<span class="p">{</span><span class="s">u&#39;Altocumulus&#39;</span><span class="p">:</span> <span class="mi">7</span><span class="p">,</span> <span class="s">u&#39;Missing&#39;</span><span class="p">:</span> <span class="mi">255</span><span class="p">,</span> <span class="s">u&#39;Stratus&#39;</span><span class="p">:</span> <span class="mi">2</span><span class="p">,</span>
+<span class="s">u&#39;Clear&#39;</span><span class="p">:</span> <span class="mi">0</span><span class="p">,</span> <span class="s">u&#39;Nimbostratus&#39;</span><span class="p">:</span> <span class="mi">6</span><span class="p">,</span> <span class="s">u&#39;Cumulus&#39;</span><span class="p">:</span> <span class="mi">4</span><span class="p">,</span>
+<span class="s">u&#39;Altostratus&#39;</span><span class="p">:</span> <span class="mi">5</span><span class="p">,</span> <span class="s">u&#39;Cumulonimbus&#39;</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span>
+<span class="s">u&#39;Stratocumulus&#39;</span><span class="p">:</span> <span class="mi">3</span><span class="p">}</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">cloud_var</span><span class="p">[:]</span>
+<span class="p">[</span><span class="mi">0</span> <span class="mi">2</span> <span class="mi">4</span> <span class="o">--</span> <span class="mi">1</span><span class="p">]</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">nc</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
+</pre></div>
+
+
 <h2><div id='section13'>13) Parallel IO.</h2>
 <p>If MPI parallel enabled versions of netcdf and hdf5 are detected, and
 <a href="https://mpi4py.scipy.org">mpi4py</a> is installed, netcdf4-python will
 be built with parallel IO capabilities enabled.  To use parallel IO,
 your program must be running in an MPI environment using 
 <a href="https://mpi4py.scipy.org">mpi4py</a>.</p>
-<pre><code>:::python
-&gt;&gt;&gt; from mpi4py import MPI
-&gt;&gt;&gt; import numpy as np
-&gt;&gt;&gt; from netCDF4 import Dataset
-&gt;&gt;&gt; rank = MPI.COMM_WORLD.rank  # The process ID (integer 0-3 for 4-process run)
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">mpi4py</span> <span class="kn">import</span> <span class="n">MPI</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="kn">import</span> <span class="nn">numpy</span> <span class="kn">as</span> <span class="nn">np</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="kn">from</span> <span class="nn">netCDF4</span> <span class="kn">import</span> <span class="n">Dataset</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">rank</span> <span class="o">=</span> <span class="n">MPI</span><span class="o">.</span><span class="n">COMM_WORLD</span><span class="o">.</span><span class="n">rank</span>  <span class="c"># The process ID (integer 0-3 for 4-process run)</span>
+</pre></div>
+
+
 <p>To run an MPI-based parallel program like this, you must use <code>mpiexec</code> to launch several
 parallel instances of Python (for example, using <code>mpiexec -np 4 python mpi_example.py</code>).
 The parallel features of netcdf4-python are mostly transparent -
 when a new dataset is created or an existing dataset is opened,
 use the <code>parallel</code> keyword to enable parallel access.</p>
-<pre><code>:::python
-&gt;&gt;&gt; nc = Dataset('parallel_tst.nc','w',parallel=True)
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">nc</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s">&#39;parallel_tst.nc&#39;</span><span class="p">,</span><span class="s">&#39;w&#39;</span><span class="p">,</span><span class="n">parallel</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
+</pre></div>
+
+
 <p>The optional <code>comm</code> keyword may be used to specify a particular
 MPI communicator (<code>MPI_COMM_WORLD</code> is used by default).  Each process (or rank)
 can now write to the file indepedently.  In this example the process rank is
 written to a different variable index on each task</p>
-<pre><code>:::python
-&gt;&gt;&gt; d = nc.createDimension('dim',4)
-&gt;&gt;&gt; v = nc.createVariable('var', np.int, 'dim')
-&gt;&gt;&gt; v[rank] = rank
-&gt;&gt;&gt; nc.close()
-
-% ncdump parallel_test.nc
-netcdf parallel_test {
-dimensions:
-    dim = 4 ;
-    variables:
-    int64 var(dim) ;
-    data:
-
-    var = 0, 1, 2, 3 ;
-}
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">d</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s">&#39;dim&#39;</span><span class="p">,</span><span class="mi">4</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">v</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">&#39;var&#39;</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">int</span><span class="p">,</span> <span class="s">&#39;dim&#39;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">v</span><span class="p">[</span><span class="n">rank</span><span class="p">]</span> <span class="o">=</span> <span class="n">rank</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">nc</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
+
+<span class="o">%</span> <span class="n">ncdump</span> <span class="n">parallel_test</span><span class="o">.</span><span class="n">nc</span>
+<span class="n">netcdf</span> <span class="n">parallel_test</span> <span class="p">{</span>
+<span class="n">dimensions</span><span class="p">:</span>
+    <span class="n">dim</span> <span class="o">=</span> <span class="mi">4</span> <span class="p">;</span>
+    <span class="n">variables</span><span class="p">:</span>
+    <span class="n">int64</span> <span class="n">var</span><span class="p">(</span><span class="n">dim</span><span class="p">)</span> <span class="p">;</span>
+    <span class="n">data</span><span class="p">:</span>
+
+    <span class="n">var</span> <span class="o">=</span> <span class="mi">0</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="p">}</span>
+</pre></div>
+
+
 <p>There are two types of parallel IO, independent (the default) and collective.
 Independent IO means that each process can do IO independently. It should not
 depend on or be affected by other processes. Collective IO is a way of doing
@@ -2077,6 +2183,86 @@ <h2><div id='section13'>13) Parallel IO.</h2>
    you can read it).</li>
 <li>You cannot use variable-length (VLEN) data types. </li>
 </ul>
+<h2><div id='section14'>14) Dealing with strings.</h2>
+<p>The most flexible way to store arrays of strings is with the 
+<a href="#section11">Variable-length (vlen) string data type</a>. However, this requires
+the use of the NETCDF4 data model, and the vlen type does not map very well
+numpy arrays (you have to use numpy arrays of dtype=<code>object</code>, which are arrays of
+arbitrary python objects). numpy does have a fixed-width string array
+data type, but unfortunately the netCDF data model does not.
+Instead fixed-width byte strings are typically stored as <a href="https://www.unidata.ucar.edu/software/netcdf/docs/BestPractices.html#bp_Strings-and-Variables-of-type-char">arrays of 8-bit
+characters</a>.
+To perform the conversion to and from character arrays to fixed-width numpy string arrays, the
+following convention is followed by the python interface.
+If the <code>_Encoding</code> special attribute is set for a character array
+(dtype <code>S1</code>) variable, the <a href="#netCDF4.chartostring"><code>chartostring</code></a> utility function is used to convert the array of
+characters to an array of strings with one less dimension (the last dimension is
+interpreted as the length of each string) when reading the data. The character
+set (usually ascii) is specified by the <code>_Encoding</code> attribute. If <code>_Encoding</code>
+is 'none' or 'bytes', then the character array is converted to a numpy
+fixed-width byte string array (dtype <code>S#</code>), otherwise a numpy unicode (dtype
+<code>U#</code>) array is created.  When writing the data,
+<a href="#netCDF4.stringtochar"><code>stringtochar</code></a> is used to convert the numpy string array to an array of
+characters with one more dimension. For example,</p>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">nc</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s">&#39;stringtest.nc&#39;</span><span class="p">,</span><span class="s">&#39;w&#39;</span><span class="p">,</span><span class="n">format</span><span class="o">=</span><span class="s">&#39;NETCDF4_CLASSIC&#39;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">nc</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s">&#39;nchars&#39;</span><span class="p">,</span><span class="mi">3</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">nc</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s">&#39;nstrings&#39;</span><span class="p">,</span><span class="bp">None</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">v</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">&#39;strings&#39;</span><span class="p">,</span><span class="s">&#39;S1&#39;</span><span class="p">,(</span><span class="s">&#39;nstrings&#39;</span><span class="p">,</span><span class="s">&#39;nchars&#39;</span><span class="p">))</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">datain</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="s">&#39;foo&#39;</span><span class="p">,</span><span class="s">&#39;bar&#39;</span><span class="p">],</span><span class="n">dtype</span><span class="o">=</span><span class="s">&#39;S3&#39;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">v</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">stringtochar</span><span class="p">(</span><span class="n">datain</span><span class="p">)</span> <span class="c"># manual conversion to char array</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">v</span><span class="p">[:]</span> <span class="c"># data returned as char array</span>
+<span class="p">[[</span><span class="n">b</span><span class="s">&#39;f&#39;</span> <span class="n">b</span><span class="s">&#39;o&#39;</span> <span class="n">b</span><span class="s">&#39;o&#39;</span><span class="p">]</span>
+<span class="p">[</span><span class="n">b</span><span class="s">&#39;b&#39;</span> <span class="n">b</span><span class="s">&#39;a&#39;</span> <span class="n">b</span><span class="s">&#39;r&#39;</span><span class="p">]]</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">v</span><span class="o">.</span><span class="n">_Encoding</span> <span class="o">=</span> <span class="s">&#39;ascii&#39;</span> <span class="c"># this enables automatic conversion</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">v</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">datain</span> <span class="c"># conversion to char array done internally</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">v</span><span class="p">[:]</span> <span class="c"># data returned in numpy string array</span>
+<span class="p">[</span><span class="s">&#39;foo&#39;</span> <span class="s">&#39;bar&#39;</span><span class="p">]</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">nc</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
+</pre></div>
+
+
+<p>Even if the <code>_Encoding</code> attribute is set, the automatic conversion of char
+arrays to/from string arrays can be disabled with
+<a href="#netCDF4.Variable.set_auto_chartostring"><code>set_auto_chartostring</code></a>. </p>
+<p>A similar situation is often encountered with numpy structured arrays with subdtypes
+containing fixed-wdith byte strings (dtype=<code>S#</code>). Since there is no native fixed-length string
+netCDF datatype, these numpy structure arrays are mapped onto netCDF compound
+types with character array elements.  In this case the string &lt;-&gt; char array
+conversion is handled automatically (without the need to set the <code>_Encoding</code>
+attribute) using <a href="https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.view.html">numpy
+views</a>.
+The structured array dtype (including the string elements) can even be used to
+define the compound data type - the string dtype will be converted to
+character array dtype under the hood when creating the netcdf compound type.
+Here's an example:</p>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="n">nc</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s">&#39;compoundstring_example.nc&#39;</span><span class="p">,</span><span class="s">&#39;w&#39;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">dtype</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">dtype</span><span class="p">([(</span><span class="s">&#39;observation&#39;</span><span class="p">,</span> <span class="s">&#39;f4&#39;</span><span class="p">),</span>
+                  <span class="p">(</span><span class="s">&#39;station_name&#39;</span><span class="p">,</span><span class="s">&#39;S80&#39;</span><span class="p">)])</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">station_data_t</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">createCompoundType</span><span class="p">(</span><span class="n">dtype</span><span class="p">,</span><span class="s">&#39;station_data&#39;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">nc</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s">&#39;station&#39;</span><span class="p">,</span><span class="bp">None</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">statdat</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">&#39;station_obs&#39;</span><span class="p">,</span> <span class="n">station_data_t</span><span class="p">,</span> <span class="p">(</span><span class="s">&#39;station&#39;</span><span class="p">,))</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">data</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">empty</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="n">dtype</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">data</span><span class="p">[</span><span class="s">&#39;observation&#39;</span><span class="p">][:]</span> <span class="o">=</span> <span class="p">(</span><span class="mf">123.</span><span class="p">,</span><span class="mf">3.14</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">data</span><span class="p">[</span><span class="s">&#39;station_name&#39;</span><span class="p">][:]</span> <span class="o">=</span> <span class="p">(</span><span class="s">&#39;Boulder&#39;</span><span class="p">,</span><span class="s">&#39;New York&#39;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">statdat</span><span class="o">.</span><span class="n">dtype</span> <span class="c"># strings actually stored as character arrays</span>
+<span class="p">{</span><span class="s">&#39;names&#39;</span><span class="p">:[</span><span class="s">&#39;observation&#39;</span><span class="p">,</span><span class="s">&#39;station_name&#39;</span><span class="p">],</span> <span class="s">&#39;formats&#39;</span><span class="p">:[</span><span class="s">&#39;&lt;f4&#39;</span><span class="p">,(</span><span class="s">&#39;S1&#39;</span><span class="p">,</span> <span class="p">(</span><span class="mi">80</span><span class="p">,))],</span> <span class="s">&#39;offsets&#39;</span><span class="p">:[</span><span class="mi">0</span><span class="p">,</span><span class="mi">4</span><span class="p">],</span> <span class="s">&#39;itemsize&#39;</span><span class="p">:</span><span class="mi">84</span><span class="p">,</span> <span class="s">&#39;aligned&#39;</span><span class="p">:</span><span class="bp">True</span><span class="p">}</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">statdat</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">data</span> <span class="c"># strings converted to character arrays internally</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">statdat</span><span class="p">[:]</span> <span class="c"># character arrays converted back to strings</span>
+<span class="p">[(</span><span class="mf">123.</span>  <span class="p">,</span> <span class="s">&#39;Boulder&#39;</span><span class="p">)</span> <span class="p">(</span>  <span class="mf">3.14</span><span class="p">,</span> <span class="s">&#39;New York&#39;</span><span class="p">)]</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">statdat</span><span class="p">[:]</span><span class="o">.</span><span class="n">dtype</span>
+<span class="p">{</span><span class="s">&#39;names&#39;</span><span class="p">:[</span><span class="s">&#39;observation&#39;</span><span class="p">,</span><span class="s">&#39;station_name&#39;</span><span class="p">],</span> <span class="s">&#39;formats&#39;</span><span class="p">:[</span><span class="s">&#39;&lt;f4&#39;</span><span class="p">,</span><span class="s">&#39;S80&#39;</span><span class="p">],</span> <span class="s">&#39;offsets&#39;</span><span class="p">:[</span><span class="mi">0</span><span class="p">,</span><span class="mi">4</span><span class="p">],</span> <span class="s">&#39;itemsize&#39;</span><span class="p">:</span><span class="mi">84</span><span class="p">,</span> <span class="s">&#39;aligned&#39;</span><span class="p">:</span><span class="bp">True</span><span class="p">}</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">statdat</span><span class="o">.</span><span class="n">set_auto_chartostring</span><span class="p">(</span><span class="bp">False</span><span class="p">)</span> <span class="c"># turn off auto-conversion</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">statdat</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">data</span><span class="o">.</span><span class="n">view</span><span class="p">(</span><span class="n">dtype</span><span class="o">=</span><span class="p">[(</span><span class="s">&#39;observation&#39;</span><span class="p">,</span> <span class="s">&#39;f4&#39;</span><span class="p">),(</span><span class="s">&#39;station_name&#39;</span><span class="p">,</span><span class="s">&#39;S1&#39;</span><span class="p">,</span><span class="mi">10</span><span class="p">)])</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">statdat</span><span class="p">[:]</span> <span class="c"># now structured array with char array subtype is returned</span>
+<span class="p">[(</span><span class="mf">123.</span>  <span class="p">,</span> <span class="p">[</span><span class="s">&#39;B&#39;</span><span class="p">,</span> <span class="s">&#39;o&#39;</span><span class="p">,</span> <span class="s">&#39;u&#39;</span><span class="p">,</span> <span class="s">&#39;l&#39;</span><span class="p">,</span> <span class="s">&#39;d&#39;</span><span class="p">,</span> <span class="s">&#39;e&#39;</span><span class="p">,</span> <span class="s">&#39;r&#39;</span><span class="p">,</span> <span class="s">&#39;&#39;</span><span class="p">,</span> <span class="s">&#39;&#39;</span><span class="p">,</span> <span class="s">&#39;&#39;</span><span class="p">])</span>
+<span class="p">(</span>  <span class="mf">3.14</span><span class="p">,</span> <span class="p">[</span><span class="s">&#39;N&#39;</span><span class="p">,</span> <span class="s">&#39;e&#39;</span><span class="p">,</span> <span class="s">&#39;w&#39;</span><span class="p">,</span> <span class="s">&#39; &#39;</span><span class="p">,</span> <span class="s">&#39;Y&#39;</span><span class="p">,</span> <span class="s">&#39;o&#39;</span><span class="p">,</span> <span class="s">&#39;r&#39;</span><span class="p">,</span> <span class="s">&#39;k&#39;</span><span class="p">,</span> <span class="s">&#39;&#39;</span><span class="p">,</span> <span class="s">&#39;&#39;</span><span class="p">])]</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">nc</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
+</pre></div>
+
+
+<p>Note that there is currently no support for mapping numpy structured arrays with
+unicode elements (dtype <code>U#</code>) onto netCDF compound types, nor is there support 
+for netCDF compound types with vlen string components.</p>
 <p>All of the code in this tutorial is available in <code>examples/tutorial.py</code>, except
 the parallel IO example, which is in <code>examples/mpi_example.py</code>.
 Unit tests are in the <code>test</code> directory.</p>
@@ -2116,8 +2302,9 @@ <h2 class="section-title" id="header-functions">Functions</h2>
 Will be converted to a array of strings, where each string has a fixed
 length of <code>b.shape[-1]</code> characters.</p>
 <p>optional kwarg <code>encoding</code> can be used to specify character encoding (default
-<code>utf-8</code>).</p>
-<p>returns a numpy string array with datatype <code>'UN'</code> and shape
+<code>utf-8</code>). If <code>encoding</code> is 'none' or 'bytes', a <code>numpy.string_</code> btye array is
+returned.</p>
+<p>returns a numpy string array with datatype <code>'UN'</code> (or <code>'SN'</code>) and shape
 <code>b.shape[:-1]</code> where where <code>N=b.shape[-1]</code>.</p></div>
   <div class="source_cont">
 </div>
@@ -2290,7 +2477,8 @@ <h2 class="section-title" id="header-functions">Functions</h2>
 is the number of characters in each string.  Will be converted to
 an array of characters (datatype <code>'S1'</code> or <code>'U1'</code>) of shape <code>a.shape + (N,)</code>.</p>
 <p>optional kwarg <code>encoding</code> can be used to specify character encoding (default
-<code>utf-8</code>).</p>
+<code>utf-8</code>). If <code>encoding</code> is 'none' or 'bytes', a <code>numpy.string_</code> the input array
+is treated a raw byte strings (<code>numpy.string_</code>).</p>
 <p>returns a numpy character array with datatype <code>'S1'</code> or <code>'U1'</code>
 and shape <code>a.shape + (N,)</code>, where N is the length of each string in a.</p></div>
   <div class="source_cont">
@@ -2330,6 +2518,16 @@ <h3>Class variables</h3>
             
   
     <div class="desc"><p>A numpy dtype object describing the compound data type.</p></div>
+  <div class="source_cont">
+</div>
+
+            </div>
+            <div class="item">
+            <p id="netCDF4.CompoundType.dtype_view" class="name">var <span class="ident">dtype_view</span></p>
+            
+
+            
+  
   <div class="source_cont">
 </div>
 
@@ -2956,24 +3154,24 @@ <h3>Static methods</h3>
     <div class="desc"><p>Returns a list of variables that match specific conditions.</p>
 <p>Can pass in key=value parameters and variables are returned that
 contain all of the matches. For example, </p>
-<pre><code>:::python
-&gt;&gt;&gt; # Get variables with x-axis attribute.
-&gt;&gt;&gt; vs = nc.get_variables_by_attributes(axis='X')
-&gt;&gt;&gt; # Get variables with matching "standard_name" attribute
-&gt;&gt;&gt; vs = nc.get_variables_by_attributes(standard_name='northward_sea_water_velocity')
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="c"># Get variables with x-axis attribute.</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">axis</span><span class="o">=</span><span class="s">&#39;X&#39;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># Get variables with matching &quot;standard_name&quot; attribute</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">standard_name</span><span class="o">=</span><span class="s">&#39;northward_sea_water_velocity&#39;</span><span class="p">)</span>
+</pre></div>
+
+
 <p>Can pass in key=callable parameter and variables are returned if the
 callable returns True.  The callable should accept a single parameter,
 the attribute value.  None is given as the attribute value when the
 attribute does not exist on the variable. For example,</p>
-<pre><code>:::python
-&gt;&gt;&gt; # Get Axis variables
-&gt;&gt;&gt; vs = nc.get_variables_by_attributes(axis=lambda v: v in ['X', 'Y', 'Z', 'T'])
-&gt;&gt;&gt; # Get variables that don't have an "axis" attribute
-&gt;&gt;&gt; vs = nc.get_variables_by_attributes(axis=lambda v: v is None)
-&gt;&gt;&gt; # Get variables that have a "grid_mapping" attribute
-&gt;&gt;&gt; vs = nc.get_variables_by_attributes(grid_mapping=lambda v: v is not None)
-</code></pre></div>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="c"># Get Axis variables</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">axis</span><span class="o">=</span><span class="k">lambda</span> <span class="n">v</span><span class="p">:</span> <span class="n">v</span> <span class="ow">in</span> <span class="p">[</span><span class="s">&#39;X&#39;</span><span class="p">,</span> <span class="s">&#39;Y&#39;</span><span class="p">,</span> <span class="s">&#39;Z&#39;</span><span class="p">,</span> <span class="s">&#39;T&#39;</span><span class="p">])</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># Get variables that don&#39;t have an &quot;axis&quot; attribute</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">axis</span><span class="o">=</span><span class="k">lambda</span> <span class="n">v</span><span class="p">:</span> <span class="n">v</span> <span class="ow">is</span> <span class="bp">None</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># Get variables that have a &quot;grid_mapping&quot; attribute</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">grid_mapping</span><span class="o">=</span><span class="k">lambda</span> <span class="n">v</span><span class="p">:</span> <span class="n">v</span> <span class="ow">is</span> <span class="ow">not</span> <span class="bp">None</span><span class="p">)</span>
+</pre></div></div>
   <div class="source_cont">
 </div>
 
@@ -3238,8 +3436,7 @@ <h3>Static methods</h3>
   
     <div class="desc"><p>set a netCDF dataset or group string attribute using name,value pair.
 Use if you need to ensure that a netCDF attribute is created with type
-<code>NC_STRING</code> if the file format is <code>NETCDF4</code>.
-Use if you need to set an attribute to an array of variable-length strings.</p></div>
+<code>NC_STRING</code> if the file format is <code>NETCDF4</code>.</p></div>
   <div class="source_cont">
 </div>
 
@@ -3930,24 +4127,24 @@ <h3>Static methods</h3>
     <div class="desc"><p>Returns a list of variables that match specific conditions.</p>
 <p>Can pass in key=value parameters and variables are returned that
 contain all of the matches. For example, </p>
-<pre><code>:::python
-&gt;&gt;&gt; # Get variables with x-axis attribute.
-&gt;&gt;&gt; vs = nc.get_variables_by_attributes(axis='X')
-&gt;&gt;&gt; # Get variables with matching "standard_name" attribute
-&gt;&gt;&gt; vs = nc.get_variables_by_attributes(standard_name='northward_sea_water_velocity')
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="c"># Get variables with x-axis attribute.</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">axis</span><span class="o">=</span><span class="s">&#39;X&#39;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># Get variables with matching &quot;standard_name&quot; attribute</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">standard_name</span><span class="o">=</span><span class="s">&#39;northward_sea_water_velocity&#39;</span><span class="p">)</span>
+</pre></div>
+
+
 <p>Can pass in key=callable parameter and variables are returned if the
 callable returns True.  The callable should accept a single parameter,
 the attribute value.  None is given as the attribute value when the
 attribute does not exist on the variable. For example,</p>
-<pre><code>:::python
-&gt;&gt;&gt; # Get Axis variables
-&gt;&gt;&gt; vs = nc.get_variables_by_attributes(axis=lambda v: v in ['X', 'Y', 'Z', 'T'])
-&gt;&gt;&gt; # Get variables that don't have an "axis" attribute
-&gt;&gt;&gt; vs = nc.get_variables_by_attributes(axis=lambda v: v is None)
-&gt;&gt;&gt; # Get variables that have a "grid_mapping" attribute
-&gt;&gt;&gt; vs = nc.get_variables_by_attributes(grid_mapping=lambda v: v is not None)
-</code></pre></div>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="c"># Get Axis variables</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">axis</span><span class="o">=</span><span class="k">lambda</span> <span class="n">v</span><span class="p">:</span> <span class="n">v</span> <span class="ow">in</span> <span class="p">[</span><span class="s">&#39;X&#39;</span><span class="p">,</span> <span class="s">&#39;Y&#39;</span><span class="p">,</span> <span class="s">&#39;Z&#39;</span><span class="p">,</span> <span class="s">&#39;T&#39;</span><span class="p">])</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># Get variables that don&#39;t have an &quot;axis&quot; attribute</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">axis</span><span class="o">=</span><span class="k">lambda</span> <span class="n">v</span><span class="p">:</span> <span class="n">v</span> <span class="ow">is</span> <span class="bp">None</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># Get variables that have a &quot;grid_mapping&quot; attribute</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">grid_mapping</span><span class="o">=</span><span class="k">lambda</span> <span class="n">v</span><span class="p">:</span> <span class="n">v</span> <span class="ow">is</span> <span class="ow">not</span> <span class="bp">None</span><span class="p">)</span>
+</pre></div></div>
   <div class="source_cont">
 </div>
 
@@ -4212,8 +4409,7 @@ <h3>Static methods</h3>
   
     <div class="desc"><p>set a netCDF dataset or group string attribute using name,value pair.
 Use if you need to ensure that a netCDF attribute is created with type
-<code>NC_STRING</code> if the file format is <code>NETCDF4</code>.
-Use if you need to set an attribute to an array of variable-length strings.</p></div>
+<code>NC_STRING</code> if the file format is <code>NETCDF4</code>.</p></div>
   <div class="source_cont">
 </div>
 
@@ -4265,24 +4461,23 @@ <h3>Static methods</h3>
 or NETCDF3_64BIT_DATA</code> format (<code>NETCDF4</code> Datasets won't work).</p>
 <p>Adapted from <a href="http://pysclint.sourceforge.net/pycdf">pycdf</a> by Andre Gosselin.</p>
 <p>Example usage (See <a href="#netCDF4.MFDataset.__init__"><code>__init__</code></a> for more details):</p>
-<pre><code>:::python
-&gt;&gt;&gt; import numpy
-&gt;&gt;&gt; # create a series of netCDF files with a variable sharing
-&gt;&gt;&gt; # the same unlimited dimension.
-&gt;&gt;&gt; for nf in range(10):
-&gt;&gt;&gt;     f = Dataset("mftest%s.nc" % nf,"w")
-&gt;&gt;&gt;     f.createDimension("x",None)
-&gt;&gt;&gt;     x = f.createVariable("x","i",("x",))
-&gt;&gt;&gt;     x[0:10] = numpy.arange(nf*10,10*(nf+1))
-&gt;&gt;&gt;     f.close()
-&gt;&gt;&gt; # now read all those files in at once, in one Dataset.
-&gt;&gt;&gt; f = MFDataset("mftest*nc")
-&gt;&gt;&gt; print f.variables["x"][:]
-[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
- 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
- 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
- 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99]
-</code></pre></div>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="kn">import</span> <span class="nn">numpy</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># create a series of netCDF files with a variable sharing</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># the same unlimited dimension.</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">for</span> <span class="n">nf</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">10</span><span class="p">):</span>
+<span class="o">&gt;&gt;&gt;</span>     <span class="n">f</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s">&quot;mftest</span><span class="si">%s</span><span class="s">.nc&quot;</span> <span class="o">%</span> <span class="n">nf</span><span class="p">,</span><span class="s">&quot;w&quot;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span>     <span class="n">f</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s">&quot;x&quot;</span><span class="p">,</span><span class="bp">None</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span>     <span class="n">x</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">&quot;x&quot;</span><span class="p">,</span><span class="s">&quot;i&quot;</span><span class="p">,(</span><span class="s">&quot;x&quot;</span><span class="p">,))</span>
+<span class="o">&gt;&gt;&gt;</span>     <span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">:</span><span class="mi">10</span><span class="p">]</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="n">nf</span><span class="o">*</span><span class="mi">10</span><span class="p">,</span><span class="mi">10</span><span class="o">*</span><span class="p">(</span><span class="n">nf</span><span class="o">+</span><span class="mi">1</span><span class="p">))</span>
+<span class="o">&gt;&gt;&gt;</span>     <span class="n">f</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># now read all those files in at once, in one Dataset.</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">f</span> <span class="o">=</span> <span class="n">MFDataset</span><span class="p">(</span><span class="s">&quot;mftest*nc&quot;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">f</span><span class="o">.</span><span class="n">variables</span><span class="p">[</span><span class="s">&quot;x&quot;</span><span class="p">][:]</span>
+<span class="p">[</span> <span class="mi">0</span>  <span class="mi">1</span>  <span class="mi">2</span>  <span class="mi">3</span>  <span class="mi">4</span>  <span class="mi">5</span>  <span class="mi">6</span>  <span class="mi">7</span>  <span class="mi">8</span>  <span class="mi">9</span> <span class="mi">10</span> <span class="mi">11</span> <span class="mi">12</span> <span class="mi">13</span> <span class="mi">14</span> <span class="mi">15</span> <span class="mi">16</span> <span class="mi">17</span> <span class="mi">18</span> <span class="mi">19</span> <span class="mi">20</span> <span class="mi">21</span> <span class="mi">22</span> <span class="mi">23</span> <span class="mi">24</span>
+ <span class="mi">25</span> <span class="mi">26</span> <span class="mi">27</span> <span class="mi">28</span> <span class="mi">29</span> <span class="mi">30</span> <span class="mi">31</span> <span class="mi">32</span> <span class="mi">33</span> <span class="mi">34</span> <span class="mi">35</span> <span class="mi">36</span> <span class="mi">37</span> <span class="mi">38</span> <span class="mi">39</span> <span class="mi">40</span> <span class="mi">41</span> <span class="mi">42</span> <span class="mi">43</span> <span class="mi">44</span> <span class="mi">45</span> <span class="mi">46</span> <span class="mi">47</span> <span class="mi">48</span> <span class="mi">49</span>
+ <span class="mi">50</span> <span class="mi">51</span> <span class="mi">52</span> <span class="mi">53</span> <span class="mi">54</span> <span class="mi">55</span> <span class="mi">56</span> <span class="mi">57</span> <span class="mi">58</span> <span class="mi">59</span> <span class="mi">60</span> <span class="mi">61</span> <span class="mi">62</span> <span class="mi">63</span> <span class="mi">64</span> <span class="mi">65</span> <span class="mi">66</span> <span class="mi">67</span> <span class="mi">68</span> <span class="mi">69</span> <span class="mi">70</span> <span class="mi">71</span> <span class="mi">72</span> <span class="mi">73</span> <span class="mi">74</span>
+ <span class="mi">75</span> <span class="mi">76</span> <span class="mi">77</span> <span class="mi">78</span> <span class="mi">79</span> <span class="mi">80</span> <span class="mi">81</span> <span class="mi">82</span> <span class="mi">83</span> <span class="mi">84</span> <span class="mi">85</span> <span class="mi">86</span> <span class="mi">87</span> <span class="mi">88</span> <span class="mi">89</span> <span class="mi">90</span> <span class="mi">91</span> <span class="mi">92</span> <span class="mi">93</span> <span class="mi">94</span> <span class="mi">95</span> <span class="mi">96</span> <span class="mi">97</span> <span class="mi">98</span> <span class="mi">99</span><span class="p">]</span>
+</pre></div></div>
   <div class="source_cont">
 </div>
 
@@ -4736,24 +4931,24 @@ <h3>Static methods</h3>
     <div class="desc"><p>Returns a list of variables that match specific conditions.</p>
 <p>Can pass in key=value parameters and variables are returned that
 contain all of the matches. For example, </p>
-<pre><code>:::python
-&gt;&gt;&gt; # Get variables with x-axis attribute.
-&gt;&gt;&gt; vs = nc.get_variables_by_attributes(axis='X')
-&gt;&gt;&gt; # Get variables with matching "standard_name" attribute
-&gt;&gt;&gt; vs = nc.get_variables_by_attributes(standard_name='northward_sea_water_velocity')
-</code></pre>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="c"># Get variables with x-axis attribute.</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">axis</span><span class="o">=</span><span class="s">&#39;X&#39;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># Get variables with matching &quot;standard_name&quot; attribute</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">standard_name</span><span class="o">=</span><span class="s">&#39;northward_sea_water_velocity&#39;</span><span class="p">)</span>
+</pre></div>
+
+
 <p>Can pass in key=callable parameter and variables are returned if the
 callable returns True.  The callable should accept a single parameter,
 the attribute value.  None is given as the attribute value when the
 attribute does not exist on the variable. For example,</p>
-<pre><code>:::python
-&gt;&gt;&gt; # Get Axis variables
-&gt;&gt;&gt; vs = nc.get_variables_by_attributes(axis=lambda v: v in ['X', 'Y', 'Z', 'T'])
-&gt;&gt;&gt; # Get variables that don't have an "axis" attribute
-&gt;&gt;&gt; vs = nc.get_variables_by_attributes(axis=lambda v: v is None)
-&gt;&gt;&gt; # Get variables that have a "grid_mapping" attribute
-&gt;&gt;&gt; vs = nc.get_variables_by_attributes(grid_mapping=lambda v: v is not None)
-</code></pre></div>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="c"># Get Axis variables</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">axis</span><span class="o">=</span><span class="k">lambda</span> <span class="n">v</span><span class="p">:</span> <span class="n">v</span> <span class="ow">in</span> <span class="p">[</span><span class="s">&#39;X&#39;</span><span class="p">,</span> <span class="s">&#39;Y&#39;</span><span class="p">,</span> <span class="s">&#39;Z&#39;</span><span class="p">,</span> <span class="s">&#39;T&#39;</span><span class="p">])</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># Get variables that don&#39;t have an &quot;axis&quot; attribute</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">axis</span><span class="o">=</span><span class="k">lambda</span> <span class="n">v</span><span class="p">:</span> <span class="n">v</span> <span class="ow">is</span> <span class="bp">None</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># Get variables that have a &quot;grid_mapping&quot; attribute</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">vs</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">get_variables_by_attributes</span><span class="p">(</span><span class="n">grid_mapping</span><span class="o">=</span><span class="k">lambda</span> <span class="n">v</span><span class="p">:</span> <span class="n">v</span> <span class="ow">is</span> <span class="ow">not</span> <span class="bp">None</span><span class="p">)</span>
+</pre></div></div>
   <div class="source_cont">
 </div>
 
@@ -5019,8 +5214,7 @@ <h3>Static methods</h3>
   
     <div class="desc"><p>set a netCDF dataset or group string attribute using name,value pair.
 Use if you need to ensure that a netCDF attribute is created with type
-<code>NC_STRING</code> if the file format is <code>NETCDF4</code>.
-Use if you need to set an attribute to an array of variable-length strings.</p></div>
+<code>NC_STRING</code> if the file format is <code>NETCDF4</code>.</p></div>
   <div class="source_cont">
 </div>
 
@@ -5069,33 +5263,32 @@ <h3>Static methods</h3>
     <div class="desc"><p>Class providing an interface to a MFDataset time Variable by imposing a unique common
 time unit and/or calendar to all files.</p>
 <p>Example usage (See <a href="#netCDF4.MFTime.__init__"><code>__init__</code></a> for more details):</p>
-<pre><code>:::python
-&gt;&gt;&gt; import numpy
-&gt;&gt;&gt; f1 = Dataset("mftest_1.nc","w", format="NETCDF4_CLASSIC")
-&gt;&gt;&gt; f2 = Dataset("mftest_2.nc","w", format="NETCDF4_CLASSIC")
-&gt;&gt;&gt; f1.createDimension("time",None)
-&gt;&gt;&gt; f2.createDimension("time",None)
-&gt;&gt;&gt; t1 = f1.createVariable("time","i",("time",))
-&gt;&gt;&gt; t2 = f2.createVariable("time","i",("time",))
-&gt;&gt;&gt; t1.units = "days since 2000-01-01"
-&gt;&gt;&gt; t2.units = "days since 2000-02-01"
-&gt;&gt;&gt; t1.calendar = "standard"
-&gt;&gt;&gt; t2.calendar = "standard"
-&gt;&gt;&gt; t1[:] = numpy.arange(31)
-&gt;&gt;&gt; t2[:] = numpy.arange(30)
-&gt;&gt;&gt; f1.close()
-&gt;&gt;&gt; f2.close()
-&gt;&gt;&gt; # Read the two files in at once, in one Dataset.
-&gt;&gt;&gt; f = MFDataset("mftest*nc")
-&gt;&gt;&gt; t = f.variables["time"]
-&gt;&gt;&gt; print t.units
-days since 2000-01-01
-&gt;&gt;&gt; print t[32] # The value written in the file, inconsistent with the MF time units.
-1
-&gt;&gt;&gt; T = MFTime(t)
-&gt;&gt;&gt; print T[32]
-32
-</code></pre></div>
+<div class="codehilite"><pre><span class="o">&gt;&gt;&gt;</span> <span class="kn">import</span> <span class="nn">numpy</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">f1</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s">&quot;mftest_1.nc&quot;</span><span class="p">,</span><span class="s">&quot;w&quot;</span><span class="p">,</span> <span class="n">format</span><span class="o">=</span><span class="s">&quot;NETCDF4_CLASSIC&quot;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">f2</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s">&quot;mftest_2.nc&quot;</span><span class="p">,</span><span class="s">&quot;w&quot;</span><span class="p">,</span> <span class="n">format</span><span class="o">=</span><span class="s">&quot;NETCDF4_CLASSIC&quot;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">f1</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s">&quot;time&quot;</span><span class="p">,</span><span class="bp">None</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">f2</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s">&quot;time&quot;</span><span class="p">,</span><span class="bp">None</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">t1</span> <span class="o">=</span> <span class="n">f1</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">&quot;time&quot;</span><span class="p">,</span><span class="s">&quot;i&quot;</span><span class="p">,(</span><span class="s">&quot;time&quot;</span><span class="p">,))</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">t2</span> <span class="o">=</span> <span class="n">f2</span><span class="o">.</span><span class="n">createVariable</span><span class="p">(</span><span class="s">&quot;time&quot;</span><span class="p">,</span><span class="s">&quot;i&quot;</span><span class="p">,(</span><span class="s">&quot;time&quot;</span><span class="p">,))</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">t1</span><span class="o">.</span><span class="n">units</span> <span class="o">=</span> <span class="s">&quot;days since 2000-01-01&quot;</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">t2</span><span class="o">.</span><span class="n">units</span> <span class="o">=</span> <span class="s">&quot;days since 2000-02-01&quot;</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">t1</span><span class="o">.</span><span class="n">calendar</span> <span class="o">=</span> <span class="s">&quot;standard&quot;</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">t2</span><span class="o">.</span><span class="n">calendar</span> <span class="o">=</span> <span class="s">&quot;standard&quot;</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">t1</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">31</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">t2</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">30</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">f1</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">f2</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="c"># Read the two files in at once, in one Dataset.</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">f</span> <span class="o">=</span> <span class="n">MFDataset</span><span class="p">(</span><span class="s">&quot;mftest*nc&quot;</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">t</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="n">variables</span><span class="p">[</span><span class="s">&quot;time&quot;</span><span class="p">]</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">t</span><span class="o">.</span><span class="n">units</span>
+<span class="n">days</span> <span class="n">since</span> <span class="mi">2000</span><span class="o">-</span><span class="mo">01</span><span class="o">-</span><span class="mo">01</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">t</span><span class="p">[</span><span class="mi">32</span><span class="p">]</span> <span class="c"># The value written in the file, inconsistent with the MF time units.</span>
+<span class="mi">1</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="n">T</span> <span class="o">=</span> <span class="n">MFTime</span><span class="p">(</span><span class="n">t</span><span class="p">)</span>
+<span class="o">&gt;&gt;&gt;</span> <span class="k">print</span> <span class="n">T</span><span class="p">[</span><span class="mi">32</span><span class="p">]</span>
+<span class="mi">32</span>
+</pre></div></div>
   <div class="source_cont">
 </div>
 
@@ -5818,11 +6011,15 @@ <h3>Static methods</h3>
 <p>If <code>maskandscale</code> is set to <code>True</code>, and the variable has a
 <code>scale_factor</code> or an <code>add_offset</code> attribute, then data read
 from that variable is unpacked using::</p>
-<pre><code>data = self.scale_factor*data + self.add_offset
-</code></pre>
+<div class="codehilite"><pre>data = self.scale_factor*data + self.add_offset
+</pre></div>
+
+
 <p>When data is written to a variable it is packed using::</p>
-<pre><code>data = (data - self.add_offset)/self.scale_factor
-</code></pre>
+<div class="codehilite"><pre>data = (data - self.add_offset)/self.scale_factor
+</pre></div>
+
+
 <p>If either scale_factor is present, but add_offset is missing, add_offset
 is assumed zero.  If add_offset is present, but scale_factor is missing,
 scale_factor is assumed to be one.
@@ -5859,11 +6056,15 @@ <h3>Static methods</h3>
 <p>If <code>scale</code> is set to <code>True</code>, and the variable has a
 <code>scale_factor</code> or an <code>add_offset</code> attribute, then data read
 from that variable is unpacked using::</p>
-<pre><code>data = self.scale_factor*data + self.add_offset
-</code></pre>
+<div class="codehilite"><pre>data = self.scale_factor*data + self.add_offset
+</pre></div>
+
+
 <p>When data is written to a variable it is packed using::</p>
-<pre><code>data = (data - self.add_offset)/self.scale_factor
-</code></pre>
+<div class="codehilite"><pre>data = (data - self.add_offset)/self.scale_factor
+</pre></div>
+
+
 <p>If either scale_factor is present, but add_offset is missing, add_offset
 is assumed zero.  If add_offset is present, but scale_factor is missing,
 scale_factor is assumed to be one.
diff --git a/examples/tutorial.py b/examples/tutorial.py
index 78eb27fdf..1ead6ad63 100644
--- a/examples/tutorial.py
+++ b/examples/tutorial.py
@@ -162,18 +162,17 @@ def walktree(top):
 datac2.imag = datain['imag']
 print(datac.dtype,datac)
 print(datac2.dtype,datac2)
+
 # more complex compound type example.
-from netCDF4 import chartostring, stringtoarr
 f = Dataset('compound_example.nc','w') # create a new dataset.
 # create an unlimited  dimension call 'station'
 f.createDimension('station',None)
 # define a compound data type (can contain arrays, or nested compound types).
-NUMCHARS = 80 # number of characters to use in fixed-length strings.
 winddtype = numpy.dtype([('speed','f4'),('direction','i4')])
 statdtype = numpy.dtype([('latitude', 'f4'), ('longitude', 'f4'),
                          ('surface_wind',winddtype),
                          ('temp_sounding','f4',10),('press_sounding','i4',10),
-                         ('location_name','S1',NUMCHARS)])
+                         ('location_name','S12')])
 # use this data type definitions to create a compound data types
 # called using the createCompoundType Dataset method.
 # create a compound type for vector wind which will be nested inside
@@ -182,12 +181,12 @@ def walktree(top):
 # now that wind_data_t is defined, create the station data type.
 station_data_t = f.createCompoundType(statdtype,'station_data')
 # create nested compound data types to hold the units variable attribute.
-winddtype_units = numpy.dtype([('speed','S1',NUMCHARS),('direction','S1',NUMCHARS)])
-statdtype_units = numpy.dtype([('latitude', 'S1',NUMCHARS), ('longitude', 'S1',NUMCHARS),
+winddtype_units = numpy.dtype([('speed','S12'),('direction','S12')])
+statdtype_units = numpy.dtype([('latitude', 'S12'), ('longitude', 'S12'),
                                ('surface_wind',winddtype_units),
-                               ('temp_sounding','S1',NUMCHARS),
-                               ('location_name','S1',NUMCHARS),
-                               ('press_sounding','S1',NUMCHARS)])
+                               ('temp_sounding','S12'),
+                               ('location_name','S12'),
+                               ('press_sounding','S12')])
 # create the wind_data_units type first, since it will nested inside
 # the station_data_units data type.
 wind_data_units_t = f.createCompoundType(winddtype_units,'wind_data_units')
@@ -196,35 +195,33 @@ def walktree(top):
 # create a variable of of type 'station_data_t'
 statdat = f.createVariable('station_obs', station_data_t, ('station',))
 # create a numpy structured array, assign data to it.
-data = numpy.empty(1,station_data_t)
+data = numpy.empty(1,statdtype)
 data['latitude'] = 40.
 data['longitude'] = -105.
 data['surface_wind']['speed'] = 12.5
 data['surface_wind']['direction'] = 270
 data['temp_sounding'] = (280.3,272.,270.,269.,266.,258.,254.1,250.,245.5,240.)
 data['press_sounding'] = range(800,300,-50)
-# variable-length string datatypes are not supported inside compound types, so
-# to store strings in a compound data type, each string must be
-# stored as fixed-size (in this case 80) array of characters.
-data['location_name'] = stringtoarr('Boulder, Colorado, USA',NUMCHARS)
+data['location_name'] = 'Boulder, CO'
 # assign structured array to variable slice.
 statdat[0] = data
 # or just assign a tuple of values to variable slice
 # (will automatically be converted to a structured array).
-statdat[1] = (40.78,-73.99,(-12.5,90),
+statdat[1] = numpy.array((40.78,-73.99,(-12.5,90),
              (290.2,282.5,279.,277.9,276.,266.,264.1,260.,255.5,243.),
-             range(900,400,-50),stringtoarr('New York, New York, USA',NUMCHARS))
+             range(900,400,-50),'New York, NY'),data.dtype)
 print(f.cmptypes)
 windunits = numpy.empty(1,winddtype_units)
 stationobs_units = numpy.empty(1,statdtype_units)
-windunits['speed'] = stringtoarr('m/s',NUMCHARS)
-windunits['direction'] = stringtoarr('degrees',NUMCHARS)
-stationobs_units['latitude'] = stringtoarr('degrees north',NUMCHARS)
-stationobs_units['longitude'] = stringtoarr('degrees west',NUMCHARS)
+windunits['speed'] = 'm/s'
+windunits['direction'] = 'degrees'
+stationobs_units['latitude'] = 'degrees N'
+stationobs_units['longitude'] = 'degrees W'
 stationobs_units['surface_wind'] = windunits
-stationobs_units['location_name'] = stringtoarr('None', NUMCHARS)
-stationobs_units['temp_sounding'] = stringtoarr('Kelvin',NUMCHARS)
-stationobs_units['press_sounding'] = stringtoarr('hPa',NUMCHARS)
+stationobs_units['location_name'] = 'None'
+stationobs_units['temp_sounding'] = 'Kelvin'
+stationobs_units['press_sounding'] = 'hPa'
+print(stationobs_units.dtype)
 statdat.units = stationobs_units
 # close and reopen the file.
 f.close()
@@ -234,22 +231,7 @@ def walktree(top):
 print(statdat)
 # print out data in variable.
 print('data in a variable of compound type:')
-print('----')
-for data in statdat[:]:
-    for name in statdat.dtype.names:
-        if data[name].dtype.kind == 'S': # a string
-            # convert array of characters back to a string for display.
-            units = chartostring(statdat.units[name])
-            print(name,': value =',chartostring(data[name]),\
-                    ': units=',units)
-        elif data[name].dtype.kind == 'V': # a nested compound type
-            units_list = [chartostring(s) for s in tuple(statdat.units[name])]
-            print(name,data[name].dtype.names,': value=',data[name],': units=',\
-            units_list)
-        else: # a numeric type.
-            units = chartostring(statdat.units[name])
-            print(name,': value=',data[name],': units=',units)
-    print('----')
+print(statdat[:])
 f.close()
 
 f = Dataset('tst_vlen.nc','w')
@@ -306,3 +288,35 @@ def walktree(top):
 print(cloud_var.datatype.enum_dict)
 print(cloud_var[:])
 f.close()
+
+# dealing with strings
+from netCDF4 import stringtochar
+nc = Dataset('stringtest.nc','w',format='NETCDF4_CLASSIC')
+nc.createDimension('nchars',3)
+nc.createDimension('nstrings',None)
+v = nc.createVariable('strings','S1',('nstrings','nchars'))
+datain = numpy.array(['foo','bar'],dtype='S3')
+v[:] = stringtochar(datain) # manual conversion to char array
+print(v[:]) # data returned as char array
+v._Encoding = 'ascii' # this enables automatic conversion
+v[:] = datain # conversion to char array done internally
+print(v[:]) # data returned in numpy string array
+nc.close()
+# strings in compound types
+nc = Dataset('compoundstring_example.nc','w')
+dtype = numpy.dtype([('observation', 'f4'),
+                     ('station_name','S12')])
+station_data_t = nc.createCompoundType(dtype,'station_data')
+nc.createDimension('station',None)
+statdat = nc.createVariable('station_obs', station_data_t, ('station',))
+data = numpy.empty(2,station_data_t.dtype_view)
+data['observation'][:] = (123.,3.14)
+data['station_name'][:] = ('Boulder','New York')
+print(statdat.dtype) # strings actually stored as character arrays
+statdat[:] = data # strings converted to character arrays internally
+print(statdat[:]) # character arrays converted back to strings
+print(statdat[:].dtype)
+statdat.set_auto_chartostring(False) # turn off auto-conversion
+statdat[:] = data.view(station_data_t.dtype)
+print(statdat[:]) # now structured array with char array subtype is returned
+nc.close()
diff --git a/netCDF4/_netCDF4.pyx b/netCDF4/_netCDF4.pyx
index 89f707e2a..b65938d7e 100644
--- a/netCDF4/_netCDF4.pyx
+++ b/netCDF4/_netCDF4.pyx
@@ -112,6 +112,7 @@ Tutorial
 11. [Variable-length (vlen) data types.](#section11)
 12. [Enum data type.](#section12)
 13. [Parallel IO.](#section13)
+14. [Dealing with strings](#section14)
 
 
 ## <div id='section1'>1) Creating/Opening/Closing a netCDF file.
@@ -535,7 +536,7 @@ Hemisphere longitudes, resulting in a numpy array of shape  (3, 3, 36, 71).
     shape of fancy temp slice =  (3, 3, 36, 71)
 
 ***Special note for scalar variables***: To extract data from a scalar variable
-`v` with no associated dimensions, use `np.asarray(v)` or `v[...]`. The result
+`v` with no associated dimensions, use `numpy.asarray(v)` or `v[...]`. The result
 will be a numpy scalar array.
 
 ## <div id='section7'>7) Dealing with time coordinates.
@@ -932,7 +933,7 @@ written to a different variable index on each task
 
     :::python
     >>> d = nc.createDimension('dim',4)
-    >>> v = nc.createVariable('var', np.int, 'dim')
+    >>> v = nc.createVariable('var', numpy.int, 'dim')
     >>> v[rank] = rank
     >>> nc.close()
 
@@ -964,6 +965,89 @@ are collective.  There are a couple of important limitatons of parallel IO:
    you can read it).
  - You cannot use variable-length (VLEN) data types. 
 
+## <div id='section14'>14) Dealing with strings.
+
+The most flexible way to store arrays of strings is with the 
+[Variable-length (vlen) string data type](#section11). However, this requires
+the use of the NETCDF4 data model, and the vlen type does not map very well
+numpy arrays (you have to use numpy arrays of dtype=`object`, which are arrays of
+arbitrary python objects). numpy does have a fixed-width string array
+data type, but unfortunately the netCDF data model does not.
+Instead fixed-width byte strings are typically stored as [arrays of 8-bit
+characters](https://www.unidata.ucar.edu/software/netcdf/docs/BestPractices.html#bp_Strings-and-Variables-of-type-char).
+To perform the conversion to and from character arrays to fixed-width numpy string arrays, the
+following convention is followed by the python interface.
+If the `_Encoding` special attribute is set for a character array
+(dtype `S1`) variable, the `netCDF4.chartostring` utility function is used to convert the array of
+characters to an array of strings with one less dimension (the last dimension is
+interpreted as the length of each string) when reading the data. The character
+set (usually ascii) is specified by the `_Encoding` attribute. If `_Encoding`
+is 'none' or 'bytes', then the character array is converted to a numpy
+fixed-width byte string array (dtype `S#`), otherwise a numpy unicode (dtype
+`U#`) array is created.  When writing the data,
+`netCDF4.stringtochar` is used to convert the numpy string array to an array of
+characters with one more dimension. For example,
+
+    :::python
+    >>> nc = Dataset('stringtest.nc','w',format='NETCDF4_CLASSIC')
+    >>> nc.createDimension('nchars',3)
+    >>> nc.createDimension('nstrings',None)
+    >>> v = nc.createVariable('strings','S1',('nstrings','nchars'))
+    >>> datain = numpy.array(['foo','bar'],dtype='S3')
+    >>> v[:] = stringtochar(datain) # manual conversion to char array
+    >>> v[:] # data returned as char array
+    [[b'f' b'o' b'o']
+    [b'b' b'a' b'r']]
+    >>> v._Encoding = 'ascii' # this enables automatic conversion
+    >>> v[:] = datain # conversion to char array done internally
+    >>> v[:] # data returned in numpy string array
+    ['foo' 'bar']
+    >>> nc.close()
+
+Even if the `_Encoding` attribute is set, the automatic conversion of char
+arrays to/from string arrays can be disabled with
+`netCDF4.Variable.set_auto_chartostring`. 
+
+A similar situation is often encountered with numpy structured arrays with subdtypes
+containing fixed-wdith byte strings (dtype=`S#`). Since there is no native fixed-length string
+netCDF datatype, these numpy structure arrays are mapped onto netCDF compound
+types with character array elements.  In this case the string <-> char array
+conversion is handled automatically (without the need to set the `_Encoding`
+attribute) using [numpy
+views](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.view.html).
+The structured array dtype (including the string elements) can even be used to
+define the compound data type - the string dtype will be converted to
+character array dtype under the hood when creating the netcdf compound type.
+Here's an example:
+
+    :::python
+    >>> nc = Dataset('compoundstring_example.nc','w')
+    >>> dtype = numpy.dtype([('observation', 'f4'),
+                      ('station_name','S80')])
+    >>> station_data_t = nc.createCompoundType(dtype,'station_data')
+    >>> nc.createDimension('station',None)
+    >>> statdat = nc.createVariable('station_obs', station_data_t, ('station',))
+    >>> data = numpy.empty(2,dtype)
+    >>> data['observation'][:] = (123.,3.14)
+    >>> data['station_name'][:] = ('Boulder','New York')
+    >>> statdat.dtype # strings actually stored as character arrays
+    {'names':['observation','station_name'], 'formats':['<f4',('S1', (80,))], 'offsets':[0,4], 'itemsize':84, 'aligned':True}
+    >>> statdat[:] = data # strings converted to character arrays internally
+    >>> statdat[:] # character arrays converted back to strings
+    [(123.  , 'Boulder') (  3.14, 'New York')]
+    >>> statdat[:].dtype
+    {'names':['observation','station_name'], 'formats':['<f4','S80'], 'offsets':[0,4], 'itemsize':84, 'aligned':True}
+    >>> statdat.set_auto_chartostring(False) # turn off auto-conversion
+    >>> statdat[:] = data.view(dtype=[('observation', 'f4'),('station_name','S1',10)])
+    >>> statdat[:] # now structured array with char array subtype is returned
+    [(123.  , ['B', 'o', 'u', 'l', 'd', 'e', 'r', '', '', ''])
+    (  3.14, ['N', 'e', 'w', ' ', 'Y', 'o', 'r', 'k', '', ''])]
+    >>> nc.close()
+
+Note that there is currently no support for mapping numpy structured arrays with
+unicode elements (dtype `U#`) onto netCDF compound types, nor is there support 
+for netCDF compound types with vlen string components.
+
 All of the code in this tutorial is available in `examples/tutorial.py`, except
 the parallel IO example, which is in `examples/mpi_example.py`.
 Unit tests are in the `test` directory.
@@ -1236,7 +1320,7 @@ cdef _get_att(grp, int varid, name, encoding='utf-8'):
             # check if it's a compound
             try:
                 type_att = _read_compound(grp, att_type)
-                value_arr = numpy.empty(att_len,type_att)
+                value_arr = numpy.empty(att_len,type_att.dtype_view)
             except:
                 # check if it's an enum
                 try:
@@ -4052,6 +4136,13 @@ rename a `netCDF4.Variable` attribute named `oldname` to `newname`."""
                     if matchdim:
                         data = chartostring(data, encoding=encoding)
 
+        # if structure array contains char arrays, return view as strings
+        # if _Encoding att set (issue #773)
+        if self._iscompound and \
+           self._cmptype.dtype != self._cmptype.dtype_view and \
+           self.chartostring:
+#          self.chartostring and getattr(self,'_Encoding',None) is not None:
+                data = data.view(self._cmptype.dtype_view)
         return data
 
     def _toma(self,data):
@@ -4306,6 +4397,16 @@ cannot be safely cast to variable data type""" % attname
                     # of characters with one more dimension.
                     data = stringtochar(data, encoding=encoding)
 
+        # if structured data has strings (and _Encoding att set), create view as char arrays
+        # (issue #773)
+        if self._iscompound and \
+           self._cmptype.dtype != self._cmptype.dtype_view and \
+           _set_viewdtype(data.dtype) == self._cmptype.dtype_view and \
+           self.chartostring:
+#          self.chartostring and getattr(self,'_Encoding',None) is not None:
+                # may need to cast input data to aligned type
+                data = data.astype(self._cmptype.dtype_view).view(self._cmptype.dtype)
+
         if self._isvlen: # if vlen, should be object array (don't try casting)
             if self.dtype == str:
                 # for string vars, if data is not an array
@@ -4951,7 +5052,7 @@ The instance variables `dtype` and `name` should not be modified by
 the user.
     """
     cdef public nc_type _nc_type
-    cdef public dtype, name
+    cdef public dtype, dtype_view, name
     __pdoc__['CompoundType.name'] = \
     """String name."""
     __pdoc__['CompoundType.dtype'] = \
@@ -4991,13 +5092,21 @@ the user.
         # (this may or may not be still true, but empirical
         # evidence suggests that segfaults occur if this
         # alignment step is skipped - see issue #705).
+        # numpy string subdtypes (i.e. 'S80') are 
+        # automatically converted to character array
+        # subtypes (i.e. ('S1',80)).  If '_Encoding'
+        # variable attribute is set, data will be converted
+        # to and from the string array representation with views.
         dt = _set_alignment(numpy.dtype(dt))
+        # create a view datatype for converting char arrays to/from strings
+        dtview = _set_viewdtype(numpy.dtype(dt))
         if 'typeid' in kwargs:
             xtype = kwargs['typeid']
         else:
             xtype = _def_compound(grp, dt, dtype_name)
         self._nc_type = xtype
         self.dtype = dt
+        self.dtype_view = dtview
         self.name = dtype_name
 
     def __repr__(self):
@@ -5027,11 +5136,38 @@ def _set_alignment(dt):
                     raise TypeError('nested structured dtype arrays not supported')
                 else:
                     dtx = dt.fields[name][0]
+        else:
+            # convert character string elements to char arrays
+            if fmt.kind == 'S' and fmt.itemsize != 1:
+                dtx = numpy.dtype('(%s,)S1' % fmt.itemsize)
+            else:
+                # primitive data type
+                dtx = dt.fields[name][0]
+        formats.append(dtx)
+    # leave out offsets, they will be re-computed to preserve alignment.
+    dtype_dict = {'names':names,'formats':formats}
+    return numpy.dtype(dtype_dict, align=True)
+
+def _set_viewdtype(dt):
+    # recursively change character array dtypes to string dtypes
+    names = dt.names; formats = []
+    for name in names:
+        fmt = dt.fields[name][0]
+        if fmt.kind == 'V':
+            if fmt.shape == ():
+                dtx = _set_viewdtype(dt.fields[name][0])
+            else:
+                if fmt.subdtype[0].kind == 'V': # structured dtype
+                    raise TypeError('nested structured dtype arrays not supported')
+                elif fmt.subdtype[0].kind == 'S' and len(dt.fields[name][0].shape) == 1:
+                    lenchar = dt.fields[name][0].shape[0]
+                    dtx = numpy.dtype('S%s' % lenchar)
+                else:
+                    dtx = dt.fields[name][0]
         else:
             # primitive data type
             dtx = dt.fields[name][0]
         formats.append(dtx)
-    # leave out offsets, they will be re-computed to preserve alignment.
     dtype_dict = {'names':names,'formats':formats}
     return numpy.dtype(dtype_dict, align=True)
 
@@ -5118,9 +5254,10 @@ cdef _find_cmptype(grp, dtype):
         names2 = cmpdt.dtype.fields.keys()
         formats1 = [v[0] for v in dtype.fields.values()]
         formats2 = [v[0] for v in cmpdt.dtype.fields.values()]
+        formats2v = [v[0] for v in cmpdt.dtype_view.fields.values()]
         # match names, formats, but not offsets (they may be changed
         # by netcdf lib).
-        if names1==names2 and formats1==formats2:
+        if names1==names2 and formats1==formats2 or (formats1 == formats2v):
             match = True
             break
     if not match:
@@ -5508,14 +5645,18 @@ is the number of characters in each string.  Will be converted to
 an array of characters (datatype `'S1'` or `'U1'`) of shape `a.shape + (N,)`.
 
 optional kwarg `encoding` can be used to specify character encoding (default
-`utf-8`).
+`utf-8`). If `encoding` is 'none' or 'bytes', a `numpy.string_` the input array
+is treated a raw byte strings (`numpy.string_`).
 
 returns a numpy character array with datatype `'S1'` or `'U1'`
 and shape `a.shape + (N,)`, where N is the length of each string in a."""
     dtype = a.dtype.kind
     if dtype not in ["S","U"]:
         raise ValueError("type must string or unicode ('S' or 'U')")
-    b = numpy.array(tuple(a.tostring().decode(encoding)),dtype+'1')
+    if encoding in ['none','None','bytes']:
+        b = numpy.array(tuple(a.tostring()),'S1')
+    else:
+        b = numpy.array(tuple(a.tostring().decode(encoding)),dtype+'1')
     b.shape = a.shape + (a.itemsize,)
     return b
 
@@ -5530,16 +5671,23 @@ Will be converted to a array of strings, where each string has a fixed
 length of `b.shape[-1]` characters.
 
 optional kwarg `encoding` can be used to specify character encoding (default
-`utf-8`).
+`utf-8`). If `encoding` is 'none' or 'bytes', a `numpy.string_` btye array is
+returned.
 
-returns a numpy string array with datatype `'UN'` and shape
+returns a numpy string array with datatype `'UN'` (or `'SN'`) and shape
 `b.shape[:-1]` where where `N=b.shape[-1]`."""
     dtype = b.dtype.kind
     if dtype not in ["S","U"]:
         raise ValueError("type must be string or unicode ('S' or 'U')")
-    bs = b.tostring().decode(encoding)
+    if encoding in ['none','None','bytes']:
+        bs = b.tostring()
+    else:
+        bs = b.tostring().decode(encoding)
     slen = int(b.shape[-1])
-    a = numpy.array([bs[n1:n1+slen] for n1 in range(0,len(bs),slen)],'U'+repr(slen))
+    if encoding in ['none','None','bytes']:
+        a = numpy.array([bs[n1:n1+slen] for n1 in range(0,len(bs),slen)],'S'+repr(slen))
+    else:
+        a = numpy.array([bs[n1:n1+slen] for n1 in range(0,len(bs),slen)],'U'+repr(slen))
     a.shape = b.shape[:-1]
     return a
 
diff --git a/test/tst_compoundatt.py b/test/tst_compoundatt.py
index 47eb8af2e..fa90e7d0f 100644
--- a/test/tst_compoundatt.py
+++ b/test/tst_compoundatt.py
@@ -2,7 +2,7 @@
 import unittest
 import os
 import tempfile
-from netCDF4 import Dataset, CompoundType, chartostring, stringtoarr
+from netCDF4 import Dataset, CompoundType
 import numpy as np
 from numpy.testing import assert_array_equal, assert_array_almost_equal
 
@@ -16,15 +16,13 @@
 dtype=np.dtype([('speed', 'f4'), ('direction', 'f4')])
 TYPE_NAME = 'wind_vector_type'
 TYPE_NAMEC = 'wind_vectorunits_type'
-dtypec=np.dtype([('speed', 'c',(8,)), ('direction', 'c',(8,))])
+dtypec=np.dtype([('speed', 'S8'), ('direction', 'S8')])
 missvals = np.empty(1,dtype)
 missvals['direction']=1.e20
 missvals['speed']=-999.
-windunits = np.zeros(1,dtypec)
-windunits['speed'] = stringtoarr('m/s',\
-        dtypec.fields['speed'][0].itemsize)
-windunits['direction'] = stringtoarr('degrees',\
-        dtypec.fields['direction'][0].itemsize)
+windunits = np.empty(1,dtypec)
+windunits['speed'] = 'm/s'
+windunits['direction'] = 'degrees'
 
 class VariablesTestCase(unittest.TestCase):
 
@@ -65,10 +63,10 @@ def runTest(self):
         assert_array_equal(vv.units['speed'], windunits['speed'].squeeze())
         assert_array_equal(vv.units['direction'],\
                 windunits['direction'].squeeze())
-        assert(chartostring(v.units['speed']).item().rstrip() == 'm/s')
-        assert(chartostring(v.units['direction']).item().rstrip() == 'degrees')
-        assert(chartostring(vv.units['speed']).item().rstrip() == 'm/s')
-        assert(chartostring(vv.units['direction']).item().rstrip() == 'degrees')
+        assert(v.units['speed'] == b'm/s')
+        assert(v.units['direction'] == b'degrees')
+        assert(vv.units['speed'] == b'm/s')
+        assert(vv.units['direction'] == b'degrees')
         f.close()
 
 if __name__ == '__main__':
diff --git a/test/tst_compoundvar.py b/test/tst_compoundvar.py
index 1ad87f8ba..72b689206 100644
--- a/test/tst_compoundvar.py
+++ b/test/tst_compoundvar.py
@@ -111,6 +111,30 @@ def runTest(self):
         assert_array_almost_equal(dataoutg['y1']['x'],datag['y1']['x'])
         assert_array_almost_equal(dataoutg['y1']['y'],datag['y1']['y'])
         f.close()
+        # issue 773
+        f = Dataset(self.file,'w')
+        dtype = np.dtype([('observation', 'i4'),
+                          ('station_name','S80')])
+        dtype_nest = np.dtype([('observation', 'i4'),
+                               ('station_name','S80'),
+                               ('nested_observation',dtype)])
+        station_data_t1 = f.createCompoundType(dtype,'station_data1')
+        station_data_t2 = f.createCompoundType(dtype_nest,'station_data')
+        f.createDimension('station',None)
+        statdat = f.createVariable('station_obs', station_data_t2, ('station',))
+        assert(statdat.dtype == station_data_t2.dtype)
+        datain = np.empty(2,station_data_t2.dtype_view)
+        datain['observation'][:] = (123,314)
+        datain['station_name'][:] = ('Boulder','New York')
+        datain['nested_observation']['observation'][:] = (-999,999)
+        datain['nested_observation']['station_name'][:] = ('Boston','Chicago')
+        statdat[:] = datain
+        f.close()
+        f = Dataset(self.file)
+        dataout = f['station_obs'][:]
+        assert(dataout.dtype == station_data_t2.dtype_view)
+        assert_array_equal(datain, dataout)
+        f.close()
 
 if __name__ == '__main__':
     from netCDF4 import getlibversion