Interactions

The interact function (panel.interact) automatically creates controls for interactively browsing code and data.

import panel as pn

from panel import widgets
from panel.interact import fixed, interact, interact_manual, interactive


pn.extension()

interact

At the simplest level, interact controls are automatically generated for function arguments, and the function is then called with those arguments when you interactively edit the controls. To use interact you need to define a function that you want to examine. Here is a function that returns the only argument: x.

def f(x):
    return x

If you pass this function as the first argument together with an integer keyword argument x=10 to interact a slider is generated and bound to the function parameters.

interact(f, x=10)

If you move the slider, the function is called, which outputs the current value of x. If you pass True or False interact generates a check box:

interact(f, x=True)

When you pass a string, interact generates a text area.

interact(f, x="Hi Pythonistas!")

interact can also be used as a Decorator. In this way you can define a function as well as determine the type of interaction. As the following example shows, interact works also with functions that have multiple arguments.

@interact(x=True, y=1.0)
def g(x, y):
    return (x, y)


g

Layout of interactive widgets

The interact function returns a panel that contains the widgets and the display output. By indexing these panels we can lay out the objects exactly how we want:

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd


%matplotlib inline


def mplplot(df, **kwargs):
    fig = df.plot().get_figure()
    plt.close(fig)
    return fig


def sine(frequency=1.0, amplitude=1.0, n=200, view_fn=mplplot):
    xs = np.arange(n) / n * 20.0
    ys = amplitude * np.sin(frequency * xs)
    df = pd.DataFrame(dict(y=ys), index=xs)
    return view_fn(df, frequency=frequency, amplitude=amplitude, n=n)

i = pn.interact(sine, n=(5, 100))
pn.Row(i[1][0], pn.Column("<br>\n### Sine waves", i[0][0], i[0][1]))

layout = interact(f, x=10)

pn.Column("**A custom interact layout**", pn.Row(layout[0], layout[1]))

Set arguments with fixed

There may be times when you want to examine a function using interact, but want to set one or more of its arguments to specific values. This can be achieved using the fixed function:

def h(p, q):
    return (p, q)

interact(h, p=5, q=fixed(20))

Widget abbreviations

If you pass certain values, interact use automatically the appropriate widget, for example a checkbox for True or IntSlider for integer values. So you don’t have to explicitly specify the appropriate widget:

interact(f, x=widgets.FloatSlider(start=0.0,end=10.0,step=0.01,value=3.0))

interact(f, x=(0.0,10.0,0.01,3.0))

This example shows how the keyword arguments are processed by interact:

1. If the keyword argument is an instance of Widget with a value attribute, this widget is used. Any widget with a value attribute can be used, including custom ones.

2. Otherwise, the value is treated as a Widget Abbreviation that is converted to a widget before use.

The following table gives an overview of the various Widget Abbreviations:

Keyword argument	Widget
True or False	Checkbox
"Hi Pythonistas!"	Text
Integer value as min, max,step, value	IntSlider
Floating-point min, max,step, value	FloatSlider
["apple", "pear"] or {"one": 1, "two": 2}	Dropdown