## 简介及定义

aiohttp是一个为Python提供异步HTTP 客户端/服务端编程，基于asyncio(Python用于支持异步编程的标准库)的异步库。



**核心功能**
* 同时支持客户端使用和服务端使用。
* 同时支持服务端WebSockets组件和客户端WebSockets组件，开箱即用呦。
* web服务器具有中间件，信号组件和可插拔路由的功能。

## 安装
```shell
pip install aiohttp
```
用安装更快的cchardet来替代chardet进行解码
```bash
pip install cchardet
```
对于更快的客户端API DNS解析方案，aiodns是个很好的选择，极力推荐: 
```bash
$ pip install aiodns
```

## 快速开始
client.py
```python
# coding:utf-8
"""
文件直接运行
"""
import aiohttp
import asyncio
import async_timeout

# 定义异步函数=协程
async def fetch(session, url):
    with async_timeout.timeout(10):
        async with session.get(url) as response:
            # 必须使用await，不能使用yield from;如果是使用yield from ，需要采用@asyncio.coroutine相对应
            return await response.text()

async def main():
    async with aiohttp.ClientSession() as session:
        # 建立一个session对象，用session对象去打开网页
        html = await fetch(session, 'http://www.baidu.com')

        print(html.encode('utf-8'))
'''
async def 用来定义异步函数，其内部有异步操作。每个线程有一个事件循环，主线程调用asyncio.get_event_loop()时会创建事件循环，把异步的任务丢给这个循环的run_until_complete()方法，事件循环会安排协同程序的执行。
'''
loop = asyncio.get_event_loop() #获取“事件循环”对象
loop.run_until_complete(main()) #通过事件循环，去调用协程函数
loop.close()  # 结束时间循环
```

server.py
```python
# coding:utf-8
"""
1. 运行文件
2. 在8080端口访问
"""
from aiohttp import web

async def handle(request):
    name = request.match_info.get('name', "Anonymous")
    text = "Hello, " + name
    return web.Response(text=text)

app = web.Application()
app.router.add_get('/', handle)
app.router.add_get('/{name}', handle)

web.run_app(app)
```
## 客户端使用
### 1.发起请求
client2.py
```python
#coding:utf-8
import asyncio
import aiohttp
async  def main():
    async with aiohttp.ClientSession() as session:
        async with session.get('https://api.github.com/events') as resp:
            print(resp.status)
            # print(type(resp.text()))
            a = await resp.text()
            a = a.encode('utf-8')
            print(a)

loop = asyncio.get_event_loop() #获取“事件循环”对象
loop.run_until_complete(main()) 

```
其他请求:
* session.post('http://httpbin.org/post', data=b'data')
* session.put('http://httpbin.org/put', data=b'data')
* session.delete('http://httpbin.org/delete')
* session.head('http://httpbin.org/get')
* session.options('http://httpbin.org/get')
* session.patch('http://httpbin.org/patch', data=b'data')

**注意**
不要为每个请求都创建一个会话。大多数情况下每个应用程序只需要一个会话就可以执行所有的请求。 每个会话对象都包含一个连接池，可复用的连接和持久连接状态(keep-alives，这两个是默认的)可提升总体的执行效率。

### 2.发送json请求
每个会话的请求方法都可接受json参数
```python
async with aiohttp.ClientSession() as session:
    async with session.post(json={'test':'object'})
```
默认情况下，会话session使用Python标准库里的json模块解析json信息。但还可使用其他的json解析器。可以给clientsession制定json_serlialize参数实现
```python
import ujson
async with aiohttp.ClientSession(json_serialize=ujson.dumps) as session:
    async with session.post(json={'test':'object'})
```
### 3.传递url中的参数
```python
params = {'key1': 'value1', 'key2': 'value2'}
async with session.get('http://httpbin.org/get',
                       params=params) as resp:
    assert str(resp.url) == 'http://httpbin.org/get?key2=value2&key1=value1'
```
同键不同值的**并联字典（MultiDict） **也同样支持。 可使用带有两个tuples(元组，python中的数据类型)的list(列表，python中的数据类型)来构建:
```python
params = [('key', 'value1'), ('key', 'value2')]
async with session.get('http://httpbin.org/get',
                       params=params) as r:
    assert str(r.url) == 'http://httpbin.org/get?key=value2&key=value1'
```
同样也允许你传递str（字符串）给params，但要小心一些不能被编码的字符。+就是一个不能被编码的字符:
```python
async with session.get('http://httpbin.org/get',
                       params='key=value+1') as r:
        assert str(r.url) == 'http://httpbin.org/get?key=value+1'
```
**注意**
aiohttp会在发送请求前标准化URL。 域名部分会用IDNA 编码，路径和查询条件会重新编译(requoting)。 比如:URL('http://example.com/путь%30?a=%31') 会被转化为URL('http://example.com/%D0%BF%D1%83%D1%82%D1%8C/0?a=1') 如果服务器需要接受准确的表示并不要求编译URL，那标准化过程应是禁止的。 禁止标准化可以使用encoded=True:
```python
await session.get(URL('http://example.com/%30', encoded=True))
```

*传递params时不要用encode=True，这俩参数不能同时使用。*

### 4.获取响应内容
我们可以读取服务器的响应内容
```python
async with session.get('https://api.github.com/events') as resp:
    print(await resp.text())
```
aiohttp将会自动解码内容。你可以为text()方法指定编码(使用encoding参数):
```python
await resp.text(encoding='windows-1251')
```
#### 获取二进制响应内容
```python
print(await resp.read())
b'[{"created_at":"2015-06-12T14:06:22Z","public":true,"actor":{...
```
#### 获取json响应内容
```python
async with session.get('https://api.github.com/events') as resp:
    print(await resp.json())
```
**注意**
这些方法会读出内存中所有响应的内容。如果你要读非常多的数据，考虑使用流式响应方法进行读取。

#### 获取流失响应内容
read(), json(), text()等方法使用起来很方便，但也要注意谨慎地使用。上述方法会将所有的响应内容加载到内存。举个例子，如果你要下载几个G的文件，这些方法还是会将所有内容都加载到内存，内存会表示"臣妾做不到啊~"(如果内存不够的话)。作为代替你可以用content属性。content其实是 aiohttp.StreamReader类的实例。gzip和deflate传输编码同样会自动解码。
```python
async with session.get('https://api.github.com/events') as resp:
    await resp.content.read(10)
```
一般情况下，你可以使用下列模式将内容保存在一个文件中：
```python
with open(filename, 'wb') as fd:
    while True:
        chunk = await resp.content.read(chunk_size)
        if not chunk:
            break
        fd.write(chunk)
```


### 5.获取请求信息
ClientResponse（客户端响应）对象含有request_info(请求信息)，主要是url和headers信息。 raise_for_status结构体上的信息会被复制给ClientResponseError实例。

#### 自定义headers信息
```python
import json
url = 'https://api.github.com/some/endpoint'
payload = {'some': 'data'}
headers = {'content-type': 'application/json'}

await session.post(url,
                   data=json.dumps(payload),
                   headers=headers)
```

#### 自定义Cookies
```python
url = 'http://httpbin.org/cookies'
cookies = {'cookies_are': 'working'}
async with ClientSession(cookies=cookies) as session:
    async with session.get(url) as resp:
        assert await resp.json() == {
           "cookies": {"cookies_are": "working"}}
```
### 6.发起更复杂的post请求
如果你想发送非表单形式的数据你可用str(字符串)代替dict(字典)。这些数据会直接发送出去。 例如，GitHub API v3 接受JSON编码POST/PATCH数据:
```python
import json
url = 'https://api.github.com/some/endpoint'
payload = {'some': 'data'}

async with session.post(url, data=json.dumps(payload)) as resp:
    ...
```
#### 发送多部分编码文件
```python
url = 'http://httpbin.org/post'
files = {'file': open('report.xls', 'rb')}

await session.post(url, data=files)
```
你也可以显式地设置文件名，文件类型：
```python
url = 'http://httpbin.org/post'
data = FormData()
data.add_field('file',
               open('report.xls', 'rb'),
               filename='report.xls',
               content_type='application/vnd.ms-excel')

await session.post(url, data=data)
```

### 7.流式上传
aiohttp 支持多种形式的流式上传，允许你直接发送大文件而不必读到内存。
```python
with open('massive-body', 'rb') as f:
   await session.post('http://httpbin.org/post', data=f)
```
或者使用aiohttp.streamer对象：
```python
@aiohttp.streamer
def file_sender(writer, file_name=None):
    with open(file_name, 'rb') as f:
        chunk = f.read(2**16)
        while chunk:
            yield from writer.write(chunk)
            chunk = f.read(2**16)

# 之后你可以使用’file_sender‘传递给data:

async with session.post('http://httpbin.org/post',
                        data=file_sender(file_name='huge_file')) as resp:
    print(await resp.text())
```
同样可以使用StreamReader对象.

我们来看下如何把来自于另一个请求的内容作为文件上传并计算其SHA1值:
```python
async def feed_stream(resp, stream):
    h = hashlib.sha256()

    while True:
        chunk = await resp.content.readany()
        if not chunk:
            break
        h.update(chunk)
        stream.feed_data(chunk)

    return h.hexdigest()

resp = session.get('http://httpbin.org/post')
stream = StreamReader()
loop.create_task(session.post('http://httpbin.org/post', data=stream))

file_hash = await feed_stream(resp, stream)
```
因为响应对象的content属性是一个StreamReader实例，所以你可以将get和post请求连在一起用:
```python
r = await session.get('http://python.org')
await session.post('http://httpbin.org/post',
                   data=r.content)
```

### 8.上传预压缩过的数据
上传一个已经压缩过的数据，需要为Headers中的Content-Encoding指定算法名(通常是deflate或者是zlib).
```python
async def my_coroutine(session, headers, my_data):
    data = zlib.compress(my_data)
    headers = {'Content-Encoding': 'deflate'}
    async with session.post('http://httpbin.org/post',
                            data=data,
                            headers=headers)
        pass
```

### 9.持久连接(keep-aliver)，连接池和cookies共享
ClientSession可以在多个请求之间共享cookies
```python
async with aiohttp.ClientSession() as session:
    await session.get(
        'http://httpbin.org/cookies/set?my_cookie=my_value')
    filtered = session.cookie_jar.filter_cookies('http://httpbin.org')
    assert filtered['my_cookie'].value == 'my_value'
    async with session.get('http://httpbin.org/cookies') as r:
        json_body = await r.json()
        assert json_body['cookies']['my_cookie'] == 'my_value'
```
你也可以为所有的会话请求设置headers:
```python
async with aiohttp.ClientSession(
    headers={"Authorization": "Basic bG9naW46cGFzcw=="}) as session:
    async with session.get("http://httpbin.org/headers") as r:
        json_body = await r.json()
        assert json_body['headers']['Authorization'] == \
            'Basic bG9naW46cGFzcw=='
```
### 10.安全cookies
ClientSession中的默认的aiohttp.CookiesJar使用的是严苛模式，RFC 2109明确禁止使用ip地址形式的URL携带cookies信息。比如: http://127.0.0.1:80/cookie 这样很好，不过有些时候我们测试时需要允许携带cookies。在aiohttp.CookiesJar中传递unsafe=True来实现这一效果:

```python
jar = aiohttp.CookieJar(unsafe=True)
session = aiohttp.ClientSession(cookie_jar=jar)
```
### 11. 使用虚假Cookie Jar
有时不想处理cookie。这时可以在会话中使用aiohttp.DummyCookieJar来达到目的。
```python
jar = aiohttp.DummyCookieJar()
session = aiohttp.ClientSession(cookie_jar=jar)
```

### 12. 使用连接器
想要调整请求的传输层你可以为ClientSession及其同类组件传递自定义的连接器。例如:
```python
conn = aiohttp.TCPConnector()
session = aiohttp.ClientSession(connector=conn)
```
#### 限制连接池的容量
限制同一时间打开的连接数可以传递limit参数:
```python
conn = aiohttp.TCPConnector(limit=30)
```
这样就将总数限制在30.

默认情况下是100.

如果你不想有限制，传递0即可:

限制同一时间在同一个端点((host, port, is_ssl) 3者都一样的情况)打开的连接数可指定limit_per_host参数:
```python
conn = aiohttp.TCPConnector(limit_per_host=30)
```
#### 使用自定义域名服务器
底层需要aiodns支持：
```python
from aiohttp.resolver import AsyncResolver

resolver = AsyncResolver(nameservers=["8.8.8.8", "8.8.4.4"])
conn = aiohttp.TCPConnector(resolver=resolver)
```
#### 为Tcp sockets添加ssl控制
默认情况下aiohttp总会对使用了HTTPS协议(的URL请求)查验其身份。但也可将verify_ssl设置为False让其不检查:
```python
r = await session.get('https://example.com', verify_ssl=False)
```
如果你需要设置自定义SSL信息(比如使用自己的证书文件)你可以创建一个ssl.SSLContext实例并传递到ClientSession中:
```python
sslcontext = ssl.create_default_context(
   cafile='/path/to/ca-bundle.crt')
r = await session.get('https://example.com', ssl_context=sslcontext)
```

如果你需要忽略所有SSL的错误:
```python
try:
    await session.get('https://expired.badssl.com/')
except aiohttp.ClientSSLError as e:
    assert isinstance(e, ssl.SSLError)

try:
    await session.get('https://wrong.host.badssl.com/')
except aiohttp.ClientSSLError as e:
    assert isinstance(e, ssl.CertificateError)
```
### 13. unix域套接字
如果你的服务器使用UNIX域套接字你可以用UnixConnector:
```python
conn = aiohttp.UnixConnector(path='/path/to/socket')
session = aiohttp.ClientSession(connector=conn)
```

> 什么是套接字？

TCP用主机的IP地址加上主机上的端口号作为TCP连接的端点，这种端点就叫做套接字（socket）或插口。套接字用（IP地址：端口号）表示，区分不同应用程序进程间的网络通信和连接,主要有3个参数：通信的目的IP地址、使用的传输层协议(TCP或UDP)和使用的端口号。

### 14. 代理支持
aiohttp 支持 HTTP/HTTPS形式的代理。你需要使用proxy参数:
```python
async with aiohttp.ClientSession() as session:
    async with session.get("http://python.org",
                           proxy="http://some.proxy.com") as resp:
        print(resp.status)
```
同时也支持认证代理
```python
async with aiohttp.ClientSession() as session:
    proxy_auth = aiohttp.BasicAuth('user', 'pass')
    async with session.get("http://python.org",
                           proxy="http://some.proxy.com",
                           proxy_auth=proxy_auth) as resp:
        print(resp.status)
```
```python
session.get("http://python.org",
            proxy="http://user:pass@some.proxy.com")
```
### 15.查看响应状态码
```python
async with session.get('http://httpbin.org/get') as resp:
    assert resp.status == 200
```
### 16.获取响应cookies
```python
url = 'http://example.com/some/cookie/setting/url'
async with session.get(url) as resp:
    print(resp.cookies['example_cookie_name'])
```
### 17.使用websockets
客户端
```python
session = aiohttp.ClientSession()
async with session.ws_connect('http://example.org/websocket') as ws:

    async for msg in ws:
        if msg.type == aiohttp.WSMsgType.TEXT:
            if msg.data == 'close cmd':
                await ws.close()
                break
            else:
                await ws.send_str(msg.data + '/answer')
        elif msg.type == aiohttp.WSMsgType.CLOSED:
            break
        elif msg.type == aiohttp.WSMsgType.ERROR:
            break
```

你只能使用一种读取方式(例如await ws.receive() 或者 async for msg in ws:)和写入方法，但可以有多个写入任务，写入任务也是异步完成的(ws.send_str('data'))。

[官方文档](https://www.cntofu.com/book/127/aiohttp%E6%96%87%E6%A1%A3/ClientReference.md)

aiohttp的使用

## 前言
如果我们要把程序部署到其他地方的服务器上，供更多人访问，可能会出现失去的问题，所以可以使用flask-moment来解决。



首先使用pipenv 安装
```
pipenv install flask-moment
```

然后我们实例化扩展提供的Moment类，并传入程序实例app，以完成扩展的初始化；
```
from flask_moment import Moment
app = Flask(__name__)
moment = Moment(app)
```

**Flask-Moment默认以英文显示时间，我们可以传入区域字符串到locale()方法来更改显示语言**
```
{{ moment.locale('zh-cn')}}
```
**更合理的方式是根据用户浏览器或计算机的语言来设置语言**
```
{{ moment.locale(auto_detect=True)}}
```

## 渲染时间日期
**format()方法接受特定的格式字符串来渲染时间格式**，比如：
```
{{ moment(timestamp).format('格式字符串') }}
```


| 格式字符串 | 输出示例 |
| --- | --- |
|L  |2017-07-26  |
|LL  |2017年7月26日  |
|LLL  |2017年7月26日早上8点00分  |
|LLLL  |2017年7月26日星期三早上8点00分  |
|LT  |早上8点00分  |
|LTS  |早上8点0分0秒  |
|lll  |2017年8月10日 03:23  |
|llll  |2017年8月10日 星期四03:23  |

**支持输出相对时间**。比如相对于当前时间的”三分钟前“等。
```
<small>{{ moment(moment.timestamp).fromNow(refresh=True) }}</small>
```
**当鼠标悬停再问候消息的时间日期上时，希望能够显示一个包含具体的绝对时间的弹出窗口**
```
<small data-toggle="tooltip” data- placement= "top " data delay=” 500 ”data- timestamp= ” {{ message timestamp strftime dT sz ’） ｝｝
{ { moment (message . times tamp) . fromNow (refresh=True) } }
</small>
```
我们js中将时间日期对应元素的tooltip内容设置为渲染后的时间日期：
```
$(function(){
    function render_time() {
    return moment($(this).data('timestamp').format('lll'))
    }
    $('[data-toggle="tooltip"]').tooltip)
    {title:render_time});
});

```

flask_moment

5数据库

4表单

## 0.什么叫做渲染？
模板引擎的作用就是读取并执行模板中的特殊语法标记，并根据传入的数据将变量替换为实际值，输出最终的HTML页面，这个过程被称为渲染(rendering)。



flask默认使用的模板为Jinja2，它是一个功能齐全的Python模板引擎，除了设置变量，还允许我们在模板中添加if判断，执行for迭代，调用函数等，以各种方式控制模板输出。

## 1. if和for的用法
```
<div class="layui-inline">       
    <label class="layui-form-label" for="search_s">子类</label>       
    <div class="layui-input-inline">              
        <select name="father" id="search_s">                  
            <option style='display: none'></option>                     
            {%for son in sons%}                  
            {% if '——' not in son%}                   
            <option name="count_type_s" value="{{son}}">{{son}}</option>                  
            {%endif%}                  
            {% endfor %}              
        </select>       
 </div>


```
### 1.1 3种定界符

* 语句，比如if判断、for循环等。
```
{%……%}
```
* 表达式，比如字符串、变量、函数调用等。
```
{{……}}
```
* 注释
```
{#……#}
```

### 1.2 模板语法
Jinja2允许你在模板中使用大部分Python对象，比如字符串、列表、字典、元组、整型、浮点型、布尔值。

它支持其他基本的运算符号（加减乘除）、比较符号 == ！=、逻辑符号（and or not 和括号）以及in、is、None和布尔值。

常用的Jinja2 for循环特殊变量

| 变量名 |说明  |
| --- | --- |
|loop.index  |当前迭代数字，从1开始  |
|loop.index()  |当前迭代数字，从0开始  |
|loop.reindex  |当前反向迭代数，从1开始  |
|loop.reindex()  |当前反向迭代数，从0开始  |
|loop.first  |如果是第一个元素，则为True  |
|loop.last  |如果是最后一个元素，则为True  |
|loop.previtem  |上一个迭代的条目  |
|loop.nextitem  |下一个迭代的条目  |
|loop.length  |序列包含的元素数量  |

### 1.3 过滤器
过滤器是一些可以用来修改和过滤变量值的特殊函数，过滤器和变量用一个竖线隔开，需要参数的过滤可以像函数一样使用括号传递。
```
{{ name|title }}
```
相当于Python里调用name.title().

另一种方法是将过滤器作用于一部分模板数据，使用filter标签和endfilter标签声明开始和结束。

比如下面使用upper过滤器将一段文字转换为大写：
```
{% filter upper%}
    This text become uppercase
{% endfilter %}
```


## 2.模板辅助工具
除了在渲染的时候传入变量，也可以**在模板中定义变量**，使用set标签(set的作用就是定义变量,是全局变量)：
```
{% set navigation = [('/','Home'),('/about','About')]%}
```
**with定义的是局部变量**
```
{% with username = '局部变量'%}
{% endwith %}
```
你也可以将一部分模板数据定义为变量，使用set和endset标签声明开始和结束：
```
{% set navigation%}
<li><a href = "/">Home</a>
<li><a href ="/about">About</a>
{% endset %}
```
### 2.1自定义上下文
如果多个模板都需要使用同一变量，那么比起在多个视图函数中重复传入，更好的方式是能够设置一个模板全局变量。

Flask提供了一个app.context_processor装饰器，可以用来注册模板上下文处理函数，它可以帮我们完成统一传入变量的工作。
```
@app.context_processor
def inject_foo():
    foo = 'I am a foo.'
    return dict(foo=foo)
```
接下来，你就可以直接在Html中调用：
```
{{foo}}
```
### 2.2自定义全局函数
我们可以使用app.template_global装饰器直接将函数注册为模板全局函数。
```
@app.template_global()
def bar():
    return 'I am bar.'
```
默认使用函数的原名称传入模板，在app.template_global装饰器中使用name参数可以指定一个自定义名称。

**内置过滤器**

| 过滤器 |说明  |
| --- | --- |
|default(value,default_value=u'',boolean=False)  |设置默认值，默认值作为参数传入，别名为d  |
|escape(s)  |转义Html文本，别名为e  |
|first(eq)  |返回序列的第一个元素 |
|last(eq)  |返回序列的最后一个元素  |
|length(eq)  |返回变量的长度  |
|random(eq)  |返回序列中的随机元素  |
|safe(value)  |将变量值标记为安全，避免转义  |
|trim(value)  |清楚变量值前后的空格  |
|max(value,case_sensitive=False,attribute=None)  |返回序列中的最大值  |
|min(value,case_sensitive=False,attribute=None)   |返回序列中的最小值  |
|unique(value,case_sensitive=False,attribute=None)   |返回序列中的不重复的值  |
|striptags(value)  |清楚变量值内的Html标签  |
|urlize(value,trim_url_limit=None,nofollow=False,target=None,rel=None)  |将url文本转换为可单击的HTML链接  |
|wordcount(s)  |计算单词数量  |
|tojson(value,indent=None)  |将变量值转换为Json格式  |
|truncate(s,length=225,killwords=False,end='……',leeway=None)  |截断字符串，常用于文章摘要，lenght参数设置截断的长度，killwords参数设置是否阶段单词，end参数设置结尾的符号  |

在使用过滤器时，列表中过滤器函数的第一个参数表示被过滤的变量值或字符串，即竖线符号左侧的值，其他的参数可以通过添加括号传入。
```
<h1>hello,{{name|default('陌生人')|title}}!</h1>
```
XSS攻击的主要防范措施，其中最主要的是对用户输入的文本进行转义。

根据Flask设置，Jinja2会自动对模板中的变量进行转义，所以我们不用手动使用escape过滤器或调用escape()函数对变量进行转义。

> 如果你想避免转义，将变量作为HTML解析，可以对变量使用safe过滤器：
```
{{ sanitized_text|safe}}
```
另一种将文本标记为安全的方法是在渲染前将变量转换为Markup对象。
```
from flask import Markup
@app.route('/hello')
def hello():
    text = Markup('<h1>Hello，Flask！</h1>')
    return render_template('index.html',text=text)
```
这时在模板中可以直接使用{{text}}


### 2.3自定义过滤器
使用app.template_filter()装饰器可以注册自定义过滤器
```
from flask import Markup
@app.template_filter()
def muiscal(s):
    return s+Markup('&#9835;')
```

### 2.4 测试器
用法：
```
{% if age is number %}
{{ age*365 }}
{% else %}
无效的数字
{% endif %}
```
**内置测试器**

| 测试器 |说明  |
| --- | --- |
|callable(object)  | 判断对象是否可被调用 |
|defined(value)  |判断变量是否已定义  |
|undefined(value)  |判断变量是否未定义  |
|none(value)  |判断变量是否为None  |
|number(value)  |判断变量是否为数字  |
|string(value)  |判断变量是否为字符串  |
|sequence(value)  |判断变量是否是序列，比如字符串、列表、元组  |
|iterable(value)  |判断变量是否迭代  |
|mapping(value)  |判断变量是否是匹配对象，比如字典  |
|sameas(value,other)  |判断变量与other是否指向相同的内存地址  |


**自定义测试器**
```
@app.template_text()
def baz(n):
    if n=='baz':
        return True
    return False
```


### 2.5 模板环境对象
在Jinja2中，渲染行为有Jinja2.Environment类控制，所有的配置选项、上下文变量、全局函数、过滤器和测试器都存储在Environment实例上。

当与Flask结合后，我们并不单独创建Environment对象，而是使用Flask创建的Envirment对象，它存储在app.jinja_env的属性上。

在程序中，我们可以使用app.jinja_env更改jinja2设置，比如，可以自定义所有的定界符。
```
app = Flask(__name__)
app.jinja_env.variable_start_string=''[['
app.jinja_env.variable_end_string = ']]'
```

#### 1.添加自定义全局对象
```
def bar():
    return 'I am bar.'
foo = ' I am foo.''
app.jinja_env.globals['bar'] = bar
app.jinja_env.globals['foo'] = foo
```

#### 2.添加自定义过滤器
```
def smiling(s):
    return s+ ':)'
 app.jinja_env.filters['smiling'] = smiling
```
#### 3.添加自定义测试器
```
def baz(n):
    if n =='baz':
        return True
    return False
app.jinja_env.tests['baz'] = baz
```


## 3.模板结构组织
### 3.1局部模板
我们使用include标签来插入一个局部模板，这会把局部模板的全部内容插在使用include标签的位置。

比如，在其他模板中，我们可以在任意位置使用下面的代码插入__banner.html的内容。
```
{% include '_banner.html' %}
```

### 3.2 宏
宏(macro)是Jinja2提供的一个非常有用的特性，类似Python中的函数。

使用宏可以把一部分模板代码封装到宏里，使用传递的参数来构建内容，最后返回构建后的内容。

为了方便管理，我们可以把宏存储在单独的文件中，这个文件通常命名为macros.html或_macors.html。

在创建宏时，我们使用macro和endmacro标签声明宏的开始和结束。在开始标签中定义宏的名称和接受的参数，例如：
```
{% macro qux(amount=1)%}
{% if amount ==1%}
I am qux.
{% elif amout >1%}
We are quxs.
{% endif %}
{% endmacro %}
```
使用时，需要像从Python模块中导入函数一样使用import语句导入它，然后作为函数调用，传入必要的参数，如下所示：
```
{% from 'macros.html' import qux%}
……
{% qux(amout=5)%}

```
在Jinja2中，默认情况下包含(include)一个局部模板会传递当前上下文到局部模板中，但导入(import )却不会。
具体来说，当我们使用render_tempate()函数渲染一个foo.html的模板时，这个foo.html的模板上下文包含下列对象。

* [ ] Flask使用内置的模板上下文处理函数提供的g、session、config、request
* [ ] 扩展使用内置的模板上下文处理函数提供的变量
* [ ] 自定义模板上下文处理器传入的变量
* [ ] 使用render_template()函数传入的变量
* [ ] Jinja2 和Flask内置及自定义全局对象
* [ ] Jinja2内置自定义过滤器
* [ ] Jinja2内置自定义测试器

使用include标签插入的局部模板包含下列对象：

* [ ] Jinja2和Flask内置的全局函数和自定义全局函数
* [ ] Jinja2内置及自定义过滤器
* [ ] Jinja2内置及自定义测试器

因此，如果我们想在导入的宏中使用第一个列表中的2、3、4项，就需要在导入时显式地使用with context 声明传入当前模板的上下文:
```
{% from "macros.html" import foo with context %}
```

### 3.3 模板继承
**编写基模板**
基模板存储了程序页面的固定部分，通常被命名为base.html或layout.html。

块的开始和结束分别使用block和endblock标签声明，而且块之间可以嵌套。

在这个基模板中，我们创建了六个块**head、title、styles、content、footer和scripts**

（1）覆盖内容

当在子模板里创建同名的块时，会使用子块的内容覆盖父块的内容。

（2）追加内容

需要使用super()函数进行声明。
```
{% block styles %}
{{ super() }}
<style>
    .foo{
     color:red;
    }
</style>
{% endblock %}
```
## 4. 模板进阶实践
### 4.1 空白控制
如果你想在渲染时自动去掉这些空行，可以在定界符内添加减号。

比如，{%-endfor%}会移除该语句前的空白，同理，在右边的边界符内测添加减号将移除该语句后的空白。

```
{% if user.bio -%}
<i> This user has not provided a bio.</i>
{% else -%}
<i> This user has not provided a bio.</i>
{%- endif %}
```
除了再模板中使用减号来控制空白外，我们也可以使用模板环境对象提供的trim_blocks和lstrip_blocks属性设置，前者用来删除Jinja2语句后的第一个空行，后者用来删除Jinja2语句所在行之前的空格和制表符：
```
app.jinja_env.trim_blocks = True
app.jinja_env.lstrip_blocks = True
```
宏内的空白不受控制，需要加-号

### 4.2 加载静态文件
```
<img src ="{{url_for('static',filename='avatar.jpg')}} " width="50">

```

简介及定义

前言

1.据库的分类

1. 使用Flask-WTF处理表单

0.什么叫做渲染？