Is there a reason we don't import the entire sqlalchemy base?

Hey Chris Hummel, a good question! There are a few factors being balanced: code readability, code writing speed, and possible some minor execution speed.

• code readability: If the only import was import sqlalchemy, then every reference into that library would require the code to list the full path to the Class, method, or attribute. Using more direct import references places the names into the current module namespace for direct access. Less cluttered code is perhaps more readable.

# Using a simple import
import sqlalchemy

Base = sqlalchemy.ext.declarative.declarative_base()

class Book(Base):
    __tablename__ = "books"

    id = sqlachemy.Column(sqlachemy.Integer, primary_key = True)
    title = sqlalchemy.Column("Title", sqlachemy.String)

# Using more direct references allows direct access in module namespace
from sqlalchemy import (Column, Integer, String)
from sqlalchemy.ext.declarative import delclarative_base

Base = declarative_base()

class Book(Base):
    __tablename__ = "books"

    id = Column(Integer, primary_key = True)
    title = Column("Title", String)

Some argue code that using direct references that are too specific makes it necessary to scan the imports to determine whether an object with a simple reference is local to the module or has been imported.

• code writing speed. Certainly, only have to type a shorted reference to an imported object is better than having to type the full path to an import. Sometimes aliasing is used to short the names further: import numpy as np. Now only np is needed.

• code execution speed. Each time an object is referenced, it needs to be looked up in the various namespaces, local to global, then builtins, to find the object.

Take Column vs sqlalchemy.Column for example. If imported as from sqlachemy import Column then the look up would be: * looking for "Column" * look local to class Book * look global in current module (Found "Column")

If imported as import sqlachemy then the look up would be: *:looking for "sqlalchemy.Column" * look local to class Book * look global in current module (Found "sqlalchemy") * look in sqlalchemy (Found "Column")

The extra lookup into sqlalchemy for Column would happen every time the sqlalchemy.Column is referenced. So a minor speed up would occur by eliminating the extra lookup. This speed up is almost insignificant in this case. In cases where the "dot" referenced name is used in a large loop then the extra lookup steps would be repeated a significant number of times.

Each project or group may have their own style of importing. The best rule is to follow along the current style. If developing your own modules then you get to establish the style.

Post back if you have more questions. Good luck!!