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

Oliver Schinagl <oliver+python@schinagl.nl> writes:
>Simply put, which of the two would be considered cleaner and
>more pythonic?

I'm not sure what "clean" or "pythonic" means here.

To me, the canonical import is

import math
print( math.sin( 0 ))

, because "math.sin" shows where "sin" does come from.
This is valid for production code.

For tiny code examples it might look nicer to use

from math import sin
print( sin( 0 ))

, but I would try to avoid

from math import sin as sine
print( sine( 0 ))

because it hides the common name of the object.

When there is a nested module,

import tkinter.messagebox
tkinter.messagebox.showinfo( "ok.", "It's alright." )

, as this won't work:

import tkinter
tkinter.messagebox.showinfo( "ok.", "It's alright." )

. But for small code examples:

from tkinter.messagebox import showinfo
showinfo( "ok.", "It's alright." )

.