flask的基本使用

一.flask简介

flask是一款非常流行的Python Web框架，出生于2010年，作者是Armin Ronacher,本来这个项目只是作者在愚人节的一个玩笑，后来由于非常受欢迎，进而成为一个正式的项目。目前为止最新的版本是0.12.2。

flask自2010年发布第一个版本以来，大受欢迎，深得开发者的喜爱，并且在多个公司已经得到了应用，flask能如此流行的原因，可以分为以下几点：

  • 微框架、简洁、只做他需要做的，给开发者提供了很大的扩展性。
  • Flask和相关的依赖（Jinja2、Werkzeug）设计得非常优秀，用起来很爽。
  • 开发效率非常高，比如使用SQLAlchemy的ORM操作数据库可以节省开发者大量书写sql的时间。
  • 社区活跃度非常高。

Flask的灵活度非常之高，他不会帮你做太多的决策，即使做已经帮你做出选择，你也能非常容易的更换成你需要的，比如：

  • 使用Flask开发数据库的时候，具体是使用SQLAlchemy还是MongoEngine或者是不用ORM而直接基于MySQL-Python这样的底层驱动进行开发都是可以的，选择权完全掌握在你自己的手中。区别于Django，Django内置了非常完善和丰富的功能，并且如果你想替换成你自己想要的，要么不支持，要么非常麻烦。
  • 把默认的Jinija2模板引擎替换成Mako引擎或者是其他模板引擎都是非常容易的。

二.开发环境介绍

使用virtualenv创建虚拟环境来进行开发，这样做的好处可以避免环境被污染

virtualenv 安装教程：https://www.cnblogs.com/xufangming/articles/8986725.html

安装flask：

pip install flask

三.装饰器相关知识的回顾

1.无参数装饰器

import time


def wrapper(func):
    def inner(*args, **kwargs):
        start_time = time.time()
        res = func(*args, **kwargs)
        end_time = time.time()
        times = end_time - start_time
        return times
    return inner


@wrapper  # func=wrapper(func)
def func():
    return 123


res = func()
print("花费的时间:%s" % res)    #花费的时间:0.0

2.有参数的装饰器

有参数的装饰器本质上就是在无参数的装饰器的外面在套一层函数，把参数传递进去

例如：

def f1(a=None):  # 定义一个外层函数，给装饰器传参数a默认是None
    def foo(func):  # foo是我们原来的装饰器函数，func是被装饰的函数
        def bar(*args, **kwargs):  # args和kwargs是被装饰器函数的参数
            # 根据装饰器的参数做一些逻辑判断
            if a:
                print("{}您好".format(a))
            else:
                print("您好")
            # 调用被装饰的函数，接收参数args和kwargs
            func(*args, **kwargs)

        return bar

    return foo


@f1()  # 不给装饰器传参数，使用默认的'None'参数  等价于  func=f1(2)(func)
def wish(name):
    print("{}祝您前程似锦".format(name))


@f1("亲爱的园友")  # 给装饰器传一个参数
def greet_wish(name):
    print("{}祝您前程似锦".format(name))


if __name__ == '__main__':
    wish("kevin")
    print('-' * 50)
    greet_wish("kevin")


"""
您好
kevin祝您前程似锦
--------------------------------------------------
亲爱的园友您好
kevin祝您前程似锦
"""

3.flask本质上就是一个带参数的装饰器

@app.route('/index')
def index():
    return 'Index'
 
 
#route的源码如下
def route(self, rule, **options):
    def decorator(f):
        endpoint = options.pop("endpoint", f.__name__)
        self.add_url_rule(rule, endpoint, f, **options)
        return f
    return decorator

四.Django，flask，tornad框架之间的差异

Django:内部包含了非常多的组件比如：orm，form，modelForm，缓存，session等等。

Flask:短小精悍，内部没有包含多少组件，但是第三方的组件是非常丰富的。路由比较特殊：基于装饰器来实现，但是究其本质还是通过add_url_rule来实现

Tornado:是异步非阻塞框架,node.js也是异步非阻塞。

五.flask的初步使用

1.flask组件介绍

flask的模板引擎用的是jinji2

flask使用ORM组件是SQLAlchemy

flask的wsgi工具箱是Werkzeug

2.flask简单示例

from flask import Flask

app=Flask(__name__)


@app.route('/index')
def index():
    return 'hello world'


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

在浏览器中可以看到输入网址可以看到：

3.使用flask实现一个简单的登录示例

 

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

app = Flask(__name__)
app.debug = True
app.secret_key = 'lcgasdasdadhahah'

USERS = {
    1: {'name': '漩涡鸣人', 'age': 19, 'gender': '男', 'text': '我一直都是说道做到的,因为这就是我的忍道'},
    2: {'name': '藤原佐为', 'age': 28, 'gender': '男', 'text': '我只知道自己执黑子时从来没输过！'},
    3: {'name': '李舜生', 'age': 18, 'gender': '女', 'text': '总有一天我会撕去这满是虚假的星空'}}


def wrapper(func):
    def inner(*args, **kwargs):
        if not session.get("user_info"):
            return redirect(url_for('login'))
        ret = func(*args, **kwargs)
        return ret

    return inner


@app.route('/login', methods=['GET', 'POST'], endpoint='login')
def login():
    if request.method == "GET":
        return render_template('login.html')
    else:
        user = request.form.get('user')
        pwd = request.form.get('pwd')
        if user == 'lcg' and pwd == '123':
            session['user_info'] = user
            return redirect(url_for('index'))
        return render_template('login.html', error='用户名或密码错误')


@app.route('/detail/<int:nid>', methods=['GET', 'POST'], endpoint='detail')
@wrapper
def detail(nid):
    info = USERS.get(nid)
    return render_template('detail.html', info=info)


@app.route('/index', methods=['GET'], endpoint='index')
@wrapper
def index():
    return render_template('index.html', user_dict=USERS)


if __name__ == '__main__':
    app.run()
demo.py
<!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>
templates/login.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>用户列表</h1>
<table>
    {% for k,v in user_dict.items() %}
    <tr>
        <td>{{k}}</td>
        <td>{{v.name}}</td>
        <td>{{v['name']}}</td>
        <td>{{v.get('name')}}</td>
        <td><a href="/detail/{{k}}">查看详细</a></td>
    </tr>
    {% endfor %}
</table>
</body>
</html>
templates/index.html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>详细信息 {{info.name}}</h1>
<div>
    {{info.text}}
</div>
</body>
</html>
templates/detail.html

 4.flask配置文件相关

flask中的配置文件是一个flask.config.Config对象（继承字典）,默认配置为：
#可以通过 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,
    }
flask默认配置

修改配置的几种方法：

方式一：

app.config['DEBUG'] = True
PS： 由于Config对象本质上是字典，所以还可以使用app.config.update(...)
#可以使用app.config.update()同时的更新多条配置

方式二：

app.config.from_pyfile("python文件名称")
如：
config.py
HOST = '0.0.0.0'
PORT = 3306
 
app.config.from_pyfile("config.py")
#通过print(app.config) 可以知道配置中多了'HOST': '0.0.0.0', 'PORT': 3306这两个变量，如果变量存在，则会替换
 
 
app.config.from_envvar("环境变量名称")
#采用上述方法需要导入os 模块
import os
flask_env= r'D:\flask_demo\config.py'

os.environ['flask_env']=flask_env
app.config.from_envvar('flask_env')

#通过print(app.config) 可以知道配置中多了'HOST': '0.0.0.0', 'PORT': 3306这两个变量，如果变量存在，则会替换

环境变量的值为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('config.Config')
 
config.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

#通过print(app.config) 可以看到配置发生了一些变化

 示例二：采用生开发，测试和生产不同的配置

import os

basedir = os.path.abspath(os.path.dirname(__file__))


class Config:
    SECRET_KEY = os.environ.get('SECRET_KEY') or 'hard to guess string'
    SQLALCHEMY_COMMIT_ON_TEARDOWN = True
    FLASKY_MAIL_SUBJECT_PREFIX = '[Flasky]'
    FLASKY_MAIL_SENDER = '879651072@qq.com'
    FLASKY_ADMIN = os.environ.get('FLASKY_ADMIN')

    @staticmethod
    def init_app(app):
        pass


class DevelopmentConfig(Config):
    DEBUG = True
    MAIL_SERVER = 'smtp.qq.com'
    MAIL_PORT = 587
    MAIL_USE_TLS = True
    MAIL_USERNAME = os.environ.get('MAIL_USERNAME')
    MAIL_PASSWORD = os.environ.get('MAIL_PASSWORD')
    SQLALCHEMY_DATABASE_URI = os.environ.get('DEV_DATABASE_URI') or \
                              'sqlite:///' + os.path.join(basedir, 'data-dev.sqlite')


class TestingConfig(Config):
    TESTING = True
    SQLALCHEMY_DATABASE_URI = os.environ.get('TEST_DATABASE_URI') or \
                              'sqlite:///' + os.path.join(basedir, 'data-test.sqlite')


class ProductionConfig(Config):
    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URI') or \
                              'sqlite:///' + os.path.join(basedir, 'data.sqlite')


config = {
    'development': DevelopmentConfig,
    'testing': TestingConfig,
    'Production': ProductionConfig,
    'default': DevelopmentConfig
}
config.py
from config import config

app.config.from_object(config['development']) #采用开发环境的配置变量

#同样可以使用生产和测试环境的相关变量

#通过print(app.config)可以配置的相关情况

六.路由系统相关介绍

 1.基本用法介绍

路由比较特殊，：是基于装饰器实现的，但是究其本质还是有add_url_rule实现的。

@app.route('/user/<username>')
 
@app.route('/post/<int:post_id>')
 
@app.route('/post/<float:post_id>')
 
@app.route('/post/<path:path>')
 
@app.route('/login', methods=['GET', 'POST'], endpoint='login')

示例：

@app.route('/')
@app.route('/hello')
@app.route('/hello/<name>')
def hello(name=None):
    if name is None:
        name = 'World'
    return 'Hello %s' % name

这个例子接受三种URL规则，”/”和”/hello”都不带参数，函数参数”name”值将为空，页面显示”Hello World”；”/hello/“带参数，页面会显示参数”name”的值，效果与上面第一个例子相同。

2.HTTP请求方法设置

HTTP请求方法常用的有Get, Post, Put, Delete。

from flask import request
 
#@app.route('/login', methods=['GET', 'POST'],endpoint='index') 
@app.route('/login', methods=['GET', 'POST'])  
def login():
    if request.method == 'POST':
        return 'This is a POST request'
    else:
        return 'This is a GET request'


#endpoint是别名，不写别名的话。别名默认就是被装饰的函数名。

当你请求地址”http://localhost:5000/login”，”GET”和”POST”请求会返回不同的内容，其他请求方法则会返回405错误。

3.url_for的用法介绍

url_for第一个参数，应该是视图函数的名字的字符串。后面的参数就是传递给url。
如果传递的参数之前在url中已经定义了，那么这个参数就会被当成path的形式给
url。如果这个参数之前没有在url中定义，那么将变成查询字符串的形式放到url中。

from flask import Flask, url_for

app = Flask(__name__)

app.debug = True


@app.route('/')
def index():
    print(url_for('list1', page=3, num=2))  # /list/3/?num=2
    return 'this is index page'


@app.route('/list/<page>/')
def list1(page):
    return 'this is page %s' % page


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

为什么需要url_for?

1. 将来如果修改了URL，但没有修改该URL对应的函数名，就不用到处去替换URL了。(修改url可以通过函数名来生成相应的url)
2. url_for会自动的处理那些特殊的字符，不需要手动去处理。（可以拼接url）

url_for('list1', page=3, num=2)  # /list/3/?num=2

七.Werkzeug

1.什么是WSGI？什么是wsgiref？

WSGI（Web Server Common Interface）是专门为Python语言制定的web服务器与应用程序之间的网关接口规范，通俗的来说，只要一个服务器拥有一个实现了WSGI标准规范的模块（例如apache的mod_wsgi模块），那么任意的实现了WSGI规范的应用程序都能与它进行交互。因此，WSGI也主要分为两个程序部分：服务器部分和应用程序部分。 
wsgiref则是官方给出的一个实现了WSGI标准用于演示用的简单Python内置库，它实现了一个简单的WSGI Server和WSGI Application（在simple_server模块中），主要分为五个模块：simple_server， util， headers， handlers， validate。

from wsgiref.simple_server import make_server


def runserver(environ, start_response):
    start_response("200 OK", [('Content-Type', 'text/plain; charset=utf-8')])
    return [bytes('Hello, world!', encoding='utf-8')]


if __name__ == '__main__':
    server = make_server("127.0.0.1", 8000, runserver)
    server.serve_forever(
wsgiref示例

werkzeug示例：

from werkzeug.wrappers import Request, Response
from werkzeug.serving import run_simple


@Request.application
def hello(request):
    return Response('Hello World!')


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

werkzeug里面是封装了HTTPServer 的，那么我们就有点底了，这差不多到头了，已经和 Python 的 API 碰上了。好，既然是继承自 HTTPServer，那么就把他当做 HTTPServer。

八.jinja2模板引擎

1.介绍

如果我们单纯的返回文本，可以不需要使用模板引擎，但是在实际生产环境中，我们往往返回的是一个页面，这个时候我们就需要使用模板引擎，在Django中国，自带了模板引擎，在flask中，我们需要使用第三方的模板引擎目前市面上有非常多的模板系统，其中最知名最好用的就是Jinja2和Mako，我们先来看一下这两个模板的特点和不同：

  1. Jinja2：Jinja是日本寺庙的意思，并且寺庙的英文是temple和模板的英文template的发音类似。Jinja2是默认的仿Django模板的一个模板引擎，由Flask的作者开发。它速度快，被广泛使用，并且提供了可选的沙箱模板来保证执行环境的安全，它有以下优点：

    • 让前端开发者和后端开发者工作分离。
    • 减少Flask项目代码的耦合性，页面逻辑放在模板中，业务逻辑放在视图函数中，将页面逻辑和业务逻辑解耦有利于代码的维护。
    • 提供了控制语句、继承等高级功能，减少开发的复杂度。

  2. Marko：Marko是另一个知名的模板。他从Django、Jinja2等模板借鉴了很多语法和API，他有以下优点：

    • 性能和Jinja2相近，在这里可以看到。
    • 有大型网站在使用，有成功的案例。Reddit和豆瓣都在使用。
    • 有知名的web框架支持。Pylons和Pyramid这两个web框架内置模板就是Mako。
    • 支持在模板中写几乎原生的Python语法的代码，对Python工程师比较友好，开发效率高。
    • 自带完整的缓存系统。当然也提供了非常好的扩展借口，很容易切换成其他的缓存系统。

2.flak使用jinja2引擎渲染

2.1简单使用

要渲染一个模板，通过render_template方法即可，以下将用一个简单的例子进行讲解：

from flask import Flask, render_template
 
app = Flask(__name__)
 
 
@app.route('/about/')
def about():
    return render_template('about.html')

当访问/about/的时候，about()函数会在当前目录下的templates文件夹下寻找about.html模板文件。如果想更改模板文件地址，应该在创建app的时候，给Flask传递一个关键字参数template_folder，指定具体的路径，再看以下例子：

from flask import Flask,render_template
    app = Flask(__name__,template_folder=r'C:\templates')
 
    @app.route('/about/')
    def about():
        return render_template('about.html')

以上例子将会在C盘的templates文件夹中寻找模板文件。

2.2模板中传递参数

1. 在使用`render_template`渲染模版的时候，可以传递关键字参数。以后直接在模版中使用就可以了。
2. 如果你的参数过多，那么可以将所有的参数放到一个字典中，然后在传这个字典参数的时候，使用两个星号，将字典打散成关键参数。

from flask import Flask,render_template
 
app = Flask(__name__)
 
 
@app.route('/')
def hello_world():
    context = {
        'username':'xxx',
        'age': 25,
        'country': 'china',
        'childrens': {
            'name':'abc',
            'height': 180
        }
    }
    return render_template('index.html',**context)
 
 
if __name__ == '__main__':
    app.run(debug=True)

index.html：

<body>
    这是从模版中渲染的数据
    <p>{{ username }}</p>
    <p>{{ age }}</p>
    <p>{{ country }}</p>
    <p>{{ childrens.name }}</p>
    <p>{{ childrens['name'] }}</p>
</body>

2.3 模板中反向解析url

模版中的url_for跟我们后台视图函数中`url_for使用起来基本是一模一样的。也是传递视图函数的名字，也可以传递参数。

<a href="{{ url_for('login',ref='/',id='1') }}">登录</a>
<a href="{{ url_for('hello_world') }}">hello</a>

 views.py

@app.route('/accounts/login/<id>/')
def login(id):
    return render_template('login.html')

3.jinja2模板过滤器

1.什么是过滤器，语法是什么

1. 有时候我们想要在模版中对一些变量进行处理，那么就必须需要类似于Python中的函数一样，可以将这个值传到函数中，然后做一些操作。在模版中，过滤器相当于是一个函数，把当前的变量传入到过滤器中，然后过滤器根据自己的功能，再返回相应的值，之后再将结果渲染到页面中。
2. 基本语法：`{{ variable|过滤器名字 }}`。使用管道符号`|`进行组合。

2.常用过滤器

default过滤器：

使用方式{{ value|default('默认值') }}。如果value这个key不存在，那么就会使用default过滤器提供的默认值。如果你想使用类似于python中判断一个值是否为False（例如：None、空字符串、空列表、空字典等），那么就必须要传递另外一个参数{{ value|default('默认值',boolean=True) }}。
可以使用or来替代default('默认值',boolean=True)。例如：{{ signature or '此人很懒，没有留下任何说明' }}。

3.自动转义过滤器：

  1. safe过滤器：可以关闭一个字符串的自动转义。
  2. escape过滤器：对某一个字符串进行转义。
  3. autoescape标签，可以对他里面的代码块关闭或开启自动转义。
from flask import Flask, render_template

app = Flask(__name__)


@app.route('/')
def about():
    alter = '<script>alert("hello")</script>'
    return render_template('about.html', alter=alter)


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

about.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
{{ alter|safe }}
</body>
</html>

下面用法也可以关闭转义

{% autoescape off %}
    {{ alert}}
 {% endautoescape %}
或
 {% autoescape on %}
    {{ alert}}
 {% endautoescape %}
结果一样，同safe过滤器

开启转义：

{% autoescape off %}
    {{ alert|escape}}
 {% endautoescape %}
或
 {% autoescape on %}
    {{ alert|escape}}
 {% endautoescape %}

4.常用过滤器：

  • first(value)：返回一个序列的第一个元素。names|first。
  • format(value,arags,*kwargs)：格式化字符串。例如以下代码：
{{ "%s" - "%s"|format('Hello?',"Foo!") }}

输出：Helloo? - Foo!

  • last(value)：返回一个序列的最后一个元素。示例：names|last。
  • length(value)：返回一个序列或者字典的长度。示例：names|length。
  • join(value,d=u'')：将一个序列用d这个参数的值拼接成字符串。
  • safe(value)：如果开启了全局转义，那么safe过滤器会将变量关掉转义。示例：content_html|safe。
  • int(value)：将值转换为int类型。
  • float(value)：将值转换为float类型。
  • lower(value)：将字符串转换为小写。
  • upper(value)：将字符串转换为小写。
  • replace(value,old,new)： 替换将old替换为new的字符串。
  • truncate(value,length=255,killwords=False)：截取length长度的字符串。
  • striptags(value)：删除字符串中所有的HTML标签，如果出现多个空格，将替换成一个空格。
  • trim：截取字符串前面和后面的空白字符。
  • string(value)：将变量转换成字符串。
  • wordcount(s)：计算一个长字符串中单词的个数。

常用的过滤器大概就是以上的这些

5.自定义模版过滤器：

过滤器本质上就是一个函数。自定义过滤器需要被注册到jinja2模板当中。@app.template_filter('cut')中cut是以后要用的过滤器的名字。这句话就是将自定义过滤器需注册到jinja2模板当中。

 

from flask import Flask, render_template

app = Flask(__name__)


@app.template_filter('rep')
def my_cut(value):
    value = value.replace('xxx', '-')
    return value


@app.route('/')
def about():
    val = 'helloxxxxxxworld'
    return render_template('about.html', val=val)


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

about.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>


    {{val|rep}}

</body>
</html>

6.自定义事件过滤器

from flask import Flask, render_template

from datetime import datetime

app = Flask(__name__)


@app.template_filter('rep')
def my_cut(value):
    value = value.replace('xxx', '-')
    return value


@app.template_filter('handle_time')
def handle_time(time):
    """
    time距离现在的时间间隔
    1. 如果时间间隔小于1分钟以内，那么就显示“刚刚”
    2. 如果是大于1分钟小于1小时，那么就显示“xx分钟前”
    3. 如果是大于1小时小于24小时，那么就显示“xx小时前”
    4. 如果是大于24小时小于30天以内，那么就显示“xx天前”
    5. 否则就是显示具体的时间 2017/10/20 16:15
    """
    if isinstance(time, datetime):
        now = datetime.now()
        timestamp = (now - time).total_seconds()
        if timestamp < 60:
            return "刚刚"
        elif timestamp >= 60 and timestamp < 60 * 60:
            minutes = timestamp / 60
            return "%s分钟前" % int(minutes)
        elif timestamp >= 60 * 60 and timestamp < 60 * 60 * 24:
            hours = timestamp / (60 * 60)
            return '%s小时前' % int(hours)
        elif timestamp >= 60 * 60 * 24 and timestamp < 60 * 60 * 24 * 30:
            days = timestamp / (60 * 60 * 24)
            return "%s天前" % int(days)
        else:
            return time.strftime('%Y/%m/%d %H:%M')
    else:
        return time


@app.route('/')
def about():
    val = 'helloxxxxxxworld'
    create_time = datetime(2017,8,20,16,19,0)
    return render_template('about.html', val=val,create_time=create_time)


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

about.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    {{val|rep}}
    <p>{{ create_time|handle_time }}</p>

</body>
</html>

4.模板控制语句

所有的控制语句都是放在{% ... %}中，并且有一个语句{% endxxx %}来进行结束，Jinja中常用的控制语句有if/for..in..，现对他们进行讲解：

  1. if：if语句和python中的类似，可以使用>，<，<=，>=，==，!=来进行判断，也可以通过and，or，not，()来进行逻辑合并操作，以下看例子：

{% if kenny.sick %}
   Kenny is sick.
{% elif kenny.dead %}
 You killed Kenny!  You bastard!!!
{% else %}
 Kenny looks okay --- so far
{% endif %}

for...in...：for循环可以遍历任何一个序列包括列表、字典、元组。并且可以进行反向遍历，以下将用几个例子进行解释：

普通的遍历：

<ul>
   {% for user in users %}
   <li>{{ user.username }}</li>
   {% endfor %}
</ul>

遍历字典：

<dl>
{% for key, value in my_dict.iteritems() %}
<dt>{{ key}}</dt>
<dd>{{ value}}</dd>
{% endfor %}
</dl>

如果序列中没有值的时候，进入else：

<ul>
{% for user in users %}
<li>{{ user.username}}</li>
{% else %}
<li><em>no users found</em></li>
{% endfor %}
</ul>

并且Jinja中的for循环还包含以下变量，可以用来获取当前的遍历状态：

loop.index 当前迭代的索引（从1开始） 
loop.first 是否是第一次迭代，返回True或False 
loop.last 是否是最后一次迭代，返回True或False
loop.length 序列的长度

另外，不可以使用continue和break表达式来控制循环的执行。

5.模板继承

Flask中的模板可以继承，通过继承可以把模板中许多重复出现的元素抽取出来，放在父模板中，并且父模板通过定义block给子模板开一个口，子模板根据需要，再实现这个block，假设现在有一个base.html这个父模板，代码如下：

<!DOCTYPE html>
<html lang="en">
<head>
    {% block head %}
    <link rel="stylesheet" href="style.css" />
    <title>{% block title %}{% endblock %} - My Webpage</title>
    {% endblock %}
</head>
<body>
    <div id="content">{% block content %}{% endblock %}</div>
    <div id="footer">
        {% block footer %}
        © Copyright 2008 by <a href="http://www.baidu.com">you</a>.
        {% endblock %}
    </div>
</body>
</html>

以上父模板中，抽取了所有模板都需要用到的元素html、body等，并且对于一些所有模板都要用到的样式文件style.css也进行了抽取，同时对于一些子模板需要重写的地方，比如title、head、content都定义成了block，然后子模板可以根据自己的需要，再具体的实现。以下再来看子模板的代码：

{% extends "base.html" %}
{% block title %}Index{% endblock %}
{% block head %}
    {{ super() }}
    <style type="text/css">
        .important { color: #336699; }
    </style>
{% endblock %}
{% block content %}
    <h1>Index</h1>
    <p class="important">
      Welcome to my awesome homepage.
    </p>
{% endblock %}

首先第一行就定义了子模板继承的父模板，并且可以看到子模板实现了title这个block，并填充了自己的内容，再看head这个block，里面调用了super()这个函数，这个函数的目的是执行父模板中的代码，把父模板中的内容添加到子模板中，如果没有这一句，则父模板中处在head这个block中的代码将会被子模板中的代码给覆盖掉。

另外，模板中不能出现重名的block，如果一个地方需要用到另外一个block中的内容，可以使用self.blockname的方式进行引用，比如以下示例：

<title>{% block title %}{% endblock %}</title>
<h1>{{ self.title() }}</h1>
{% block body %}{% endblock %}

以上示例中h1标签重用了title这个block中的内容，子模板实现了title这个block，h1标签也能拥有这个值。

另外，在子模板中，所有的文本标签和代码都要添加到从父模板中继承的block中。否则，这些文本和标签将不会被渲染。

 6.模板转义

转义的概念是，在模板渲染字符串的时候，字符串有可能包括一些非常危险的字符比如<、>等，这些字符会破坏掉原来HTML标签的结构，更严重的可能会发生XSS跨域脚本攻击，因此如果碰到<、>这些字符的时候，应该转义成HTML能正确表示这些字符的写法，比如>在HTML中应该用&lt;来表示等。

但是Flask中默认没有开启全局自动转义，针对那些以.html、.htm、.xml和.xhtml结尾的文件，如果采用render_template函数进行渲染的，则会开启自动转义。并且当用render_template_string函数的时候，会将所有的字符串进行转义后再渲染。而对于Jinja2默认没有开启全局自动转义，作者有自己的原因：

  1. 渲染到模板中的字符串并不是所有都是危险的，大部分还是没有问题的，如果开启自动转义，那么将会带来大量的不必要的开销。
  2. Jinja2很难获取当前的字符串是否已经被转义过了，因此如果开启自动转义，将对一些已经被转义过的字符串发生二次转义，在渲染后会破坏原来的字符串。

在没有开启自动转义的模式下（比如以.conf结尾的文件），对于一些不信任的字符串，可以通过{{ content_html|e }}或者是{{ content_html|escape }}的方式进行转义。在开启了自动转义的模式下，如果想关闭自动转义，可以通过{{ content_html|safe }}的方式关闭自动转义。而{%autoescape true/false%}...{%endautoescape%}可以将一段代码块放在中间，来关闭或开启自动转义，例如以下代码关闭了自动转义：

{% autoescape false %}
  <p>autoescaping is disabled here</p>
  <p>{{ will_not_be_escaped }}</p>
{% endautoescape %}

7.模板数据类型和运算符

数据类型：

Jinja支持许多数据类型，包括：字符串、整型、浮点型、列表、元组、字典、True/False。

运算符：

  • +号运算符：可以完成数字相加，字符串相加，列表相加。但是并不推荐使用+运算符来操作字符串，字符串相加应该使用~运算符。
  • -号运算符：只能针对两个数字相减。
  • /号运算符：对两个数进行相除。
  • %号运算符：取余运算。
  • *号运算符：乘号运算符，并且可以对字符进行相乘。
  • **号运算符：次幂运算符，比如2**3=8。
  • in操作符：跟python中的in一样使用，比如true返回true。
  • ~号运算符：拼接多个字符串，比如HelloWorld将返回HelloWorld。

8.静态文件配置

Web应用中会出现大量的静态文件来使得网页更加生动美观。静态文件主要包括有CSS样式文件、JavaScript脚本文件、图片文件、字体文件等静态资源。在Jinja中加载静态文件非常简单，只需要通过url_for全局函数就可以实现，看以下代码：

<link href="{{ url_for('static',filename='about.css') }}">

url_for函数默认会在项目根目录下的static文件夹中寻找about.css文件，如果找到了，会生成一个相对于项目根目录下的/static/about.css路径。当然我们也可以把静态文件不放在static文件夹中，此时就需要具体指定了，看以下代码：

app = Flask(__name__,static_folder='/tmp')

那么访问静态文件的时候，将会到/tmp这个文件夹下寻找。

九.视图

之前我们接触的视图都是函数，所以一般简称视图函数。其实视图也可以基于类来实现，类视图的好处是支持继承，但是类视图不能跟函数视图一样，写完类视图还需要通过app.add_url_rule(url_rule,view_func)来进行注册。以下将对两种类视图进行讲解：

标准视图：

标准视图继承自flask.views.View，并且在子类中必须实现dispatch_request方法，这个方法类似于视图函数，也要返回一个基于Response或者其子类的对象。以下将用一个例子进行讲解：

class BaseView(views.View):
    # 自定义方法，用来获取模板路径
    def get_template_name(self):
        raise NotImplementedError()
 
    # 必须实现的方法，用来处理请求的
    def dispatch_request(self):
        if request.method != 'GET':
            return 'method error'
 
        #这里从self.get_data()中获取数据，子类应该实现这个方法
        context = {'data':self.get_data()}
        return render_template(self.get_template_name(),**context)
 
class UserView(BaseView):
    # 实现从父类继承的获取模板路径的方法
    def get_template_name(self):
        return 'user.html'
 
    # 重写获取数据的方法
    def get_data(self):
        return [{
            'username': 'fake',
            'avatar': 'http://www.baidu.com/'
        }]
 
# 类视图通过add_url_rule方法和url做映射
app.add_url_rule('/users/',view_func=UserView.as_view('userview'))

基于调度方法的视图：

Flask还为我们提供了另外一种类视图flask.views.MethodView，对每个HTTP方法执行不同的函数（映射到对应方法的小写的同名方法上），这对RESTful API尤其有用，以下将用一个例子来进行讲解：

class UserAPI(views.MethodView):
      # 当客户端通过get方法进行访问的时候执行的函数
      def get(self):
          return jsonify({
              'username':'0bug',
              'avatar':'http://www.baidu.com/'
          })
 
      # 当客户端通过post方法进行访问的时候执行的函数
      def post(self):
          return 'UNSUPPORTED!'
 
  # 通过add_url_rule添加类视图和url的映射，并且在as_view方法中指定该url的名称，方便url_for函数调用
 
  app.add_url_rule('/myuser/',view_func=UserAPI.as_view('userapiview'))

用类视图的一个缺陷就是比较难用装饰器来装饰，比如有时候需要做权限验证的时候，比如看以下例子：

def user_required(f):
    def decorator(*args,**kwargs):
        if not g.user:
            return 'auth failure'
        return f(*args,**kwargs)
    return decorator

如果要在类视图上进行装饰，只能在as_view函数上进行装饰了，使用方式如下：

view = user_required(UserAPI.as_view('users'))
app.add_url_rule('/users/',view_func=view)

从Flask 0.8开始，还可以通过在类中添加decorators属性来实现对视图的装饰：

class UserAPI(views.MethodView):
    decorators = [user_required]
    ...

 

posted @ 2018-07-18 17:41  明-少  阅读(465)  评论(0)    收藏  举报