Python Why Import Star Is Bad Tutorial - Complete Guide

Hello, code ninjas! Today, we are about to delve into the fascinating world of Python and discuss a common stumbling block for beginners and even seasoned coders – the usage of import *. By the end of this tutorial, you’ll understand why overusing this statement may pose a problem and how to navigate your way towards cleaner, more efficient, and reliable code.

Table of contents

What Does “import *” Mean?

In Python, import * is a statement used for importing all functions, classes, and variables from another module. It’s similar to saying “Give me everything you’ve got!” to the module you are importing into your code. This can simplify code writing, especially when dealing with modules with an extensive amount of functions or classes.

While using import * might seem like a advantageous shortcut in the short run, it often leads to code that can be at best confusing and at worst problematic. With import *, all the functions and classes from another module get imported into your current namespace which can cause naming clashes, and debugging nightmares.

Understanding why import * is not a recommended practice is a significant step towards mastering Python. It helps you develop good programming habits, encourages the separation of concerns, and facilitates readable and maintainable code. Moreover, your projects will be a lot more reliable as the risk of runtime errors due to naming conflicts significantly decreases.

So, let’s dive into coding and see how using import * can affect our Python projects.

FREE COURSES AT ZENVA

LEARN GAME DEVELOPMENT, PYTHON AND MORE

ACCESS FOR FREE

AVAILABLE FOR A LIMITED TIME ONLY

How “import *” Works

Let’s start by using import * in a basic script. Consider the file example_module.py with the following content:

# example_module.py
def greet(name):
    return "Hello, " + name

def farewell(name):
    return "Goodbye, " + name

You can use import * to import everything from the module:

# main.py
from example_module import *

print(greet("Coder"))
print(farewell("Coder"))

The Problem

The issue with import * arises when two or more modules have functions or classes with the same name:

# another_module.py
def greet(name):
    return "Hey, " + name

Now, if we try to use import * for both modules:

# main.py
from example_module import *
from another_module import *

print(greet("Coder"))

The output will be “Hey, Coder” because the function from another_module overwrote the first one without warning. This is the kind of problem import * can lead to, which could be a big headache to debug.

How to Import Correctly

Instead of using import *, you can import whole modules or just the features you need, like so:

# main.py
import example_module
import another_module

print(example_module.greet("Coder"))
print(another_module.greet("Coder"))

Or even better, import just the features you need:

# main.py
from example_module import greet

print(greet("Coder"))

Doing this ensures no conflicts arise due to overwriting.

Importing Specific Functions

When working with larger modules, it’s often beneficial to import only the specific functions you need. Below is an example of how to do this:

from example_module import greet
print(greet("Coder"))

Now, if we try to call a function that we didn’t specifically import, Python throws an error:

from example_module import greet
print(farewell("Coder"))  # NameError: name 'farewell' is not defined

Importing with Aliases

There can be situations when function names are long or conflict with your variable names. Python provides a way to alias imported functions:

from example_module import greet as hello
print(hello("Coder"))

Importing Multiple Functions

You can import multiple functions in a single line of code:

from example_module import greet, farewell
print(greet("Coder"))
print(farewell("Coder"))

Importing Entire Modules

You can import the whole module instead of individual functions. This way, there won’t be any naming conflicts in your namespace:

import example_module
print(example_module.greet("Coder"))
print(example_module.farewell("Coder"))

Understanding Import Order

In Python, the order of imports matters. It’s important to understand that further imports can overwrite previous ones:

from example_module import greet  # returns "Hello, ..."
from another_module import greet  # returns "Hey, ..."

print(greet("Coder"))  # output: "Hey, Coder"

In this example, the last imported greet function overwrites the first one. This underlines the necessity to avoid overbroad importing like import *.

Where to Go Next?

Now that we’ve uncovered the reasons to reconsider the use of import * in Python, you may be wondering what the next step is in your coding journey. Don’t worry, we’ve got you covered!

You can take your Python skills to the next level with our comprehensive Python Mini-Degree. This course covers a vast array of Python programming topics and equips you with in-depth knowledge to create your own games, algorithms, and real-world apps.

Python’s simplicity and versatility have made it a popular choice for both beginners and experienced programmers. With our Python Mini-Degree, you get to create exciting projects ranging from arcade games to medical diagnosis bots and escape rooms. These hands-on projects, coupled with live coding sessions and in-course quizzes, consolidate your learning and make the journey highly interactive and fun.

At Zenva, we have a multitude of Python courses catering to different learning needs. From beginner to professional level, we gear you up to excel in programming, game development, and AI. Our lesson structure is flexible and accessible, giving you the freedom to learn at your own pace and on any device.

Graduates of our courses have built impressive portfolios of real-world projects and have taken a significant leap in their careers. By mastering Python, you’ll be equipped with a highly sought-after skill in today’s job market, particularly valuable in areas like data science and AI.

Conclusion

Mastering Python opens doors to vast possibilities — be it creating engaging games, crafting cutting-edge AI, or solving complex data science problems. By avoiding common pitfalls such as the overuse of import *, you ensure your Python projects run smoothly and efficiently.

Are you ready to take your Python prowess up a notch? Start your journey with us at Zenva. Our Python Mini-Degree nurtures your programming skills with real-life projects and thorough guidance. Be part of our coding tribe, and let’s create magic with code!

Did you come across any errors in this tutorial? Please let us know by completing this form and we’ll look into it!

FREE COURSES