flask框架快速使用

09-01 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 也许是“微小”的，但它已准备好在需求繁杂的生产环境中投入使用

wsgiref

最简单的Web应用就是先把HTML用文件保存好，用一个现成的HTTP服务器软件，接收用户请求，从文件中读取HTML，返回。

如果要动态生成HTML，就需要把上述步骤自己来实现。不过，接受HTTP请求、解析HTTP请求、发送HTTP响应都是苦力活，如果我们自己来写这些底层代码，还没开始写动态HTML呢，就得花个把月去读HTTP规范。

正确的做法是底层代码由专门的服务器软件实现，我们用Python专注于生成HTML文档。因为我们不希望接触到TCP连接、HTTP原始请求和响应格式，所以，需要一个统一的接口协议来实现这样的服务器软件，让我们专心用Python编写Web业务。这个接口就是WSGI：Web Server Gateway Interface。而wsgiref模块就是python基于wsgi协议开发的服务模块

Copy
from wsgiref.simple_server import make_server

def mya(environ, start_response):
    print(environ)
    start_response('200 OK', [('Content-Type', 'text/html')])
    if environ.get('PATH_INFO') == '/index':
        with open('index.html','rb') as f:
            data=f.read()

    elif environ.get('PATH_INFO') == '/login':
        with open('login.html', 'rb') as f:
            data = f.read()
    else:
        data=b'<h1>Hello, web!</h1>'
    return [data]

if __name__ == '__main__':
    myserver = make_server('', 8011, mya)
    print('监听8010')
    myserver.serve_forever()

wsgiref简单应用

1.安装

pip3 install flask

2.werkzeug简介

Werkzeug是一个WSGI工具包，他可以作为一个Web框架的底层库。这里稍微说一下， werkzeug 不是一个web服务器，也不是一个web框架，而是一个工具包，官方的介绍说是一个 WSGI 工具包，它可以作为一个 Web 框架的底层库，因为它封装好了很多 Web 框架的东西，例如 Request，Response 等等

代码示例：

Copy
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快速使用

Copy
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

Copy
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 == 'cxw' 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

Copy
<!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

Copy
<!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

Copy
<!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>

作业：登录认证装饰器

-多个装饰器执行顺序

-反向查找的名称（endpoint），不允许重复

4.配置文件

flask中的配置文件是一个flask.config.Config对象（继承字典）,默认配置为：

Copy
 {
        '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,
    }

方式一

Copy
   app.config['DEBUG'] = True
   PS： 由于Config对象本质上是字典，所以还可以使用app.config.update(...)

方式二

Copy
#通过py文件配置
app.config.from_pyfile("python文件名称")
如：
settings.py
DEBUG = True

app.config.from_pyfile("settings.py")
#通过环境变量配置
app.config.from_envvar("环境变量名称")
#app.config.from_pyfile(os.environ['YOURAPPLICATION_SETTINGS'])
环境变量的值为python文件名称名称，内部调用from_pyfile方法

app.config.from_json("json文件名称")
JSON文件名称，必须是json格式，因为内部会执行json.loads

app.config.from_mapping({'DEBUG': True})
字典格式

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的配置文件

from  flask import Flask,request,render_template,session,redirect,url_for


app=Flask(__name__)
## 方式一，直接给app设置（仅仅支持以下两个）
# app.secret_key='asdfasdfasdf4545322wefaaeaesfsad'
# app.debug=True  # 调试模式

# 方式二，给app的config设置,可以设置所有配置文件
# 所有配置文件都是这个属性
# print(app.config)
# app.config['DEBUG']=True

# 第三种方式通过py文件(跟django一样了，但是不好，不常用)
# app.config.from_pyfile("settings.py")

#
#通过环境变量配置
# import os
# os.environ['DEBUG']='ddd'
# app.config.from_envvar(os.environ['DEBUG'])
#app.config.from_pyfile(os.environ['YOURAPPLICATION_SETTINGS'])
# 环境变量的值为python文件名称名称，内部调用from_pyfile方法

# app.config.from_json("setting.json")
# JSON文件名称，必须是json格式，因为内部会执行json.loads
# app.config.from_mapping({'DEBUG': True})


# 通过类配置(用的多)
# app.config.from_object('settings.DevelopmentConfig')
app.config.from_object('settings.ProductionConfig')

print(app.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.route('/index')
def index():
    return 'hello world'


if __name__ == '__main__':
    app.run()
setting

setting.py

# DEBUG=True


class Config(object):
    DEBUG = False
    TESTING = False
    DATABASE_URI = 'xxxx'
    USER='root'
    PASSWORD='123'


class ProductionConfig(Config):
    DATABASE_URI = 'mysql://user@localhost/foo'
    USER = 'luffy'
    PASSWORD = 'luffy?'


class DevelopmentConfig(Config):
    DEBUG = True
    DATABASE_URI = '127.0.0.1'
    USER = 'root'
    PASSWORD = '123'


class TestingConfig(Config):
    TESTING = True
View Code

 

 

5.路由系统

典型写法

Copy
@app.route('/detail/<int:nid>',methods=['GET'],endpoint='detail')

默认转换器

Copy
DEFAULT_CONVERTERS = {
    'default':          UnicodeConverter,
    'string':           UnicodeConverter,
    'any':              AnyConverter,
    'path':             PathConverter,
    'int':              IntegerConverter,
    'float':            FloatConverter,
    'uuid':             UUIDConverter,
}

路由系统
from flask import Flask,render_template,redirect,jsonify,request
app=Flask(__name__,template_folder='templates')

# @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,
}
'''

# 路由系统本质(重点)
# @app.route('/')----本质原理----》index=app.route('/')(index)
# app.route()--->decorator内存地址----》index=decorator(index)
# self.add_url_rule(rule, endpoint, f, **options)
# 不使用装饰器来注册路由
# @app.route()
# def index():
#     return jsonify({'name':'lqz','age':18})
#
# def home():
#     return 'home'


# 不用装饰器，自己注册路由
# app.add_url_rule('/',endpoint='index',view_func=index)
# # url('/index',view.test,name='xxx')
# app.add_url_rule('/home',endpoint='home',view_func=home)


#与django路由类似
#django与flask路由：flask路由基于装饰器，本质是基于：add_url_rule
#add_url_rule 源码中，endpoint如果为空，endpoint = _endpoint_from_view_func(view_func)，最终取view_func.__name__（函数名）
# endpoint如果不传，默认用函数名作为反向解析的名字，但是一定要注意多装饰器的问题



#### CBV(源码分析)
from flask.views import View,MethodView
# 如果继承的是View，必须重写dispatch_request，自己去做分发
# class Index(View):# 一般不集成view
#     # 重写dispatch_request
#     def dispatch_request(self):
#         return '所有请求都走我，我自己分发'

# 继承MethodView----》它等同于django中的View
# class Index(MethodView):
#     def get(self):
#         print(request.method)
#         return 'index 的get请求就过来了'
#     def post(self):
#         return 'post请求'



@app.route('/',defaults={'name':'lqz'},redirect_to='http://www.baidu.com')
def index(name):
    return 'sss'

### add_rul_url的参数
'''

@app.route和app.add_url_rule参数:
rule, URL规则，不支持正则 （django2.0以后不用正则了）
view_func, 视图函数名称 （cbv  类名.as_view(name)）
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




'''



### 可以通过自定义，让路由支持正则（了解）

# 注册路由
# 如果是cbv，as_view(name='xx') name就是别名
#如果endpoint不传，使用函数名字作为endpoint----view
# 优先有endpoint指定的
app.add_url_rule('/index',endpoint='sss',view_func=Index.as_view(name='xx'))

if __name__ == '__main__':
    app.run(port=8000)
View Code

 

路由系统本质

Copy
"""
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(源码分析)

Copy
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参数

Copy
@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
    '''

支持正则

Copy
#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.模版

6.1渲染变量

Copy
<!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>

6.2变量的循环

Copy
<!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>

6.3逻辑判断

Copy
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>用户列表</h1>
    <table>
        {% if name %}
          <h1>Hello {{ name }}!</h1>
        {% else %}
          <h1>Hello World!</h1>
        {% endif %}
    </table>
</body>
</html>

比django中多可以加括号，执行函数，传参数

Copy
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

Copy
<!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一模一样

7.请求响应

Copy
   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  post和get提交的数据总和
        # request.cookies  客户端所带的cookie
        # request.headers  请求头
        # request.path     不带域名，请求路径
        # request.full_path  不带域名，带参数的请求路径
        # request.script_root  
        # request.url           带域名带参数的请求路径
        # request.base_url		带域名请求路径
        # request.url_root      域名
        # request.host_url		域名
        # request.host			127.0.0.1:500
        # 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()

8.session

Copy
cookie:存放在客户端的键值对
session：存放在客户端的键值对
token:存放在客户端，通过算法来校验

在使用session之前必须现在设置一下密钥

Copy
app.secret_key="asdas" #值随便

除请求对象之外，还有一个 session 对象。它允许你在不同请求间存储特定用户的信息。它是在 Cookies 的基础上实现的，并且对 Cookies 进行密钥签名要使用会话，你需要设置一个密钥。 (app.session_interface对象)

Copy
设置：session['username'] ＝ 'xxx'
#在django中发什么三件事，1，生成一个随机的字符串 2 往数据库存 3 写入cookie返回浏览器
#在flask中他没有数据库，但session是怎样实现的？
	# 生成一个密钥写入这个cookie,然后下次请求的时候，通过这个cookie解密，然后赋值给session
    #我们通过app.session_interface来查看
  

删除：session.pop('username', None)

app.session_interface中save_session的参数（设置cookie的参数）

Copy
key, 键
value='', 值
max_age=None, 超时时间 cookie需要延续的时间（以秒为单位）如果参数是\ None`` ，这个cookie会延续到浏览器关闭为止
expires=None, 超时时间(IE requires expires, so set it if hasn't been already.)
path='/', Cookie生效的路径，/ 表示根路径，特殊的：根路径的cookie可以被任何url的页面访问，浏览器只会把cookie回传给带有该路径的页面，这样可以避免将cookie传给站点中的其他的应用。
domain=None, Cookie生效的域名 你可用这个参数来构造一个跨站cookie。如， domain=".example.com"所构造的cookie对下面这些站点都是可读的：www.example.com 、 www2.example.com 和an.other.sub.domain.example.com 。如果该参数设置为 None ，cookie只能由设置它的站点读取
secure=False, 浏览器将通过HTTPS来回传cookie
httponly=False 只能http协议传输，无法被JavaScript获取（不是绝对，底层抓包可以获取到也可以被覆盖）

session源码的执行流程

Copy
-save_seesion
	-响应的时候，把session中的值加密序列化放大到了cookie中，返回到浏览器中
-open_session
	-请求来了，从cookie中取出值，反解，生成session对象，以后再视图函数中直接用sessoin就可以了。

session及其源码分析
1 第一步必须配置秘钥
2 全局导入session对象
3 赋值：sesion['key']=value
4 取值：session['key']
5 数据加密以后，放到了cookie中----（token）



1 源码分析执行流程
2 请求来了在open_session中取出cookie，反解数据，包装成session---》视图函数中使用session
3 只要session修改了，请求走了---》save_session---》把session加密，放到cookie中，返回给前端
4 不同浏览器，cookie不同（你的淘宝，同一个浏览器只能登陆一个用户）




回想django中的session如何实现的？
    -原理一模一样，它在哪写的，在中间件中，process_request和process_response
View Code

 

 

9.闪现（message）

Copy
-设置:flash('aaa')
-取值：get_flashed_message()
-
-假设在a页面操作出错，跳转到b页面，在b页面显示a页面的错误信息

示例：

Copy
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:
    如果get_flashed_messages(with_category=True)
    """
    data = get_flashed_messages(category_filter=['x1'])
    if data:
        msg = data[0]
    else:
        msg = "..."
    return "错误信息：%s" %(msg,)

if __name__ == '__main__':
    app.run()

闪现
1 一些数据，放在某个位置，下次请求再取出来，取完就没了（flash）
2 访问index--》name=lqz，放在某个位置
3 下次访问order---》把这个数据取出来
4 放到session中可以吗？

5 本质原理：闪现是基于session的

6 使用
    -设置 flash('aaa')
  -取值：get_flashed_message()
  
7 分类
    -设置：flash('超时错误',category="x1")
    -取值：data = get_flashed_messages(category_filter=['x1'])
View Code

 

 

10.请求扩展

1 before_request

类比django中间件中的process_request，在请求收到之前绑定一个函数做一些事情

Copy
#基于它做用户登录认证
@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，每一个请求之后绑定一个函数，如果请求没有异常

Copy
@app.after_request
def process_response1(response):
    print('process_response1 走了')
    return response

3 before_first_request

第一次请求时,跟浏览器无关

Copy
@app.before_first_request
def first():
    pass

4 teardown_request

每一个请求之后绑定一个函数，即使遇到了异常

Copy
@app.teardown_request 
def ter(e):
    pass

5 errorhandler

路径不存在时404，服务器内部错误500

Copy
@app.errorhandler(404)
def error_404(arg):
    return "404错误了"

6 template_global

标签

Copy
@app.template_global()
def sb(a1, a2):
    return a1 + a2
#{{sb(1,2)}}

7 template_filter

过滤器

Copy
@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所有都执行

请求扩展（django中中间件）

#  请求扩展（等同于django中的中间件，在请求进入视图函数之前，和离开视图函数之后执行一些功能）
# before_request：请求来之前执行（可以加多个，从上往下执行，等同于中间件的process_request）
# after_request:请求走之后（可以加多个，从下往上执行，等同于以中间件的process_response）
# before_first_request:项目运行后的第一次会执行它（初始化的工工作）
# @app.teardown_request:出错也会走，记录日志
# @app.errorhandler(404)：状态码是响应的，就会触发它的执行
#@app.template_global()  # 全局函数，在模板中直接使用
# @app.template_filter() # 全局过滤器，在模板中直接使用
from flask import Flask,request,render_template
from flask.views import MethodView
app = Flask(__name__)
app.debug=False
# @app.before_request
# def before():
#     #取出访问者的ip，记录一下
#     print(request.path)
#     print('我执行了')
#     # return '回去'  # 直接回去了，等同于django中return Response对象
# @app.before_request
# def before2():
#     print('我执行了2222')


# @app.after_request
# def after(response):
#     print('我走了')
#
#     print(response)
#     # response.headers['sss']='sss'
#     #设置cookie
#     return response
# @app.after_request
# def after2(response):
#     print('我走了22222')
#     return response



# @app.before_first_request
# def first():
#     print('我的第一次给了这个地址',request.environ.get('REMOTE_ADDR'))

# @app.teardown_request  # 响应走的时候，错误也会走，记录错误日志，前提是debug为false
# def ter(e):
#     print('我一直走')
#     print(e)


# @app.errorhandler(404)
# def error_404(arg):
#     return "404错误了"
#     # return render_template('好看的模板')

# @app.errorhandler(500)
# def error_500(arg):
#     return "500错误了"


# 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,a4):
    return a1 + 100+a2+a3+a4
#{{ 1|db(2,3)}}



@app.route('/')
def hello_world():
    print('我是视图函数')
    return render_template('index.html',a=100)



if __name__ == '__main__':
    app.run(port=8080)
View Code

 

 

11 中间件（了解）

Copy
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()

请求所有的流程

Copy
ctx = self.request_context(environ)
        error = None
        try:
            try:
                ctx.push()
                #根据路径去执行视图函数，视图类
                response = self.full_dispatch_request()
            except Exception as e:
                error = e
                response = self.handle_exception(e)
            except:  # noqa: B001
                error = sys.exc_info()[1]
                raise
            return response(environ, start_response)
        finally:
            #不管出不出异常，都会走这里
            if self.should_ignore_error(error):
                error = None
            ctx.auto_pop(error)
中间件
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替换为自定义的，
    aaa=Md(app.wsgi_app)
    app.wsgi_app = aaa
    app.run()
    # flask请求来了会执行，执行app()--->触发：类的__call__
    # app.__call__---->self.wsgi_app(environ, start_response)
    # 请求来了以后，会执行Md对象的__call__
    # aaa(environ, start_response)--->Md类的__call__()
View Code

 

 

12.蓝图

对程序进行目录结构划分

不使用蓝图，自己分文件

目录结构：

Copy
-templates
-views
	-__init__.py
    -user.py
    -order.py
-app.py

app.py

Copy
from views import app
if __name__ == '__main__':
    app.run()

init.py

Copy
from flask import Flask,request
app = Flask(__name__)
#不导入这个不行
from . import account
from . import order
from . import user

user.py

Copy
from . import app
@app.route('/user')
def user():
    return 'user'

order.py

Copy
from . import app
@app.route('/order')
def order():
    return 'order'

使用蓝图之中小型系统

详见代码：pro_flask_简单应用程序目录示例.zip

目录结构：

Copy
-flask_pro
	-flask_test
    	-__init__.py
    	-static
        -templates
        -views
        	-order.py
            -user.py
     -manage.py

_init.py

Copy
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

Copy
from flask_test import  app
if __name__ == '__main__':
    app.run(port=8008)

user.py

Copy
from flask import Blueprint
us=Blueprint('user',__name__)

@us.route('/login')
def login():
    return 'login'

order.py

Copy
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的概念

蓝图

1 是一个类的对象，用来划分项目目录，为了避免使用app划分目录的时候出现循环导入问题
2 使用步骤
    -实例化得到一个蓝图对象
        from flask import Blueprint
        account = Blueprint('account', __name__)
    -像使用app一样使用蓝图，注册路由
        @account.route('/login.html', methods=['GET', "POST"])
        def login():
            return render_template('login.html')
        
    -在app中注册蓝图
        from .views.account import account
        app.register_blueprint(account)
        
3 注意点：
    1 蓝图注册进app时，指定前缀（类似于路由分发）
        app.register_blueprint(admin, url_prefix='/admin')
    2 蓝图对象在实例化的时候，可以指定当前蓝图使用哪个模板文件夹和静态文件夹
    如果不指定，默认用app的，查找顺序是先从自己里面找，找不到再找app的
        web = Blueprint('web',__name__,template_folder='templates',static_folder='static')
        
    3 蓝图对象有自己的请求扩展，请求扩展只属于当前蓝图
    # 只有访问当前蓝图管理的路径才会触发请求扩展
    web = Blueprint('web', __name__,template_folder='templates',static_folder='static')
    @web.before_request
    def web_request():
        print('web request')
    @web.after_request
    def web_after(response):
        print(response)
        return response
View Code

 

13.请求上下文源码分析

Copy
第一阶段：将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

14.g对象

专门用来存储用户信息的g对象，g的全称的为global

g对象在一次请求中的所有的代码的地方，都是可以使用的

g对象和session的区别

Copy
session对象是可以跨request的，只要session还未失效，不同的request的请求会获取到同一个session，但是g对象不是，g对象不需要管过期时间，请求一次就g对象就改变了一次，或者重新赋值了一次

15.flask-session

作用：将默认保存的签名cookie中的值 保存到 redis/memcached/file/Mongodb/SQLAlchemy

安装：pip3 install flask-session

使用1：

Copy
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：

Copy
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失效。

Copy
response.set_cookie('k','v',exipre=None)#这样设置即可
#在session中设置
app.session_interface=RedisSessionInterface(conn,key_prefix='lqz',permanent=False)
#一般不用，我们一般都设置超时时间，多长时间后失效

问题：cookie默认超时时间是多少？如何设置超时时间

Copy
#源码expires = self.get_expiration_time(app, session)
'PERMANENT_SESSION_LIFETIME':           timedelta(days=31),#这个配置文件控制

flask请求上下文
1 当flask启动，等待客户端请求
2 一旦请求来了：app()--->app.__call__()---->app.wsgi_app()
3 wsgi_app()源码如下：
    # environ：http请求字典
    # 返回一个ctx=RequestContext,对象中有Request对象，Session对象。。。
    ctx = self.request_context(environ)
    error = None
    try:
        try:
                # 把ctx对象放到了全局变量_request_ctx_stack中
                # _request_ctx_stack全局变量是LocalStack的对象
                # LocalStack类的push方法
                '''
                        def push(self, obj):
                            rv = getattr(self._local, "stack", None)
                            if rv is None:
                                self._local.stack = rv = []
                            rv.append(obj)
                            return rvbefore_first_request,before_request,after_request
                        '''
                ctx.push()
                # 执行请求扩展的东西（before_first_request,before_request,after_request）
                # 根据路径执行视图函数
                response = self.full_dispatch_request()
            except Exception as e:
                error = e
                response = self.handle_exception(e)
                except: 
                    error = sys.exc_info()[1]
                    raise
                    return response(environ, start_response)
            finally:
                 if self.should_ignore_error(error):
                      error = None
                      ctx.auto_pop(error)
View Code

falsk上下文源码分析（详细txt和图片）

请求上下文执行流程（ctx）：
        -0 flask项目一启动，有6个全局变量
            -_request_ctx_stack：LocalStack对象
            -_app_ctx_stack ：LocalStack对象
            -request ： LocalProxy对象
            -session ： LocalProxy对象
        -1 请求来了 app.__call__()---->内部执行：self.wsgi_app(environ, start_response)
        -2 wsgi_app()
            -2.1 执行：ctx = self.request_context(environ)：返回一个RequestContext对象，并且封装了request(当次请求的request对象)，session
            -2.2 执行： ctx.push()：RequestContext对象的push方法
                -2.2.1 push方法中中间位置有：_request_ctx_stack.push(self)，self是ctx对象
                -2.2.2 去_request_ctx_stack对象的类中找push方法（LocalStack中找push方法）
                -2.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
                            self._local.stack = rv = []
                        # 把ctx放到了列表中
                        #self._local={'线程id1':{'stack':[ctx,]},'线程id2':{'stack':[ctx,]},'线程id3':{'stack':[ctx,]}}
                        rv.append(obj)
                        return rv
        -3 如果在视图函数中使用request对象，比如：print(request)
            -3.1 会调用request对象的__str__方法，request类是：LocalProxy
            -3.2 LocalProxy中的__str__方法：lambda x: str(x._get_current_object())
                -3.2.1 内部执行self._get_current_object()
                -3.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__)
                -3.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)
                -3.2.4 所以：print(request) 实质上是在打印当此请求的request对象的__str__
        -4 如果在视图函数中使用request对象，比如：print(request.method):实质上是取到当次请求的reuquest对象的method属性
        
        -5 最终，请求结束执行： 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依次执行
        -flask有一个请求上下文，一个应用上下文
            -ctx:
                -是：RequestContext对象:封装了request和session
                -调用了：_request_ctx_stack.push(self)就是把：ctx放到了那个位置
            -app_ctx:
                -是：AppContext(self) 对象：封装了当前的app和g
                -调用 _app_ctx_stack.push(self) 就是把：app_ctx放到了那个位置
    -g是个什么鬼？
        专门用来存储用户信息的g对象，g的全称的为global 
        g对象在一次请求中的所有的代码的地方，都是可以使用的 
        
        
    -代理模式
        -request和session就是代理对象，用的就是代理模式
View Code
-g是个什么鬼？
    专门用来存储用户信息的g对象，g的全称的为global 
    g对象在一次请求中的所有的代码的地方，都是可以使用的 (当次请求中传递一些数据)
    
-g对象和session的区别
    g对象只对当次请求有效（当此请求内有效）
    session：可以跨请求，该用户的多次请求中都可以使用
View Code

flask-session的使用

1 由于原生的flask中session是加密后放到了cookie中
2 我们想保存到文件中，数据库中，redis（比较多）。。。
3 借助于第三方：flask-session


1 第一种使用方式
from flask import Flask,session
import redis
from flask_session import RedisSessionInterface
app = Flask(__name__)

# 不需要指定
# app.secret_key='dafasdf'

conn=redis.Redis(host='127.0.0.1',port=6379)

app.session_interface=RedisSessionInterface(conn,key_prefix='lqz')
@app.route('/set_session')
def set_session():
    session['name']='lqz'
    return 'session写入了，写了name=lqz'

@app.route('/get_session')
def get_session():
    # s=session['name']
    s=session.get('name','娶不到')
    return '获取到的session是'+s

if __name__ == '__main__':
    app.run()
    
2 第二种方式
from flask_session import Session
# 方式一
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = Redis(host='127.0.0.1',port='6379')
app.config['SESSION_KEY_PREFIX']='lqz'
# 方式二
# app.config.from_object('settings.Pro')
# 使用第三方插件，是一个通用方式
Session(app) # 本质跟上面一样，只不过通过配置文件来处理，好处是后期只改配置文件，即可完成配置




3 注意：设置session的过期时间，在配置文件中设置
app.config['PERMANENT_SESSION_LIFETIME']=timedelta(seconds=7)
View Code

 

 requirements.txt

1 在虚拟环境中直接导出
    pip3 freeze >requirements.txt
2 系统环境装了很多模块，只导出当前项目依赖的模块
    -pip3 install pipreqs
    -pipreqs ./ --encoding=utf8
View Code

threading.local

# 不用local,会出现并发安全的问题
# from threading import Thread
# import time
# lqz = -1
# def task(arg):
#     global lqz
#     lqz = arg
#     # time.sleep(2)
#     print(lqz)
#
# for i in range(10):
#     t = Thread(target=task,args=(i,))
#     t.start()


# 使用local
# from threading import Thread
from threading import local
# import time
# from threading import get_ident
# # 特殊的对象，不同线程操作它，操作的是线程自己的，不会出现并发安全问题
# lqz = local()
# def task(arg):
#     # 对象.val = 1/2/3/4/5
#     lqz.value = arg
#     time.sleep(2)
#     print(lqz.value)
# for i in range(10):
#     t = Thread(target=task,args=(i,))
#     t.start()



# 自己写个local对象（low版本）

# from threading import get_ident,Thread
# import time
# storage = {}
# # {线程id号1:{key:value},线程id号2:{key:value},线程id号3:{key:value}}
# def set(k,v):
#     ident = get_ident() # 获取线程id号
#     if ident in storage:
#         storage[ident][k] = v
#     else:
#         storage[ident] = {k:v}
# def get(k):
#     ident = get_ident()
#     return storage[ident][k]
# def task(arg):
#     set('val',arg)
#     time.sleep(2)
#     v = get('val')
#     print(v)
#
# for i in range(10):
#     t = Thread(target=task,args=(i,))
#     t.start()


# 面向对象版本
# from threading import get_ident,Thread
# import time
# class Local(object):
#     storage = {}
#     # {线程id号1: {key: value}, 线程id号2: {key: value}, 线程id号3: {key: value}}
#     def set(self, k, v):
#         ident = get_ident()
#         if ident in Local.storage:
#             Local.storage[ident][k] = v
#         else:
#             Local.storage[ident] = {k: v}
#     def get(self, k):
#         ident = get_ident()
#         return Local.storage[ident][k]
# obj = Local()
# def task(arg):
#     obj.set('val',arg)
#     v = obj.get('val')
#     print(v)
# for i in range(10):
#     t = Thread(target=task,args=(i,))
#     t.start()


# 面向对象版本，通过.取值，赋值
# from threading import get_ident,Thread
# import time
# class Local(object):
#     storage = {}
#     ## {线程id号1: {key: value}, 线程id号2: {key: value}, 线程id号3: {key: value}}
#     def __setattr__(self, k, v):
#         ident = get_ident()
#         if ident in Local.storage:
#             Local.storage[ident][k] = v
#         else:
#             Local.storage[ident] = {k: v}
#     def __getattr__(self, k):
#         ident = get_ident()
#         return Local.storage[ident][k]
# obj = Local()
# obj2 = Local() # 所有的local对象用的是同一个字典，不好
# def task(arg):
#     obj.val = arg
#     print(obj.val)
# for i in range(10):
#     t = Thread(target=task,args=(i,))
#     t.start()


# 不同local对象，使用自己的字典
# from threading import get_ident,Thread
# import time
# class Local(object):
#     def __init__(self):
#         # self.storage={}  递归
#         # setattr(self,'storage',{}) 递归
#         #Local.__setattr__(self,'storage',{})
#
#         object.__setattr__(self,'storage',{})
#
#     def __setattr__(self, k, v):
#         ident = get_ident()
#         if ident in self.storage:
#             self.storage[ident][k] = v
#         else:
#             self.storage[ident] = {k: v}
#     def __getattr__(self, k):
#         ident = get_ident()
#         return self.storage[ident][k]
# obj = Local()
# def task(arg):
#     obj.val = arg
#     # obj.xxx = arg
#     time.sleep(1)
#     print(obj.val)
# for i in range(10):
#     t = Thread(target=task,args=(i,))
#     t.start()


# 多线程下可以使用，一旦加入协程，就不行了
# 自定义一个兼容线程和协程的local对象
try:
    from greenlet import getcurrent as get_ident

except Exception as e:
    from threading import get_ident

from threading import Thread
import time
class Local(object):
    def __init__(self):
        object.__setattr__(self,'storage',{})
    def __setattr__(self, k, v):
        ident = get_ident()
        if ident in self.storage:
            self.storage[ident][k] = v
        else:
            self.storage[ident] = {k: v}

        # try:
        #     storage[ident][name] = value
        # except KeyError:
        #     storage[ident] = {name: value}


    def __getattr__(self, k):
        ident = get_ident()
        return self.storage[ident][k]
obj = Local()
def task(arg):
    obj.val = arg
    # obj.xxx = arg
    print(obj.storage)
    print(obj.val)
for i in range(10):
    t = Thread(target=task,args=(i,))
    t.start()
View Code

偏函数

from functools import partial  # 偏函数


def add(a,b,c):
    return a+b+c

add=partial(add,2) # add是一个偏函数了，提前传值

print(add)
# print(add(3,4))
print(add(2,3,4))
# print(add(2,3,4))
View Code

 

 

16.数据库连接池

pymsql链接数据库

Copy
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",['lqz','123',])
cursor.execute("select id,name from users where name=%(user)s and pwd=%(pwd)s",{'user':'lqz','pwd':'123'})
obj = cursor.fetchone()
conn.commit()
cursor.close()
conn.close()

print(obj)

数据库连接池版

setting.py

Copy
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

Copy
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

使用：

Copy
obj = SQLHelper.fetch_one("select id,name from users where name=%(user)s and pwd=%(pwd)s", form.data)

数据库连接池
https://www.cnblogs.com/liuqingzheng/articles/9006055.html
    
1 传统方案存在的问题
# 第一种方案，全局使用沟通一个curser会存在效率问题，安全性问题
conn = pymysql.Connect(host='127.0.0.1', user='root', password="123", database='luffy', port=3306)
curser = conn.cursor()

# 第二种：不限制数据库的连接数，会导致连接数暴增
conn = pymysql.Connect(host='127.0.0.1', user='root', password="123", database='luffy', port=3306)
curser = conn.cursor()

2 使用数据库连接池
    -pip3 install DButils
    -两种模式：
        第一种模式不用（为每个线程创建一个连接，线程即使调用了close方法，也不会关闭，只是把连接重新放到连接池，供自己线程再次使用。当线程终止时，连接自动关闭）
        第二种：创建一批连接到连接池，供所有线程共享使用

3 使用步骤
    -第一步：新建sql_pool.py
    import pymysql
    # from DBUtils.PooledDB import PooledDB
    from dbutils.pooled_db import PooledDB
    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='luffy',
        charset='utf8'
    )
    
    -第二步:使用
    from sql_pool import POOL
    conn = POOL.connection() # 从连接池种取一个链接（如果没有，阻塞在这）
    curser = conn.cursor()
    curser.execute('select * from luffy_order where id<2')
    res=curser.fetchall()
    print(res)
View Code

 

 

17.wtforms

安装:pip3 install wtforms

使用1：

Copy
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

Copy
<!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：

Copy
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()
Copy
<!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>

wtforms
0 pip3 install wtforms 
0 要使用邮箱认证，还需要装一个模块：pip3 install email-validator
1 等同于django中的forms，做数据验证，模板的渲染
3 使用
注释
# wtforms


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='用户名长度必须大于6且小于18')
        ],
        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()
基本使用
<!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>
View Code
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='xxx'
    )

    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,2]}) # 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()
更多使用
<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>
View Code

 

 

18.信号

Flask框架中的信号基于blinker，其主要就是让开发者可是在flask请求过程中定制一些用户行为

安装：pip3 install blinker

内置信号：

Copy
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在其中添加数据时，自动触发

使用信号：

Copy
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()

一个流程中的信号触发点（了解）

Copy
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

自定义信号(了解)：

Copy
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()
信号
0 pip3 install blinker
1 让开发者可是在请求过程中定制一些用户行为
2 内置信号
内置信号：
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在其中添加数据时，自动触发

3 信号可以干什么
    1 记录日志（某个表新增了数据，记录日志，某个表删除了数据。。。）
    2 更新缓存（假设给article表数据加了缓存，一旦该表插入数据，一旦触发article表新增数据的信号，删除缓存，重新生成缓存（同步的话速度稍微慢一些，结合celery，异步生成缓存））
    
4 内置信号的使用
    -第一步：定义要给函数
    -第二步：跟信号绑定
    信号.connect(函数内存地址)
    -第三步：触发信号（内置信号自动触发）信号.send(self)
    
5 自定义信号
    -第0步：定义一个信号
    -第一步：定义要给函数
    -第二步：跟信号绑定
    信号.connect(函数内存地址)
    -第三步：触发信号（内置信号自动触发）信号.send(self)
View Code
# 信号
from flask import Flask, signals,render_template

app = Flask(__name__)


# 内置信号使用
# 内置信号request_started = _signals.signal('request-started')                # 请求到来前执行
# 给它绑定一个函数执行

# 第一步：写好函数
def before_request_signal(*args,**kwargs):
    # print('请求来了，触发了这个信号')
    print(args)
    print(kwargs)
    print('模板渲染了，触发了这个信号')



# 第二步：跟信号绑定
signals.request_started.connect(before_request_signal)
# signals.request_finished.connect(before_request_signal)
# 模板渲染后
# signals.template_rendered.connect(before_request_signal)

# 第三步：触发信号（不需要手动触发，请求走到这，就会触发）

@app.route('/')
def hello_world():
    # return 'hello world'
    return render_template('index.html')


if __name__ == '__main__':
    app.run()
    app.wsgi_app()
内置信号
# 自定义信号
from flask import Flask, signals, render_template
from flask.signals import _signals

app = Flask(__name__)

# 第0步：定义信号（定义了一个叫lqz的信号）
lqz = _signals.signal('lqz')


# 第一步：写好函数
def before_request_signal(*args, **kwargs):
    print(args)
    print(kwargs)
    print('触发了自定义的lqz信号')


# 第二步：跟自定义的信号绑定
lqz.connect(before_request_signal)


# 第三步：触发信号（自定义信号，要自己触发）

@app.route('/')
def hello_world():
    res = render_template('index.html')
    # 在模板渲染之后，触发自定义的lqz信号
    lqz.send('sss',name='lqz')
    return res


if __name__ == '__main__':
    app.run()
自定义信号

 

 

19.多app应用

Copy
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)

多app应用
# 多app应用，在一个flask项目中，可以有多个app对象
# werkzeug：0.16.1 及之前版本
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"


dm = DispatcherMiddleware(app1, {
    '/pro': app2,
})

if __name__ == "__main__":
    run_simple('localhost', 5000, dm)

# 当请求来了：dm()--->DispatcherMiddleware的__call__
View Code

 

 

20.flask-script

用于实现类似于django中 python3 manage.py runserver ...类似的命令

安装：pip3 install flask-script

使用

Copy
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

自定制命令

Copy
@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 lqz -u http://www.oldboyedu.com
    执行： python manage.py  cmd --name lqz --url http://www.oldboyedu.com
    :param name:
    :param url:
    :return:
    """
    print(name, url)
#有什么用？
#把excel的数据导入数据库，定制个命令，去执行

falsk-script
1 django 运行项目  python manage.py runserver 
2 借助于flask-script可以子定制命令
    pip3 install flask-script
    
3 使用
    -自带一个runserver
    -自定制命令
    
    

from flask import Flask
from flask_script import Manager
app = Flask(__name__)


manager=Manager(app)


# 自己定制命令
@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 lqz -u http://www.oldboyedu.com
    执行： python manage.py  cmd --name lqz --url http://www.oldboyedu.com
    :param name:
    :param url:
    :return:
    """
    print(name, url)
#有什么用？
#把excel的数据导入数据库，定制个命令，去执行



@app.route('/')
def index():
    return '首页'

if __name__ == '__main__':
    manager.run()
#以后在执行，直接：python3 manage.py runserver
#python3 manage.py runserver --help
View Code

 

 

21flask-admin

安装

Copy
pip3 install flask_admin

简单使用

Copy
from flask import Flask
from flask_admin import Admin

app = Flask(__name__)
#将app注册到adminzhong 
admin = Admin(app)

if __name__=="mian":

	app.run()
#访问
#127.0.0.1:5000/admin端口，会得到一个空白的页面

将表模型注册到admin中

Copy
#在将表注册之前应该对app进行配置
SQLALCHEMY_DATABASE_URI = "mysql+pymysql://root:@127.0.0.1:3307/py9api?charset=utf8mb4"
SQLALCHEMY_POOL_SIZE = 5
SQLALCHEMY_POOL_TIMEOUT = 30
SQLALCHEMY_POOL_RECYCLE = -1

#导入models文件的中的表模型
from flask_admin.contrib.sqla import ModelView
from api.models import Stock,Product,Images,Category,Wxuser,Banner

admin.add_view(ModelView(Stock, db.session))
admin.add_view(ModelView(Product, db.session))

admin.add_view(ModelView(Category, db.session))

如果有个字段是图片指端

Copy
#配置上传文件的路径
#导入from flask_admin.contrib.fileadmin import FileAdmin
from flask_admin.contrib.fileadmin import FileAdmin,form
file_path = op.join(op.dirname(__file__), 'static')
admin = Admin(app)
admin.add_view(FileAdmin(file_path, '/static/', name='文件'))

#如果有个字段要是上传文件重写该方法的modleView类，假设imgae_url是文件图片的字段
class ImagesView(ModelView):

    form_extra_fields = {
        'image_url': form.ImageUploadField('Image',
                                          base_path=file_path,
                                          relative_path='uploadFile/'
                                          )
    }

admin.add_view(ImagesView(Images, db.session))

sqlqlchemy
https://www.cnblogs.com/aizhinong/category/1730604.html

SQLAlchemy

1 orm框架，django-orm
2 第三方的orm框架，可以独立于web项目使用
3 pip3 install SQLAlchemy
4 组成部分
    Engine，框架的引擎
    Connection Pooling ，数据库连接池
    Dialect，选择连接数据库的DB API种类
    Schema/Types，架构和类型
    SQL Exprression Language，SQL表达式语言
    
5 SQLAlchemy不能创建数据库，创建表，创建字段
开篇
# 执行原生sql

## 执行原生sql
import time
import threading
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.engine.base import Engine

engine = create_engine(
    "mysql+pymysql://root:123@127.0.0.1:3306/book?charset=utf8",
    max_overflow=0,  # 超过连接池大小外最多创建的连接
    pool_size=2,  # 连接池大小
    pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
    pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
def task(arg):
    conn = engine.raw_connection()
    cursor = conn.cursor()
    cursor.execute(
        "select * from app01_author"
    )
    result = cursor.fetchall()
    print(result)
    cursor.close()
    conn.close()

for i in range(20):
    t = threading.Thread(target=task, args=(i,))
    t.start()
执行原生sql
# 数据新增

## orm的 单表操作

from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from models import Users,Person,Hobby
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/aaa", max_overflow=0, pool_size=5)
Connection = sessionmaker(bind=engine)

# 每次执行数据库操作时，都需要创建一个Connection,是从连接池中拿链接
con = Connection()

# ############# 执行ORM操作 #############
# 创建出对象，通过conn.add(对象)，把对象增加进去
# obj1 = Users(name="egon")
# con.add(obj1)



# 一对多的关系，新增数据

# hobby=Hobby(caption='橄榄球')
# hobby2=Hobby(caption='乒乓球')
# con.add(hobby)
# person=Person(name='lqz',hobby_id=1)
# con.add(person)

# con.add_all([hobby,hobby2])

hobby=Hobby(caption='美女')
person=Person(name='egon',hobby=hobby)
# person=Person(name='egon',hobby_id=3)

con.add_all([hobby,person])


# 提交事务
con.commit()

# 关闭session，其实是将连接放回连接池
con.close()
数据新增
# models.py



# 通过类，创建表

import datetime
from sqlalchemy.orm import sessionmaker, relationship
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 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)
    # #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'), #索引
    )


# 一对多，一个爱好，可以有多个人喜欢，关联字段写在多的一方，写在Person中
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跟hobby表的id字段关联
    hobby_id = Column(Integer, ForeignKey("hobby.id"))

    # 跟数据库无关，不会新增字段，只用于快速链表操作
    # 类名，backref用于反向查询
    hobby = relationship('Hobby', backref='pers')

# 把表同步到数据库
def init_db():
    """
    根据类创建数据库表
    :return:
    """
    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  # 多久之后对线程池中的线程进行一次连接的回收（重置）
    )
    # 把所有别Base管理的表都创建出来
    Base.metadata.create_all(engine)

def drop_db():
    """
    根据类创建数据库表
    :return:
    """
    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  # 多久之后对线程池中的线程进行一次连接的回收（重置）
    )
    # 把所有别Base管理的表都删除
    Base.metadata.drop_all(engine)

if __name__ == '__main__':
    init_db()
    # drop_db()
models.py
1 orm框，可以独立出来用
2 orm执行原生sql
    -生成engine（连接池）
        engine = create_engine()
     -获取链接
        conn=engine.raw_connection()
     -后续就一样了
    
3 创建表，删除表和生成字段（不能创建数据库）
    -写一个类
        Base = declarative_base()
        class Users(Base):
            __tablename__ = 'users'  # 数据库表名称
            id = Column(Integer, primary_key=True)  # id 主键
            name = Column(String(32), index=True, nullable=False)  # name列，索引，不可为空
    -把被Base管理的所有表创建和删除
        engine = create_engine()
        Base.metadata.create_all(engine)
         Base.metadata.drop_all(engine)
4 单表新增
    engine = create_engine()
    Connection = sessionmaker(bind=engine)
    # 每次执行数据库操作时，都需要创建一个Connection
    conn = Connection()
    user=User(name='lqz')
    conn.add(user)
    conn.add_all([对象1，对象2])
    # 提交
    conn.commit()
    con.close()
    
    
5 一对多关系建立
    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')
        
5 一对多新增
        engine = create_engine()
        Connection = sessionmaker(bind=engine)
        # 每次执行数据库操作时，都需要创建一个Connection
        conn = Connection()
        hobby=Hobby(caption='美女')
        person=Person(name='lqz',hobby_id=1)
        conn.add_all([hobby，person])
        # 第二种方式
        hobby=Hobby(caption='美女')
        person=Person(name='lqz',hobby=hobby) # 通过对象来匹配hobby_id
        conn.add_all([hobby，person])
        
        # 提交
        conn.commit()
        con.close()
一对多新增
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from sqlalchemy.orm import scoped_session
from models import Users

engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/aaa", max_overflow=0, pool_size=5)
# 从连接池中拿一个链接
conn = sessionmaker(bind=engine)
session = scoped_session(conn)
# @app.route('/')
# def index():
#
#     session.add()







obj1 = Users(name="lqz")
session.add(obj1)



"""
# 线程安全，基于本地线程实现每个线程用同一个session
# 特殊的：scoped_session中有原来方法的Session中的一下方法：

public_methods = (
    '__contains__', '__iter__', 'add', 'add_all', 'begin', 'begin_nested',
    'close', 'commit', 'connection', 'delete', 'execute', 'expire',
    'expire_all', 'expunge', 'expunge_all', 'flush', 'get_bind',
    'is_modified', 'bulk_save_objects', 'bulk_insert_mappings',
    'bulk_update_mappings',
    'merge', 'query', 'refresh', 'rollback',
    'scalar'
)
"""


# 提交事务
session.commit()
# 关闭session
session.close()
seoped_session线程安全
# 基本增删查改
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from sqlalchemy.orm import scoped_session
from models import Users,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)
# 从连接池中拿一个链接
conn = sessionmaker(bind=engine)
session = scoped_session(conn)



# 增 add ，add_all

# 查询
#

# 查询Users表中id为1的第一条记录
# filter_by写等式，filter写比较
# res=session.query(Users).filter_by(id=1).first()

# res=session.query(Users).filter(Users.id<2)
# for user in res:
#     print(user.name)

# 影响的条数
# res=session.query(Users).filter_by(id=1).delete()
# res=session.query(Users).filter(Users.id>1).delete()
# print(res)


### 修改
# res是影响的行数
# res=session.query(Users).filter(Users.id > 0).update({"name" : "lqz"})
#类似于django的F查询
# synchronize_session=False 表示加字符串
# res=session.query(Users).filter(Users.id > 0).update({'name': Users.name + "099"}, synchronize_session=False)
# res=session.query(Users).filter(Users.id > 0).update({"age": Users.age + 1}, synchronize_session="evaluate")
# res=session.query(Users).filter(Users.id > 0).update({Users.age: Users.age + 1}, synchronize_session="evaluate")
# print(res)



#查询

# res=session.query(Users).all() # 查所有
# res=session.query(Users).all()[0] #取第一个
# res=session.query(Users).first() ##取第一个

# select name as xx,age form User;
# r2 = session.query(Users.name.label('xx'), Users.age).all()
# # r2 = session.query(Users.name.label('xx'), Users.age)
#
# # print(r2)
# for user in r2:
#     print(user.xx)


#filter传的是表达式，filter_by传的是参数
# r3 = session.query(Users).filter(Users.name == "lqz099").all()
# r3 = session.query(Users).filter(Users.id == 1).all()
# r4 = session.query(Users).filter_by(name='lqz').all()
# r5 = session.query(Users).filter_by(name='lqz').first()
# print(r3)


#:value 和:name 相当于占位符，用params传参数
# select * from user where id<6 and name=lqz099 order by id;
# r6 = session.query(Users).filter(text("id<:value and name=:name")).params(value=6, name='lqz099').order_by(Users.id).all()
#自定义查询sql
# r7 = session.query(Users).from_statement(text("SELECT * FROM users where name=:name")).params(name='lqz099').all()
#
# for u in r7:
#     print(u.id)


### 其它查询操作
#　条件
# ret = session.query(Users).filter_by(name='lqz').all()
#表达式，and条件连接
# ret = session.query(Users).filter(Users.id > 1, Users.name == 'lqz099').all()
# ret = session.query(Users).filter(Users.id.between(5, 6), Users.name == 'lqz099').all()

#注意下划线
# ret = session.query(Users).filter(Users.id.in_([1,3,4])).all()

#~非，除。。外
# ret = session.query(Users).filter(~Users.id.in_([1,3,4])).all()

#二次筛选
# ret = session.query(Users).filter(Users.id.in_(session.query(Users.id).filter_by(name='lqz099')))

from sqlalchemy import and_, or_
#or_包裹的都是or条件，and_包裹的都是and条件
# ret = session.query(Users).filter(and_(Users.id > 3, Users.name == 'eric')).all()
# ret = session.query(Users).filter(Users.id > 3, Users.name == 'eric').all()
# ret = session.query(Users).filter(or_(Users.id < 5, Users.name == 'lqz099')).all()

# ret = session.query(Users).filter(
#     or_(
#         Users.id < 2,
#         and_(Users.name == 'eric', Users.id > 3),
#         Users.age != 8
#     ))
# print(ret)

# 通配符，以e开头，不以e开头
# ret = session.query(Users).filter(Users.name.like('%9%')).all()
# ret = session.query(Users).filter(~Users.name.like('%9%'))

# 限制，用于分页，区间
# select *from user limit(1:4)
# select * from users limit 1,4;   从第一条数据往后取4条
# ret = session.query(Users)[0:4]
# ret = session.query(Users)[2:6]
# print(ret[0].id)



# 排序，根据name降序排列（从大到小）
# ret = session.query(Users).order_by(Users.name.desc()).all()
#第一个条件重复后，再按第二个条件升序排
# ret = session.query(Users).order_by(Users.name.desc(), Users.id.asc())
# print(ret)


### 分组
# 分组
from sqlalchemy.sql import func
#分组之后取最大id，id之和，最小id
# select max(id),sum(id),min(id) from user group by name;
# ret = session.query(
#     func.max(Users.id),
#     func.sum(Users.id),
#     func.min(Users.id)).group_by(Users.name).all()
#haviing筛选
# select max(id),sum(id),min(id) from user group by name having min(id)>2;

# Users.objects.value(Users.name).filter().annotate(a=max(User.id),b=min(User.id)).filter(b__gt=2)
# ret = session.query(
#     func.max(Users.id),
#     func.sum(Users.id),
#     func.min(Users.id)).group_by(Users.name).having(func.min(Users.id) >2).all()





# 连表（默认用forinkey关联）
# select * from person,hobby where person.hobby_id=hobby.id;
# ret = session.query(Person, Hobby).filter(Person.hobby_id == Hobby.id).all()
# # print(ret)[(person,hobby),(person,hobby)]
#
#
# for p in ret:
#     print(p[0])
#     print(p[1].caption)
#     print('-----')


#join表，默认是inner join,没有指定on的字段，默认用外键关联
# select * from Person inner join Hobby on  person.hobby_id =hobby.id;
# ret = session.query(Person).join(Hobby)
# print(ret)
# #isouter=True 外连，表示Person left join Favor，没有右连接，反过来即可
# ret = session.query(Person).join(Hobby, isouter=True)
ret = session.query(Hobby).join(Person, isouter=True)
# print(ret)


# 自己指定on条件（连表条件）,第二个参数，支持on多个条件，用and_,同上
# select * from Person left join Hobby on person.id=hobby.id
# ret = session.query(Person).join(Hobby,Person.hobby_id==Hobby.id, isouter=True)
# print(ret)
# select * from Person inner join Hobby on Person.hobby_id=Hobby.id where person.id>1 and hobby.caption='篮球'
# ret = session.query(Person).join(Hobby).filter(Person.id>1,Hobby.caption=='篮球')


# # 组合（了解）UNION 操作符用于合并两个或多个 SELECT 语句的结果集
# #union和union all的区别？
q1 = session.query(Person.name).filter(Person.nid > 2)
# q1 = session.query(Person.name).filter(Person.nid > 2).all()


# q2 = session.query(Hobby.caption).filter(Hobby.id < 2)
# ret = q1.union(q2).all()
# print(ret)

q1 = session.query(Person.name).filter(Person.nid > 2)
q2 = session.query(Hobby.caption).filter(Hobby.id < 2)
ret = q1.union_all(q2).all()
print(ret)




session.commit()
session.close()
基本增删查改
import datetime
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship
from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index
Base = declarative_base()


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')


# 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  # 多久之后对线程池中的线程进行一次连接的回收（重置）
#     )

# Base.metadata.create_all(engine)
多对多关系建立和操作
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///example.sqlite"
db = SQLAlchemy(app)


class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String, unique=True, nullable=False)
    email = db.Column(db.String, unique=True, nullable=False)


db.session.add(User(username="Flask", email="example@example.com"))
db.session.commit()

users = User.query.all()
flask-sqlalchemy的使用
# 详见sansa项目
# flask和SQLAchemy的管理者，通过他把他们做连接
db = SQLAlchemy()
    - 包含配置
    - 包含ORM基类
    - 包含create_all
    - engine
    - 创建连接
# flask-migrate
python3 manage.py db init 初始化：只执行一次
python3 manage.py db migrate 等同于 makemigartions
python3 manage.py db upgrade 等同于migrate
项目分文件使用sqlalchemy+flask+migrate
1 数据库单实例---》搭建mysql主从（一主一从：读写分离）---》mysql集群---》分库分表
2 django中实现读写分离
    
    
    
3 分表有两种：水平分表（按id范围分表），垂直分表（一对一的关系）

    MyCat：数据库中间件
    1--1000w在default的book表中
    1000w--2000w在db1的book表中
django多数据库
python manage.py makemigraions
            
            python manage.py migrate app名称 --databse=配置文件数据名称的别名
            
            手动操作：
                models.UserType.objects.using('db1').create(title='普通用户')
                result = models.UserType.objects.all().using('default')
                
            自动操作：
                class Router1:
                    def db_for_read(self, model, **hints):
                        """
                        Attempts to read auth models go to auth_db.
                        """
                        return 'db1'

                    def db_for_write(self, model, **hints):
                        """
                        Attempts to write auth models go to auth_db.
                        """
                        return 'default'

                配置：
                    DATABASES = {
                        'default': {
                            'ENGINE': 'django.db.backends.sqlite3',
                            'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
                        },
                        'db1': {
                            'ENGINE': 'django.db.backends.sqlite3',
                            'NAME': os.path.join(BASE_DIR, 'db1.sqlite3'),
                        },
                    }
                    DATABASE_ROUTERS = ['db_router.Router1',]
                    
                使用：
                    models.UserType.objects.create(title='VVIP')

                    result = models.UserType.objects.all()
                    print(result)
                                        
                补充：粒度更细
                    class Router1:
                        def db_for_read(self, model, **hints):
                            """
                            Attempts to read auth models go to auth_db.
                            """
                            if model._meta.model_name == 'usertype':
                                return 'db1'
                            else:
                                return 'default'

                        def db_for_write(self, model, **hints):
                            """
                            Attempts to write auth models go to auth_db.
                            """
                            return 'default'
            问题： 
                app01中的表在default数据库创建
                app02中的表在db1数据库创建
                
                # 第一步：
                    python manage.py makemigraions 
                
                # 第二步：
                    app01中的表在default数据库创建
                    python manage.py migrate app01 --database=default
                
                # 第三步：
                    app02中的表在db1数据库创建
                    python manage.py migrate app02 --database=db1
                    
                # 手动操作：
                    m1.UserType.objects.using('default').create(title='VVIP')
                    m2.Users.objects.using('db1').create(name='VVIP',email='xxx')
                # 自动操作：
                    配置： 
                        class Router1:
                            def db_for_read(self, model, **hints):
                                """
                                Attempts to read auth models go to auth_db.
                                """
                                if model._meta.app_label == 'app01':
                                    return 'default'
                                else:
                                    return 'db1'

                            def db_for_write(self, model, **hints):
                                """
                                Attempts to write auth models go to auth_db.
                                """
                                if model._meta.app_label == 'app01':
                                    return 'default'
                                else:
                                    return 'db1'

                        DATABASE_ROUTERS = ['db_router.Router1',]
                    
                    使用： 
                        m1.UserType.objects.using('default').create(title='VVIP')
                        m2.Users.objects.using('db1').create(name='VVIP',email='xxx')
            其他：
                数据库迁移时进行约束：
                    class Router1:
                        def allow_migrate(self, db, app_label, model_name=None, **hints):
                            """
                            All non-auth models end up in this pool.
                            """
                            if db=='db1' and app_label == 'app02':
                                return True
                            elif db == 'default' and app_label == 'app01':
                                return True
                            else:
                                return False
                            
                            # 如果返回None，那么表示交给后续的router，如果后续没有router，则相当于返回True
                            
                        def db_for_read(self, model, **hints):
                            """
                            Attempts to read auth models go to auth_db.
                            """
                            if model._meta.app_label == 'app01':
                                return 'default'
                            else:
                                return 'db1'

                        def db_for_write(self, model, **hints):
                            """
                            Attempts to write auth models go to auth_db.
                            """
                            if model._meta.app_label == 'app01':
                                return 'default'
                            else:
                                return 'db1'
Python manage.py makemigrations
#
# websocket是给浏览器新建一套协议。协议规定：浏览器和服务端连接之后不断开，以此可以完成：服务端向客户端主动推送消息。
# websocket协议额外做的一些前天操作：
#     - 握手，连接前进行校验
#     - 发送数据加密
# pip3 install gevent-websocket
from geventwebsocket.handler import WebSocketHandler
from gevent.pywsgi import WSGIServer
from flask import Flask,render_template,request
import pickle

app = Flask(__name__)
app.secret_key = 'xfsdfqw'
flask中使用websocket
@app.route('/index')
def index():
    return render_template('index.html')
url
WS_LIST = []

@app.route('/test')
def test():
    ws = request.environ.get('wsgi.websocket')
    if not ws:
        return '请使用WebSocket协议'
    # websocket连接已经成功
    WS_LIST.append(ws)
    while True:
        # 等待用户发送消息，并接受
        message = ws.receive()

        # 关闭：message=None
        if not message:
            WS_LIST.remove(ws)
            break

        for item in WS_LIST:
            item.send(message)

    return "asdfasdf"
View Code
if __name__ == '__main__':
    http_server = WSGIServer(('0.0.0.0', 5000,), app, handler_class=WebSocketHandler)
    http_server.serve_forever()
View Code
 <!DOCTYPE html>
    <html lang="zh-cn">
    <head>
        <meta charset="UTF-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <title>Title</title>
        <style>
            .msg-item{
                padding: 5px;
                border: 1px;
                margin: 0 5px;
            }
        </style>
    </head>
    <body>
        <h1>首页</h1>
        <div>
            <h2>发送消息</h2>
            <input id="msg" type="text"  /> <input type="button" value="发送" onclick="sendMsg()">
            <h2>接收消息</h2>
            <div id="container">

            </div>
        </div>

        <script src="/static/jquery-3.3.1.min.js"></script>
        <script>

            ws = new WebSocket('ws://192.168.12.42:5000/test');
            ws.onmessage = function (event) {
                var tag = document.createElement('div');
                tag.className = 'msg-item';
                tag.innerText = event.data;
                $('#container').append(tag);
            }

            function sendMsg() {
                ws.send($('#msg').val());
            }

        </script>
    </body>
    </html>
View Code

 

 详细内容请移步

https://www.cnblogs.com/xiaoyuanqujing/p/11637949.html

posted @ 2021-02-22 10:57  Οo白麒麟оΟ  阅读(70)  评论(0)  编辑  收藏  举报