Flask入门
Flask
0.Flask简介
Flask是一个基于Python开发并且依赖jinja2模板和Werkzeug WSGI服务的一个微型框架，对于Werkzeug本质是Socket服务端，其用于接收http请求并对请求进行预处理，然后触发Flask框架，开发人员基于Flask框架提供的功能对请求进行相应的处理，并返回给用户，如果要返回给用户复杂的内容时，需要借助jinja2模板来实现对模板的处理，即：将模板和数据进行渲染，将渲染后的字符串返回给用户浏览器。
“微”(micro) 并不表示你需要把整个 Web 应用塞进单个 Python 文件（虽然确实可以 ），也不意味着 Flask 在功能上有所欠缺。微框架中的“微”意味着 Flask 旨在保持核心简单而易于扩展。Flask 不会替你做出太多决策——比如使用何种数据库。而那些 Flask 所选择的——比如使用何种模板引擎——则很容易替换。除此之外的一切都由可由你掌握。如此，Flask 可以与您珠联璧合。
默认情况下，Flask 不包含数据库抽象层、表单验证，或是其它任何已有多种库可以胜任的功能。然而，Flask 支持用扩展来给应用添加这些功能，如同是 Flask 本身实现的一样。众多的扩展提供了数据库集成、表单验证、上传处理、各种各样的开放认证技术等功能。Flask 也许是“微小”的，但它已准备好在需求繁杂的生产环境中投入使用
1.安装
pip3 install flask
2.werkzeug简介
Werkzeug是一个WSGI工具包，他可以作为一个Web框架的底层库。这里稍微说一下， werkzeug 不是一个web服务器，也不是一个web框架，而是一个工具包，官方的介绍说是一个 WSGI 工具包，它可以作为一个 Web 框架的底层库，因为它封装好了很多 Web 框架的东西，例如 Request，Response 等等
代码示例：
from werkzeug.wrappers import Request, Response
@Request.application
def hello(request):
return Response('Hello World!')
if __name__ == '__main__':
from werkzeug.serving import run_simple
run_simple('localhost', 4000, hello)
3.flask快速使用
from flask import Flask
# 实例化产生一个Flask对象
app = Flask(__name__)
# 将 '/'和视图函数hello_workd的对应关系添加到路由中
@app.route('/') # 1. v=app.route('/') 2. v(hello_world)
def hello_world():
return 'Hello World!'
if __name__ == '__main__':
app.run() # 最终调用了run_simple()
案例：登录，显示用户信息
main.py
from flask import Flask,render_template,request,redirect,session,url_for
app = Flask(__name__)
app.debug = True
app.secret_key = 'sdfsdfsdfsdf'
USERS = {
1:{'name':'张三','age':18,'gender':'男','text':"道路千万条"},
2:{'name':'李四','age':28,'gender':'男','text':"搞钱第一条"},
3:{'name':'王五','age':18,'gender':'女','text':"行车不规范"},
}
@app.route('/detail/<int:nid>',methods=['GET'])
def detail(nid):
user = session.get('user_info')
if not user:
return redirect('/login')
info = USERS.get(nid)
return render_template('detail.html',info=info)
@app.route('/index',methods=['GET'])
def index():
user = session.get('user_info')
if not user:
# return redirect('/login')
url = url_for('l1')
return redirect(url)
return render_template('index.html',user_dict=USERS)
@app.route('/login',methods=['GET','POST'],endpoint='l1')
def login():
if request.method == "GET":
return render_template('login.html')
else:
# request.query_string
user = request.form.get('user')
pwd = request.form.get('pwd')
if user == 'lqz' and pwd == '123':
session['user_info'] = user
return redirect('http://www.baidu.com')
return render_template('login.html',error='用户名或密码错误')
if __name__ == '__main__':
app.run()
detail.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>详细信息 {{info.name}}</h1>
<div>
{{info.text}}
</div>
</body>
</html>
index.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>用户列表</h1>
<table>
{% 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 %}
</table>
</body>
</html>
login.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>用户登录</h1>
<form method="post">
<input type="text" name="user">
<input type="text" name="pwd">
<input type="submit" value="登录">{{error}}
</form>
</body>
</html>
4.配置文件
flask中的配置文件是一个flask.config.Config对象（继承字典）,默认配置为：
{
'DEBUG': get_debug_flag(default=False), # 是否开启Debug模式
'TESTING': False, # 是否开启测试模式
'PROPAGATE_EXCEPTIONS': None,
'PRESERVE_CONTEXT_ON_EXCEPTION': None,
'SECRET_KEY': None,
'PERMANENT_SESSION_LIFETIME': timedelta(days=31),
'USE_X_SENDFILE': False,
'LOGGER_NAME': None,
'LOGGER_HANDLER_POLICY': 'always',
'SERVER_NAME': None,
'APPLICATION_ROOT': None,
'SESSION_COOKIE_NAME': 'session',
'SESSION_COOKIE_DOMAIN': None,
'SESSION_COOKIE_PATH': None,
'SESSION_COOKIE_HTTPONLY': True,
'SESSION_COOKIE_SECURE': False,
'SESSION_REFRESH_EACH_REQUEST': True,
'MAX_CONTENT_LENGTH': None,
'SEND_FILE_MAX_AGE_DEFAULT': timedelta(hours=12),
'TRAP_BAD_REQUEST_ERRORS': False,
'TRAP_HTTP_EXCEPTIONS': False,
'EXPLAIN_TEMPLATE_LOADING': False,
'PREFERRED_URL_SCHEME': 'http',
'JSON_AS_ASCII': True,
'JSON_SORT_KEYS': True,
'JSONIFY_PRETTYPRINT_REGULAR': True,
'JSONIFY_MIMETYPE': 'application/json',
'TEMPLATES_AUTO_RELOAD': None,
}
配置方式一
app.config['DEBUG'] = True
PS： 由于Config对象本质上是字典，所以还可以使用app.config.update(...)
配置方式二
1.通过py文件配置
# 1.通过py文件配置
app.config.from_pyfile("python文件名称")
# 如：
# #settings.py
DEBUG = True
app.config.from_pyfile("settings.py")
2.通过环境变量配置
# 2.通过环境变量配置
# app.config.from_envvar("环境变量名称")
app.config.from_pyfile(os.environ['YOURAPPLICATION_SETTINGS'])
# 环境变量的值为python文件名称名称，内部调用from_pyfile方法
3.从JSON文件中获取
app.config.from_json("json文件名称")
# JSON文件名称，必须是json格式，因为内部会执行json.loads
4.字典格式
app.config.from_mapping({'DEBUG': True})
# 字典格式
5.通过Python类或类的路径获取
# 格式：app.config.from_object("python类或类的路径")
app.config.from_object('pro_flask.settings.TestingConfig')
# 在settings.py 中写代码：
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
# PS: 从sys.path中已经存在路径开始写
# PS: settings.py文件默认路径要放在程序root_path目录，如果instance_relative_config为True，则就是instance_path目录（Flask对象init方法的参数）
总结：
"""
flask配置文件的 dbug更改配置四种方式
"""
from flask import Flask
app = Flask(__name__)
# 第一种方式
# app.debug=True
# 第二种方式：
# app.config['DEBUG'] = True
# 第三种方式
# app.config.from_pyfile('settings.py')
# 第四种方式：
app.config.from_object('settings.TestingConfig')
@app.route('/')
def index():
return 'index'
if __name__ == '__main__':
app.run()
5.路由系统
典型写法
@app.route('/detail/<int:nid>',methods=['GET'],endpoint='detail')
默认转换器
DEFAULT_CONVERTERS = {
'default': UnicodeConverter,
'string': UnicodeConverter,
'any': AnyConverter,
'path': PathConverter,
'int': IntegerConverter,
'float': FloatConverter,
'uuid': UUIDConverter,
}
路由系统本质
"""
1. decorator = app.route('/',methods=['GET','POST'],endpoint='n1')
def route(self, rule, **options):
# app对象
# rule= /
# options = {methods=['GET','POST'],endpoint='n1'}
def decorator(f):
endpoint = options.pop('endpoint', None)
self.add_url_rule(rule, endpoint, f, **options)
return f
return decorator
2. @decorator
decorator(index)
"""
# 同理
def login():
return '登录'
app.add_url_rule('/login', 'n2', login, methods=['GET',"POST"])
# 与django路由类似
# django与flask路由：flask路由基于装饰器，本质是基于：add_url_rule
# add_url_rule 源码中，endpoint如果为空，endpoint = _endpoint_from_view_func(view_func)，最终取view_func.__name__（函数名）
CBV(源码分析)
django中的三件套： 对比 Flask
Httpresponse ---> ''
render ---> render_template
redirect ---> redirect
JsonResponse ---> jsonify
def auth(func):
def inner(*args, **kwargs):
print('before')
result = func(*args, **kwargs)
print('after')
return result
return inner
class IndexView(views.View):
methods = ['GET']
decorators = [auth, ]
def dispatch_request(self):
print('Index')
return 'Index!'
app.add_url_rule('/index', view_func=IndexView.as_view(name='index')) # name=endpoint
#或者，通常用此方式
class IndexView(views.MethodView):
methods = ['GET']
decorators = [auth, ]
def get(self):
return 'Index.GET'
def post(self):
return 'Index.POST'
app.add_url_rule('/index', view_func=IndexView.as_view(name='index')) # name=endpoint
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最后的 / 符号是否严格要求
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>')
'''
#子域名访问
subdomain = None,
'''
#C:\Windows\System32\drivers\etc\hosts
127.0.0.1 www.liuqingzheng.com
127.0.0.1 admin.liuqingzheng.com
127.0.0.1 buy.liuqingzheng.com
from flask import Flask, views, url_for
app = Flask(import_name=__name__)
app.config['SERVER_NAME'] = 'liuqingzheng.com:5000'
@app.route("/", subdomain="admin")
def static_index():
"""Flask supports static subdomains
This is available at static.your-domain.tld"""
return "static.your-domain.tld"
#可以传入任意的字符串，如传入的字符串为aa，显示为 aa.liuqingzheng.com
@app.route("/dynamic", subdomain="<username>")
def username_index(username):
"""Dynamic subdomains are also supported
Try going to user1.your-domain.tld/dynamic"""
return username + ".your-domain.tld"
if __name__ == '__main__':
app.run()
访问：
http://www.liuqingzheng.com:5000/dynamic
http://admin.liuqingzheng.com:5000/dynamic
http://buy.liuqingzheng.com:5000/dynamic
'''
支持正则
#1 写类，继承BaseConverter
#2 注册：app.url_map.converters['regex'] = RegexConverter
# 3 使用：@app.route('/index/<regex("\d+"):nid>') 正则表达式会当作第二个参数传递到类中
from flask import Flask, views, url_for
from werkzeug.routing import BaseConverter
app = Flask(import_name=__name__)
class RegexConverter(BaseConverter):
"""
自定义URL匹配正则表达式
"""
def __init__(self, map, regex):
super(RegexConverter, self).__init__(map)
self.regex = regex
def to_python(self, value):
"""
路由匹配时，匹配成功后传递给视图函数中参数的值
"""
return int(value)
def to_url(self, value):
"""
使用url_for反向生成URL时，传递的参数经过该方法处理，返回的值用于生成URL中的参数
"""
val = super(RegexConverter, self).to_url(value)
return val
# 添加到flask中
app.url_map.converters['regex'] = RegexConverter
@app.route('/index/<regex("\d+"):nid>')
def index(nid):
print(url_for('index', nid='888'))
return 'Index'
if __name__ == '__main__':
app.run()
6.模版
比django中多可以加括号，执行函数，传参数
from flask import Flask,render_template,Markup,jsonify,make_response
app = Flask(__name__)
def func1(arg):
return Markup("<input type='text' value='%s' />" %(arg,))
@app.route('/')
def index():
return render_template('index.html',ff = func1)
if __name__ == '__main__':
app.run()
index.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
{{ff('六五')}}
{{ff('六五')|safe}}
</body>
</html>
注意：
1.Markup等价django的mark_safe ,
2.extends,include一模一样
案例二：
html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.4.1/jquery.min.js"></script>
<link href="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.4.1/css/bootstrap.min.css" rel="stylesheet">
<script src="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.4.1/js/bootstrap.min.js"></script>
</head>
<body>
{{ test(1,2,3) }}
{#{{ 1|db(2,3) }}#}
{#{{ time|date:''}}#}
</body>
</html>
模板.py
from flask import Flask, request, render_template
from markupsafe import Markup
app = Flask(__name__)
app.debug = True
@app.route('/')
def index():
def test(a, b, c):
return a + b + c
# s = request.form.get('s')
# string = "<input type='text' value='123'>"
# # string = " < input type='text' value='123' >"
# test = Markup(string)
return render_template('index.html', test=test)
if __name__ == '__main__':
app.run()
7.请求响应
用postman发送post请求：
from flask import Flask
from flask import request
from flask import render_template
from flask import redirect
from flask import make_response
app = Flask(__name__)
@app.route('/login.html', methods=['GET', "POST"])
def login():
# 请求相关信息
# request.method 请求方式
# request.args get请求
# request.form post请求数据 非文件数据
# request.values get请求，post请求数据
# request.cookies
# request.headers
# request.path
# request.full_path
# request.script_root
# request.url
# request.base_url
# request.url_root
# request.host_url
# request.host
# request.files
# obj = request.files['the_file_name']
# obj.save('/var/www/uploads/' + secure_filename(f.filename))
# 响应相关信息
# return "字符串"
# return render_template('html模板路径',**{})
# return redirect('/index.html')
#return jsonify({'k1':'v1'})
# 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 "内容"
if __name__ == '__main__':
app.run()
# 测试结果：
from flask import Flask, request, render_template, make_response
app = Flask(__name__)
@app.route('/', methods=['GET', 'POST'])
def index():
# print(request.method) # POST
# print(request.args) # get # ImmutableMultiDict([('age', '1')])
# print(request.form) # get # ImmutableMultiDict([('username', 'admin'), ('password', '123456')])
# print("=======================") # =======================
# print(request.values) # get，post都有 # CombinedMultiDict([ImmutableMultiDict([('age', '1')]), ImmutableMultiDict([('username', 'admin'), ('password', '123456')])])
# print(request.cookies) # ImmutableMultiDict([('sessionid', 's0pvi2f9nn4jhdv6rxw03onvvih7y8o5')])
# print(request.headers)
"""
User-Agent: PostmanRuntime/7.28.0
Accept: */*
Postman-Token: 5f51e591-0ec1-4fd1-814e-85e0ee658e06
Host: 127.0.0.1:5000
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Content-Type: multipart/form-data; boundary=--------------------------547245136723244984706428
Cookie: sessionid=s0pvi2f9nn4jhdv6rxw03onvvih7y8o5
Content-Length: 281
"""
# print(request.path) # /
# print(request.script_root) # 啥也没有
# print(request.url) # http://127.0.0.1:5000/?age=1 或者 http://127.0.0.1:5000/ 就是填写的url地址
# print(request.base_url) # http://127.0.0.1:5000/
# print(request.url_root) # http://127.0.0.1:5000/
# print(request.host_url) # http://127.0.0.1:5000/
# print(request.host) # 127.0.0.1:5000
# request.script_root
# request.url
# request.base_url
# request.url_root
# request.host_url
# request.host
# obj = make_response('index11')
obj = make_response(render_template('index.html')) # 如果返回的是模板就这么写
obj.set_cookie('key', 'value') # 设置cookie，在浏览器中Application可以查看到
obj.delete_cookie('key') # 删除cookie
print(request.cookies) # ImmutableMultiDict([('sessionid', 's0pvi2f9nn4jhdv6rxw03onvvih7y8o5')])
obj.headers['sth'] = 'something' # 头信息
return obj
# return 'index'
# return make_response('index11')
@app.route('/test')
def test():
print(request.method) # post
return 'index'
if __name__ == '__main__':
app.run()
html界面body体内啥也没有
cookie即使在浏览器关掉了，我们其实照样可以用cookie，比如在浏览器的url中携带cookie信息。
8.session
除请求对象之外，还有一个 session 对象。它允许你在不同请求间存储特定用户的信息。它是在 Cookies 的基础上实现的，并且对 Cookies 进行密钥签名要使用会话，你需要设置一个密钥。 (app.session_interface对象)
设置：session['username'] ＝ 'xxx'
删除：session.pop('username', None)
9.闪现（message）
-设置:flash('aaa')
-取值：get_flashed_message()
-假设在a页面操作出错，跳转到b页面，在b页面显示a页面的错误信息
示例：
from flask import Flask,flash,get_flashed_messages,request,redirect
app = Flask(__name__)
app.secret_key = 'asdfasdf'
@app.route('/index')
def index():
# 从某个地方获取设置过的所有值，并清除。
val = request.args.get('v')
if val == 'oldboy':
return 'Hello World!'
flash('超时错误',category="x1")
return "ssdsdsdfsd"
# return redirect('/error')
@app.route('/error')
def error():
"""
展示错误信息
:return:
"""
data = get_flashed_messages(category_filter=['x1'])
if data:
msg = data[0]
else:
msg = "..."
return "错误信息：%s" %(msg,)
if __name__ == '__main__':
app.run()
10.请求扩展
1 before_request
类比django中间件中的process_request，在请求收到之前绑定一个函数做一些事情
#基于它做用户登录认证
@app.before_request
def process_request(*args,**kwargs):
if request.path == '/login':
return None
user = session.get('user_info')
if user:
return None
return redirect('/login')
2 after_request
类比django中间件中的process_response，每一个请求之后绑定一个函数，如果请求没有异常
@app.after_request
def process_response1(response):
print('process_response1 走了')
return response
3 before_first_request
只在第一次请求时触发,跟浏览器无关
# 只在第一次请求的时候触发
@app.before_first_request
def first():
pass
4 teardown_request
每一个请求之后绑定一个函数，即使遇到了异常
@app.teardown_request
def ter(e):
pass
5 errorhandler
路径不存在时404，服务器内部错误500
@app.errorhandler(404)
def error_404(arg):
return "404错误了"
6 template_global
标签
@app.template_global()
def sb(a1, a2):
return a1 + a2
#{{sb(1,2)}}
7 template_filter
过滤器
@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所有都执行
11 中间件（了解）
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__':
#把原来的wsgi_app替换为自定义的
app.wsgi_app = Md(app.wsgi_app)
app.run()
12.蓝图
对程序进行目录结构划分
不使用蓝图，自己分文件
目录结构：
-templates
-views
-__init__.py
-user.py
-order.py
-app.py
app.py
from views import app
if __name__ == '__main__':
app.run()
init.py
from flask import Flask,request
app = Flask(__name__)
#不导入这个不行
from . import account
from . import order
from . import user
user.py
from . import app
@app.route('/user')
def user():
return 'user'
order.py
from . import app
@app.route('/order')
def order():
return 'order'
使用蓝图之中小型系统
详见代码：pro_flask_简单应用程序目录示例.zip
目录结构：
-flask_pro
-flask_test
-__init__.py
-static
-templates
-views
-order.py
-user.py
-manage.py
__init__.py
from flask import Flask
app=Flask(__name__)
from flask_test.views import user
from flask_test.views import order
app.register_blueprint(user.us)
app.register_blueprint(order.ord)
manage.py
from flask_test import app
if __name__ == '__main__':
app.run(port=8008)
user.py
from flask import Blueprint
us=Blueprint('user',__name__)
@us.route('/login')
def login():
return 'login'
order.py
from flask import Blueprint
ord=Blueprint('order',__name__)
@ord.route('/test')
def test():
return 'order test'
使用蓝图之大型系统
详见代码：pro_flask_大型应用目录示例.zip
总结：
1 xxx = Blueprint('account', name,url_prefix='/xxx') ：蓝图URL前缀，表示url的前缀，在该蓝图下所有url都加前缀
2 xxx = Blueprint('account', name,url_prefix='/xxx',template_folder='tpls')：给当前蓝图单独使用templates，向上查找，当前找不到，会找总templates
3 蓝图的befort_request，对当前蓝图有效
4 大型项目，可以模拟出类似于django中app的概念
自定义local对象
# a = local()
# import time
#
# def task(arg):
# global a
#
# a.val = arg
# time.sleep(2)
# print(a.val)
#
# for i in range(10):
# t = Thread(target=task, args=(i,))
# t.start()
# 自定义local对象
# {'线程1':{'arg':1},'线程2':{'arg':2},'线程3':{'线程3':{'arg':3}}}
from threading import get_ident, current_thread
# 面向对象版本
# class Local():
# storage = {}
# def set(self,k,v):
# ident = get_ident()
# # ident = v
# if ident in self.storage:
# self.storage[ident][k] = v
# else:
# self.storage[ident] = {k:v}
#
# def get(self,v):
# ident = get_ident()
# return self.storage[ident][v]
#
# obj = Local()
# import time
# def task(arg):
# obj.set('val',arg)
# val = obj.get('val')
#
# time.sleep(2)
# print(val)
#
#
# for i in range(10):
# t = Thread(target=task, args=(i,))
# t.start()
#
# print(obj.storage)
# 面向对象版本
# class Local():
# # storage = {}
# def __init__(self):
# object.__setattr__(self, 'storage', {})
# # 这样写会有递归问题
# # self.storage = {}
#
# def __setattr__(self, key, value):
# ident = get_ident()
# if ident in self.storage:
# self.storage[ident][key] = value
# else:
# self.storage[ident] = {key: value}
#
# def __getattr__(self, item):
# ident = get_ident()
# return self.storage[ident][item]
#
#
# obj = Local()
# import time
#
#
# def task(arg):
# obj.val = arg
# time.sleep(2)
# print(obj.val)
#
#
# for i in range(10):
# t = Thread(target=task, args=(i,))
# t.start()
#
# print(obj.storage)
# 以上只支持线程，不支持协程
# 支持协程
try:
# 获取协程id
from greenlet import getcurrent as get_ident
except:
from threading import get_ident
class Local():
# storage = {}
def __init__(self):
object.__setattr__(self, 'storage', {})
# 这样写会有递归问题
# self.storage = {}
def __setattr__(self, key, value):
ident = get_ident()
if ident in self.storage:
self.storage[ident][key] = value
else:
self.storage[ident] = {key: value}
def __getattr__(self, item):
ident = get_ident()
return self.storage[ident][item]
obj = Local()
import time
def task(arg):
obj.val = arg
time.sleep(2)
print(obj.val)
for i in range(10):
t = Thread(target=task, args=(i,))
t.start()
print(obj.storage)
13.请求上下文源码分析
请求上下文执行流程（ctx）：
-1 flask项目一启动，有6个全局变量
-_request_ctx_stack：LocalStack对象
-_app_ctx_stack ：LocalStack对象
-request ： LocalProxy对象
-session ： LocalProxy对象
-2 请求来了 app.__call__()---->内部执行：self.wsgi_app(environ, start_response)
-3 wsgi_app()
-3.1 执行：ctx = self.request_context(environ)：返回一个RequestContext对象，并且封装了request(当次请求的request对象)，session
-3.2 执行： ctx.push()：RequestContext对象的push方法
-3.2.1 push方法中中间位置有：_request_ctx_stack.push(self)，self是ctx对象
-3.2.2 去_request_ctx_stack对象的类中找push方法（LocalStack中找push方法）
-3.2.3 push方法源码：
def push(self, obj):
#通过反射找self._local,在init实例化的时候生成的：self._local = Local()
#Local()flask封装的支持线程和协程的local对象
# 一开始取不到stack，返回None
rv = getattr(self._local, "stack", None)
if rv is None:
#走到这，self._local.stack=[],rv=[]
self._local.stack = rv = []
# 把ctx放到了列表中
#self._local={'线程id1':{'stack':[ctx,]},'线程id2':{'stack':[ctx,]},'线程id3':{'stack':[ctx,]}}
rv.append(obj)
return rv
-4 如果在视图函数中使用request对象，比如：print(request)
-4.1 会调用request对象的__str__方法，request类是：LocalProxy
-4.2 LocalProxy中的__str__方法：lambda x: str(x._get_current_object())
-4.2.1 内部执行self._get_current_object()
-4.2.2 _get_current_object()方法的源码如下：
def _get_current_object(self):
if not hasattr(self.__local, "__release_local__"):
#self.__local() 在init的时候，实例化的，在init中：object.__setattr__(self, "_LocalProxy__local", local)
# 用了隐藏属性
#self.__local 实例化该类的时候传入的local（偏函数的内存地址：partial(_lookup_req_object, "request")）
#加括号返回，就会执行偏函数，也就是执行_lookup_req_object，不需要传参数了
#这个地方的返回值就是request对象(当此请求的request，没有乱)
return self.__local()
try:
return getattr(self.__local, self.__name__)
except AttributeError:
raise RuntimeError("no object bound to %s" % self.__name__)
-4.2.3 _lookup_req_object函数源码如下：
def _lookup_req_object(name):
#name是'request'字符串
#top方法是把第三步中放入的ctx取出来，因为都在一个线程内，当前取到的就是当次请求的ctx对象
top = _request_ctx_stack.top
if top is None:
raise RuntimeError(_request_ctx_err_msg)
#通过反射，去ctx中把request对象返回
return getattr(top, name)
-4.2.4 所以：print(request) 实质上是在打印当此请求的request对象的__str__
-5 如果在视图函数中使用request对象，比如：print(request.method):实质上是取到当次请求的reuquest对象的method属性
-6 最终，请求结束执行： ctx.auto_pop(error)，把ctx移除掉
其他的东西：
-session:
-请求来了opensession
-ctx.push()---->也就是RequestContext类的push方法的最后的地方：
if self.session is None:
#self是ctx，ctx中有个app就是flask对象， self.app.session_interface也就是它：SecureCookieSessionInterface()
session_interface = self.app.session_interface
self.session = session_interface.open_session(self.app, self.request)
if self.session is None:
#经过上面还是None的话，生成了个空session
self.session = session_interface.make_null_session(self.app)
-请求走了savesession
-response = self.full_dispatch_request() 方法内部：执行了before_first_request，before_request，视图函数，after_request，savesession
-self.full_dispatch_request()---->执行：self.finalize_request(rv)-----》self.process_response(response)----》最后：self.session_interface.save_session(self, ctx.session, response)
-请求扩展相关
before_first_request，before_request，after_request依次执行
#######################################################################################
第一阶段：将ctx(request,session)放到Local对象上
第二阶段：视图函数导入：request/session
request.method
-LocalProxy对象.method,执行getattr方法，getattr(self._get_current_object(), name)
-self._get_current_object()返回return self.__local()，self.__local()，在LocakProxy实例化的时候,object.__setattr__(self, '_LocalProxy__local', local),此处local就是：partial(_lookup_req_object, 'request')
-def _lookup_req_object(name):
top = _request_ctx_stack.top #_request_ctx_stack 就是LocalStack()对象，top方法把ctx取出来
if top is None:
raise RuntimeError(_request_ctx_err_msg)
return getattr(top, name)#获取ctx中的request或session对象
第三阶段：请求处理完毕
- 获取session并保存到cookie
- 将ctx删除
程序运行，两个LocalStack()对象，一个里面放request和session，另一个放g和current_app
并发编程里有一个涉及 并发安全 的问题：如果通过共享变量的方式 十个线程都要处理(检验)某个变量，就会检验出问题---->临界区：a=a-1
首先要 先拿到a 再减去1 再赋值给a 这三步就存在临界区，某个线程拿到a=10， 减去1=9，另一个线程也拿到a=10 减去1=9，而不是叠加去减得不到8；
所以要在临界区 加锁。
14.g对象
专门用来存储用户信息的g对象，g的全称的为global
g对象在一次请求中的所有的代码的地方，都是可以使用的
g对象和session的区别
session对象是可以跨request的，只要session还未失效，不同的request的请求会获取到同一个session，但是g对象不是，g对象不需要管过期时间，请求一次就g对象就改变了一次，或者重新赋值了一次
15.flask-session
作用：将默认保存的签名cookie中的值 保存到 redis/memcached/file/Mongodb/SQLAlchemy
安装：pip3 install flask-session
使用1：
from flask import Flask,session
from flask_session import RedisSessionInterface
import redis
app = Flask(__name__)
conn=redis.Redis(host='127.0.0.1',port=6379)
#use_signer是否对key签名
app.session_interface=RedisSessionInterface(conn,key_prefix='lqz')
@app.route('/')
def hello_world():
session['name']='lqz'
return 'Hello World!'
if __name__ == '__main__':
app.run()
使用2：
from redis import Redis
from flask.ext.session import Session
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = Redis(host='192.168.0.94',port='6379')
Session(app)
问题：设置cookie时，如何设定关闭浏览器则cookie失效。
response.set_cookie('k','v',exipre=None)#这样设置即可
#在session中设置
app.session_interface=RedisSessionInterface(conn,key_prefix='lqz',permanent=False)
#一般不用，我们一般都设置超时时间，多长时间后失效
问题：cookie默认超时时间是多少？如何设置超时时间
#源码expires = self.get_expiration_time(app, session)
'PERMANENT_SESSION_LIFETIME': timedelta(days=31),#这个配置文件控制
16.数据库连接池
pymsql链接数据库
import pymysql
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123456', db='s8day127db')
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
# cursor.execute("select id,name from users where name=%s and pwd=%s",['ll','123',])
cursor.execute("select id,name from users where name=%(user)s and pwd=%(pwd)s",{'user':'egon','pwd':'123'})
obj = cursor.fetchone()
conn.commit()
cursor.close()
conn.close()
print(obj)
数据库连接池版
数据库连接池的两种模式：
https://www.cnblogs.com/wangkun122/articles/8992637.html
setting.py
from datetime import timedelta
from redis import Redis
import pymysql
from DBUtils.PooledDB import PooledDB, SharedDBConnection
class Config(object):
DEBUG = True
SECRET_KEY = "umsuldfsdflskjdf"
PERMANENT_SESSION_LIFETIME = timedelta(minutes=20)
SESSION_REFRESH_EACH_REQUEST= True
SESSION_TYPE = "redis"
PYMYSQL_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=[], # 开始会话前执行的命令列表。如：["set datestyle to ...", "set time zone ..."]
ping=0,
# ping MySQL服务端，检查是否服务可用。# 如：0 = None = never, 1 = default = whenever it is requested, 2 = when a cursor is created, 4 = when a query is executed, 7 = always
host='127.0.0.1',
port=3306,
user='root',
password='123456',
database='s8day127db',
charset='utf8'
)
class ProductionConfig(Config):
SESSION_REDIS = Redis(host='192.168.0.94', port='6379')
class DevelopmentConfig(Config):
SESSION_REDIS = Redis(host='127.0.0.1', port='6379')
class TestingConfig(Config):
pass
utils/sql.py
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
使用：
obj = SQLHelper.fetch_one("select id,name from users where name=%(user)s and pwd=%(pwd)s", form.data)
17.wtforms
安装:pip3 install wtforms==2.2.1
使用1：
from flask import Flask, render_template, request, redirect
from wtforms import Form
from wtforms.fields import simple
from wtforms import validators
from wtforms import widgets
app = Flask(__name__, template_folder='templates')
app.debug = True
class LoginForm(Form):
# 字段（内部包含正则表达式）
name = simple.StringField(
label='用户名',
validators=[
validators.DataRequired(message='用户名不能为空.'),
validators.Length(min=6, max=18, message='用户名长度必须大于%(min)d且小于%(max)d')
],
widget=widgets.TextInput(), # 页面上显示的插件
render_kw={'class': 'form-control'}
)
# 字段（内部包含正则表达式）
pwd = simple.PasswordField(
label='密码',
validators=[
validators.DataRequired(message='密码不能为空.'),
validators.Length(min=8, message='用户名长度必须大于%(min)d'),
validators.Regexp(regex="^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[$@$!%*?&])[A-Za-z\d$@$!%*?&]{8,}",
message='密码至少8个字符，至少1个大写字母，1个小写字母，1个数字和1个特殊字符')
],
widget=widgets.PasswordInput(),
render_kw={'class': 'form-control'}
)
@app.route('/login', methods=['GET', 'POST'])
def login():
if request.method == 'GET':
form = LoginForm()
return render_template('login.html', form=form)
else:
form = LoginForm(formdata=request.form)
if form.validate():
print('用户提交数据通过格式验证，提交的值为：', form.data)
else:
print(form.errors)
return render_template('login.html', form=form)
if __name__ == '__main__':
app.run()
login.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>登录</h1>
<form method="post">
<p>{{form.name.label}} {{form.name}} {{form.name.errors[0] }}</p>
<p>{{form.pwd.label}} {{form.pwd}} {{form.pwd.errors[0] }}</p>
<input type="submit" value="提交">
</form>
</body>
</html>
使用2：
from flask import Flask, render_template, request, redirect
from wtforms import Form
from wtforms.fields import core
from wtforms.fields import html5
from wtforms.fields import simple
from wtforms import validators
from wtforms import widgets
app = Flask(__name__, template_folder='templates')
app.debug = True
class RegisterForm(Form):
name = simple.StringField(
label='用户名',
validators=[
validators.DataRequired()
],
widget=widgets.TextInput(),
render_kw={'class': 'form-control'},
default='alex'
)
pwd = simple.PasswordField(
label='密码',
validators=[
validators.DataRequired(message='密码不能为空.')
],
widget=widgets.PasswordInput(),
render_kw={'class': 'form-control'}
)
pwd_confirm = simple.PasswordField(
label='重复密码',
validators=[
validators.DataRequired(message='重复密码不能为空.'),
validators.EqualTo('pwd', message="两次密码输入不一致")
],
widget=widgets.PasswordInput(),
render_kw={'class': 'form-control'}
)
email = html5.EmailField(
label='邮箱',
validators=[
validators.DataRequired(message='邮箱不能为空.'),
validators.Email(message='邮箱格式错误')
],
widget=widgets.TextInput(input_type='email'),
render_kw={'class': 'form-control'}
)
gender = core.RadioField(
label='性别',
choices=(
(1, '男'),
(2, '女'),
),
coerce=int # “1” “2”
)
city = core.SelectField(
label='城市',
choices=(
('bj', '北京'),
('sh', '上海'),
)
)
hobby = core.SelectMultipleField(
label='爱好',
choices=(
(1, '篮球'),
(2, '足球'),
),
coerce=int
)
favor = core.SelectMultipleField(
label='喜好',
choices=(
(1, '篮球'),
(2, '足球'),
),
widget=widgets.ListWidget(prefix_label=False),
option_widget=widgets.CheckboxInput(),
coerce=int,
default=[1, 2]
)
def __init__(self, *args, **kwargs):
super(RegisterForm, self).__init__(*args, **kwargs)
self.favor.choices = ((1, '篮球'), (2, '足球'), (3, '羽毛球'))
def validate_pwd_confirm(self, field):
"""
自定义pwd_confirm字段规则，例：与pwd字段是否一致
:param field:
:return:
"""
# 最开始初始化时，self.data中已经有所有的值
if field.data != self.data['pwd']:
# raise validators.ValidationError("密码不一致") # 继续后续验证
raise validators.StopValidation("密码不一致") # 不再继续后续验证
@app.route('/register', methods=['GET', 'POST'])
def register():
if request.method == 'GET':
form = RegisterForm(data={'gender': 2,'hobby':[1,]}) # initial
return render_template('register.html', form=form)
else:
form = RegisterForm(formdata=request.form)
if form.validate():
print('用户提交数据通过格式验证，提交的值为：', form.data)
else:
print(form.errors)
return render_template('register.html', form=form)
if __name__ == '__main__':
app.run()
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>用户注册</h1>
<form method="post" novalidate style="padding:0 50px">
{% for field in form %}
<p>{{field.label}}: {{field}} {{field.errors[0] }}</p>
{% endfor %}
<input type="submit" value="提交">
</form>
</body>
</html>
18.信号
Flask框架中的信号基于blinker，其主要就是让开发者可是在flask请求过程中定制一些用户行为
安装：pip3 install blinker
内置信号：
request_started = _signals.signal('request-started') # 请求到来前执行
request_finished = _signals.signal('request-finished') # 请求结束后执行
before_render_template = _signals.signal('before-render-template') # 模板渲染前执行
template_rendered = _signals.signal('template-rendered') # 模板渲染后执行
got_request_exception = _signals.signal('got-request-exception') # 请求执行出现异常时执行
request_tearing_down = _signals.signal('request-tearing-down') # 请求执行完毕后自动执行（无论成功与否）
appcontext_tearing_down = _signals.signal('appcontext-tearing-down')# 应用上下文执行完毕后自动执行（无论成功与否）
appcontext_pushed = _signals.signal('appcontext-pushed') # 应用上下文push时执行
appcontext_popped = _signals.signal('appcontext-popped') # 应用上下文pop时执行
message_flashed = _signals.signal('message-flashed') # 调用flask在其中添加数据时，自动触发
使用信号：
from flask import Flask,signals,render_template
app = Flask(__name__)
# 往信号中注册函数
def func(*args,**kwargs):
print('触发型号',args,kwargs)
signals.request_started.connect(func)
# 触发信号： signals.request_started.send()
@app.before_first_request
def before_first1(*args,**kwargs):
pass
@app.before_first_request
def before_first2(*args,**kwargs):
pass
@app.before_request
def before_first3(*args,**kwargs):
pass
@app.route('/',methods=['GET',"POST"])
def index():
print('视图')
return render_template('index.html')
if __name__ == '__main__':
app.wsgi_app
app.run()
一个流程中的信号触发点（了解）
a. before_first_request
b. 触发 request_started 信号
c. before_request
d. 模板渲染
渲染前的信号 before_render_template.send(app, template=template, context=context)
rv = template.render(context) # 模板渲染
渲染后的信号 template_rendered.send(app, template=template, context=context)
e. after_request
f. session.save_session()
g. 触发 request_finished信号
如果上述过程出错：
触发错误处理信号 got_request_exception.send(self, exception=e)
h. 触发信号 request_tearing_down
自定义信号(了解)：
from flask import Flask, current_app, flash, render_template
from flask.signals import _signals
app = Flask(import_name=__name__)
# 自定义信号
xxxxx = _signals.signal('xxxxx')
def func(sender, *args, **kwargs):
print(sender)
# 自定义信号中注册函数
xxxxx.connect(func)
@app.route("/x")
def index():
# 触发信号
xxxxx.send('123123', k1='v1')
return 'Index'
if __name__ == '__main__':
app.run()
19.多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)
20.flask-script
用于实现类似于django中 python3 manage.py runserver ...类似的命令
安装：pip3 install flask-script
使用
from flask_script import Manager
app = Flask(__name__)
manager=Manager(app)
...
if __name__ == '__main__':
manager.run()
#以后在执行，直接：python3 manage.py runserver
#python3 manage.py runserver --help
自定制命令
@manager.command
def custom(arg):
"""
自定义命令
python manage.py custom 123
:param arg:
:return:
"""
print(arg)
@manager.option('-n', '--name', dest='name')
#@manager.option('-u', '--url', dest='url')
def cmd(name, url):
"""
自定义命令（-n也可以写成--name）
执行： python manage.py cmd -n egon -u http://www.oldboyedu.com
执行： python manage.py cmd --name egon --url http://www.oldboyedu.com
:param name:
:param url:
:return:
"""
print(name, url)
21 SQLAlchemy介绍
1 python中的orm框架
Django's ORM
优点：易用，学习曲线短
和Django紧密集合，用Django时使用约定俗成的方法去操作数据库
缺点：不好处理复杂的查询，强制开发者回到原生SQL
紧密和Django集成，使得在Django环境外很难使用
peewee
优点：
Django式的API，使其易用
轻量实现，很容易和任意web框架集成
缺点：
多对多查询写起来不直观
SQLAlchemy
优点：
企业级 API，使得代码有健壮性和适应性
灵活的设计，使得能轻松写复杂查询
缺点：
重量级 API，导致长学习曲线
2 SQLAlchemy是一个基于Python实现的ORM框架。该框架建立在 DB API之上，使用关系对象映射进行数据库操作，简言之便是：将类和对象转换成SQL，然后使用数据API执行SQL并获取执行结果
# 安装
pip3 install sqlalchemy
# SQLAlchemy本身无法操作数据库，其必须以来pymsql等第三方插件
22 简单使用
#orm的简单使用（创建表和删除表）
-第一步创建一个models.py
-在models中写类，写字段
-把表同步到数据库：Base.metadata.create_all(engine)
-把表从数据库删除：Base.metadata.drop_all(engine)
# 详情见models.py
models.py
# 建表，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
from sqlalchemy.orm import relationship
Base = declarative_base()
class Users(Base):
__tablename__ = 'users' # 数据库表名称
id = Column(Integer, primary_key=True) # id 主键
name = Column(String(32), index=True, nullable=False) # name列，索引，不可为空
email = Column(String(32), unique=True) # 唯一
age = Column(Integer)
# datetime.datetime.now不能加括号，加了括号，以后永远是当前时间
ctime = Column(DateTime, default=datetime.datetime.now) # 时间类型，默认值是当前时间
extra = Column(Text, nullable=True)
__table_args__ = (
UniqueConstraint('id', 'name', name='uix_id_name'), # 联合唯一
Index('ix_id_name', 'name', 'email'), # 联合索引
)
def __repr__(self):
return self.name
# 一对多关系
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='persons')
# 多对多关系，需要建立第三张表，本质其实还是一对多
class Boy2Girl(Base):
__tablename__ = 'boy2girl'
id = Column(Integer, primary_key=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)
name = Column(String(64), unique=True, nullable=False)
# 与生成表结构无关，仅用于查询方便,放在哪个单表中都可以
girls = relationship('Girl', secondary='boy2girl', backref='boys')
def init_db():
"""
根据类创建数据库表
:return:
"""
engine = create_engine(
"mysql+pymysql://root:123@127.0.0.1:3306/bbb?charset=utf8",
max_overflow=0, # 超过连接池大小外最多创建的连接
pool_size=5, # 连接池大小
pool_timeout=30, # 池中没有线程最多等待的时间，否则报错
pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
Base.metadata.create_all(engine)
def drop_db():
"""
根据类删除数据库表
:return:
"""
engine = create_engine(
"mysql+pymysql://root:123@127.0.0.1:3306/bbb?charset=utf8",
max_overflow=0, # 超过连接池大小外最多创建的连接
pool_size=5, # 连接池大小
pool_timeout=30, # 池中没有线程最多等待的时间，否则报错
pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
Base.metadata.drop_all(engine)
if __name__ == '__main__':
init_db()
# drop_db()
23 一对多关系，多对多关系
# 一对多关系
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)
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)
name = Column(String(64), unique=True, nullable=False)
# 与生成表结构无关，仅用于查询方便,放在哪个单表中都可以
# servers = relationship('Girl', secondary='boy2girl', backref='boys')
24 基本操作，一对多，多对多操作
24.1 基本操作
######## 单表操作
# 在users表中插入一条数据
# user=Users(name='lqz',extra='介绍',email='33@qq.com')
# session.add(user)
# 查询一条记录
# res=session.query(Users).filter(Users.id >= 4).all() # filter中是使用条件
# res=session.query(Users).filter(Users.id >= 4) # filter中是使用条件，直接打印结果看到的是原生sql
# res=session.query(Users).filter(Users.id > 0).all() # filter中是使用条件
# res=session.query(Users).filter_by(name='lqz').all() # filter_by中使用关键字
# res=session.query(Users).filter_by(name='lqz').first() # filter_by中使用关键字、
# 删除(不要all或者first后再调用delete)
# res=session.query(Users).filter_by(name='lqz').delete()
# 更新
# session.query(Users).filter(Users.id > 0).update({"name" : "lqz"})
# 类似于django的F查询
# 字符串相加
# session.query(Users).filter(Users.id > 0).update({Users.name: Users.name + "099"}, synchronize_session=False)
# 数字相加
# session.query(Users).filter(Users.id > 0).update({"age": Users.age + 1}, synchronize_session="evaluate")
24.2 一对多
####一对多
# 增加（最基本的方式，麻烦一些）
# hobby=Hobby(caption='篮球')
# person=Person(name='张三',hobby_id=1)
# session.add_all([hobby,person])
# 使用
# 增加
# hobby=session.query(Hobby).filter_by(id=1).first()
# person=Person(name='张三',hobby=hobby)
# person=Person(name='李四',hobby_id=hobby.id)
# session.add(person)
# 查询(基于对象的跨表查询，需要借助于relationship)
# 正向查询
# person=session.query(Person).filter_by(nid=1).first()
# print(person.name)
# print(person.hobby_id)
# # hobby=session.query(Hobby).filter_by(id=person.hobby_id).first()
# print(person.hobby.caption)
# 反向查询（有relationship，指定了backref，有了hobby查询person）
# hobby = session.query(Hobby).filter_by(id=2).first()
# 如果没有relationship的反向查询
# persons = session.query(Person).filter(Person.hobby_id == hobby.id).all()
# print(persons)
# 反向查询（有relationship，指定了backref，有了hobby查询person）
# print(hobby.persons)
#
# print(hobby)
#
#
# # 把egon的hobby改成篮求
# # egon = session.query(Person).filter_by(name='egon').update({Person.hobby:hobby}) #不能使用对象直接修改
# egon = session.query(Person).filter_by(name='egon').update({Person.hobby_id:hobby.id}) #这个key
#
# print(egon)
24.3 多对多
####多对多
# girl = Girl(name='刘亦菲')
# boy = Boy(name='吴亦凡')
# session.add_all([girl, boy])
# b2g = Boy2Girl(boy_id=2, girl_id=1)
# session.add(b2g)
# 基于对象的跨表查(正向和反向)
# wyz=session.query(Boy).filter_by(name='吴彦祖').first()
# print(wyz.girls)
lyf=session.query(Girl).filter_by(name='刘亦菲').first()
print(lyf.boys)
25 基于scoped_session实现线程安全
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
from sqlalchemy.sql import text
from models import Users, Hobby, Person, Girl, Boy, Boy2Girl
from sqlalchemy.orm import scoped_session
# 1 创建engine对象
engine = create_engine(
"mysql+pymysql://root:123@127.0.0.1:3306/bbb?charset=utf8",
max_overflow=0, # 超过连接池大小外最多创建的连接
pool_size=5, # 连接池大小
pool_timeout=30, # 池中没有线程最多等待的时间，否则报错
pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
# 2 生成一个session对象
Session = sessionmaker(bind=engine)
# session = Session() # 就是一个连接对象，就是一个conn
# 3 多线程并发情况下，不要使用session对象，
session = scoped_session(Session)
#全局使用这个session
# scoped_session为什么会有session对象的所有方法（for循环一个个的把session的方法写到到了scoped_session没，点的时候，没有提示）
# session.add(Users(name='ass',extra='介绍',email='33eeee@qq.com',age=20))
res=session.query(Users).filter_by(name='ass').all()
print(res)
# print(session.__dict__)
# session.commit()
# session.close()
26 基本增删查改,常用操作
# 常用api，查询
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
from sqlalchemy.sql import text
from models import Users, Hobby, Person, Girl, Boy, Boy2Girl
from sqlalchemy.orm import scoped_session
# 1 创建engine对象
engine = create_engine(
"mysql+pymysql://root:123@127.0.0.1:3306/bbb?charset=utf8",
max_overflow=0, # 超过连接池大小外最多创建的连接
pool_size=5, # 连接池大小
pool_timeout=30, # 池中没有线程最多等待的时间，否则报错
pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
# 2 生成一个session对象
Session = sessionmaker(bind=engine)
session = Session() # 就是一个连接对象，就是一个conn
# 条件
# ret = session.query(Users).filter_by(name='lqz').all()
#表达式，and条件连接
# ret = session.query(Users).filter(Users.id > 1, Users.name == 'lqz').all()
# ret = session.query(Users).filter(Users.id.between(7, 9), Users.name == 'lqz').all()
# #注意下划线
# ret = session.query(Users).filter(Users.id.in_([1,3,4,6])).all()
# #~非，除。。外
# ret = session.query(Users).filter(~Users.id.in_([1,3,4])).all()
# #二次筛选
# ret=session.query(Users.id,Users.name).filter_by(name='lqz').all()
# ret = session.query(Users).filter(Users.id.in_(session.query(Users.id).filter_by(name='lqz')))
from sqlalchemy import and_, or_
# #or_包裹的都是or条件，and_包裹的都是and条件
# ret = session.query(Users).filter(and_(Users.id > 3, Users.name == 'lqz')).all()
# ret = session.query(Users).filter(or_(Users.id >15, Users.name == 'lqz')).all()
# ret = session.query(Users).filter(
# or_(
# Users.id < 2,
# and_(Users.name == 'lqz', Users.id > 3),
# Users.extra != ""
# ))
#
#
# # 通配符，以e开头，不以e开头
# ret = session.query(Users).filter(Users.name.like('a%'))
# ret = session.query(Users).filter(~Users.name.like('l%')).all()
#
# # 限制，用于分页，区间
# ret = session.query(Users)[1:2]
#
# # 排序，根据name降序排列（从大到小）
# ret = session.query(Users).order_by(Users.name.desc()).all()
# #第一个条件重复后，再按第二个条件升序排
ret = session.query(Users).order_by(Users.name.desc(), Users.id.asc()).all()
#
# # 分组
from sqlalchemy.sql import func
#
# ret = session.query(Users.name).group_by(Users.name).all()
# #分组之后取最大id，id之和，最小id
# ret = session.query(
# Users.name,
# func.max(Users.id),
# func.sum(Users.id),
# func.min(Users.id)).group_by(Users.name).all()
# select name,max(id),sum(id),min(id) from users group by name;
# #haviing筛选
# ret = session.query(
# func.max(Users.id),
# func.sum(Users.id),
# func.min(Users.id)).filter(Users.id>1).group_by(Users.name).having(func.min(Users.id) >2).all()
# select name,max(id),sum(id),min(id) as min_id from users where id >1 group by name having min_id>2;
# # 连表（默认用forinkey关联）
# ret = session.query(Hobby.id,Hobby.caption, Person.name).filter(Hobby.id == Person.hobby_id).all()
# ret = session.query(Hobby, Person).filter(Hobby.id == Person.hobby_id).all()
# select * from hobby,person where hobby.id=person.hobby_id;
# #join表，默认是inner join
# ret = session.query(Person).join(Hobby)
# select * from Person inner join Hobby on Person.hobby_id=Hobby.id;
# #isouter=True 外连，表示Person left join Favor，没有右连接，反过来即可
# ret = session.query(Person).join(Hobby, isouter=True)
###如果不指定isouter表示inner join，默认使用外键字段关联
###如果isouter=True，就是left join
### 如果想实现right join 反过来写ret = session.query(Hobby).join(Person, isouter=True)
# # 自己指定on条件（连表条件）,第二个参数，支持on多个条件，用and_,同上
# ret = session.query(Person).join(Hobby,Person.nid==Hobby.id, isouter=True)
print(ret)
27 执行原生sql
import time
import threading
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
from sqlalchemy.sql import text
from sqlalchemy.engine.result import ResultProxy
from db import Users, Hosts
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
session = Session()
# 查询
# cursor = session.execute('select * from users')
# result = cursor.fetchall()
# 添加
cursor = session.execute('insert into users(name) values(:value)',params={"value":'lqz'})
session.commit()
print(cursor.lastrowid)
session.close()
28 flask-SQLAlchemy
把sqlalchemy集成到flask中
使用步骤：(可能会因为版本出问题)
# 第一步，导入：
from flask_sqlalchemy import SQLAlchemy
# 第二部：实例化得到对象
db = SQLAlchemy()
# 第三步：注册到app中
db.init_app(app)
# 使用session
from models import User
db.session.add(User(name='lqz'))
# 建表，基类db.Model
29 flask-migrate
模拟django可以自动处理表和字段
from flask_migrate import Migrate,MigrateCommand # 2.5.3
Migrate(app,db)
manager.add_command('db', MigrateCommand)
# 在命令行下执行
'''
python3 manage.py db init 初始化：只执行一次,会在项目路径生成一个migrations文件夹
python3 manage.py db migrate 等同于 makemigartions 还没有同步到数据库
python3 manage.py db upgrade 等同于migrate 同步到数据库
'''
补充
1 导出项目的依赖
-pip3 freeze >req.txt # 把所有模块都会导出
-pip3 install pipreqs # 只导出当前项目依赖的模块
-在当前路径下生成requirements.txt
-pipreqs ./ --encoding=utf-8 #如果是window需要指定编码
-py2,和py3 兼容报错（自行百度一下：使用0.4版本以下）
2 运行给你的项目
-创建一个movie库
-在models.py中注释掉顶部两行，解开下面的导入和main，右键执行
-把表创建到数据库中，并且插入一个超级用户
-安装依赖
-启动项目
-python3 manage.py runserver
1.内容有错还请在评论区指出哦！谢谢！
