Flask基础

时间  2019-11-09
标签 flask 基础 栏目 Python 繁體版
原文   原文链接

一，Flask初始html

Python三大Web框架对比前端

1.Django 主要特色是大而全,集成了不少组件,例如: Models Admin Form 等等, 无论你用获得用不到,反正它全都有,属于全能型框架web

2.Tornado 主要特色是原生异步非阻塞,在IO密集型应用和多任务处理上占据绝对性的优点,属于专一型框架json

3.Flask 主要特色小而轻,原生组件几乎为0, 三方提供的组件请参考Django 很是全面,属于短小精悍型框架flask

Django 一般用于大型Web应用因为内置组件足够强大因此使用Django开发能够一鼓作气后端

Tornado 一般用于API后端应用,游戏服务后台,其内部实现的异步非阻塞真是稳得一批浏览器

Flask 一般应用于小型应用和快速构建应用,其强大的三方库,足以支撑一个大型的Web应用安全

Django 优势是大而全,缺点也就暴露出来了,这么多的资源一次性所有加载,确定会形成一部分的资源浪费服务器

Tornado 优势是异步,缺点是干净,连个Session都不支持websocket

Flask 优势是精悍简单,缺点是你不会!哈哈哈哈哈哈!

Flask:
1.轻，短小精悍
2.快，三行代码开启服务
缺点：
1.组件大部分来源于三方，flask-admin，flask-session
2.flask大版本更新，组件更新速度慢
    
Django:
1.大而全，admin，models，Form，中间件，session
2.一个框架解决全部问题
缺点：
1.一旦启动，全部资源所有加载，用不到的，浪费了
2.太大了，结构复杂
3.全部的组件，所有由Django自身控制

Tornado：
1.原生websocket
2.异步io
3.非阻塞
缺点：
三方及原生组件几乎为0

 

二. Flask 的安装与HelloWorld

Flask的安装特别难,可是以一个多年奋斗在程序界的我,确定会找出一个最简单的方法教大家,具体操做以下:

pip install Flask

别问我还有没有复杂的方法,没有!

 

Flask安装完成了,下面使用Flask走一遍仪式:

三行代码

from flask import Flask app = Flask(__name__) app.run()

默认端口是5000，由于没有定义路由，因此报404。可是服务是起来了！

 

六行代码

from flask import Flask # 导入Flask类 app = Flask(__name__) # 实例化Flask对象app @app.route("/")　　　　# app中的route装饰器 def index():　　　　　　# 视图函数 return "HelloWorld!!"　　# 返回响应体
# 监听地址为0.0.0.0,表示服务器的全部网卡 # 5000是监听端口 # debug=True表示启动debug模式。当代码有改动时,Flask会自动加载,无序重启！ app.run()　　# 启动Flask服务

注意：默认的debug模式是关闭的。若有有代码改动，须要重启flask才行生效！

可是开启debug模式，代码一有改动，会马上加载，无需重启！

 

还有一点，app = Flask(__name__)。这里面的__name__表示 标识模块的名字的一个系统变量

还能够是 app= Flask("fdsafejisi")，这样运行也没有问题。那么为何要用__name__呢？

后面学习到蓝图会用到！

 

启动了Flask,获得了返回值,打印在页面上

 

2、Response三剑客

HTTPResponse

@app.route("/")  # app中的route装饰器
def index():  # 视图函数
    return "HelloWorld!!"  # HttpResponse

在Flask 中的HttpResponse 在咱们看来其实就是直接返回字符串

Redirect

from flask import Flask  # 导入Flask类
from flask import redirect  # 导入flask中的redirect

app = Flask(__name__)


# app中的route装饰器,用来指定视图函数的URL地址
@app.route("/redi")
def redi():  # 视图函数
    return redirect("/")  # redirect跳转至"/"


@app.route("/")
def index():  # 视图函数
    return "hello"


if __name__ == '__main__':
    app.run("0.0.0.0", 5000, debug=True)
View Code

每当访问"/redi"这个地址的时候,视图函数redi会触发redirect("/") 跳转到url地址:  "/" 并会触发"/"对应的视图函数index()

render (render_template)

from flask import Flask  # 导入Flask类
from flask import render_template  # 导入flask中的render_template

app = Flask(__name__)


@app.route("/home")
def home():  # 视图函数
    # 渲染html模板,返回html页面
    return render_template("home.html")


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

在当前py文件目录中建立templates，在此目录下建立文件home.html

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

目录结果以下：

./
├── demo.py
└── templates
    └── home.html

为何要必定要建立templates文件夹呢？叫abc，行不行呢？不行！

看这一行代码

app = Flask(__name__)

使用Ctrl+鼠标左键，点击Falsk，查看源码

def __init__( self, import_name, static_url_path=None, static_folder='static', static_host=None, host_matching=False, subdomain_matching=False, template_folder='templates', instance_path=None, instance_relative_config=False, root_path=None ):

看到template_folder变量没有？文件夹必须叫这个名字！

 

3、Request(全局变量,独有机制--Flask请求上下文管理)

每一个框架中都有处理请求的机制(request),可是每一个框架的处理方式和机制是不一样的

为了了解Flask的request中都有什么东西,首先咱们要写一个先后端的交互

基于HTML + Flask 写一段先后端的交互

先写一段儿HTML form表单中提交方式是post  action地址是 /req

 

在templates目录建立文件login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>欢迎登录</h1>
<form action="/req" method="post">
    <p>
        <input type="text" name="user" placeholder="请输入用户名">
    </p>
    <p>
        <input type="password" name="pwd" placeholder="请输入密码">
    </p>
    <input type="submit" value="提交">
</form>
</body>
</html>
登陆界面

写好一个标准 form 表单,一点提交,搜就向后端提交一个POST请求过去了

后端的接收方式就 666 了

首先要从 flask 包中导入 request 模块 , 至于为何要导入 request 呢? 这里不作解释,暂时你就知道 request 若是要用,须要导入

from flask import Flask  # 导入Flask类
from flask import render_template  # 导入flask中的render_template
from flask import request  # 导入flask中的request
 app = Flask(__name__) @app.route("/login") def login(): return render_template("login.html") @app.route("/req",methods=["POST"])  # 只容许POST
def home():  # 视图函数
    print(request)  # request对象
    print(request.method)  # POST看来可使用这种方式来验证请求方式
    # ImmutableMultiDict([('user', 'xiao'), ('pwd', '123')])
    print(request.form) # ImmutableMultiDict 它看起来像是Dict,使用字典方式取值
    print(request.form["user"])  # xiao
    print(request.form.get("pwd"))  # 123
    # 字典迭代器对象,keys表示获取全部值
    print(request.form.keys()) # 既然是迭代器,就可使用for循环了
    for i in request.form.keys(): print(i) return "ok"


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

解释一个 @app.route("/req",methods=["POST"]) :

methods=["POST"]  表明这个url地址只容许 POST 请求,是个列表也就是意味着能够容许多重请求方式,例如GET之类的

 

储存数据：

1.request.args

　　request.args.get("name") url中取值 　　print(request.args)  # ImmutableMultiDict([('id', '1'), ('age', '20')])
　　print(request.args["id"])  # 1
　　print(request.args.get("age"))  # 20
　　print(list(request.args.keys()))  # ['id', 'age']
　　print(list(request.args.values()))  # ['1', '20']　　
　　req_dict = dict(request.args)  # {'id': ['1'], 'age': ['20']}
　　print(req_dict)

2.request.form

Form表单中传递过来的值 使用 request.form 中拿到
print(request.form)  # ImmutableMultiDict([('user', 'xiao'), ('pwd', '123')]) # ImmutableMultiDict 它看起来像是的Dict 就用Dict的方法取值试一下吧 print(request.form["user"]) # xiao print(request.form.get("pwd")) # 123 # 看来所有才对了, ImmutableMultiDict 彷佛就是个字典,再来玩一玩它 print(list(request.form.keys())) # ['user', 'pwd'] 看来是又才对了 #若是以上全部的方法你都以为用的不爽的话 req_dict = dict(request.form) print(req_dict) # 若是你以为用字典更爽的话,也能够转成字典操做(这里有坑)

3.request.json

若是在请求中写入了 "application/json" 使用 request.json 则返回json解析数据, 不然返回 None

4.request.data 

若是处理不了的就变成字符串儿存在data里面 

5..request.values（禁用）

只要是个参数我都要

 

 属性数据：

1.request.method  ：   验证请求方式

2.request.url    request.path

 

　　 # 获取当前的url路径
    print(request.path)  # /req
    # 当前url路径的上一级路径
    print(request.script_root)  #     # 当前url的所有路径
    print(request.url)  # http://127.0.0.1:5000/req
    # 当前url的路径的上一级所有路径
    print(request.url_root)  # http://127.0.0.1:5000/

 

3.request.files :  给我一个文件我帮你保管

若是遇到文件上传的话,request.files 里面存的是你上传的文件,可是 Flask 在这个文件的操做中加了必定的封装,让操做变得极为简单

print(request.files)  # ImmutableMultiDict([('file', <FileStorage: 'DragonFire.txt' ('text/plain')>)])
print(request.files["file"])  # <FileStorage: 'DragonFire.txt' ('text/plain')>
my_file = request.files["file"] my_file.save("OldBoyEDU.txt")  # 保存文件,里面能够写完整路径+文件名

 注意：前端页面必须设置enctype="multipart/form-data"，不然提交时，会报错

 <form action="/req" method="post" enctype="multipart/form-data">

4.request.headers  : 用来获取本次请求的请求头

5.request.cookies : 存在浏览器端的字符串儿也会一块儿带过来

前提是你要开启浏览器的 cookies

request.cookies 是将cookies中信息读取出来

*form表单的坑

若是url和form中的Key重名的话,form中的同名的key中value会被url中的value覆盖
<form action="/req?id=1&user=20" method="post">
    <p>
        <input type="text" name="user" placeholder="请输入用户名">
    </p>
    <p>
        <input type="password" name="pwd" placeholder="请输入密码">
    </p>
    <input type="submit" value="提交">
</form>
若是url和form中的Key重名的话,form中的同名的key中value会被url中的value覆

 

4、模板语言 Jinja2

Flask中默认的模板语言是Jinja2

Jinja2模板语言中的 for

{% for foo in g %} {{ foo }} {% endfor %}

Jinja2模板语言中的 if

{% if g %}

{% elif g %}
    
{% else %}
    
{% endif %}

Jinja2 的高阶用法

<input type='text' name='user' value='xiao'>

safe  显示渲染后的效果

后端代码：

from flask import Flask  # 导入Flask类
from flask import render_template  # 导入flask中的render_template

app = Flask(__name__)

@app.route("/")
def index():
    tag = "<input type='text' name='user' value='xiao'>"
    return render_template("index.html",tag=tag)

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

前端代码：

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

    {{ tag|safe }}

</body>
</html>

或者

后端代码：

from flask import Flask  # 导入Flask类
from flask import render_template  # 导入flask中的render_template
from flask import Markup  # 导入 flask 中的 Markup 模块

app = Flask(__name__)

@app.route("/")
def index():
    tag = "<input type='text' name='user' value='xiao'>"
    # Markup帮助我们在HTML的标签上作了一层封装,让Jinja2模板语言知道这是一个安全的HTML标签
    markup_tag = Markup(tag)
    # <input type='text' name='user' value='DragonFire'> <class 'markupsafe.Markup'>
    print(markup_tag,type(markup_tag))

    return render_template("index.html", tag=markup_tag)

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

前端代码：

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

    {{ tag }}

</body>
</html>

执行Python函数

模板中执行函数，首先在文件中定义一个函数

后端代码：

from flask import Flask  # 导入Flask类
from flask import render_template  # 导入flask中的render_template

app = Flask(__name__)

#定义一个函数,把它传递给前端
def a_b_sum(a,b):
    return a+b

@app.route("/")
def index():
    return render_template("index.html", tag=a_b_sum)

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

前端代码：

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

    {{ tag }}
    <br>
    {#传入2个参数#}
    {{ tag(99,1) }}

</body>
</html>

还能够定义全局函数,无需后端传递给前端,Jinja2直接就能够执行的函数

后端代码：

from flask import Flask  # 导入Flask类
from flask import render_template  # 导入flask中的render_template

app = Flask(__name__)

@app.template_global()  # 定义全局模板函数
def a_b_sum(a, b):
    return a + b


@app.template_filter()  # 定义全局模板函数
def a_b_c_sum(a, b, c):
    return a + b + c


@app.route("/")
def index():
    return render_template("index.html", tag="")

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

前端代码：

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

    {#函数#}
    {{ a_b_sum(99,1) }}
    <br>
    {#过滤器#}
    {{ 1 | a_b_c_sum(197,2) }}

</body>
</html>

两个函数的调用方式不太同样

尤为是@app.template_filter() 它的调用方式比较特别,这是两个Flask中的特殊装饰器

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程