I've been asking myself questions for some time now. If I have to distribute an application that uses large libraries, or frameworks, can I afford to import the entire library or framework, and call the modules when I need them, for example:

import os

import nltk

import codecs

import json

import collections

import flask



#e.g.

json.load(json_data)

collection.Counter(aList)

nltk.word_tokenize(sentence)

codecs.open(aFile)

os.listdir(aPath)

or otherwise it is better to import only the necessary modules, in order to promote lightness and performance, for example:

from collections import Counter

from flask import request, Flask, render_template, redirect, url_for

from nltk.data import load

from nltk import word_tokenize

from nltk.corpus import stopwords.words as stopW

from os import listdir

It makes me very curious to know which is the best solution when we aim to distribute an application on any platform (whether desktop, mobile, or web based).
Thank you very much in advance.

First wonder

It depends what you want to achieve. Take an example: If you have a big pile of code like 500 lines it's easier for readability if you import "module" for instance

import myscript

and 400 lines later when you need to use the function from myscript you need to write

myscript.somefunction()

now it's easier to read your code because you already know from where is this function come from.

Because in the second scenario if you import

from myscript import somefunction

you would write

somefunction()

Which is harder to diagnose from where this function came from if you have 5 and more imports like that

Another discuss about first wonder

Second wonder

In your example you show something like

from flask import request, Flask, render_template, redirect, url_for

and I would stick with that because of one big advantage, if you import the whole module like that

import flask

you could forget or by accident create function that already exists in the flask for instance:

def request():

    pass

and this would overwrite your imported function and give you a nice headache because now this function returns nothing.

Performance

In both situation as Thomas said entire module needs to be imported so in both situations performance should be the same.

Summary

For libraries, I would choose to from module import function most of the times. Except for some libraries like numpy because I never saw this library imports in a different way than:

import numpy as np

And it's really convenient because it's easier to read your code for somebody else and vice versa.

But if I import many own scripts I would choose to

import myscript

because it's easier to understand from where this function comes from and function can have the same name in different scripts. But as I said it's my opinion and I think it's quite a convenient way. But if you would like to do it differently go ahead :)