python-day45_MySQL数据库5_面向对象

1，函数编程：数据和逻辑分离

　　a= 123
　　b = 456
　　c = 789

　　def exc3(proc_name):
　　　　callproc(xxx)
　　　　return xxx

　　def exc4(proc_name):
　　　　callproc(xxx)
　　　　return xxx

2，面向对象：数据和逻辑（属性和行为）组合在一起
　　class SqlHelper:
　　　　def __init__(self):
　　　　self.host = ''
　　　　self.port =''
　　　　self.db =''
　　　　self.charset=''

　　def exc1(self,SQL):
　　　　# 连接
　　　　conn(self.host,)
　　　　execute("inser")
　　　　return xx

　　def exc2(self,proc_name):
　　　　callproc(xxx)
　　　　return xxx

　　1. 提取共性
　　2. 分类
　　3. 模板“约束”
　　4. 当一类函数公用同样参数时候，可以转变成类进行 - 分类

3，分类示例：
　　类 = 表；对象=行

　　class Userinfo:

　　　　def __init__(self,id,name):
　　　　""" ‘约束’每个对象中只有两个字段，即：每个行数据都有id和name列"""
　　　　　　self.id = id
　　　　　　self.name= name
　　　　def add(self,name):
　　　　　　pass

# row1 = UserInfo(1,'alex') # 第一行
# row2 = UserInfo(2,'alex') # 第二行

4，特殊方法：
class Foo:
　　def __init__(self,name):
　　　　self.name = name

　　def show(self):
　　　　print(self.name)

　　def __call__(self):
　　　　pass

　　def __getitem__(self,key):
　　　　pass

　　def __setitem__(self,key,value):
　　　　pass

　　def __delitem__(self,key):
　　　　pass

obj1 = Foo('eric')

obj1()　　#调用__call__方法
obj1['k']　　#调用__getitem__方法
obj1['k'] = 123　　#调用__setitem__方法
del obj[k]　　#调用__delitem__方法
obj.__dict__

5. ORM框架：SQLAlchemy
　　- 作用：
　　　　1. 提供简单的规则
　　　　2. 自动转换成SQL语句

　　- DB first: 手动创建数据库以及表　　 -> 通过ORM框架　　-> 自动生成类
　　- code first：手动创建类、和数据库　　 -> 通过ORM框架　　 -> 以及表

　　a. 功能
　　　　- 创建数据库表
　　　　- 连接数据库（非SQLAlchemy,pymyql,mysqldb,....）
　　　　- 类转换SQL语句
　　　　- 操作数据行
　　　　　　增
　　　　　　删
　　　　　　改
　　　　　　查

　　　　- 便利的功能

　　2. 自己开发Web框架
　　　　- socket
　　　　- http协议
　　　　- HTML知识
　　　　- 数据库（pymysql，SQLAlchemy）

6，

　　SQLAlchemy是Python编程语言下的一款ORM框架，该框架建立在数据库API之上，使用关系对象映射进行数据库操作，简言之便是：将对象转换成SQL，然后使用数据API执行SQL并获取执行结果。

　　安装sqlAlchemy模块：pip install flask-SQLAlchemy

从代码 > 表。

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index,CHAR,VARCHAR
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine

Base = declarative_base()

class UserType(Base):
    __tablename__='usertype'
    id = Column(Integer,primary_key=True,autoincrement=True)
    title=Column(VARCHAR(32),nullable=True,index=True)

class Users(Base):
    __tablename__='users'
    id=Column(Integer,primary_key=True,autoincrement=True)
    name = Column(VARCHAR(32),nullable=True,index=True)
    email = Column(VARCHAR(16),unique=True)
    user_type_id = Column(Integer,ForeignKey('usertype.id'))

def create_db():
    engine = create_engine('mysql+pymysql://alex:[email protected]:3306/py_day43?charset=utf8',max_overflow=5)
    Base.metadata.create_all(engine)

def drop_db():
    engine = create_engine('mysql+pymysql://alex:[email protected]:3306/py_day43?charset=utf8',max_overflow=5)
    Base.metadata.drop_all(engine)

engine = create_engine('mysql+pymysql://alex:[email protected]:3306/py_day43?charset=utf8',max_overflow=5)
Session =sessionmaker(bind=engine)
session = Session()

create_db()
# drop_db()

session.commit()
session.close()

类 ->表，对象 -> 行

　　增

# obj1 = UserType(title='普通用户')
# session.add(obj1)        #增加一行

objs = [
    UserType(title='超级用户'),
    UserType(title='白金用户'),
    UserType(title='黑金用户')
]
session.add_all(objs)       #增加多行

　　删

session.query(UserType).filter(UserType.id>2).delete()

　　改

session.query(UserType.id,UserType.title).filter(UserType.id>0).update({'title':'黑金'})
session.query(UserType).filter(UserType.id>0).update({UserType.title:UserType.title+'X'},synchronize_session=False)
session.query(UserType).filter(UserType.id>0).update({'num':UserType.num+1},synchronize_session='evaluate')

　　查

print(session.query(UserType))  #代表SQL语句
print(session.query(UserType).all())    #执行SQL语句后的查询结果
user_type_list = session.query(UserType).all()
for row in user_type_list:
    print(row.id,row.title) #每一行，为一个对象，表中有多少行，就有多少个对象。将行取出并打印

# select xxx  UserType where
user_type_list = session.query(UserType.id,UserType.title).filter(UserType.id>2)    # filter代表WHERE
for row in user_type_list:
    print(row.id,row.title)

　　其它

条件
ret = session.query(Users).filter_by(name='alex').all()
ret = session.query(Users).filter(Users.id > 1, Users.name == 'eric').all()
ret = session.query(Users).filter(Users.id.between(1, 3), Users.name == 'eric').all()
ret = session.query(Users).filter(Users.id.in_([1,3,4])).all()
ret = session.query(Users).filter(~Users.id.in_([1,3,4])).all()
ret = session.query(Users).filter(Users.id.in_(session.query(Users.id).filter_by(name='eric'))).all()

与 或:
from sqlalchemy import and_, or_
ret = session.query(Users).filter(and_(Users.id > 3, Users.name == 'eric')).all()
ret = session.query(Users).filter(or_(Users.id < 2, Users.name == 'eric')).all()
ret = session.query(Users).filter(
    or_(
        Users.id < 2,
        and_(Users.name == 'eric', Users.id > 3),
        Users.extra != ""
    )).all()

通配符 非:
ret = session.query(Users).filter(Users.name.like('e%')).all()
ret = session.query(Users).filter(~Users.name.like('e%')).all()

限制:
ret = session.query(Users)[1:2]

排序:
ret = session.query(Users).order_by(Users.name.desc()).all()
ret = session.query(Users).order_by(Users.name.desc(), Users.id.asc()).all()

分组:
from sqlalchemy.sql import func

ret = session.query(Users).group_by(Users.extra).all()
ret = session.query(
    func.max(Users.id),
    func.sum(Users.id),
    func.min(Users.id)).group_by(Users.name).all()

ret = session.query(
    func.max(Users.id),
    func.sum(Users.id),
    func.min(Users.id)).group_by(Users.name).having(func.min(Users.id) >2).all()

连表:
ret = session.query(Users, Favor).filter(Users.id == Favor.nid).all()
ret = session.query(Person).join(Favor).all()    #默认是inner join
ret = session.query(Person).join(Favor, isouter=True).all()    #加上isouter=true,就改为left join。left join就是left outer join的简写
示例：

user_list = session.query(Users,UserType).join(UserType,isouter=True)
print(user_list)
for row in user_list:
    print(row[0].id,row[0].name,row[0].email,row[0].user_type_id,row[1].title)    #ro[0]是Users表，ro[1]是UserType表





组合:
q1 = session.query(Users.name).filter(Users.id > 2)
q2 = session.query(Favor.caption).filter(Favor.nid < 2)
ret = q1.union(q2).all()

q1 = session.query(Users.name).filter(Users.id > 2)
q2 = session.query(Favor.caption).filter(Favor.nid < 2)
ret = q1.union_all(q2).all()

子查询：

7，

class Users(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(VARCHAR(32), nullable=True, index=True)
    email = Column(VARCHAR(16), unique=True)
    user_type_id = Column(Integer,ForeignKey("usertype.id"))

    user_type = relationship("UserType")    #relationship指当前表的行，与外键的行关联起来，当前表被操作时，外键数据会一起输出显示。正向操作

#用调用外键方式一
user_list = session.query(Users,UserType).join(UserType,isouter=True) #没有使用relationship时，调用外键的代码
print(user_list)
for row in user_list:
print(row[0].id,row[0].name,row[0].email,row[0].user_type_id,row[1].title)

#用调用外键方式二
user_list = session.query(Users) #在Users类中使用relationship时，可操作外键数据，代码比用SQL语句调用外键要少
print(user_list)
for row in user_list:
print(row.id,row.name,row.email,row.user_type_id,row.user_type.title)

8，

class Users(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(VARCHAR(32), nullable=True, index=True)
    email = Column(VARCHAR(16), unique=True)
    user_type_id = Column(Integer,ForeignKey("usertype.id")) user_type = relationship("UserType",backref='xxoo') #backref指在操作外键的表时，当前表的行会被关联。反向操作

type_list = session.query(UserType)
for row in type_list:
print(row.id,row.title,session.query(Users).filter(Users.user_type_id == row.id).all())

type_list = session.query(UserType)
for row in type_list:
print(row.id,row.title,row.xxoo) #当在Users类中的relationship增加backref='xxoo'。本段代码输出跟上面的代码输出是一样的

python-day45_MySQL数据库5_面向对象

猜你喜欢