Python How to block user from calling module via another module by attributing it

In Python, you can control access to modules and their functions by utilizing various techniques. One common approach is to use attributes and encapsulation to limit what can be accessed from other modules. In this tutorial, we will show you how to prevent users from calling a module's functions from another module by attributing them with an underscore (_) to indicate they are intended for internal use only.
In Python, there's no strict concept of "private" methods or variables like some other programming languages. However, you can follow a convention to indicate that certain functions or variables are intended for internal use only. This is done by prefixing them with an underscore (_). Users can still access these attributes, but it's a signal that they should not be used outside of the module.
Let's create a simple example with two modules: module_a and module_b. module_a will contain a function with a leading underscore, and module_b will attempt to call that function.
In module_a, we have a function named _private_function() with a leading underscore. This convention signals to other developers that this function should be considered "private" and not used directly from outside the module. The public_function() is intended for external use.
In module_b, we import module_a and try to call both the public and private functions from module_a. We can see what happens when we run this code.
As you can see, we are able to call both the public and private functions from module_b, but it's important to note that using _private_function() is discouraged and considered bad practice. The leading underscore is a convention that developers should follow, but it does not enforce any strict access control.
While Python doesn't enforce strict access control, it's important to follow best practices to maintain code quality and readability: