Working with Tkinter for several years, I’ve often found that users accidentally type letters into fields meant for ZIP codes or phone numbers.
It is a common issue that can break your Python application or lead to messy database errors.
In this tutorial, I will show you exactly how to allow only numbers in a Tkinter Entry widget using proven methods I use in my own projects.
The Problem with Default Entry Widgets
By default, the Tkinter Entry widget is quite “friendly”; it accepts any character the user types.
If you are building a tool to calculate sales tax in New York or a simple payroll app, you don’t want “abc” in your salary field.
Method 1: Use the Register Method and Validation Command
This is my favorite way to handle number-only inputs because it stops the character from ever appearing in the box.
It feels much smoother for the user than showing an error message after they have already finished typing.
Tkinter has a built-in validation system that involves a “callback” function.
This function checks the input every time a key is pressed and returns either True (allow it) or False (block it).
Here is the full code to create an entry that only accepts digits. In this example, let’s imagine we are building a simple “Social Security Number” or “ZIP Code” validator for a US-based form.
import tkinter as tk
def validate_number(char):
# This function returns True if the character is a digit or empty
if char.isdigit() or char == "":
return True
else:
return False
def main():
root = tk.Tk()
root.title("PythonGuides - Number Validation")
root.geometry("400x250")
# Register the validation function
# 'd' stands for action (insert/delete), 'P' is the value after the change
# 'S' is the text string being inserted or deleted
reg = root.register(validate_number)
tk.Label(root, text="Enter your 5-digit US ZIP Code:", font=("Arial", 11)).pack(pady=10)
# Apply validation using 'key' substitution
# %S passes the string being typed to our function
zip_entry = tk.Entry(root, validate="key", validatecommand=(reg, '%S'))
zip_entry.pack(pady=5)
root.mainloop()
if __name__ == "__main__":
main()You can see the output in the screenshot below.
I find this method robust because it prevents the error at the source.
The %S percentage substitution is the secret sauce here; it specifically sends only the character being inserted to our logic.
Method 2: Use the Trace Method on a StringVar
Sometimes, you might want to allow the user to type whatever they want, but instantly “clean” the input.
I often use this when I’m dealing with data that might be copied and pasted from a document or a spreadsheet.
We link the Entry widget to a StringVar. We then “trace” that variable, meaning every time it changes, a function runs to strip out any non-numeric characters.
Let’s use an example of entering a California-style “Price per Gallon” for a gas station app.
import tkinter as tk
import re
class NumericEntryApp:
def __init__(self, root):
self.root = root
self.root.title("Gas Price Input")
self.root.geometry("400x200")
self.number_var = tk.StringVar()
# Trace the variable 'w' (write) mode
self.number_var.trace_add("write", self.only_numbers)
tk.Label(root, text="Enter Price (Numbers Only):").pack(pady=10)
self.entry = tk.Entry(root, textvariable=self.number_var)
self.entry.pack(pady=5)
def only_numbers(self, *args):
value = self.number_var.get()
# Use regex to keep only digits
clean_value = re.sub(r'[^0-9]', '', value)
if value != clean_value:
self.number_var.set(clean_value)
if __name__ == "__main__":
root = tk.Tk()
app = NumericEntryApp(root)
root.mainloop()You can see the output in the screenshot below.
In this setup, if a user tries to type “4.25$”, the code immediately removes the dots and signs, leaving only “425”.
Method 3: Handle Decimals (Float Validation)
In many USA-specific applications, like calculating interest rates for a mortgage in Texas, you need more than just whole numbers.
You need to allow a single decimal point. This is a bit more complex because you have to ensure the user doesn’t type “12.34.56”.
I check two things: is the character a digit, or is it a period? If it’s a period, I check if there is already a period in the text.
import tkinter as tk
def validate_float(current_value, new_char):
# Allow digits
if new_char.isdigit():
return True
# Allow one decimal point
if new_char == "." and "." not in current_value:
return True
# Allow backspace/deletion
if new_char == "":
return True
return False
root = tk.Tk()
root.title("Mortgage Rate Calculator")
vcmd = (root.register(validate_float), '%P', '%S')
tk.Label(root, text="Enter Interest Rate (%):").pack(pady=10)
rate_entry = tk.Entry(root, validate="key", validatecommand=vcmd)
rate_entry.pack(pady=10)
root.mainloop()You can see the output in the screenshot below.
Advanced Validation: Limit Character Length
When working with US Phone numbers, you usually want exactly 10 digits.
I’ve found that combining type validation with length validation provides the best user experience.
Code for 10-Digit Phone Number Only
def validate_phone(P):
# P represents the value that the text will have if the change is allowed
if len(P) > 10:
return False
if P == "" or P.isdigit():
return True
return False
# Usage in Entry
# phone_entry = tk.Entry(root, validate="key", validatecommand=(reg_phone, '%P'))Using %P is better here than %S because %P checks the entire resulting string after the edit.
Best Practices for Tkinter Validation
Over the years, I have learned a few hard lessons about UI design in Python.
First, always give the user a label. If they type a letter and nothing happens, they might think your app is frozen.
Second, consider changing the background color of the Entry widget if the input is invalid but not blocked.
Common Mistakes to Avoid
A common mistake I see beginners make is forgetting to “register” the callback function.
Without root.register(), Tkinter won’t know how to bridge the gap between its underlying Tcl/Tk engine and your Python code.
Another slip-up is using validate=”focusout”. This only checks the input when the user clicks away.
In my experience, “key” validation is much better for preventing bad data in the first place.
Real-World Example: A Simple US Invoice App
Let’s put everything together. Imagine we are creating a small tool to calculate the total price of items in a Chicago warehouse.
We need quantity (integers only) and price (floats allowed).
import tkinter as tk
class InvoiceApp:
def __init__(self, root):
self.root = root
self.root.title("Warehouse Tool")
self.root.geometry("350x300")
# Registration
self.v_int = (root.register(self.is_int), '%P')
self.v_float = (root.register(self.is_float), '%P')
tk.Label(root, text="Item Quantity:").pack(pady=5)
self.qty = tk.Entry(root, validate="key", validatecommand=self.v_int)
self.qty.pack()
tk.Label(root, text="Unit Price ($):").pack(pady=5)
self.price = tk.Entry(root, validate="key", validatecommand=self.v_float)
self.price.pack()
self.btn = tk.Button(root, text="Calculate Total", command=self.calculate)
self.btn.pack(pady=20)
self.result = tk.Label(root, text="Total: $0.00", font=("Arial", 12, "bold"))
self.result.pack()
def is_int(self, P):
return P == "" or P.isdigit()
def is_float(self, P):
if P == "": return True
try:
float(P)
return True
except ValueError:
return False
def calculate(self):
try:
q = int(self.qty.get())
p = float(self.price.get())
self.result.config(text=f"Total: ${q * p:.2f}")
except:
self.result.config(text="Invalid Input!")
if __name__ == "__main__":
win = tk.Tk()
InvoiceApp(win)
win.mainloop()This simple structure ensures that your business logic never encounters a ValueError because the UI layer has already filtered the junk.
In this tutorial, I have covered several ways to restrict a Tkinter Entry widget to numeric values.
Whether you use the validatecommand for real-time blocking or trace for cleaning up input, both are effective depending on your specific needs.
I personally find the validatecommand with the %S or %P substitutions to be the cleanest approach for most US-based business applications.
You may also read:
- How to Change Tkinter Label Color in Python
- How to Wrap Text in Tkinter Label
- Python Tkinter Frame Grid
- Python Tkinter Button Click
I am Bijay Kumar, a Microsoft MVP in SharePoint. Apart from SharePoint, I started working on Python, Machine learning, and artificial intelligence for the last 5 years. During this time I got expertise in various Python libraries also like Tkinter, Pandas, NumPy, Turtle, Django, Matplotlib, Tensorflow, Scipy, Scikit-Learn, etc… for various clients in the United States, Canada, the United Kingdom, Australia, New Zealand, etc. Check out my profile.
