1.
from sqlalchemy import create_engine
import os

if os.path.exists("something.db"):
    os.remove("something.db")
e = create_engine("sqlite:///something.db")
e.execute("""
    create table employee (
        emp_id integer primary key,
        emp_name varchar
    )
""")
e.execute("insert into employee (emp_name) values (:emp_name)", emp_name="dilbert")
result=e.execute("select * from employee").fetchall()
print(result)

-------------------------------------
2.
from sqlalchemy import *
tables_for_db = create_engine("sqlite:///something.db")
metaData1 = MetaData()
user_table = Table('user', metaData1,
                   Column('id', Integer, primary_key=True),
                   Column('name', String),
                   Column('fullname', String)
                   )

addresses_table = Table('address', metaData1,
                        Column('id', Integer, primary_key=True),
                        Column('email_address', String(100), nullable=False),
                        Column('user_id', Integer, ForeignKey('user.id'))
                        )

story_table = Table('story', metaData1,
                    Column('story_id', Integer, primary_key=True),
                    Column('version_id', Integer, primary_key=True),
                    Column('headline', Unicode(100), nullable=False),
                    Column('body', UnicodeText)
                    )

published_table = Table('published', metaData1,
                        Column('pub_id', Integer, primary_key=True),
                        Column('pub_timestamp', DateTime, nullable=False),
                        Column('story_id', Integer),
                        Column('version_id', Integer),
                        ForeignKeyConstraint(
                            ['story_id', 'version_id'],
                            ['story.story_id', 'story.version_id'])
                        )

network_table = Table('network', metaData1,
                      Column('network_id', Integer, primary_key=True),
                      Column('name', String(100), nullable=False),
                      Column('created_at', DateTime, nullable=False),
                      Column('owner_id', Integer, ForeignKey('user.id'))
                      )
metaData1.create_all(tables_for_db)
metaData2 = MetaData()
reflect = Table('user', metaData2, autoload=True, autoload_with=tables_for_db)
inspector = inspect(tables_for_db)
for column in inspector.get_columns('network'):
    print(column)
tableNames=inspector.get_table_names()
result = []
for table in tableNames:
   for column in inspector.get_columns(table):
       if column['name'] == 'story_id':
            result += table
print(set(result))

Результат

{'autoincrement': True, 'nullable': False, 'default': None, 'name': 'network_id', 'type': INTEGER(), 'primary_key': 1}
{'autoincrement': True, 'nullable': False, 'default': None, 'name': 'name', 'type': VARCHAR(length=100), 'primary_key': 0}
{'autoincrement': True, 'nullable': False, 'default': None, 'name': 'created_at', 'type': DATETIME(), 'primary_key': 0}
{'autoincrement': True, 'nullable': True, 'default': None, 'name': 'owner_id', 'type': INTEGER(), 'primary_key': 0}


----------------------------------------
3.
from sqlalchemy import *

metaData1 = MetaData()
third= create_engine("sqlite:///something.db")
connection = third.connect()

userTable = Table('username', metaData1,
                    Column('id', Integer, primary_key=True),
                    Column('username', String(50)),
                    Column('fullname', String(50))
                   )
print(userTable.columns)

addressTable = Table("address", metaData1,
                      Column('id', Integer, primary_key=True),
                      Column('username_id', Integer, ForeignKey('username.id'),
                             nullable=False),
                      Column('email_address', String(100), nullable=False)
                      )
metaData1.create_all(something)

connection.execute(addressTable.insert(), [
    {"user_id": 1, "email_address": "ed@ed.com"},
    {"user_id": 1, "email_address": "ed@gmail.com"},
    {"user_id": 2, "email_address": "jack@yahoo.com"},
    {"user_id": 3, "email_address": "wendy@gmail.com"},
])
print(userTable.c.fullname == 'ed')
print(and_(userTable.c.fullname == 'ed',userTable.c.id > 5))
print(or_(userTable.c.username == 'ed'))


result = connection.execute(userTable.insert().values(username='ed', fullname='Ed Jones'))
result.inserted_primary_key
connection.execute(userTable.insert(), [
    {'username': 'jack', 'fullname': 'Jack Burger'},
    {'username': 'wendy', 'fullname': 'Wendy Weathersmith'}
])
result = connection.execute(userTable.insert(), [
    {'username': 'dilbert',
     'fullname': 'Dilbert Jones'}
])
print(result.inserted_primary_key)
selected = select([userTable]).\
    where(or_(userTable.c.username == 'wendy',userTable.c.username == 'dilbert')).\
    order_by(userTable.c.fullname)
print(connection.execute(selected).fetchall())
text = select([userTable.c.fullname, addressTable.c.email_address]).\
    select_from(userTable.join(addressTable)).\
    where(userTable.c.username=='ed').\
    order_by(addressTable.c.email_address)
print(text)
result = userTable.update().values(fullname="Ed Jones").where(userTable.c.username == 'ed')
print(result)
connection.execute(userTable.delete())
connection.execute(addressTable.delete())

------------------------------------------
4.

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String,ForeignKey,Numeric
from sqlalchemy.orm import Session,relationship
from sqlalchemy import create_engine

engine = create_engine("sqlite:///something.db")
conn = engine.connect()

Base = declarative_base()

class Network(Base):
    __tablename__ = 'network'
    id = Column(Integer, primary_key=True)
    name = Column(String(100), nullable=False)
    def __repr__(self):
        return "Network: %r" % (self.name)
Base.metadata.create_all(engine)

from sqlalchemy.orm import Session
session = Session(bind = engine)
session.add(Network(name = 'net1'))
session.add(Network(name = 'net2'))
session.commit()
select_network = select([Network.__table__])
result = conn.execute(select_network)
print (result.fetchall())

class User(Base):
    __tablename__ = 'user'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    fullname = Column(String)
    def __repr__(self):
        return "<User(%r, %r)>" % (
                self.name, self.fullname
            )

session.add_all([
    User(name='wendy', fullname='Wendy Weathersmith'),
    User(name='mary', fullname='Mary Contrary'),
    User(name='fred', fullname='Fred Flinstone')
])

query = session.query(User.fullname).order_by(User.fullname)
print(query.all())

query2 = query.filter(User.name.in_(['mary', 'ed']))
query2.all()
print(query2[1])

query3 = session.query(User.name, Address.email_address).join(Address).filter(Address.email_address.in_(['j25@yahoo.com']))
print(query3.all())

class Account(Base):
    __tablename__ = 'account'
    id = Column(Integer, primary_key=True)
    owner = Column(String(50), nullable=False)
    balance = Column(Numeric, default=0)
    def __repr__(self):
        return "Account: %r, %r" % (self.owner, self.balance)

class Transaction(Base):
    __tablename__ = 'transaction'
    id = Column(Integer, primary_key=True)
    amount = Column(Numeric, nullable=False)
    account_id = Column(Integer, ForeignKey(Account.__tablename__ + '.id'), nullable=False)
    account = relationship('Account', backref="transactions")
    def __repr__(self):
        return "Transaction: %r" % (self.amount)

session = Session(bind = engine)
session.add_all([Account(owner = "Jack Jones", balance = 5000),
                 Account(owner="Ed Rendell", balance=10000),
                 Transaction(amount=500, account=account1),
                 Transaction(amount=4500, account=account1),
                 Transaction(amount=6000, account=account2),
                 Transaction(amount = 4000,  account = account2)])
session.commit()

for account in session.query(Account).all():
    owner = account.owner
    balance = account.balance
    spent_money = 0
    for account_transaction in account.transactions:
        spent_money += account_transaction.amount

    print("Account owner: " + str(owner) + '\t' +
          "Account balance: " + str(balance) + '\t' +
          "Spent money: " + str(spent_money))

Result:

Account owner: Jack Jones   Account balance: 5000.0000000000    Spent money: 5000.0000000000
Account owner: Ed Rendell   Account balance: 10000.0000000000   Spent money: 10000.0000000000