超实用的Flask入门基础教程,新手必备!

2019/04/10 10:10
阅读数 38

Flask入门基础教程

Flask简介

Flask是一个轻量级的可定制框架,使用Python语言编写,较其他同类型框架更为灵活、轻便、安全且容易上手。它可以很好地结合MVC模式进行开发,开发人员分工合作,小型团队在短时间内就可以完成功能丰富的中小型网站或Web服务的实现。另外,Flask还有很强的定制性,用户可以根据自己的需求来添加相应的功能,在保持核心功能简单的同时实现功能的丰富与扩展,其强大的插件库可以让用户实现个性化的网站定制,开发出功能强大的网站。

 

安装Flask

依赖

当安装 Flask 时,以下配套软件会被自动安装:

> - Werkzeug 用于实现 WSGI 是一个 WSGI(在 Web 应用和多种服务器之间的标准 Python 接口) 工具集。

> - jinja2是Python的一个流行的模板引擎。Web模板系统将模板与特定数据源组合以呈现动态网页。

> - MarkupSafe 与 Jinja 共用,在渲染页面时用于避免不可信的输入,防止注入攻击。

> - ItsDangerous 保证数据完整性的安全标志数据,用于保护 Flask 的 session cookie.

> - Click 是一个命令行应用的框架。用于提供 flask 命令,并允许添加自定义 管理命令。

 

创建虚拟环境

创建文件夹,在文件夹下面 输入命令

python -m venv venv_name

激活虚拟环境

激活这个虚拟环境(注意,使用的是虚拟环境的话前面会有(venv_name)这个显示的,不然就是没有激活虚拟环境。)

venv_name\Scripts\activate

 

安装Flask

在已激活的虚拟环境中使用pip安装Flask

pip install Flask

 

基础介绍

在Flask中,最基础的一个功能是这样子的

from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_world():
return 'Hello, World!'

if __name__ == '__main__':
app.run(debug=True, host='0.0.0.0', port=5000)

 

  1.  首先,我们导入了Flask类。
  2. 其次我们创建了Flask的实例,第一个参数是应用模块或者包的名称。 如果你使用单一的模块(如本例),你应该使用 __name__ ,因为模块的名称将会因其作为单独应用启动还是作为模块导入而有不同( 也即是 '__main__' 或实际的导入名)。这是必须的,这样 Flask 才知道到哪去找模板、静态文件等等。
  3. route()是一个路由,其实是一个装饰器,在其中输入URL,会帮我们在这个URL下执行对应的方法。
  4. 接着是函数主体,可以写方法也可以调用其他方法的返回值,最后返回到浏览器上显示的信息
  5. 最后我们用 run() 函数来让应用运行在本地服务器上。 其中 if __name__ =='__main__': 确保服务器只会在该脚本被 Python 解释器直接执行的时候才会运行,而不是作为模块导入的时候。debug=True开启了调试模式,相当于在发生错误时提供一个相当有用的调试器。host=’0.0.0.0‘可以允许同一个局域网内别的用户访问,这个方法让操作系统监听所有公网 IP。port自定义端口。

 

路由

现代Web框架使用路由技术来帮助用户记住应用程序URL。可以直接访问所需的页面,而无需从主页导航。Flask中的route()装饰器用于将URL绑定到函数。例如:

@app.route('/index')
def index():
return 'This is a index page...'

 

在这里,URL '/ index' 规则绑定到index()函数。 因此,如果用户访问127.0.0.1:5000/index,index()函数的输出将在浏览器中呈现。


变量规则

通过把 URL 的一部分标记为 <variable_name> 就可以在 URL 中添加变量。标记的 部分会作为关键字参数传递给函数。通过使用 <converter:variable_name> ,可以 选择性的加上一个转换器,为变量指定规则。请看下面的例子:

 

@app.route('/user/<username>')
def show_user_profile(username):
# show the user profile for that user
return 'User %s' % escape(username)

@app.route('/post/<int:post_id>')
def show_post(post_id):
# show the post with the given id, the id is an integer
return 'Post %d' % post_id

@app.route('/path/<path:subpath>')
def show_subpath(subpath):
# show the subpath after /path/
return 'Subpath %s' % escape(subpath)

 

转换器类型:

类型 说明 
string  (缺省值) 接受任何不包含斜杠的文本
int  接受正整数
float  接受正浮点数
path 类似string,但可以包含斜杠
uuid  接受UUID字符串

 


唯一 URL / 重定向行为

Flask的URL规则是基于Werkzeug的路由模块。模块背后的思想是基于 Apache 以及更早的 HTTP 服务器主张的先例,保证优雅且唯一的 URL。

 

@app.route('/projects/')
def projects():
return 'The project page'

@app.route('/about')
def about():
return 'The about page'

 

访问第一个路由不带/时,Flask会自动重定向到正确地址。
访问第二个路由时末尾带上/后Flask会直接报404 NOT FOUND错误。

永久性重定向和暂时性重定向
flask是通过flask.redirect(location,code=302)这个函数来实现重定向的,location是需要重定向到的url,应该配合之前讲的在url_for()函数来使用,code表示哪种重定向,默认302,也即暂时性重定向,301是永久性重定向.

 

构建URL

如果 Flask 能匹配 URL,那么 Flask 可以生成它们吗?当然可以。你可以用 url_for()来给指定的函数构造 URL。它接受函数名作为第一个参数,也接受对应 URL 规则的变量部分的命名参数。未知变量部分会添加到 URL 末尾作为查询参数。
例如,这里我们使用 test_request_context() 方法来尝试使用 url_for() 。 test_request_context() 告诉 Flask 正在处理一个请求,而实际上也许我们正处在交互 Python shell 之中, 并没有真正的请求。

from flask import Flask, url_for

app = Flask(__name__)

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

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

@app.route('/user/<username>')
def profile(username):
return '{}\'s profile'.format(escape(username))

with app.test_request_context():
print(url_for('index'))    #输出 /
print(url_for('login'))    #输出 /login
print(url_for('login', next='/'))    #输出 /login?next=/
print(url_for('profile', username='John Doe'))    #输出 /user/John%20Doe

 

那么为什么不在把 URL 写死在模板中,而要使用反转函数 url_for() 动态构建?

  1. 反转通常比硬编码 URL 的描述性更好。
  2. 你可以只在一个地方改变 URL ,而不用到处乱找。
  3. URL 创建会为你处理特殊字符的转义和 Unicode 数据,比较直观。
  4. 生产的路径总是绝对路径,可以避免相对路径产生副作用。
  5. 如果你的应用是放在 URL 根路径之外的地方(如在 /myapplication 中,不在 / 中), url_for() 会为你妥善处理。

 

HTTP方法

Web 应用使用不同的 HTTP 方法处理 URL 。当你使用 Flask 时,应当熟悉 HTTP 方法。 缺省情况下,一个路由只回应 GET 请求。 可以使用 route() 装饰器的 methods 参数来处理不同的 HTTP 方法:

from flask import request

@app.route('/login', methods=['GET', 'POST'])
def login():
if request.method == 'POST':
return do_the_login()
else:
return show_the_login_form()如果当前使用了 GET 方法, Flask 会自动添加 HEAD 方法支持,并且同时还会 按照 HTTP RFC 来处理 HEAD 请求。同样, OPTIONS 也会自动实现。

HTTP 方法(也经常被叫做“谓词”)告知服务器,客户端想对请求的页面 做 些什么。下面的都是非常常见的方法:

  1. GET:浏览器告知服务器:只 获取 页面上的信息并发给我。这是最常用的方法。
  2. HEAD:浏览器告诉服务器:欲获取信息,但是只关心 消息头。应用应像处理 GET 请求一样来处理它,但是不分发实际内容。在 Flask 中你完全无需 人工 干预,底层的 Werkzeug 库已经替你打点好了。
  3. POST:浏览器告诉服务器:想在 URL 上 发布 新信息。并且,服务器必须确保 数据已存储且仅存储一次。这是HTML 表单通常发送数据到服务器的方法。
  4. PUT:类似 POST 但是服务器可能触发了存储过程多次,多次覆盖掉旧值。你可能会问这有什么用,当然这是有原因的。考虑到传输中连接可能会丢失,在 这种
  5.  情况下浏览器和服务器之间的系统可能安全地第二次接收请求,而不破坏其它东西。因为 POST它只触发一次,所以用 POST是不可能的。
  6. DELETE:删除给定位置的信息。
  7. OPTIONS:给客户端提供一个敏捷的途径来弄清这个 URL 支持哪些 HTTP 方法。从 Flask 0.6 开始,实现了自动处理。

 

Request对象

from flask import Flask,jsonify
from flask import request

@app.route('/api/add', methods=['POST'])
def add_elasticsearch():
city_name = request.form.get('city_name')
diagnose_people = request.form.get('diagnose_people')
suspect_people = request.form.get('suspect_people')
death_people = request.form.get('death_people')
cure_people = request.form.get('cure_people')
result = main.FuncUtil.add_es(city_name, diagnose_people, suspect_people, death_people, cure_people)
return jsonify(result)

request中”method”变量可以获取当前请求的方法,即”GET”, “POST”, “DELETE”, “PUT”等。”form”变量是一个字典,可以获取Post请求表单中的内容,如果提交的表单中不存在,则会返回一个”KeyError”,你可以不捕获,页面会返回400错误(想避免抛出这”KeyError”,你可以用request.form.get(“user”)来替代)。而”request.args.get()”方法则可以获取Get请求URL中的参数,该函数的第二个参数是默认值,当URL参数不存在时,则返回默认值。在后文的请求对象会讲到。

 

 静态文件

动态 web 应用也会需要静态文件,通常是 CSS 和 JavaScript 文件。理想状况下, 你已经配置好 Web 服务器来提供静态文件,但是在开发中,Flask 也可以做到。 只要在你的包中或是模块的所在目录中创建一个名为 static 的文件夹,在应用中使用 /static 即可访问。
给静态文件生成 URL ,使用特殊的 'static' 端点名:

url_for('static', filename='style.css')

这个文件应该存储在文件系统上的 static/style.css 。


模板渲染

Flask的模板功能是基于Jinja2模板引擎实现的。让我们来实现一个例子。修改之前的Flask运行文件,代码如下:

from flask import Flask,render_template

app = Flask(__name__)

@app.route('/hello/<name>')
def hello_world(name=None):
return render_template('hello.html', name=name)

if __name__ == '__main__':
app.run(debug=True, host='0.0.0.0', port=5000)

 


这段代码”hello()”函数并不是直接返回字符串,而是调用了”render_template()”方法来渲染模板。方法的第一个参数”hello.html”指向你想渲染的模板名称,第二个参数”name”是你要传到模板去的变量,变量可以传多个。接下来我们创建模板文件。在当前目录下,创建一个子目录”templates”(注意,一定要使用这个名字)。然后在”templates”目录下创建文件”hello.html”,内容如下:

<!doctype html>
<title>Hello Reader</title>

{% if name %}
<h1>Hello {{ name }}!</h1>

{% else %}
<h1>Hello World!</h1>

{% endif %}

这是一个HTML模板,根据”name”变量的值,显示不同的内容。变量或表达式由”{{ }}”修饰,而控制语句由”{% %}”修饰,其他的代码,就是我们常见的HTML。打开浏览器,输入”http://127.0.0.1:5000/hello/Reader”,页面上即显示大标题”Hello Reader !”。

 

模板继承

一般我们的网站虽然页面多,但是很多部分是重用的,比如页首,页脚,导航栏之类的。对于每个页面,都要写这些代码,很麻烦。Flask的Jinja2模板支持模板继承功能,省去了这些重复代码。让我们基于上面的例子,在”templates”目录下,创建一个名为”layout.html”的模板:

<!doctype html>

<title>Hello xxx</title>

<link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='style.css') }}">

<div class="page">

{% block body %}

{% endblock %}

</div>

再修改之前的”hello.html”,把原来的代码定义在”block body”中,并在代码一开始”继承”上面的”layout.html”:

{% extends "layout.html" %}
{% block body %}

{% if name %}
<h1>Hello {{ name }}!</h1>

{% else %}
<h1>Hello World!</h1>

{% endif %}
{% endblock %}

 


打开浏览器,再看下”http://127.0.0.1:5000/hello/Reader”页面的源码。

<!doctype html>
<title>Hello xxx</title>

<link rel="stylesheet" type="text/css" href="/static/style.css">

<div class="page">

<h1>Hello Reader!</h1>
</div>

 


你会发现,虽然”render_template()”加载了”hello.html”模板,但是”layout.html”的内容也一起被加载了。而且”hello.html”中的内容被放置在”layout.html”中”{% block body %}”的位置上。形象的说,就是”hello.html”继承了”layout.html”。

 

访问请求数据

对于 Web 应用,与客户端发送给服务器的数据交互至关重要。在 Flask 中由全局的 request 对象来提供这些信息。如果你有一定的 Python 经验,你会好奇,为什么这个对象是全局的,为什么 Flask 还能保证线程安全。答案是本地环境。


本地环境

Flask 中的某些对象是全局对象,但却不是通常的那种。这些对象实际上是特定环境的局部对象的代理。虽然很拗口,但实际上很容易理解。

想象一下处理线程的环境。一个请求传入,Web 服务器决定生成一个新线程( 或者别的什么东西,只要这个底层的对象可以胜任并发系统,而不仅仅是线程)。 当 Flask 开始它内部的请求处理时,它认定当前线程是活动的环境,并绑定当前的应用和 WSGI 环境到那个环境上(线程)。它的实现很巧妙,能保证一个应用调用另一个应用时不会出现问题。

所以,这对你来说意味着什么?除非你要做类似单元测试的东西,否则你基本上可以完全无视它。你会发现依赖于一段请求对象的代码,因没有请求对象无法正常运行。解决方案是,自行创建一个请求对象并且把它绑定到环境中。单元测试的最简单的解决方案是:用 test_request_context() 环境管理器。结合 with 声明,绑定一个测试请求,这样你才能与之交互。下面是一个例子:

from flask import request

with app.test_request_context('/hello', method='POST'):
# 现在,你可以对请求执行某些操作,直到with块结束为止,例如基本断言:
assert request.path == '/hello'
assert request.method == 'POST'

 


另一种可能是:传递整个 WSGI 环境给 request_context() 方法:

from flask import request

with app.request_context(environ):
assert request.method == 'POST'

 

 


请求对象

通过使用 method 属性可以操作当前请求方法,通过使用 form 属性处理表单数据(在 POST 或者 PUT 请求 中传输的数据)。以下是使用上述两个属性的例子:

from flask import render_template

@app.route('/login', methods=['POST', 'GET'])
def login():
error = None
if request.method == 'POST':
if valid_login(request.form['username'],
request.form['password']):
return log_the_user_in(request.form['username'])
else:
error = 'Invalid username/password'
#如果请求方法为GET或凭据无效,则执行以下代码
return render_template('login.html', error=error)

 

当 form 属性中不存在这个键时会发生什么?会引发一个 KeyError 。 如果你不像捕捉一个标准错误一样捕捉 KeyError ,那么会显示一个 HTTP 400 Bad Request 错误页面。因此,多数情况下你不必处理这个问题。
要操作 URL (如 ?key=value )中提交的参数可以使用 args 属性:
searchword = request.args.get('key', '')
用户可能会改变 URL 导致出现一个 400 请求出错页面,这样降低了用户友好度。因此, 我们推荐使用 get 或通过捕捉 KeyError 来访问 URL 参数。


文件上传

用 Flask 处理文件上传很容易,只要确保不要忘记在你的 HTML 表单中设置 enctype="multipart/form-data" 属性就可以了。否则浏览器将不会传送你的文件。
已上传的文件被储存在内存或文件系统的临时位置。你可以通过请求对象 files 属性来访问上传的文件。每个上传的文件都储存在这个 字典型属性中。这个属性基本和标准 Python file 对象一样,另外多出一个 用于把上传文件保存到服务器的文件系统中的 save() 方法。下例展示其如何运作:

from flask import request

@app.route('/upload', methods=['GET', 'POST'])
def upload_file():
if request.method == 'POST':
f = request.files['the_file']
f.save('/var/www/uploads/uploaded_file.txt')

 

如果想要知道文件上传之前其在客户端系统中的名称,可以使用 filename 属性。但是请牢记这个值是 可以伪造的,永远不要信任这个值。如果想要把客户端的文件名作为服务器上的文件名, 可以通过 Werkzeug 提供的 secure_filename() 函数:

from flask import request
from werkzeug.utils import secure_filename

@app.route('/upload', methods=['GET', 'POST'])
def upload_file():
if request.method == 'POST':
f = request.files['the_file']
f.save('/var/www/uploads/' + secure_filename(f.filename))

 

 

Cookies

要访问 cookies ,可以使用 cookies 属性。可以使用响应 对象 的 set_cookie 方法来设置 cookies 。请求对象的 cookies 属性是一个包含了客户端传输的所有 cookies 的字典。在 Flask 中,如果使用 会话 ,那么就不要直接使用 cookies ,因为 会话 比较安全一些。
读取 cookies:

from flask import request

@app.route('/')
def index():
username = request.cookies.get('username')
# use cookies.get(key) instead of cookies[key] to not get a
# KeyError if the cookie is missing.

 

储存 cookies:

from flask import make_response

@app.route('/')
def index():
resp = make_response(render_template(...))
resp.set_cookie('username', 'the username')
return resp

 

注意, cookies 设置在响应对象上。通常只是从视图函数返回字符串, Flask 会把它们 转换为响应对象。如果你想显式地转换,那么可以使用 make_response() 函数,然后再修改它。
使用 延迟的请求回调 方案可以在没有响应对象的情况下设置一个 cookie 。

 

重定向和错误

你可以用 redirect() 函数把用户重定向到其它地方。放弃请求并返回错误代码,用 abort() 函数。这里是一个它们如何使用的例子:

from flask import abort, redirect, url_for

@app.route('/')
def index():
return redirect(url_for('login'))

@app.route('/login')
def login():
abort(401)
this_is_never_executed()

 

这是一个相当无意义的例子因为用户会从主页重定向到一个不能访问的页面 (401 意味着禁止访问),但是它展示了重定向是如何工作的。

默认情况下,错误代码会显示一个黑白的错误页面。如果你要定制错误页面, 可以使用 errorhandler() 装饰器:

from flask import render_template

@app.errorhandler(404)
def page_not_found(error):
return render_template('page_not_found.html'), 404

 

注意 render_template() 调用之后的 404 。这告诉 Flask,该页的错误代码是 404 ,即没有找到。默认为 200,也就是一切正常。

 

响应

视图函数的返回值会被自动转换为一个响应对象。如果返回值是一个字符串, 它被转换为该字符串为主体的、状态码为 200 OK的 、 MIME 类型是text/html 的响应对象。Flask 把返回值转换为响应对象的逻辑是这样:
> 1. 如果返回的是一个合法的响应对象,它会从视图直接返回。
> 2. 如果返回的是一个字符串,响应对象会用字符串数据和默认参数创建。
> 3. 如果返回的是一个字典,那么调用 jsonify 创建一个响应对象。
> 4. 如果返回的是一个元组,且元组中的元素可以提供额外的信息。这样的元组必须是(response, status, headers) 的形式,且至少包含一个元素。 status 值会覆盖状态代码, headers可以是一个列表或字典,作为额外的消息标头值。
> 5. 如果上述条件均不满足, Flask 会假设返回值是一个合法的 WSGI应用程序,并转换为一个请求对象。 如果你想在视图里操纵上述步骤结果的响应对象,可以使用 make_response() 函数。

譬如你有这样一个视图:

@app.errorhandler(404)
def not_found(error):
return render_template('error.html'), 404

 


你只需要把返回值表达式传递给 make_response() ,获取结果对象并修改,然后再返回它:

@app.errorhandler(404)
def not_found(error):
resp = make_response(render_template('error.html'), 404)
resp.headers['X-Something'] = 'A value'
return resp

 

 


 JSON 格式的 API

JSON 格式的响应是常见的,用 Flask 写这样的 API 是很容易上手的。如果从视图 返回一个 dict ,那么它会被转换为一个 JSON 响应。

@app.route("/me")
def me_api():
user = get_current_user()
return {
"username": user.username,
"theme": user.theme,
"image": url_for("user_image", filename=user.image),
}

 

如果 dict 还不能满足需求,还需要创建其他类型的 JSON 格式响应,可以使用 jsonify() 函数。该函数会序列化任何支持的 JSON 数据类型。 也可以研究研究 Flask 社区扩展,以支持更复杂的应用。

@app.route("/users")
def users_api():
users = get_all_users()
return jsonify([user.to_json() for user in users])

 

 

会话

除了请求对象之外还有一种称为 session 的对象,允许你在不同请求 之间储存信息。这个对象相当于用密钥签名加密的 cookie ,即用户可以查看你的 cookie ,但是如果没有密钥就无法修改它。
使用会话之前你必须设置一个密钥。举例说明:

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

app = Flask(__name__)

#设置一个随机密钥
app.secret_key = b'_5#y2L"F4Q8z\n\xec]/'

@app.route('/')
def index():
if 'username' in session:
return 'Logged in as %s' % escape(session['username'])
return 'You are not logged in'

@app.route('/login', methods=['GET', 'POST'])
def login():
if request.method == 'POST':
session['username'] = request.form['username']
return redirect(url_for('index'))
return '''
<form method="post">
<p><input type=text name=username>
<p><input type=submit value=Login>
</form>
'''

@app.route('/logout')
def logout():
# remove the username from the session if it's there
session.pop('username', None)
return redirect(url_for('index'))

 

这里用到的 escape() 是用来转义的。如果不使用模板引擎就可以像上例 一样使用这个函数来转义。

如何生成一个好的密钥
生成随机数的关键在于一个好的随机种子,因此一个好的密钥应当有足够的随机性。 操作系统可以有多种方式基于密码随机生成器来生成随机数据。使用下面的命令 可以快捷的为 Flask.secret_key ( 或者 SECRET_KEY )生成值:

import os 
print(os.urandom(16))    #b'_5#y2L"F4Q8z\n\xec]/'

 


基于 cookie 的会话的说明: Flask 会取出会话对象中的值,把值序列化后储存到 cookie 中。在打开 cookie 的情况下,如果需要查找某个值,但是这个值在请求中 没有持续储存的话,那么不会得到一个清晰的出错信息。请检查页面响应中的 cookie 的大小是否与网络浏览器所支持的大小一致。
除了缺省的客户端会话之外,还有许多 Flask 扩展支持服务端会话。

消息闪现

一个好的应用和用户接口都有良好的反馈,否则到后来用户就会讨厌这个应用。 Flask 通过闪现系统来提供了一个易用的反馈方式。闪现系统的基本工作原理是在请求结束时 记录一个消息,提供且只提供给下一个请求使用。通常通过一个布局模板来展现闪现的 消息。
flash() 用于闪现一个消息。在模板中,使用 get_flashed_messages() 来操作消息


日志

有时候可能会遇到数据出错需要纠正的情况。例如因为用户篡改了数据或客户端代码出错 而导致一个客户端代码向服务器发送了明显错误的 HTTP 请求。多数时候在类似情况下 返回 400 Bad Request 就没事了,但也有不会返回的时候,而代码还得继续运行下去。
这时候就需要使用日志来记录这些不正常的东西了。自从 Flask 0.3 后就已经为你配置好 了一个日志工具。
以下是一些日志调用示例:

app.logger.debug('A value for debugging')
app.logger.warning('A warning occurred (%d apples)', 42)
app.logger.error('An error occurred')

 

 

部署到 Web 服务器

准备好部署你的 Flask 应用了吗?你可以立即部署到付费的或者免费的服务器来完成快速入门。

 

原文出处:https://www.cnblogs.com/Zhengnengjin/p/Eternity_Znj.html

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部