目录
Flask
1 flask简介
Flask是一个Python编写的Web 微框架，让我们可以使用Python语言快速实现一个网站或Web服务
django是一个大而全的web框架，它内置许多模块，flask是一个小而精的轻量级框架
Django功能大而全，Flask只包含基本的配置, Django的一站式解决的思路，能让开发者不用在开发之前就在选择应用的基础设施上花费大量时间。Django有模板，表单，路由，基本的数据库管理等等内建功能。与之相反，Flask只是一个内核，默认依赖于2个外部库： Jinja2 模板引擎和 WSGI工具集--Werkzeug , flask的使用特点是基本所有的工具使用都依赖于导入的形式去扩展，flask只保留了web开发的核心功能。
WSGI（web服务器网关接口）是python中用来规定web服务器如何与python Web服务器如何与Python Web程序进行沟通的标准，本质上就是一个socket服务端。而 Werkzeug模块 就是WSGI一个具体的实现
关键词：一个Python编写微web框架 一个核心两个库( Jinja2 模板引擎 和 WSGI工具集)
2 flask的简单使用
# 1 安装
pip install flask
flask的依赖包：
Jinja2-2.10 渲染模板引擎工具集
MarkupSafe-1.1.0 可以识别HTML转义规则。HTML字符转义工具集
Werkzeug-0.14.1 Web 框架的底层库，提供了请求及响应以及开发服务器的功能，简称WSGI工具集
click-7.0 命令行工具集
itsdangerous-1.1.0 加密工具集
# 2 使用
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'Hello World!'
if __name__ == '__main__':
app.run()
# 实际开发时不会使用run运行，因为性能过低
# 直接运行该py文件即可开启一个最简单的web项目
# 相比于django，灵活性完全不是一个等级
3 web三板斧
与django中的三板斧相同，flask也可以使用模板，直接返回字符串，重定向
django flask
HttpResponse()--->直接写字符串
render()--------->render_template('index.html')
redirect()------->redirect()
# 注意点：html文件必须在templates文件夹下！！！！
from flask import Flask, redirect, render_template
app = Flask(__name__)
@app.route('/')
def hello_world():
return '字符串'
return render_template('index.html')
# 注意点：html文件必须在templates文件夹下！！！！
return redirect('/login')
4 路由
4.1 路由基本使用
flask中的路由是通过为装饰器传参实现的
# 路由写法：@app.route（路径，允许的请求方式，FBV别名）
# 路径与django2中的path相同，不是正则匹配
# 别名可用于反向解析，如果不填写默认为FBV的函数名
# 允许的请求方式注意写列表，内部为大写的请求方式字符串，不写默认为只允许GET请求
@app.route('/login',methods=['GET','POST'],endpoint='l1')
def hello_world():
return 'Hello World!'
4.2 有名分组
路由还可以使用有名分组以及转换器
@app.route('/student_list/<student_id>/')
def student_list(student_id):
# 注意函数的形参必须与路由中的名字一样
return '学生{}号的信息'.format(student_id)
@app.route('/student_list/<int:student_id>/')
def article_detail(student_id):
# 注意函数的形参必须与路由中的名字一样
return '学生{}号的信息'.format(student_id)
4.3 转换器
DEFAULT_CONVERTERS = {
'default': UnicodeConverter,
'string': UnicodeConverter,
'any': AnyConverter,
'path': PathConverter,
'int': IntegerConverter,
'float': FloatConverter,
'uuid': UUIDConverter,
}
string: 默认的数据类型，接收没有任何斜杠"\ /"的字符串
int: 整型
float: 浮点型
path: 和string类型相似，但是接受斜杠，如：可以接受参数/aa/bb/cc/多条放在一起
uuid: 只接受uuid格式的字符串字符串
any: 可以指定多种路径
@app.route('/<any(student,class):url_path>/<id>/')
def item(url_path, id):
if url_path == 'student':
return '学生{}详情'.format(id)
else:
return '班级{}详情'.format(id)
4.4 查询字符串
from flask import Flask,request
# url地址中的查询字符串可以通过request.args获取
@app.route('/student_name/')
def school_name_list():
name = request.args.get('name')
age = request.args.get('age')
return "学生的姓名为{}，年龄为{}".format(name, age)
4.5 反向解析
flask路由可以通过endpoint即别名反向获取该视图函数的路由地址，这就是反向解析
4.5.1 无分组的反向解析
@app.route('/')
def demo1():
print(url_for("book"))
# 注意这个引用的是endpoint，如果没起别名默认为视图函数名字
print(type(url_for("book")))
return url_for("book")
4.5.2 含分组的反向解析
url_for传了别名后还可以传其他参数
优先满足有名分组的需求，剩余的作为查询字符串传入
# student视图函数需要传一个id才能做反向解析
@app.route('/student/<int:id>/')
def student(id):
return 'student {}'.format(id)
@app.route('/demo2/')
def demo2():
student_url = url_for('student', id=5, name='mark') # id 就是动态path的key 必须赋值， # name 将作为查询字符串传入
print(student_url)
return student_url
4.5.3 反向解析添加查询字符串
@app.route('/demo3/')
def demo3():
school_url = url_for('school', school_level='high', name='college')
# 具体要拼接的查询参数 以关键字实参的形式写在url_for里
print(school_url)
return school_url
@app.route('/school/')
def school():
return 'school message'
4.5.4 正则匹配路由/自定义匹配规则
我们可以通过继承werkzeug.routing 的BaseConverter类从而自己定义一个动态路由过滤器的规则
from flask import Flask,request
from werkzeug.routing import BaseConverter
app = Flask(__name__)
app.debug =True
class TelephoneConverter(BaseConverter):
regex = '1[3857]\d{9}' # 正则规则
app.url_map.converters['tel'] = TelephoneConverter
@app.route('/student/<tel:telenum>/')
def student_detail(telenum):
return '学生的手机号码是{}'.format(telenum)
if __name__ == '__main__':
app.run()
1.自定义动态路由过滤器类，该类必须继承werkzeug.routing 的BaseConverter类
2.通过类内添加regex属性指定路由规则
3.将自定义的类映射到app.url_map.converters中（其本质是一个字典）
app.url_map.converters['tel'] = TelephoneConverter
自定义动态路由过滤器之处理动态路由
自定义一个类，该通过继承`werkzeug.routing 的BaseConverter`类不光可以实现正则匹配，我们介绍一下以下两个方法：
- 在该类中实现 to_python 方法：
这个方法的返回值，将会传递给视图函数的形参。我们可以利用这个方法实现处理url中动态路由部分。
- 在该类中实现 to_url 方法：
翻转url的时候也就是使用url_for函数的时候，我们传入指定的动态路由部分，触发to_url方法，这个方法的返回值，会拼接在非动态路由上，从而实现生成符合要求的url格式。
from flask import Flask,request,url_for
from werkzeug.routing import BaseConverter
app = Flask(__name__)
app.debug =True
class ListConverter(BaseConverter):
regex = '.*' # 这个regex代表都匹配的意思，可以根据自己的需求制定url规则
def to_python(self, value):
'''这个函数用于拿到了路由里的动态参数赋值给value，
可以在to_python进行操作动态参数，
返回操作完的的结果给视图函数的形参'''
return value.split('+')
def to_url(self, value):
'''这个函数用于和url_for连用，
url_for通过指定给动态参数(以关键字实参的形式)赋值给value
我们可以根据我们的需求操作url_for传进来的参数，
然后返回一个理想的动态路由内容拼接在url上'''
return '+'.join(value)
app.url_map.converters['list'] = ListConverter
@app.route('/student_list/<list:students>/')
def student_list(students):
print(url_for('student_list',students=['a','b'])) # 输出 /student_list/a+b/
return '{}'.format(students)
if __name__ == '__main__':
app.run()
4.6 路由的本质
路由本质就是：app.add_url_rule()
endpoint：如果不写默认是函数名，endpoint不能重名
def route(self, rule, **options):
...
def decorator(f):
endpoint = options.pop('endpoint', None)
self.add_url_rule(rule, endpoint, f, **options)
return f
return decorator
@setupmethod
def add_url_rule(self, rule, endpoint=None, view_func=None,
provide_automatic_options=None, **options):
...
if endpoint is None:
endpoint = _endpoint_from_view_func(view_func)
options['endpoint'] = endpoint
methods = options.pop('methods', None)
if methods is None:
methods = getattr(view_func, 'methods', None) or ('GET',)
app.add_url_rule参数
@app.route和app.add_url_rule参数:
rule, URL规则
view_func, 视图函数名称
defaults = None, 默认值, 当URL中无参数，函数需要参数时，使用defaults = {'k': 'v'}为函数提供参数
endpoint = None, 名称，用于反向生成URL，即： url_for('名称')
methods = None, 允许的请求方式，如：["GET", "POST"]
#对URL最后的 / 符号是否严格要求,默认严格，False，就是不严格
strict_slashes = None
'''
@app.route('/index', strict_slashes=False)
# 访问http://www.xx.com/index/ 或http://www.xx.com/index均可
@app.route('/index', strict_slashes=True)
# 仅访问http://www.xx.com/index
'''
#重定向到指定地址
redirect_to = None,
'''
@app.route('/index/<int:nid>', redirect_to='/home/<nid>')
'''
5 模板语言
flask使用jinja2模版语法作为框架的默认模板引擎
# 基本与django的模版语法相同，支持过滤器，if，for等
# 不同点：jinja2中函数需要加括号执行，所以函数可以传入参数
{% for k,v in user_dict.items() %}
<tr>
<td>{{k}}</td>
<td>{{v.name}}</td>
<td>{{v['name']}}</td>
<td>{{v.get('name')}}</td>
<td><a href="/detail/{{k}}">查看详细</a></td>
</tr>
{% endfor %}
{{ url_for('static',filename='相对于static文件夹的路径') }}
<script src="{{ url_for('static',filename='js/demo.js') }}"></script>
{% with messages = get_flashed_messages() %} # 获取所有的闪现信息返回一个列表
{% endwith %}
{% with messages = get_flashed_messages(with_categories=true) %}
{% endwith %}
{% with messages = get_flashed_messages(category_filter=["username"]) %}
{% endwith %}
6 app配置方式
6.1 方式一
app.config['DEBUG'] = True
PS： 由于Config对象本质上是字典，所以还可以使用 app.config.update(...)
6.2 方式二(常用方案)
#通过py文件配置
app.config.from_pyfile("python文件名称")
# 如：
# settings.py
DEBUG = True
6.3 方式三
app.config.from_object('settings.TestingConfig')
class Config(object):
DEBUG = False
TESTING = False
DATABASE_URI = 'sqlite://:memory:'
class ProductionConfig(Config):
DATABASE_URI = 'mysql://user@localhost/foo'
class DevelopmentConfig(Config):
DEBUG = True
class TestingConfig(Config):
TESTING = True
7 request对象
flask中的request对象封装解析了请求报文中的数据，其大部分功能是由依赖包werkzeug完成的，并且每个request对象都是线程隔离的，保证了数据的安全性。
flask的request对象都是通过导入的request进行操作，并且能保证不同的请求取出的数据是当此请求的数据，非常神奇，详情可以阅读源码分析
from flask import Flask, request
requst对象的常用方法
print(request.path) # 输出 /student_list/
print(request.full_path) # 输出 /student_list/?name=mark
print(request.host) # 输出 127.0.0.1:5000
print(request.host_url) # 输出 http://127.0.0.1:5000/
print(request.base_url) # 输出 http://127.0.0.1:5000/student_list/
print(request.url) # 输出 http://127.0.0.1:5000/student_list/?name=mark
print(request.url_root) # 输出 http://127.0.0.1:5000/
request.method 提交的方法
request.args get请求提及的数据
request.query_string 查询字符串
request.form post请求提交的数据
request.values post和get提交的数据总和
request.cookies 客户端所带的cookie
request.headers 请求头
request.path 不带域名，请求路径
request.full_path 不带域名，带参数的请求路径
request.url 带域名带参数的请求路径
request.base_url 带域名请求路径
request.url_root 域名
request.host_url 域名
request.host 127.0.0.1:500
request.files 文件
request.json
request.is_json
request.data
request.referer
request.scheme
request.user_agent
8 视图
8.1 FBV
8.1.1 两种添加路由的方法
@app.route('/add_url_test/',endpoint='add_demo')
app.add_url_rule('/add_url_test/',endpoint='add_demo',view_func=add_url_test)
8.1.2 FBV添加装饰器
# 装饰器一定要写在注册路由的下面，写在视图函数的上面。
# 装饰器内部一定要使用@wraps(func)方法，用于保护被装饰函数的属性。
from flask import Flask, request
from functools import wraps
app = Flask(__name__)
def login_verify(func):
@wraps(func)
def wrapper(*args, **kwargs):
user_name = request.args.get('user')
password = request.args.get('password')
if user_name == 'mark' and password == '123':
return func(*args,**kwargs)
else:
return '请登录'
return wrapper
@app.route('/')
def hello_world():
return 'Hello World!'
@app.route('/my_info/')
@login_verify
def my_info():
return '个人信息页面'
8.2 CBV
8.2.1 CBV基本使用
# 1 从flask中导入 views
# 2 写一个类继承 views.MethodView
# 3 在类中写methods = ['GET','POST'] 可以指定可接受的请求类型
# 4 在类中写decorators = [login_verify,]可以指定装饰器，第一个装饰器是最里层函数依次往后包裹
# 5 在类中写def get(self):用于获取get请求
# 6 在类中写def post(self):用于获取post请求
# 7 添加路由的方法使用
app.add_url_rule('路由',view_func=CBVTest.as_view(name='自定义一个端点名字'))
# 其原理是CBVTest.as_view(name='自定义一个端点名字')会返回一个函数，name是为这个函数命的名字，可以通过这个函数进行分发请求等操作。
from flask import Flask, views, request, url_for
from functools import wraps
def login_verify(func):
@wraps(func)
def wrapper(*args, **kwargs):
user_name = request.args.get('user')
password = request.args.get('password')
if user_name == 'mark' and password == '123':
return func(*args,**kwargs)
else:
return '请登录'
return wrapper
class CBVTest(views.MethodView):
methods = ['GET','POST'] # 指定可以接收的方法有什么
decorators = [login_verify,] # 指定自定义的装饰器
def get(self):
print(url_for('cbvtest'))
return 'cbv_get'
def post(self):
return 'cbv_post'
app.add_url_rule('/cbvtest',view_func=CBVTest.as_view(name='cbvtest'),endpoint='end_demo')
8.2.2 路由参数
@app.route和app.add_url_rule参数:
# 常用参数：
rule： URL规则
view_func： 视图函数名称
endpoint = None： 名称，用于反向生成URL，即： url_for('名称')
methods = None： 允许的请求方式，如：["GET", "POST"]
# 不常用参数
strict_slashes = False 对URL最后的 / 符号是否严格要求
@app.route('/index', strict_slashes=False)
redirect_to=“ ” 重定向到指定地址
@app.route("/",redirect_to='/home/')
defaults = None 为函数提供默认参数值
当URL中无参数，函数需要参数时，使用defaults = {'k': 'v'}
subdomain=“ ” 子域名设置
from flask import Flask,url_for
app = Flask(__name__)
app.debug = True
'''
先在hosts设置域名解析(就是在本机的hosts文件上编辑上域名对应ip的关系)
域名解析会先解析本地如果没有再解析dns服务器
C:\Windows\System32\drivers\etc\hosts
127.0.0.1 mark.com
127.0.0.1 admin.mark.com
'''
app.config['SERVER_NAME'] = 'mark.com:5000' # 这个代表访问这个域名的时候要访问5000端口
@app.route("/")
def index():
return '设置域名成功'
@app.route("/admin_demo/",subdomain='admin')
def admin_demo():
return '设置子域名成功'
'''
在浏览器中访问主域名
mark.com:5000/
在浏览器中访问子域名
admin.mark.com:5000/admin_demo/
注意：后面跟的path路径部分正常写
'''
if __name__ == '__main__':
app.run(host='127.0.0.1',port=5000) # 测试服务器不稳定，尽量手动制定ip和端口
9 session
# SECRET_KEY:如果使用session，必须配置
# SESSION_COOKIE_NAME：cookie名字
# 数据库地址，端口号，也要放到配置文件中，但是不是内置的参数
# flask内置session如何实现的？
-通过SECRET_KEY加密以后，当做cookie返回给浏览器
-下次发送请求，携带cookie过来，反解，再放到session中
# 全局导入
# 视图函数中 session['key']=value
# 删除：session.pop('key')
# 取：session['key']
# open_session
# save_session
10 中间件
from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
return 'Hello World!'
# 模拟中间件
class Md(object):
def __init__(self,old_wsgi_app):
self.old_wsgi_app = old_wsgi_app
def __call__(self, environ, start_response):
print('开始之前')
ret = self.old_wsgi_app(environ, start_response)
print('结束之后')
return ret
if __name__ == '__main__':
#1我们发现当执行app.run方法的时候，最终执行run_simple，最后执行app(),也就是在执行app.__call__方法
#2 在__call__里面，执行的是self.wsgi_app().那我们希望在执行他本身的wsgi之前做点事情。
#3 所以我们先用Md类中__init__，保存之前的wsgi,然后我们用将app.wsgi转化成Md的对象。
#4 那执行新的的app.wsgi_app，就是执行Md的__call__方法。
#把原来的wsgi_app替换为自定义的，
app.wsgi_app = Md(app.wsgi_app)
app.run()
11 猴子补丁
# 什么是猴子补丁？
# 只是一个概念，不属于任何包和模块
# 利用了python一切皆对象的理念，在程序运行过程中，动态修改方法
# 概念
# class Monkey():
# def play(self):
# print('猴子在玩')
#
#
# class Dog():
# def play(self):
# print('狗子在玩')
#
# m=Monkey()
# # m.play()
# m.play=Dog().play
#
# m.play()
# 有什么用？
# 这里有一个比较实用的例子,
# 很多用到import json,
# 后来发现ujson性能更高,
# 如果觉得把每个文件的import json改成import ujson as json成本较高,
# 或者说想测试一下ujson替换是否符合预期, 只需要在入口加上:
# 只需要在程序入口
# import json
# import ujson
#
# def monkey_patch_json():
# json.__name__ = 'ujson'
# json.dumps = ujson.dumps
# json.loads = ujson.loads
# monkey_patch_json()
#
# aa=json.dumps({'name':'lqz','age':19})
# print(aa)
#协程：单线程下实现并发
# from gevent import monkey;monkey.patch_all()
# import gevent
# import time
# def eat():
# print('eat food 1')
# time.sleep(2)
# print('eat food 2')
#
# def play():
# print('play 1')
# time.sleep(1)
# print('play 2')
#
# g1=gevent.spawn(eat)
# g2=gevent.spawn(play)
# gevent.joinall([g1,g2])
# print('主')
12 蓝图（blueprint）
1 没有蓝图之前前，都是单文件
2 有了蓝图可以分文件，分app，之前的请求扩展还是一样用，只是在当前蓝图对象管理下的有效
3 蓝图使用
#第一步在app中注册蓝图，括号里是一个蓝图对象
app.register_blueprint(user.us)
# 第二步，在不同文件中注册路由时，直接使用蓝图对象注册，不用使用app了，避免了循环导入的问题
@account.route('/login.html', methods=['GET', "POST"])
4 中小型项目目录划分
项目名字
-pro_flask文件夹
-__init__.py
-templates
-login.html
-statics
-code.png
-views
-blog.py
-account.py
-user.py
-run.py
5 大型项目
项目名
-pro_flask文件夹
-__init__.py
-web
-__init__.py
-static
-views.py
-templates
-admin
-templates
-static
-views.py
-__init__.py
-run.py
13 响应对象的方法
# 响应对象
# 响应相关信息
# return "字符串"
# return render_template('html模板路径',**{})
# return redirect('/index.html')
# 对着django，JsonResponse
# return jsonify({'k1':'v1'})
aa='hello world'
res=make_response(aa)
res.set_cookie('xxx','lqz')
# 往响应头中放东西
res.headers['X-Something'] = 'A value'
print(type(res))
from flask.wrappers import Response
return res
# response = make_response(render_template('index.html'))
# response是flask.wrappers.Response类型
# response.delete_cookie('key')
# response.set_cookie('key', 'value')
# response.headers['X-Something'] = 'A value'
# return response
# return 'hello'
13.1 导出依赖包文件
varchr :65535个字节的数据
-utf8:中文2个字节，varchar（300）
-utf8mb4:3个字节，varchar（300）
# 快速导出requestment.txt
pip3 install pipreqs
# pipreqs ./ --encoding=utf-8
14 闪现
-设置:flash('aaa')
-取值：get_flashed_message()
-设置：flash('lqz',category='error1')
-取值：res=get_flashed_messages(category_filter=['error1'])
-假设在a页面操作出错，跳转到b页面，在b页面显示a页面的错误信息
15 请求扩展
1 类似于django的中间件，请求来了，请求走了，什么操作
# 1 请求来了就会触发,类似于django的process_request,如果有多个，顺序是从上往下
@app.before_request
def before(*args,**kwargs):
if request.path=='/login':
return None
else:
name=session.get('user')
if not name:
return redirect('/login')
else:
return None
# 2 # 请求走了就会触发,类似于django的process_response,如果有多个，顺序是从下往上执行
@app.after_request
def after(response):
print('我走了')
return response
#3 before_first_request 项目启动起来第一次会走，以后都不会走了，也可以配多个（项目启动初始化的一些操作）
@app.before_first_request
def first():
print('我的第一次')
# 4 每次视图函数执行完了都会走它，# 用来记录出错日志
@app.teardown_request # 用来记录出错日志
def ter(e):
print(e)
print('我是teardown_request ')
# 5 errorhandler绑定错误的状态码，只要码匹配，就走它
@app.errorhandler(404)
def error_404(arg):
return render_template('error.html',message='404错误')
#
# 6 全局标签
@app.template_global()
def sb(a1, a2):
return a1 + a2
# 在模板中：{{ sb(3,4) }}
# 7 全局过滤器
@app.template_filter()
def db(a1, a2, a3):
return a1 + a2 + a3
# 在模板中{{ 1|db(2,3)}}
1 重点掌握before_request和after_request，
2 注意有多个的情况，执行顺序
3 before_request请求拦截后（也就是有return值），response所有都执行
16 flask-session
# 1 替换flask内置的session，支持存到redis，存到数据库
#2 flask-session如何使用
方式一：
conn=redis.Redis(host='127.0.0.1',port=6379)
app.session_interface=RedisSessionInterface(conn,'lqz',permanent=False)
方式二：
# from redis import Redis
# from flask.ext.session import Session
# app.config['SESSION_TYPE'] = 'redis'
#
# app.config['SESSION_KEY_PREFIX'] = 'lqz'
#
# app.config['SESSION_REDIS'] = Redis(host='127.0.0.1',port='6379')
# # 本质跟上面一样
# # 类似的用法在flask中很常见 函数(app)
# Session(app)
# 问题1
-关闭浏览器cookie失效
app.session_interface=RedisSessionInterface(conn,key_prefix='lqz',permanent=False)
# 问题2
-cookie默认超时时间是多少？如何设置超时时间
'PERMANENT_SESSION_LIFETIME': timedelta(days=31),#这个配置文件控制
17 数据库连接池
# pip install DBUtils
# import pymysql
#
# from DBUtils.PooledDB import PooledDB
# import time
# from threading import Thread
# POOL = PooledDB(
# creator=pymysql, # 使用链接数据库的模块
# maxconnections=6, # 连接池允许的最大连接数，0和None表示不限制连接数
# mincached=2, # 初始化时，链接池中至少创建的空闲的链接，0表示不创建
# maxcached=5, # 链接池中最多闲置的链接，0和None不限制
# maxshared=3, # 链接池中最多共享的链接数量，0和None表示全部共享。PS: 无用，因为pymysql和MySQLdb等模块的 threadsafety都为1，所有值无论设置为多少，_maxcached永远为0，所以永远是所有链接都共享。
# blocking=True, # 连接池中如果没有可用连接后，是否阻塞等待。True，等待；False，不等待然后报错
# maxusage=None, # 一个链接最多被重复使用的次数，None表示无限制
# setsession=[], # 开始会话前执行的命令列表。
# ping=0,
# # ping MySQL服务端，检查是否服务可用。
# host='127.0.0.1',
# port=3306,
# user='root',
# password='123',
# database='flask',
# charset='utf8'
# )
#
#
# def func():
# # 检测当前正在运行连接数的是否小于最大链接数，如果不小于则：等待或报raise TooManyConnections异常
# # 否则
# # 则优先去初始化时创建的链接中获取链接 SteadyDBConnection。
# # 然后将SteadyDBConnection对象封装到PooledDedicatedDBConnection中并返回。
# # 如果最开始创建的链接没有链接，则去创建一个SteadyDBConnection对象，再封装到PooledDedicatedDBConnection中并返回。
# # 一旦关闭链接后，连接就返回到连接池让后续线程继续使用。
# conn = POOL.connection()
#
# # print(th, '链接被拿走了', conn1._con)
# # print(th, '池子里目前有', pool._idle_cache, '\r\n')
#
# cursor = conn.cursor()
# cursor.execute('select * from boy')
# result = cursor.fetchall()
# time.sleep(2)
# print(result)
# conn.close()
#
# if __name__ == '__main__':
# for i in range(10):
# t=Thread(target=func)
# t.start()
# import pymysql
# from settings import Config
# class SQLHelper(object):
#
# @staticmethod
# def open(cursor):
# POOL = Config.PYMYSQL_POOL
# conn = POOL.connection()
# cursor = conn.cursor(cursor=cursor)
# return conn,cursor
#
# @staticmethod
# def close(conn,cursor):
# conn.commit()
# cursor.close()
# conn.close()
#
# @classmethod
# def fetch_one(cls,sql,args,cursor =pymysql.cursors.DictCursor):
# conn,cursor = cls.open(cursor)
# cursor.execute(sql, args)
# obj = cursor.fetchone()
# cls.close(conn,cursor)
# return obj
#
# @classmethod
# def fetch_all(cls,sql, args,cursor =pymysql.cursors.DictCursor):
# conn, cursor = cls.open(cursor)
# cursor.execute(sql, args)
# obj = cursor.fetchall()
# cls.close(conn, cursor)
# return obj
# @classmethod
# def execute(cls,sql, args,cursor =pymysql.cursors.DictCursor):
# conn, cursor = cls.open(cursor)
# cursor.execute(sql, args)
# cls.close(conn, cursor)
18 wtforms（forms组件）
1 校验数据
2 渲染标签
详见代码
19 信号
1 semaphore跟线程的它没有半毛钱关系
2 signal翻译过来的，flask的signal
3 信号是同步操作
4 如何使用(内置的)
######### 内置信号的使用
##第一步写一个函数（触发某些动作）
# 往信号中注册函数
def func(*args,**kwargs):
print(args[0]) # 当前app对象
print('触发信号',args,kwargs)
# 第二步：函数跟内置信号绑定
signals.request_started.connect(func)
5 自定义信号的使用
# 自定义信号
# #第一步：定义一个信号
# xxxxx = _signals.signal('xxxxx')
# # 第二步：定义一个函数
# def func3(*args,**kwargs):
# import time
# time.sleep(1)
# print('触发信号',args,kwargs)
# #第三步：信号跟函数绑定
# xxxxx.connect(func3)
#第四步：触发信号
xxxxx.send(1,k='2')
20 多app应用（了解）
### 多个app实例(启用)
from werkzeug.wsgi import DispatcherMiddleware
from werkzeug.serving import run_simple
from flask import Flask, current_app
app1 = Flask('app01')
app2 = Flask('app02')
@app1.route('/index')
def index():
return "app01"
@app2.route('/index2')
def index2():
return "app2"
# http://www.oldboyedu.com/index
# http://www.oldboyedu.com/sec/index2
dm = DispatcherMiddleware(app1, {
'/sec': app2,
})
if __name__ == "__main__":
run_simple('localhost', 5000, dm)
# 请求来了，会执行dm()--->__call__
21 flask-script（制定命令）
1 模拟出类似django的启动方式：python manage.py runserver
2 pip install flask-script
3 把excel的数据导入数据库，定制个命令，去执行(openpyxl)
python manage.py insertdb -f xxx.excl -t aa
4 使用
-方式一：python manage.py runserver
from flask import Flask
from flask_script import Manager
app = Flask(__name__)
manager=Manager(app)
if __name__ == '__main__':
manager.run()
-方式二：自定制命令
@manager.command
def custom(arg):
print(arg)
@manager.option('-n', '--name', dest='name')
@manager.option('-u', '--url', dest='url')
def cmd(name, url):
print(name, url)
5 创建超级用户
6 现在有一万条excel用户，批量导入到数据库中
-navicate直接支持
-脚本
-flask-script
22 sqlachemy
22.1 概念
1 sqlachemy：第三方orm框架（对象关系映射）
-go 中gorm，xorm
-python中：django orm，sqlachemy,peewee
-老刘带你手写的：https://www.cnblogs.com/liuqingzheng/articles/9006025.html
2 django orm，只能在django中用，不能单独用
3 使用 pip install sqlachemy
4 SQLAlchemy本身无法操作数据库，其必须以来pymsql等第三方插件
5 补充：django orm反向生成models
-python manage.py inspectdb > app/models.py
22.2 基本使用（原生sql）
import time
import threading
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.engine.base import Engine
# 第一步生成一个engine对象
engine = create_engine(
"mysql+pymysql://root:123@127.0.0.1:3306/flask?charset=utf8",
max_overflow=0, # 超过连接池大小外最多创建的连接
pool_size=5, # 连接池大小
pool_timeout=30, # 池中没有线程最多等待的时间，否则报错
pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
# 第二步：创建连接（执行原生sql）
conn = engine.raw_connection()
# 第三步：获取游标对象
cursor = conn.cursor()
# 第四步：具体操作
cursor.execute('select * from boy')
res=cursor.fetchall()
print(res)
# 比pymysql优势在，有数据库连接池
22.3 orm使用
# 创建一个个类（继承谁？字段怎么写）
import datetime
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
# 字段和字段属性
from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index
# 制造了一个类，作为所有模型类的基类
Base = declarative_base()
class User(Base):
__tablename__ = 'users' # 数据库表名称(固定写法)，如果不写，默认以类名小写作为表的名字
id = Column(Integer, primary_key=True) # id 主键
# mysql中主键自动建索引：聚簇索引
# 其他建建的索引叫：辅助索引
name = Column(String(32), index=True, nullable=False) # name列，索引，不可为空
# email = Column(String(32), unique=True) # 唯一
# #datetime.datetime.now不能加括号，加了括号，以后永远是当前时间
# ctime = Column(DateTime, default=datetime.datetime.now) # default默认值
# extra = Column(Text, nullable=True)
#类似于djagno的 Meta
# __table_args__ = (
# UniqueConstraint('id', 'name', name='uix_id_name'), #联合唯一
# Index('ix_id_name', 'name', 'email'), #索引
# )
# 创建表
def create_table():
# 创建engine对象
engine = create_engine(
"mysql+pymysql://root:123@127.0.0.1:3306/aaa?charset=utf8",
max_overflow=0, # 超过连接池大小外最多创建的连接
pool_size=5, # 连接池大小
pool_timeout=30, # 池中没有线程最多等待的时间，否则报错
pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
# 通过engine对象创建表
Base.metadata.create_all(engine)
# 删除表
def drop_table():
# 创建engine对象
engine = create_engine(
"mysql+pymysql://root:123@127.0.0.1:3306/aaa?charset=utf8",
max_overflow=0, # 超过连接池大小外最多创建的连接
pool_size=5, # 连接池大小
pool_timeout=30, # 池中没有线程最多等待的时间，否则报错
pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
# 通过engine对象删除所有表
Base.metadata.drop_all(engine)
if __name__ == '__main__':
# create_table()
drop_table()
# 创建库？手动创建库
# 问题，sqlachemy支持修改字段吗？不支持
22.4 线程安全
#基于scoped_session实现线程安全
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from models import User # pycharm报错，不会影响我们
from sqlalchemy.orm import scoped_session
# 1 制作engine
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/aaa", max_overflow=0, pool_size=5)
# 2 制造一个 session 类（会话）
Session = sessionmaker(bind=engine) # 得到一个类
# 3 得到一个session对象（线程安全的session）
#现在的session已经不是session对象了
#为什么线程安全，还是用的local
session = scoped_session(Session)
# session=Session()
# 4 创建一个对象
obj1 = User(name="2008")
# 5 把对象通过add放入
session.add(obj1)
# session.aaa()
# 6 提交
session.commit()
session.close()
# 类不继承Session类，但是有该类的所有方法（通过反射，一个个放进去）
# scoped_session.add------->instrument(name)--->do函数内存地址---》现在假设我要这么用：session.add()--->do()
# scoped_session.close----->instrument(name)--->do函数内存地址
22.5 基本增删查改
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from models import User,Person,Hobby
from sqlalchemy.orm import scoped_session
from sqlalchemy.sql import text
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/aaa", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
# session = scoped_session(Session)
session=Session()
####1 新增多个对象
# obj=User(name='xxx')
# obj2=User(name='yyyy')
# obj3=User(name='zzz')
#新增同样对象
# session.add_all([obj,obj2,obj3])
#新增不同对象
# session.add_all([Person(name='lqz'),Hobby()])
####2 简单删除（查到删除）
# res=session.query(User).filter_by(name='2008').delete()
# res=session.query(User).filter(User.id>=2).delete()
# # 影响1行
# print(res)
#### 3 修改
# res=session.query(User).filter_by(id=1).update({User.name:'ccc'})
# res=session.query(User).filter_by(id=1).update({'name':'ccc'})
# session.query(User).filter(User.id > 0).update({User.name: User.name + "099"}, synchronize_session=False) # 如果要把它转成字符串相加
# session.query(User).filter(User.id > 0).update({"age": User.age + 1}, synchronize_session="evaluate") ## 如果要把它转成数字相加
####4 基本查询操作
# res=session.query(User).all()
# print(type(res))
# res=session.query(User).first()
# print(res)
#filter传的是表达式，filter_by传的是参数
# res=session.query(User).filter(User.id==1).all()
# res=session.query(User).filter(User.id>=1).all()
# res=session.query(User).filter(User.id<1).all()
# res=session.query(User).filter_by(name='ccc099').all()
#了解
# res = session.query(User).from_statement(text("SELECT * FROM users where name=:name")).params(name='ccc099').all()
# print(res)
session.commit()
# 并没有真正关闭连接，而是放回池中
session.close()
22.6 高级操作
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from models import User,Person,Hobby
from sqlalchemy.sql import text
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/aaa", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
session=Session()
# 1 查询名字为lqz的所有user对象
# ret = session.query(User).filter_by(name='ccc099').all()
# 2 表达式，and条件连接
# ret = session.query(User).filter(User.id > 1, User.name == 'egon').all()
# 查找id在1和10之间，并且name=egon的对象
# ret = session.query(User).filter(User.id.between(1, 10), User.name == 'egon').all()
# in条件(class_,因为这是关键字，不能直接用)
# ret = session.query(User).filter(User.id.in_([1,3,4])).all()
# 取反 ~
ret = session.query(User).filter(~User.id.in_([1,3,4])).all()
#二次筛选
# select *
# ret = session.query(User).filter(User.id.in_(session.query(User.id).filter_by(name='egon'))).all()
# # select name，id 。。。。
# ret = session.query(User.id,User.name).filter(User.id.in_(session.query(User.id).filter_by(name='egon'))).all()
'''
SELECT users.id AS users_id, users.name AS users_name
FROM users
WHERE users.id IN (SELECT users.id AS users_id
FROM users
WHERE users.name = %(name_1)s)
'''
#
from sqlalchemy import and_, or_
#or_包裹的都是or条件，and_包裹的都是and条件
#查询id>3并且name=egon的人
# ret = session.query(User).filter(and_(User.id > 3, User.name == 'egon')).all()
# 查询id大于2或者name=ccc099的数据
# ret = session.query(User).filter(or_(User.id > 2, User.name == 'ccc099')).all()
# ret = session.query(User).filter(
# or_(
# User.id < 2,
# and_(User.name == 'egon', User.id > 3),
# User.extra != ""
# )).all()
# print(ret)
'''
select *from user where id<2 or (name=egon and id >3) or extra !=''
'''
# 通配符，以e开头，不以e开头
# ret = session.query(User).filter(User.name.like('e%')).all()
# ret = session.query(User).filter(~User.name.like('e%')).all()
# 限制，用于分页，区间 limit
# 前闭后开区间，1能取到，3取不到
ret = session.query(User)[1:3]
'''
select * from users limit 1,2;
'''
# 排序，根据name降序排列（从大到小）
# ret = session.query(User).order_by(User.name.desc()).all()
# ret = session.query(User).order_by(User.name.asc()).all()
#第一个条件降序排序后，再按第二个条件升序排
# ret = session.query(User).order_by(User.id.asc(),User.name.desc()).all()
# ret = session.query(User).order_by(User.name.desc(),User.id.asc()).all()
# 分组
from sqlalchemy.sql import func
# ret = session.query(User).group_by(User.name).all()
#分组之后取最大id，id之和，最小id
# sql 分组之后，要查询的字段只能有分组字段和聚合函数
# ret = session.query(
# func.max(User.id),
# func.sum(User.id),
# func.min(User.id),
# User.name).group_by(User.name).all()
# '''
# select max(id),sum(id),min(id) from user group by name;
#
# '''
# for obj in ret:
# print(obj[0],'----',obj[1],'-----',obj[2],'-----',obj[3])
# print(ret)
#haviing筛选
# ret = session.query(
# func.max(User.id),
# func.sum(User.id),
# func.min(User.id)).group_by(User.name).having(func.min(User.id) >2).all()
'''
select max(id),sum(id),min(id) from user group by name having min(id)>2;
'''
print(ret)
session.commit()
session.close()
22.7 多表操作
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from models import User,Person,Hobby,Boy,Girl,Boy2Girl
from sqlalchemy.sql import text
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/aaa", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
session=Session()
### 1 一对多插入数据
# obj=Hobby(caption='足球')
# session.add(obj)
# p=Person(name='张三',hobby_id=2)
# session.add(p)
### 2 方式二(默认情况传对象有问题)
###### Person表中要加 hobby = relationship('Hobby', backref='pers')
# p=Person(name='李四',hobby=Hobby(caption='美女'))
# 等同于
# p=Person(name='李四2')
# p.hobby=Hobby(caption='美女2')
# session.add(p)
## 3 方式三，通过反向操作
# hb = Hobby(caption='人妖')
# hb.pers = [Person(name='文飞'), Person(name='博雅')]
# session.add(hb)
#### 4 查询（查询：基于连表的查询，基于对象的跨表查询）
### 4.1 基于对象的跨表查询(子查询，两次查询)
# 正查
# p=session.query(Person).filter_by(name='张三').first()
# print(p)
# print(p.hobby.caption)
# 反查
# h=session.query(Hobby).filter_by(caption='人妖').first()
# print(h.pers)
### 4.2 基于连表的跨表查（查一次）
# 默认根据外键连表
# isouter=True 左外连，表示Person left join Hobby，没有右连接，反过来即可
# 不写 inner join
# person_list=session.query(Person,Hobby).join(Hobby,isouter=True).all()
# print(person_list)
# print(person_list)
# for row in person_list:
# print(row[0].name,row[1].caption)
# '''
# select * from person left join hobby on person.hobby_id=hobby.id
# '''
#
# ret = session.query(Person, Hobby).filter(Person.hobby_id == Hobby.id)
# print(ret)
# '''
# select * from user,hobby where user.id=favor.nid;
#
# '''
#join表，默认是inner join
# ret = session.query(Person).join(Hobby)
# # ret = session.query(Hobby).join(Person,isouter=True)
# '''
# SELECT *
# FROM person INNER JOIN hobby ON hobby.id = person.hobby_id
# '''
# print(ret)
# 指定连表字段（从来没用过）
# ret = session.query(Person).join(Hobby,Person.nid==Hobby.id, isouter=True)
# # ret = session.query(Person).join(Hobby,Person.hobby_id==Hobby.id, isouter=True).all()
# print(ret)
'''
SELECT *
FROM person LEFT OUTER JOIN hobby ON person.nid = hobby.id
'''
# print(ret)
# 组合（了解）UNION 操作符用于合并两个或多个 SELECT 语句的结果集
# union和union all的区别？
# q1 = session.query(User.name).filter(User.id > 2) # 6条数据
# q2 = session.query(User.name).filter(User.id < 8) # 2条数据
# q1 = session.query(User.id,User.name).filter(User.id > 2) # 6条数据
# q2 = session.query(User.id,User.name).filter(User.id < 8) # 2条数据
# ret = q1.union_all(q2).all()
# ret1 = q1.union(q2).all()
# print(ret)
# print(ret1)
#
# q1 = session.query(User.name).filter(User.id > 2)
# q2 = session.query(Hobby.caption).filter(Hobby.nid < 2)
# ret = q1.union_all(q2).all()
#### 多对多
# session.add_all([
# Boy(hostname='霍建华'),
# Boy(hostname='胡歌'),
# Girl(name='刘亦菲'),
# Girl(name='林心如'),
# ])
# session.add_all([
# Boy2Girl(girl_id=1, boy_id=1),
# Boy2Girl(girl_id=2, boy_id=1)
# ])
##### 要有girls = relationship('Girl', secondary='boy2girl', backref='boys')
# girl = Girl(name='张娜拉')
# girl.boys = [Boy(hostname='张铁林'),Boy(hostname='费玉清')]
# session.add(girl)
# boy=Boy(hostname='蔡徐坤')
# boy.girls=[Girl(name='谢娜'),Girl(name='巧碧螺')]
# session.add(boy)
# session.commit()
# 基于对象的跨表查
# girl=session.query(Girl).filter_by(id=3).first()
# print(girl.boys)
#### 基于连表的跨表查询
# 查询蔡徐坤约过的所有妹子
'''
select girl.name from girl,boy,Boy2Girl where boy.id=Boy2Girl.boy_id and girl.id=Boy2Girl.girl_id where boy.name='蔡徐坤'
'''
# ret=session.query(Girl.name).filter(Boy.id==Boy2Girl.boy_id,Girl.id==Boy2Girl.girl_id,Boy.hostname=='蔡徐坤').all()
'''
select girl.name from girl inner join Boy2Girl on girl.id=Boy2Girl.girl_id inner join boy on boy.id=Boy2Girl.boy_id where boy.hostname='蔡徐坤'
'''
# ret=session.query(Girl.name).join(Boy2Girl).join(Boy).filter(Boy.hostname=='蔡徐坤').all()
ret=session.query(Girl.name).join(Boy2Girl).join(Boy).filter_by(hostname='蔡徐坤').all()
print(ret)
### 执行原生sql（用的最多的）
### django中orm如何执行原生sql
#
# cursor = session.execute('insert into users(name) values(:value)',params={"value":'xxx'})
# print(cursor.lastrowid)
# session.commit()
session.close()
22.8 models.py
# 创建一个个类（继承谁？字段怎么写）
import datetime
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
# 字段和字段属性
from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index
from sqlalchemy.orm import relationship
# 制造了一个类，作为所有模型类的基类
Base = declarative_base()
class User(Base):
__tablename__ = 'users' # 数据库表名称(固定写法)，如果不写，默认以类名小写作为表的名字
id = Column(Integer, primary_key=True) # id 主键
# mysql中主键自动建索引：聚簇索引
# 其他建建的索引叫：辅助索引
name = Column(String(32), index=True, nullable=False) # name列，索引，不可为空
# email = Column(String(32), unique=True) # 唯一
# #datetime.datetime.now不能加括号，加了括号，以后永远是当前时间
# ctime = Column(DateTime, default=datetime.datetime.now) # default默认值
# extra = Column(Text, nullable=True)
#类似于djagno的 Meta
# __table_args__ = (
# UniqueConstraint('id', 'name', name='uix_id_name'), #联合唯一
# Index('ix_id_name', 'name', 'email'), #索引
# )
def __str__(self):
return self.name
def __repr__(self):
# python是强类型语言
return self.name+str(self.id)
# 一对多关系
# 一个Hobby可以有很多人喜欢
# 一个人只能由一个Hobby
class Hobby(Base):
__tablename__ = 'hobby'
id = Column(Integer, primary_key=True)
caption = Column(String(50), default='篮球')
class Person(Base):
__tablename__ = 'person'
nid = Column(Integer, primary_key=True)
name = Column(String(32), index=True, nullable=True)
# hobby指的是tablename而不是类名，uselist=False
# 一对多的关系，关联字段写在多的一方
hobby_id = Column(Integer, ForeignKey("hobby.id")) # 默认可以为空
# 跟数据库无关，不会新增字段，只用于快速链表操作
# 类名，backref用于反向查询
hobby = relationship('Hobby', backref='pers')
# 多对多关系
# 实实在在存在的表
class Boy2Girl(Base):
__tablename__ = 'boy2girl'
id = Column(Integer, primary_key=True, autoincrement=True) # autoincrement自增，默认是True
girl_id = Column(Integer, ForeignKey('girl.id'))
boy_id = Column(Integer, ForeignKey('boy.id'))
class Girl(Base):
__tablename__ = 'girl'
id = Column(Integer, primary_key=True)
name = Column(String(64), unique=True, nullable=False)
class Boy(Base):
__tablename__ = 'boy'
id = Column(Integer, primary_key=True, autoincrement=True)
hostname = Column(String(64), unique=True, nullable=False)
# 与生成表结构无关，仅用于查询方便,放在哪个单表中都可以
# secondary 通过哪个表建关联，跟django中的through一模一样
girls = relationship('Girl', secondary='boy2girl', backref='boys')
# 创建表
def create_table():
# 创建engine对象
engine = create_engine(
"mysql+pymysql://root:123@127.0.0.1:3306/aaa?charset=utf8",
max_overflow=0, # 超过连接池大小外最多创建的连接
pool_size=5, # 连接池大小
pool_timeout=30, # 池中没有线程最多等待的时间，否则报错
pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
# 通过engine对象创建表
Base.metadata.create_all(engine)
# 删除表
def drop_table():
# 创建engine对象
engine = create_engine(
"mysql+pymysql://root:123@127.0.0.1:3306/aaa?charset=utf8",
max_overflow=0, # 超过连接池大小外最多创建的连接
pool_size=5, # 连接池大小
pool_timeout=30, # 池中没有线程最多等待的时间，否则报错
pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
# 通过engine对象删除所有表
Base.metadata.drop_all(engine)
if __name__ == '__main__':
create_table() # 原来已经存在user表，再执行一次不会有问题
# drop_table()
# 创建库？手动创建库
# 问题，sqlachemy支持修改字段吗？不支持
23 Flask-SQLAlchemy
1 Flask-SQLAlchemy
2 flask-migrate
-python3 manage.py db init 初始化：只执行一次
-python3 manage.py db migrate 等同于 makemigartions
-python3 manage.py db upgrade 等同于migrate
3 看代码
4 Flask-SQLAlchemy如何使用
1 from flask_sqlalchemy import SQLAlchemy
2 db = SQLAlchemy()
3 db.init_app(app)
4 以后在视图函数中使用
-db.session 就是咱们讲的session
5 flask-migrate的使用（表创建，字段修改）
1 from flask_migrate import Migrate,MigrateCommand
2 Migrate(app,db)
3 manager.add_command('db', MigrateCommand)
6 直接使用
-python3 manage.py db init 初始化：只执行一次，创建migrations文件夹
-python3 manage.py db migrate 等同于 makemigartions
-python3 manage.py db upgrade 等同于migrate
posted on
