Widget Events

Special Events

from __future__ import print_function

Button kann nicht zur Darstellung eines Datentyps verwendet werden, sondern nur für on_click. Mit der print-Funktion kann der Docstring von on_click ausgegeben werden.

import ipywidgets as widgets


print(widgets.Button.on_click.__doc__)

Register a callback to execute when the button is clicked.

        The callback will be called with one argument, the clicked button
        widget instance.

        Parameters
        ----------
        remove: bool (optional)
            Set to true to remove the callback from the list of callbacks.

Beispiele

Button-Klicks sind stateless, d.h. sie übertragen Nachrichten vom Frontend zum Backend. Wenn ihr die on_click-Methode verwendet, wird ein Button angezeigt, der die Nachricht ausgibt, sobald auf sie geklickt wurde.

from IPython.display import display


button = widgets.Button(description="Click Me!")
display(button)


def on_button_clicked(b):
    print("Button clicked.")


button.on_click(on_button_clicked)

Traitlet events

Widget-Properties sind IPython-Traitlets. Um Änderungen vorzunehmen, kann die Methode observe des Widgets zum Registrieren eines callback verwendet werden. Den Docstring für observe seht ihr unten.

Weitere Informationen erhaltet ihr unter Traitlet events.

print(widgets.Widget.observe.__doc__)

Setup a handler to be called when a trait changes.

        This is used to setup dynamic notifications of trait changes.

        Parameters
        ----------
        handler : callable
            A callable that is called when a trait changes. Its
            signature should be ``handler(change)``, where ``change`` is a
            dictionary. The change dictionary at least holds a 'type' key.
            * ``type``: the type of notification.
            Other keys may be passed depending on the value of 'type'. In the
            case where type is 'change', we also have the following keys:
            * ``owner`` : the HasTraits instance
            * ``old`` : the old value of the modified trait attribute
            * ``new`` : the new value of the modified trait attribute
            * ``name`` : the name of the modified trait attribute.
        names : list, str, All
            If names is All, the handler will apply to all traits.  If a list
            of str, handler will apply to all names in the list.  If a
            str, the handler will apply just to that name.
        type : str, All (default: 'change')
            The type of notification to filter by. If equal to All, then all
            notifications are passed to the observe handler.

Linking Widgets

Für die Verknüpfung von Widget-Attributen könnt ihr diese einfach miteinander verknüpfen.

Linking Traitlet-Attribute im Kernel

caption = widgets.Label(
    value="The values of slider1 and slider2 are synchronized"
)
sliders1, slider2 = widgets.IntSlider(description="Slider 1"),\
                    widgets.IntSlider(description="Slider 2")
l = widgets.link((sliders1, "value"), (slider2, "value"))
display(caption, sliders1, slider2)

Linking Widgets-Attribute auf der Client-Seite

Beim Synchronisieren von Traitlet-Attributen tritt möglicherweise eine Verzögerung aufgrund der Kommunikation mit dem Server auf. Ihr könnt jedoch die Widget-Attribute auch direkt im Browser mit den Link-Widgets verknüpfen. Dabei bleiben die Javascript-Links mit jslink auch bestehen, wenn Widgets in HTML-Webseiten ohne Kernel eingebettet werden.

caption = widgets.Label(
    value="The values of range1 and range2 are synchronized"
)
range1, range2 = widgets.IntSlider(description="Range 1"),\
                 widgets.IntSlider(description="Range 2")
l = widgets.jslink((range1, "value"), (range2, "value"))
display(caption, range1, range2)

caption = widgets.Label(
    value="Changes in source_range values are reflected in target_range1"
)
source_range, target_range1 = widgets.IntSlider(description="Source range"),\
                              widgets.IntSlider(description="Target range 1")
dl = widgets.jsdlink((source_range, "value"), (target_range1, "value"))
display(caption, source_range, target_range1)

Kontinuierliche Updates

Einige Widgets bieten ein continuous_update-Attribut mit der Möglichkeit, Werte kontinuierlich zu aktualisieren. Im folgenden Beispiel sehen wir, dass die delayed Controls ihren Wert erst übertragen, nachdem der Benutzer den Schieberegler gezogen oder das Textfeld gesendet hat. Die continuous slides übertragen ihre Werte kontinuierlich, sobald sie geändert werden.

a = widgets.IntSlider(description="Delayed", continuous_update=False)
b = widgets.IntText(description="Delayed", continuous_update=False)
c = widgets.IntSlider(description="Continuous", continuous_update=True)
d = widgets.IntText(description="Continuous", continuous_update=True)

widgets.link((a, "value"), (b, "value"))
widgets.link((a, "value"), (c, "value"))
widgets.link((a, "value"), (d, "value"))
widgets.VBox([a, b, c, d])