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()