sqlalchemy基本的增刪改查

#encoding: utf-8

from sqlalchemy import create_engine,Column,Integer,String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

HOSTNAME = '127.0.0.1'

PORT = 3306

DATABASE = 'first_sqlalchemy'

USERNAME = 'root'

PASSWORD = '123456'

#dialect+driver://username:password@host:port/database
DB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/" \
         "{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)

engine = create_engine(DB_URI)

Base = declarative_base(engine)

# Session = sessionmaker(engine)
# session = Session()

session = sessionmaker(engine)()#這里要解釋下，學習python都是類里面的流程是__new__,類實例化一個空對象，__init__，為空對象構造屬性，__call__,把對象變成一個函數調用

class sessionmaker(_SessionClassMethods):
　　

def __init__(self, bind=None, class_=Session, autoflush=True,
             autocommit=False,
             expire_on_commit=True,
             info=None, **kw):
#這一步就是sessionmaker(engine)干的事，實例化一個對象，后面加個括號是干嘛呢？，就是對象調用加括號調用了__call__方法。 

def __call__(self, **local_kw):
    """Produce a new :class:`.Session` object using the configuration
    established in this :class:`.sessionmaker`.

    In Python, the ``__call__`` method is invoked on an object when
    it is "called" in the same way as a function::

        Session = sessionmaker()
        session = Session()  # invokes sessionmaker.__call__()

    """
    for k, v in self.kw.items():
        if k == 'info' and 'info' in local_kw:
            d = v.copy()
            d.update(local_kw['info'])
            local_kw['info'] = d
        else:
            local_kw.setdefault(k, v)
    return self.class_(**local_kw)

#返回了 self.class_(**local_kw) , self.class_ = Session(**local_kw)
#

 Session = sessionmaker(engine)() #其實就是 session = Session(**local_kw) 就是Session的對象

python前面，面向對象

class DistanceForm(object):
  def __init__(self, origin):
    self.origin = origin
    print "origin :"+str(origin)
  def __call__(self, x):
    print "x :"+str(x)
p = DistanceForm(100)
p(2000)



輸出：

origin :100
x :2000

---------------------

#創建出來一個類關系映射到數據庫
class Person(Base):
    __tablename__ = 'person'
    id = Column(Integer,primary_key=True,autoincrement=True)
    name = Column(String(50))
    age = Column(Integer)
    country = Column(String(50))

    def __str__(self):
        return "<Person(name:%s,age:%s,country:%s)>" % (self.name,self.age,self.country)

Base.metadata.create_all() #把類的數據類型映射到數據庫

#這里的__str__要不要解釋呢，還是解釋下吧！

class Person:

    def __init__(self,name):
        self.name = name

    def __str__(self):
        return self.name

    #這個__repr__是用來干嘛的
    def __repr__(self):
        return '每天都有好心情'

p = Person('xiaowu')

print(p) #當打印對象p時，
# 會默認調用__str__，如果類中沒有，就會打印對象的內存地址

#Python中這個_repr_函數，對應repr(object)這個函數，返回一個可以用來表示對象的可打印字符串：

'''
嘗試生成這樣一個字符串，將其傳給 eval()可重新生成同樣的對象 ；

否則，生成用尖括號包住的字符串，包含類型名和額外的信息(比如地址) ；

一個類(class)可以通過 __repr__() 成員來控制repr()函數作用在其實例上時的行為。
'''

print(repr(p))

#來看下eval()的用法
#eval() 函數用來執行一個字符串表達式，並返回表達式的值。
#eval(expression[, globals[, locals]])
'''
expression -- 表達式。
globals -- 變量作用域，全局命名空間，如果被提供，則必須是一個字典對象。
locals -- 變量作用域，局部命名空間，如果被提供，可以是任何映射對象。
'''
#案例：
'''
>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> n=81
>>> eval("n + 4")
85
'''

#案例演示：


class Person:

    def __init__(self,name):
        self.name = name

    def __str__(self):
        return self.name

    #這個__repr__是用來干嘛的
    def __repr__(self):
        return "{}".format({"name":"xiaowu"})

p1 = Person('xiaohong')

P = repr(p1)

print(P)

print(eval(P))

增加：

def add_data():
    p1 = Person(name='zhiliao1',age=19,country='china')
    p2 = Person(name='zhiliao2',age=20,country='china')
    session.add_all([p1,p2])
    session.commit()

查：

# 查
def search_data():
    #獲取所有的對象，query類型
    # all_person = session.query(Person).all()
    # for p in all_person:
    #     print(p)
    #     print(p.name)
    # all_person = session.query(Person).filter_by(name='zhiliao').all()
    # for x in all_person:
    #     print(x)
    # all_person = session.query(Person).filter(Person.name=='zhiliao').all()
    # print(all_person)  # [<__main__.Person object at 0x0000015BCE1B4630>]
    # for x in all_person:
    #     print(x)
    person = session.query(Person).first()
    print(person)

改：

# 改
def update_data():
    person = session.query(Person).first()
    person.name = 'ketang'
    session.commit()

刪：

# 刪
def delete_data():
    person = session.query(Person).first()
    session.delete(person)
    session.commit()

### 用session做數據的增刪改查操作：
1. 構建session對象：所有和數據庫的ORM操作都必須通過一個叫做`session`的會話對象來實現，通過以下代碼來獲取會話對象：
```python
from sqlalchemy.orm import sessionmaker

engine = create_engine(DB_URI)
session = sessionmaker(engine)()
```
2. 添加對象：
* 創建對象，也即創建一條數據：
```python
p = Person(name='zhiliao',age=18,country='china')
```
* 將這個對象添加到`session`會話對象中：
```python
session.add(p)
```
* 將session中的對象做commit操作（提交）：
```python
session.commit()
```
* 一次性添加多條數據：
```python
p1 = Person(name='zhiliao1',age=19,country='china')
p2 = Person(name='zhiliao2',age=20,country='china')
session.add_all([p1,p2])
session.commit()
```
3. 查找對象：
```python
# 查找某個模型對應的那個表中所有的數據：
all_person = session.query(Person).all()
# 使用filter_by來做條件查詢
all_person = session.query(Person).filter_by(name='zhiliao').all()
# 使用filter來做條件查詢
all_person = session.query(Person).filter(Person.name=='zhiliao').all()
# 使用get方法查找數據，get方法是根據id來查找的，只會返回一條數據或者None
person = session.query(Person).get(primary_key)
# 使用first方法獲取結果集中的第一條數據
person = session.query(Person).first()
```
4. 修改對象：首先從數據庫中查找對象，然后將這條數據修改為你想要的數據，最后做commit操作就可以修改數據了。
```python
person = session.query(Person).first()
person.name = 'ketang'
session.commit()
```
5. 刪除對象：將需要刪除的數據從數據庫中查找出來，然后使用`session.delete`方法將這條數據從session中刪除，最后做commit操作就可以了。
```python
person = session.query(Person).first()
session.delete(person)
session.commit()