Commit 8155fb8be7f8ee19f793a110d1acc81f9bafbaab - netcdf4-python

New upstream version 1.5.4 Bas Couwenberg 3 years ago

13 changed file(s) with 1118 addition(s) and 815 deletion(s). Raw diff Collapse all Expand all

+31

-27

.appveyor.yml less more

0	0	environment:
1		CONDA_INSTALL_LOCN: C:\\Miniconda36-x64
	1	PYTHON: "C:\\myminiconda3"
2	2	matrix:
3		- TARGET_ARCH: x64
4		NPY: 1.16
5		PY: 3.6
6
7		- TARGET_ARCH: x64
8		NPY: 1.16
	3	- NPY: 1.17
9	4	PY: 3.7
10	5
11		platform:
12		- x64
	6	- NPY: 1.17
	7	PY: 3.8
	8
	9	init:
	10	- "ECHO %PYTHON_VERSION% %MINICONDA%"
13	11
14	12	install:
15	13	# If there is a newer build queued for the same PR, cancel this one.

23	21	throw "There are newer queued builds for this pull request, failing early." }
24	22
25	23	# Add path, activate `conda` and update conda.
26		- cmd: call %CONDA_INSTALL_LOCN%\Scripts\activate.bat
27		- cmd: conda config --set always_yes yes --set changeps1 no --set show_channel_urls true
28		- cmd: conda update conda
29		- cmd: conda config --add channels conda-forge --force
30		- cmd: conda config --set channel_priority strict
31		- cmd: set PYTHONUNBUFFERED=1
32		- cmd: conda install conda-build vs2008_express_vc_python_patch
33		- cmd: call setup_x64
	24	- set URL="https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe"
	25	- curl -fsS -o miniconda3.exe %URL%
	26	- start /wait "" miniconda3.exe /InstallationType=JustMe /RegisterPython=0 /S /D=%PYTHON%
34	27
35		- cmd: conda create --name TEST python=%PY% numpy=%NPY% cython pip pytest hdf5 libnetcdf cftime
36		- cmd: conda info --all
37		- cmd: conda activate TEST
	28	- "set PATH=%PYTHON%;%PYTHON%\\Scripts;%PATH%"
	29	- call %PYTHON%\Scripts\activate
38	30
39		- cmd: echo [options] > setup.cfg
40		- cmd: echo [directories] >> setup.cfg
41		- cmd: echo HDF5_libdir = %CONDA_PREFIX%\Library\lib >> setup.cfg
42		- cmd: echo HDF5_incdir = %CONDA_PREFIX%\Library\include >> setup.cfg
43		- cmd: echo netCDF4_libdir = %CONDA_PREFIX%\Library\lib >> setup.cfg
44		- cmd: echo netCDF4_incdir = %CONDA_PREFIX%\Library\include >> setup.cfg
	31	- conda config --set always_yes yes --set changeps1 no --set show_channel_urls true
	32	- conda config --add channels conda-forge --force
	33	- set PYTHONUNBUFFERED=1
	34	- conda install conda-build vs2008_express_vc_python_patch
	35	- call setup_x64
	36
	37	- conda create --name TEST python=%PY% numpy=%NPY% cython pip pytest hdf5 libnetcdf cftime
	38	- conda activate TEST
	39
	40	- echo [options] > setup.cfg
	41	- echo [directories] >> setup.cfg
	42	- echo HDF5_libdir = %CONDA_PREFIX%\Library\lib >> setup.cfg
	43	- echo HDF5_incdir = %CONDA_PREFIX%\Library\include >> setup.cfg
	44	- echo netCDF4_libdir = %CONDA_PREFIX%\Library\lib >> setup.cfg
	45	- echo netCDF4_incdir = %CONDA_PREFIX%\Library\include >> setup.cfg
	46
	47	- conda info --all
	48	- conda list
45	49
46	50	# Skip .NET project specific build phase.
47	51	build: off
48	52
49	53	test_script:
50		- python -m pip install . --no-deps --ignore-installed --no-cache-dir -vvv
	54	- python -m pip install . --no-deps --ignore-installed --no-cache-dir -vv
51	55	- set NO_NET=1
52	56	- cd test && python run_all.py

-29

.travis.yml less more

15	15	- MPI=0
16	16
17	17	python:
18		- "2.7"
19		- "3.5"
20	18	- "3.6"
21	19	- "3.7"
22		- "3.8-dev"
	20	- "3.8"
23	21
24	22	matrix:
25	23	allow_failures:
26		- python: "3.8-dev"
27		- python: 3.7
	24	- python: 3.8
28	25	env:
29	26	- MPI=1
30	27	- CC=mpicc.mpich

33	30	- NETCDF_DIR=$HOME
34	31	- PATH=${NETCDF_DIR}/bin:${PATH} # pick up nc-config here
35	32	include:
36		# Absolute minimum dependencies.
37		- python: 2.7
38		env:
39		- DEPENDS="numpy==1.10.0 cython==0.21 ordereddict==1.1 setuptools==18.0 cftime"
40	33	# test MPI with latest released version
41		- python: 3.7
	34	- python: 3.8
42	35	env:
43	36	- MPI=1
44	37	- CC=mpicc.mpich
45	38	- DEPENDS="numpy>=1.10.0 cython>=0.21 setuptools>=18.0 mpi4py>=1.3.1 cftime"
46		- NETCDF_VERSION=4.6.3
47		- NETCDF_DIR=$HOME
48		- PATH=${NETCDF_DIR}/bin:${PATH} # pick up nc-config here
49		addons:
50		apt:
51		packages:
52		- mpich
53		- libmpich-dev
54		- libhdf5-mpich-dev
55		# test MPI with latest released version
56		- python: 3.7
57		env:
58		- MPI=1
59		- CC=mpicc.mpich
60		- DEPENDS="numpy>=1.10.0 cython>=0.21 setuptools>=18.0 mpi4py>=1.3.1 cftime"
61		- NETCDF_VERSION=4.6.3
62		- PNETCDF_VERSION=1.11.0
	39	- NETCDF_VERSION=4.7.3
	40	- PNETCDF_VERSION=1.12.1
63	41	- NETCDF_DIR=$HOME
64	42	- PATH=${NETCDF_DIR}/bin:${PATH} # pick up nc-config here
65	43	addons:

69	47	- libmpich-dev
70	48	- libhdf5-mpich-dev
71	49	# test with netcdf-c from github master
72		- python: 3.7
	50	- python: 3.8
73	51	env:
74	52	- MPI=1
75	53	- CC=mpicc.mpich

88	66	email: false
89	67
90	68	before_install:
91		- pip install Cython # workaround for pip bug
92	69	- pip install $DEPENDS
93	70
94	71	install:

+15

-0

Changelog less more

	0	version 1.5.4 (tag v1.5.4rel)
	1	==============================
	2	* fix printing of variable objects for variables that end with the letter 'u'
	3	(issue #983).
	4	* make sure root group has 'name' attribute (issue #988).
	5	* add the ability to pack vlen floats to integers using
	6	scale_factor/add_offset (issue #1003)
	7	* use len instead of deprecated numpy.alen (issue #1008)
	8	* check size on valid_range instead of using len (issue #1013).
	9	* add `set_chunk_cache/get_chunk_cache` module functions to reset the
	10	default chunk cache sizes before opening a Dataset (issue #1018).
	11	* replace use of numpy's deprecated tostring() method with tobytes()
	12	(issue #1023).
	13	* bump minimal numpy version to 1.9 (first version to have tobytes()).
	14
0	15	version 1.5.3 (tag v1.5.3rel)
1	16	==============================
2	17	* make sure arrays are masked that are not filled when auto_fill is off

-0

README.md less more

9	9	## News
10	10	For details on the latest updates, see the [Changelog](https://github.com/Unidata/netcdf4-python/blob/master/Changelog).
11	11
	12	07/23/2020: Version [1.5.4](https://pypi.python.org/pypi/netCDF4/1.5.4) released]. Now requires
	13	numpy >= 1.9.
	14
12	15	10/27/2019: Version [1.5.3](https://pypi.python.org/pypi/netCDF4/1.5.3) released]. Fix for
13	16	[issue #972](https://github.com/Unidata/netcdf4-python/issues/972), plus binary wheels for
14	17	python 3.8.

+834

-654

docs/netCDF4/index.html less more

3	3	<meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1" />
4	4
5	5	<title>netCDF4 API documentation</title>
6		<meta name="description" content="Version 1.5.3
	6	<meta name="description" content="Version 1.5.4
7	7	---------------
8	8	- - -
9	9

857	857
858	858	</style>
859	859
	860	<style type="text/css">
	861	.codehilite .hll { background-color: #ffffcc }
	862	.codehilite { background: #f8f8f8; }
	863	.codehilite .c { color: #408080; font-style: italic } /* Comment */
	864	.codehilite .err { border: 1px solid #FF0000 } /* Error */
	865	.codehilite .k { color: #008000; font-weight: bold } /* Keyword */
	866	.codehilite .o { color: #666666 } /* Operator */
	867	.codehilite .ch { color: #408080; font-style: italic } /* Comment.Hashbang */
	868	.codehilite .cm { color: #408080; font-style: italic } /* Comment.Multiline */
	869	.codehilite .cp { color: #BC7A00 } /* Comment.Preproc */
	870	.codehilite .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */
	871	.codehilite .c1 { color: #408080; font-style: italic } /* Comment.Single */
	872	.codehilite .cs { color: #408080; font-style: italic } /* Comment.Special */
	873	.codehilite .gd { color: #A00000 } /* Generic.Deleted */
	874	.codehilite .ge { font-style: italic } /* Generic.Emph */
	875	.codehilite .gr { color: #FF0000 } /* Generic.Error */
	876	.codehilite .gh { color: #000080; font-weight: bold } /* Generic.Heading */
	877	.codehilite .gi { color: #00A000 } /* Generic.Inserted */
	878	.codehilite .go { color: #888888 } /* Generic.Output */
	879	.codehilite .gp { color: #000080; font-weight: bold } /* Generic.Prompt */
	880	.codehilite .gs { font-weight: bold } /* Generic.Strong */
	881	.codehilite .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
	882	.codehilite .gt { color: #0044DD } /* Generic.Traceback */
	883	.codehilite .kc { color: #008000; font-weight: bold } /* Keyword.Constant */
	884	.codehilite .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */
	885	.codehilite .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */
	886	.codehilite .kp { color: #008000 } /* Keyword.Pseudo */
	887	.codehilite .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */
	888	.codehilite .kt { color: #B00040 } /* Keyword.Type */
	889	.codehilite .m { color: #666666 } /* Literal.Number */
	890	.codehilite .s { color: #BA2121 } /* Literal.String */
	891	.codehilite .na { color: #7D9029 } /* Name.Attribute */
	892	.codehilite .nb { color: #008000 } /* Name.Builtin */
	893	.codehilite .nc { color: #0000FF; font-weight: bold } /* Name.Class */
	894	.codehilite .no { color: #880000 } /* Name.Constant */
	895	.codehilite .nd { color: #AA22FF } /* Name.Decorator */
	896	.codehilite .ni { color: #999999; font-weight: bold } /* Name.Entity */
	897	.codehilite .ne { color: #D2413A; font-weight: bold } /* Name.Exception */
	898	.codehilite .nf { color: #0000FF } /* Name.Function */
	899	.codehilite .nl { color: #A0A000 } /* Name.Label */
	900	.codehilite .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */
	901	.codehilite .nt { color: #008000; font-weight: bold } /* Name.Tag */
	902	.codehilite .nv { color: #19177C } /* Name.Variable */
	903	.codehilite .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */
	904	.codehilite .w { color: #bbbbbb } /* Text.Whitespace */
	905	.codehilite .mb { color: #666666 } /* Literal.Number.Bin */
	906	.codehilite .mf { color: #666666 } /* Literal.Number.Float */
	907	.codehilite .mh { color: #666666 } /* Literal.Number.Hex */
	908	.codehilite .mi { color: #666666 } /* Literal.Number.Integer */
	909	.codehilite .mo { color: #666666 } /* Literal.Number.Oct */
	910	.codehilite .sa { color: #BA2121 } /* Literal.String.Affix */
	911	.codehilite .sb { color: #BA2121 } /* Literal.String.Backtick */
	912	.codehilite .sc { color: #BA2121 } /* Literal.String.Char */
	913	.codehilite .dl { color: #BA2121 } /* Literal.String.Delimiter */
	914	.codehilite .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */
	915	.codehilite .s2 { color: #BA2121 } /* Literal.String.Double */
	916	.codehilite .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */
	917	.codehilite .sh { color: #BA2121 } /* Literal.String.Heredoc */
	918	.codehilite .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */
	919	.codehilite .sx { color: #008000 } /* Literal.String.Other */
	920	.codehilite .sr { color: #BB6688 } /* Literal.String.Regex */
	921	.codehilite .s1 { color: #BA2121 } /* Literal.String.Single */
	922	.codehilite .ss { color: #19177C } /* Literal.String.Symbol */
	923	.codehilite .bp { color: #008000 } /* Name.Builtin.Pseudo */
	924	.codehilite .fm { color: #0000FF } /* Name.Function.Magic */
	925	.codehilite .vc { color: #19177C } /* Name.Variable.Class */
	926	.codehilite .vg { color: #19177C } /* Name.Variable.Global */
	927	.codehilite .vi { color: #19177C } /* Name.Variable.Instance */
	928	.codehilite .vm { color: #19177C } /* Name.Variable.Magic */
	929	.codehilite .il { color: #666666 } /* Literal.Number.Integer.Long */
	930	</style>
860	931
861	932	<style type="text/css">
862	933

982	1053	<li class="mono"><a href="#netCDF4.chartostring">chartostring</a></li>
983	1054	<li class="mono"><a href="#netCDF4.date2index">date2index</a></li>
984	1055	<li class="mono"><a href="#netCDF4.date2num">date2num</a></li>
	1056	<li class="mono"><a href="#netCDF4.get_chunk_cache">get_chunk_cache</a></li>
985	1057	<li class="mono"><a href="#netCDF4.getlibversion">getlibversion</a></li>
986	1058	<li class="mono"><a href="#netCDF4.num2date">num2date</a></li>
	1059	<li class="mono"><a href="#netCDF4.set_chunk_cache">set_chunk_cache</a></li>
987	1060	<li class="mono"><a href="#netCDF4.stringtoarr">stringtoarr</a></li>
988	1061	<li class="mono"><a href="#netCDF4.stringtochar">stringtochar</a></li>
989	1062	</ul>

1208	1281
1209	1282	<header id="section-intro">
1210	1283	<h1 class="title"><span class="name">netCDF4</span> module</h1>
1211		<h2>Version 1.5.3</h2>
	1284	<h2>Version 1.5.4</h2>
1212	1285	<hr />
1213	1286	<h1>Introduction</h1>
1214	1287	<p>netcdf4-python is a Python interface to the netCDF C library.</p>

1236	1309	</ul>
1237	1310	<h1>Requires</h1>
1238	1311	<ul>
1239		<li>Python 2.7 or later (python 3 works too).</li>
1240	1312	<li><a href="http://numpy.scipy.org">numpy array module</a>, version 1.10.0 or later.</li>
1241	1313	<li><a href="http://cython.org">Cython</a>, version 0.21 or later.</li>
1242	1314	<li><a href="https://pypi.python.org/pypi/setuptools">setuptools</a>, version 18.0 or

1341	1413	accomplished via the <a href="#netCDF4.Dataset.close"><code>close</code></a> method of the <a href="#netCDF4.Dataset"><code>Dataset</code></a>
1342	1414	instance.</p>
1343	1415	<p>Here's an example:</p>
1344		<pre><code>:::python
1345		>>> from netCDF4 import Dataset
1346		>>> rootgrp = Dataset("test.nc", "w", format="NETCDF4")
1347		>>> print(rootgrp.data_model)
1348		NETCDF4
1349		>>> rootgrp.close()
1350		</code></pre>
	1416	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="kn">from</span> <span class="nn">netCDF4</span> <span class="kn">import</span> <span class="n">Dataset</span>
	1417	<span class="o">>>></span> <span class="n">rootgrp</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s2">"test.nc"</span><span class="p">,</span> <span class="s2">"w"</span><span class="p">,</span> <span class="nb">format</span><span class="o">=</span><span class="s2">"NETCDF4"</span><span class="p">)</span>
	1418	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">rootgrp</span><span class="o">.</span><span class="n">data_model</span><span class="p">)</span>
	1419	<span class="n">NETCDF4</span>
	1420	<span class="o">>>></span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
	1421	</code></pre></div>
	1422
	1423
1351	1424	<p>Remote <a href="http://opendap.org">OPeNDAP</a>-hosted datasets can be accessed for
1352	1425	reading over http if a URL is provided to the <a href="#netCDF4.Dataset"><code>Dataset</code></a> constructor instead of a
1353	1426	filename. However, this requires that the netCDF library be built with

1367	1440	the <code>groups</code> dictionary attribute of the <a href="#netCDF4.Dataset"><code>Dataset</code></a> instance. Only
1368	1441	<code>NETCDF4</code> formatted files support Groups, if you try to create a Group
1369	1442	in a netCDF 3 file you will get an error message.</p>
1370		<pre><code>:::python
1371		>>> rootgrp = Dataset("test.nc", "a")
1372		>>> fcstgrp = rootgrp.createGroup("forecasts")
1373		>>> analgrp = rootgrp.createGroup("analyses")
1374		>>> print(rootgrp.groups)
1375		{'forecasts': <class 'netCDF4._netCDF4.Group'>
1376		group /forecasts:
1377		dimensions(sizes):
1378		variables(dimensions):
1379		groups: , 'analyses': <class 'netCDF4._netCDF4.Group'>
1380		group /analyses:
1381		dimensions(sizes):
1382		variables(dimensions):
1383		groups: }
1384		</code></pre>
	1443	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="n">rootgrp</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s2">"test.nc"</span><span class="p">,</span> <span class="s2">"a"</span><span class="p">)</span>
	1444	<span class="o">>>></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="s2">"forecasts"</span><span class="p">)</span>
	1445	<span class="o">>>></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="s2">"analyses"</span><span class="p">)</span>
	1446	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">rootgrp</span><span class="o">.</span><span class="n">groups</span><span class="p">)</span>
	1447	<span class="p">{</span><span class="s1">'forecasts'</span><span class="p">:</span> <span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Group</span><span class="s1">'></span>
	1448	<span class="n">group</span> <span class="o">/</span><span class="n">forecasts</span><span class="p">:</span>
	1449	<span class="n">dimensions</span><span class="p">(</span><span class="n">sizes</span><span class="p">):</span>
	1450	<span class="n">variables</span><span class="p">(</span><span class="n">dimensions</span><span class="p">):</span>
	1451	<span class="n">groups</span><span class="p">:</span> <span class="p">,</span> <span class="s1">'analyses'</span><span class="p">:</span> <span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Group</span><span class="s1">'></span>
	1452	<span class="n">group</span> <span class="o">/</span><span class="n">analyses</span><span class="p">:</span>
	1453	<span class="n">dimensions</span><span class="p">(</span><span class="n">sizes</span><span class="p">):</span>
	1454	<span class="n">variables</span><span class="p">(</span><span class="n">dimensions</span><span class="p">):</span>
	1455	<span class="n">groups</span><span class="p">:</span> <span class="p">}</span>
	1456	</code></pre></div>
	1457
	1458
1385	1459	<p>Groups can exist within groups in a <a href="#netCDF4.Dataset"><code>Dataset</code></a>, just as directories
1386	1460	exist within directories in a unix filesystem. Each <a href="#netCDF4.Group"><code>Group</code></a> instance
1387	1461	has a <code>groups</code> attribute dictionary containing all of the group

1389	1463	<code>path</code> attribute that contains a simulated unix directory path to
1390	1464	that group. To simplify the creation of nested groups, you can
1391	1465	use a unix-like path as an argument to <a href="#netCDF4.Dataset.createGroup"><code>createGroup</code></a>.</p>
1392		<pre><code>:::python
1393		>>> fcstgrp1 = rootgrp.createGroup("/forecasts/model1")
1394		>>> fcstgrp2 = rootgrp.createGroup("/forecasts/model2")
1395		</code></pre>
	1466	<div class="codehilite"><pre><span></span><code><span class="o">>>></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="s2">"/forecasts/model1"</span><span class="p">)</span>
	1467	<span class="o">>>></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="s2">"/forecasts/model2"</span><span class="p">)</span>
	1468	</code></pre></div>
	1469
	1470
1396	1471	<p>If any of the intermediate elements of the path do not exist, they are created,
1397	1472	just as with the unix command <code>'mkdir -p'</code>. If you try to create a group
1398	1473	that already exists, no error will be raised, and the existing group will be

1401	1476	<a href="#netCDF4.Dataset"><code>Dataset</code></a>. The function <code>walktree</code> is a Python generator that is used
1402	1477	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>
1403	1478	object yields summary information about it's contents.</p>
1404		<pre><code>:::python
1405		>>> def walktree(top):
1406		... values = top.groups.values()
1407		... yield values
1408		... for value in top.groups.values():
1409		... for children in walktree(value):
1410		... yield children
1411		>>> print(rootgrp)
1412		<class 'netCDF4._netCDF4.Dataset'>
1413		root group (NETCDF4 data model, file format HDF5):
1414		dimensions(sizes):
1415		variables(dimensions):
1416		groups: forecasts, analyses
1417		>>> for children in walktree(rootgrp):
1418		... for child in children:
1419		... print(child)
1420		<class 'netCDF4._netCDF4.Group'>
1421		group /forecasts:
1422		dimensions(sizes):
1423		variables(dimensions):
1424		groups: model1, model2
1425		<class 'netCDF4._netCDF4.Group'>
1426		group /analyses:
1427		dimensions(sizes):
1428		variables(dimensions):
1429		groups:
1430		<class 'netCDF4._netCDF4.Group'>
1431		group /forecasts/model1:
1432		dimensions(sizes):
1433		variables(dimensions):
1434		groups:
1435		<class 'netCDF4._netCDF4.Group'>
1436		group /forecasts/model2:
1437		dimensions(sizes):
1438		variables(dimensions):
1439		groups:
1440		</code></pre>
	1479	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="k">def</span> <span class="nf">walktree</span><span class="p">(</span><span class="n">top</span><span class="p">):</span>
	1480	<span class="o">...</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>
	1481	<span class="o">...</span> <span class="k">yield</span> <span class="n">values</span>
	1482	<span class="o">...</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>
	1483	<span class="o">...</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>
	1484	<span class="o">...</span> <span class="k">yield</span> <span class="n">children</span>
	1485	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">rootgrp</span><span class="p">)</span>
	1486	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Dataset</span><span class="s1">'></span>
	1487	<span class="n">root</span> <span class="n">group</span> <span class="p">(</span><span class="n">NETCDF4</span> <span class="n">data</span> <span class="n">model</span><span class="p">,</span> <span class="n">file</span> <span class="nb">format</span> <span class="n">HDF5</span><span class="p">):</span>
	1488	<span class="n">dimensions</span><span class="p">(</span><span class="n">sizes</span><span class="p">):</span>
	1489	<span class="n">variables</span><span class="p">(</span><span class="n">dimensions</span><span class="p">):</span>
	1490	<span class="n">groups</span><span class="p">:</span> <span class="n">forecasts</span><span class="p">,</span> <span class="n">analyses</span>
	1491	<span class="o">>>></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>
	1492	<span class="o">...</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>
	1493	<span class="o">...</span> <span class="nb">print</span><span class="p">(</span><span class="n">child</span><span class="p">)</span>
	1494	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Group</span><span class="s1">'></span>
	1495	<span class="n">group</span> <span class="o">/</span><span class="n">forecasts</span><span class="p">:</span>
	1496	<span class="n">dimensions</span><span class="p">(</span><span class="n">sizes</span><span class="p">):</span>
	1497	<span class="n">variables</span><span class="p">(</span><span class="n">dimensions</span><span class="p">):</span>
	1498	<span class="n">groups</span><span class="p">:</span> <span class="n">model1</span><span class="p">,</span> <span class="n">model2</span>
	1499	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Group</span><span class="s1">'></span>
	1500	<span class="n">group</span> <span class="o">/</span><span class="n">analyses</span><span class="p">:</span>
	1501	<span class="n">dimensions</span><span class="p">(</span><span class="n">sizes</span><span class="p">):</span>
	1502	<span class="n">variables</span><span class="p">(</span><span class="n">dimensions</span><span class="p">):</span>
	1503	<span class="n">groups</span><span class="p">:</span>
	1504	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Group</span><span class="s1">'></span>
	1505	<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>
	1506	<span class="n">dimensions</span><span class="p">(</span><span class="n">sizes</span><span class="p">):</span>
	1507	<span class="n">variables</span><span class="p">(</span><span class="n">dimensions</span><span class="p">):</span>
	1508	<span class="n">groups</span><span class="p">:</span>
	1509	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Group</span><span class="s1">'></span>
	1510	<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>
	1511	<span class="n">dimensions</span><span class="p">(</span><span class="n">sizes</span><span class="p">):</span>
	1512	<span class="n">variables</span><span class="p">(</span><span class="n">dimensions</span><span class="p">):</span>
	1513	<span class="n">groups</span><span class="p">:</span>
	1514	</code></pre></div>
	1515
	1516
1441	1517	<h2><div id='section3'>3) Dimensions in a netCDF file.</h2>
1442	1518	<p>netCDF defines the sizes of all variables in terms of dimensions, so
1443	1519	before any variables can be created the dimensions they use must be

1451	1527	<code>level</code> dimensions are unlimited. Having more than one unlimited
1452	1528	dimension is a new netCDF 4 feature, in netCDF 3 files there may be only
1453	1529	one, and it must be the first (leftmost) dimension of the variable.</p>
1454		<pre><code>:::python
1455		>>> level = rootgrp.createDimension("level", None)
1456		>>> time = rootgrp.createDimension("time", None)
1457		>>> lat = rootgrp.createDimension("lat", 73)
1458		>>> lon = rootgrp.createDimension("lon", 144)
1459		</code></pre>
	1530	<div class="codehilite"><pre><span></span><code><span class="o">>>></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="s2">"level"</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>
	1531	<span class="o">>>></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="s2">"time"</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>
	1532	<span class="o">>>></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="s2">"lat"</span><span class="p">,</span> <span class="mi">73</span><span class="p">)</span>
	1533	<span class="o">>>></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="s2">"lon"</span><span class="p">,</span> <span class="mi">144</span><span class="p">)</span>
	1534	</code></pre></div>
	1535
	1536
1460	1537	<p>All of the <a href="#netCDF4.Dimension"><code>Dimension</code></a> instances are stored in a python dictionary.</p>
1461		<pre><code>:::python
1462		>>> print(rootgrp.dimensions)
1463		{'level': <class 'netCDF4._netCDF4.Dimension'> (unlimited): name = 'level', size = 0, 'time': <class 'netCDF4._netCDF4.Dimension'> (unlimited): name = 'time', size = 0, 'lat': <class 'netCDF4._netCDF4.Dimension'>: name = 'lat', size = 73, 'lon': <class 'netCDF4._netCDF4.Dimension'>: name = 'lon', size = 144}
1464		</code></pre>
	1538	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">rootgrp</span><span class="o">.</span><span class="n">dimensions</span><span class="p">)</span>
	1539	<span class="p">{</span><span class="s1">'level'</span><span class="p">:</span> <span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Dimension</span><span class="s1">'> (unlimited): name = '</span><span class="n">level</span><span class="s1">', size = 0, '</span><span class="n">time</span><span class="s1">': <class '</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="s1">'> (unlimited): name = '</span><span class="n">time</span><span class="s1">', size = 0, '</span><span class="n">lat</span><span class="s1">': <class '</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="s1">'>: name = '</span><span class="n">lat</span><span class="s1">', size = 73, '</span><span class="n">lon</span><span class="s1">': <class '</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="s1">'>: name = '</span><span class="n">lon</span><span class="s1">', size = 144}</span>
	1540	</code></pre></div>
	1541
	1542
1465	1543	<p>Calling the python <code>len</code> function with a <a href="#netCDF4.Dimension"><code>Dimension</code></a> instance returns
1466	1544	the current size of that dimension.
1467	1545	The <a href="#netCDF4.Dimension.isunlimited"><code>isunlimited</code></a> method of a <a href="#netCDF4.Dimension"><code>Dimension</code></a> instance
1468	1546	can be used to determine if the dimensions is unlimited, or appendable.</p>
1469		<pre><code>:::python
1470		>>> print(len(lon))
1471		144
1472		>>> print(lon.isunlimited())
1473		False
1474		>>> print(time.isunlimited())
1475		True
1476		</code></pre>
	1547	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">lon</span><span class="p">))</span>
	1548	<span class="mi">144</span>
	1549	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">lon</span><span class="o">.</span><span class="n">isunlimited</span><span class="p">())</span>
	1550	<span class="kc">False</span>
	1551	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">time</span><span class="o">.</span><span class="n">isunlimited</span><span class="p">())</span>
	1552	<span class="kc">True</span>
	1553	</code></pre></div>
	1554
	1555
1477	1556	<p>Printing the <a href="#netCDF4.Dimension"><code>Dimension</code></a> object
1478	1557	provides useful summary info, including the name and length of the dimension,
1479	1558	and whether it is unlimited.</p>
1480		<pre><code>:::python
1481		>>> for dimobj in rootgrp.dimensions.values():
1482		... print(dimobj)
1483		<class 'netCDF4._netCDF4.Dimension'> (unlimited): name = 'level', size = 0
1484		<class 'netCDF4._netCDF4.Dimension'> (unlimited): name = 'time', size = 0
1485		<class 'netCDF4._netCDF4.Dimension'>: name = 'lat', size = 73
1486		<class 'netCDF4._netCDF4.Dimension'>: name = 'lon', size = 144
1487		</code></pre>
	1559	<div class="codehilite"><pre><span></span><code><span class="o">>>></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>
	1560	<span class="o">...</span> <span class="nb">print</span><span class="p">(</span><span class="n">dimobj</span><span class="p">)</span>
	1561	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Dimension</span><span class="s1">'> (unlimited): name = '</span><span class="n">level</span><span class="s1">', size = 0</span>
	1562	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Dimension</span><span class="s1">'> (unlimited): name = '</span><span class="n">time</span><span class="s1">', size = 0</span>
	1563	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Dimension</span><span class="s1">'>: name = '</span><span class="n">lat</span><span class="s1">', size = 73</span>
	1564	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Dimension</span><span class="s1">'>: name = '</span><span class="n">lon</span><span class="s1">', size = 144</span>
	1565	</code></pre></div>
	1566
	1567
1488	1568	<p><a href="#netCDF4.Dimension"><code>Dimension</code></a> names can be changed using the
1489	1569	<code>netCDF4.Datatset.renameDimension</code> method of a <a href="#netCDF4.Dataset"><code>Dataset</code></a> or
1490	1570	<a href="#netCDF4.Group"><code>Group</code></a> instance.</p>

1518	1598	coordinate variables. The <a href="#netCDF4.Dataset.createVariable"><code>createVariable</code></a>
1519	1599	method returns an instance of the <a href="#netCDF4.Variable"><code>Variable</code></a> class whose methods can be
1520	1600	used later to access and set variable data and attributes.</p>
1521		<pre><code>:::python
1522		>>> times = rootgrp.createVariable("time","f8",("time",))
1523		>>> levels = rootgrp.createVariable("level","i4",("level",))
1524		>>> latitudes = rootgrp.createVariable("lat","f4",("lat",))
1525		>>> longitudes = rootgrp.createVariable("lon","f4",("lon",))
1526		>>> # two dimensions unlimited
1527		>>> temp = rootgrp.createVariable("temp","f4",("time","level","lat","lon",))
1528		>>> temp.units = "K"
1529		</code></pre>
	1601	<div class="codehilite"><pre><span></span><code><span class="o">>>></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="s2">"time"</span><span class="p">,</span><span class="s2">"f8"</span><span class="p">,(</span><span class="s2">"time"</span><span class="p">,))</span>
	1602	<span class="o">>>></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="s2">"level"</span><span class="p">,</span><span class="s2">"i4"</span><span class="p">,(</span><span class="s2">"level"</span><span class="p">,))</span>
	1603	<span class="o">>>></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="s2">"lat"</span><span class="p">,</span><span class="s2">"f4"</span><span class="p">,(</span><span class="s2">"lat"</span><span class="p">,))</span>
	1604	<span class="o">>>></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="s2">"lon"</span><span class="p">,</span><span class="s2">"f4"</span><span class="p">,(</span><span class="s2">"lon"</span><span class="p">,))</span>
	1605	<span class="o">>>></span> <span class="c1"># two dimensions unlimited</span>
	1606	<span class="o">>>></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="s2">"temp"</span><span class="p">,</span><span class="s2">"f4"</span><span class="p">,(</span><span class="s2">"time"</span><span class="p">,</span><span class="s2">"level"</span><span class="p">,</span><span class="s2">"lat"</span><span class="p">,</span><span class="s2">"lon"</span><span class="p">,))</span>
	1607	<span class="o">>>></span> <span class="n">temp</span><span class="o">.</span><span class="n">units</span> <span class="o">=</span> <span class="s2">"K"</span>
	1608	</code></pre></div>
	1609
	1610
1530	1611	<p>To get summary info on a <a href="#netCDF4.Variable"><code>Variable</code></a> instance in an interactive session,
1531	1612	just print it.</p>
1532		<pre><code>:::python
1533		>>> print(temp)
1534		<class 'netCDF4._netCDF4.Variable'>
1535		float32 temp(time, level, lat, lon)
1536		units: K
1537		unlimited dimensions: time, level
1538		current shape = (0, 0, 73, 144)
1539		filling on, default _FillValue of 9.969209968386869e+36 used
1540		</code></pre>
	1613	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">temp</span><span class="p">)</span>
	1614	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Variable</span><span class="s1">'></span>
	1615	<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>
	1616	<span class="n">units</span><span class="p">:</span> <span class="n">K</span>
	1617	<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>
	1618	<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>
	1619	<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.969209968386869e+36</span> <span class="n">used</span>
	1620	</code></pre></div>
	1621
	1622
1541	1623	<p>You can use a path to create a Variable inside a hierarchy of groups.</p>
1542		<pre><code>:::python
1543		>>> ftemp = rootgrp.createVariable("/forecasts/model1/temp","f4",("time","level","lat","lon",))
1544		</code></pre>
	1624	<div class="codehilite"><pre><span></span><code><span class="o">>>></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="s2">"/forecasts/model1/temp"</span><span class="p">,</span><span class="s2">"f4"</span><span class="p">,(</span><span class="s2">"time"</span><span class="p">,</span><span class="s2">"level"</span><span class="p">,</span><span class="s2">"lat"</span><span class="p">,</span><span class="s2">"lon"</span><span class="p">,))</span>
	1625	</code></pre></div>
	1626
	1627
1545	1628	<p>If the intermediate groups do not yet exist, they will be created.</p>
1546	1629	<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
1547	1630	<a href="#netCDF4.Variable"><code>Variable</code></a> instances using paths.</p>
1548		<pre><code>:::python
1549		>>> print(rootgrp["/forecasts/model1"]) # a Group instance
1550		<class 'netCDF4._netCDF4.Group'>
1551		group /forecasts/model1:
1552		dimensions(sizes):
1553		variables(dimensions): float32 temp(time,level,lat,lon)
1554		groups:
1555		>>> print(rootgrp["/forecasts/model1/temp"]) # a Variable instance
1556		<class 'netCDF4._netCDF4.Variable'>
1557		float32 temp(time, level, lat, lon)
1558		path = /forecasts/model1
1559		unlimited dimensions: time, level
1560		current shape = (0, 0, 73, 144)
1561		filling on, default _FillValue of 9.969209968386869e+36 used
1562		</code></pre>
	1631	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">rootgrp</span><span class="p">[</span><span class="s2">"/forecasts/model1"</span><span class="p">])</span> <span class="c1"># a Group instance</span>
	1632	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Group</span><span class="s1">'></span>
	1633	<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>
	1634	<span class="n">dimensions</span><span class="p">(</span><span class="n">sizes</span><span class="p">):</span>
	1635	<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>
	1636	<span class="n">groups</span><span class="p">:</span>
	1637	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">rootgrp</span><span class="p">[</span><span class="s2">"/forecasts/model1/temp"</span><span class="p">])</span> <span class="c1"># a Variable instance</span>
	1638	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Variable</span><span class="s1">'></span>
	1639	<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>
	1640	<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>
	1641	<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>
	1642	<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>
	1643	<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.969209968386869e+36</span> <span class="n">used</span>
	1644	</code></pre></div>
	1645
	1646
1563	1647	<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
1564	1648	Python dictionary, in the same way as the dimensions:</p>
1565		<pre><code>:::python
1566		>>> print(rootgrp.variables)
1567		{'time': <class 'netCDF4._netCDF4.Variable'>
1568		float64 time(time)
1569		unlimited dimensions: time
1570		current shape = (0,)
1571		filling on, default _FillValue of 9.969209968386869e+36 used, 'level': <class 'netCDF4._netCDF4.Variable'>
1572		int32 level(level)
1573		unlimited dimensions: level
1574		current shape = (0,)
1575		filling on, default _FillValue of -2147483647 used, 'lat': <class 'netCDF4._netCDF4.Variable'>
1576		float32 lat(lat)
1577		unlimited dimensions:
1578		current shape = (73,)
1579		filling on, default _FillValue of 9.969209968386869e+36 used, 'lon': <class 'netCDF4._netCDF4.Variable'>
1580		float32 lon(lon)
1581		unlimited dimensions:
1582		current shape = (144,)
1583		filling on, default _FillValue of 9.969209968386869e+36 used, 'temp': <class 'netCDF4._netCDF4.Variable'>
1584		float32 temp(time, level, lat, lon)
1585		units: K
1586		unlimited dimensions: time, level
1587		current shape = (0, 0, 73, 144)
1588		filling on, default _FillValue of 9.969209968386869e+36 used}
1589		</code></pre>
	1649	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">rootgrp</span><span class="o">.</span><span class="n">variables</span><span class="p">)</span>
	1650	<span class="p">{</span><span class="s1">'time'</span><span class="p">:</span> <span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Variable</span><span class="s1">'></span>
	1651	<span class="n">float64</span> <span class="n">time</span><span class="p">(</span><span class="n">time</span><span class="p">)</span>
	1652	<span class="n">unlimited</span> <span class="n">dimensions</span><span class="p">:</span> <span class="n">time</span>
	1653	<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>
	1654	<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.969209968386869e+36</span> <span class="n">used</span><span class="p">,</span> <span class="s1">'level'</span><span class="p">:</span> <span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Variable</span><span class="s1">'></span>
	1655	<span class="n">int32</span> <span class="n">level</span><span class="p">(</span><span class="n">level</span><span class="p">)</span>
	1656	<span class="n">unlimited</span> <span class="n">dimensions</span><span class="p">:</span> <span class="n">level</span>
	1657	<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>
	1658	<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="o">-</span><span class="mi">2147483647</span> <span class="n">used</span><span class="p">,</span> <span class="s1">'lat'</span><span class="p">:</span> <span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Variable</span><span class="s1">'></span>
	1659	<span class="n">float32</span> <span class="n">lat</span><span class="p">(</span><span class="n">lat</span><span class="p">)</span>
	1660	<span class="n">unlimited</span> <span class="n">dimensions</span><span class="p">:</span>
	1661	<span class="n">current</span> <span class="n">shape</span> <span class="o">=</span> <span class="p">(</span><span class="mi">73</span><span class="p">,)</span>
	1662	<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.969209968386869e+36</span> <span class="n">used</span><span class="p">,</span> <span class="s1">'lon'</span><span class="p">:</span> <span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Variable</span><span class="s1">'></span>
	1663	<span class="n">float32</span> <span class="n">lon</span><span class="p">(</span><span class="n">lon</span><span class="p">)</span>
	1664	<span class="n">unlimited</span> <span class="n">dimensions</span><span class="p">:</span>
	1665	<span class="n">current</span> <span class="n">shape</span> <span class="o">=</span> <span class="p">(</span><span class="mi">144</span><span class="p">,)</span>
	1666	<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.969209968386869e+36</span> <span class="n">used</span><span class="p">,</span> <span class="s1">'temp'</span><span class="p">:</span> <span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Variable</span><span class="s1">'></span>
	1667	<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>
	1668	<span class="n">units</span><span class="p">:</span> <span class="n">K</span>
	1669	<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>
	1670	<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>
	1671	<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.969209968386869e+36</span> <span class="n">used</span><span class="p">}</span>
	1672	</code></pre></div>
	1673
	1674
1590	1675	<p><a href="#netCDF4.Variable"><code>Variable</code></a> names can be changed using the
1591	1676	<a href="#netCDF4.Dataset.renameVariable"><code>renameVariable</code></a> method of a <a href="#netCDF4.Dataset"><code>Dataset</code></a>
1592	1677	instance.</p>

1599	1684	attributes are set by assigning values to <a href="#netCDF4.Variable"><code>Variable</code></a> instances
1600	1685	variables. Attributes can be strings, numbers or sequences. Returning to
1601	1686	our example,</p>
1602		<pre><code>:::python
1603		>>> import time
1604		>>> rootgrp.description = "bogus example script"
1605		>>> rootgrp.history = "Created " + time.ctime(time.time())
1606		>>> rootgrp.source = "netCDF4 python module tutorial"
1607		>>> latitudes.units = "degrees north"
1608		>>> longitudes.units = "degrees east"
1609		>>> levels.units = "hPa"
1610		>>> temp.units = "K"
1611		>>> times.units = "hours since 0001-01-01 00:00:00.0"
1612		>>> times.calendar = "gregorian"
1613		</code></pre>
	1687	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="kn">import</span> <span class="nn">time</span>
	1688	<span class="o">>>></span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">description</span> <span class="o">=</span> <span class="s2">"bogus example script"</span>
	1689	<span class="o">>>></span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">history</span> <span class="o">=</span> <span class="s2">"Created "</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>
	1690	<span class="o">>>></span> <span class="n">rootgrp</span><span class="o">.</span><span class="n">source</span> <span class="o">=</span> <span class="s2">"netCDF4 python module tutorial"</span>
	1691	<span class="o">>>></span> <span class="n">latitudes</span><span class="o">.</span><span class="n">units</span> <span class="o">=</span> <span class="s2">"degrees north"</span>
	1692	<span class="o">>>></span> <span class="n">longitudes</span><span class="o">.</span><span class="n">units</span> <span class="o">=</span> <span class="s2">"degrees east"</span>
	1693	<span class="o">>>></span> <span class="n">levels</span><span class="o">.</span><span class="n">units</span> <span class="o">=</span> <span class="s2">"hPa"</span>
	1694	<span class="o">>>></span> <span class="n">temp</span><span class="o">.</span><span class="n">units</span> <span class="o">=</span> <span class="s2">"K"</span>
	1695	<span class="o">>>></span> <span class="n">times</span><span class="o">.</span><span class="n">units</span> <span class="o">=</span> <span class="s2">"hours since 0001-01-01 00:00:00.0"</span>
	1696	<span class="o">>>></span> <span class="n">times</span><span class="o">.</span><span class="n">calendar</span> <span class="o">=</span> <span class="s2">"gregorian"</span>
	1697	</code></pre></div>
	1698
	1699
1614	1700	<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
1615	1701	<a href="#netCDF4.Variable"><code>Variable</code></a> instance can be used to retrieve the names of all the netCDF
1616	1702	attributes. This method is provided as a convenience, since using the
1617	1703	built-in <code>dir</code> Python function will return a bunch of private methods
1618	1704	and attributes that cannot (or should not) be modified by the user.</p>
1619		<pre><code>:::python
1620		>>> for name in rootgrp.ncattrs():
1621		... print("Global attr {} = {}".format(name, getattr(rootgrp, name)))
1622		Global attr description = bogus example script
1623		Global attr history = Created Mon Jul 8 14:19:41 2019
1624		Global attr source = netCDF4 python module tutorial
1625		</code></pre>
	1705	<div class="codehilite"><pre><span></span><code><span class="o">>>></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>
	1706	<span class="o">...</span> <span class="nb">print</span><span class="p">(</span><span class="s2">"Global attr </span><span class="si">{}</span><span class="s2"> = </span><span class="si">{}</span><span class="s2">"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">name</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>
	1707	<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>
	1708	<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">Jul</span> <span class="mi">8</span> <span class="mi">14</span><span class="p">:</span><span class="mi">19</span><span class="p">:</span><span class="mi">41</span> <span class="mi">2019</span>
	1709	<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>
	1710	</code></pre></div>
	1711
	1712
1626	1713	<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>
1627	1714	instance provides all the netCDF attribute name/value pairs in a python
1628	1715	dictionary:</p>
1629		<pre><code>:::python
1630		>>> print(rootgrp.__dict__)
1631		{'description': 'bogus example script', 'history': 'Created Mon Jul 8 14:19:41 2019', 'source': 'netCDF4 python module tutorial'}
1632		</code></pre>
	1716	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">rootgrp</span><span class="o">.</span><span class="vm">__dict__</span><span class="p">)</span>
	1717	<span class="p">{</span><span class="s1">'description'</span><span class="p">:</span> <span class="s1">'bogus example script'</span><span class="p">,</span> <span class="s1">'history'</span><span class="p">:</span> <span class="s1">'Created Mon Jul 8 14:19:41 2019'</span><span class="p">,</span> <span class="s1">'source'</span><span class="p">:</span> <span class="s1">'netCDF4 python module tutorial'</span><span class="p">}</span>
	1718	</code></pre></div>
	1719
	1720
1633	1721	<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
1634	1722	<a href="#netCDF4.Variable"><code>Variable</code></a> using the python <code>del</code> statement (i.e. <code>del grp.foo</code>
1635	1723	removes the attribute <code>foo</code> the the group <code>grp</code>).</p>
1636	1724	<h2><div id='section6'>6) Writing data to and retrieving data from a netCDF variable.</h2>
1637	1725	<p>Now that you have a netCDF <a href="#netCDF4.Variable"><code>Variable</code></a> instance, how do you put data
1638	1726	into it? You can just treat it like an array and assign data to a slice.</p>
1639		<pre><code>:::python
1640		>>> import numpy
1641		>>> lats = numpy.arange(-90,91,2.5)
1642		>>> lons = numpy.arange(-180,180,2.5)
1643		>>> latitudes[:] = lats
1644		>>> longitudes[:] = lons
1645		>>> print("latitudes =\n{}".format(latitudes[:]))
1646		latitudes =
1647		[-90. -87.5 -85. -82.5 -80. -77.5 -75. -72.5 -70. -67.5 -65. -62.5
1648		-60. -57.5 -55. -52.5 -50. -47.5 -45. -42.5 -40. -37.5 -35. -32.5
1649		-30. -27.5 -25. -22.5 -20. -17.5 -15. -12.5 -10. -7.5 -5. -2.5
1650		0. 2.5 5. 7.5 10. 12.5 15. 17.5 20. 22.5 25. 27.5
1651		30. 32.5 35. 37.5 40. 42.5 45. 47.5 50. 52.5 55. 57.5
1652		60. 62.5 65. 67.5 70. 72.5 75. 77.5 80. 82.5 85. 87.5
1653		90. ]
1654		</code></pre>
	1727	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="kn">import</span> <span class="nn">numpy</span>
	1728	<span class="o">>>></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>
	1729	<span class="o">>>></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>
	1730	<span class="o">>>></span> <span class="n">latitudes</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">lats</span>
	1731	<span class="o">>>></span> <span class="n">longitudes</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">lons</span>
	1732	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="s2">"latitudes =</span><span class="se">\n</span><span class="si">{}</span><span class="s2">"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">latitudes</span><span class="p">[:]))</span>
	1733	<span class="n">latitudes</span> <span class="o">=</span>
	1734	<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>
	1735	<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>
	1736	<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>
	1737	<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>
	1738	<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>
	1739	<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>
	1740	<span class="mf">90.</span> <span class="p">]</span>
	1741	</code></pre></div>
	1742
	1743
1655	1744	<p>Unlike NumPy's array objects, netCDF <a href="#netCDF4.Variable"><code>Variable</code></a>
1656	1745	objects with unlimited dimensions will grow along those dimensions if you
1657	1746	assign data outside the currently defined range of indices.</p>
1658		<pre><code>:::python
1659		>>> # append along two unlimited dimensions by assigning to slice.
1660		>>> nlats = len(rootgrp.dimensions["lat"])
1661		>>> nlons = len(rootgrp.dimensions["lon"])
1662		>>> print("temp shape before adding data = {}".format(temp.shape))
1663		temp shape before adding data = (0, 0, 73, 144)
1664		>>>
1665		>>> from numpy.random import uniform
1666		>>> temp[0:5, 0:10, :, :] = uniform(size=(5, 10, nlats, nlons))
1667		>>> print("temp shape after adding data = {}".format(temp.shape))
1668		temp shape after adding data = (5, 10, 73, 144)
1669		>>>
1670		>>> # levels have grown, but no values yet assigned.
1671		>>> print("levels shape after adding pressure data = {}".format(levels.shape))
1672		levels shape after adding pressure data = (10,)
1673		</code></pre>
	1747	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="c1"># append along two unlimited dimensions by assigning to slice.</span>
	1748	<span class="o">>>></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="s2">"lat"</span><span class="p">])</span>
	1749	<span class="o">>>></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="s2">"lon"</span><span class="p">])</span>
	1750	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="s2">"temp shape before adding data = </span><span class="si">{}</span><span class="s2">"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">temp</span><span class="o">.</span><span class="n">shape</span><span class="p">))</span>
	1751	<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>
	1752	<span class="o">>>></span>
	1753	<span class="o">>>></span> <span class="kn">from</span> <span class="nn">numpy.random</span> <span class="kn">import</span> <span class="n">uniform</span>
	1754	<span class="o">>>></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="p">:,</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>
	1755	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="s2">"temp shape after adding data = </span><span class="si">{}</span><span class="s2">"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">temp</span><span class="o">.</span><span class="n">shape</span><span class="p">))</span>
	1756	<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">5</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>
	1757	<span class="o">>>></span>
	1758	<span class="o">>>></span> <span class="c1"># levels have grown, but no values yet assigned.</span>
	1759	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="s2">"levels shape after adding pressure data = </span><span class="si">{}</span><span class="s2">"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">levels</span><span class="o">.</span><span class="n">shape</span><span class="p">))</span>
	1760	<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>
	1761	</code></pre></div>
	1762
	1763
1674	1764	<p>Note that the size of the levels variable grows when data is appended
1675	1765	along the <code>level</code> dimension of the variable <code>temp</code>, even though no
1676	1766	data has yet been assigned to levels.</p>
1677		<pre><code>:::python
1678		>>> # now, assign data to levels dimension variable.
1679		>>> levels[:] = [1000.,850.,700.,500.,300.,250.,200.,150.,100.,50.]
1680		</code></pre>
	1767	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="c1"># now, assign data to levels dimension variable.</span>
	1768	<span class="o">>>></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>
	1769	</code></pre></div>
	1770
	1771
1681	1772	<p>However, that there are some differences between NumPy and netCDF
1682	1773	variable slicing rules. Slices behave as usual, being specified as a
1683	1774	<code>start:stop:step</code> triplet. Using a scalar integer index <code>i</code> takes the ith

1686	1777	than for numpy arrays. Only 1-d boolean arrays and integer sequences are
1687	1778	allowed, and these indices work independently along each dimension (similar
1688	1779	to the way vector subscripts work in fortran). This means that</p>
1689		<pre><code>:::python
1690		>>> temp[0, 0, [0,1,2,3], [0,1,2,3]].shape
1691		(4, 4)
1692		</code></pre>
	1780	<div class="codehilite"><pre><span></span><code><span class="o">>>></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><span class="o">.</span><span class="n">shape</span>
	1781	<span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
	1782	</code></pre></div>
	1783
	1784
1693	1785	<p>returns an array of shape (4,4) when slicing a netCDF variable, but for a
1694	1786	numpy array it returns an array of shape (4,).
1695	1787	Similarly, a netCDF variable of shape <code>(2,3,4,5)</code> indexed

1702	1794	it provides a very powerful way to extract data from multidimensional netCDF
1703	1795	variables by using logical operations on the dimension arrays to create slices.</p>
1704	1796	<p>For example,</p>
1705		<pre><code>:::python
1706		>>> tempdat = temp[::2, [1,3,6], lats>0, lons>0]
1707		</code></pre>
	1797	<div class="codehilite"><pre><span></span><code><span class="o">>>></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">></span><span class="mi">0</span><span class="p">,</span> <span class="n">lons</span><span class="o">></span><span class="mi">0</span><span class="p">]</span>
	1798	</code></pre></div>
	1799
	1800
1708	1801	<p>will extract time indices 0,2 and 4, pressure levels
1709	1802	850, 500 and 200 hPa, all Northern Hemisphere latitudes and Eastern
1710	1803	Hemisphere longitudes, resulting in a numpy array of shape (3, 3, 36, 71).</p>
1711		<pre><code>:::python
1712		>>> print("shape of fancy temp slice = {}".format(tempdat.shape))
1713		shape of fancy temp slice = (3, 3, 36, 71)
1714		</code></pre>
	1804	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="s2">"shape of fancy temp slice = </span><span class="si">{}</span><span class="s2">"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">tempdat</span><span class="o">.</span><span class="n">shape</span><span class="p">))</span>
	1805	<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>
	1806	</code></pre></div>
	1807
	1808
1715	1809	<p><strong><em>Special note for scalar variables</em></strong>: To extract data from a scalar variable
1716	1810	<code>v</code> with no associated dimensions, use <code>numpy.asarray(v)</code> or <code>v[...]</code>.
1717	1811	The result will be a numpy scalar array.</p>

1737	1831	<a href="https://unidata.github.io/cftime">cftime</a> package must be installed
1738	1832	separately). Here's an example of how they
1739	1833	can be used:</p>
1740		<pre><code>:::python
1741		>>> # fill in times.
1742		>>> from datetime import datetime, timedelta
1743		>>> from netCDF4 import num2date, date2num
1744		>>> dates = [datetime(2001,3,1)+n*timedelta(hours=12) for n in range(temp.shape[0])]
1745		>>> times[:] = date2num(dates,units=times.units,calendar=times.calendar)
1746		>>> print("time values (in units {}):\n{}".format(times.units, times[:]))
1747		time values (in units hours since 0001-01-01 00:00:00.0):
1748		[17533104. 17533116. 17533128. 17533140. 17533152.]
1749		>>> dates = num2date(times[:],units=times.units,calendar=times.calendar)
1750		>>> print("dates corresponding to time values:\n{}".format(dates))
1751		dates corresponding to time values:
1752		[real_datetime(2001, 3, 1, 0, 0) real_datetime(2001, 3, 1, 12, 0)
1753		real_datetime(2001, 3, 2, 0, 0) real_datetime(2001, 3, 2, 12, 0)
1754		real_datetime(2001, 3, 3, 0, 0)]
1755		</code></pre>
	1834	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="c1"># fill in times.</span>
	1835	<span class="o">>>></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>
	1836	<span class="o">>>></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>
	1837	<span class="o">>>></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>
	1838	<span class="o">>>></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>
	1839	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="s2">"time values (in units </span><span class="si">{}</span><span class="s2">):</span><span class="se">\n</span><span class="si">{}</span><span class="s2">"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">times</span><span class="o">.</span><span class="n">units</span><span class="p">,</span> <span class="n">times</span><span class="p">[:]))</span>
	1840	<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="mi">0001</span><span class="o">-</span><span class="mi">01</span><span class="o">-</span><span class="mi">01</span> <span class="mi">00</span><span class="p">:</span><span class="mi">00</span><span class="p">:</span><span class="mf">00.0</span><span class="p">):</span>
	1841	<span class="p">[</span><span class="mf">17533104.</span> <span class="mf">17533116.</span> <span class="mf">17533128.</span> <span class="mf">17533140.</span> <span class="mf">17533152.</span><span class="p">]</span>
	1842	<span class="o">>>></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>
	1843	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="s2">"dates corresponding to time values:</span><span class="se">\n</span><span class="si">{}</span><span class="s2">"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">dates</span><span class="p">))</span>
	1844	<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>
	1845	<span class="p">[</span><span class="n">real_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="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span> <span class="n">real_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="mi">12</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
	1846	<span class="n">real_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">2</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="n">real_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">2</span><span class="p">,</span> <span class="mi">12</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
	1847	<span class="n">real_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">3</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">)]</span>
	1848	</code></pre></div>
	1849
	1850
1756	1851	<p><a href="#netCDF4.num2date"><code>num2date</code></a> converts numeric values of time in the specified <code>units</code>
1757	1852	and <code>calendar</code> to datetime objects, and <a href="#netCDF4.date2num"><code>date2num</code></a> does the reverse.
1758	1853	All the calendars currently defined in the

1773	1868	must in be in <code>NETCDF3_64BIT_OFFSET</code>, <code>NETCDF3_64BIT_DATA</code>, <code>NETCDF3_CLASSIC</code> or
1774	1869	<code>NETCDF4_CLASSIC</code> format (<code>NETCDF4</code> formatted multi-file
1775	1870	datasets are not supported).</p>
1776		<pre><code>:::python
1777		>>> for nf in range(10):
1778		... with Dataset("mftest%s.nc" % nf, "w", format="NETCDF4_CLASSIC") as f:
1779		... _ = f.createDimension("x",None)
1780		... x = f.createVariable("x","i",("x",))
1781		... x[0:10] = numpy.arange(nf10,10(nf+1))
1782		</code></pre>
	1871	<div class="codehilite"><pre><span></span><code><span class="o">>>></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>
	1872	<span class="o">...</span> <span class="k">with</span> <span class="n">Dataset</span><span class="p">(</span><span class="s2">"mftest</span><span class="si">%s</span><span class="s2">.nc"</span> <span class="o">%</span> <span class="n">nf</span><span class="p">,</span> <span class="s2">"w"</span><span class="p">,</span> <span class="nb">format</span><span class="o">=</span><span class="s2">"NETCDF4_CLASSIC"</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
	1873	<span class="o">...</span> <span class="n">_</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="s2">"x"</span><span class="p">,</span><span class="kc">None</span><span class="p">)</span>
	1874	<span class="o">...</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="s2">"x"</span><span class="p">,</span><span class="s2">"i"</span><span class="p">,(</span><span class="s2">"x"</span><span class="p">,))</span>
	1875	<span class="o">...</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>
	1876	</code></pre></div>
	1877
	1878
1783	1879	<p>Now read all the files back in at once with <a href="#netCDF4.MFDataset"><code>MFDataset</code></a></p>
1784		<pre><code>:::python
1785		>>> from netCDF4 import MFDataset
1786		>>> f = MFDataset("mftest*nc")
1787		>>> print(f.variables["x"][:])
1788		[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
1789		24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
1790		48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
1791		72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
1792		96 97 98 99]
1793		</code></pre>
	1880	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="kn">from</span> <span class="nn">netCDF4</span> <span class="kn">import</span> <span class="n">MFDataset</span>
	1881	<span class="o">>>></span> <span class="n">f</span> <span class="o">=</span> <span class="n">MFDataset</span><span class="p">(</span><span class="s2">"mftest*nc"</span><span class="p">)</span>
	1882	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">f</span><span class="o">.</span><span class="n">variables</span><span class="p">[</span><span class="s2">"x"</span><span class="p">][:])</span>
	1883	<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>
	1884	<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>
	1885	<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>
	1886	<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>
	1887	<span class="mi">96</span> <span class="mi">97</span> <span class="mi">98</span> <span class="mi">99</span><span class="p">]</span>
	1888	</code></pre></div>
	1889
	1890
1794	1891	<p>Note that <a href="#netCDF4.MFDataset"><code>MFDataset</code></a> can only be used to read, not write, multi-file
1795	1892	datasets.</p>
1796	1893	<h2><div id='section9'>9) Efficient compression of netCDF variables.</h2>

1829	1926	'lossy' instead of 'lossless', that is some precision in the data is
1830	1927	sacrificed for the sake of disk space.</p>
1831	1928	<p>In our example, try replacing the line</p>
1832		<pre><code>:::python
1833		>>> temp = rootgrp.createVariable("temp","f4",("time","level","lat","lon",))
1834		</code></pre>
	1929	<div class="codehilite"><pre><span></span><code><span class="o">>>></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="s2">"temp"</span><span class="p">,</span><span class="s2">"f4"</span><span class="p">,(</span><span class="s2">"time"</span><span class="p">,</span><span class="s2">"level"</span><span class="p">,</span><span class="s2">"lat"</span><span class="p">,</span><span class="s2">"lon"</span><span class="p">,))</span>
	1930	</code></pre></div>
	1931
	1932
1835	1933	<p>with</p>
1836		<pre><code>:::python
1837		>>> temp = rootgrp.createVariable("temp","f4",("time","level","lat","lon",),zlib=True)
1838		</code></pre>
	1934	<div class="codehilite"><pre><span></span><code><span class="o">>>></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="s2">"temp"</span><span class="p">,</span><span class="s2">"f4"</span><span class="p">,(</span><span class="s2">"time"</span><span class="p">,</span><span class="s2">"level"</span><span class="p">,</span><span class="s2">"lat"</span><span class="p">,</span><span class="s2">"lon"</span><span class="p">,),</span><span class="n">zlib</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
	1935	</code></pre></div>
	1936
	1937
1839	1938	<p>and then</p>
1840		<pre><code>:::python
1841		>>> temp = rootgrp.createVariable("temp","f4",("time","level","lat","lon",),zlib=True,least_significant_digit=3)
1842		</code></pre>
	1939	<div class="codehilite"><pre><span></span><code><span class="o">>>></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="s2">"temp"</span><span class="p">,</span><span class="s2">"f4"</span><span class="p">,(</span><span class="s2">"time"</span><span class="p">,</span><span class="s2">"level"</span><span class="p">,</span><span class="s2">"lat"</span><span class="p">,</span><span class="s2">"lon"</span><span class="p">,),</span><span class="n">zlib</span><span class="o">=</span><span class="kc">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>
	1940	</code></pre></div>
	1941
	1942
1843	1943	<p>and see how much smaller the resulting files are.</p>
1844	1944	<h2><div id='section10'>10) Beyond homogeneous arrays of a fixed type - compound data types.</h2>
1845	1945	<p>Compound data types map directly to numpy structured (a.k.a 'record')

1855	1955	<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.
1856	1956	Since there is no native complex data type in netcdf, compound types are handy
1857	1957	for storing numpy complex arrays. Here's an example:</p>
1858		<pre><code>:::python
1859		>>> f = Dataset("complex.nc","w")
1860		>>> size = 3 # length of 1-d complex array
1861		>>> # create sample complex data.
1862		>>> datac = numpy.exp(1j*(1.+numpy.linspace(0, numpy.pi, size)))
1863		>>> # create complex128 compound data type.
1864		>>> complex128 = numpy.dtype([("real",numpy.float64),("imag",numpy.float64)])
1865		>>> complex128_t = f.createCompoundType(complex128,"complex128")
1866		>>> # create a variable with this data type, write some data to it.
1867		>>> x_dim = f.createDimension("x_dim",None)
1868		>>> v = f.createVariable("cmplx_var",complex128_t,"x_dim")
1869		>>> data = numpy.empty(size,complex128) # numpy structured array
1870		>>> data["real"] = datac.real; data["imag"] = datac.imag
1871		>>> v[:] = data # write numpy structured array to netcdf compound var
1872		>>> # close and reopen the file, check the contents.
1873		>>> f.close(); f = Dataset("complex.nc")
1874		>>> v = f.variables["cmplx_var"]
1875		>>> datain = v[:] # read in all the data into a numpy structured array
1876		>>> # create an empty numpy complex array
1877		>>> datac2 = numpy.empty(datain.shape,numpy.complex128)
1878		>>> # .. fill it with contents of structured array.
1879		>>> datac2.real = datain["real"]; datac2.imag = datain["imag"]
1880		>>> print('{}: {}'.format(datac.dtype, datac)) # original data
1881		complex128: [ 0.54030231+0.84147098j -0.84147098+0.54030231j -0.54030231-0.84147098j]
1882		>>>
1883		>>> print('{}: {}'.format(datac2.dtype, datac2)) # data from file
1884		complex128: [ 0.54030231+0.84147098j -0.84147098+0.54030231j -0.54030231-0.84147098j]
1885		</code></pre>
	1958	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="n">f</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s2">"complex.nc"</span><span class="p">,</span><span class="s2">"w"</span><span class="p">)</span>
	1959	<span class="o">>>></span> <span class="n">size</span> <span class="o">=</span> <span class="mi">3</span> <span class="c1"># length of 1-d complex array</span>
	1960	<span class="o">>>></span> <span class="c1"># create sample complex data.</span>
	1961	<span class="o">>>></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">1</span><span class="n">j</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>
	1962	<span class="o">>>></span> <span class="c1"># create complex128 compound data type.</span>
	1963	<span class="o">>>></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="s2">"real"</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="s2">"imag"</span><span class="p">,</span><span class="n">numpy</span><span class="o">.</span><span class="n">float64</span><span class="p">)])</span>
	1964	<span class="o">>>></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="s2">"complex128"</span><span class="p">)</span>
	1965	<span class="o">>>></span> <span class="c1"># create a variable with this data type, write some data to it.</span>
	1966	<span class="o">>>></span> <span class="n">x_dim</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="s2">"x_dim"</span><span class="p">,</span><span class="kc">None</span><span class="p">)</span>
	1967	<span class="o">>>></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="s2">"cmplx_var"</span><span class="p">,</span><span class="n">complex128_t</span><span class="p">,</span><span class="s2">"x_dim"</span><span class="p">)</span>
	1968	<span class="o">>>></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="c1"># numpy structured array</span>
	1969	<span class="o">>>></span> <span class="n">data</span><span class="p">[</span><span class="s2">"real"</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="s2">"imag"</span><span class="p">]</span> <span class="o">=</span> <span class="n">datac</span><span class="o">.</span><span class="n">imag</span>
	1970	<span class="o">>>></span> <span class="n">v</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">data</span> <span class="c1"># write numpy structured array to netcdf compound var</span>
	1971	<span class="o">>>></span> <span class="c1"># close and reopen the file, check the contents.</span>
	1972	<span class="o">>>></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="s2">"complex.nc"</span><span class="p">)</span>
	1973	<span class="o">>>></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="s2">"cmplx_var"</span><span class="p">]</span>
	1974	<span class="o">>>></span> <span class="n">datain</span> <span class="o">=</span> <span class="n">v</span><span class="p">[:]</span> <span class="c1"># read in all the data into a numpy structured array</span>
	1975	<span class="o">>>></span> <span class="c1"># create an empty numpy complex array</span>
	1976	<span class="o">>>></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>
	1977	<span class="o">>>></span> <span class="c1"># .. fill it with contents of structured array.</span>
	1978	<span class="o">>>></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="s2">"real"</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="s2">"imag"</span><span class="p">]</span>
	1979	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="s1">'</span><span class="si">{}</span><span class="s1">: </span><span class="si">{}</span><span class="s1">'</span><span class="o">.</span><span class="n">format</span><span class="p">(</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="p">))</span> <span class="c1"># original data</span>
	1980	<span class="n">complex128</span><span class="p">:</span> <span class="p">[</span> <span class="mf">0.54030231</span><span class="o">+</span><span class="mf">0.84147098</span><span class="n">j</span> <span class="o">-</span><span class="mf">0.84147098</span><span class="o">+</span><span class="mf">0.54030231</span><span class="n">j</span> <span class="o">-</span><span class="mf">0.54030231</span><span class="o">-</span><span class="mf">0.84147098</span><span class="n">j</span><span class="p">]</span>
	1981	<span class="o">>>></span>
	1982	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="s1">'</span><span class="si">{}</span><span class="s1">: </span><span class="si">{}</span><span class="s1">'</span><span class="o">.</span><span class="n">format</span><span class="p">(</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="p">))</span> <span class="c1"># data from file</span>
	1983	<span class="n">complex128</span><span class="p">:</span> <span class="p">[</span> <span class="mf">0.54030231</span><span class="o">+</span><span class="mf">0.84147098</span><span class="n">j</span> <span class="o">-</span><span class="mf">0.84147098</span><span class="o">+</span><span class="mf">0.54030231</span><span class="n">j</span> <span class="o">-</span><span class="mf">0.54030231</span><span class="o">-</span><span class="mf">0.84147098</span><span class="n">j</span><span class="p">]</span>
	1984	</code></pre></div>
	1985
	1986
1886	1987	<p>Compound types can be nested, but you must create the 'inner'
1887	1988	ones first. All possible numpy structured arrays cannot be
1888	1989	represented as Compound variables - an error message will be

1890	1991	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
1891	1992	in a Python dictionary, just like variables and dimensions. As always, printing
1892	1993	objects gives useful summary information in an interactive session:</p>
1893		<pre><code>:::python
1894		>>> print(f)
1895		<class 'netCDF4._netCDF4.Dataset'>
1896		root group (NETCDF4 data model, file format HDF5):
1897		dimensions(sizes): x_dim(3)
1898		variables(dimensions): {'names':['real','imag'], 'formats':['<f8','<f8'], 'offsets':[0,8], 'itemsize':16, 'aligned':True} cmplx_var(x_dim)
1899		groups:
1900		>>> print(f.variables["cmplx_var"])
1901		<class 'netCDF4._netCDF4.Variable'>
1902		compound cmplx_var(x_dim)
1903		compound data type: {'names':['real','imag'], 'formats':['<f8','<f8'], 'offsets':[0,8], 'itemsize':16, 'aligned':True}
1904		unlimited dimensions: x_dim
1905		current shape = (3,)
1906		>>> print(f.cmptypes)
1907		{'complex128': <class 'netCDF4._netCDF4.CompoundType'>: name = 'complex128', numpy dtype = {'names':['real','imag'], 'formats':['<f8','<f8'], 'offsets':[0,8], 'itemsize':16, 'aligned':True}}
1908		>>> print(f.cmptypes["complex128"])
1909		<class 'netCDF4._netCDF4.CompoundType'>: name = 'complex128', numpy dtype = {'names':['real','imag'], 'formats':['<f8','<f8'], 'offsets':[0,8], 'itemsize':16, 'aligned':True}
1910		</code></pre>
	1994	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
	1995	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Dataset</span><span class="s1">'></span>
	1996	<span class="n">root</span> <span class="n">group</span> <span class="p">(</span><span class="n">NETCDF4</span> <span class="n">data</span> <span class="n">model</span><span class="p">,</span> <span class="n">file</span> <span class="nb">format</span> <span class="n">HDF5</span><span class="p">):</span>
	1997	<span class="n">dimensions</span><span class="p">(</span><span class="n">sizes</span><span class="p">):</span> <span class="n">x_dim</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
	1998	<span class="n">variables</span><span class="p">(</span><span class="n">dimensions</span><span class="p">):</span> <span class="p">{</span><span class="s1">'names'</span><span class="p">:[</span><span class="s1">'real'</span><span class="p">,</span><span class="s1">'imag'</span><span class="p">],</span> <span class="s1">'formats'</span><span class="p">:[</span><span class="s1">'<f8'</span><span class="p">,</span><span class="s1">'<f8'</span><span class="p">],</span> <span class="s1">'offsets'</span><span class="p">:[</span><span class="mi">0</span><span class="p">,</span><span class="mi">8</span><span class="p">],</span> <span class="s1">'itemsize'</span><span class="p">:</span><span class="mi">16</span><span class="p">,</span> <span class="s1">'aligned'</span><span class="p">:</span><span class="kc">True</span><span class="p">}</span> <span class="n">cmplx_var</span><span class="p">(</span><span class="n">x_dim</span><span class="p">)</span>
	1999	<span class="n">groups</span><span class="p">:</span>
	2000	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">f</span><span class="o">.</span><span class="n">variables</span><span class="p">[</span><span class="s2">"cmplx_var"</span><span class="p">])</span>
	2001	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Variable</span><span class="s1">'></span>
	2002	<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>
	2003	<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="s1">'names'</span><span class="p">:[</span><span class="s1">'real'</span><span class="p">,</span><span class="s1">'imag'</span><span class="p">],</span> <span class="s1">'formats'</span><span class="p">:[</span><span class="s1">'<f8'</span><span class="p">,</span><span class="s1">'<f8'</span><span class="p">],</span> <span class="s1">'offsets'</span><span class="p">:[</span><span class="mi">0</span><span class="p">,</span><span class="mi">8</span><span class="p">],</span> <span class="s1">'itemsize'</span><span class="p">:</span><span class="mi">16</span><span class="p">,</span> <span class="s1">'aligned'</span><span class="p">:</span><span class="kc">True</span><span class="p">}</span>
	2004	<span class="n">unlimited</span> <span class="n">dimensions</span><span class="p">:</span> <span class="n">x_dim</span>
	2005	<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>
	2006	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">f</span><span class="o">.</span><span class="n">cmptypes</span><span class="p">)</span>
	2007	<span class="p">{</span><span class="s1">'complex128'</span><span class="p">:</span> <span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">CompoundType</span><span class="s1">'>: name = '</span><span class="n">complex128</span><span class="s1">', numpy dtype = {'</span><span class="n">names</span><span class="s1">':['</span><span class="n">real</span><span class="s1">','</span><span class="n">imag</span><span class="s1">'], '</span><span class="n">formats</span><span class="s1">':['</span><span class="o"><</span><span class="n">f8</span><span class="s1">','</span><span class="o"><</span><span class="n">f8</span><span class="s1">'], '</span><span class="n">offsets</span><span class="s1">':[0,8], '</span><span class="n">itemsize</span><span class="s1">':16, '</span><span class="n">aligned</span><span class="s1">':True}}</span>
	2008	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">f</span><span class="o">.</span><span class="n">cmptypes</span><span class="p">[</span><span class="s2">"complex128"</span><span class="p">])</span>
	2009	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">CompoundType</span><span class="s1">'>: name = '</span><span class="n">complex128</span><span class="s1">', numpy dtype = {'</span><span class="n">names</span><span class="s1">':['</span><span class="n">real</span><span class="s1">','</span><span class="n">imag</span><span class="s1">'], '</span><span class="n">formats</span><span class="s1">':['</span><span class="o"><</span><span class="n">f8</span><span class="s1">','</span><span class="o"><</span><span class="n">f8</span><span class="s1">'], '</span><span class="n">offsets</span><span class="s1">':[0,8], '</span><span class="n">itemsize</span><span class="s1">':16, '</span><span class="n">aligned</span><span class="s1">':True}</span>
	2010	</code></pre></div>
	2011
	2012
1911	2013	<h2><div id='section11'>11) Variable-length (vlen) data types.</h2>
1912	2014	<p>NetCDF 4 has support for variable-length or "ragged" arrays. These are arrays
1913	2015	of variable length sequences having the same type. To create a variable-length
1914	2016	data type, use the <a href="#netCDF4.Dataset.createVLType"><code>createVLType</code></a> method
1915	2017	method of a <a href="#netCDF4.Dataset"><code>Dataset</code></a> or <a href="#netCDF4.Group"><code>Group</code></a> instance.</p>
1916		<pre><code>:::python
1917		>>> f = Dataset("tst_vlen.nc","w")
1918		>>> vlen_t = f.createVLType(numpy.int32, "phony_vlen")
1919		</code></pre>
	2018	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="n">f</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s2">"tst_vlen.nc"</span><span class="p">,</span><span class="s2">"w"</span><span class="p">)</span>
	2019	<span class="o">>>></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="s2">"phony_vlen"</span><span class="p">)</span>
	2020	</code></pre></div>
	2021
	2022
1920	2023	<p>The numpy datatype of the variable-length sequences and the name of the
1921	2024	new datatype must be specified. Any of the primitive datatypes can be
1922	2025	used (signed and unsigned integers, 32 and 64 bit floats, and characters),
1923	2026	but compound data types cannot.
1924	2027	A new variable can then be created using this datatype.</p>
1925		<pre><code>:::python
1926		>>> x = f.createDimension("x",3)
1927		>>> y = f.createDimension("y",4)
1928		>>> vlvar = f.createVariable("phony_vlen_var", vlen_t, ("y","x"))
1929		</code></pre>
	2028	<div class="codehilite"><pre><span></span><code><span class="o">>>></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="s2">"x"</span><span class="p">,</span><span class="mi">3</span><span class="p">)</span>
	2029	<span class="o">>>></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="s2">"y"</span><span class="p">,</span><span class="mi">4</span><span class="p">)</span>
	2030	<span class="o">>>></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="s2">"phony_vlen_var"</span><span class="p">,</span> <span class="n">vlen_t</span><span class="p">,</span> <span class="p">(</span><span class="s2">"y"</span><span class="p">,</span><span class="s2">"x"</span><span class="p">))</span>
	2031	</code></pre></div>
	2032
	2033
1930	2034	<p>Since there is no native vlen datatype in numpy, vlen arrays are represented
1931	2035	in python as object arrays (arrays of dtype <code>object</code>). These are arrays whose
1932	2036	elements are Python object pointers, and can contain any type of python object.

1934	2038	but of varying length.
1935	2039	In this case, they contain 1-D numpy <code>int32</code> arrays of random length between
1936	2040	1 and 10.</p>
1937		<pre><code>:::python
1938		>>> import random
1939		>>> random.seed(54321)
1940		>>> data = numpy.empty(len(y)*len(x),object)
1941		>>> for n in range(len(y)*len(x)):
1942		... data[n] = numpy.arange(random.randint(1,10),dtype="int32")+1
1943		>>> data = numpy.reshape(data,(len(y),len(x)))
1944		>>> vlvar[:] = data
1945		>>> print("vlen variable =\n{}".format(vlvar[:]))
1946		vlen variable =
1947		[[array([1, 2, 3, 4, 5, 6, 7, 8], dtype=int32) array([1, 2], dtype=int32)
1948		array([1, 2, 3, 4], dtype=int32)]
1949		[array([1, 2, 3], dtype=int32)
1950		array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32)
1951		array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32)]
1952		[array([1, 2, 3, 4, 5, 6, 7], dtype=int32) array([1, 2, 3], dtype=int32)
1953		array([1, 2, 3, 4, 5, 6], dtype=int32)]
1954		[array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32)
1955		array([1, 2, 3, 4, 5], dtype=int32) array([1, 2], dtype=int32)]]
1956		>>> print(f)
1957		<class 'netCDF4._netCDF4.Dataset'>
1958		root group (NETCDF4 data model, file format HDF5):
1959		dimensions(sizes): x(3), y(4)
1960		variables(dimensions): int32 phony_vlen_var(y,x)
1961		groups:
1962		>>> print(f.variables["phony_vlen_var"])
1963		<class 'netCDF4._netCDF4.Variable'>
1964		vlen phony_vlen_var(y, x)
1965		vlen data type: int32
1966		unlimited dimensions:
1967		current shape = (4, 3)
1968		>>> print(f.vltypes["phony_vlen"])
1969		<class 'netCDF4._netCDF4.VLType'>: name = 'phony_vlen', numpy dtype = int32
1970		</code></pre>
	2041	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="kn">import</span> <span class="nn">random</span>
	2042	<span class="o">>>></span> <span class="n">random</span><span class="o">.</span><span class="n">seed</span><span class="p">(</span><span class="mi">54321</span><span class="p">)</span>
	2043	<span class="o">>>></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>
	2044	<span class="o">>>></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>
	2045	<span class="o">...</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="s2">"int32"</span><span class="p">)</span><span class="o">+</span><span class="mi">1</span>
	2046	<span class="o">>>></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>
	2047	<span class="o">>>></span> <span class="n">vlvar</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">data</span>
	2048	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="s2">"vlen variable =</span><span class="se">\n</span><span class="si">{}</span><span class="s2">"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">vlvar</span><span class="p">[:]))</span>
	2049	<span class="n">vlen</span> <span class="n">variable</span> <span class="o">=</span>
	2050	<span class="p">[[</span><span class="n">array</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">8</span><span class="p">],</span> <span class="n">dtype</span><span class="o">=</span><span class="n">int32</span><span class="p">)</span> <span class="n">array</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="n">dtype</span><span class="o">=</span><span class="n">int32</span><span class="p">)</span>
	2051	<span class="n">array</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">],</span> <span class="n">dtype</span><span class="o">=</span><span class="n">int32</span><span class="p">)]</span>
	2052	<span class="p">[</span><span class="n">array</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="n">dtype</span><span class="o">=</span><span class="n">int32</span><span class="p">)</span>
	2053	<span class="n">array</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">8</span><span class="p">,</span> <span class="mi">9</span><span class="p">],</span> <span class="n">dtype</span><span class="o">=</span><span class="n">int32</span><span class="p">)</span>
	2054	<span class="n">array</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">8</span><span class="p">,</span> <span class="mi">9</span><span class="p">],</span> <span class="n">dtype</span><span class="o">=</span><span class="n">int32</span><span class="p">)]</span>
	2055	<span class="p">[</span><span class="n">array</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">],</span> <span class="n">dtype</span><span class="o">=</span><span class="n">int32</span><span class="p">)</span> <span class="n">array</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="n">dtype</span><span class="o">=</span><span class="n">int32</span><span class="p">)</span>
	2056	<span class="n">array</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">],</span> <span class="n">dtype</span><span class="o">=</span><span class="n">int32</span><span class="p">)]</span>
	2057	<span class="p">[</span><span class="n">array</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">8</span><span class="p">,</span> <span class="mi">9</span><span class="p">],</span> <span class="n">dtype</span><span class="o">=</span><span class="n">int32</span><span class="p">)</span>
	2058	<span class="n">array</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">],</span> <span class="n">dtype</span><span class="o">=</span><span class="n">int32</span><span class="p">)</span> <span class="n">array</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="n">dtype</span><span class="o">=</span><span class="n">int32</span><span class="p">)]]</span>
	2059	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
	2060	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Dataset</span><span class="s1">'></span>
	2061	<span class="n">root</span> <span class="n">group</span> <span class="p">(</span><span class="n">NETCDF4</span> <span class="n">data</span> <span class="n">model</span><span class="p">,</span> <span class="n">file</span> <span class="nb">format</span> <span class="n">HDF5</span><span class="p">):</span>
	2062	<span class="n">dimensions</span><span class="p">(</span><span class="n">sizes</span><span class="p">):</span> <span class="n">x</span><span class="p">(</span><span class="mi">3</span><span class="p">),</span> <span class="n">y</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
	2063	<span class="n">variables</span><span class="p">(</span><span class="n">dimensions</span><span class="p">):</span> <span class="n">int32</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>
	2064	<span class="n">groups</span><span class="p">:</span>
	2065	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">f</span><span class="o">.</span><span class="n">variables</span><span class="p">[</span><span class="s2">"phony_vlen_var"</span><span class="p">])</span>
	2066	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Variable</span><span class="s1">'></span>
	2067	<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>
	2068	<span class="n">vlen</span> <span class="n">data</span> <span class="nb">type</span><span class="p">:</span> <span class="n">int32</span>
	2069	<span class="n">unlimited</span> <span class="n">dimensions</span><span class="p">:</span>
	2070	<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>
	2071	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">f</span><span class="o">.</span><span class="n">vltypes</span><span class="p">[</span><span class="s2">"phony_vlen"</span><span class="p">])</span>
	2072	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">VLType</span><span class="s1">'>: name = '</span><span class="n">phony_vlen</span><span class="s1">', numpy dtype = int32</span>
	2073	</code></pre></div>
	2074
	2075
1971	2076	<p>Numpy object arrays containing python strings can also be written as vlen
1972	2077	variables, For vlen strings, you don't need to create a vlen data type.
1973	2078	Instead, simply use the python <code>str</code> builtin (or a numpy string datatype
1974	2079	with fixed length greater than 1) when calling the
1975	2080	<a href="#netCDF4.Dataset.createVariable"><code>createVariable</code></a> method.</p>
1976		<pre><code>:::python
1977		>>> z = f.createDimension("z",10)
1978		>>> strvar = f.createVariable("strvar", str, "z")
1979		</code></pre>
	2081	<div class="codehilite"><pre><span></span><code><span class="o">>>></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="s2">"z"</span><span class="p">,</span><span class="mi">10</span><span class="p">)</span>
	2082	<span class="o">>>></span> <span class="n">strvar</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="s2">"strvar"</span><span class="p">,</span> <span class="nb">str</span><span class="p">,</span> <span class="s2">"z"</span><span class="p">)</span>
	2083	</code></pre></div>
	2084
	2085
1980	2086	<p>In this example, an object array is filled with random python strings with
1981	2087	random lengths between 2 and 12 characters, and the data in the object
1982	2088	array is assigned to the vlen string variable.</p>
1983		<pre><code>:::python
1984		>>> chars = "1234567890aabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
1985		>>> data = numpy.empty(10,"O")
1986		>>> for n in range(10):
1987		... stringlen = random.randint(2,12)
1988		... data[n] = "".join([random.choice(chars) for i in range(stringlen)])
1989		>>> strvar[:] = data
1990		>>> print("variable-length string variable:\n{}".format(strvar[:]))
1991		variable-length string variable:
1992		['Lh' '25F8wBbMI' '53rmM' 'vvjnb3t63ao' 'qjRBQk6w' 'aJh' 'QF'
1993		'jtIJbJACaQk4' '3Z5' 'bftIIq']
1994		>>> print(f)
1995		<class 'netCDF4._netCDF4.Dataset'>
1996		root group (NETCDF4 data model, file format HDF5):
1997		dimensions(sizes): x(3), y(4), z(10)
1998		variables(dimensions): int32 phony_vlen_var(y,x), <class 'str'> strvar(z)
1999		groups:
2000		>>> print(f.variables["strvar"])
2001		<class 'netCDF4._netCDF4.Variable'>
2002		vlen strvar(z)
2003		vlen data type: <class 'str'>
2004		unlimited dimensions:
2005		current shape = (10,)
2006		</code></pre>
	2089	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="n">chars</span> <span class="o">=</span> <span class="s2">"1234567890aabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"</span>
	2090	<span class="o">>>></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="s2">"O"</span><span class="p">)</span>
	2091	<span class="o">>>></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>
	2092	<span class="o">...</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>
	2093	<span class="o">...</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="s2">""</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>
	2094	<span class="o">>>></span> <span class="n">strvar</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">data</span>
	2095	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="s2">"variable-length string variable:</span><span class="se">\n</span><span class="si">{}</span><span class="s2">"</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">strvar</span><span class="p">[:]))</span>
	2096	<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>
	2097	<span class="p">[</span><span class="s1">'Lh'</span> <span class="s1">'25F8wBbMI'</span> <span class="s1">'53rmM'</span> <span class="s1">'vvjnb3t63ao'</span> <span class="s1">'qjRBQk6w'</span> <span class="s1">'aJh'</span> <span class="s1">'QF'</span>
	2098	<span class="s1">'jtIJbJACaQk4'</span> <span class="s1">'3Z5'</span> <span class="s1">'bftIIq'</span><span class="p">]</span>
	2099	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
	2100	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Dataset</span><span class="s1">'></span>
	2101	<span class="n">root</span> <span class="n">group</span> <span class="p">(</span><span class="n">NETCDF4</span> <span class="n">data</span> <span class="n">model</span><span class="p">,</span> <span class="n">file</span> <span class="nb">format</span> <span class="n">HDF5</span><span class="p">):</span>
	2102	<span class="n">dimensions</span><span class="p">(</span><span class="n">sizes</span><span class="p">):</span> <span class="n">x</span><span class="p">(</span><span class="mi">3</span><span class="p">),</span> <span class="n">y</span><span class="p">(</span><span class="mi">4</span><span class="p">),</span> <span class="n">z</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span>
	2103	<span class="n">variables</span><span class="p">(</span><span class="n">dimensions</span><span class="p">):</span> <span class="n">int32</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="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">str</span><span class="s1">'> strvar(z)</span>
	2104	<span class="n">groups</span><span class="p">:</span>
	2105	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">f</span><span class="o">.</span><span class="n">variables</span><span class="p">[</span><span class="s2">"strvar"</span><span class="p">])</span>
	2106	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Variable</span><span class="s1">'></span>
	2107	<span class="n">vlen</span> <span class="n">strvar</span><span class="p">(</span><span class="n">z</span><span class="p">)</span>
	2108	<span class="n">vlen</span> <span class="n">data</span> <span class="nb">type</span><span class="p">:</span> <span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">str</span><span class="s1">'></span>
	2109	<span class="n">unlimited</span> <span class="n">dimensions</span><span class="p">:</span>
	2110	<span class="n">current</span> <span class="n">shape</span> <span class="o">=</span> <span class="p">(</span><span class="mi">10</span><span class="p">,)</span>
	2111	</code></pre></div>
	2112
	2113
2007	2114	<p>It is also possible to set contents of vlen string variables with numpy arrays
2008	2115	of any string or unicode data type. Note, however, that accessing the contents
2009	2116	of such variables will always return numpy arrays with dtype <code>object</code>.</p>

2015	2122	The base integer data type and a python dictionary describing the allowed
2016	2123	values and their names are used to define an Enum data type using
2017	2124	<a href="#netCDF4.Dataset.createEnumType"><code>createEnumType</code></a>.</p>
2018		<pre><code>:::python
2019		>>> nc = Dataset('clouds.nc','w')
2020		>>> # python dict with allowed values and their names.
2021		>>> enum_dict = {'Altocumulus': 7, 'Missing': 255,
2022		... 'Stratus': 2, 'Clear': 0,
2023		... 'Nimbostratus': 6, 'Cumulus': 4, 'Altostratus': 5,
2024		... 'Cumulonimbus': 1, 'Stratocumulus': 3}
2025		>>> # create the Enum type called 'cloud_t'.
2026		>>> cloud_type = nc.createEnumType(numpy.uint8,'cloud_t',enum_dict)
2027		>>> print(cloud_type)
2028		<class 'netCDF4._netCDF4.EnumType'>: name = 'cloud_t', numpy dtype = uint8, fields/values ={'Altocumulus': 7, 'Missing': 255, 'Stratus': 2, 'Clear': 0, 'Nimbostratus': 6, 'Cumulus': 4, 'Altostratus': 5, 'Cumulonimbus': 1, 'Stratocumulus': 3}
2029		</code></pre>
	2125	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="n">nc</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s1">'clouds.nc'</span><span class="p">,</span><span class="s1">'w'</span><span class="p">)</span>
	2126	<span class="o">>>></span> <span class="c1"># python dict with allowed values and their names.</span>
	2127	<span class="o">>>></span> <span class="n">enum_dict</span> <span class="o">=</span> <span class="p">{</span><span class="s1">'Altocumulus'</span><span class="p">:</span> <span class="mi">7</span><span class="p">,</span> <span class="s1">'Missing'</span><span class="p">:</span> <span class="mi">255</span><span class="p">,</span>
	2128	<span class="o">...</span> <span class="s1">'Stratus'</span><span class="p">:</span> <span class="mi">2</span><span class="p">,</span> <span class="s1">'Clear'</span><span class="p">:</span> <span class="mi">0</span><span class="p">,</span>
	2129	<span class="o">...</span> <span class="s1">'Nimbostratus'</span><span class="p">:</span> <span class="mi">6</span><span class="p">,</span> <span class="s1">'Cumulus'</span><span class="p">:</span> <span class="mi">4</span><span class="p">,</span> <span class="s1">'Altostratus'</span><span class="p">:</span> <span class="mi">5</span><span class="p">,</span>
	2130	<span class="o">...</span> <span class="s1">'Cumulonimbus'</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="s1">'Stratocumulus'</span><span class="p">:</span> <span class="mi">3</span><span class="p">}</span>
	2131	<span class="o">>>></span> <span class="c1"># create the Enum type called 'cloud_t'.</span>
	2132	<span class="o">>>></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="s1">'cloud_t'</span><span class="p">,</span><span class="n">enum_dict</span><span class="p">)</span>
	2133	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">cloud_type</span><span class="p">)</span>
	2134	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">EnumType</span><span class="s1">'>: name = '</span><span class="n">cloud_t</span><span class="s1">', numpy dtype = uint8, fields/values ={'</span><span class="n">Altocumulus</span><span class="s1">': 7, '</span><span class="n">Missing</span><span class="s1">': 255, '</span><span class="n">Stratus</span><span class="s1">': 2, '</span><span class="n">Clear</span><span class="s1">': 0, '</span><span class="n">Nimbostratus</span><span class="s1">': 6, '</span><span class="n">Cumulus</span><span class="s1">': 4, '</span><span class="n">Altostratus</span><span class="s1">': 5, '</span><span class="n">Cumulonimbus</span><span class="s1">': 1, '</span><span class="n">Stratocumulus</span><span class="s1">': 3}</span>
	2135	</code></pre></div>
	2136
	2137
2030	2138	<p>A new variable can be created in the usual way using this data type.
2031	2139	Integer data is written to the variable that represents the named
2032	2140	cloud types in enum_dict. A <code>ValueError</code> will be raised if an attempt
2033	2141	is made to write an integer value not associated with one of the
2034	2142	specified names.</p>
2035		<pre><code>:::python
2036		>>> time = nc.createDimension('time',None)
2037		>>> # create a 1d variable of type 'cloud_type'.
2038		>>> # The fill_value is set to the 'Missing' named value.
2039		>>> cloud_var = nc.createVariable('primary_cloud',cloud_type,'time',
2040		... fill_value=enum_dict['Missing'])
2041		>>> # write some data to the variable.
2042		>>> cloud_var[:] = [enum_dict[k] for k in ['Clear', 'Stratus', 'Cumulus',
2043		... 'Missing', 'Cumulonimbus']]
2044		>>> nc.close()
2045		>>> # reopen the file, read the data.
2046		>>> nc = Dataset('clouds.nc')
2047		>>> cloud_var = nc.variables['primary_cloud']
2048		>>> print(cloud_var)
2049		<class 'netCDF4._netCDF4.Variable'>
2050		enum primary_cloud(time)
2051		_FillValue: 255
2052		enum data type: uint8
2053		unlimited dimensions: time
2054		current shape = (5,)
2055		>>> print(cloud_var.datatype.enum_dict)
2056		{'Altocumulus': 7, 'Missing': 255, 'Stratus': 2, 'Clear': 0, 'Nimbostratus': 6, 'Cumulus': 4, 'Altostratus': 5, 'Cumulonimbus': 1, 'Stratocumulus': 3}
2057		>>> print(cloud_var[:])
2058		[0 2 4 -- 1]
2059		>>> nc.close()
2060		</code></pre>
	2143	<div class="codehilite"><pre><span></span><code><span class="o">>>></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="s1">'time'</span><span class="p">,</span><span class="kc">None</span><span class="p">)</span>
	2144	<span class="o">>>></span> <span class="c1"># create a 1d variable of type 'cloud_type'.</span>
	2145	<span class="o">>>></span> <span class="c1"># The fill_value is set to the 'Missing' named value.</span>
	2146	<span class="o">>>></span> <span class="n">cloud_var</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="s1">'primary_cloud'</span><span class="p">,</span><span class="n">cloud_type</span><span class="p">,</span><span class="s1">'time'</span><span class="p">,</span>
	2147	<span class="o">...</span> <span class="n">fill_value</span><span class="o">=</span><span class="n">enum_dict</span><span class="p">[</span><span class="s1">'Missing'</span><span class="p">])</span>
	2148	<span class="o">>>></span> <span class="c1"># write some data to the variable.</span>
	2149	<span class="o">>>></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="n">k</span><span class="p">]</span> <span class="k">for</span> <span class="n">k</span> <span class="ow">in</span> <span class="p">[</span><span class="s1">'Clear'</span><span class="p">,</span> <span class="s1">'Stratus'</span><span class="p">,</span> <span class="s1">'Cumulus'</span><span class="p">,</span>
	2150	<span class="o">...</span> <span class="s1">'Missing'</span><span class="p">,</span> <span class="s1">'Cumulonimbus'</span><span class="p">]]</span>
	2151	<span class="o">>>></span> <span class="n">nc</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
	2152	<span class="o">>>></span> <span class="c1"># reopen the file, read the data.</span>
	2153	<span class="o">>>></span> <span class="n">nc</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s1">'clouds.nc'</span><span class="p">)</span>
	2154	<span class="o">>>></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="s1">'primary_cloud'</span><span class="p">]</span>
	2155	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">cloud_var</span><span class="p">)</span>
	2156	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Variable</span><span class="s1">'></span>
	2157	<span class="n">enum</span> <span class="n">primary_cloud</span><span class="p">(</span><span class="n">time</span><span class="p">)</span>
	2158	<span class="n">_FillValue</span><span class="p">:</span> <span class="mi">255</span>
	2159	<span class="n">enum</span> <span class="n">data</span> <span class="nb">type</span><span class="p">:</span> <span class="n">uint8</span>
	2160	<span class="n">unlimited</span> <span class="n">dimensions</span><span class="p">:</span> <span class="n">time</span>
	2161	<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>
	2162	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</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>
	2163	<span class="p">{</span><span class="s1">'Altocumulus'</span><span class="p">:</span> <span class="mi">7</span><span class="p">,</span> <span class="s1">'Missing'</span><span class="p">:</span> <span class="mi">255</span><span class="p">,</span> <span class="s1">'Stratus'</span><span class="p">:</span> <span class="mi">2</span><span class="p">,</span> <span class="s1">'Clear'</span><span class="p">:</span> <span class="mi">0</span><span class="p">,</span> <span class="s1">'Nimbostratus'</span><span class="p">:</span> <span class="mi">6</span><span class="p">,</span> <span class="s1">'Cumulus'</span><span class="p">:</span> <span class="mi">4</span><span class="p">,</span> <span class="s1">'Altostratus'</span><span class="p">:</span> <span class="mi">5</span><span class="p">,</span> <span class="s1">'Cumulonimbus'</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="s1">'Stratocumulus'</span><span class="p">:</span> <span class="mi">3</span><span class="p">}</span>
	2164	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">cloud_var</span><span class="p">[:])</span>
	2165	<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>
	2166	<span class="o">>>></span> <span class="n">nc</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
	2167	</code></pre></div>
	2168
	2169
2061	2170	<h2><div id='section13'>13) Parallel IO.</h2>
2062	2171	<p>If MPI parallel enabled versions of netcdf and hdf5 or pnetcdf are detected,
2063	2172	and <a href="https://mpi4py.scipy.org">mpi4py</a> is installed, netcdf4-python will

2067	2176	available if the <a href="https://parallel-netcdf.github.io/">PnetCDF</a> library is
2068	2177	available. To use parallel IO, your program must be running in an MPI
2069	2178	environment using <a href="https://mpi4py.scipy.org">mpi4py</a>.</p>
2070		<pre><code>:::python
2071		>>> from mpi4py import MPI
2072		>>> import numpy as np
2073		>>> from netCDF4 import Dataset
2074		>>> rank = MPI.COMM_WORLD.rank # The process ID (integer 0-3 for 4-process run)
2075		</code></pre>
	2179	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="kn">from</span> <span class="nn">mpi4py</span> <span class="kn">import</span> <span class="n">MPI</span>
	2180	<span class="o">>>></span> <span class="kn">import</span> <span class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>
	2181	<span class="o">>>></span> <span class="kn">from</span> <span class="nn">netCDF4</span> <span class="kn">import</span> <span class="n">Dataset</span>
	2182	<span class="o">>>></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="c1"># The process ID (integer 0-3 for 4-process run)</span>
	2183	</code></pre></div>
	2184
	2185
2076	2186	<p>To run an MPI-based parallel program like this, you must use <code>mpiexec</code> to launch several
2077	2187	parallel instances of Python (for example, using <code>mpiexec -np 4 python mpi_example.py</code>).
2078	2188	The parallel features of netcdf4-python are mostly transparent -
2079	2189	when a new dataset is created or an existing dataset is opened,
2080	2190	use the <code>parallel</code> keyword to enable parallel access.</p>
2081		<pre><code>:::python
2082		>>> nc = Dataset('parallel_test.nc','w',parallel=True)
2083		</code></pre>
	2191	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="n">nc</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s1">'parallel_test.nc'</span><span class="p">,</span><span class="s1">'w'</span><span class="p">,</span><span class="n">parallel</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
	2192	</code></pre></div>
	2193
	2194
2084	2195	<p>The optional <code>comm</code> keyword may be used to specify a particular
2085	2196	MPI communicator (<code>MPI_COMM_WORLD</code> is used by default). Each process (or rank)
2086	2197	can now write to the file indepedently. In this example the process rank is
2087	2198	written to a different variable index on each task</p>
2088		<pre><code>:::python
2089		>>> d = nc.createDimension('dim',4)
2090		>>> v = nc.createVariable('var', np.int, 'dim')
2091		>>> v[rank] = rank
2092		>>> nc.close()
2093
2094		% ncdump parallel_test.nc
2095		netcdf parallel_test {
2096		dimensions:
2097		dim = 4 ;
2098		variables:
2099		int64 var(dim) ;
2100		data:
2101
2102		var = 0, 1, 2, 3 ;
2103		}
2104		</code></pre>
	2199	<div class="codehilite"><pre><span></span><code><span class="o">>>></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="s1">'dim'</span><span class="p">,</span><span class="mi">4</span><span class="p">)</span>
	2200	<span class="o">>>></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="s1">'var'</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="s1">'dim'</span><span class="p">)</span>
	2201	<span class="o">>>></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>
	2202	<span class="o">>>></span> <span class="n">nc</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
	2203
	2204	<span class="o">%</span> <span class="n">ncdump</span> <span class="n">parallel_test</span><span class="o">.</span><span class="n">nc</span>
	2205	<span class="n">netcdf</span> <span class="n">parallel_test</span> <span class="p">{</span>
	2206	<span class="n">dimensions</span><span class="p">:</span>
	2207	<span class="n">dim</span> <span class="o">=</span> <span class="mi">4</span> <span class="p">;</span>
	2208	<span class="n">variables</span><span class="p">:</span>
	2209	<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>
	2210	<span class="n">data</span><span class="p">:</span>
	2211
	2212	<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>
	2213	<span class="p">}</span>
	2214	</code></pre></div>
	2215
	2216
2105	2217	<p>There are two types of parallel IO, independent (the default) and collective.
2106	2218	Independent IO means that each process can do IO independently. It should not
2107	2219	depend on or be affected by other processes. Collective IO is a way of doing

2144	2256	<code>U#</code>) array is created. When writing the data,
2145	2257	<a href="#netCDF4.stringtochar"><code>stringtochar</code></a> is used to convert the numpy string array to an array of
2146	2258	characters with one more dimension. For example,</p>
2147		<pre><code>:::python
2148		>>> from netCDF4 import stringtochar
2149		>>> nc = Dataset('stringtest.nc','w',format='NETCDF4_CLASSIC')
2150		>>> _ = nc.createDimension('nchars',3)
2151		>>> _ = nc.createDimension('nstrings',None)
2152		>>> v = nc.createVariable('strings','S1',('nstrings','nchars'))
2153		>>> datain = numpy.array(['foo','bar'],dtype='S3')
2154		>>> v[:] = stringtochar(datain) # manual conversion to char array
2155		>>> print(v[:]) # data returned as char array
2156		[[b'f' b'o' b'o']
2157		[b'b' b'a' b'r']]
2158		>>> v._Encoding = 'ascii' # this enables automatic conversion
2159		>>> v[:] = datain # conversion to char array done internally
2160		>>> print(v[:]) # data returned in numpy string array
2161		['foo' 'bar']
2162		>>> nc.close()
2163		</code></pre>
	2259	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="kn">from</span> <span class="nn">netCDF4</span> <span class="kn">import</span> <span class="n">stringtochar</span>
	2260	<span class="o">>>></span> <span class="n">nc</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s1">'stringtest.nc'</span><span class="p">,</span><span class="s1">'w'</span><span class="p">,</span><span class="nb">format</span><span class="o">=</span><span class="s1">'NETCDF4_CLASSIC'</span><span class="p">)</span>
	2261	<span class="o">>>></span> <span class="n">_</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="s1">'nchars'</span><span class="p">,</span><span class="mi">3</span><span class="p">)</span>
	2262	<span class="o">>>></span> <span class="n">_</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="s1">'nstrings'</span><span class="p">,</span><span class="kc">None</span><span class="p">)</span>
	2263	<span class="o">>>></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="s1">'strings'</span><span class="p">,</span><span class="s1">'S1'</span><span class="p">,(</span><span class="s1">'nstrings'</span><span class="p">,</span><span class="s1">'nchars'</span><span class="p">))</span>
	2264	<span class="o">>>></span> <span class="n">datain</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="s1">'foo'</span><span class="p">,</span><span class="s1">'bar'</span><span class="p">],</span><span class="n">dtype</span><span class="o">=</span><span class="s1">'S3'</span><span class="p">)</span>
	2265	<span class="o">>>></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="c1"># manual conversion to char array</span>
	2266	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">v</span><span class="p">[:])</span> <span class="c1"># data returned as char array</span>
	2267	<span class="p">[[</span><span class="sa">b</span><span class="s1">'f'</span> <span class="sa">b</span><span class="s1">'o'</span> <span class="sa">b</span><span class="s1">'o'</span><span class="p">]</span>
	2268	<span class="p">[</span><span class="sa">b</span><span class="s1">'b'</span> <span class="sa">b</span><span class="s1">'a'</span> <span class="sa">b</span><span class="s1">'r'</span><span class="p">]]</span>
	2269	<span class="o">>>></span> <span class="n">v</span><span class="o">.</span><span class="n">_Encoding</span> <span class="o">=</span> <span class="s1">'ascii'</span> <span class="c1"># this enables automatic conversion</span>
	2270	<span class="o">>>></span> <span class="n">v</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">datain</span> <span class="c1"># conversion to char array done internally</span>
	2271	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">v</span><span class="p">[:])</span> <span class="c1"># data returned in numpy string array</span>
	2272	<span class="p">[</span><span class="s1">'foo'</span> <span class="s1">'bar'</span><span class="p">]</span>
	2273	<span class="o">>>></span> <span class="n">nc</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
	2274	</code></pre></div>
	2275
	2276
2164	2277	<p>Even if the <code>_Encoding</code> attribute is set, the automatic conversion of char
2165	2278	arrays to/from string arrays can be disabled with
2166	2279	<a href="#netCDF4.Variable.set_auto_chartostring"><code>set_auto_chartostring</code></a>.</p>

2175	2288	define the compound data type - the string dtype will be converted to
2176	2289	character array dtype under the hood when creating the netcdf compound type.
2177	2290	Here's an example:</p>
2178		<pre><code>:::python
2179		>>> nc = Dataset('compoundstring_example.nc','w')
2180		>>> dtype = numpy.dtype([('observation', 'f4'),
2181		... ('station_name','S10')])
2182		>>> station_data_t = nc.createCompoundType(dtype,'station_data')
2183		>>> _ = nc.createDimension('station',None)
2184		>>> statdat = nc.createVariable('station_obs', station_data_t, ('station',))
2185		>>> data = numpy.empty(2,dtype)
2186		>>> data['observation'][:] = (123.,3.14)
2187		>>> data['station_name'][:] = ('Boulder','New York')
2188		>>> print(statdat.dtype) # strings actually stored as character arrays
2189		{'names':['observation','station_name'], 'formats':['<f4',('S1', (10,))], 'offsets':[0,4], 'itemsize':16, 'aligned':True}
2190		>>> statdat[:] = data # strings converted to character arrays internally
2191		>>> print(statdat[:]) # character arrays converted back to strings
2192		[(123. , b'Boulder') ( 3.14, b'New York')]
2193		>>> print(statdat[:].dtype)
2194		{'names':['observation','station_name'], 'formats':['<f4','S10'], 'offsets':[0,4], 'itemsize':16, 'aligned':True}
2195		>>> statdat.set_auto_chartostring(False) # turn off auto-conversion
2196		>>> statdat[:] = data.view(dtype=[('observation', 'f4'),('station_name','S1',10)])
2197		>>> print(statdat[:]) # now structured array with char array subtype is returned
2198		[(123. , [b'B', b'o', b'u', b'l', b'd', b'e', b'r', b'', b'', b''])
2199		( 3.14, [b'N', b'e', b'w', b' ', b'Y', b'o', b'r', b'k', b'', b''])]
2200		>>> nc.close()
2201		</code></pre>
	2291	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="n">nc</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s1">'compoundstring_example.nc'</span><span class="p">,</span><span class="s1">'w'</span><span class="p">)</span>
	2292	<span class="o">>>></span> <span class="n">dtype</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="s1">'observation'</span><span class="p">,</span> <span class="s1">'f4'</span><span class="p">),</span>
	2293	<span class="o">...</span> <span class="p">(</span><span class="s1">'station_name'</span><span class="p">,</span><span class="s1">'S10'</span><span class="p">)])</span>
	2294	<span class="o">>>></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="s1">'station_data'</span><span class="p">)</span>
	2295	<span class="o">>>></span> <span class="n">_</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="s1">'station'</span><span class="p">,</span><span class="kc">None</span><span class="p">)</span>
	2296	<span class="o">>>></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="s1">'station_obs'</span><span class="p">,</span> <span class="n">station_data_t</span><span class="p">,</span> <span class="p">(</span><span class="s1">'station'</span><span class="p">,))</span>
	2297	<span class="o">>>></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">2</span><span class="p">,</span><span class="n">dtype</span><span class="p">)</span>
	2298	<span class="o">>>></span> <span class="n">data</span><span class="p">[</span><span class="s1">'observation'</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>
	2299	<span class="o">>>></span> <span class="n">data</span><span class="p">[</span><span class="s1">'station_name'</span><span class="p">][:]</span> <span class="o">=</span> <span class="p">(</span><span class="s1">'Boulder'</span><span class="p">,</span><span class="s1">'New York'</span><span class="p">)</span>
	2300	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">statdat</span><span class="o">.</span><span class="n">dtype</span><span class="p">)</span> <span class="c1"># strings actually stored as character arrays</span>
	2301	<span class="p">{</span><span class="s1">'names'</span><span class="p">:[</span><span class="s1">'observation'</span><span class="p">,</span><span class="s1">'station_name'</span><span class="p">],</span> <span class="s1">'formats'</span><span class="p">:[</span><span class="s1">'<f4'</span><span class="p">,(</span><span class="s1">'S1'</span><span class="p">,</span> <span class="p">(</span><span class="mi">10</span><span class="p">,))],</span> <span class="s1">'offsets'</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="s1">'itemsize'</span><span class="p">:</span><span class="mi">16</span><span class="p">,</span> <span class="s1">'aligned'</span><span class="p">:</span><span class="kc">True</span><span class="p">}</span>
	2302	<span class="o">>>></span> <span class="n">statdat</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">data</span> <span class="c1"># strings converted to character arrays internally</span>
	2303	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">statdat</span><span class="p">[:])</span> <span class="c1"># character arrays converted back to strings</span>
	2304	<span class="p">[(</span><span class="mf">123.</span> <span class="p">,</span> <span class="sa">b</span><span class="s1">'Boulder'</span><span class="p">)</span> <span class="p">(</span> <span class="mf">3.14</span><span class="p">,</span> <span class="sa">b</span><span class="s1">'New York'</span><span class="p">)]</span>
	2305	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">statdat</span><span class="p">[:]</span><span class="o">.</span><span class="n">dtype</span><span class="p">)</span>
	2306	<span class="p">{</span><span class="s1">'names'</span><span class="p">:[</span><span class="s1">'observation'</span><span class="p">,</span><span class="s1">'station_name'</span><span class="p">],</span> <span class="s1">'formats'</span><span class="p">:[</span><span class="s1">'<f4'</span><span class="p">,</span><span class="s1">'S10'</span><span class="p">],</span> <span class="s1">'offsets'</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="s1">'itemsize'</span><span class="p">:</span><span class="mi">16</span><span class="p">,</span> <span class="s1">'aligned'</span><span class="p">:</span><span class="kc">True</span><span class="p">}</span>
	2307	<span class="o">>>></span> <span class="n">statdat</span><span class="o">.</span><span class="n">set_auto_chartostring</span><span class="p">(</span><span class="kc">False</span><span class="p">)</span> <span class="c1"># turn off auto-conversion</span>
	2308	<span class="o">>>></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="s1">'observation'</span><span class="p">,</span> <span class="s1">'f4'</span><span class="p">),(</span><span class="s1">'station_name'</span><span class="p">,</span><span class="s1">'S1'</span><span class="p">,</span><span class="mi">10</span><span class="p">)])</span>
	2309	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">statdat</span><span class="p">[:])</span> <span class="c1"># now structured array with char array subtype is returned</span>
	2310	<span class="p">[(</span><span class="mf">123.</span> <span class="p">,</span> <span class="p">[</span><span class="sa">b</span><span class="s1">'B'</span><span class="p">,</span> <span class="sa">b</span><span class="s1">'o'</span><span class="p">,</span> <span class="sa">b</span><span class="s1">'u'</span><span class="p">,</span> <span class="sa">b</span><span class="s1">'l'</span><span class="p">,</span> <span class="sa">b</span><span class="s1">'d'</span><span class="p">,</span> <span class="sa">b</span><span class="s1">'e'</span><span class="p">,</span> <span class="sa">b</span><span class="s1">'r'</span><span class="p">,</span> <span class="sa">b</span><span class="s1">''</span><span class="p">,</span> <span class="sa">b</span><span class="s1">''</span><span class="p">,</span> <span class="sa">b</span><span class="s1">''</span><span class="p">])</span>
	2311	<span class="p">(</span> <span class="mf">3.14</span><span class="p">,</span> <span class="p">[</span><span class="sa">b</span><span class="s1">'N'</span><span class="p">,</span> <span class="sa">b</span><span class="s1">'e'</span><span class="p">,</span> <span class="sa">b</span><span class="s1">'w'</span><span class="p">,</span> <span class="sa">b</span><span class="s1">' '</span><span class="p">,</span> <span class="sa">b</span><span class="s1">'Y'</span><span class="p">,</span> <span class="sa">b</span><span class="s1">'o'</span><span class="p">,</span> <span class="sa">b</span><span class="s1">'r'</span><span class="p">,</span> <span class="sa">b</span><span class="s1">'k'</span><span class="p">,</span> <span class="sa">b</span><span class="s1">''</span><span class="p">,</span> <span class="sa">b</span><span class="s1">''</span><span class="p">])]</span>
	2312	<span class="o">>>></span> <span class="n">nc</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
	2313	</code></pre></div>
	2314
	2315
2202	2316	<p>Note that there is currently no support for mapping numpy structured arrays with
2203	2317	unicode elements (dtype <code>U#</code>) onto netCDF compound types, nor is there support
2204	2318	for netCDF compound types with vlen string components.</p>

2217	2331	<code>mode='w'</code>. Then, the <code>Dataset.close</code> method will return a python memoryview
2218	2332	object representing the Dataset. Below are examples illustrating both
2219	2333	approaches.</p>
2220		<pre><code>:::python
2221		>>> # create a diskless (in-memory) Dataset,
2222		>>> # and persist the file to disk when it is closed.
2223		>>> nc = Dataset('diskless_example.nc','w',diskless=True,persist=True)
2224		>>> d = nc.createDimension('x',None)
2225		>>> v = nc.createVariable('v',numpy.int32,'x')
2226		>>> v[0:5] = numpy.arange(5)
2227		>>> print(nc)
2228		<class 'netCDF4._netCDF4.Dataset'>
2229		root group (NETCDF4 data model, file format HDF5):
2230		dimensions(sizes): x(5)
2231		variables(dimensions): int32 v(x)
2232		groups:
2233		>>> print(nc['v'][:])
2234		[0 1 2 3 4]
2235		>>> nc.close() # file saved to disk
2236		>>> # create an in-memory dataset from an existing python
2237		>>> # python memory buffer.
2238		>>> # read the newly created netcdf file into a python
2239		>>> # bytes object.
2240		>>> with open('diskless_example.nc', 'rb') as f:
2241		... nc_bytes = f.read()
2242		>>> # create a netCDF in-memory dataset from the bytes object.
2243		>>> nc = Dataset('inmemory.nc', memory=nc_bytes)
2244		>>> print(nc)
2245		<class 'netCDF4._netCDF4.Dataset'>
2246		root group (NETCDF4 data model, file format HDF5):
2247		dimensions(sizes): x(5)
2248		variables(dimensions): int32 v(x)
2249		groups:
2250		>>> print(nc['v'][:])
2251		[0 1 2 3 4]
2252		>>> nc.close()
2253		>>> # create an in-memory Dataset and retrieve memory buffer
2254		>>> # estimated size is 1028 bytes - this is actually only
2255		>>> # used if format is NETCDF3
2256		>>> # (ignored for NETCDF4/HDF5 files).
2257		>>> nc = Dataset('inmemory.nc', mode='w',memory=1028)
2258		>>> d = nc.createDimension('x',None)
2259		>>> v = nc.createVariable('v',numpy.int32,'x')
2260		>>> v[0:5] = numpy.arange(5)
2261		>>> nc_buf = nc.close() # close returns memoryview
2262		>>> print(type(nc_buf))
2263		<class 'memoryview'>
2264		>>> # save nc_buf to disk, read it back in and check.
2265		>>> with open('inmemory.nc', 'wb') as f:
2266		... f.write(nc_buf)
2267		>>> nc = Dataset('inmemory.nc')
2268		>>> print(nc)
2269		<class 'netCDF4._netCDF4.Dataset'>
2270		root group (NETCDF4 data model, file format HDF5):
2271		dimensions(sizes): x(5)
2272		variables(dimensions): int32 v(x)
2273		groups:
2274		>>> print(nc['v'][:])
2275		[0 1 2 3 4]
2276		>>> nc.close()
2277		</code></pre>
	2334	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="c1"># create a diskless (in-memory) Dataset,</span>
	2335	<span class="o">>>></span> <span class="c1"># and persist the file to disk when it is closed.</span>
	2336	<span class="o">>>></span> <span class="n">nc</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s1">'diskless_example.nc'</span><span class="p">,</span><span class="s1">'w'</span><span class="p">,</span><span class="n">diskless</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span><span class="n">persist</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
	2337	<span class="o">>>></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="s1">'x'</span><span class="p">,</span><span class="kc">None</span><span class="p">)</span>
	2338	<span class="o">>>></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="s1">'v'</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="s1">'x'</span><span class="p">)</span>
	2339	<span class="o">>>></span> <span class="n">v</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="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
	2340	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">nc</span><span class="p">)</span>
	2341	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Dataset</span><span class="s1">'></span>
	2342	<span class="n">root</span> <span class="n">group</span> <span class="p">(</span><span class="n">NETCDF4</span> <span class="n">data</span> <span class="n">model</span><span class="p">,</span> <span class="n">file</span> <span class="nb">format</span> <span class="n">HDF5</span><span class="p">):</span>
	2343	<span class="n">dimensions</span><span class="p">(</span><span class="n">sizes</span><span class="p">):</span> <span class="n">x</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
	2344	<span class="n">variables</span><span class="p">(</span><span class="n">dimensions</span><span class="p">):</span> <span class="n">int32</span> <span class="n">v</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
	2345	<span class="n">groups</span><span class="p">:</span>
	2346	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">nc</span><span class="p">[</span><span class="s1">'v'</span><span class="p">][:])</span>
	2347	<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="p">]</span>
	2348	<span class="o">>>></span> <span class="n">nc</span><span class="o">.</span><span class="n">close</span><span class="p">()</span> <span class="c1"># file saved to disk</span>
	2349	<span class="o">>>></span> <span class="c1"># create an in-memory dataset from an existing python</span>
	2350	<span class="o">>>></span> <span class="c1"># python memory buffer.</span>
	2351	<span class="o">>>></span> <span class="c1"># read the newly created netcdf file into a python</span>
	2352	<span class="o">>>></span> <span class="c1"># bytes object.</span>
	2353	<span class="o">>>></span> <span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="s1">'diskless_example.nc'</span><span class="p">,</span> <span class="s1">'rb'</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
	2354	<span class="o">...</span> <span class="n">nc_bytes</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="n">read</span><span class="p">()</span>
	2355	<span class="o">>>></span> <span class="c1"># create a netCDF in-memory dataset from the bytes object.</span>
	2356	<span class="o">>>></span> <span class="n">nc</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s1">'inmemory.nc'</span><span class="p">,</span> <span class="n">memory</span><span class="o">=</span><span class="n">nc_bytes</span><span class="p">)</span>
	2357	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">nc</span><span class="p">)</span>
	2358	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Dataset</span><span class="s1">'></span>
	2359	<span class="n">root</span> <span class="n">group</span> <span class="p">(</span><span class="n">NETCDF4</span> <span class="n">data</span> <span class="n">model</span><span class="p">,</span> <span class="n">file</span> <span class="nb">format</span> <span class="n">HDF5</span><span class="p">):</span>
	2360	<span class="n">dimensions</span><span class="p">(</span><span class="n">sizes</span><span class="p">):</span> <span class="n">x</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
	2361	<span class="n">variables</span><span class="p">(</span><span class="n">dimensions</span><span class="p">):</span> <span class="n">int32</span> <span class="n">v</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
	2362	<span class="n">groups</span><span class="p">:</span>
	2363	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">nc</span><span class="p">[</span><span class="s1">'v'</span><span class="p">][:])</span>
	2364	<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="p">]</span>
	2365	<span class="o">>>></span> <span class="n">nc</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
	2366	<span class="o">>>></span> <span class="c1"># create an in-memory Dataset and retrieve memory buffer</span>
	2367	<span class="o">>>></span> <span class="c1"># estimated size is 1028 bytes - this is actually only</span>
	2368	<span class="o">>>></span> <span class="c1"># used if format is NETCDF3</span>
	2369	<span class="o">>>></span> <span class="c1"># (ignored for NETCDF4/HDF5 files).</span>
	2370	<span class="o">>>></span> <span class="n">nc</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s1">'inmemory.nc'</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="s1">'w'</span><span class="p">,</span><span class="n">memory</span><span class="o">=</span><span class="mi">1028</span><span class="p">)</span>
	2371	<span class="o">>>></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="s1">'x'</span><span class="p">,</span><span class="kc">None</span><span class="p">)</span>
	2372	<span class="o">>>></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="s1">'v'</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="s1">'x'</span><span class="p">)</span>
	2373	<span class="o">>>></span> <span class="n">v</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="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
	2374	<span class="o">>>></span> <span class="n">nc_buf</span> <span class="o">=</span> <span class="n">nc</span><span class="o">.</span><span class="n">close</span><span class="p">()</span> <span class="c1"># close returns memoryview</span>
	2375	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="n">nc_buf</span><span class="p">))</span>
	2376	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">memoryview</span><span class="s1">'></span>
	2377	<span class="o">>>></span> <span class="c1"># save nc_buf to disk, read it back in and check.</span>
	2378	<span class="o">>>></span> <span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="s1">'inmemory.nc'</span><span class="p">,</span> <span class="s1">'wb'</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
	2379	<span class="o">...</span> <span class="n">f</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="n">nc_buf</span><span class="p">)</span>
	2380	<span class="o">>>></span> <span class="n">nc</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s1">'inmemory.nc'</span><span class="p">)</span>
	2381	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">nc</span><span class="p">)</span>
	2382	<span class="o"><</span><span class="k">class</span> <span class="err">'</span><span class="nc">netCDF4</span><span class="o">.</span><span class="n">_netCDF4</span><span class="o">.</span><span class="n">Dataset</span><span class="s1">'></span>
	2383	<span class="n">root</span> <span class="n">group</span> <span class="p">(</span><span class="n">NETCDF4</span> <span class="n">data</span> <span class="n">model</span><span class="p">,</span> <span class="n">file</span> <span class="nb">format</span> <span class="n">HDF5</span><span class="p">):</span>
	2384	<span class="n">dimensions</span><span class="p">(</span><span class="n">sizes</span><span class="p">):</span> <span class="n">x</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
	2385	<span class="n">variables</span><span class="p">(</span><span class="n">dimensions</span><span class="p">):</span> <span class="n">int32</span> <span class="n">v</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
	2386	<span class="n">groups</span><span class="p">:</span>
	2387	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">nc</span><span class="p">[</span><span class="s1">'v'</span><span class="p">][:])</span>
	2388	<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="p">]</span>
	2389	<span class="o">>>></span> <span class="n">nc</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
	2390	</code></pre></div>
	2391
	2392
2278	2393	<p>All of the code in this tutorial is available in <code>examples/tutorial.py</code>, except
2279	2394	the parallel IO example, which is in <code>examples/mpi_example.py</code>.
2280	2395	Unit tests are in the <code>test</code> directory.</p>

2396	2511
2397	2512
2398	2513	<div class="item">
	2514	<div class="name def" id="netCDF4.get_chunk_cache">
	2515	<p>def <span class="ident">get_chunk_cache</span>(</p><p>)</p>
	2516	</div>
	2517
	2518
	2519
	2520
	2521	<div class="desc"><p>return current netCDF chunk cache information in a tuple (size,nelems,preemption).
	2522	See netcdf C library documentation for <code>nc_get_chunk_cache</code> for
	2523	details. Values can be reset with <a href="#netCDF4.set_chunk_cache"><code>set_chunk_cache</code></a>.</p></div>
	2524	<div class="source_cont">
	2525	</div>
	2526
	2527	</div>
	2528
	2529
	2530	<div class="item">
2399	2531	<div class="name def" id="netCDF4.getlibversion">
2400	2532	<p>def <span class="ident">getlibversion</span>(</p><p>)</p>
2401	2533	</div>

2419	2551
2420	2552
2421	2553
2422		<div class="desc"><p>num2date(times,units,calendar='standard')</p>
	2554	<div class="desc"><p>num2date(times,units,calendar='standard',only_use_cftime_datetimes=True,only_use_python_datetimes=False)</p>
2423	2555	<p>Return datetime objects given numeric time values. The units
2424	2556	of the numeric time values are described by the <code>units</code> argument
2425	2557	and the <code>calendar</code> keyword. The returned datetime objects represent

2436	2568	Valid calendars <code>'standard', 'gregorian', 'proleptic_gregorian'
2437	2569	'noleap', '365_day', '360_day', 'julian', 'all_leap', '366_day'</code>.
2438	2570	Default is <code>'standard'</code>, which is a mixed Julian/Gregorian calendar.</p>
2439		<p><strong><code>only_use_cftime_datetimes</code></strong>: if False (default), datetime.datetime
	2571	<p><strong><code>only_use_cftime_datetimes</code></strong>: if False, python datetime.datetime
2440	2572	objects are returned from num2date where possible; if True dates which
2441		subclass cftime.datetime are returned for all calendars.</p>
	2573	subclass cftime.datetime are returned for all calendars. Default <code>True</code>.</p>
	2574	<p><strong><code>only_use_python_datetimes</code></strong>: always return python datetime.datetime
	2575	objects and raise an error if this is not possible. Ignored unless
	2576	<code>only_use_cftime_datetimes=False</code>. Default <code>False</code>.</p>
2442	2577	<p>returns a datetime instance, or an array of datetime instances with
2443	2578	approximately 100 microsecond accuracy.</p>
2444		<p><strong><em>Note</em></strong>: The datetime instances returned are 'real' python datetime
	2579	<p><strong><em>Note</em></strong>: If only_use_cftime_datetimes=False and
	2580	use_only_python_datetimes=False, the datetime instances
	2581	returned are 'real' python datetime
2445	2582	objects if <code>calendar='proleptic_gregorian'</code>, or
2446	2583	<code>calendar='standard'</code> or <code>'gregorian'</code>
2447	2584	and the date is after the breakpoint between the Julian and
2448		Gregorian calendars (1582-10-15). Otherwise, they are 'phony' datetime
2449		objects which support some but not all the methods of 'real' python
	2585	Gregorian calendars (1582-10-15). Otherwise, they are ctime.datetime
	2586	objects which support some but not all the methods of native python
2450	2587	datetime objects. The datetime instances
2451	2588	do not contain a time-zone offset, even if the specified <code>units</code>
2452	2589	contains one.</p></div>
	2590	<div class="source_cont">
	2591	</div>
	2592
	2593	</div>
	2594
	2595
	2596	<div class="item">
	2597	<div class="name def" id="netCDF4.set_chunk_cache">
	2598	<p>def <span class="ident">set_chunk_cache</span>(</p><p>self,size=None,nelems=None,preemption=None)</p>
	2599	</div>
	2600
	2601
	2602
	2603
	2604	<div class="desc"><p>change netCDF4 chunk cache settings.
	2605	See netcdf C library documentation for <code>nc_set_chunk_cache</code> for
	2606	details.</p></div>
2453	2607	<div class="source_cont">
2454	2608	</div>
2455	2609

2757	2911
2758	2912	<div class="desc"><p>If <code>True</code>, child Dimension and Variables objects only keep weak references to
2759	2913	the parent Dataset or Group.</p></div>
	2914	<div class="source_cont">
	2915	</div>
	2916
	2917	</div>
	2918	<div class="item">
	2919	<p id="netCDF4.Dataset.name" class="name">var <span class="ident">name</span></p>
	2920
	2921
	2922
	2923
2760	2924	<div class="source_cont">
2761	2925	</div>
2762	2926

2877	3041	reducing memory usage and open file handles. However, in many cases this is not
2878	3042	desirable, since the associated Variable instances may still be needed, but are
2879	3043	rendered unusable when the parent Dataset instance is garbage collected.</p>
2880		<p><strong><code>_ncstring_attrs__</code></strong>: if <code>_ncstring_attrs__=True</code>, all string attributes will use
2881		the variable length NC_STRING attributes (default <code>False</code>, ascii text
2882		attributes written as NC_CHAR).</p>
2883	3044	<p><strong><code>memory</code></strong>: if not <code>None</code>, create or open an in-memory Dataset.
2884	3045	If mode = 'r', the memory kwarg must contain a memory buffer object
2885	3046	(an object that supports the python buffer interface).

3027	3188
3028	3189	<div class="item">
3029	3190	<div class="name def" id="netCDF4.Dataset.createVariable">
3030		<p>def <span class="ident">createVariable</span>(</p><p>self, varname, datatype, dimensions=(), zlib=False, complevel=4, shuffle=True, fletcher32=False, contiguous=False, chunksizes=None, endian='native', least_significant_digit=None, fill_value=None)</p>
	3191	<p>def <span class="ident">createVariable</span>(</p><p>self, varname, datatype, dimensions=(), zlib=False, complevel=4, shuffle=True, fletcher32=False, contiguous=False, chunksizes=None, endian='native', least_significant_digit=None, fill_value=None, chunk_cache=None)</p>
3031	3192	</div>
3032	3193
3033	3194

3184	3345	<div class="desc"><p>Returns a list of variables that match specific conditions.</p>
3185	3346	<p>Can pass in key=value parameters and variables are returned that
3186	3347	contain all of the matches. For example,</p>
3187		<pre><code>:::python
3188		>>> # Get variables with x-axis attribute.
3189		>>> vs = nc.get_variables_by_attributes(axis='X')
3190		>>> # Get variables with matching "standard_name" attribute
3191		>>> vs = nc.get_variables_by_attributes(standard_name='northward_sea_water_velocity')
3192		</code></pre>
	3348	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="c1"># Get variables with x-axis attribute.</span>
	3349	<span class="o">>>></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="s1">'X'</span><span class="p">)</span>
	3350	<span class="o">>>></span> <span class="c1"># Get variables with matching "standard_name" attribute</span>
	3351	<span class="o">>>></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="s1">'northward_sea_water_velocity'</span><span class="p">)</span>
	3352	</code></pre></div>
	3353
	3354
3193	3355	<p>Can pass in key=callable parameter and variables are returned if the
3194	3356	callable returns True. The callable should accept a single parameter,
3195	3357	the attribute value. None is given as the attribute value when the
3196	3358	attribute does not exist on the variable. For example,</p>
3197		<pre><code>:::python
3198		>>> # Get Axis variables
3199		>>> vs = nc.get_variables_by_attributes(axis=lambda v: v in ['X', 'Y', 'Z', 'T'])
3200		>>> # Get variables that don't have an "axis" attribute
3201		>>> vs = nc.get_variables_by_attributes(axis=lambda v: v is None)
3202		>>> # Get variables that have a "grid_mapping" attribute
3203		>>> vs = nc.get_variables_by_attributes(grid_mapping=lambda v: v is not None)
3204		</code></pre></div>
	3359	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="c1"># Get Axis variables</span>
	3360	<span class="o">>>></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="s1">'X'</span><span class="p">,</span> <span class="s1">'Y'</span><span class="p">,</span> <span class="s1">'Z'</span><span class="p">,</span> <span class="s1">'T'</span><span class="p">])</span>
	3361	<span class="o">>>></span> <span class="c1"># Get variables that don't have an "axis" attribute</span>
	3362	<span class="o">>>></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="kc">None</span><span class="p">)</span>
	3363	<span class="o">>>></span> <span class="c1"># Get variables that have a "grid_mapping" attribute</span>
	3364	<span class="o">>>></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="kc">None</span><span class="p">)</span>
	3365	</code></pre></div></div>
3205	3366	<div class="source_cont">
3206	3367	</div>
3207	3368

4047	4208
4048	4209	<div class="item">
4049	4210	<div class="name def" id="netCDF4.Group.createVariable">
4050		<p>def <span class="ident">createVariable</span>(</p><p>self, varname, datatype, dimensions=(), zlib=False, complevel=4, shuffle=True, fletcher32=False, contiguous=False, chunksizes=None, endian='native', least_significant_digit=None, fill_value=None)</p>
	4211	<p>def <span class="ident">createVariable</span>(</p><p>self, varname, datatype, dimensions=(), zlib=False, complevel=4, shuffle=True, fletcher32=False, contiguous=False, chunksizes=None, endian='native', least_significant_digit=None, fill_value=None, chunk_cache=None)</p>
4051	4212	</div>
4052	4213
4053	4214

4204	4365	<div class="desc"><p>Returns a list of variables that match specific conditions.</p>
4205	4366	<p>Can pass in key=value parameters and variables are returned that
4206	4367	contain all of the matches. For example,</p>
4207		<pre><code>:::python
4208		>>> # Get variables with x-axis attribute.
4209		>>> vs = nc.get_variables_by_attributes(axis='X')
4210		>>> # Get variables with matching "standard_name" attribute
4211		>>> vs = nc.get_variables_by_attributes(standard_name='northward_sea_water_velocity')
4212		</code></pre>
	4368	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="c1"># Get variables with x-axis attribute.</span>
	4369	<span class="o">>>></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="s1">'X'</span><span class="p">)</span>
	4370	<span class="o">>>></span> <span class="c1"># Get variables with matching "standard_name" attribute</span>
	4371	<span class="o">>>></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="s1">'northward_sea_water_velocity'</span><span class="p">)</span>
	4372	</code></pre></div>
	4373
	4374
4213	4375	<p>Can pass in key=callable parameter and variables are returned if the
4214	4376	callable returns True. The callable should accept a single parameter,
4215	4377	the attribute value. None is given as the attribute value when the
4216	4378	attribute does not exist on the variable. For example,</p>
4217		<pre><code>:::python
4218		>>> # Get Axis variables
4219		>>> vs = nc.get_variables_by_attributes(axis=lambda v: v in ['X', 'Y', 'Z', 'T'])
4220		>>> # Get variables that don't have an "axis" attribute
4221		>>> vs = nc.get_variables_by_attributes(axis=lambda v: v is None)
4222		>>> # Get variables that have a "grid_mapping" attribute
4223		>>> vs = nc.get_variables_by_attributes(grid_mapping=lambda v: v is not None)
4224		</code></pre></div>
	4379	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="c1"># Get Axis variables</span>
	4380	<span class="o">>>></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="s1">'X'</span><span class="p">,</span> <span class="s1">'Y'</span><span class="p">,</span> <span class="s1">'Z'</span><span class="p">,</span> <span class="s1">'T'</span><span class="p">])</span>
	4381	<span class="o">>>></span> <span class="c1"># Get variables that don't have an "axis" attribute</span>
	4382	<span class="o">>>></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="kc">None</span><span class="p">)</span>
	4383	<span class="o">>>></span> <span class="c1"># Get variables that have a "grid_mapping" attribute</span>
	4384	<span class="o">>>></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="kc">None</span><span class="p">)</span>
	4385	</code></pre></div></div>
4225	4386	<div class="source_cont">
4226	4387	</div>
4227	4388

4585	4746	or NETCDF3_64BIT_DATA</code> format (<code>NETCDF4</code> Datasets won't work).</p>
4586	4747	<p>Adapted from <a href="http://pysclint.sourceforge.net/pycdf">pycdf</a> by Andre Gosselin.</p>
4587	4748	<p>Example usage (See <a href="#netCDF4.MFDataset.__init__"><code>__init__</code></a> for more details):</p>
4588		<pre><code>:::python
4589		>>> import numpy as np
4590		>>> # create a series of netCDF files with a variable sharing
4591		>>> # the same unlimited dimension.
4592		>>> for nf in range(10):
4593		... with Dataset("mftest%s.nc" % nf, "w", format='NETCDF4_CLASSIC') as f:
4594		... f.createDimension("x",None)
4595		... x = f.createVariable("x","i",("x",))
4596		... x[0:10] = np.arange(nf10,10(nf+1))
4597		>>> # now read all those files in at once, in one Dataset.
4598		>>> f = MFDataset("mftest*nc")
4599		>>> print(f.variables["x"][:])
4600		[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
4601		24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
4602		48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
4603		72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
4604		96 97 98 99]
4605		</code></pre></div>
	4749	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="kn">import</span> <span class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>
	4750	<span class="o">>>></span> <span class="c1"># create a series of netCDF files with a variable sharing</span>
	4751	<span class="o">>>></span> <span class="c1"># the same unlimited dimension.</span>
	4752	<span class="o">>>></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>
	4753	<span class="o">...</span> <span class="k">with</span> <span class="n">Dataset</span><span class="p">(</span><span class="s2">"mftest</span><span class="si">%s</span><span class="s2">.nc"</span> <span class="o">%</span> <span class="n">nf</span><span class="p">,</span> <span class="s2">"w"</span><span class="p">,</span> <span class="nb">format</span><span class="o">=</span><span class="s1">'NETCDF4_CLASSIC'</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
	4754	<span class="o">...</span> <span class="n">f</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s2">"x"</span><span class="p">,</span><span class="kc">None</span><span class="p">)</span>
	4755	<span class="o">...</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="s2">"x"</span><span class="p">,</span><span class="s2">"i"</span><span class="p">,(</span><span class="s2">"x"</span><span class="p">,))</span>
	4756	<span class="o">...</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">np</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>
	4757	<span class="o">>>></span> <span class="c1"># now read all those files in at once, in one Dataset.</span>
	4758	<span class="o">>>></span> <span class="n">f</span> <span class="o">=</span> <span class="n">MFDataset</span><span class="p">(</span><span class="s2">"mftest*nc"</span><span class="p">)</span>
	4759	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">f</span><span class="o">.</span><span class="n">variables</span><span class="p">[</span><span class="s2">"x"</span><span class="p">][:])</span>
	4760	<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>
	4761	<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>
	4762	<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>
	4763	<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>
	4764	<span class="mi">96</span> <span class="mi">97</span> <span class="mi">98</span> <span class="mi">99</span><span class="p">]</span>
	4765	</code></pre></div></div>
4606	4766	<div class="source_cont">
4607	4767	</div>
4608	4768

4687	4847	</div>
4688	4848	<div class="item">
4689	4849	<p id="netCDF4.MFDataset.keepweakref" class="name">var <span class="ident">keepweakref</span></p>
	4850
	4851
	4852
	4853
	4854	<div class="source_cont">
	4855	</div>
	4856
	4857	</div>
	4858	<div class="item">
	4859	<p id="netCDF4.MFDataset.name" class="name">var <span class="ident">name</span></p>
4690	4860
4691	4861
4692	4862

4903	5073
4904	5074	<div class="item">
4905	5075	<div class="name def" id="netCDF4.MFDataset.createVariable">
4906		<p>def <span class="ident">createVariable</span>(</p><p>self, varname, datatype, dimensions=(), zlib=False, complevel=4, shuffle=True, fletcher32=False, contiguous=False, chunksizes=None, endian='native', least_significant_digit=None, fill_value=None)</p>
	5076	<p>def <span class="ident">createVariable</span>(</p><p>self, varname, datatype, dimensions=(), zlib=False, complevel=4, shuffle=True, fletcher32=False, contiguous=False, chunksizes=None, endian='native', least_significant_digit=None, fill_value=None, chunk_cache=None)</p>
4907	5077	</div>
4908	5078
4909	5079

5060	5230	<div class="desc"><p>Returns a list of variables that match specific conditions.</p>
5061	5231	<p>Can pass in key=value parameters and variables are returned that
5062	5232	contain all of the matches. For example,</p>
5063		<pre><code>:::python
5064		>>> # Get variables with x-axis attribute.
5065		>>> vs = nc.get_variables_by_attributes(axis='X')
5066		>>> # Get variables with matching "standard_name" attribute
5067		>>> vs = nc.get_variables_by_attributes(standard_name='northward_sea_water_velocity')
5068		</code></pre>
	5233	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="c1"># Get variables with x-axis attribute.</span>
	5234	<span class="o">>>></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="s1">'X'</span><span class="p">)</span>
	5235	<span class="o">>>></span> <span class="c1"># Get variables with matching "standard_name" attribute</span>
	5236	<span class="o">>>></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="s1">'northward_sea_water_velocity'</span><span class="p">)</span>
	5237	</code></pre></div>
	5238
	5239
5069	5240	<p>Can pass in key=callable parameter and variables are returned if the
5070	5241	callable returns True. The callable should accept a single parameter,
5071	5242	the attribute value. None is given as the attribute value when the
5072	5243	attribute does not exist on the variable. For example,</p>
5073		<pre><code>:::python
5074		>>> # Get Axis variables
5075		>>> vs = nc.get_variables_by_attributes(axis=lambda v: v in ['X', 'Y', 'Z', 'T'])
5076		>>> # Get variables that don't have an "axis" attribute
5077		>>> vs = nc.get_variables_by_attributes(axis=lambda v: v is None)
5078		>>> # Get variables that have a "grid_mapping" attribute
5079		>>> vs = nc.get_variables_by_attributes(grid_mapping=lambda v: v is not None)
5080		</code></pre></div>
	5244	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="c1"># Get Axis variables</span>
	5245	<span class="o">>>></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="s1">'X'</span><span class="p">,</span> <span class="s1">'Y'</span><span class="p">,</span> <span class="s1">'Z'</span><span class="p">,</span> <span class="s1">'T'</span><span class="p">])</span>
	5246	<span class="o">>>></span> <span class="c1"># Get variables that don't have an "axis" attribute</span>
	5247	<span class="o">>>></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="kc">None</span><span class="p">)</span>
	5248	<span class="o">>>></span> <span class="c1"># Get variables that have a "grid_mapping" attribute</span>
	5249	<span class="o">>>></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="kc">None</span><span class="p">)</span>
	5250	</code></pre></div></div>
5081	5251	<div class="source_cont">
5082	5252	</div>
5083	5253

5439	5609	<div class="desc"><p>Class providing an interface to a MFDataset time Variable by imposing a unique common
5440	5610	time unit and/or calendar to all files.</p>
5441	5611	<p>Example usage (See <a href="#netCDF4.MFTime.__init__"><code>__init__</code></a> for more details):</p>
5442		<pre><code>:::python
5443		>>> import numpy
5444		>>> f1 = Dataset("mftest_1.nc","w", format="NETCDF4_CLASSIC")
5445		>>> f2 = Dataset("mftest_2.nc","w", format="NETCDF4_CLASSIC")
5446		>>> f1.createDimension("time",None)
5447		>>> f2.createDimension("time",None)
5448		>>> t1 = f1.createVariable("time","i",("time",))
5449		>>> t2 = f2.createVariable("time","i",("time",))
5450		>>> t1.units = "days since 2000-01-01"
5451		>>> t2.units = "days since 2000-02-01"
5452		>>> t1.calendar = "standard"
5453		>>> t2.calendar = "standard"
5454		>>> t1[:] = numpy.arange(31)
5455		>>> t2[:] = numpy.arange(30)
5456		>>> f1.close()
5457		>>> f2.close()
5458		>>> # Read the two files in at once, in one Dataset.
5459		>>> f = MFDataset("mftest_*nc")
5460		>>> t = f.variables["time"]
5461		>>> print(t.units)
5462		days since 2000-01-01
5463		>>> print(t[32]) # The value written in the file, inconsistent with the MF time units.
5464		1
5465		>>> T = MFTime(t)
5466		>>> print(T[32])
5467		32
5468		</code></pre></div>
	5612	<div class="codehilite"><pre><span></span><code><span class="o">>>></span> <span class="kn">import</span> <span class="nn">numpy</span>
	5613	<span class="o">>>></span> <span class="n">f1</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s2">"mftest_1.nc"</span><span class="p">,</span><span class="s2">"w"</span><span class="p">,</span> <span class="nb">format</span><span class="o">=</span><span class="s2">"NETCDF4_CLASSIC"</span><span class="p">)</span>
	5614	<span class="o">>>></span> <span class="n">f2</span> <span class="o">=</span> <span class="n">Dataset</span><span class="p">(</span><span class="s2">"mftest_2.nc"</span><span class="p">,</span><span class="s2">"w"</span><span class="p">,</span> <span class="nb">format</span><span class="o">=</span><span class="s2">"NETCDF4_CLASSIC"</span><span class="p">)</span>
	5615	<span class="o">>>></span> <span class="n">f1</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s2">"time"</span><span class="p">,</span><span class="kc">None</span><span class="p">)</span>
	5616	<span class="o">>>></span> <span class="n">f2</span><span class="o">.</span><span class="n">createDimension</span><span class="p">(</span><span class="s2">"time"</span><span class="p">,</span><span class="kc">None</span><span class="p">)</span>
	5617	<span class="o">>>></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="s2">"time"</span><span class="p">,</span><span class="s2">"i"</span><span class="p">,(</span><span class="s2">"time"</span><span class="p">,))</span>
	5618	<span class="o">>>></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="s2">"time"</span><span class="p">,</span><span class="s2">"i"</span><span class="p">,(</span><span class="s2">"time"</span><span class="p">,))</span>
	5619	<span class="o">>>></span> <span class="n">t1</span><span class="o">.</span><span class="n">units</span> <span class="o">=</span> <span class="s2">"days since 2000-01-01"</span>
	5620	<span class="o">>>></span> <span class="n">t2</span><span class="o">.</span><span class="n">units</span> <span class="o">=</span> <span class="s2">"days since 2000-02-01"</span>
	5621	<span class="o">>>></span> <span class="n">t1</span><span class="o">.</span><span class="n">calendar</span> <span class="o">=</span> <span class="s2">"standard"</span>
	5622	<span class="o">>>></span> <span class="n">t2</span><span class="o">.</span><span class="n">calendar</span> <span class="o">=</span> <span class="s2">"standard"</span>
	5623	<span class="o">>>></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>
	5624	<span class="o">>>></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>
	5625	<span class="o">>>></span> <span class="n">f1</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
	5626	<span class="o">>>></span> <span class="n">f2</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
	5627	<span class="o">>>></span> <span class="c1"># Read the two files in at once, in one Dataset.</span>
	5628	<span class="o">>>></span> <span class="n">f</span> <span class="o">=</span> <span class="n">MFDataset</span><span class="p">(</span><span class="s2">"mftest_*nc"</span><span class="p">)</span>
	5629	<span class="o">>>></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="s2">"time"</span><span class="p">]</span>
	5630	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">t</span><span class="o">.</span><span class="n">units</span><span class="p">)</span>
	5631	<span class="n">days</span> <span class="n">since</span> <span class="mi">2000</span><span class="o">-</span><span class="mi">01</span><span class="o">-</span><span class="mi">01</span>
	5632	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">t</span><span class="p">[</span><span class="mi">32</span><span class="p">])</span> <span class="c1"># The value written in the file, inconsistent with the MF time units.</span>
	5633	<span class="mi">1</span>
	5634	<span class="o">>>></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>
	5635	<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">T</span><span class="p">[</span><span class="mi">32</span><span class="p">])</span>
	5636	<span class="mi">32</span>
	5637	</code></pre></div></div>
5469	5638	<div class="source_cont">
5470	5639	</div>
5471	5640

5867	6036
5868	6037	<div class="item">
5869	6038	<div class="name def" id="netCDF4.Variable.__init__">
5870		<p>def <span class="ident">__init__</span>(</p><p>self, group, name, datatype, dimensions=(), zlib=False, complevel=4, shuffle=True, fletcher32=False, contiguous=False, chunksizes=None, endian='native', least_significant_digit=None,fill_value=None)</p>
	6039	<p>def <span class="ident">__init__</span>(</p><p>self, group, name, datatype, dimensions=(), zlib=False, complevel=4, shuffle=True, fletcher32=False, contiguous=False, chunksizes=None, endian='native', least_significant_digit=None,fill_value=None,chunk_cache=None)</p>
5871	6040	</div>
5872	6041
5873	6042

5938	6107	is replaced with this value. If fill_value is set to <code>False</code>, then
5939	6108	the variable is not pre-filled. The default netCDF fill values can be found
5940	6109	in <code>netCDF4.default_fillvals</code>.</p>
	6110	<p><strong><code>chunk_cache</code></strong>: If specified, sets the chunk cache size for this variable.
	6111	Persists as long as Dataset is open. Use <code>netCDF4.set_var_chunk_cache</code> to
	6112	change it when Dataset is re-opened. </p>
5941	6113	<p><strong><em>Note</em></strong>: <a href="#netCDF4.Variable"><code>Variable</code></a> instances should be created using the
5942	6114	<a href="#netCDF4.Dataset.createVariable"><code>createVariable</code></a> method of a <a href="#netCDF4.Dataset"><code>Dataset</code></a> or
5943	6115	<a href="#netCDF4.Group"><code>Group</code></a> instance, not using this class directly.</p></div>

6249	6421	<p>If <code>maskandscale</code> is set to <code>True</code>, and the variable has a
6250	6422	<code>scale_factor</code> or an <code>add_offset</code> attribute, then data read
6251	6423	from that variable is unpacked using::</p>
6252		<pre><code>data = self.scale_factor*data + self.add_offset
6253		</code></pre>
	6424	<div class="codehilite"><pre><span></span><code><span class="err">data = self.scale_factor*data + self.add_offset</span>
	6425	</code></pre></div>
	6426
	6427
6254	6428	<p>When data is written to a variable it is packed using::</p>
6255		<pre><code>data = (data - self.add_offset)/self.scale_factor
6256		</code></pre>
	6429	<div class="codehilite"><pre><span></span><code><span class="err">data = (data - self.add_offset)/self.scale_factor</span>
	6430	</code></pre></div>
	6431
	6432
6257	6433	<p>If either scale_factor is present, but add_offset is missing, add_offset
6258	6434	is assumed zero. If add_offset is present, but scale_factor is missing,
6259	6435	scale_factor is assumed to be one.

6290	6466	<p>If <code>scale</code> is set to <code>True</code>, and the variable has a
6291	6467	<code>scale_factor</code> or an <code>add_offset</code> attribute, then data read
6292	6468	from that variable is unpacked using::</p>
6293		<pre><code>data = self.scale_factor*data + self.add_offset
6294		</code></pre>
	6469	<div class="codehilite"><pre><span></span><code><span class="err">data = self.scale_factor*data + self.add_offset</span>
	6470	</code></pre></div>
	6471
	6472
6295	6473	<p>When data is written to a variable it is packed using::</p>
6296		<pre><code>data = (data - self.add_offset)/self.scale_factor
6297		</code></pre>
	6474	<div class="codehilite"><pre><span></span><code><span class="err">data = (data - self.add_offset)/self.scale_factor</span>
	6475	</code></pre></div>
	6476
	6477
6298	6478	<p>If either scale_factor is present, but add_offset is missing, add_offset
6299	6479	is assumed zero. If add_offset is present, but scale_factor is missing,
6300	6480	scale_factor is assumed to be one.

6448	6628	<footer id="footer">
6449	6629	<p>
6450	6630	Documentation generated by
6451		<a href="https://github.com/BurntSushi/pdoc">pdoc 0.3.2.dev29</a>
	6631	<a href="https://github.com/BurntSushi/pdoc">pdoc 0.3.2.dev30</a>
6452	6632	</p>
6453	6633
6454	6634	<p>pdoc is in the public domain with the

-1

netCDF4/__init__.py less more

8	8	__has_nc_create_mem__, __has_cdf5_format__,
9	9	__has_parallel4_support__, __has_pnetcdf_support__)
10	10	__all__ =\
11		['Dataset','Variable','Dimension','Group','MFDataset','MFTime','CompoundType','VLType','date2num','num2date','date2index','stringtochar','chartostring','stringtoarr','getlibversion','EnumType']
	11	['Dataset','Variable','Dimension','Group','MFDataset','MFTime','CompoundType','VLType','date2num','num2date','date2index','stringtochar','chartostring','stringtoarr','getlibversion','EnumType','get_chunk_cache','set_chunk_cache']

+140

-98

netCDF4/_netCDF4.pyx less more

0	0	"""
1		Version 1.5.3
	1	Version 1.5.4
2	2	---------------
3	3	- - -
4	4

35	35	Requires
36	36	========
37	37
38		- Python 2.7 or later (python 3 works too).
39	38	- [numpy array module](http://numpy.scipy.org), version 1.10.0 or later.
40	39	- [Cython](http://cython.org), version 0.21 or later.
41	40	- [setuptools](https://pypi.python.org/pypi/setuptools), version 18.0 or

1205	1204	# python3: zip is already python2's itertools.izip
1206	1205	pass
1207	1206
1208		__version__ = "1.5.3"
	1207	__version__ = "1.5.4"
1209	1208
1210	1209	# Initialize numpy
1211	1210	import posixpath

1250	1249	used to build the module, and when it was built.
1251	1250	"""
1252	1251	return (<char *>nc_inq_libvers()).decode('ascii')
	1252
	1253	def get_chunk_cache():
	1254	"""
	1255	`get_chunk_cache()`
	1256
	1257	return current netCDF chunk cache information in a tuple (size,nelems,preemption).
	1258	See netcdf C library documentation for `nc_get_chunk_cache` for
	1259	details. Values can be reset with `netCDF4.set_chunk_cache`."""
	1260	cdef int ierr
	1261	cdef size_t sizep, nelemsp
	1262	cdef float preemptionp
	1263	ierr = nc_get_chunk_cache(&sizep, &nelemsp, &preemptionp)
	1264	_ensure_nc_success(ierr)
	1265	size = sizep; nelems = nelemsp; preemption = preemptionp
	1266	return (size,nelems,preemption)
	1267
	1268	def set_chunk_cache(size=None,nelems=None,preemption=None):
	1269	"""
	1270	`set_chunk_cache(self,size=None,nelems=None,preemption=None)`
	1271
	1272	change netCDF4 chunk cache settings.
	1273	See netcdf C library documentation for `nc_set_chunk_cache` for
	1274	details."""
	1275	cdef int ierr
	1276	cdef size_t sizep, nelemsp
	1277	cdef float preemptionp
	1278	# reset chunk cache size, leave other parameters unchanged.
	1279	size_orig, nelems_orig, preemption_orig = get_chunk_cache()
	1280	if size is not None:
	1281	sizep = size
	1282	else:
	1283	sizep = size_orig
	1284	if nelems is not None:
	1285	nelemsp = nelems
	1286	else:
	1287	nelemsp = nelems_orig
	1288	if preemption is not None:
	1289	preemptionp = preemption
	1290	else:
	1291	preemptionp = preemption_orig
	1292	ierr = nc_set_chunk_cache(sizep,nelemsp, preemptionp)
	1293	_ensure_nc_success(ierr)
1253	1294
1254	1295	__netcdf4libversion__ = getlibversion().split()[0]
1255	1296	__hdf5libversion__ = _gethdf5libversion()

1413	1454	if name == '_FillValue' and python3:
1414	1455	# make sure _FillValue for character arrays is a byte on python 3
1415	1456	# (issue 271).
1416		pstring = value_arr.tostring()
	1457	pstring = value_arr.tobytes()
1417	1458	else:
1418	1459	pstring =\
1419		value_arr.tostring().decode(encoding,errors='replace').replace('\x00','')
	1460	value_arr.tobytes().decode(encoding,errors='replace').replace('\x00','')
1420	1461	return pstring
1421	1462	elif att_type == NC_STRING:
1422	1463	values = <char*>PyMem_Malloc(sizeof(char) * att_len)

2094	2135	desirable, since the associated Variable instances may still be needed, but are
2095	2136	rendered unusable when the parent Dataset instance is garbage collected.
2096	2137
2097		`_ncstring_attrs__`: if `_ncstring_attrs__=True`, all string attributes will use
2098		the variable length NC_STRING attributes (default `False`, ascii text
2099		attributes written as NC_CHAR).
2100
2101	2138	`memory`: if not `None`, create or open an in-memory Dataset.
2102	2139	If mode = 'r', the memory kwarg must contain a memory buffer object
2103	2140	(an object that supports the python buffer interface).

2421	2458	ncdump = [repr(type(self))]
2422	2459	dimnames = tuple(_tostr(dimname)+'(%s)'%len(self.dimensions[dimname])\
2423	2460	for dimname in self.dimensions.keys())
2424		varnames = tuple(\
2425		[_tostr(self.variables[varname].dtype)+' '+_tostr(varname)+
2426		(((_tostr(self.variables[varname].dimensions)
2427		.replace("u'",""))\
2428		.replace("'",""))\
2429		.replace(", ",","))\
2430		.replace(",)",")") for varname in self.variables.keys()])
	2461	if python3:
	2462	varnames = tuple(\
	2463	[_tostr(self.variables[varname].dtype)+' '+_tostr(varname)+
	2464	((_tostr(self.variables[varname].dimensions)).replace(",)",")")).replace("'","")
	2465	for varname in self.variables.keys()])
	2466	else: # don't try to remove quotes in python2
	2467	varnames = tuple(\
	2468	[_tostr(self.variables[varname].dtype)+' '+_tostr(varname)+
	2469	(_tostr(self.variables[varname].dimensions)).replace(",)",")")
	2470	for varname in self.variables.keys()])
2431	2471	grpnames = tuple(_tostr(grpname) for grpname in self.groups.keys())
2432	2472	if self.path == '/':
2433	2473	ncdump.append('root group (%s data model, file format %s):' %

2636	2676	"""
2637	2677	**`createVariable(self, varname, datatype, dimensions=(), zlib=False,
2638	2678	complevel=4, shuffle=True, fletcher32=False, contiguous=False, chunksizes=None,
2639		endian='native', least_significant_digit=None, fill_value=None)`**
	2679	endian='native', least_significant_digit=None, fill_value=None, chunk_cache=None)`**
2640	2680
2641	2681	Creates a new variable with the given `varname`, `datatype`, and
2642	2682	`dimensions`. If dimensions are not given, the variable is assumed to be

3197	3237	vs.append(_vars[vname])
3198	3238
3199	3239	return vs
	3240
	3241	def _getname(self):
	3242	# private method to get name associated with instance.
	3243	cdef int ierr
	3244	cdef char namstring[NC_MAX_NAME+1]
	3245	with nogil:
	3246	ierr = nc_inq_grpname(self._grpid, namstring)
	3247	_ensure_nc_success(ierr)
	3248	return namstring.decode('utf-8')
	3249
	3250	property name:
	3251	"""string name of Group instance"""
	3252	def __get__(self):
	3253	return self._getname()
	3254	def __set__(self,value):
	3255	raise AttributeError("name cannot be altered")
3200	3256
3201	3257
3202	3258	cdef class Group(Dataset):

3283	3339	overrides `netCDF4.Dataset` close method which does not apply to `netCDF4.Group`
3284	3340	instances, raises IOError."""
3285	3341	raise IOError('cannot close a `netCDF4.Group` (only applies to Dataset)')
3286
3287		def _getname(self):
3288		# private method to get name associated with instance.
3289		cdef int ierr
3290		cdef char namstring[NC_MAX_NAME+1]
3291		with nogil:
3292		ierr = nc_inq_grpname(self._grpid, namstring)
3293		_ensure_nc_success(ierr)
3294		return namstring.decode('utf-8')
3295
3296		property name:
3297		"""string name of Group instance"""
3298		def __get__(self):
3299		return self._getname()
3300		def __set__(self,value):
3301		raise AttributeError("name cannot be altered")
3302	3342
3303	3343
3304	3344	cdef class Dimension:

3578	3618	**`__init__(self, group, name, datatype, dimensions=(), zlib=False,
3579	3619	complevel=4, shuffle=True, fletcher32=False, contiguous=False,
3580	3620	chunksizes=None, endian='native',
3581		least_significant_digit=None,fill_value=None)`**
	3621	least_significant_digit=None,fill_value=None,chunk_cache=None)`**
3582	3622
3583	3623	`netCDF4.Variable` constructor.
3584	3624

3659	3699	is replaced with this value. If fill_value is set to `False`, then
3660	3700	the variable is not pre-filled. The default netCDF fill values can be found
3661	3701	in `netCDF4.default_fillvals`.
	3702
	3703	`chunk_cache`: If specified, sets the chunk cache size for this variable.
	3704	Persists as long as Dataset is open. Use `netCDF4.set_var_chunk_cache` to
	3705	change it when Dataset is re-opened.
3662	3706
3663	3707	*Note*: `netCDF4.Variable` instances should be created using the
3664	3708	`netCDF4.Dataset.createVariable` method of a `netCDF4.Dataset` or

4430	4474	# set_auto_mask or set_auto_maskandscale), perform
4431	4475	# automatic conversion to masked array using
4432	4476	# missing_value/_Fill_Value.
4433		# ignore for compound, vlen or enum datatypes.
	4477	# applied for primitive and (non-string) vlen,
	4478	# ignored for compound and enum datatypes.
4434	4479	try: # check to see if scale_factor and add_offset is valid (issue 176).
4435	4480	if hasattr(self,'scale_factor'): float(self.scale_factor)
4436	4481	if hasattr(self,'add_offset'): float(self.add_offset)

4441	4486	msg = 'invalid scale_factor or add_offset attribute, no unpacking done...'
4442	4487	warnings.warn(msg)
4443	4488
4444		if self.mask and (self._isprimitive or self._isenum):
	4489	if self.mask and\
	4490	(self._isprimitive or self._isenum or\
	4491	(self._isvlen and self.dtype != str)):
4445	4492	data = self._toma(data)
4446	4493	else:
4447	4494	# if attribute _Unsigned is True, and variable has signed integer

4451	4498	if is_unsigned and data.dtype.kind == 'i':
4452	4499	data=data.view('%su%s'%(data.dtype.byteorder,data.dtype.itemsize))
4453	4500
4454		if self.scale and self._isprimitive and valid_scaleoffset:
	4501	if self.scale and\
	4502	(self._isprimitive or (self._isvlen and self.dtype != str)) and\
	4503	valid_scaleoffset:
4455	4504	# if variable has scale_factor and add_offset attributes, apply
4456	4505	# them.
4457	4506	if hasattr(self, 'scale_factor') and hasattr(self, 'add_offset'):

4601	4650	safe_validrange = self._check_safecast('valid_range')
4602	4651	safe_validmin = self._check_safecast('valid_min')
4603	4652	safe_validmax = self._check_safecast('valid_max')
4604		if safe_validrange and len(self.valid_range) == 2:
	4653	if safe_validrange and self.valid_range.size == 2:
4605	4654	validmin = numpy.array(self.valid_range[0], self.dtype)
4606	4655	validmax = numpy.array(self.valid_range[1], self.dtype)
4607	4656	else:

4665	4714	# and there are no missing values
4666	4715	data = numpy.array(data, copy=False)
4667	4716
	4717	return data
	4718
	4719	def _pack(self,data):
	4720	# pack non-masked values using scale_factor and add_offset
	4721	if hasattr(self, 'scale_factor') and hasattr(self, 'add_offset'):
	4722	data = (data - self.add_offset)/self.scale_factor
	4723	if self.dtype.kind in 'iu': data = numpy.around(data)
	4724	elif hasattr(self, 'scale_factor'):
	4725	data = data/self.scale_factor
	4726	if self.dtype.kind in 'iu': data = numpy.around(data)
	4727	elif hasattr(self, 'add_offset'):
	4728	data = data - self.add_offset
	4729	if self.dtype.kind in 'iu': data = numpy.around(data)
	4730	if ma.isMA(data):
	4731	# if underlying data in masked regions of masked array
	4732	# corresponds to missing values, don't fill masked array -
	4733	# just use underlying data instead
	4734	if hasattr(self, 'missing_value') and \
	4735	numpy.all(numpy.in1d(data.data[data.mask],self.missing_value)):
	4736	data = data.data
	4737	else:
	4738	if hasattr(self, 'missing_value'):
	4739	# if missing value is a scalar, use it as fill_value.
	4740	# if missing value is a vector, raise an exception
	4741	# since we then don't know how to fill in masked values.
	4742	if numpy.array(self.missing_value).shape == ():
	4743	fillval = self.missing_value
	4744	else:
	4745	msg="cannot assign fill_value for masked array when missing_value attribute is not a scalar"
	4746	raise RuntimeError(msg)
	4747	if numpy.array(fillval).shape != ():
	4748	fillval = fillval[0]
	4749	elif hasattr(self, '_FillValue'):
	4750	fillval = self._FillValue
	4751	else:
	4752	fillval = default_fillvals[self.dtype.str[1:]]
	4753	# some versions of numpy have trouble handling
	4754	# MaskedConstants when filling - this is is
	4755	# a workaround (issue #850)
	4756	if data.shape == (1,) and data.mask.all():
	4757	data = numpy.array([fillval],self.dtype)
	4758	else:
	4759	data = data.filled(fill_value=fillval)
	4760	if self.dtype != data.dtype:
	4761	data = data.astype(self.dtype) # cast data to var type, if necessary.
4668	4762	return data
4669	4763
4670	4764	def _assign_vlen(self, elem, data):

4821	4915	# issue 458, allow Ellipsis to be used for scalar var
4822	4916	if type(elem) == type(Ellipsis) and not\
4823	4917	len(self.dimensions): elem = 0
	4918	# pack as integers if desired.
	4919	if self.scale:
	4920	data = self._pack(data)
4824	4921	self._assign_vlen(elem, data)
4825	4922	return
4826	4923

4876	4973	# exists (improves compression).
4877	4974	if self._has_lsd:
4878	4975	data = _quantize(data,self.least_significant_digit)
4879		# if auto_scale mode set to True, (through
4880		# a call to set_auto_scale or set_auto_maskandscale),
4881		# perform automatic unpacking using scale_factor/add_offset.
4882		# if auto_mask mode is set to True (through a call to
4883		# set_auto_mask or set_auto_maskandscale), perform
4884		# automatic conversion to masked array using
4885		# valid_min,validmax,missing_value,_Fill_Value.
4886		# ignore if not a primitive or enum data type (not compound or vlen).
4887
4888		# remove this since it causes suprising behaviour (issue #777)
4889		# (missing_value should apply to scaled data, not unscaled data)
4890		#if self.mask and (self._isprimitive or self._isenum):
4891		# # use missing_value as fill value.
4892		# # if no missing value set, use _FillValue.
4893		# if hasattr(self, 'scale_factor') or hasattr(self, 'add_offset'):
4894		# # if not masked, create a masked array.
4895		# if not ma.isMA(data): data = self._toma(data)
4896	4976
4897	4977	if self.scale and self._isprimitive:
4898	4978	# pack non-masked values using scale_factor and add_offset
4899		if hasattr(self, 'scale_factor') and hasattr(self, 'add_offset'):
4900		data = (data - self.add_offset)/self.scale_factor
4901		if self.dtype.kind in 'iu': data = numpy.around(data)
4902		elif hasattr(self, 'scale_factor'):
4903		data = data/self.scale_factor
4904		if self.dtype.kind in 'iu': data = numpy.around(data)
4905		elif hasattr(self, 'add_offset'):
4906		data = data - self.add_offset
4907		if self.dtype.kind in 'iu': data = numpy.around(data)
4908		if ma.isMA(data):
4909		# if underlying data in masked regions of masked array
4910		# corresponds to missing values, don't fill masked array -
4911		# just use underlying data instead
4912		if hasattr(self, 'missing_value') and \
4913		numpy.all(numpy.in1d(data.data[data.mask],self.missing_value)):
4914		data = data.data
4915		else:
4916		if hasattr(self, 'missing_value'):
4917		# if missing value is a scalar, use it as fill_value.
4918		# if missing value is a vector, raise an exception
4919		# since we then don't know how to fill in masked values.
4920		if numpy.array(self.missing_value).shape == ():
4921		fillval = self.missing_value
4922		else:
4923		msg="cannot assign fill_value for masked array when missing_value attribute is not a scalar"
4924		raise RuntimeError(msg)
4925		if numpy.array(fillval).shape != ():
4926		fillval = fillval[0]
4927		elif hasattr(self, '_FillValue'):
4928		fillval = self._FillValue
4929		else:
4930		fillval = default_fillvals[self.dtype.str[1:]]
4931		# some versions of numpy have trouble handling
4932		# MaskedConstants when filling - this is is
4933		# a workaround (issue #850)
4934		if data.shape == (1,) and data.mask.all():
4935		data = numpy.array([fillval],self.dtype)
4936		else:
4937		data = data.filled(fill_value=fillval)
	4979	data = self._pack(data)
4938	4980
4939	4981	# Fill output array with data chunks.
4940	4982	for (a,b,c,i) in zip(start, count, stride, put_ind):

6090	6132	if dtype not in ["S","U"]:
6091	6133	raise ValueError("type must string or unicode ('S' or 'U')")
6092	6134	if encoding in ['none','None','bytes']:
6093		b = numpy.array(tuple(a.tostring()),'S1')
	6135	b = numpy.array(tuple(a.tobytes()),'S1')
6094	6136	else:
6095		b = numpy.array(tuple(a.tostring().decode(encoding)),dtype+'1')
	6137	b = numpy.array(tuple(a.tobytes().decode(encoding)),dtype+'1')
6096	6138	b.shape = a.shape + (a.itemsize,)
6097	6139	return b
6098	6140

6116	6158	if dtype not in ["S","U"]:
6117	6159	raise ValueError("type must be string or unicode ('S' or 'U')")
6118	6160	if encoding in ['none','None','bytes']:
6119		bs = b.tostring()
	6161	bs = b.tobytes()
6120	6162	else:
6121		bs = b.tostring().decode(encoding)
	6163	bs = b.tobytes().decode(encoding)
6122	6164	slen = int(b.shape[-1])
6123	6165	if encoding in ['none','None','bytes']:
6124	6166	a = numpy.array([bs[n1:n1+slen] for n1 in range(0,len(bs),slen)],'S'+repr(slen))

-1

netCDF4/utils.py less more

350	350	# at this stage e is a slice, a scalar integer, or a 1d integer array.
351	351	# integer array: _get call for each True value
352	352	if np.iterable(e):
353		sdim.append(np.alen(e))
	353	sdim.append(len(e))
354	354	# Scalar int or slice, just a single _get call
355	355	else:
356	356	sdim.append(1)

-5

setup.py less more

3	3	from distutils.dist import Distribution
4	4
5	5	setuptools_extra_kwargs = {
6		"install_requires": ["numpy>=1.7","cftime"],
	6	"install_requires": ["numpy>=1.9","cftime"],
7	7	"setup_requires": ['setuptools>=18.0', "cython>=0.19"],
8	8	"entry_points": {
9	9	'console_scripts': [

595	595
596	596	setup(name="netCDF4",
597	597	cmdclass=cmdclass,
598		version="1.5.3",
	598	version="1.5.4",
599	599	long_description="netCDF version 4 has many features not found in earlier versions of the library, such as hierarchical groups, zlib compression, multiple unlimited dimensions, and new data types. It is implemented on top of HDF5. This module implements most of the new features, and can read and write netCDF files compatible with older versions of the library. The API is modelled after Scientific.IO.NetCDF, and should be familiar to users of that module.\n\nThis project is hosted on a `GitHub repository <https://github.com/Unidata/netcdf4-python>`_ where you may access the most up-to-date source.",
600	600	author="Jeff Whitaker",
601	601	author_email="jeffrey.s.whitaker@noaa.gov",

607	607	keywords=['numpy', 'netcdf', 'data', 'science', 'network', 'oceanography',
608	608	'meteorology', 'climate'],
609	609	classifiers=["Development Status :: 3 - Alpha",
610		"Programming Language :: Python :: 2",
611		"Programming Language :: Python :: 2.7",
612	610	"Programming Language :: Python :: 3",
613		"Programming Language :: Python :: 3.5",
614	611	"Programming Language :: Python :: 3.6",
615	612	"Programming Language :: Python :: 3.7",
	613	"Programming Language :: Python :: 3.8",
616	614	"Intended Audience :: Science/Research",
617	615	"License :: OSI Approved",
618	616	"Topic :: Software Development :: Libraries :: Python Modules",

+41

-0

test/tst_chunk_cache.py less more

	0	import unittest, netCDF4, tempfile, os
	1
	2	file_name = tempfile.NamedTemporaryFile(suffix='.nc', delete=False).name
	3	cache_size = 10000
	4	cache_nelems = 100
	5	cache_preempt = 0.5
	6	cache_size2 = 20000
	7	cache_nelems2 = 200
	8	cache_preempt2 = 1.0
	9
	10	class RefCountTestCase(unittest.TestCase):
	11
	12	def setUp(self):
	13	nc = netCDF4.Dataset(file_name, mode='w', format='NETCDF4')
	14	d = nc.createDimension('fred', 2000)
	15	# can only change cache size in createVariable (not nelems or preemption)
	16	# this change lasts only as long as file is open.
	17	v = nc.createVariable('frank','f',('fred',),chunk_cache=15000)
	18	size, nelems, preempt = v.get_var_chunk_cache()
	19	assert(size==15000)
	20	self.file=file_name
	21	nc.close()
	22
	23	def tearDown(self):
	24	# Remove the temporary files
	25	os.remove(self.file)
	26
	27	def runTest(self):
	28	"""testing methods for accessing and changing chunk cache"""
	29	# change cache parameters before opening fil.
	30	netCDF4.set_chunk_cache(cache_size, cache_nelems, cache_preempt)
	31	nc = netCDF4.Dataset(self.file, mode='r')
	32	# check to see that chunk cache parameters were changed.
	33	assert(netCDF4.get_chunk_cache() == (cache_size, cache_nelems, cache_preempt))
	34	# change cache parameters for variable, check
	35	nc['frank'].set_var_chunk_cache(cache_size2, cache_nelems2, cache_preempt2)
	36	assert(nc['frank'].get_var_chunk_cache() == (cache_size2, cache_nelems2, cache_preempt2))
	37	nc.close()
	38
	39	if __name__ == '__main__':
	40	unittest.main()

-0

test/tst_grps.py less more

65	65	def runTest(self):
66	66	"""testing groups"""
67	67	f = netCDF4.Dataset(self.file1, 'r')
	68	# issue 988
	69	f.name
68	70	tree = [f.path]
69	71	for children in walktree(f):
70	72	for child in children:

-0

test/tst_masked4.py less more

35	35	v.missing_value = np.array(32767, v.dtype)
36	36	v.valid_min = np.array(self.valid_min, v.dtype)
37	37	v.valid_max = np.array(self.valid_max, v.dtype)
	38	v.valid_range = np.array(0, v.dtype) # issue 1013, this is wrong but should not raise an exception
38	39
39	40	v[0] = self.valid_min-1
40	41	v[1] = self.v[1]

+40

-0

test/tst_vlen.py less more

189	189	v[0].size # BOOM!
190	190	f.close()
191	191
	192	class Vlen_ScaledInts(unittest.TestCase):
	193	def setUp(self):
	194	self.file = FILE_NAME
	195	nc = Dataset(self.file, 'w')
	196	vlen_type = nc.createVLType(np.uint8, 'vltest')
	197	nc.createDimension('x', None)
	198	v = nc.createVariable('vl', vlen_type, 'x')
	199	v.scale_factor = 1./254.
	200	v.missing_value=np.array(255,np.uint8)
	201	# random lengths between 1 and 1000
	202	ilen = np.random.randint(1,1000,size=100)
	203	n = 0
	204	for nlen in ilen:
	205	data = np.random.uniform(low=0.0, high=1.0, size=nlen)
	206	if n==99:
	207	# mark last value as missing
	208	mask = np.zeros(data.shape,dtype=bool)
	209	mask[-1] = True
	210	data = np.ma.masked_array(data, mask=mask)
	211	self.data = data
	212	v[n] = data
	213	n += 1
	214	nc.close()
	215	def tearDown(self):
	216	# Remove the temporary files
	217	os.remove(self.file)
	218	def runTest(self):
	219	"""testing packing float vlens as scaled integers (issue #1003)."""
	220	nc = Dataset(self.file)
	221	# see if data is masked
	222	data = nc['vl'][-1]
	223	assert(data[-1] is np.ma.masked)
	224	# check max error of compression
	225	err = np.abs(data - self.data)
	226	assert(err.max() < nc['vl'].scale_factor)
	227	# turn off auto-scaling
	228	nc.set_auto_maskandscale(False)
	229	data = nc['vl'][-1]
	230	assert(data[-1] == 255)
	231	nc.close()
192	232
193	233	if __name__ == '__main__':
194	234	unittest.main()