How to run Specific function automatically or infinite times in Python Tkinter?

When creating graphical user interfaces with Python's Tkinter library, you often need to run specific functions automatically at regular intervals. This is useful for updating displays, handling periodic tasks, or refreshing data. Python Tkinter provides several approaches to achieve automatic function execution.

Understanding the Tkinter Event Loop

Tkinter applications are event-driven, meaning they continuously listen for events like button clicks or keyboard inputs. The event loop runs indefinitely using mainloop(), constantly checking for events and executing appropriate handlers.

To run functions automatically within this event loop, we have three main approaches:

• Using the after() method ? Schedule functions with delays

• Running functions in separate threads ? For concurrent execution

• Custom event-driven approach ? For advanced control

Using the after() Method

The after() method schedules function execution after a specified delay. This is the most common approach for periodic tasks in Tkinter.

Example

import tkinter as tk
import time

def my_function():
    current_time = time.strftime("%H:%M:%S")
    print(f"Function executed at {current_time}")

def schedule_function():
    my_function()  # Call the function
    root.after(1000, schedule_function)  # Schedule again in 1000ms (1 second)

root = tk.Tk()
root.geometry("300x100")
root.title("Using the after() method")

label = tk.Label(root, text="Check console for output")
label.pack(pady=20)

schedule_function()  # Start the scheduled function
root.mainloop()

Function executed at 14:30:15
Function executed at 14:30:16
Function executed at 14:30:17
...

The function runs every second within the main thread, ensuring the GUI remains responsive.

Running Functions in Separate Threads

For long-running tasks that might freeze the GUI, use threading to run functions concurrently.

Example

import tkinter as tk
import threading
import time

def long_running_function():
    # Simulate a time-consuming task
    time.sleep(3)
    print("Long-running function completed")

def run_function_in_thread():
    thread = threading.Thread(target=long_running_function)
    thread.daemon = True  # Dies when main thread dies
    thread.start()
    print("Thread started - GUI remains responsive")

root = tk.Tk()
root.geometry("300x150")
root.title("Threading Example")

label = tk.Label(root, text="Click button to run function in thread")
label.pack(pady=10)

button = tk.Button(root, text="Run Function", command=run_function_in_thread)
button.pack(pady=10)

root.mainloop()

Thread started - GUI remains responsive
Long-running function completed

Important: Tkinter is not thread-safe. Never modify GUI elements directly from threads. Use after() to schedule GUI updates from the main thread.

Custom Event-Driven Approach

For advanced scenarios requiring start/stop control and flexible timing, create a custom class.

Example

import tkinter as tk

class AutoFunctionApp:
    def __init__(self, root):
        self.root = root
        self.interval = 2000  # 2 seconds
        self.running = False
        self.counter = 0
        
        # Create GUI elements
        self.label = tk.Label(root, text="Counter: 0")
        self.label.pack(pady=10)
        
        self.start_btn = tk.Button(root, text="Start", command=self.start)
        self.start_btn.pack(side=tk.LEFT, padx=5)
        
        self.stop_btn = tk.Button(root, text="Stop", command=self.stop)
        self.stop_btn.pack(side=tk.LEFT, padx=5)
    
    def my_function(self):
        if self.running:
            self.counter += 1
            self.label.config(text=f"Counter: {self.counter}")
            print(f"Function executed - Counter: {self.counter}")
            self.root.after(self.interval, self.my_function)
    
    def start(self):
        if not self.running:
            self.running = True
            self.my_function()
    
    def stop(self):
        self.running = False

root = tk.Tk()
root.geometry("200x100")
root.title("Custom Event-Driven App")

app = AutoFunctionApp(root)
root.mainloop()

Function executed - Counter: 1
Function executed - Counter: 2
Function executed - Counter: 3
...

Comparison

Conclusion

Use after() for simple periodic tasks, threading for long-running operations, and custom classes for complex scenarios requiring start/stop control. The after() method is usually the best choice for most automatic function execution needs in Tkinter applications.