MySql数据库安装：省略

SQLAlchemy介绍和基本使用：

数据库是开发网站的基础，，在Flask中，支持的数据库有：MySql，PostgreSql，SQLite，Redis，MongoDB来写原生的语言实现功能，也可以使用高级别的数据库抽象方式，例如SQLAlchemy或者MongoEngine这样的ORM.

除此之外，还需要在python中安装pymsql,以及SQLAlchemy

SQLAlchemy可以独立于Flask使用，对数据库进行操作，可以避免写sql语句。

连接的格式：dialect+driver://username:password@host:port/database

SQLAlchemy连接数据库实例代码：

# -*- coding: utf-8 -*-
from sqlalchemy import create_engineHOST_NAME = "127.0.0.1"
PORT = "3306"
DATABASE = "cms"
USERNAME = "root"
PASSWORD = "root1234"# dialect+driver://username:password@host:port/databaseDB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{database}".format(username=USERNAME, password=PASSWORD, host=HOST_NAME, port=PORT, database=DATABASE
)# 创建数据库引擎
engine = create_engine(DB_URI)conn = engine.connect()result = conn.execute("select 1")
print(result.fetchone())

数据库ORM介绍：

使用SQLAlchemy可以写原生的sql语句，也可以使用数据库ORM对数据库进行操作，ORM(Object Relation MAP)，及对象关系映射，即数据库表与模型对象之间的映射。将数据库中的表与python中的类映射起来。

这样主要是为了解决：

1. SQL语句重复利用率不高，且越复杂的sql语句条件越多，代码越长，会出现很多相近的SQL语句。

2. 很多SQL语句是在业务逻辑中拼出来的，如果有数据库需要更改，就要去修改大量的sql语句，容易造成错误及遗漏

3. 写sql时容易忽略web安全问题，给未来造成隐患。

ORM优点：

1. 易用性：使用ORM做数据库开发，可以有效减少重复SQL语句，写出来的模型更加的直观，清晰

2. 性能损耗小：ORM转换成底层数据库指令会有一些开销，但是通过不断的优化，这种性能开销已经非常小，且综合考虑易用性，这种损耗是值得的。（数据：性能损耗不足5%）

3. 设计灵活：可以轻松写出复杂的查询

4. 可移植性：SQLAlchemy封装了底层的数据库实现，支持多个关系数据库引擎，可以非常容易的切换数据库。

映射的步骤：

1. 用declarative_base根据engine创建一个ORM基类Base

2. 用Base作为基类创建自定义的ORM类，定义__tablename__属性来指定创建好的表名，

3. 创建属性来映射到表中的字段，所有的属性都应该为Column类型

4. 使用Base.metadata.create_all()来将模型映射到数据库中

# -*- coding: utf-8 -*-
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_baseHOST_NAME = "127.0.0.1"
PORT = "3306"
DATABASE = "cms"
USERNAME = "root"
PASSWORD = "root1234"# dialect+driver://username:password@host:port/databaseDB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{database}".format(username=USERNAME, password=PASSWORD, host=HOST_NAME, port=PORT, database=DATABASE
)# 创建数据库引擎
engine = create_engine(DB_URI)
Base = declarative_base(engine)   # 通过继承Base创建ORM模型/ 创建基类# 1. 创建ORM模型，必须继承自SQLAlchemy：
# 2. 在ORM中创建一些属性，跟表中的字段一一映射，这些属性必须是SQLAlchemy提供的数据类型
# 3. 将创建好的ORM模型映射到数据库中class Person(Base):__tablename__ = "person"     # 定义表的名字id = Column(Integer, primary_key=True, autoincrement=True)      # 创建字段name = Column(String(50))age = Column(Integer)Base.metadata.create_all()

运行脚本，在cms数据库中创建表person:

将模型映射到数据库之后，即使改变了类中的属性重新运行代码，也不会重新映射模型。

SQLALchemy属性常用数据类型：

1. Column常用参数

default：默认值

nullable：是否可空

primary_key：是否为主键

unique：是否唯一

autoincrement：是否自动增长

name：该属性在数据库中的映射字段

onupdate: 如果数据库中某个字段被更新了，则onupdate=True的字段的值也会随着更新。（例如，一篇文章的更新时间的属性可以设置位onupdate=True, 当文章的标题被修改后，对应的更新时间也会发生变化）

2. 常用数据类型

Integer：整形，映射到数据库中是int类型

Float：浮点类型，32位，会出现精度丢失

Double：浮点类型，64位，会出现精度丢失

Boolean：传递True/False进去

DECIMAL：定点类型，不会出现精度丢失，有参数，DECIMAL(10,4), 存储10位长度的数字，精确到小数点后4位

enum：枚举类型， Enum('a', 'b', 'c')

Date：传递datetime.date()参数    (年月日)

DateTime：传递datetime.datetime()进去      （年月日时间）

Time：传递datetime.time()进去          （只有时间）

String：字符类型，使用时需要指定长度，区别于Text类型

Text：文本类型

LONGTEXT：长文本类型

# -*- coding: utf-8 -*-
# -*- coding: utf-8 -*-
from sqlalchemy import create_engine, Column, Integer, String, DateTime
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from datetime import datetimeHOST_NAME = "127.0.0.1"
PORT = "3306"
DATABASE = "cms"
USERNAME = "root"
PASSWORD = "root1234"# dialect+driver://username:password@host:port/databaseDB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{database}".format(username=USERNAME, password=PASSWORD, host=HOST_NAME, port=PORT, database=DATABASE
)# 创建数据库引擎
engine = create_engine(DB_URI)
Base = declarative_base(engine)   # 通过继承Base创建ORM模型/ 创建基类db_session = sessionmaker(engine)()   # 创建会话，才能实现增删改查
# 1. 创建ORM模型，必须继承自SQLAlchemy：
# 2. 在ORM中创建一些属性，跟表中的字段一一映射，这些属性必须是SQLAlchemy提供的数据类型
# 3. 将创建好的ORM模型映射到数据库中class Article(Base):__tablename__ = "article"id = Column(Integer, primary_key=True, autoincrement=True)view_cnt = Column(Integer, default=0)title = Column(String(50), nullable=False)create_time = Column(DateTime, default=datetime.now)   # 创建时间Base.metadata.drop_all()
Base.metadata.create_all()artice = Article(title="Gone With Wind", view_cnt=11)
db_session.add(artice)
db_session.commit()      # 提交

可以查询数据库中的数据：

还可以使用一个方法：

artice1 = Article(title="Gone With Wind", view_cnt=11)
artice2 = Article(title="Gone With Wind", view_cnt=11)
db_session.add_all([artice1, artice2])
db_session.commit()      # 提交

# -*- coding: utf-8 -*-
# -*- coding: utf-8 -*-
from sqlalchemy import create_engine, Column, Integer, String, DateTime
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from datetime import datetimeHOST_NAME = "127.0.0.1"
PORT = "3306"
DATABASE = "cms"
USERNAME = "root"
PASSWORD = "root1234"# dialect+driver://username:password@host:port/databaseDB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{database}".format(username=USERNAME, password=PASSWORD, host=HOST_NAME, port=PORT, database=DATABASE
)# 创建数据库引擎
engine = create_engine(DB_URI)
Base = declarative_base(engine)   # 通过继承Base创建ORM模型/ 创建基类db_session = sessionmaker(engine)()   # 创建会话，才能实现增删改查
# 1. 创建ORM模型，必须继承自SQLAlchemy：
# 2. 在ORM中创建一些属性，跟表中的字段一一映射，这些属性必须是SQLAlchemy提供的数据类型
# 3. 将创建好的ORM模型映射到数据库中class Article(Base):__tablename__ = "article"id = Column(Integer, primary_key=True, autoincrement=True)view_cnt = Column(Integer, default=0)title = Column(String(50), nullable=False)create_time = Column(DateTime, default=datetime.now)   # 创建时间update_time = Column(DateTime, default=datetime.now, onupdate=datetime.now)# create_time必须同时指定default值和onupdate值,在第一次插入数据的时候会有时间，# 在修改数据的时候也会更新时间Base.metadata.drop_all()
Base.metadata.create_all()artice1 = Article(title="Gone With Wind", view_cnt=11)
artice2 = Article(title="Jane Austing")
db_session.add_all([artice1, artice2])
db_session.commit()      # 提交# article = db_session.query(Article).first()
# article.title = "Jane Aye"
# db_session.commit()   # 提交

数据展示：

现在对数据进行修改：

# -*- coding: utf-8 -*-
# -*- coding: utf-8 -*-
from sqlalchemy import create_engine, Column, Integer, String, DateTime
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from datetime import datetimeHOST_NAME = "127.0.0.1"
PORT = "3306"
DATABASE = "cms"
USERNAME = "root"
PASSWORD = "root1234"# dialect+driver://username:password@host:port/databaseDB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{database}".format(username=USERNAME, password=PASSWORD, host=HOST_NAME, port=PORT, database=DATABASE
)# 创建数据库引擎
engine = create_engine(DB_URI)
Base = declarative_base(engine)   # 通过继承Base创建ORM模型/ 创建基类db_session = sessionmaker(engine)()   # 创建会话，才能实现增删改查
# 1. 创建ORM模型，必须继承自SQLAlchemy：
# 2. 在ORM中创建一些属性，跟表中的字段一一映射，这些属性必须是SQLAlchemy提供的数据类型
# 3. 将创建好的ORM模型映射到数据库中class Article(Base):__tablename__ = "article"id = Column(Integer, primary_key=True, autoincrement=True)view_cnt = Column(Integer, default=0)title = Column(String(50), nullable=False)create_time = Column(DateTime, default=datetime.now)   # 创建时间update_time = Column(DateTime, default=datetime.now, onupdate=datetime.now)# create_time必须同时指定default值和onupdate值,在第一次插入数据的时候会有时间，# 在修改数据的时候也会更新时间# Base.metadata.drop_all()
# Base.metadata.create_all()
#
#
# artice1 = Article(title="Gone With Wind", view_cnt=11)
# artice2 = Article(title="Jane Austing")
# db_session.add_all([artice1, artice2])
# db_session.commit()      # 提交article = db_session.query(Article).first()   # 查询数据
article.title = "Jane Aye"                    # 修改数据
db_session.commit()   # 提交

数据展示：

可以看到，被修改的数据，title字段发生了变化，同时，update_time字段的值也随着更新了,但是update_time字段必须指定默认值，在第一次插入数据的时候使用。

query函数可查询的数据：

1. query可用参数：

/模型对象，指定查找这个模型中的所有的对象

/模型中的属性，可以指定查找某个模型的其中几个属性

/聚合函数，func.count, func.avg, func.max, func.min，func.sum

首先，在数据库中插入一些测试数据

# -*- coding: utf-8 -*-
from sqlalchemy import create_engine, Column, Integer, String, DateTime, Float, func
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from datetime import datetime
import randomHOST_NAME = "127.0.0.1"
PORT = "3306"
DATABASE = "cms"
USERNAME = "root"
PASSWORD = "root1234"# dialect+driver://username:password@host:port/databaseDB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{database}".format(username=USERNAME, password=PASSWORD, host=HOST_NAME, port=PORT, database=DATABASE
)# 创建数据库引擎
engine = create_engine(DB_URI)
Base = declarative_base(engine)   # 通过继承Base创建ORM模型/ 创建基类db_session = sessionmaker(engine)()   # 创建会话，才能实现增删改查
# 1. 创建ORM模型，必须继承自SQLAlchemy：
# 2. 在ORM中创建一些属性，跟表中的字段一一映射，这些属性必须是SQLAlchemy提供的数据类型
# 3. 将创建好的ORM模型映射到数据库中class Article(Base):__tablename__ = "article"id = Column(Integer, primary_key=True, autoincrement=True)title = Column(String(50), nullable=False)price = Column(Float, nullable=False)def __repr__(self):return "<article>" + str(self.id) + " | " + self.title + " | " + str(self.price)# Base.metadata.drop_all()
# Base.metadata.create_all()# 数据库中插入测试数据
# for cnt in range(10):
#     article = Article(title="article" + str(cnt), price=random.randint(25, 100))
#     db_session.add(article)
# db_session.commit()      # 提交# 查询数据
articles = db_session.query(Article).all()   # 查询数据   # 返回article对象
for article in articles:print(article)print("-"*50)
articles_title_price = db_session.query(Article.title, Article.price).all()   # 返回元组
for data in articles_title_price:print(data)print("-"*50)
# 聚合函数
count = db_session.query(func.count(Article.id)).all()
print("共有{}条数据".format(count[0]))average_price = db_session.query(func.avg(Article.price)).all()
print("平均值{}".format(average_price[0]))

filter函数实现条件过滤：

过滤是数据提取中的一个重要的功能，常用的过滤功能有：

1. equals

2. not equals

3. like    做匹配   ilike 不区分大小写

4. in

5. not in

6. is null

7. is not null

8. and

9. or

示例代码：

# -*- coding: utf-8 -*-
# -*- coding: utf-8 -*-
from sqlalchemy import create_engine, Column, Integer, String, DateTime, Float, func
from sqlalchemy import and_, or_
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from datetime import datetime
import randomHOST_NAME = "127.0.0.1"
PORT = "3306"
DATABASE = "cms"
USERNAME = "root"
PASSWORD = "root1234"# dialect+driver://username:password@host:port/databaseDB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{database}".format(username=USERNAME, password=PASSWORD, host=HOST_NAME, port=PORT, database=DATABASE
)# 创建数据库引擎
engine = create_engine(DB_URI)
Base = declarative_base(engine)   # 通过继承Base创建ORM模型/ 创建基类db_session = sessionmaker(engine)()   # 创建会话，才能实现增删改查
# 1. 创建ORM模型，必须继承自SQLAlchemy：
# 2. 在ORM中创建一些属性，跟表中的字段一一映射，这些属性必须是SQLAlchemy提供的数据类型
# 3. 将创建好的ORM模型映射到数据库中class Article(Base):__tablename__ = "article"id = Column(Integer, primary_key=True, autoincrement=True)title = Column(String(50), nullable=False)price = Column(Float, nullable=False)def __repr__(self):return "<article>" + str(self.id) + " | " + self.title + " | " + str(self.price)# Base.metadata.drop_all()
# Base.metadata.create_all()# 数据库中插入测试数据
# for cnt in range(10):
#     article = Article(title="article" + str(cnt), price=random.randint(25, 100))
#     db_session.add(article)
# db_session.commit()      # 提交# equal
articles = db_session.query(Article).filter(Article.id == 1).all()   # 查询数据   # 返回article对象
for article in articles:print(article)# not equal
print("-"*50)
articles = db_session.query(Article).filter(Article.title != "title2").all()   # 查询数据   # 返回article对象
for article in articles:print(article)# like
print("-"*50)
articles_title_price = db_session.query(Article).filter(Article.title.like("shel%")).all()   # 返回元组
for data in articles_title_price:print(data)# in_
print("-"*50)
articles = db_session.query(Article).filter(Article.title.in_(["shell", "article3", "article1"])).all()
for article in articles:print(article)# not in
print("-"*50)
articles = db_session.query(Article).filter(~Article.title.in_(["shell", "article3", "article1"])).all()
for article in articles:print(article)# is null
print("-"*50)
articles = db_session.query(Article).filter(Article.title is None).all()
for article in articles:print(article)# is not null
print("-"*50)
articles = db_session.query(Article).filter(Article.title is not None).all()
for article in articles:print(article)# and 用于多个条件连接   and_也可以用
print("-"*50)
articles = db_session.query(Article).filter(Article.title == "article8",Article.id == 9).all()
for article in articles:print(article)# or 用于多个条件连接
print("-"*50)
articles = db_session.query(Article).filter(or_(Article.title == "article8",Article.id == 2)).all()
for article in articles:print(article)

如果想查看原生的SQL语句，可以不在后面加all()或者first()

外键及其四种约束

1. 外键：是多表之间进行关联的基础，SQLAlchemy同样也支持外键，同构foreignKey来实现，并且可以指定表的外键约束。

# -*- coding: utf-8 -*-from sqlalchemy import create_engine, Column, Integer, String, DateTime, Float, func
from sqlalchemy import Text, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from datetime import datetime
import randomHOST_NAME = "127.0.0.1"
PORT = "3306"
DATABASE = "cms"
USERNAME = "root"
PASSWORD = "root1234"# dialect+driver://username:password@host:port/databaseDB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{database}".format(username=USERNAME, password=PASSWORD, host=HOST_NAME, port=PORT, database=DATABASE
)# 创建数据库引擎
engine = create_engine(DB_URI)
Base = declarative_base(engine)   # 通过继承Base创建ORM模型/ 创建基类db_session = sessionmaker(engine)()   # 创建会话，才能实现增删改查
# 1. 创建ORM模型，必须继承自SQLAlchemy：
# 2. 在ORM中创建一些属性，跟表中的字段一一映射，这些属性必须是SQLAlchemy提供的数据类型
# 3. 将创建好的ORM模型映射到数据库中class Article(Base):__tablename__ = "article"id = Column(Integer, primary_key=True, autoincrement=True)title = Column(String(50), nullable=False)content = Column(Text, nullable=False)uid = Column(Integer, ForeignKey("user.id"), nullable=False)  # 创建外键def __repr__(self):return "<article>" + str(self.id) + " | " + self.title + " | " + " | " + str(self.uid)class User(Base):__tablename__ = "user"id = Column(Integer, primary_key=True, autoincrement=True)username = Column(String(50), nullable=False)Base.metadata.drop_all()
Base.metadata.create_all()

使用SQLAlchemy创建外键，需要在从表中增加一个字段，指定这个字段外键的是哪个表的哪个字段即可，从表中外键的字段，必须和父表的主键字段类型保持一致。

外键约束： 由于从表会引用主表中的字段，从表中的总段记录删除，主表中的数据应该如何变化呢？

外键约束有以下几项：
RESTRICT：父表数据被删除，会阻止删除

NO ACTION：在mysql中，同RESTRICT

CASCADE：级联删除，父表中的数据删除，子表中的数据也跟随删除

SET NULL：父表数据被删除，子表数据相应的字段会被设置位null

class Article(Base):__tablename__ = "article"id = Column(Integer, primary_key=True, autoincrement=True)title = Column(String(50), nullable=False)content = Column(Text, nullable=False)uid = Column(Integer, ForeignKey("user.id", ondelete="RESTRICT"), nullable=False)  # 创建外键# ondelete表示的是外键的约束def __repr__(self):return "<article>" + str(self.id) + " | " + self.title + " | " + " | " + str(self.uid)

ORM层面外键的优化使用，以及一对多的关系

在两个表中查询数据：

# -*- coding: utf-8 -*-from sqlalchemy import create_engine, Column, Integer, String, DateTime, Float, func
from sqlalchemy import Text, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from datetime import datetime
import randomHOST_NAME = "127.0.0.1"
PORT = "3306"
DATABASE = "cms"
USERNAME = "root"
PASSWORD = "root1234"# dialect+driver://username:password@host:port/databaseDB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{database}".format(username=USERNAME, password=PASSWORD, host=HOST_NAME, port=PORT, database=DATABASE
)# 创建数据库引擎
engine = create_engine(DB_URI)
Base = declarative_base(engine)   # 通过继承Base创建ORM模型/ 创建基类db_session = sessionmaker(engine)()   # 创建会话，才能实现增删改查
# 1. 创建ORM模型，必须继承自SQLAlchemy：
# 2. 在ORM中创建一些属性，跟表中的字段一一映射，这些属性必须是SQLAlchemy提供的数据类型
# 3. 将创建好的ORM模型映射到数据库中class Article(Base):__tablename__ = "article"id = Column(Integer, primary_key=True, autoincrement=True)title = Column(String(50), nullable=False)content = Column(Text, nullable=False)uid = Column(Integer, ForeignKey("user.id", ondelete="RESTRICT"), nullable=False)  # 创建外键# ondelete表示的是外键的约束def __repr__(self):return "<article>" + str(self.id) + " | " + self.title + " | " + " | " + str(self.uid)class User(Base):__tablename__ = "user"id = Column(Integer, primary_key=True, autoincrement=True)username = Column(String(50), nullable=False)def __repr__(self):return str(self.id) + " | " + self.usernamearticle = db_session.query(Article).first()
uid = article.uid
user = db_session.query(User).filter(User.id == uid).first()
print(article.title, article.content, user.username)

上述查找数据的方法过于繁琐，sqlAlchemy提供了更加简便和强大的方法：

一对多与多对一：

SQLAlchemy提供的relationship可以定义属性，在以后访问相关联的表的时候，就可以直接通过属性访问的方式进行访问

# -*- coding: utf-8 -*-from sqlalchemy import create_engine, Column, Integer, String, DateTime, Float, func
from sqlalchemy import Text, ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, relationship
from datetime import datetime
import randomHOST_NAME = "127.0.0.1"
PORT = "3306"
DATABASE = "cms"
USERNAME = "root"
PASSWORD = "root1234"# dialect+driver://username:password@host:port/databaseDB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{database}".format(username=USERNAME, password=PASSWORD, host=HOST_NAME, port=PORT, database=DATABASE
)# 创建数据库引擎
engine = create_engine(DB_URI)
Base = declarative_base(engine)   # 通过继承Base创建ORM模型/ 创建基类db_session = sessionmaker(engine)()   # 创建会话，才能实现增删改查
# 1. 创建ORM模型，必须继承自SQLAlchemy：
# 2. 在ORM中创建一些属性，跟表中的字段一一映射，这些属性必须是SQLAlchemy提供的数据类型
# 3. 将创建好的ORM模型映射到数据库中class Article(Base):__tablename__ = "article"id = Column(Integer, primary_key=True, autoincrement=True)title = Column(String(50), nullable=False)content = Column(Text, nullable=False)uid = Column(Integer, ForeignKey("user.id", ondelete="RESTRICT"), nullable=False)  # 创建外键# ondelete表示的是外键的约束author = relationship("User", backref="articles")    # relationship 一个Article对应一个authordef __repr__(self):return "<article>" + str(self.id) + " | " + self.title + " | " + " | " + str(self.uid)class User(Base):__tablename__ = "user"id = Column(Integer, primary_key=True, autoincrement=True)username = Column(String(50), nullable=False)# articles也可以通过在Article中赋值backref参数实现# articles = relationship("Article")  # relationship 一个author可能对应多个Articledef __repr__(self):return str(self.id) + " | " + self.usernamearticle = db_session.query(Article).first()
print(article.author.username)print("-"*50)
user = db_session.query(User).filter(User.id == article.uid).first()
print(user.articles)

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

Web后端学习笔记 Flask (5) 数据库相关推荐

1. Web后端学习笔记 Flask（1）基础知识

   基础的准备 1. 使用的python版本 python3.6 2. pycharm编辑器 3. 安装python虚拟环境: python中的虚拟环境: python中的虚拟环境相当于一个抽屉,在这个抽 ...

2. Web后端学习笔记Flask（2）模板

   模板渲染: 在flask中,视图函数可以直接通过render_template进行模板渲染.在flask中,模板文件是存放在template文件夹中:在调用模板文件的时候,模板文件的路径从templa ...

3. Web后端学习笔记 Flask（7）数据库

   高级查询: 1. group_by 根据某个字段进行分组,比如说需要根据某个字段分组,来统计每组有多少人. 2. having having是对查询结果进一步过滤,比如只想看到未成年人的数量,那么首先 ...

4. Web后端学习笔记 Flask（6）数据库

   SQLAlchemy一对一关系实现: 在一对多的条件下:给Article表中添加article,只需要将article放入到user的article属性中,再将user添加到user表中即可,此时的a ...

5. Web后端学习笔记 Flask（10）CSRF攻击原理

   CSRF(Cross Site Request Forgery,跨站域请求伪造)是一种网络的攻击方式,它在2007年曾被列为互联网20大安全隐患之一. CSRF攻击的原理: 网站是通过cookie实现 ...

6. Web后端学习笔记 Flask（9）cookie and session

   Flask_wtf除了可以做表单验证,模板渲染之外,还可以防御CSRF攻击.要了解CSRF攻击的原理,首先需要了解cookie和session的知识点. cookie:在网站中,HTTP请求是无状态的 ...

7. Web后端学习笔记 Flask（8） WTForms 表单验证，文件上传

   Flask-WTF是简化了WTForms操作的一个第三方库.WTForms表单的两个主要功能是验证用户提交数据的合法性以及渲染模板.同时还包含一些其他的功能.例如CSRF保护,文件上传等功能,安装fl ...

8. Web后端学习笔记 Flask （14）redis

   redis介绍: redis是一种noSQL数据库,它的数据是保存在内存中,同时,redis可以定时把内存中的数据同步到磁盘,即可以将数据持久化,并且它比memcached支持更多的数据结构,stri ...

9. Web后端学习笔记 Flask（13）memcached

   memcached介绍: memcached相当于一个内存的缓存系统,数据原本是存储在数据库当中,memcached是一个内存级别的缓存系统,可以把数据存到内存当中,此时的访问速度就会更快.设计它的初 ...

最新文章

1. quartus FIR仿真笔记
2. flask笔记3-模板
3. 微信扫码登录实现原理
4. 深度学习与神经网络——邱锡鹏
5. python 类函数 成员函数_python内置函数类型，如何为新类型定义成员函数？
6. 8-汇编语言数据长度及寻址-bx/si/di/bp+ss+ptr+div+dd+dup
7. openstack RC文件的使用
8. 1160. 不容易系列之二
9. BF算法（Java实现）
10. 我们要做一个靠谱的人~以信而立天下
11. 玩机搞机---小米机型格机 檫除分区后修复nv损坏问题的硬件类修复步骤解析
12. qq邮箱发送邮件到163邮箱
13. tomcat服务器缓存配置文件,Tomcat7服务器配置Cache-Control和Expires
14. 美国虚拟PSTN号码
15. 关系抽取Casrel实现(Pytorch版)
16. 实验报告微型计算机拆卸顺序表,顺序表的操作实验报告馒头制作.doc
17. upload-labs上传漏洞记录
18. 评：Linux多线程服务端编程
19. puuty链接linux时间超时,Putty连接Linux提示timed out的解决办法
20. PSPNet Caffe 编译安装

热门文章

1. K8S_Google工作笔记0004---平台规划和部署方式介绍_搭建k8s集群准备
2. ASP.Net学习笔记013--ViewState初探2
3. 微信公众开放平台开发01---微信公众平台介绍,以及开发准备
4. isalnum c语言函数
5. The reference to entity characterEncoding must end with the ';' delimiter
6. 杭电2571 命运
7. unsigned char bcd串乱码问题解决
8. java中criteria类_java – Criteria API：按类类型过滤
9. linux驱动编写（dma驱动）
10. 解析超大文件_MySQL物理文件结构和SQL执行流程