Python Flask学习

Posted 2021-03-26 Mr-Lf

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python Flask学习相关的知识，希望对你有一定的参考价值。

一：Flask应用

　　必须在项目导入flask模块，flask类的一个对象是我们的WSGI应用程序
　　Flask构造函数使用当前模块(__name__)的名称作为参数
　　Flask类的route()函数是一个装饰器，他告诉应用程序那个URL因该调用相关的函数

from flask import Flask
app = Flask(__name__)

#相当于app.add_url_rule(\'/\',\'/\',\'hello_world\')
@app.route(\'/\') 
def hello_word():
    return "Hello World"

if __name__ == "__main__":
    app.run()
#访问页面输出Hello World

　@app.route(rule,options)
- rule参数表示与该函数的URL绑定
- options是要转发给基础RULE对象的参数列表
- 在上面的示例中,\'/\'URL与hello_world()函数绑定，因此，当在浏览器中打开web服务器的主页时，将呈现该函数的输出
　app.run(host,port,debug,options)
- host：监听的主机名，设置为0.0.0.0都可以访问
- port：监听端口值
- debug：调试，如果更改代码服务器会自动重启，提供一个有用的调试器来跟踪应用程序的错误
- options：要转发到底层的Werkzebug服务器

　二：Flask路由

@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\'])

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

from flask import Flask
app = Flask(__name__)

#下面的语句相当于app.add_url_rule(\'/\',\'hello\',\'hello_word\')用于将函数和url绑定
@app.route(\'/hello\')
def hello_word():
    return "Hello World"

　　@app.route(\'/hello\')在这里，URL:\'/hello\'规则绑定到hello_world函数，因此用户访问http://127.0.0.1:5000/hello页面将显示hello world

　　参数：

       @app.route和app.add_url_rule参数：
            rule,                       URL规则
            view_func,                  视图函数名称
            defaults=None,              默认值,当URL中无参数，函数需要参数时，使用defaults={\'k\':\'v\'}为函数提供参数
            endpoint=None,              名称，用于反向生成URL，即： url_for(\'名称\')
            methods=None,               允许的请求方式，如：["GET","POST"]
            

            strict_slashes=None,        对URL最后的 / 符号是否严格要求，
                                        如：
                                            @app.route(\'/index\',strict_slashes=False)，
                                                访问 http://www.xx.com/index/ 或 http://www.xx.com/index均可
                                            @app.route(\'/index\',strict_slashes=True)
                                                仅访问 http://www.xx.com/index 
            redirect_to=None,           重定向到指定地址
                                        如：
                                            @app.route(\'/index/<int:nid>\', redirect_to=\'/home/<nid>\')
                                            或
                                            def func(adapter, nid):
                                                return "/home/888"
                                            @app.route(\'/index/<int:nid>\', redirect_to=func)
            subdomain=None,             子域名访问
                                                from flask import Flask, views, url_for

                                                app = Flask(import_name=__name__)
                                                app.config[\'SERVER_NAME\'] = \'wupeiqi.com:5000\'


                                                @app.route("/", subdomain="admin")
                                                def static_index():
                                                    """Flask supports static subdomains
                                                    This is available at static.your-domain.tld"""
                                                    return "static.your-domain.tld"


                                                @app.route("/dynamic", subdomain="<username>")
                                                def username_index(username):
                                                    """Dynamic subdomains are also supported
                                                    Try going to user1.your-domain.tld/dynamic"""
                                                    return username + ".your-domain.tld"


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

View Code

三：Flask变量规则

　　通过向规则参数添加变量部分，可以动态构建URL，此变量部分标记为<variable-name>,他作为关键参数传递给与规则相关联的函数

　　在一下示例中，route()装饰器的规则参数包含附加到URL \'/hello\'的<name>。如果在浏览器中访问http://127.0.0.1:5000/hello/github，则\'github\'将作为参数提供给hello()函数

from flask import Flask
app = Flask(__name__)

#访问http://127.0.0.1:5000/hello/github页面返回hello welcome to github
@app.route(\'/hello/<name>\')
def hello(name):
	return "hellow welcome to %s"%name

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

除了默认字符串变量部分之外，还可以提供以下转换器构建规则

int：接受整数
float：对于浮点值
path：接受用作目录分隔符的斜杠

@app.route(\'/blog/<int:ID>\')
def show_blog(ID):
	return "blog number %d"%id

@app.route(\'/blog/<float:FID>\')
def get_fid(FID):
	return "blog floatnumber %f"%FID
访问http://127.0.0.1:5000/blog/11返回blog number 11
注意上述的<int:ID>与show_blog(ID)中的参数名要一样

四：Flask的URL唯一性

@app.route(\'/python\')
def hellopy():
	return "hello python"
@app.route(\'/flask/\')
def hellofl():
	return "hellow Flask"

访问第一个规则页面http://127.0.01:5000/python正常，但访问/python/爆404

访问第二规则页面会自动在后面加上/（后面开始没有/时），这是一个规范的url

五：Flask Url构建

　　url_for函数对于动态构建特定函数的URL非常有用，该函数接收函数的名称作为第一个参数，以及一个或多个关键字参数，每个参数对应URL的变量部分

　　redirect模块用于url跳转,url_for(url,options)指定跳转的页面和参数

from flask import redirect, url_for
@app.route(\'/admin\')
def hello_admin():
    return "hello admin"


@app.route(\'/guest/<guest>\')
def hello_guest(guest):
    return "Hello %s as Guest" % guest


@app.route(\'/user/\')
def hello_user(name):
    if name == \'admin\':
        return redirect(url_for(\'hello_admin\'))
    else:
        return redirect(url_for(\'hello_guest\', guest=name))

打开浏览器并输入URL http://localhost:5000/user/admin

浏览器中的应用程序响应是： Hello Admin
ur：http://127.0.0.1:5000/admin

在浏览器中输入以下URL http://localhost:5000/user/ppp

应用程序响应现在更改为：Hello ppp as Guest
url：http://127.0.0.1:5000/guest/guest

　　上述脚本有一个函数 hello_user(name)，它接受来自 URL 的参数的值。
　　hello_user() 函数检查接收的参数是否与 ‘admin’ 匹配。如果匹配，则使用 url_for() 将应用程序重定向到 hello_admin() 函数，否则重定向到将接收的参数作为 guest 参数传递给它的 hello_guest() 函数。

六：Flask HTTP方法

　　GET请求获取表单数据值用request.args.get(\'key\')

　　POST请求获取表单数据值用 request.form[\'key\']

from flask import redirect, url_for, request‘

@app.route(\'/login\', methods=[\'POST\', \'GET\'])
def login():
	print(request.method)
　　　　#判断请求方法
	if request.method == "POST":
　　　　　　　　　　获取以post方式提交的数据
		user = request.form[\'nm\']
　　　　　　　　　　跳转到success函数
		return redirect(url_for(\'success\', name=user))
	else:
　　　　　　　　　　#获取get提交的参数
		user = request.args.get(\'nm\')
		return redirect(url_for(\'success\', name=user))

<!DOCTYPE html>
<html>
<head>
	<title></title>
</head>
<body>
	<form action="http://127.0.0.1:5000/login" method="post">
	<p>Enter Name:</p>
	<input type="text" name="nm" />
	<input type="submit" value="submit" />
	</form>
</body>
</html>

七：Flask模板

　　术语‘web templating system（web模板系统）’指的是设计一个HTML脚本，其中可以动态插入变量数据。web模板系统包括模板引擎，某种数据源和模板处理器。

　　Flask使用jinga2模板引擎。Web模板包含用于变量和表达式（在这些情况下为Python表达式）的HTML语法散布占位符，这些是在呈现模板时替换的值

　　return render_template(\'hello.html\',name=user)返回一个hello.html的模板，模板中name变量user的值

<!DOCTYPE html>
<html>
<head>
    <title>get请求示例</title>
</head>
<body>
    {{name}}
    <form action="/deal_request" method="get">
        <input type="text" name="q" />
        <input type="submit" value="搜索" /> 
    </form>
</body>
</html>

hello.html

@app.route(\'/hello/<user>\')
def index(user):
	#返回template下的某个html文件
    return render_template(\'get.html\',name=user)
访问http://127.0.0.1:5000/hello/aaa 页面显示aaa

jinja2模板引擎使用以下分隔符从HTML转义
1. {% %} 　用于语句
2. {{ }} 用于表达式可以打印到模板输出
3. {# #} 用于未包含在模板输出中的注释
4. # ## 用于语句
在模板中使用条件语句

{% if name %}
    <h1>Hello {{name}}</h1>
{% else %}
    <h1>Hello hello.html</h1>
{% endif %}

hello.html

@app.route(\'/hello/<user>\')
def index(user):
	#返回template下的某个html文件，这里的name与hello.html中name需一致
    return render_template(\'hello.html\',name=user)

八：Flask静态文件

　　Web应用程序通常需要静态文件，例如javascript文件或支持网页显示的CSS文件。通常，配置Web服务器并为您提供这些服务，但在开发过程中，这些文件是从您的包或模块旁边的static文件夹中提供，它将在应用程序的/static中提供。

　　特殊端点\'static\'用于生成静态文件的URL。

　　在下面的示例中，在index.html中的HTML按钮的OnClick事件上调用hello.js中定义的javascript函数，该函数在Flask应用程序的“/”URL上呈现。

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

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

flask.py

<html>

   <head>
      <script type = "text/javascript" 
        #相当于src={{url_for(/static/hello.js)}}
         src = "{{ url_for(\'static\', filename = \'hello.js\') }}" ></script>
   </head>
   
   <body>
      <input type = "button" onclick = "sayHello()" value = "Say Hello" />
   </body>
   
</html>

index.html

function sayHello() {
   alert("Hello World")
}

hello.js

九：Flask Request对象

来自客户端网页的数据作为全局请求对象发送到服务器。为了处理请求数据，应该从Flask模块导入。

Request对象的重要属性如下所列：

Form - 它是一个字典对象，包含表单参数及其值的键和值对。
args - 解析查询字符串的内容，它是问号（？）之后的URL的一部分。
Cookies - 保存Cookie名称和值的字典对象。
files - 与上传文件有关的数据。
method - 当前请求方法。

十：Flask 将表单数据发送到模板

　　我们已经看到，可以在URL规则中指定http方法。触发函数接收的Form数据可以以字典对象的形式收集它并将其转发到模板以在相应的网页上呈现它。

　　在以下示例中，\'/\' URL会呈现具有表单的网页（student.html）。填入的数据会发布到触发 result()函数的\'/result\' URL。

　　results()函数收集字典对象中的request.form中存在的表单数据，并将其发送给result.html。

　　该模板动态呈现表单数据的HTML表格。

获取POST提交的数据request.form,reques.form[\'key\'],

获取GET提交的数据request.args.get()

from flask import Flask, render_template, request
app = Flask(name)

@app.route(\'/\')
def student():
   return render_template(\'student.html\')

@app.route(\'/result\',methods = [\'POST\', \'GET\'])
def result():
   if request.method == \'POST\':
    
      result = request.form
      return render_template("result.html",result = result)


if name == \'main\':
   app.run(debug = True)

flask.py

  <form action = "http://localhost:5000/result&quot; method = "POST">
     <p>Name <input type = "text" name = "Name" /></p>
     <p>Physics <input type = "text" name = "Physics" /></p>
     <p>Chemistry <input type = "text" name = "chemistry" /></p>
     <p>Maths <input type ="text" name = "Mathematics" /></p>
     <p><input type = "submit" value = "submit" /></p>
  </form>

studnet.html

  <table border = 1>
     {% for key, value in result.items() %}


    &lt;tr&gt;
       &lt;th&gt; {{ key }} &lt;/th&gt;
       &lt;td&gt; {{ value }} &lt;/td&gt;
    &lt;/tr&gt;

 {% endfor %}

  </table>

result.html

十一：Flask Cookie

在Flask中操作cookie，是通过response对象来操作，可以在response返回之前，通过response.set_cookie来设置，这个方法有以下几个参数需要注意：

　　key：设置的cookie的key。

　　value：key对应的value。

　　max_age：改cookie的过期时间，如果不设置，则浏览器关闭后就会自动过期。

　　expires：过期时间，应该是一个datetime类型。

　　domain：该cookie在哪个域名中有效。一般设置子域名，比如cms.example.com。

　　path：该cookie在哪个路径下有效。

获取：request.cookies.get(key)

设置：resp.set_cookie(key, value, max_age=整数)

删除：resp.delete_cookie(key)

from flask import Flask, request, Response, render_template

app = Flask(__name__)


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


@app.route(\'/setcookie\')
def setcookie():
    name = request.args.get(\'username\')
        #设置cookie
    resp = Response()
    resp.set_cookie(\'username\',name)
    return resp

@app.route(\'/getcookie\')
def getcookie():
    cookie=request.cookies.get(\'username\')
    return render_template(\'getcookie.html\',cookie=cookie)


if __name__ == \'__main__\':
    app.run(port=3000)

flask.py

<!DOCTYPE html>
<html>
<head>
    <title></title>
</head>
<body>
    {{cookie}}
</body>
</html>

getcookie.html

<!DOCTYPE html>
<html>
<head>
    <title></title>
</head>
<body>
    <form action="/setcookie">
        <input type="text" name="username" />
        <input type="submit" name="提交" />
    </form>
</body>
</html>>

index.html

十二：Flask Sessions　　

　　Flask中的session是通过from flask import session。然后添加值key和value进去即可。

　　client side session：Flask中的session机制是将session信息加密，然后存储在cookie中。专业术语叫做client side session。

　　server side session：存储在服务器，客户端保存的时session_id（通过cookie完成）

使用：

　　获取：session.get(key, \'默认值\')

　　 session.permanent = True

　　　session[key] = value

　　　session.pop(\'key\')

　　　session.clear()

from flask import Flask, session, redirect, url_for, escape, request
 
app = Flask(__name__)
 
@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的值
        session[\'username\'] = request.form[\'username\']
        #重定向url
        return redirect(url_for(\'index\'))
    return \'\'\'
        <form action="" 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中的某个值
    session.pop(\'username\', None)
    return redirect(url_for(\'index\'))
 
# set the secret key.  keep this really secret:
#session密钥
app.secret_key = \'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT\'

flask.py

十三：Flask重定向和错误

@app.route(\'/\')
def index():
    return render_template(\'login.html\')


@app.route(\'/login\', methods=[\'POST\', \'GET\'])
def login():
    if request.method == "POST" and request.form[\'username\'] == \'admin\':
        #重定向success页面
        return redirect(url_for(\'success\'))
    #重定向index页面
    return redirect(url_for(\'index\'))


@app.route(\'/success\')
def success():
    return "login in successful"

重定向

在上述函数中：

location参数是应该重定向响应的URL。
statuscode发送到浏览器标头，默认为302。
response参数用于实例化响应。

以下状态代码已标准化：

HTTP_300_MULTIPLE_CHOICES
HTTP_301_MOVED_PERMANENTLY
HTTP_302_FOUND
HTTP_303_SEE_OTHER
HTTP_304_NOT_MODIFIED
HTTP_305_USE_PROXY
HTTP_306_RESERVED
HTTP_307_TEMPORARY_REDIRECT

@app.route(\'/\')
def index():
    return render_template(\'login.html\')

@app.route(\'/login\',methods=[\'POST\',\'GET\'])
def login():
    if request.method==\'POST\':
        if request.form[\'username\']==\'admin\':
            return redirect(url_for(\'success\'))
        else:
            #错误请求返回状态码
            abort(401)
    return redirect(url_for(\'index\'))
@app.route(\'/success\')
def success():
    return "login in successfully"

错误请求

Flask.abort(code)

Code参数采用以下值之一：

400 - 用于错误请求
401 - 用于未身份验证的
403 - Forbidden
404 - 未不到
406 - 表示不接受
415 - 用于不支持的媒体类型
429 - 请求过多

十三：Flask消息闪现

　　一个好的基于GUI的应用程序会向用户提供有关交互的反馈。例如，桌面应用程序使用对话框或消息框，JavaScript使用警报用于类似目的。

　　在Flask Web应用程序中生成这样的信息性消息很容易，那就是flash，只显示一次数据就没有了

　　flash(v)存储值

　　get_flashed_messages()获取值

@app.route(\'/\')
def index():
        #获取消息内容
    print(get_flashed_messages())
    return render_template(\'login.html\')
@app.route(\'/set\')
def index2():
    v=request.args.get(\'p\')
        #存储值
    flash(v)
    return \'ok\'


if __name__ == \'__main__\':
    app.secret_key=\'ddwadaw\'
    app.run(port=9000)flask

flask.py

  {% with messages = get_flashed_messages() %}
     {% if messages %}

           {% for message in messages %}
               {{message}}
           {% endfor %}
 
     {% endif %}
  {% endwith %}

index.html

十四：文件上传

　　在Flask中处理文件上传非常简单。它需要一个HTML表单，其enctype属性设置为“multipart / form-data”，将文件发布到URL。URL处理程序从request.files[]对象中提取文件，并将其保存到所需的位置。每个上传的文件首先会保存在服务器上的临时位置，然后将其实际保存到它的最终位置

　　但是，建议使用secure_filename()函数获取它的安全版本。

　　f = request.files[\'file\']获取文件对象

　　f.save(secure_filename(f.filename))保存文件

<!DOCTYPE html>
<html>
<head>
    <title></title>
</head>
<body>
    <form action="/uploader" method="post" enctype="multipart/form-data">
        <input type="file" name="file" />
        <input type="submit" />

    </form>
</body>
</html>>

upload.html

@app.route(\'/upload\')
def upload():
    return render_template(\'upload.html\')


@app.route(\'/uploader\', methods=[\'GET\', \'POST\'])
def upload_file():
    if request.method == \'POST\':
        #获取文件对象
        f = request.files[\'file\']
        print(f)
        #保存文件
        f.save(secure_filename(f.filename))
        return \'python学习笔记-flask学习
 Flask 编写http接口api及接口自动化测试
 python 机器学习有用的代码片段
 学习参考《Flask Web开发：基于Python的Web应用开发实战（第2版）》中文PDF+源代码
 学习笔记：python3，代码片段（2017）
 12_关于flask中的宏