On 06/19/2015 11:41 PM, James Schneider wrote: > This is strictly a Python question, nothing Django-specific, but I've > found this site to be helpful in explaining the different ways to import > things: > > http://effbot.org/zone/import-confusion.htm
This is good as far as it goes, but it is also quite old, and thus
doesn't cover explicit relative imports at all (because they didn't
exist yet when it was written).
> In general, using 'from blah import *' is frowned upon except in very
> specific cases. While it is easier up front, it makes the code hard to
> read later on, since you aren't explicitly dating where the functions or
> classes you are using are coming from.
>
> In general, you'll want to be as specific as possible when importing
> things to keep your code clean and easy to read, even if it does make it
> a bit longer.
>
> For example:
>
> from CatAppA import *
> from CatAppB import *
>
> my_cat = get_cat('Katy Purry')
>
> If we were inspecting this code, we wouldn't know whether or not
> get_cat() comes from CatApp A or B, which makes troubleshooting more
> difficult, especially if both apps (or modules) define a get_cat()
> function. It would be much better to say:
>
> from CatAppA import get_cat
> from CatAppB import say_meow
>
> my_cat = get_cat('Katy Purry')
>
> Now we know that get_cat() comes from CatAppA.
Yes, that's a great description of the reason to avoid `import *`.
> The other aspect to consider is memory use. If a module defines 500
> functions, doing 'import modulename' will load all 500 in memory, rather
> than just picking out the one or two you might use.
This isn't true. When you first import a module (no matter what syntax
you use), its full code is executed, resulting in a module object with
all of its top-level objects and attributes defined, which is placed
into the `sys.modules` dictionary. So every function or class defined in
the module will be in memory no matter what.
The import syntax you use determines only which functions/objects you
get references to in the current module, it doesn't change memory usage
at all.
(Not to mention that, apart from extreme cases, memory usage of your
code objects themselves will be negligible compared to your data.)
> Aside from that, all of your references would be prefixed with
> 'modulename', which may or may not make the code more readable.
This isn't related to `import *`, it depends on the distinction between
from somemodule import some_func
vs
import somemodule
In the latter case, you would use `somemodule.some_func` in your code;
in the former you'd use `some_func`. Both of those are equally explicit;
the choice between them is really a matter of preference, conciseness,
and avoiding naming clashes. If I am using only one or two things from a
module (especially if I am using them many times), I'll usually use
`import from` to make the references shorter. If I am using many things
from the module, I'll prefer the latter form (and sometimes shorten the
module name with an alias, via `import somemodule as sm`).
> In general, I import everything explicitly, and I use relative import
> paths for imports in files that are in the same directory:
>
> from .models import Cat
>
> Yes, it makes my import lines much longer, but having them more explicit
> makes the code much easier to read on larger chunks of code.
>
> There it's some contention as to whether or not to use relative imports,
> some devs prefer to use the more explicit appname.models version. Both
> do the same thing.
>
> Check out the Django source code to see how they handle imports, and
> definitely look at PEP8:
>
> https://www.python.org/dev/peps/pep-0008/#imports
Good advice; PEP 8 gives useful guidance on these questions.
Carl
--
You received this message because you are subscribed to the Google Groups
"Django users" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to django-users+unsubscr...@googlegroups.com.
To post to this group, send email to django-users@googlegroups.com.
Visit this group at http://groups.google.com/group/django-users.
To view this discussion on the web visit
https://groups.google.com/d/msgid/django-users/55876B8F.70705%40oddbird.net.
For more options, visit https://groups.google.com/d/optout.
signature.asc
Description: OpenPGP digital signature
