Why You Should Avoid from tkinter import * in Python

Python’s Tkinter library is a powerful building block for graphical user interfaces. While it’s easier to use from tkinter import * for quick access, it can lead to several problems in larger, more complex codes. In this blog, we will discuss the various reasons one needs to avoid using from tkinter import * and provide better practices.

1) Namespace Pollution

• Importing * from tkinter clutters your local namespace. It literally means that all functions, classes, and variables defined within tkinter are now accessible directly into your code without using the tkinter. prefix.
•  If you happen to have used names of functions or variables from another module, naming conflicts arise. This can be shown with an example:

from tkinter import *  

def calculate_area(length, width):  # Custom function
    area = length * width
    message = f"The area is: {area}"  # Variable named 'message'

window = Tk()
label = Label(window, text=message)  # Using 'message' from tkinter.messagebox
label.pack()

window.mainloop()

As this example illustrates, the statement from tkinter import * introduces tkinter.messagebox into the namespace. Now, if tkinter.messagebox itself defines a function called message, then that would immediately bring it into conflict with the intended use of message within the calculate_area function as well, which could result in your code running with an error.

Recommended Approach:

import tkinter as tk # Alias for cleaner code

def calculate_area(length, width):
    area = length * width
    message = f"The area is: {area}" # No conflicts

window = tk.Tk()
label = tk.Label(window, text=message)
label.pack()

tk.mainloop()

As shown above, by explicit import of only required modules from tkinter, like tk.Tk, tk.Label, the code created has no namespace clutter and is more maintainable.

2) Reduced Readability and Maintainability

• Code that explicitly imports what it needs from tkinter is also easier to read and easier to maintain. It makes it clear exactly which elements of tkinter you are using. In case someone else needs to look at your code, they know exactly what is happening.
• Explicit imports allow for easier refactoring. For example, if at a later date you needed to change the name of something in the tkinter module to something else, you would only need to change the import line, not search all your code for possible conflicts.

Conclusion

Using explicit import statements for modules and aliasing them will lead to more readable, maintainable, and less error-prone code. Remember to always use explicit imports, rather than from module import *, for readability of code and avoiding possible future conflicts and errors. For further information, refer to this webpage.