交互式验证TKINTER中的输入小部件内容

Question

在tkinter 条目小部件中，用于交互式验证内容的推荐技术是什么？

我已经阅读了有关使用 validate = true 和 validateCommand =命令的帖子，并且看来这些功能受到> 的清除的限制。 valialatecommand 命令更新条目 widget的值。

鉴于此行为，我们应该在 KeyPress ，剪切和粘贴事件并进行监视/更新我们的条目的情况下绑定。小部件通过这些事件的价值？ （以及我可能错过的其他相关事件？）

还是我们应该完全忘记交互式验证，仅在 focus> focusOut 事件上验证？

Answer 1

正确的答案是，使用小部件的 validatecommand 属性。不幸的是，在TKINTER世界中，此功能在TK World中已足够充分记录在TKInter世界中。即使没有很好地记录下来，它也需要您需要进行验证的一切，而无需求绑定或跟踪变量，或者从验证过程中修改小部件。

诀窍是要知道您可以将tkinter传递给您的validate命令。这些值为您提供了所有您需要了解的信息，以决定数据是否有效：编辑之前的值，如果编辑有效，则编辑后的值以及其他几个信息。但是，要使用这些这些信息，您需要做一点伏都教才能将此信息传递给您的validate命令。

注意：验证命令返回 true 或 false 很重要。其他任何事情都会导致小部件关闭验证。

这是一个只允许小写的示例。它还以说明性目的打印所有特殊值的值。他们并不是所有必要的；您很少需要一两个以上。

import tkinter as tk  # python 3.x
# import Tkinter as tk # python 2.x

class Example(tk.Frame):

    def __init__(self, parent):
        tk.Frame.__init__(self, parent)

        # valid percent substitutions (from the Tk entry man page)
        # note: you only have to register the ones you need; this
        # example registers them all for illustrative purposes
        #
        # %d = Type of action (1=insert, 0=delete, -1 for others)
        # %i = index of char string to be inserted/deleted, or -1
        # %P = value of the entry if the edit is allowed
        # %s = value of entry prior to editing
        # %S = the text string being inserted or deleted, if any
        # %v = the type of validation that is currently set
        # %V = the type of validation that triggered the callback
        #      (key, focusin, focusout, forced)
        # %W = the tk name of the widget

        vcmd = (self.register(self.onValidate),
                '%d', '%i', '%P', '%s', '%S', '%v', '%V', '%W')
        self.entry = tk.Entry(self, validate="key", validatecommand=vcmd)
        self.text = tk.Text(self, height=10, width=40)
        self.entry.pack(side="top", fill="x")
        self.text.pack(side="bottom", fill="both", expand=True)

    def onValidate(self, d, i, P, s, S, v, V, W):
        self.text.delete("1.0", "end")
        self.text.insert("end","OnValidate:\n")
        self.text.insert("end","d='%s'\n" % d)
        self.text.insert("end","i='%s'\n" % i)
        self.text.insert("end","P='%s'\n" % P)
        self.text.insert("end","s='%s'\n" % s)
        self.text.insert("end","S='%s'\n" % S)
        self.text.insert("end","v='%s'\n" % v)
        self.text.insert("end","V='%s'\n" % V)
        self.text.insert("end","W='%s'\n" % W)

        # Disallow anything but lowercase letters
        if S == S.lower():
            return True
        else:
            self.bell()
            return False

if __name__ == "__main__":
    root = tk.Tk()
    Example(root).pack(fill="both", expand=True)
    root.mainloop()

有关寄存器方法时发生的事情的更多信息，请参见 tkinter输入验证需要调用寄存器（）？

有关规范文档的信息，请参见 tcl/tk入门人页面的验证部分

Answer 2

在研究和实验Bryan的代码之后，我产生了最少的输入验证版本。以下代码将放置一个入口框，仅接受数字数字。

from tkinter import *

root = Tk()

def testVal(inStr,acttyp):
    if acttyp == '1': #insert
        if not inStr.isdigit():
            return False
    return True

entry = Entry(root, validate="key")
entry['validatecommand'] = (entry.register(testVal),'%P','%d')
entry.pack()

root.mainloop()

也许我应该补充说，我仍在学习Python，我会很乐意接受所有评论/建议。

Answer 3

使用 tkinter.stringvar 来跟踪条目 widget的值。您可以通过在其上设置 trace 来验证 StringVar 的值。

这是一个简短的工作程序，它仅接受条目 widget中的有效浮子。

try:
    from tkinter import *
except ImportError:
    from Tkinter import *  # Python 2


root = Tk()
sv = StringVar()

def validate_float(var):
    new_value = var.get()
    try:
        new_value == '' or float(new_value)
        validate_float.old_value = new_value
    except:
        var.set(validate_float.old_value)

validate_float.old_value = ''  # Define function attribute.

# trace wants a callback with nearly useless parameters, fixing with lambda.
sv.trace('w', lambda nm, idx, mode, var=sv: validate_float(var))
ent = Entry(root, textvariable=sv)
ent.pack()
ent.focus_set()

root.mainloop()

Answer 4

布莱恩的答案是正确的，但是没有人提到tkinter小部件的“无效”属性。

一个很好的解释在这里：

在损坏链接的情况下，文本复制/粘贴，

条目窗口部门还支持一个无效的选项，该选项指定每当有valialateCommand返回false时指定调用的回调函数。此命令可以通过使用小部件关联的文本变量上的.set（）方法来修改小部件中的文本。设置此选项与设置ValidateCommand相同。您必须使用.register（）方法包装python函数；此方法将包装函数的名称返回为字符串。然后，您将作为该字符串或包含替换代码的元组的第一个元素作为InvalidCommand选项的值传递。

注意：
我只有一件事我无法弄清楚如何做：如果将验证添加到条目中，并且用户选择了部分文本并键入新值，则无法捕获原始值并重置条目。这是一个示例

1. 条目，旨在仅通过实现“ valialatecommand”
2. 用户输入1234567
3. 用户选择“ 345”并按'J'来接受整数。这被注册为两个动作：删除“ 345”，以及插入“ J”。 TKINTER忽略了删除，并且仅在插入“ J”的插入上。 'valiTateCommand'返回false，并且传递给“ InvalidCommand”函数的值如下：％d = 1，％i = 2，％p = 12J67，％s = 1267，％s = J，
4. 如果代码未实现“ invalidCommand”函数，“ validateCommand”功能将拒绝“ J”，结果将为1267。如果代码确实实现了“ InvalidCommand”功能，则无法恢复原始的1234567。

Answer 5

定义返回布尔值的函数，该功能指示输入是否有效。
将其注册为TCL回调，然后将回调名称传递给窗口小部件，以 valialateTecommand 。

例如：

import tkinter as tk


def validator(P):
    """Validates the input.

    Args:
        P (int): the value the text would have after the change.

    Returns:
        bool: True if the input is digit-only or empty, and False otherwise.
    """

    return P.isdigit() or P == ""


root = tk.Tk()

entry = tk.Entry(root)
entry.configure(
    validate="key",
    validatecommand=(
        root.register(validator),
        "%P",
    ),
)
entry.grid()

root.mainloop()

Answer 6

在研究 Bryan Oakley的答案时，有些事情告诉我，可以开发更一般的解决方案。以下示例介绍了用于验证目的的模式枚举，类型词典和设置功能。参见第48行，例如用法及其简单性的演示。

#! /usr/bin/env python3
# https://stackoverflow.com/questions/4140437
import enum
import inspect
import tkinter
from tkinter.constants import *


Mode = enum.Enum('Mode', 'none key focus focusin focusout all')
CAST = dict(d=int, i=int, P=str, s=str, S=str,
            v=Mode.__getitem__, V=Mode.__getitem__, W=str)


def on_validate(widget, mode, validator):
    # http://www.tcl.tk/man/tcl/TkCmd/ttk_entry.htm#M39
    if mode not in Mode:
        raise ValueError('mode not recognized')
    parameters = inspect.signature(validator).parameters
    if not set(parameters).issubset(CAST):
        raise ValueError('validator arguments not recognized')
    casts = tuple(map(CAST.__getitem__, parameters))
    widget.configure(validate=mode.name, validatecommand=[widget.register(
        lambda *args: bool(validator(*(cast(arg) for cast, arg in zip(
            casts, args)))))]+['%' + parameter for parameter in parameters])


class Example(tkinter.Frame):

    @classmethod
    def main(cls):
        tkinter.NoDefaultRoot()
        root = tkinter.Tk()
        root.title('Validation Example')
        cls(root).grid(sticky=NSEW)
        root.grid_rowconfigure(0, weight=1)
        root.grid_columnconfigure(0, weight=1)
        root.mainloop()

    def __init__(self, master, **kw):
        super().__init__(master, **kw)
        self.entry = tkinter.Entry(self)
        self.text = tkinter.Text(self, height=15, width=50,
                                 wrap=WORD, state=DISABLED)
        self.entry.grid(row=0, column=0, sticky=NSEW)
        self.text.grid(row=1, column=0, sticky=NSEW)
        self.grid_rowconfigure(1, weight=1)
        self.grid_columnconfigure(0, weight=1)
        on_validate(self.entry, Mode.key, self.validator)

    def validator(self, d, i, P, s, S, v, V, W):
        self.text['state'] = NORMAL
        self.text.delete(1.0, END)
        self.text.insert(END, 'd = {!r}\ni = {!r}\nP = {!r}\ns = {!r}\n'
                              'S = {!r}\nv = {!r}\nV = {!r}\nW = {!r}'
                         .format(d, i, P, s, S, v, V, W))
        self.text['state'] = DISABLED
        return not S.isupper()


if __name__ == '__main__':
    Example.main()

Answer 7

import tkinter
tk=tkinter.Tk()
def only_numeric_input(e):
    #this is allowing all numeric input
    if e.isdigit():
        return True
    #this will allow backspace to work
    elif e=="":
        return True
    else:
        return False
#this will make the entry widget on root window
e1=tkinter.Entry(tk)
#arranging entry widget on screen
e1.grid(row=0,column=0)
c=tk.register(only_numeric_input)
e1.configure(validate="key",validatecommand=(c,'%P'))
tk.mainloop()
#very usefull for making app like calci

Answer 8

如果要同时设置数字和最大字符，则此代码可以提供帮助。

from tkinter import *

root = Tk()

def validate(P):
    if len(P) == 0 or len(P) <= 10 and P.isdigit():  # 10 characters
        return True
    else:
        return False

ent = Entry(root, validate="key", validatecommand=(root.register(validate), '%P'))
ent.pack()

root.mainloop()

Answer 9

这是@Steven Rumbalski的答案 验证 entrac> widget值，通过追踪到 StringVar - 我已经通过将其编辑到位，在某种程度上进行了调试并改进。

下面的版本将所有内容都放入 stringvar subclass 以封装更好的事情，更重要的是，允许同一时间同时存在多个独立实例，而不会彼此干扰 - 他的实现一个潜在的问题，因为它利用函数属性而不是实例属性，这些属性与全局变量基本相同，并且在这种情况下可能会导致问题。

try:
    from tkinter import *
except ImportError:
    from Tkinter import *  # Python 2


class ValidateFloatVar(StringVar):
    """StringVar subclass that only allows valid float values to be put in it."""

    def __init__(self, master=None, value=None, name=None):
        StringVar.__init__(self, master, value, name)
        self._old_value = self.get()
        self.trace('w', self._validate)

    def _validate(self, *_):
        new_value = self.get()
        try:
            new_value == '' or float(new_value)
            self._old_value = new_value
        except ValueError:
            StringVar.set(self, self._old_value)


root = Tk()
ent = Entry(root, textvariable=ValidateFloatVar(value=42.0))
ent.pack()
ent.focus_set()
ent.icursor(END)

root.mainloop()

Answer 10

响应 ORIONROBERT的问题 处理简单验证文本替代文本，而不是单独的删除或插入：

将选定文本的替换作为删除处理，然后插入。例如，当删除应将光标移动到左侧时，这可能会导致问题，而替换应将光标移动到右侧。幸运的是，这两个过程彼此之间立即执行 。
因此，我们可以区分删除本身和直接删除，然后直接删除由于替换而引起的插入，因为后者没有改变删除和插入之间的空闲标志。

使用替代品和 widget.after_idle（）来利用这。
after_idle（）在事件队列结束时执行lambda功能：

class ValidatedEntry(Entry):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        self.tclValidate = (self.register(self.validate), '%d', '%i', '%P', '%s', '%S', '%v', '%V', '%W')
        # attach the registered validation function to this spinbox
        self.config(validate = "all", validatecommand = self.tclValidate)

    def validate(self, type, index, result, prior, indelText, currentValidationMode, reason, widgetName):

        if typeOfAction == "0":
            # set a flag that can be checked by the insertion validation for being part of the substitution
            self.substitutionFlag = True
            # store desired data
            self.priorBeforeDeletion = prior
            self.indexBeforeDeletion = index
            # reset the flag after idle
            self.after_idle(lambda: setattr(self, "substitutionFlag", False))

            # normal deletion validation
            pass

        elif typeOfAction == "1":

            # if this is a substitution, everything is shifted left by a deletion, so undo this by using the previous prior
            if self.substitutionFlag:
                # restore desired data to what it was during validation of the deletion
                prior = self.priorBeforeDeletion
                index = self.indexBeforeDeletion

                # optional (often not required) additional behavior upon substitution
                pass

            else:
                # normal insertion validation
                pass

        return True

当然，在替换后，在验证删除部分时，仍然不知道插入是否会遵循。
幸运的是，有：
.set（），
.icursor（），
.index（sel_first），
.index（sel_last），
.index（insert），
我们可以追溯地实现最期望的行为（因为我们的新替代品与插入的结合是一个新的独特事件。

Answer 11

entry_text1 = StringVar()
XYZ=Entry( root, width=10,textvariable=entry_text1 ,  
font=font3)
XYZ.grid(column=1,row=1,padx=10)

try:
    XYZ=float(entry_text1.get())
    return True
except ValueError:        
    XYZ.delete(0, END)       
    XYZ.insert(0,0)
    tkinter.messagebox.showinfo("not pass",  "please enter only 
    number with '.' or only number") 
    return False