http://loo2k.com/blog/why-avoid-css-expression/

本节情

  1. ORM介绍
  2. sqlalchemy安装
  3. sqlalchemy基本接纳
  4. 大多外键关联
  5. 多针对性大多涉及
  6. 申结构设计作业 
     

4

一、ORM介绍

假使写序用pymysql和程序交互,这是休是如描绘原生sql语句。假使进展复杂的查询,这sql语句就要举行一点一点凑合,而且未太有重用性,扩张不便于。而且写的sql语句可能不敏捷,导致程序运行也变慢。 
为制止把sql语句写好于代码里,有没起一致种植形式直接将原生sql封装好了以以你熟习的点子操作,像面向对象这样? 
  
orm(object relational
mapping),就是目的映射关系程序,简单的说我们好像python这种面向对象的次第来说一切均对象,然而咱应用的数据库可仍然关系型的,为了保证平等的下习惯,通过orm将编程语言的靶子模型和数据库的涉及模型建立映射关系,这样大家于动编程语言对数据库举办操作的时节可一向使用编程语言的目的模型举办操作就好了,而未用直接运用sql语言。

ORM
十分给将数据库也给您实例化了
,在代码操作mysql中级又加以了orm这同叠。 
orm的优点:

  1. 隐蔽了多少访问细节,“封闭”的通用数据库交互,ORM的基本。他令我们的通用数据库交互变得简单易行,并且完全不用考虑该死的SQL语句。急速开,由此而来。
  2. ORM使大家协会固化数据结构变得简单易行。

缺点:

  1. 无可制止的,自动化意味着映射和关联管理,代价是牺牲性能(早期,这是有非喜欢ORM人的共同点)。现在底各样ORM框架还于品味以各类艺术来减轻这块(LazyLoad,Cache),效果仍旧挺醒目标。

七月 12, 2011 10:28 |
前端开发 | Add a
comment

二、sqlalchemy安装

当Python中,最著名的ORM框架是SQLAlchemy。用户包括openstack\Dropbox等享誉公司如故下,紧要用户列表http://www.sqlalchemy.org/organizations.html#openstack

安装sqlalchemy

pip install SQLAlchemy
pip install pymysql
# 由于mysqldb依然不支持py3,所以这里我们用pymysql与sqlalchemy交互

 

Centos7 安装mariadb-server

yum -y install mariadb-server  # 安装
systemctl start  mariadb.service  # 启动
mysqladmin -uroot -p password  # 设密码
GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY PASSWORD '123456' WITH GRANT OPTION;  # 授权
flush privileges;

先曾经上了同样篇著作 缓解 IE6 position:fixed
固定定位问题
,讲的是动 CSS
表达式来化解 IE6 不能以 positio: fixed;
固定定位的题材;在作品见报后的至本,一些对象晓自己 CSS
表明式可能会面潜移默化到网站的属性;

其三、sqlalchemy基本使用

Dialect用于和数目API举办互换,依照部署文件的两样调用不同的数据库API,从而实现对数据库的操作,如:

MySQL-Python
    mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>

pymysql
    mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]

MySQL-Connector
    mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>

cx_Oracle
    oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]

 

经这多少个朋友等的擢升,我再多的小心了有关 CSS
表达式方面的知识,而即刻首稿子,是我于看
高性能网站建设指南》后,以及前做的有些读书,我牵记总括下
怎么尽量幸免使用 CSS 表达式”;

1、创建表

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String
# 创建实例,并连接test库
engine = create_engine("mysql+pymysql://root:123456@localhost/test",
                                    encoding='utf-8', echo=True)
# echo=True 显示信息
Base = declarative_base()  # 生成orm基类

class User(Base):
    __tablename__ = 'user'  # 表名
    id = Column(Integer, primary_key=True)
    name = Column(String(32))
    password = Column(String(64))

Base.metadata.create_all(engine) #创建表结构 (这里是父类调子类)

运作,展现相关信息,包括生成的sql语句:

CREATE TABLE user (
    id INTEGER NOT NULL AUTO_INCREMENT, 
    name VARCHAR(32), 
    password VARCHAR(64), 
    PRIMARY KEY (id)
)

 

连没有觉得代码量变少啊, 莫急,好戏在后

除了上边的成立之外,还有雷同种植成立表的方

from sqlalchemy import Table, MetaData, Column, Integer, String, ForeignKey
from sqlalchemy.orm import mapper

metadata = MetaData()

user = Table('user', metadata,
            Column('id', Integer, primary_key=True),
            Column('name', String(50)),
            Column('fullname', String(50)),
            Column('password', String(12))
        )

class User(object):
    def __init__(self, name, fullname, password):
        self.name = name
        self.fullname = fullname
        self.password = password

mapper(User, user)  # 类User 和 user关联起来
# the table metadata is created separately with the Table construct, 
# then associated with the User class via the mapper() function
# 如果数据库里有,就不会创建了。

 

极致中央的申我们创建好了,这大家开用orm创设同久数试试

什么是 CSS Expression?

CSS Expression (CSS 表明式),是一样种植使动态设置 CSS 属性的法子,并且让
IE5 以上的版本所支撑,可是 IE8 的专业格局既不再补助 CSS
表明式了[\[1\]](http://loo2k.com/blog/why-avoid-css-expression/#expressions)

2、插入一长长的数据

from sqlalchemy import create_engine
from sqlalchemy import Table, MetaData, Column, Integer, String
from sqlalchemy.orm import mapper, sessionmaker
# 创建实例,并连接test库
engine = create_engine("mysql+pymysql://root:123456@localhost/test",
                                    encoding='utf-8', echo=True)

metadata = MetaData()

user = Table('user', metadata,
            Column('id', Integer, primary_key=True),
            Column('name', String(50)),
            Column('password', String(12))
        )

class User(object):
    def __init__(self, name, id, password):
        self.id = id
        self.name = name
        self.password = password
# the table metadata is created separately with the Table construct, then associated with the User class via the mapper() function
mapper(User, user)

# 创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
Session_class = sessionmaker(bind=engine)  # 实例和engine绑定
Session = Session_class()  # 生成session实例,相当于游标

user_obj = User(id=27,name="fgf",password="123456")  # 生成你要创建的数据对象
print(user_obj.name,user_obj.id)  # 此时还没创建对象呢,不信你打印一下id发现还是None

Session.add(user_obj)  # 把要创建的数据对象添加到这个session里, 一会统一创建
print(user_obj.name,user_obj.id) #此时也依然还没创建

Session.commit() #现此才统一提交,创建数据

 

描绘这么多代码才创建同漫长数据,你意味着太tm的坚苦了,正而转身离开,我关已公的手不加大,高潮还从未到。。

一个简单易行的 CSS 表明式

  1. body {
  2. background-color: expression((new
    Date()).getHours()%2?”#B8D4FF”:”#F08A00″);
  3. }

即刻段代码的企图是会为你页面中 body 的背景观每隔一钟头换一浅;

3.1、查询

my_user = Session.query(User).filter_by(name="fgf").first()  # 查询
print(my_user)

这时公看到的输出是这般的应当

<__main__.User object at 0x7f0a5a3dea20>

 

sqlalchemy把再次来到的多寡映射成一个目标啊,那样您调用每个字段就可和调用对象属性一样啊,like
this..

print(my_user.id,my_user.name,my_user.password)
# 输出
27 fgf 123456

 

可是才突显的内存对象对址没办法分清再次来到的是呀数据的,除非打印具体字段看一下,如果想叫它换的可读,只需要在定义表的类似上边加上这样的代码

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

 

from sqlalchemy import create_engine
from sqlalchemy import Table, MetaData, Column, Integer, String
from sqlalchemy.orm import mapper, sessionmaker
# 创建实例,并连接test库
engine = create_engine("mysql+pymysql://root:123456@localhost/test",
                                    encoding='utf-8', echo=True)

metadata = MetaData()

user = Table('user', metadata,
            Column('id', Integer, primary_key=True),
            Column('name', String(50)),
            Column('password', String(12))
        )
class User(object):
    def __init__(self, name, id, password):
        self.id = id
        self.name = name
        self.password = password
    def __repr__(self):
        return "<User(name='%s',  password='%s')>" % (self.name, self.password)

mapper(User, user)
# 创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
Session_class = sessionmaker(bind=engine)
Session = Session_class()  # 生成session实例

my_user = Session.query(User).filter_by(name="fgf").first()  # 查询第一个
# my_user = Session.query(User).filter_by().all()  # 查询所有
print(my_user)
# print(my_user.id,my_user.name,my_user.password)

# Session.commit()  #查询不需要commit

 

取得有数据

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

 

CSS Expression 带来的特性问题

是的,参考 MSDN
有关动态性
的文档,你会意识,其实 CSS 表达式依旧很强劲的,比如你得下 CSS
表明式实现 min-width 属性,隔行换色,模拟 :hover, :before, :after
等伪类;

不过,正式以 CSS 表达式太强大了,以至于 CSS
表明式带来的要紧的性问题:“为了保中,CSS
表明式会举行反复的求值
”,到底出多累?就是在您转移窗口大小,滚动页面甚至移动鼠标都相会接触发表明式进行求值,如此反复之求值以至于浏览器的性能收到严重的震慑;

3.2、多规格查询

filter_by与filter

my_user1 = Session.query(User).filter(User.id>2).all()
my_user2 = Session.query(User).filter_by(id=27).all()  # filter_by相等用‘=’
my_user3 = Session.query(User).filter(User.id==27).all()  # filter相等用‘==’

print(my_user1,'\n',my_user2,'\n',my_user3)

 

差不多规格查询

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

 

地点2独filter的涉嫌一定给 user.id >1 AND user.id <7 的效果

有关对 CSS Expression 的特性测试

这一个测试的方是根源于近日一段时间在圈之《大性能网站建设指南》中的规则7;

  1. P {
  2. width: expression( setCntr(), document.body.clientWidth<600?”600px”:”auto”);
  3. min-width:600px;
  4. border:1px solid;
  5. }

本条模式通过绑定一个 setCntr() 函数到 CSS
表明式上,总括页面执行了聊坏的 CSS
表达式,并彰显在一个文本框里面;你为堪由此 IE5 ~ IE6 访问
http://stevesouders.com/hpws/expression-counter.php 举行测试;

4、修改

my_user = Session.query(User).filter_by(name="fgf").first()
my_user.name = "fenggf"  # 查询出来之后直接赋值修改
my_user.passwork = "123qwe"
Session.commit()

 

测试结果

页面内发 10 个段子,加载了页面大概执行了 40 次的 CSS
表明式,然后于公改变页面大小,滚动页面,甚至移动鼠标,在本人之测试里不动鼠标依然会尽
CSS 表明式,几万不佳的求值根本不在说话下,而且每当点击文本框之后,IE
就曾经卡死了;

5、回滚

my_user = Session.query(User).filter_by(id=1).first()
my_user.name = "Jack"

fake_user = User(name='Rain', password='12345')
Session.add(fake_user)

print(Session.query(User).filter(User.name.in_(['Jack','rain'])).all() )  #这时看session里有你刚添加和修改的数据

Session.rollback() #此时你rollback一下

print(Session.query(User).filter(User.name.in_(['Jack','rain'])).all() ) #再查就发现刚才添加的数据没有了。

# Session
# Session.commit()

 

避免使 CSS Expression

吓吧,这是一个总结;即使还有针对性 CSS
表明式举办优化的艺术(你得在参考链接中找到),可是这不是即时首随笔要总括的,那篇稿子使总计的凡为啥尽量避免使用
CSS 表达式;

CSS
表明式即使强大,不过会被浏览器带来异常惨重的习性问题,并拖慢网页的加载速度;在可能的前提下,尽量避免使用
CSS 表明式!

6、总结和分组

统计 count

Session.query(User).filter(User.name.like("f%")).count()  # mysql不区分大小写

 

分组 group_by

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

 

参考链接
  1. CSS Expression
    用法总计
  2. CSS Expression
    的优化

删除 del

脚注
  1. IE 8 的科班格局不再补助 CSS
    表达式

css
IE

More Articles about

7.1、外键关联

预备干活:先创设一个表明,再插入数据

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import sessionmaker
# 创建实例,并连接test库
engine = create_engine("mysql+pymysql://root:123456@localhost/test",
                                    encoding='utf-8', echo=True)

Base = declarative_base()  # 生成orm基类

class Student(Base):
    __tablename__ = 'student'  # 表名
    id = Column(Integer, primary_key=True, autoincrement=True)
    stu_id = Column(Integer)
    age = Column(Integer)  # 整型
    gender = Column(Enum('M','F'),nullable=False)

Base.metadata.create_all(engine) #创建表结构 (这里是父类调子类)

# 创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
Session_class = sessionmaker(bind=engine)
Session = Session_class()  # 生成session实例
stu_obj = Student(stu_id=27, age=22, gender="M")
Session.add(stu_obj)
Session.commit() #现此才统一提交,创建数据

 

连表

ret = session.query(Users, Favor).filter(Users.id == Favor.nid).all()

# 以下两种 必须表之间有外键关联才能查
ret = session.query(Person).join(Favor).all()  
ret = session.query(Person).join(Favor, isouter=True).all()

 

首先种示例:

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, Enum
from sqlalchemy.orm import sessionmaker
# 创建实例,并连接test库
engine = create_engine("mysql+pymysql://root:123456@localhost/test",
                                    encoding='utf-8')
Base = declarative_base()  # 生成orm基类

class User(Base):
    __tablename__ = 'user'  # 表名
    id = Column(Integer, primary_key=True)
    name = Column(String(32))
    password = Column(String(64))
    def __repr__(self):
        return "[%s name:%s]" %(self.id, self.name)

class Student(Base):
    __tablename__ = 'student'  # 表名
    id = Column(Integer, primary_key=True, autoincrement=True)
    stu_id = Column(Integer)
    age = Column(Integer)  # 整型
    gender = Column(Enum('M','F'),nullable=False)
    def __repr__(self):
        return "[%s stu_id:%s sex:%s]" %(self.stu_id, self.age, self.gender)

Session_class = sessionmaker(bind=engine)
Session = Session_class()  # 生成session实例

res = Session.query(User, Student).filter(User.id == Student.stu_id).all()
print(res)

 

css, IE

外键关联实现

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Enum,DATE,Integer, String,ForeignKey
from sqlalchemy.orm import sessionmaker,relationship

engine = create_engine("mysql+pymysql://root:123456@localhost/test",
                                    encoding='utf-8')
Base = declarative_base()  # 生成orm基类

class Stu2(Base):
    __tablename__ = "stu2"
    id = Column(Integer, primary_key=True)
    name = Column(String(32),nullable=False)
    register_date = Column(DATE,nullable=False)
    def __repr__(self):
        return "<%s name:%s>" % (self.id, self.name)

class StudyRecord(Base):
    __tablename__ = "study_record"
    id = Column(Integer, primary_key=True)
    day = Column(Integer,nullable=False)
    status = Column(String(32),nullable=False)
    stu_id = Column(Integer,ForeignKey("stu2.id"))  #------外键关联------
    #这个nb,允许你在user表里通过backref字段反向查出所有它在stu2表里的关联项数据
    stu2 = relationship("Stu2", backref="my_study_record")  # 添加关系,反查(在内存里)
    def __repr__(self):
        return "<%s day:%s status:%s>" % (self.stu2.name, self.day,self.status)

Base.metadata.create_all(engine)  # 创建表结构

Session_class = sessionmaker(bind=engine)  # 创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
session = Session_class()  # 生成session实例 #cursor

s1 = Stu2(name="A",register_date="2014-05-21")
s2 = Stu2(name="J",register_date="2014-03-21")
s3 = Stu2(name="R",register_date="2014-02-21")
s4 = Stu2(name="E",register_date="2013-01-21")

study_obj1 = StudyRecord(day=1,status="YES", stu_id=1)
study_obj2 = StudyRecord(day=2,status="NO", stu_id=1)
study_obj3 = StudyRecord(day=3,status="YES", stu_id=1)
study_obj4 = StudyRecord(day=1,status="YES", stu_id=2)

session.add_all([s1,s2,s3,s4,study_obj1,study_obj2,study_obj3,study_obj4])  # 创建
session.commit()

stu_obj = session.query(Stu2).filter(Stu2.name=="a").first()  # 查询
# 在stu2表,查到StudyRecord表的记录
print(stu_obj.my_study_record)  # 查询A一共上了几节课

 

得查阅创立命令:

show create table study_record;

 

7.2、多外键关联

差不多外键关联,并且关系和一个阐明。 
下表中,Customer表有2独字段都关乎了Address表 
cat orm_many_fk.py

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

Base = declarative_base()

class Customer(Base):
    __tablename__ = 'customer'
    id = Column(Integer, primary_key=True)
    name = Column(String(64))
    # 账单地址和邮寄地址 都关联同一个地址表
    billing_address_id = Column(Integer, ForeignKey("address.id"))
    shipping_address_id = Column(Integer, ForeignKey("address.id"))

    billing_address = relationship("Address", foreign_keys=[billing_address_id])
    shipping_address = relationship("Address", foreign_keys=[shipping_address_id])

class Address(Base):
    __tablename__ = 'address'
    id = Column(Integer, primary_key=True)
    street = Column(String(64))
    city = Column(String(64))
    state = Column(String(64))
    def __repr__(self):
        return self.street

engine = create_engine("mysql+pymysql://root:123456@localhost/test",
                                    encoding='utf-8')
Base.metadata.create_all(engine)  # 创建表结构

 

MariaDB [test]> show create table customer;
| customer | CREATE TABLE `customer` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(64) DEFAULT NULL,
  `billing_address_id` int(11) DEFAULT NULL,
  `shipping_address_id` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `billing_address_id` (`billing_address_id`),
  KEY `shipping_address_id` (`shipping_address_id`),
  CONSTRAINT `customer_ibfk_1` FOREIGN KEY (`billing_address_id`) REFERENCES `address` (`id`),
  CONSTRAINT `customer_ibfk_2` FOREIGN KEY (`shipping_address_id`) REFERENCES `address` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 |

MariaDB [test]> desc customer;
+---------------------+-------------+------+-----+---------+----------------+
| Field               | Type        | Null | Key | Default | Extra          |
+---------------------+-------------+------+-----+---------+----------------+
| id                  | int(11)     | NO   | PRI | NULL    | auto_increment |
| name                | varchar(64) | YES  |     | NULL    |                |
| billing_address_id  | int(11)     | YES  | MUL | NULL    |                |
| shipping_address_id | int(11)     | YES  | MUL | NULL    |                |
+---------------------+-------------+------+-----+---------+----------------+

 

好端端写的时光,表结构单独写一个模块。添加数

import orm_many_fk
from sqlalchemy.orm import sessionmaker

Session_class = sessionmaker(bind=orm_many_fk.engine)  # 创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
session = Session_class()  # 生成session实例 #cursor

addr1 = orm_many_fk.Address(street="Tiantongyuan", city="ChangPing", state="BJ")
addr2 = orm_many_fk.Address(street="Wudaokou", city="Haidian", state="BJ")
addr3 = orm_many_fk.Address(street="Yanjiao", city="LangFang", state="HB")

session.add_all([addr1,addr2,addr3])
c1 =  orm_many_fk.Customer(name="Fgf", billing_address= addr1,shipping_address=addr2)
c2 =  orm_many_fk.Customer(name="Jack", billing_address= addr3,shipping_address=addr3)

session.add_all([c1,c2])
session.commit()

obj = session.query(orm_many_fk.Customer).filter(orm_many_fk.Customer.name=="Fgf").first()
print(obj.name,obj.billing_address,obj.shipping_address)  # 查询

 

7.3 多针对几近干

今昔来统筹一个力所能及描述“图书”与“作者”的涉及的申结构,需求是

  1. 同一本书可以发少数个作者共出版
  2. 一个作者可以形容一些按部就班书 
    这儿你会意识,用事先学的外键好像没有道落实地方的需了 
    那么怎么处置吧? 此时,我们得以再一次干来同摆中间表,就得了 
    这么就一定给通过book_m2m_author表完成了book表和author表往日的基本上针对大多关联 
    双向一对多,就是多针对性几近。 
    所以orm如何表示也?

# 创建表结构
from sqlalchemy import Table, Column, Integer,String,DATE, ForeignKey
from sqlalchemy.orm import relationship
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

Base = declarative_base()
# 第三张表 自己创建。不需要手动管理,orm自动维护
book_m2m_author = Table('book_m2m_author', Base.metadata,
                        Column('book_id',Integer,ForeignKey('books.id')),
                        Column('author_id',Integer,ForeignKey('authors.id')),
                        )
class Book(Base):
    __tablename__ = 'books'
    id = Column(Integer,primary_key=True)
    name = Column(String(64))
    pub_date = Column(DATE)
    # book表不知道第三张表,所以关联一下第三张表
    authors = relationship('Author',secondary=book_m2m_author,backref='books')
    def __repr__(self):
        return self.name

class Author(Base):
    __tablename__ = 'authors'
    id = Column(Integer, primary_key=True)
    name = Column(String(32))
    def __repr__(self):
        return self.name

engine = create_engine("mysql+pymysql://root:123456@localhost/test",
                                    encoding='utf-8')
Base.metadata.create_all(engine)  # 创建表结构

MariaDB [test]> desc book_m2m_author;
+-----------+---------+------+-----+---------+-------+
| Field     | Type    | Null | Key | Default | Extra |
+-----------+---------+------+-----+---------+-------+
| book_id   | int(11) | YES  | MUL | NULL    |       |
| author_id | int(11) | YES  | MUL | NULL    |       |
+-----------+---------+------+-----+---------+-------+
# 做了复合键了

 

# 添加数据
import orm_m2m
from sqlalchemy.orm import sessionmaker

Session_class = sessionmaker(bind=orm_m2m.engine)  # 创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
session = Session_class()  # 生成session实例 #cursor
# 创建书
b1 = orm_m2m.Book(name="learn python with Alex",pub_date="2014-05-2")
b2= orm_m2m.Book(name="learn Zhangbility with Alex",pub_date="2015-05-2")
b3 = orm_m2m.Book(name="Learn hook up girls with Alex",pub_date="2016-05-2")
# 创建作者
a1 = orm_m2m.Author(name="Alex")
a2 = orm_m2m.Author(name="Jack")
a3 = orm_m2m.Author(name="Rain")
# 关联关系
b1.authors = [a1,a3]
b3.authors = [a1,a2,a3]

session.add_all([b1,b2,b3,a1,a2,a3])
session.commit()

 

# 重要是查询
author_obj = session.query(orm_m2m.Author).filter(orm_m2m.Author.name=="alex").first()
print(author_obj.books[0:])
book_obj = session.query(orm_m2m.Book).filter(orm_m2m.Book.id==2).first()
print(book_obj.authors)

 

基本上对大多去 
去数据平时不要管boo_m2m_authors ,
sqlalchemy会自动帮您拿相应的数额删除

经过书删除作者

author_obj =s.query(Author).filter_by(name="Jack").first()
book_obj = s.query(Book).filter_by(name="跟Alex学把妹").first()
book_obj.authors.remove(author_obj) #从一本书里删除一个作者
s.commit()

 

直白去作者 

删除作者时,会管这一个作者和所有书的涉关系数据也自动删除

author_obj =s.query(Author).filter_by(name="Alex").first()
# print(author_obj.name , author_obj.books)
s.delete(author_obj)
s.commit()

 

8、中文题目

先翻数据库的字符集

MariaDB [test]> show create database test;
+----------+-----------------------------------------------------------------+
| Database | Create Database                                                 |
+----------+-----------------------------------------------------------------+
| test     | CREATE DATABASE `test` /*!40100 DEFAULT CHARACTER SET latin1 */ |
+----------+-----------------------------------------------------------------+

 

改数据库的字符集(如果改动字符集,添加本不亮闽南语,可能就是需创制是指定尝试一下了。)

MariaDB [test]> alter database test character set utf8;

 

始建数据库指定数据库的字符集

MariaDB [test]> create database mydb character set utf8;

 

sqlalchemy 连接指定

engine = create_engine("mysql+pymysql://root:123456@localhost/test?charset=utf8",)

 

转自:http://blog.csdn.net/fgf00/article/details/52949973