# Holomap ¶

- Title
- HoloMap Container
- Dependencies
- Plotly
- Backends
- Matplotlib
- Bokeh
- Plotly

```
import numpy as np
import holoviews as hv
hv.extension('matplotlib')
```

A HoloMap is an explorable multi-dimensional dictionary of HoloViews objects. A
```
HoloMap
```

cannot contain
```
Layouts
```

,
```
NdLayouts
```

,
```
GridSpaces
```

or other
```
HoloMaps
```

or
```
DyamicMap
```

but can contain any other HoloViews object. See the
Building Composite Objects
user guide for details on how to compose containers.

###
```
HoloMap
```

holds dictionaries
¶

As a
```
HoloMap
```

is a dictionary of elements, let us now create a dictionary of sine curves:

```
frequencies = [0.5, 0.75, 1.0, 1.25]
def sine_curve(phase, freq):
xvals = [0.1* i for i in range(100)]
return hv.Curve((xvals, [np.sin(phase+freq*x) for x in xvals]))
curve_dict = {f:sine_curve(0,f) for f in frequencies}
```

We now have a dictionary where the frequency is the key and the corresponding curve element is the value. We can now turn this dictionary into a
```
HoloMap
```

by declaring the keys as corresponding to the frequency key dimension:

```
hmap = hv.HoloMap(curve_dict, kdims='frequency')
hmap
```

###
```
HoloMap
```

is multi-dimensional
¶

By using tuple keys and making sure each position in the tuple is assigned a corresponding
```
kdim
```

,
```
HoloMaps
```

allow exploration of a multi-dimensional space:

```
phases = [0, np.pi/2, np.pi, 3*np.pi/2]
curve_dict_2D = {(p,f):sine_curve(p,f) for p in phases for f in frequencies}
hmap = hv.HoloMap(curve_dict_2D, kdims=['phase', 'frequency'])
hmap
```

###
```
HoloMap
```

supports dictionary-like behavior
¶

HoloMaps support a number of features similar to regular dictionaries, including
**
assignment
**
:

```
hmap = hv.HoloMap(kdims=['phase', 'frequency'])
for (phase, freq) in [(0,0.5), (0.5,0.5), (0.5,1), (0,1)]:
hmap[(phase, freq)] = sine_curve(phase,freq)
```

**
Key membership predicate
**
:

```
(0, 0.5) in hmap
```

**
The
get
method:
**
:

```
hmap.get((0,0.5))
```

###
```
HoloMap
```

supports multi-dimensional indexing and slicing
¶

One difference with regular dictionaries, is that
```
HoloMaps
```

support multi-dimensional indexing:

```
hmap[0,1] + hmap[0,:]
```

See the [User Guide] for more information on selecting, slicing and indexing.

###
```
HoloMap
```

is ordered
¶

One difference with regular Python dictionaries is that they are
*
ordered
*
, which can be observed by inspecting the
```
.data
```

attribute:

```
hmap.data
```

We see that internally,
```
HoloMaps
```

uses
```
OrderedDict
```

where the keys are sorted by default. You can set
```
sort=False
```

and then either supply an ordered list of (key, value) tuples, an
```
OrderedDict
```

or insert items in a chosen order.

That said, there is generally very-little reason to ever use
```
sort=False
```

as regular Python dictionaries do not have a well-defined key ordering and
```
HoloViews
```

sliders work regardless of the ordering used. The only reason to set the ordering is if you wish to iterate over a
```
HoloMap
```

using the
```
items
```

,
```
keys
```

,
```
values
```

methods or use the iterator interface.

Download this notebook from GitHub (right-click to download).