Imports and dot-notation

[Oliver Schinagl]

Dear list,


First a disclaimer, I am a python novice ;) so apologies beforehand for 
any incorrect terms and use thereof :)

I have a question about the preferred/pythonic way dealing with imports. 
But let me start by giving a little bit of an example (which lead me to 
this question).

Looking at a python projects code and repository layout, we see the 
following directory structure.


/project/core
/project/components/module1
...
/project/components/moduleN
/projects/util

(this is far from complete, but enough to help paint a picture.

Some modules import other modules, and I see (at the very least) two 
(kind of three?) different ways of doing so.

`from project.components.module1 import function1, function2 as func, 
CONST1, CONST2 as CONST`

or maybe even (which has as an advantage that it becomes clear which 
namespace something belongs to

`from project.components.module1 import function1, function2 as 
module1_function2, CONST1, CONST2 as MODULE1_CONST2`

but then it really just becomes personal preference, as the number of 
characters saved on typing is almost negative (due to having a more 
complex import).


but also the dot notation being used

`from project.components import module1`

where obviously the functions are invoked as `module1.function1` etc

I hope the above is clear enough from an example.


Simply put, which of the two would be considered cleaner and more pythonic?

Now for a bit more thought, looking at PEP8, we notes about imports, but 
sadly PEP8 does not state which method is better/preferred. While 
obviously in the end, it's always the maintainers choice in what they 
prefer, so are tabs vs spaces and PEP8 is opinionated about that too (in 
a good way, even though I'm not a fan :p).

Likewise, if we look at PEP20, there's quite a few 'guidelines' that 
suggest the dot-notation. To name a few (opinionated) examples (but note 
I am just using PEP20 as a helper to give some arguments, I know some 
people feel strongly against pep20 :p):

* Beautiful is better than ugly.
   - Personally, I think the dot notation is more beautiful, but I 
understand that some people find the short notation more beautiful and 
less of an eye sore ;)

* Explicit is better than implicit.
   - To me, this is a strong point. Being more explicit is always 
better, using the dot notation (if though it's not doing the WHOLE path) 
is a nice balance in being explicit enough. Code readability comes from 
being more explicit (without being to terse of course).

* Simple is better than complex.
* Flat is better than nested.
   -  I think having more flat and simple imports, and (while more 
characters to potentially type in the invocation) more readable 
invocations would be better?

* Readability counts.
   - The dot notation seems to help in readability. For those unfamiliar 
(or less familiar) with a code base, it becomes incredibly clear where a 
something comes from (WITHOUT having to rely on IDE's; sure you can 
hover over something and see that the IDE has hopefully worked out where 
something came from, but this doesn't work when just reading a page of 
code, you aren't going to hover over everything and remember all that 
context).

* In the face of ambiguity, refuse the temptation to guess.
   - I'd argue this is almost self-explanatory, not using dot-notation 
makes it more ambiguous where something is coming from.

* There should be one-- and preferably only one --obvious way to do it.
   - This is where my confusion/question obviously comes from, as 
there's multiple ways of doing it, so maybe PEP8 (or a new one) should 
more strongly favor one?

* Namespaces are one honking great idea -- let's do more of those!
   - Basically, this question/proposal would 'force/nudge' you into 
writing more with namespaces by using the namespace as prefix.


So what IS the preferred/more pythonic/recommended way to deal with imports?

Why was this not mentioned in PEP8?

Is it worth while to introduce a new PEP or amend PEP8?


For what it's worth, hallucinating chatgpt/google bard both say the same 
about this topic, that within the python community, it is generally 
preferred and a good idea to use dot-notation. But how correct are they lol.


Thank you for reading,

Olliver