這兩個模塊可以直接通過pip安裝：

打開mysql創建幾個表：

CREATE TABLE `student_age`(
    `id` int not null,
    `age` int not null,
    `sex` ENUM(‘M‘, ‘F‘) not null,
    PRIMARY KEY(`id`)
);

INSERT INTO student_age(id, age, sex) VALUES(1, 18, ‘M‘), (2, 26, ‘M‘), (3, 20, ‘F‘);

CREATE TABLE `student_name`(
    `id` int not null auto_increment,
    `name` varchar(10) not null default ‘‘,
    `stu_id` int not null,
    PRIMARY KEY(`id`),
    FOREIGN KEY(`stu_id`) REFERENCES `student_age`(`id`)
);

INSERT INTO student_name(name, stu_id) VALUES(‘Jack‘, 1), (‘Eric‘, 2), (‘Alice‘, 3);

pymysql基本連接示例：

import pymysql

#建立管道
conn = pymysql.connect(host=‘127.0.0.1‘, port=3306, user=‘root‘, passwd=‘123456‘, db=‘test‘)
#創建遊標
cursor = conn.cursor()

effect_rows = cursor.execute(‘SELECT * FROM student_name‘)

print(‘rows[%d]‘ % effect_rows, cursor.fetchall())

#關閉連接
conn.close()

　　pymysql插入數據和事物的效果一樣，可以實現回滾，自增id占用，必須提交才會生效：

import pymysql, time

#設置數據庫連接參數
host = ‘localhost‘
port = 3306
user = ‘root‘
passwd = ‘123456‘
db = ‘test‘

#創建通道
conn = pymysql.connect(host=host, port=port, user=user, passwd=passwd, db=db)
#創建遊標
cursor = conn.cursor()
#寫sql語句
sql = "INSERT INTO student_age(id, age, sex) VALUES(4, 21, ‘F‘)"
#執行sql語句
effect_row = cursor.execute(sql)
#打印影響行
print(effect_row)
time.sleep(30)
#提交數據
conn.commit()
#關閉通道
conn.close()

　　orm操作數據庫新建一張表：

‘‘‘
對象關系映射（英語：(Object Relational Mapping，簡稱ORM，或O/RM，或O/R mapping），是一種程序技術，用於實現面向對象編程語言裏不同類型系統的數據之間的轉換  。從效果上說，它其實是創建了一個可在編程語言裏使用的--“虛擬對象數據庫”。
‘‘‘
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String

engine = create_engine("mysql+pymysql://root:123456@localhost/test", encoding="utf-8", echo=True)

#生成orm基類
Base = declarative_base()

class User(Base):
    #表名
    __tablename__ = ‘user‘
    id = Column(Integer, primary_key=True)
    name = Column(String(32))
    password = Column(String(64))

#創建表結構
Base.metadata.create_all(engine)

　　新增數據：

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import sessionmaker
#創建工程
engine = create_engine("mysql+pymysql://root:123456@localhost/test", encoding=‘utf-8‘, echo=True)
#創建基本處理類
Base = declarative_base()
#
class User(Base):
    #表名
    __tablename__ = ‘user‘
    id = Column(Integer, primary_key=True)
    name = Column(String(32))
    password = Column(String(64))
    
#綁定要操作的數據庫
Session_class = sessionmaker(bind=engine)
#類似於創建遊標
Session = Session_class()
obj1 = User(id=1, name=‘summer‘, password=‘111111‘)
#加入會話任務列表
session.add(obj1)
#此時數據還未真正寫入
print(obj1.id, obj1.name, obj1.password)
#寫入數據庫
session.commit()

　　查詢和格式化輸出：

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy import func
#創建工程
engine = create_engine("mysql+pymysql://root:123456@localhost/test", encoding=‘utf8‘)
#創建基本處理類
Base = declarative_base()
#
class User(Base):
    #表名
    __tablename__ = ‘user‘
    id = Column(Integer, primary_key=True)
    name = Column(String(32))
    password = Column(String(64))
    
    #格式化輸出查詢結果
    def __repr__(self):
        return "<%s name:%s>" % (self.id, self.name)
    
#綁定要操作的數據庫
Session_class = sessionmaker(bind=engine)
#類似於創建遊標
Session = Session_class()
#查詢
# data = Session.query(User).all()    #查詢全部

#條件查詢
data = Session.query(User).filter(User.id>1).first()   #獲取第一個
#修改
data.name = ‘Tom‘
data = Session.query(User).filter(User.id>1).first()
#撤銷操作
# Session.rollback()
# print(‘after rollback‘)
# data = Session.query(User).filter(User.id>1).first()

#提交之後才會作用到數據庫，和mysql事務的的效果一樣
# Session.commit()

# data = Session.query(User).filter(User.id>1).filter(User.id<4).all()  #獲取區間數據

#統計
data = Session.query(User).filter(User.name.in_([‘Eric‘, ‘Alice‘])).count()

#分組查詢
data = Session.query(func.count(User.name), User.name).group_by(User.name).all()
print(data)
#沒有重寫__repr__之前的訪問方式
# print(data[0].id, data[0].name, data[0].password)

　　外鍵表的創建：

"""
外鍵表的創建：
學生表students
課程表days
簽到表records，關聯學生和課程表
"""
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, Enum

#創建工程
engine = create_engine("mysql+pymysql://root:123456@localhost/test", encoding=‘utf-8‘)
#創建基類
Base = declarative_base()

#創建表結構
class Student(Base):
    __tablename__ = ‘students‘
    id = Column(Integer, nullable=False, primary_key=True)
    name = Column(String(10), nullable=False)
    sex = Column(Enum(‘F‘, ‘M‘))
    
    def __repr__(self):
        return "<id:%s name:%s>" % (self.id, self.name)

class Days(Base):
    __tablename__ = ‘days‘
    id = Column(Integer, nullable=False, primary_key=True)
    content = Column(String(32), nullable=False)
    
    def __repr__(self):
        return "<day_id:%s content:%s>" % (self.id, self.content)
    
class Record(Base):
    __tablename__ = ‘records‘
    id = Column(Integer, nullable=False, primary_key=True)
    stu_id = Column(Integer, ForeignKey("students.id"), nullable=False)
    day_id = Column(Integer, ForeignKey("days.id"), nullable=False)
    status = Column(Enum("Yes", "No"))
    
    def __repr__(self):
        return "<id:%s status:%s>" % (self.id, self.status)

#生成表
Base.metadata.create_all(engine)

　　外鍵表的數據插入：

"""
外鍵表的創建：
學生表students
課程表days
簽到表records，關聯學生和課程表
"""
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, Enum

#創建工程
engine = create_engine("mysql+pymysql://root:123456@localhost/test", encoding=‘utf-8‘)
#創建基類
Base = declarative_base()

#創建表結構
class Student(Base):
    __tablename__ = ‘students‘
    id = Column(Integer, nullable=False, primary_key=True)
    name = Column(String(10), nullable=False)
    sex = Column(Enum(‘F‘, ‘M‘))
    
    def __repr__(self):
        return "<id:%s name:%s>" % (self.id, self.name)

class Days(Base):
    __tablename__ = ‘days‘
    id = Column(Integer, nullable=False, primary_key=True)
    content = Column(String(32), nullable=False)
    
    def __repr__(self):
        return "<day_id:%s content:%s>" % (self.id, self.content)
    
class Record(Base):
    __tablename__ = ‘records‘
    id = Column(Integer, nullable=False, primary_key=True)
    stu_id = Column(Integer, ForeignKey("students.id"), nullable=False)
    day_id = Column(Integer, ForeignKey("days.id"), nullable=False)
    status = Column(Enum("Yes", "No"))
    
    def __repr__(self):
        return "<id:%s status:%s>" % (self.id, self.status)

#生成表
Base.metadata.create_all(engine)

　　外鍵表的關聯查詢：

"""
外鍵關聯查詢
"""
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import Column, Integer, String, Enum, ForeignKey

#創建工程
engine = create_engine("mysql+pymysql://root:123456@localhost/test", encoding=‘utf-8‘)
#創建基類
Base = declarative_base()
#創建表結構
class Students(Base):
    __tablename__ = ‘students‘
    id = Column(Integer, nullable=False, primary_key=True)
    name = Column(String(10), nullable=False)
    sex = Column(Enum(‘F‘, ‘M‘))
    
    def __repr__(self):
        return "<id:%s name:%s>" % (self.id, self.name)
    
class Days(Base):
    __tablename__ = ‘days‘
    id = Column(Integer, nullable=False, primary_key=True)
    content = Column(String(32), nullable=False)
    
    def __repr__(self):
        return "<id:%s content:%s>" % (self.id, self.content)

class Records(Base):
    __tablename__ = ‘records‘
    id = Column(Integer, nullable=False, primary_key=True)
    stu_id = Column(Integer, ForeignKey("students.id"), nullable=False)
    day_id = Column(Integer, ForeignKey("days.id"), nullable=False)
    status = Column(Enum("Yes", "No"))
    students = relationship("Students", backref="students_records")
    days = relationship("Days", backref="days_records")
    def __repr__(self):
        return "<name:%s content:%s status:%s>" % (self.students.name, self.days.content, self.status)

#生成表
Base.metadata.create_all(engine)
#創建會話
Session_class = sessionmaker(bind=engine)
#創建遊標
session = Session_class()
data = session.query(Students).filter(Students.name==‘Eric‘).first()
print(data.students_records)

　　兩個外鍵關聯到同一張表：

"""
兩個外鍵關聯到同一張表
"""
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, String, Integer, ForeignKey
from sqlalchemy.orm import relationship

engine = create_engine("mysql+pymysql://root:123456@localhost/test", encoding=‘utf-8‘)
Base = declarative_base()

class Address(Base):
    __tablename__ = ‘address‘
    id = Column(Integer, primary_key=True, nullable=False)
    province = Column(String(10), nullable=True)
    city = Column(String(10), nullable=True)
    
class Users(Base):
    __tablename__ = ‘users‘
    id = Column(Integer, primary_key=True, nullable=False)
    name = Column(String(10), nullable=True)
    first_addr_id = Column(Integer, ForeignKey(‘address.id‘))
    second_addr_id = Column(Integer, ForeignKey(‘address.id‘))
    first_addr = relationship("Address", foreign_keys=[first_addr_id])
    second_addr = relationship("Address", foreign_keys=[second_addr_id])
    
    def __repr__(self):
        return "<name %s address %s %s>" % (self.name, self.first_addr.province, self.second_addr.province)
    
Base.metadata.create_all(engine)

　　寫入數據：

"""
往表中寫入數據
"""
import ex5_1
from sqlalchemy.orm import sessionmaker

Session_class = sessionmaker(bind=ex5_1.engine)
session = Session_class()

add1 = ex5_1.Address(province=‘HeNan‘, city=‘NanYang‘)
add2 = ex5_1.Address(province=‘HeBei‘, city=‘HanDan‘)
add3 = ex5_1.Address(province=‘HuNan‘, city=‘YueYang‘)

session.add_all([add1, add2, add3])

user1 = ex5_1.Users(name=‘Eric‘, first_addr=add1, second_addr=add2)
user2 = ex5_1.Users(name=‘Alice‘, first_addr=add2, second_addr=add3)
user3 = ex5_1.Users(name=‘Peter‘, first_addr=add3, second_addr=add1)

session.add_all([user1, user2, user3])
session.commit()

　　查詢：

import ex5_1

data = ex5_1.session.query(ex5_1.Users).filter(ex5_1.Users.name==‘Eric‘).first()
print(data)

　　多對多外鍵：

#創建表
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, String, Integer, DATE, Table, ForeignKey
from sqlalchemy.orm import relationship

engine = create_engine("mysql+pymysql://root:123456@localhost/test", encoding=‘utf-8‘)

Base = declarative_base()

book_m2m_author = Table(
    ‘book_m2m_author‘,
    Base.metadata,
    Column(‘book_id‘, Integer, ForeignKey(‘books.id‘)),
    Column(‘author_id‘, Integer, ForeignKey(‘authors.id‘))
)

class Books(Base):
    __tablename__ = ‘books‘
    id = Column(Integer, primary_key=True, nullable=True)
    book_name = Column(String(20), nullable=False)
    publish_time = Column(DATE)
    #創建到authors表的映射，關聯關系表book_m2m_author，回查字段books
    authors = relationship("Authors", secondary=book_m2m_author, backref="books")
    
    def __repr__(self):
        return "<book_name:%s>" % self.book_name
    
class Authors(Base):
    __tablename__ = ‘authors‘
    id = Column(Integer, primary_key=True, nullable=True)
    author_name = Column(String(20), nullable=False)
    def __repr__(self):
        return "<author_name:%s>" % self.author_name

Base.metadata.create_all(engine)

　　創建數據：

#插入數據
import ex6_1
from sqlalchemy.orm import sessionmaker

#創建會話
Session_class = sessionmaker(bind=ex6_1.engine)
Session = Session_class()

b1 = ex6_1.Books(book_name=‘C++ primer plus‘)
b2 = ex6_1.Books(book_name=‘Python‘)
b3 = ex6_1.Books(book_name=‘Java‘)
a1 = ex6_1.Authors(author_name=‘Eric‘)
a2 = ex6_1.Authors(author_name=‘Alice‘)
a3 = ex6_1.Authors(author_name=‘James‘)

b1.authors = [a1, a2]
b2.authors = [a2, a3]
b3.authors = [a3, a1]

Session.add_all([b1, b2, b3, a1, a2, a3])
Session.commit()

　　關聯查詢和刪除操作：

#查詢數據
import ex6_1
from sqlalchemy.orm import sessionmaker

Session_class = sessionmaker(bind=ex6_1.engine)
Session = Session_class()

data = Session.query(ex6_1.Books).filter(ex6_1.Books.book_name==‘Python‘).first()
print("book_name:%s author:%s" % (data, data.authors))

#刪除數據時不用管book_m2m_author，sqlalchemy會自動刪除

#通過書刪除作者
# book_obj = Session.query(ex6_1.Books).filter(ex6_1.Books.book_name==‘Python‘).first()
# author_obj = Session.query(ex6_1.Authors).filter(ex6_1.Authors.author_name==‘James‘).first()
# book_obj.authors.remove(author_obj)

#刪除作者時，會把這個作者跟所有書的關聯關系數據也自動刪除
data = Session.query(ex6_1.Authors).filter(ex6_1.Authors.author_name==‘Eric‘).first()
#從authors裏面刪除這個作者，並從book_m2m_author裏面所有書中刪除這個作者
Session.delete(data)

#提交修改到數據庫
Session.commit()

pymysql和sqlalchemy模塊操作mysql數據庫