On 09Aug2023 12:30, Oliver Schinagl <oliver+pyt...@schinagl.nl> wrote:
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?
This is almost entirely a programmer preference thing.
The Zen, as usual, offers guideance but not dictates.
As you say, the module1.func form is very clear and has its beauty.
Personally I lean towards the single name flavour, sometimes with a
rename. FOr example, with os.path I often go:
from os.path import join as joinpath
and likewise for several other names from there, because the bare names
are very generic (eg "join"). I see to be alone here. Many other people
use:
import os.path
and use the full os.path.join in their code, which I find jarring and
visually noisy.
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).
PEP8 is for the stdlib source code; that said it is also the basis for
most Python coding styles in the wild.
For me, the Zen's "readability counts" is the most important guideline;
and to this end, your "module1.function" is an entirely reasonable
response, particularly if you've got a lot of imports. But it does make
for more verbose code, and that works against readability to a degree.
This is why it's all subjective.
Particular workplaces may mandate particular styles, but in your
personal code? Do what seem best, and experience will cause that to
evolve over time.
Also, the style can depend on the code you're working on. For a small
module with few imports the:
from module1 import funcname
can be a win because the code is short, and this short form of funcname
is both clear and readable. But in a very long piece of code with many
imports you might go for module1.funcname for clarity, particularly if
funcname is generic or overlaps with another similar imported name.
Cheers,
Cameron Simpson <c...@cskk.id.au>
--
https://mail.python.org/mailman/listinfo/python-list
