python之ORM的使用

Posted 2020-11-20 柒月不哭

---恢复内容开始---

1.ORM是什么？

orm就是对象映射关系程序，简单来世就是类似于python这种面向对象的程序来说一切接对象，它可以将我们平常所使用的SQL语句，转换成可以使用对象模型进行操作的模块，而不是直接使用SQL语句。

2.sqlalchemy的安装

在python中这个模块时最有名的，使用的人较多。

 通过PIP 安装：

　　

1 pip install SQLALchemy<br><br>pip install pymysql 
2  #由于mysqldb依然不支持py3，所以这里我们用pymysql与sqlalchemy交互

3.sqlalchemy基本使用

最开始我们创建一张数据表如下：

1 CREATE TABLE user (
2     id INTEGER NOT NULL AUTO_INCREMENT, 
3     name VARCHAR(32), 
4     password VARCHAR(64), 
5     PRIMARY KEY (id)
6 )

这是最简单的SQL表如果再加上外键什么的，那就更加复杂了，所以就有了我们的sqlalchemy!

 1 import sqlalchemy
 2 from sqlalchemy import create_engine
 3 from sqlalchemy.ext.declarative import declarative_base
 4 from sqlalchemy import Column, Integer, String
 5  
 6 engine = create_engine("mysql+pymysql://root:[email protected]/testdb",
 7                                     encoding=‘utf-8‘, echo=True)
 8  
 9  
10 Base = declarative_base() #生成orm基类
11  
12 class User(Base):
13     __tablename__ = ‘user‘ #表名
14     id = Column(Integer, primary_key=True)
15     name = Column(String(32))
16     password = Column(String(64))
17  
18 Base.metadata.create_all(engine) #创建表结构

看到这里你可能感觉不出什么，那是因为现在实现的功能比较简单，但是当功能复杂以后，你就会发现这个东西的好处。

除上面的创建之外，还有一种创建表的方式，虽不常用，但还是看看吧

 

---恢复内容结束---

1.ORM是什么？

orm就是对象映射关系程序，简单来世就是类似于python这种面向对象的程序来说一切接对象，它可以将我们平常所使用的SQL语句，转换成可以使用对象模型进行操作的模块，而不是直接使用SQL语句。

2.sqlalchemy的安装

在python中这个模块时最有名的，使用的人较多。

 通过PIP 安装：

　　

1 pip install SQLALchemy<br><br>pip install pymysql 
2  #由于mysqldb依然不支持py3，所以这里我们用pymysql与sqlalchemy交互

3.sqlalchemy基本使用

最开始我们创建一张数据表如下：

1 CREATE TABLE user (
2     id INTEGER NOT NULL AUTO_INCREMENT, 
3     name VARCHAR(32), 
4     password VARCHAR(64), 
5     PRIMARY KEY (id)
6 )

这是最简单的SQL表如果再加上外键什么的，那就更加复杂了，所以就有了我们的sqlalchemy!

 1 import sqlalchemy
 2 from sqlalchemy import create_engine
 3 from sqlalchemy.ext.declarative import declarative_base
 4 from sqlalchemy import Column, Integer, String
 5  
 6 engine = create_engine("mysql+pymysql://root:[email protected]/testdb",
 7                                     encoding=‘utf-8‘, echo=True)
 8  
 9  
10 Base = declarative_base() #生成orm基类
11  
12 class User(Base):
13     __tablename__ = ‘user‘ #表名
14     id = Column(Integer, primary_key=True)
15     name = Column(String(32))
16     password = Column(String(64))
17  
18 Base.metadata.create_all(engine) #创建表结构

看到这里你可能感觉不出什么，那是因为现在实现的功能比较简单，但是当功能复杂以后，你就会发现这个东西的好处。

这里还有一种创建表的方式，但是不常用

 1 from sqlalchemy import Table, MetaData, Column, Integer, String, ForeignKey
 2 from sqlalchemy.orm import mapper
 3  
 4 metadata = MetaData()
 5  
 6 user = Table(‘user‘, metadata,
 7             Column(‘id‘, Integer, primary_key=True),
 8             Column(‘name‘, String(50)),
 9             Column(‘fullname‘, String(50)),
10             Column(‘password‘, String(12))
11         )
12  
13 class User(object):
14     def __init__(self, name, fullname, password):
15         self.name = name
16         self.fullname = fullname
17         self.password = password
18  
19 mapper(User, user) #the table metadata is created separately with the Table construct, then associated with the User class via the mapper() function

其实第一种就是第二种创建表方式的一种封装

现在来创建一条数据试试

Session_class = sessionmaker(bind=engine) #创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
Session = Session_class() #生成session实例
 
 
user_obj = User(name="alex",password="alex3714") #生成你要创建的数据对象
print(user_obj.name,user_obj.id)  #此时还没创建对象呢，不信你打印一下id发现还是None
 
Session.add(user_obj) #把要创建的数据对象添加到这个session里， 一会统一创建
print(user_obj.name,user_obj.id) #此时也依然还没创建
 
Session.commit() #现此才统一提交，创建数据

 

查询：

1 my_user = Session.query(User).filter_by(name="alex").first()
2 print(my_user)

 

他输出的是：

<__main__.User object at 0x105b4ba90>

他返回的是一个对象，所以是这个样子，你可以通过调出他里面对象的方式来显示。

1 print(my_user.id,my_user.name,my_user.password)
2  
3 输出
4 1 alex alex3714

 不过刚才上面的显示的内存对象对址你是没办法分清返回的是什么数据的，除非打印具体字段看一下，如果想让它变的可读，只需在定义表的类下面加上这样的代码

def __repr__(self):
    return "<User(name=‘%s‘,  password=‘%s‘)>" % (
        self.name, self.password)

修改

1 my_user = Session.query(User).filter_by(name="alex").first()
2  
3 my_user.name = "Alex Li"
4  
5 Session.commit()

回滚

 1 my_user = Session.query(User).filter_by(id=1).first()
 2 my_user.name = "Jack"
 3  
 4  
 5 fake_user = User(name=‘Rain‘, password=‘12345‘)
 6 Session.add(fake_user)
 7  
 8 print(Session.query(User).filter(User.name.in_([‘Jack‘,‘rain‘])).all() )  #这时看session里有你刚添加和修改的数据
 9  
10 Session.rollback() #此时你rollback一下
11  
12 print(Session.query(User).filter(User.name.in_([‘Jack‘,‘rain‘])).all() ) #再查就发现刚才添加的数据没有了。
13  
14 # Session
15 # Session.commit()

获取所有数据

print(Session.query(User.name,User.id).all() )

多条件查询

1 objs = Session.query(User).filter(User.id>0).filter(User.id<7).all()

上面2个filter的关系相当于 user.id >1 AND user.id <7 的效果

统计和分组

Session.query(User).filter(User.name.like("Ra%")).count()

分组

from sqlalchemy import func
print(Session.query(func.count(User.name),User.name).group_by(User.name).all() )

输出为：

[(1, ‘Jack‘), (2, ‘Rain‘)]

 

外键关联

创建一个address表，跟user表关联

 1 from sqlalchemy import ForeignKey
 2 from sqlalchemy.orm import relationship
 3  
 4 class Address(Base):
 5     __tablename__ = ‘addresses‘
 6     id = Column(Integer, primary_key=True)
 7     email_address = Column(String(32), nullable=False)
 8     user_id = Column(Integer, ForeignKey(‘user.id‘))
 9  
10     user = relationship("User", backref="addresses") #这个nb，允许你在user表里通过backref字段反向查出所有它在addresses表里的关联项
11  
12     def __repr__(self):
13         return "<Address(email_address=‘%s‘)>" % self.email_address

表创建好以后可以反查试试

1 obj = Session.query(User).first()
2 for i in obj.addresses: #通过user对象反查关联的addresses记录
3     print(i)
4  
5 addr_obj = Session.query(Address).first()
6 print(addr_obj.user.name)  #在addr_obj里直接查关联的user表

 

创建关联对象

1 obj = Session.query(User).filter(User.name==‘rain‘).all()[0]
2 print(obj.addresses)
3  
4 obj.addresses = [Address(email_address="[email protected]"), #添加关联对象
5                  Address(email_address="[email protected]")]
6  
7  
8 Session.commit()