# HoloMap#

Title
HoloMap Container
Dependencies
Bokeh
Backends
Bokeh
Matplotlib
Plotly
```import numpy as np
import holoviews as hv
hv.extension('bokeh')
```

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
```
```True
```

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
```
```{(0, 0.5): :Curve   [x]   (y),
(0, 1): :Curve   [x]   (y),
(0.5, 0.5): :Curve   [x]   (y),
(0.5, 1): :Curve   [x]   (y)}
```

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.

This web page was generated from a Jupyter notebook and not all interactivity will work on this website. Right click to download and run locally for full Python-backed interactivity.