bind . <KeyPress> {puts %K}

Corresponding Tkinter script:

from Tkinter import *

class Output(Label):
    def printkey(self, event):
        self.config(text=event.keysym)

root = Tk()
label = Label(root, text='Press a key...')
output = Output(root, takefocus=1)
label.pack()
output.pack()
output.focus()
output.bind('<KeyPress>', output.printkey)
root.mainloop()       

Now you know why we use Tcl instead of Python!

fisheggs 2008-01-26:

To be fair, you're comparing an apple to an Orange Glazed Coffee Cake. So this is the Deep Dish Apple Pie version of the tcl example.

package require snit

::snit::widgetadaptor Output {
    constructor {args} {
        installhull using label
        $self configurelist $args
    }
    method printkey {event} {
        # I really should have created a ::snit::type that collected all
        # the event values and made them available as instance variables
        # and passed that in here, but to keep it simple....
        $self config -text $event
    }
    delegate method * to hull
    delegate option * to hull
}

label .label -text "Press a key..."
Output .output -takefocus 1
pack .label
pack .output
focus .output
bind .output <KeyPress> {.output printkey %K}

PYK 2013-11-28: Now you know why we don't use snit!

2014-02-20: I certainly wouldn't say that. The point was that the Python example was able to modify a label widget (by subclassing it) so that it would change its text in response to keypress events, which went beyond the simple Tcl invocation that it was compared to. fisheggs then demonstrated how one could use Snit to modify a label in a similar way (by delegating to it). Modifying a widget will, by the nature of the matter, always be more verbose and complex than using it directly, but in both the Python and Snit examples you only have to deal with the complexity once, and as soon as the new class or snidget is in your library, their use is as straightforward as standard Tkinter or Tk code.

That said, I think I might have defined Output this way instead (if I had even bothered to support the -takefocus option: not doing so would have saved me one LOC):

::snit::widget Output {
    hulltype ttk::label
    delegate method printkey to hull as {config -text}
    delegate option * to hull   ;# if you really want to have -takefocus et al
}

which in turn demands that the widget type ttk::label be added to the list of hull types, if you haven't already done that:

lappend snit::hulltypes ttk::label

Use of this Output is the same as before.

But still, in this case adapting the label isn't really necessary in Tk (and I suspect not in Tkinter either): this is all the code that's actually needed:

label .label -text "Press a key..."
label .output -takefocus 1
pack .label
pack .output
focus .output
bind .output <KeyPress> {.output configure -text %K}

(and even then, you can save one line by combining the packs, but that's just being cheap).

bind . <Alt-Key-eacute> ...

_keypress_string $w HELLO\n