Why does Python not allow us to call functions like other languages do?

Question

What many other languages do

In many languages, I can have a function defined in a file called get_xyz.m (for example) and then other functions or scripts can use that function with a syntax like:

get_xyz(argument)

For example, if I want the argument to be the number "5", the I can do:

get_xyz(5)

What we have done in Python

Python doesn't allow "functions as files" unless we add lines like from get_xyz import get_xyz to the beginning, which seems like a waste of space and can make the file quite long if there's a lot of them to import. Instead it we can have a "module" file which can contain functions, but they can't be called in such a simple way like in other languages. The reason this question arose for me while working on a project with other team members, is because we had something like:

get_xyz.get_xyz(argument) 

in Python, which looked very redundant. One programmer changed it to something like:

go_db.get_xyz(argument) 

which I found to be a big more confusing and it seemed "forced", as if we didn't really want to come up with a second name, but it was done in order to make the "module" and "function" have different names.

What others have done in Python

Others have also run into this issue in their Python programs, and one example can be seen here for a Python program that currently has 898 stars and 475 forks on GitHub:

fci.FCI(argument)

Here the "module" name and the function name are distinguished by using lower case and capital letters.

Why can't we just call functions like in other languages?

I debated for a while with two hard-core Python enthusiasts about this, and the only answer that I eventually got at the very end was:

"This solves the issue of namespaces, so that no two things have the same name."

Is that the only reason why Python was designed this way?

Answer 1

This pattern is not as common as you think

It looks like you're referencing MATLAB there. MATLAB is the only language I know that forces a file to be in one-to-one correspondence with the language's notion of a "function". In my experience, when a language ties an existing construct to the source files making up your program, it just limits what you can do.

• MATLAB forces files to be public functions, and that forces me to split up several small but public functions into extremely tiny files.
• Java forces files to be public classes. This results in several awkward patterns where I have so-called "classes" containing only static methods.

The languages that have the most success leveraging the file system do so by creating a new construct in the language itself specifically for the notion of a file. Python, and many languages, calls these construct a "module". A module is not an existing language feature. It's a new thing that can essentially be defined as "the reification of a file within Python". As such, its needs are exactly built to suit files and are not shoehorning the filesystem into an existing model of "functions" or "classes".

It's telling that the two most popular "better Java" languages removed the "one-class-per-file" restriction that Java put into place. Kotlin and Scala both allow any number of public declarations, even non-classes, to be placed in a single file, and they do the work of compiling that down to something the JVM acknowledges.

Answer 2

There are a few reasons:

1. As you said, so no two namespaces have the same name.
2. Readability and clarity. The module.function() syntax provides clear information about where the function is defined making it more readable and clear, especially in big projects.
3. Modularity and Encapsulation. This helps organize code and improves its maintainability.
4. Explicit importing. It is a documentation method to show what's in the code and prevents function name collision between different modules.
5. Consistency and easy to use. It is also how you would go about getting attributes or object methods, making it more intuitive and easy to learn.