---恢復內容開始---

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:alex3714@localhost/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:alex3714@localhost/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()

python之ORM的使用（1）