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">

```

3模板

2Flask与Http

Flask（瓶子，烧瓶）是使用Python编写的Web为框架，

Web框架可以让我们不用关心底层的请求相应处理，更方便高效地编写Web程序。

因为Flask核心是：简单且已于扩展，所以被称作为框架。
Flask有2个主要依赖：
* 一个是WSGI（Web Segver Gateway Inteface，Web服务器网关接口）工具集——Werkzeug。
* 另一个是Jinjia2模板引擎
> WSGI是Python中用来规定Web服务器如何与PythonWeb程序进行沟通的标准。




### 1.1搭建开发环境
#### 1.1.1 pipenv 工作流
pipenv是基于pip的python包管理工具，

它和pip的用法非常相似，可以看作pip的加强版，它的出现解决了旧的pip+virtualenv+requirement.txt的工作方式的弊端。

具体来说，它是pip、pipfile和virutalenv的结合体，它让包安装、包依赖管理和虚拟环境管理更加方便，使用它可以实现更高效的python项目开发工作流。

使用pip安装pipenv
```
pip install pipenv
```
##### 1.创建虚拟环境
使用pipenv install 命令为当前的项目创建虚拟环境。

如果项目根目录下没有Pipfile文件，就会创建Pipfile和Pipfile.lock文件，

前者用来记录项目依赖包列表，后者记录了固定版本的详细依赖包列表。

当我们使用Pipenv安装/删除/更新依赖包时，Pipfile和Pipfile.lock会自动更新：
```
pipenv nstall
```
>这会为当前项目创建一个文件夹，其中包含隔离的Python解释器环境，并且安装pip、wheel、setuptools等基本的包。
>
>默认情况下，Pipenv会同意管理所有虚拟环境，
>
>在Windows系统中，虚拟环境文件夹会在C:\Users\Administrator\.virtualenvs\目录下创建，
>
>而Linux或MacOS会在~/.local/share/virtualenvs/目录下创建。
>
>如果你想在项目目录内创建虚拟环境文件夹，可以设置环境变量PIPENV_VENV_IN_PROJECT,
>
>这时名为.vev的虚拟环境文件夹将在项目根目录创建。
```
export PIPENV_VENV_IN_PROJECT=1
```
>可以通过--three和--two选项来声明虚拟环境中使用的Python版本，或是使用--python选项指定具体的版本号。

在Pipenv中，可以使用pipenv shell命令显示地激活虚拟环境。退出使用exit：

```
pipenv shell
```
当执行pipenv shell 或pipenv run命令时，pipenv会自动从项目目录下的.env文件中加载环境变量。

除了显示地激活虚拟环境，pipenv还提供了一个pipenv run命令，这个命令允许你不显示地激活虚拟环境即可在当前项目的虚拟环境中执行命令，比如：
```
pipenv run python hello.py
```
##### 2.创建程序实例
```
from flask import Flask
app= FLask(__name__)
```
##### 3.注册路由
```
@app.route('/greet',defaults={'name':'Product'})   # 默认值
@app .route (’ / hi/<name> ' )  # 动态url
@app . route ( ' / hello ’)
def say hello () :
    return hl>Hello  Flask ' </hl> '
```
### 1.2启动开发服务器
```
flask run
```
#### 1.自动发现程序实例
一般来说，在执行flask run命令运行程序前，我们需要提供程序实例所在模块的位置。

我们在上面可以直接运行程序，是因为Flask会自动探测程序实例，自动探测存在下面这些规则：

* 从当前目录寻找app.py和wsgi.py模块，并从中寻找名为app或application的程序实例。
* 从环境变量Flask_APP对应的值寻找名为app或application的程序实例。

因为我们的程序主模块命名为app.py，所以flask run命令会自动在其中寻找程序实例。

如果你的程序主模块是其他名称，比如hello.py，

那么需要设置变量FlASK_APP，将包含程序实例的模块名赋值给这个变量。

Linux或macOS使用export命令：
```
export FLASK_APP = hello
```
在windows系统中使用set命令：
```
set FLASK_APP =hello
```
#### 2.管理环境变量
Flask的自动发现程序实例机制还有第三条规则：如果安装了pythonn-dotenv，

那么在使用flask run或其他命令时会是使用它自动从.flaskenv文件和.env文件中加载环境变量。

>当安装了python-dotenv时，Flask在加载环境变量的优先级是：
>
>手动设置的环境变量>.env中设置的环境变量>.flaskenv设置的环境变量

我们在项目根目录下分别创建两个文件：.env和.flaskenv。

.flaskenv用来存储和Flask相关的公开环境变量，比如FLASK_APP；

而.env用来存储包含敏感信息的环境便令，比如我们会用来配置Email服务器的账户名和密码。

在.flaskenv或.env文件中，环境变量使用键值对的形式定义，每行一个，以#开头的为注释，如下所示：
```
SOME_VAR=1
# 这是注释
FOO="BAR"
```
#### 3.设置运行环境
开发环境和生产环境是我们后面会频繁接触到的概念。

开发环境是指我们在本地编写和测试程序时的计算机环境，而生产环境与开发环境相对，它指的是网站部署上线用户访问的服务器环境。

根据运行环境的不同，Flask程序、扩展以及其他程序会改变相应的行为和设置。
我们将把环境变量FLASK_ENV的值写入.flaskenv文件中。
```
FLASK_ENV=development
```
>如果你想单独控制调试模式的开关，可以通过FLASK_DEBUG环境变量设置，设为1，则开启，设为0，则关闭。不过通常不推荐手动设置这个值。

**重载器**

默认会使用Werkzeug内置的stat重载器，它的缺点是耗电较验证，而且准确性一般。

为了获得更优秀的体验，我们可以安装另一个用于监测文件变动的Python库Watchdog，安装后Werkzeug会自动使用它来监测文件变动：

```
pipenv install watchdog --dev
```
因为这个包只在开发时才会用到，所以我们在安装命令后添加了一个 --dev选项，这用来把这个包声明为开发依赖。

在Pipefile文件中，这个包会被添加到dev-packages部分。

不过，如果项目中使用了单独的css或JS文件时候，那么浏览器可能会缓存这些文件，从而导致对文件做出的修改不能立刻生效。

在浏览器中，我们可以按下Crtl+F5执行硬重载，即忽略缓存并重载（刷新）页面。

### 1.3 Flask扩展

以某扩展实现了 Foo 功能为例，这个扩展的名称将是 Flask Foo Foo-Flask ；

程序包或模块的命名使用小写加下划线，即 flask foo 即导人时的名称 ；

用于初始化的类一般为 Foo ，实例化的类实 般使用小 ，即 foo 初始化这个假想中的 ask Foo 扩展的示例如下所示：
```
from flask import Flask
from flask_foo impor Foo
app =Flask( __name__ )
foo =Foo (app)
```
### 1.4 项目配置
在一个项目中，你会用到许多配置：
* Flask提供的配置
* 扩展提供的配置
* 程序特定的配置。

和平时使用变量不同，这些配置变量都通过Flask对象的app.config属性作为统一的接口来设置和获取，它指向的Config类实际上是字典的子类，所以你可以像操作其他字典一样操作它。

```
app.config['ADMIN_NAME']= 'Peter'
```
使用update()方法则可以一次加载多个值：
```
app.config.update(
TESTTING=True,SECRET_KEY='_sadkowpqk_'
)
```
### 1.5 URL与端点
为了解决修改路由的问题，使用FLask提供的url_for()函数获取url，当路由中定义的URL规则被修改时候，这个函数总会返回争取的URL。
```
@app .route (’ / ’ )
def index() :
    return ’ Hello Flask l ’
调用url_for（'index'）即可获取对应的URL，即'/'
```
### 1.6 Flask命令
通过创建任意一个函数，并为其添加app.cli.command()装饰器，我们就可以注册一个flask命令。
```
@app.cli.command()
def hello():
    click.echo(’hello ,Human‘)
```
在命令行下执行flask hello 就会出发这个hello()函数:
```
$flask hello
hello,Human
```
### 1.7 模板与静态文件
默认情况下，模板文件存放在项目根目录中的templates文件中，静态文件放在static文件下。

这两个文件需要和包含程序实例的模块处于同一个目录下，对应的项目结构示例如下所示：
>hello/
>   templates/
>   static/
>   app.py

### 1.8 Flask与MVC架构

![image.png](https://www.choumaomi.com/static/img/68a591d04630ab82a8cfde6375d2ef07.image.png)
术语views用来表示MVC（Model-View-Controller,模型-视图-控制器）架构中的View。

在MVC架构中，程序被分为三个组件：数据处理(Model)、用户界面（view）、交互逻辑（controller）。

严格来说，Flask并不是MVC架构的框架，因为它没有内置数据模型支持。

为了方便描述，使用了app.route()装饰器的函数仍被称为书体函数，同时会使用<函数名>视图的形式来代指某个视图函数。

粗略归类，如果想要使用Flask编写一个MVC架构的程序，那么视图函数可以作为控制器，视图则是使用Jinja2渲染的HTML模板，而模型Model可以使用其他库来实现。

1Flask起步

### 1. 版本检查
```
import sqlalchemy
sqlalchemy.__version__
```

### 2. 链接
echo：True   会显示每条执行的SQL语句，可以关闭。
create_engine()返回一个Engine的实例，并且它表示通过数据库语法处理细节的核心接口
```
from sqlalchemy import create_engine
engine = create_engine('sqlite:///:memory',echo=True)
```

### 3.声明映像
当使用orm时，构造进程首先描述数据库的表，然后定义我们用来映射哪些表的类。
在现版本中，这2个任务通常一起执行，通过使用Declarative方法，我们可以创建一些包含描述要被映射的实际数据库表的准则的映射类。
通过delarative_base()创建一个基类：
```
from sqlalchemy.ext.declarative import declarative_base
Base=declarative_base()
# 依据这个base定义任意数量的映射类
from sqlalchemy import Column,Integer,String
class User(Base):
    __tablename__ = 'users'
    id = Column(Integer,primary_key=True)
    name = Column(String)
```
### 4.构造模式（暂无）
### 5.创建映射类的实例
```
ed_user = User(name='ed',fullname='Ed Jones',password='edpassword')
```
### 6. 创建会话
orm通过Session与数据库建立链接的，当应用第一次载入时，我们定义一个Session类(声明create_engine（）的同时)，这个session类为新的session对象提供工厂服务。
```
from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)
```
这个定制的session类会创建绑定到数据库的session对象。如果需要和数据库建立链接，只需要实例化一个session：
```
session = Session()
```
此时对象的实例仍在等待中，只有在被使用的时候，才会建立链接。

### 7.添加新对象
```
ed_user = User(name='ed',fullname='Ed Jones',passoword='edspassword')
session.add(ed_user)
session.commit()  # 提交所有剩余的更改数据库
```
### 8.回滚
```
session.rollback()
```
### 9. 查询
通过session的query()方法创建一个查询对象。这个函数的参数数量是可变的，参数可以是任何类或者是类的描述的集合。
```
for instance in session.query(User).order_by(User.id)
    print instance.name,instance.fullname
```
或者
```
for name,fullname in session.query(User.name,User.fullname):
    print name,fullname
```
label()相当于row.name
```
for row in session.query(User.name.label('name_label')).all():
    print(row.name_label)
```
aliased()，是类的别名，如果有多个实体都要查询一个类，可以用aliased()
```
for sqlalchemy.orm import aliased
    user_alias = aliased(User,name='user_alias')
for row in session.query(user_alias,user_alias.name).all():
    print row.user_alias
```
Query的Limit和Offset操作：
```
for u in session.query(User).order_by(User.id)[1:3]:
    print u
```
#### 9.1 关键字过滤查询

* query.filter(User.name == 'ed')  # 等于
* query.filter(User.name != 'ed')   # 不等于
* query.filter(User.name.like('%ed%'))  # 模糊查询
* user.filter(User.name.in_(['ed','wendy','jack']))  # in
* query.filter(User.name.in_(session.query(User.name).filter(User.name.like('%ed%'))))  # in
* query.filter(~User.name.in_(['ed','wendy','jack']))  # not in
* query.filter(User.name ==None)  #is None
* query.filter(User.name !=None)  # not None
**与的操作**
```
from sqlalchemy import and_
```
* query.filter(and_(User.name == 'ed',User.fullname =='Ed Jones')) # and
* query.filter(User.name =='ed',User.fullname =='Ed Jones')  ＃and
* query.filter(User.name == 'ed').filter(User.fullname == 'Ed Jones' ) # and

**并的操作**
```
from sqlalchemy import or_
```
* query.filter(or_(User.name =='ed',User.name =='wendy'))  # or
* query.filter(User.name.match('Wendy'))  #match

#### 9.2 返回列表和数量

1. all()返回一个列表：可以进行Python列表的操作
```
query = session.query(User).filter(User.name.like('%ed')).order_by(User.id)
query.all()
输出
[<User(name='ed',fullname='EdJones', password='f8s7ccs')>,<User(name='fred',fullname='FredFlinstone', password='blah')>]
```
2. first() 适用于限制一个情况，返回查询到的第一个结果作为标量？
```
query.first()

<User(name='ed',fullname='Ed Jones', password='f8s7ccs')>
```
3. one()完全获取所有行，并且如果查询到的不只有一个对象或是复合行，就会抛出异常。
```
from sqlalchemy.orm.exc import MultipleResultsFound
user=query.one()
try:
    user = query.one()
except:
    MultipleResultsFound, e:
    print e
```
如果一行也没有，会抛出no row was found的错误。
**scalar()作为one()方法的一句，并且在one()成功基础上返回行的第一列**
```
query = session.query(User.id).filter(User.name =='ed')
query.scarlar()
```
#### 9.3 使用字符串SQL

#### 9.4 计数
 count()用来统计查询结果的数量 
```
session.query(User).filter(User.name.like('%ed')).count()
```
更高级的用法：func.count()
```
from sqlalchemy import func
session.query(func.count(User.name),username).group_by(User.name).all()
[(1,'ed'),(1,'fred'),(1,'mary'),(1,'wendy')]
```
为了实现简单技术SELECT count(\*) FROM table:
```
session.query(func.count('*')).select_from(User).scalar()
或者
session.query(func.count(User.id)).scalar()
```
### 10. 建立联系（外键）
```
class User(Base):
    __tablename__ = 'user'
    id = Column(Integer, primary_key=True)
    name = Column(String)

    addresses = relationship("Address", backref="user")


class Address(Base):
    __tablename__ = 'address'
    id = Column(Integer, primary_key=True)
    email = Column(String)
    user_id = Column(Integer, ForeignKey('user.id'))
```

#### **具体解释：**
1、假如没有relationship，我们只能像下面这样调用关系数据。
#给定参数user.name，获取该user的addresses（从一个表查询完了之后，再去另一个表中查找）
```
def get_addresses_from_user(user_name):
    user=session.query(User).filter_by(name=user_name).first()
    address=session.query(Address).filter_by(user_id=user.id).first()
    return address
```
如果在User中使用relationship定义addresses属性的话，
```
addresses=relationship('Address')
```
则我们直接在User对象中通过addresses属性获得指定用户的所有地址
```
def get_addresses_from_user(user_name):
    user=session.query(User).filter_by(name=user_name).first()
    return user.addresses
```
**注意，在上面的addresses属性中，我们并没有定义backref属性，所以我们可以通过User对象获取所拥有的地址，但是不能通过Address对象获取到所属的用户**
```
>>> u = User()
>>> u.addresses
[]
>>> a = Address()
>>> a.user
Traceback (most recent call last):
  File "<input>", line 1, in <module>
AttributeError: 'Address' object has no attribute 'user'
```
但是当我们有从Address对象获取所属用户的需求时，backref参数就派上用场了。
```
addresses = relationship('Address', backref='user')
```
>简而言之
**backref用于在关系另一端的类中快捷地创建一个指向当前类对象的属性**


**概念性的东西**
>在大多数的外键约束关系数据库只能连接到一个主键列，或具有唯一约束的列。
>外键约束如果是指向多个列的主键，并且它本身也具有多列，这种被称为：“复合外键”
>外键可以自动更新自己来相应它所引用的行或者列。这被称为级联，是一种建立在关系数据库的功能。
>外键可以参考自己的表格。这种被称为“自引”外键

#### backref 和 back_populates的区别
[brackref和back_populates的区别](https://blog.csdn.net/sinat_41667855/article/details/118729091?spm=1001.2014.3001.5501)
放代码：
```
class Comment(db.Model):    
    id = db.Column(db.Integer, primary_key=True)    
    author = db.Column(db.String(30))    
    email = db.Column(db.String(254))    
    site = db.Column(db.String(255))    
    body = db.Column(db.Text)    
    from_admin = db.Column(db.Boolean, default=False)    
    reviewed = db.Column(db.Boolean, default=False)    
    timestamp = db.Column(db.DateTime, default=datetime.utcnow, index=True)    
    replied_id = db.Column(db.Integer, db.ForeignKey('comment.id'))    
    post_id = db.Column(db.Integer, db.ForeignKey('post.id'))    
    post = db.relationship('Post', back_populates='comments')    
    replies = db.relationship('Comment', back_populates='replied', cascade='all')    
    replied = db.relationship('Comment', back_populates='replies', remote_side=[id])

```
> cascade的属性

* cascade=save-update; 默认选项，在添加一条数据的时候，会把其他和它相关联的数据都添加到数据中。若不想同步添加，令cascade=''
* delete；表示当删除某一个模型中的数据的时候，是否也删掉使用relationship和他相关的数据。
* delete-orphan：表示当对一个ORM对象接触了父表中的关联对象的时候，自己便会被删除掉。（即子表中的某条数据没有了关联数据，则该条数据会被自动删除掉）。当然如果父表中的数据被删除，自己也会被删除。这个选项只能用在一对多上，不能用在多对多以及多对一上。并且还需要在子模型中relationship中，增加一个single_parent=True的参数。
* merge：默认选项，当在使用session.merge，合并一个对象的时候，会将使用了relationship相关联的对象也进行merge操作。如user表中已有一条数据id=1,而脚本中另外生成了一条id=1的数据。那么就可用merge覆盖掉原数据及相关联数据。
* all：是对 save-update、merge、refresh-expire,expunge,delete几种的缩写。

> remote_side
* remote_side 字段用于建立多对一的关系，如果不加这个字段会报错。

### 11.操作主外键关联的对象
现在我们已经在User类中创建了一个空的addresser集合，可变集合类型，例如set和dict，都可以用，但是默认的集合类型是list。
```
>>>jack = User(name='jack',fullname='Jack Bean',passowrd ='gjffdd')
>>>jack.address
[]
```
现在可以直接在User对象中添加Address对象。只需要指定一个完整的列表：
```
jack.addresses = [Address(email_adress='jack@google.com'),Address('j25@yahoo.com')]
```
### 12.使用JOINS查询
现在有了2张表，可以进行更多的查询操作。
```
for u,a in session.query(User,Address).filter(User.id==Adress.user_id).filter(Address.email_address=='jack@google.com').all()
    print u
    print a
 
```
**用Query.join()方法会更加简单**
```
session.query(User).join(Address).filter(Adress.email_address=='jack@google.com').all()
```

之所以Query.join()知道怎么join两张表是因为他们之间只有一个外键。如果两张表中没有外键或一个以上的外键，当下列几种形式使用的时候，Query.join()可以表现的更好：
```
query.join(Address,User.id==Address.user_id)  # 明确的条件
query.join(User.addresses)  #指定从左到右的关系
query.join(Address,User.addresses)  # 同样，有明确的目标
query.join('addresses')  # 同样，使用字符串
query.outer_join(User.addresses)  # LEFT OUTER JOIN
```
#### 1.使用别名
当在多个表中查询时，如果同一张表需要被引用好几次，SQL通常要求对这个表起一个别名，因此，SQL可以区分这个表进行的其他操作。Query也支持别名的操作。下面我们joinAddress实体两次，找到同时拥有2个不同的email的用户。
```
>>> from sqlalchemy.orm import aliased
>>>adalias1 = aliased(Address)
>>>adalias2 = aliaed(Address)
>>> for username,email1,email2 in 
      session.query(User.name,adalias1.email_address,adalias2.email_address).
      join(adalias1,User.addresses).
      join(adalias2,User.addresses).
      filter(adalias1.email_address =='jack@google.com').
      filter(adalias2.email_address == 'j25@yahoo.com'):
      print username,email1
```

#### 2.使用子查询
```
from sqlalchemy.sql import func
stmt = session.query(Address.user_id.func.count('*').
          label('address_count')).group_by(Address.user_id).subquery()
>>>
for u,count in session.query(User,stmt.c.address_count).outerjoin(stmt,User.id ==stmt.c.user_id).order_by(User.id)
    print u,count
```
#### 3.从子查询中选择实体
上面的代码中，我们只返回了包含子查询的一个列的结果。如果想要子查询映射到一个实体的话，使用aliaesd()设置一个要映射类的子查询别名。
```
stmt = session.query(Address).filter(Address.email_address!='j25@yahoo.com').subquery()
adalias = aliased(Address,stmt)
>>> for user,address in session.query(User,adalias).join(adalias,User.addresses):
    print user
    print address
```

#### 4.使用exists（存在？)
#### 5.常见的关系运算符
== != None 都是用在多对一中，而contains()用在一对多的集合中：
```
query.filter(Address.user ==someuser)
query.filtere(User.addresses.contains(someaddress))
```
**Any()用于集合中**
```
query.filter(User.addresses.any(Address.email_address =='bar'))
query.filter(User.addresses.any(email_address='bar'))
```
**as()用在标量？不在集合中**
```
query.filter(Address.user.has(name='ed'))
```
**query.with_parent() 所有关系都适用**
```
session.query(Address).with_parent(someuser,'addresses')
```

[更多Sqlalchemy的使用经验](SQLAlchemy使用经验.md)

方法	说明	方法	说明
GET	获取资源	DELETE	删除资源
POST	传输数据	HEAD	获得报文首部
PUT	传输文件	OPTIONS	询问支持的方法

1. 使用Flask-WTF处理表单

0.什么叫做渲染？

0.常见的HTTP方法

1. 版本检查