1. <div class="clear"></div>
  2. <div class="postBody">

SQLAlchemy

1.介绍

SQLAlchemy是一个基于Python实现的ORM框架。该框架建立在 DB API之上,使用关系对象映射进行数据库操作,简言之便是:将类和对象转换成SQL,然后使用数据API执行SQL并获取执行结果。

  1. pip3 install sqlalchemy

组成部分:

  1. Engine,框架的引擎
  2. Connection Pooling ,数据库连接池
  3. Dialect,选择连接数据库的DB API种类
  4. Schema/Types,架构和类型
  5. SQL Exprression LanguageSQL表达式语言

SQLAlchemy本身无法操作数据库,其必须以来pymsql等第三方插件,Dialect用于和数据API进行交流,根据配置文件的不同调用不同的数据库API,从而实现对数据库的操作,如:

  1. MySQL-Python
  2. mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>
  3. pymysql

  4. mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]
  5. MySQL-Connector

  6. mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>
  7. cx_Oracle

  8. oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]
  9. 更多:http://docs.sqlalchemy.org/en/latest/dialects/index.html

django中如何反向生成models

  1. python manage.py inspectdb > app/models.py

2.简单使用(能创建表,删除表,不能修改表)

修改表:在数据库添加字段,类对应上

1执行原生sql(不常用)

  1. import time
  2. import threading
  3. import sqlalchemy
  4. from sqlalchemy import create_engine
  5. from sqlalchemy.engine.base import Engine
  6. engine = create_engine(

  7. "mysql+pymysql://root:123456@127.0.0.1:3306/test?charset=utf8",

  8. max_overflow=0, # 超过连接池大小外最多创建的连接

  9. pool_size=5, # 连接池大小

  10. pool_timeout=30, # 池中没有线程最多等待的时间,否则报错

  11. pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收(重置)

  12. )

  13. def task(arg):

  14. conn = engine.raw_connection()

  15. cursor = conn.cursor()

  16. cursor.execute(

  17. "select * from app01_book"

  18. )

  19. result = cursor.fetchall()

  20. print(result)

  21. cursor.close()

  22. conn.close()
  23. for i in range(20):

  24. t = threading.Thread(target=task, args=(i,))

  25. t.start()

2 orm使用

models.py

  1. import datetime
  2. from sqlalchemy import create_engine
  3. from sqlalchemy.ext.declarative import declarative_base
  4. from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index
  5. Base = declarative_base()
  6. class Users(Base):

  7. tablename = 'users' # 数据库表名称

  8. id = Column(Integer, primary_key=True) # id 主键

  9. name = Column(String(32), index=True, nullable=False) # name列,索引,不可为空

  10. # email = Column(String(32), unique=True)

  11. #datetime.datetime.now不能加括号,加了括号,以后永远是当前时间

  12. # ctime = Column(DateTime, default=datetime.datetime.now)

  13. # extra = Column(Text, nullable=True)
  14. __table_args__ = (
  15.     # UniqueConstraint('id', 'name', name='uix_id_name'), #联合唯一
  16.     # Index('ix_id_name', 'name', 'email'), #索引
  17. )
  18. def init_db():

  19. """

  20. 根据类创建数据库表

  21. :return:

  22. """

  23. engine = create_engine(

  24. "mysql+pymysql://root:123456@127.0.0.1:3306/aaa?charset=utf8",

  25. max_overflow=0, # 超过连接池大小外最多创建的连接

  26. pool_size=5, # 连接池大小

  27. pool_timeout=30, # 池中没有线程最多等待的时间,否则报错

  28. pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收(重置)

  29. )

  30. Base.metadata.create_all(engine)
  31. def drop_db():

  32. """

  33. 根据类删除数据库表

  34. :return:

  35. """

  36. engine = create_engine(

  37. "mysql+pymysql://root:123456@127.0.0.1:3306/aaa?charset=utf8",

  38. max_overflow=0, # 超过连接池大小外最多创建的连接

  39. pool_size=5, # 连接池大小

  40. pool_timeout=30, # 池中没有线程最多等待的时间,否则报错

  41. pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收(重置)

  42. )

  43. Base.metadata.drop_all(engine)
  44. if name == 'main':

  45. # drop_db()

  46. init_db()

app.py

  1. from sqlalchemy.orm import sessionmaker
  2. from sqlalchemy import create_engine
  3. from models import Users
  4. #"mysql+pymysql://root@127.0.0.1:3306/aaa"
  5. engine = create_engine("mysql+pymysql://root:123456@127.0.0.1:3306/aaa", max_overflow=0, pool_size=5)
  6. Connection = sessionmaker(bind=engine)
  7. 每次执行数据库操作时,都需要创建一个Connection

  8. con = Connection()
  9. ############# 执行ORM操作

  10. obj1 = Users(name="lqz")

  11. con.add(obj1)
  12. 提交事务

  13. con.commit()
  14. 关闭session,其实是将连接放回连接池

  15. con.close()

3.一对多关系

  1. class Hobby(Base):
  2. __tablename__ = 'hobby'
  3. id = Column(Integer, primary_key=True)
  4. caption = Column(String(50), default='篮球')
  5. class Person(Base):

  6. tablename = 'person'

  7. nid = Column(Integer, primary_key=True)

  8. name = Column(String(32), index=True, nullable=True)

  9. # hobby指的是tablename而不是类名,uselist=False

  10. hobby_id = Column(Integer, ForeignKey("hobby.id"))
  11. # 跟数据库无关,不会新增字段,只用于快速链表操作
  12. # 类名,backref用于反向查询
  13. hobby=relationship('Hobby',backref='pers')</code></pre>
  14. 4.多对多关系

  15. class Boy2Girl(Base):
  16.     __tablename__ = 'boy2girl'
  17.     id = Column(Integer, primary_key=True, autoincrement=True)
  18.     girl_id = Column(Integer, ForeignKey('girl.id'))
  19.     boy_id = Column(Integer, ForeignKey('boy.id'))
  20. class Girl(Base):

  21. tablename = 'girl'

  22. id = Column(Integer, primary_key=True)

  23. name = Column(String(64), unique=True, nullable=False)
  24. class Boy(Base):

  25. tablename = 'boy'
  26. id = Column(Integer, primary_key=True, autoincrement=True)
  27. hostname = Column(String(64), unique=True, nullable=False)
  28. # 与生成表结构无关,仅用于查询方便,放在哪个单表中都可以
  29. servers = relationship('Girl', secondary='boy2girl', backref='boys')
  30. 5.操作数据表

  31. from sqlalchemy.orm import sessionmaker
  32. from sqlalchemy import create_engine
  33. from models import Users
  34. engine = create_engine("mysql+pymysql://root:123456@127.0.0.1:3306/aaa", max_overflow=0, pool_size=5)

  35. Session = sessionmaker(bind=engine)
  36. 每次执行数据库操作时,都需要创建一个session

  37. session = Session()
  38. ############# 执行ORM操作

  39. obj1 = Users(name="lqz")

  40. session.add(obj1)
  41. 提交事务

  42. session.commit()
  43. 关闭session

  44. session.close()

  45. 6.基于scoped_session实现线程安全

  46. from sqlalchemy.orm import sessionmaker
  47. from sqlalchemy import create_engine
  48. from sqlalchemy.orm import scoped_session
  49. from models import Users
  50. engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6", max_overflow=0, pool_size=5)

  51. Session = sessionmaker(bind=engine)
  52. """
  53. 线程安全,基于本地线程实现每个线程用同一个session

  54. 特殊的:scoped_session中有原来方法的Session中的一下方法:

  55. public_methods = (

  56. 'contains', 'iter', 'add', 'add_all', 'begin', 'begin_nested',

  57. 'close', 'commit', 'connection', 'delete', 'execute', 'expire',

  58. 'expire_all', 'expunge', 'expunge_all', 'flush', 'get_bind',

  59. 'is_modified', 'bulk_save_objects', 'bulk_insert_mappings',

  60. 'bulk_update_mappings',

  61. 'merge', 'query', 'refresh', 'rollback',

  62. 'scalar'

  63. )

  64. """
  65. scoped_session类并没有继承Session,但是却又它的所有方法

  66. session = scoped_session(Session)
  67. ############# 执行ORM操作

  68. obj1 = Users(name="alex1")

  69. session.add(obj1)
  70. 提交事务

  71. session.commit()
  72. 关闭session

  73. session.close()

  74. 7.基本增删查改

  75. import time
  76. import threading
  77. from sqlalchemy.ext.declarative import declarative_base

  78. from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index

  79. from sqlalchemy.orm import sessionmaker, relationship

  80. from sqlalchemy import create_engine

  81. from sqlalchemy.sql import text
  82. from db import Users, Hosts
  83. engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6", max_overflow=0, pool_size=5)

  84. Session = sessionmaker(bind=engine)
  85. session = Session()
  86. ################ 添加

  87. """

  88. obj1 = Users(name="wupeiqi")

  89. session.add(obj1)
  90. session.add_all([

  91. Users(name="lqz"),

  92. Users(name="egon"),

  93. Hosts(name="c1.com"),

  94. ])

  95. session.commit()

  96. """
  97. ################ 删除

  98. """

  99. session.query(Users).filter(Users.id > 2).delete()

  100. session.commit()

  101. """
  102. ################ 修改

  103. """
  104. 传字典

  105. session.query(Users).filter(Users.id > 0).update({"name" : "lqz"})
  106. 类似于django的F查询

  107. session.query(Users).filter(Users.id > 0).update({Users.name: Users.name + "099"}, synchronize_session=False)

  108. session.query(Users).filter(Users.id > 0).update({"age": Users.age + 1}, synchronize_session="evaluate")

  109. session.commit()

  110. """
  111. ################ 查询

  112. """

  113. r1 = session.query(Users).all()
  114. 只取age列,把name重命名为xx

  115. r2 = session.query(Users.name.label('xx'), Users.age).all()
  116. filter传的是表达式,filter_by传的是参数

  117. r3 = session.query(Users).filter(Users.name == "lqz").all()

  118. r4 = session.query(Users).filter_by(name='lqz').all()

  119. r5 = session.query(Users).filter_by(name='lqz').first()
  120. :value 和:name 相当于占位符,用params传参数

  121. r6 = session.query(Users).filter(text("id<:value and name=:name")).params(value=224, name='fred').order_by(Users.id).all()
  122. 自定义查询sql

  123. r7 = session.query(Users).from_statement(text("SELECT * FROM users where name=:name")).params(name='ed').all()

  124. """
  125. 增,删,改都要commit()

  126. session.close()

  127. 8.常用操作

  128. # 条件
  129. ret = session.query(Users).filter_by(name='lqz').all()
  130. #表达式,and条件连接
  131. ret = session.query(Users).filter(Users.id > 1, Users.name == 'eric').all()
  132. ret = session.query(Users).filter(Users.id.between(1, 3), Users.name == 'eric').all()
  133. #注意下划线
  134. ret = session.query(Users).filter(Users.id.in_([1,3,4])).all()
  135. #~非,除。。外
  136. ret = session.query(Users).filter(~Users.id.in_([1,3,4])).all()
  137. #二次筛选
  138. ret = session.query(Users).filter(Users.id.in_(session.query(Users.id).filter_by(name='eric'))).all()
  139. from sqlalchemy import and_, or_
  140. #or_包裹的都是or条件,and_包裹的都是and条件
  141. ret = session.query(Users).filter(and_(Users.id > 3, Users.name == 'eric')).all()
  142. ret = session.query(Users).filter(or_(Users.id < 2, Users.name == 'eric')).all()
  143. ret = session.query(Users).filter(
  144.     or_(
  145.         Users.id < 2,
  146.         and_(Users.name == 'eric', Users.id > 3),
  147.         Users.extra != ""
  148.     )).all()
  149. 通配符,以e开头,不以e开头

  150. ret = session.query(Users).filter(Users.name.like('e%')).all()

  151. ret = session.query(Users).filter(~Users.name.like('e%')).all()
  152. 限制,用于分页,区间

  153. ret = session.query(Users)[1:2]
  154. 排序,根据name降序排列(从大到小)

  155. ret = session.query(Users).order_by(Users.name.desc()).all()
  156. 第一个条件重复后,再按第二个条件升序排

  157. ret = session.query(Users).order_by(Users.name.desc(), Users.id.asc()).all()
  158. 分组

  159. from sqlalchemy.sql import func
  160. ret = session.query(Users).group_by(Users.extra).all()
  161. 分组之后取最大idid之和,最小id

  162. ret = session.query(

  163. func.max(Users.id),

  164. func.sum(Users.id),

  165. func.min(Users.id)).group_by(Users.name).all()
  166. haviing筛选

  167. ret = session.query(

  168. func.max(Users.id),

  169. func.sum(Users.id),

  170. func.min(Users.id)).group_by(Users.name).having(func.min(Users.id) >2).all()
  171. 连表(默认用forinkey关联)

  172. ret = session.query(Users, Favor).filter(Users.id == Favor.nid).all()
  173. join表,默认是inner join

  174. ret = session.query(Person).join(Favor).all()
  175. isouter=True 外连,表示Person left join Favor,没有右连接,反过来即可

  176. ret = session.query(Person).join(Favor, isouter=True).all()
  177. 打印原生sql

  178. aa=session.query(Person).join(Favor, isouter=True)

  179. print(aa)
  180. 自己指定on条件(连表条件),第二个参数,支持on多个条件,用and_,同上

  181. ret = session.query(Person).join(Favor,Person.id==Favor.id, isouter=True).all()
  182. 组合(了解)UNION 操作符用于合并两个或多个 SELECT 语句的结果集

  183. unionunion all的区别?

  184. q1 = session.query(Users.name).filter(Users.id > 2)

  185. q2 = session.query(Favor.caption).filter(Favor.nid < 2)

  186. ret = q1.union(q2).all()
  187. q1 = session.query(Users.name).filter(Users.id > 2)

  188. q2 = session.query(Favor.caption).filter(Favor.nid < 2)

  189. ret = q1.union_all(q2).all()

  190. 9.执行原生sql

  191. import time
  192. import threading
  193. from sqlalchemy.ext.declarative import declarative_base

  194. from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index

  195. from sqlalchemy.orm import sessionmaker, relationship

  196. from sqlalchemy import create_engine

  197. from sqlalchemy.sql import text

  198. from sqlalchemy.engine.result import ResultProxy

  199. from db import Users, Hosts
  200. engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6", max_overflow=0, pool_size=5)

  201. Session = sessionmaker(bind=engine)
  202. session = Session()
  203. 查询

  204. cursor = session.execute('select * from users')

  205. result = cursor.fetchall()

  206. 添加

  207. cursor = session.execute('insert into users(name) values(:value)',params={"value":'lqz'})

  208. session.commit()

  209. print(cursor.lastrowid)
  210. session.close()

  211. 10.一对多

  212. import time
  213. import threading
  214. from sqlalchemy.ext.declarative import declarative_base

  215. from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index

  216. from sqlalchemy.orm import sessionmaker, relationship

  217. from sqlalchemy import create_engine

  218. from sqlalchemy.sql import text

  219. from sqlalchemy.engine.result import ResultProxy

  220. from db import Users, Hosts, Hobby, Person
  221. engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8", max_overflow=0, pool_size=5)

  222. Session = sessionmaker(bind=engine)

  223. session = Session()
  224. 添加

  225. """

  226. session.add_all([

  227. Hobby(caption='乒乓球'),

  228. Hobby(caption='羽毛球'),

  229. Person(name='张三', hobby_id=3),

  230. Person(name='李四', hobby_id=4),

  231. ])
  232. person = Person(name='张九', hobby=Hobby(caption='姑娘'))

  233. session.add(person)
  234. 添加二

  235. hb = Hobby(caption='人妖')

  236. hb.pers = [Person(name='文飞'), Person(name='博雅')]

  237. session.add(hb)
  238. session.commit()

  239. """
  240. 使用relationship正向查询

  241. """

  242. v = session.query(Person).first()

  243. print(v.name)

  244. print(v.hobby.caption)

  245. """
  246. 使用relationship反向查询

  247. """

  248. v = session.query(Hobby).first()

  249. print(v.caption)

  250. print(v.pers)

  251. """
  252. 方式一,自己链表

  253. person_list=session.query(models.Person.name,models.Hobby.caption).join(models.Hobby,isouter=True).all()

  254. person_list=session.query(models.Person,models.Hobby).join(models.Hobby,isouter=True).all()

  255. for row in person_list:

  256. # print(row.name,row.caption)

  257. print(row[0].name,row[1].caption)
  258. 方式二:通过relationship

  259. person_list=session.query(models.Person).all()

  260. for row in person_list:

  261. print(row.name,row.hobby.caption)
  262. 查询喜欢姑娘的所有人

  263. obj=session.query(models.Hobby).filter(models.Hobby.id==1).first()

  264. persons=obj.pers

  265. print(persons)

  266. session.close()

  267. 11.多对多

  268. import time
  269. import threading
  270. from sqlalchemy.ext.declarative import declarative_base

  271. from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index

  272. from sqlalchemy.orm import sessionmaker, relationship

  273. from sqlalchemy import create_engine

  274. from sqlalchemy.sql import text

  275. from sqlalchemy.engine.result import ResultProxy

  276. from db import Users, Hosts, Hobby, Person, Group, Server, Server2Group
  277. engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8", max_overflow=0, pool_size=5)

  278. Session = sessionmaker(bind=engine)

  279. session = Session()
  280. 添加

  281. """

  282. session.add_all([

  283. Server(hostname='c1.com'),

  284. Server(hostname='c2.com'),

  285. Group(name='A组'),

  286. Group(name='B组'),

  287. ])

  288. session.commit()
  289. s2g = Server2Group(server_id=1, group_id=1)

  290. session.add(s2g)

  291. session.commit()
  292. gp = Group(name='C组')

  293. gp.servers = [Server(hostname='c3.com'),Server(hostname='c4.com')]

  294. session.add(gp)

  295. session.commit()
  296. ser = Server(hostname='c6.com')

  297. ser.groups = [Group(name='F组'),Group(name='G组')]

  298. session.add(ser)

  299. session.commit()

  300. """
  301. 使用relationship正向查询

  302. """

  303. v = session.query(Group).first()

  304. print(v.name)

  305. print(v.servers)

  306. """
  307. 使用relationship反向查询

  308. """

  309. v = session.query(Server).first()

  310. print(v.hostname)

  311. print(v.groups)

  312. """
  313. session.close()

  314. 12.其它

  315. import time
  316. import threading
  317. from sqlalchemy.ext.declarative import declarative_base

  318. from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index

  319. from sqlalchemy.orm import sessionmaker, relationship

  320. from sqlalchemy import create_engine

  321. from sqlalchemy.sql import text, func

  322. from sqlalchemy.engine.result import ResultProxy

  323. from db import Users, Hosts, Hobby, Person, Group, Server, Server2Group
  324. engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8", max_overflow=0, pool_size=5)

  325. Session = sessionmaker(bind=engine)

  326. session = Session()
  327. 关联子查询:correlate(Group)表示跟Group表做关联,as_scalar相当于对该sql加括号,用于放在后面当子查询

  328. subqry = session.query(func.count(Server.id).label("sid")).filter(Server.id == Group.id).correlate(Group).as_scalar()

  329. result = session.query(Group.name, subqry)

  330. """

  331. SELECT group.name AS group_name, (SELECT count(server.id) AS sid

  332. FROM server

  333. WHERE server.id = group.id) AS anon_1

  334. FROM group

  335. """

  336. '''
  337. select * from tb where id in [select id from xxx];
  338. select id,

  339. name,

  340. #必须保证此次查询只有一个值

  341. (select max(id) from xxx) as mid

  342. from tb
  343. 例如,第三个字段只能有一个值

  344. id name  mid

  345. 1  lqz   1,2  不合理

  346. 2  egon   2
  347. '''

  348. '''

  349. 成绩表:

  350. id sid    cid    score

  351. 1  1      物理      99

  352. 2  1      化学      88

  353. 3  2      物理      95
  354. 学生表:

  355. id   name  每个学生总分数

  356. 1     xx      88

  357. 2     yy       77
  358. select id,name,

  359. (select avr(score) from 成绩表 where 成绩表.sid=学生表.id) as x

  360. from 学生表

  361. subqry = session.query(func.count(成绩表.scort).label("sc")).filter(学生表.id == 成绩表.sid).correlate(学生表).as_scalar()

  362. result = session.query(学生表.name, subqry)
  363. '''
  364. 原生SQL

  365. """
  366. 查询

  367. cursor = session.execute('select * from users')

  368. result = cursor.fetchall()
  369. 添加

  370. cursor = session.execute('insert into users(name) values(:value)',params={"value":'wupeiqi'})

  371. session.commit()

  372. print(cursor.lastrowid)

  373. """
  374. session.close()

  375. 13.Flask-SQLAlchemy

  376. flaskSQLAchemy的管理者,通过他把他们做连接

  377. db = SQLAlchemy()
  378.     - 包含配置
  379.     - 包含ORM基类
  380.     - 包含create_all
  381.     - engine
  382.     - 创建连接
  383. 离线脚本,创建表

  384. 详见代码

  385. flask-migrate

  386. python3 manage.py db init 初始化:只执行一次

  387. python3 manage.py db migrate 等同于 makemigartions

  388. python3 manage.py db upgrade 等同于migrate

posted @
2019-10-21 19:32 小猿取经 阅读(...) 评论(...) 编辑 收藏

  1. </div>

SQLAlchemy,flask-sqlalchemy的更多相关文章

  1. flask SQLAlchemy中一对多的关系实现

    SQLAlchemy是Python中比较优秀的orm框架,在SQLAlchemy中定义了多种数据库表的对应关系, 其中一对多是一种比较常见的关系.利用flask sqlalchemy实现一对多的关系如 ...

  2. python3 + flask + sqlalchemy +orm(3):多对多关系

    一篇文章有多个tag,一个tag也可以属于多篇文章,文章和tag存在多对多关系 config.py DEBUG = True #dialect+driver://root:1q2w3e4r5t@127 ...

  3. python3 + flask + sqlalchemy +orm(2):数据库中添加表

    往数据库中添加一张保存文章的表,表明为article,字段有id,title,content 同样一个配置文件:config.py DEBUG = True #dialect+driver://roo ...

  4. python 全栈开发,Day142(flask标准目录结构, flask使用SQLAlchemy,flask离线脚本,flask多app应用,flask-script,flask-migrate,pipreqs)

    昨日内容回顾 1. 简述flask上下文管理 - threading.local - 偏函数 - 栈 2. 原生SQL和ORM有什么优缺点? 开发效率: ORM > 原生SQL 执行效率: 原生 ...

  5. flask, SQLAlchemy, sqlite3 实现 RESTful API 的 todo list, 同时支持form操作

    flask, SQLAlchemy, sqlite3 实现 RESTful API, 同时支持form操作. 前端与后台的交互都采用json数据格式,原生javascript实现的ajax.其技术要点 ...

  6. Flask SQLAlchemy & model

    Flask-SQLAlchemy Flask-SQLAlchemy库让flask更方便的使用SQLALchemy,是一个强大的关系形数据库框架,既可以使用orm方式操作数据库,也可以使用原始的SQL命 ...

  7. flask建表遇到的错误: flask,sqlalchemy.exc.OperationalError: (MySQLdb._exceptions.OperationalError) (1071, 'Specified key was too long; max key length is 767 bytes')

    error:flask,sqlalchemy.exc.OperationalError: (MySQLdb._exceptions.OperationalError) (1071, 'Specifie ...

  8. Flask – SQLAlchemy成员增加

    目录 简介 结构 展示 技术 运行 代码 创建数据库表单 views视图 home主页 添加成员addnew.html 展示页show_all 简介 结构 $ tree -I "__pyca ...

  9. Python Flask SQLALchemy基础知识

    一.介绍 SQLAlchemy是一个基于Python实现的ORM框架.该框架建立在 DB API之上,使用关系对象映射进行数据库操作,简言之便是:将类和对象转换成SQL,然后使用数据API执行SQL并 ...

  10. Flask+SQLAlchemy+alembic+Flask-RESTful使用

    前言 其实准备把这篇删掉,先写Flask-restful相关的,后来想想大体框架还是先写出来,这两天踩了很多坑,有的谷歌也没有答案.一直摸索也总算是开始了. 正文 SQLAlchemy/alembic ...

随机推荐

  1. FIB表与RIB表的区别与联系

    RIB (route information base) 和 FIB (forwarding information base),又称Ip路由表 和 CEF表,它们之间的关系可以用下面这张图片来高度概 ...

  2. 【python基础语法】第5天作业练习题

    import random """ 1.一家商场在降价促销.如果购买金额50-100元(包含50元和100元)之间,会给10%的折扣(打九折), 如果购买金额大于100元 ...

  3. VMware与Centos系统安装之重置root密码

    VMware与Centos系统安装之重置root密码   今日任务 1.Linux发行版的选择 2.vmware创建一个虚拟机(centos) 3.安装配置centos7 4.xshell配置连接虚拟 ...

  4. Python3中的支持向量机SVM的使用(有实例)

    https://www.cnblogs.com/luyaoblog/p/6775342.html 首先,我们需要安装scikit-learn 一.导入sklearn算法包  在python中导入sci ...

  5. Mybatis和Hibernate面试问题及答案

    1.@Qualifier 注解 答:当有多个相同类型的bean却只有一个需要自动装配时,将@Qualifier 注解和@Autowire 注解结合使用以消除这种混淆,指定需要装配的确切的bean.   ...

  6. 什么是json? 什么是xml?JSON与XML的区别比较

    JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式.它使得人们很容易的进行阅读和编写.同时也方便了机器进行解析和生成.它是基于 JavaScript Prog ...

  7. 手动安装 saltshaker-plus 版本选择特别说明(后期重点讲解Docker安装方式)

    前后端都建议使用1.12版本

  8. Tomcat配置绝对路径

    JSP访问项目工程下的地址 <video width="640" height="264" controls src="http://local ...

  9. c#获取所有枚举

    获取所有的枚举 1.将所有的枚举单独成一个项目 2.通Assembly加载程序集 3.通过Assembly对象的GetTypes获取所有的枚举类型 4.通过Enum.GetValues可以得到枚举的所 ...

  10. python爬虫----爬取阿里数据银行websocket接口

    业务需求:爬取阿里品牌数据银行的自定义模块==>>>人群透视==>>>查看报告==>>数据 发现:数据通过websocket接口传递,此类型接口的详细理 ...