flask学习01

最新推荐文章于 2024-03-01 09:16:52 发布

Nolannk

最新推荐文章于 2024-03-01 09:16:52 发布

阅读量562

点赞数

分类专栏： flask 文章标签： flask python

本文链接：https://blog.csdn.net/joe_niu/article/details/78975350

版权

flask 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

Flask入门

WEB工作原理

C/S和B/S架构
B/S架构工作原理

客户端(浏览器) <=> WEB服务器(apache/nginx) <=> uWSGI <=> Python(Flask)

Flask框架

简介

flask是一个非常小的Python Web框架，被称为微型框架；只提供了一个强健的核心，其它功能都是通过扩展来实现。意味着可以根据项目的需求量身打造。
组成
1. 调试、路由、WSGI系统
2. 模板引擎(Jijia2，是Flask核心开发组人员开发)
安装

pip install flask

完整程序

 
   
   
    
    
     
     
     
     
      
      
       
       
        
         
          
           
           
           
           
            
             
            # 导入类库 
            
           from flask import Flask 
           # 创建实例 
           app = Flask(__name__) 
           # 视图函数 
           @app.route('/') 
           def index(): 
               return '<h1>Hello Flask !</h1>' 
           # 启动实例 
           if __name__ == '__main__': 
               app.run() 
               app.run(debug=true threaded = true )

浏览器测试：http://127.0.0.1:5000

启动参数

参数	说明
debug	是否开启调试模式，默认为False；开启后会自动加载代码
threaded	是否开启多线程，默认是不开启的
port	指定端口号
host	指定主机，设置为'0.0.0.0'之后可以通过IP访问

app.run(debug=True, threaded=True, port=5050, host='0.0.0.0')

请求与响应

变量或对象

变量/对象	上下文	说明
current_app	程序上下文	当前运行的应用实例
g	程序上下文	处理请求的临时变量，每次请求都会重置
request	请求上下文	请求对象，保存了客户端所有的HTTP的请求信息
session	请求上下文	用户会话，用于保存需要'记住'的会话信息

请求钩子函数

钩子函数	功能描述
before_first_request	第一次请求之前
before_request	每次请求之前
after_request	每次请求之后，前提是没有异常
teardown_request	每次请求之后，即使有异常发生

视图函数

无参路由

 
     
     
      
      
       
       
       
       
        
        
         
         
          
           
            
             
              
             
             
             
             
              
               
              @app.route('/test/') 
              
             def test(): 
                 return 'for test'

带参路由

 
     
     
      
      
       
       
       
       
        
        
         
         
          
           
            
             
             
             
             
              
               
              # 带参路由，参数写在<>中 
              
             @app.route('/welcome/<name>') 
             def welcome(name): 
                 return 'Hello %s !' % name 
                
             # 指定参数类型，如：string(默认)、int、float、path 
             @app.route('/user/<int:uid>') 
             def show(uid): 
                 return '%d 号，你好！' % uid 
              
             # path类型测试，(参数中的/不再作为分隔符) 
             @app.route('/path/<path:p>') 
             def path(p): 
                 return p

说明：

 
     
     
      
      
      
      
       
       
        
        
         
         
          
           
            
             
            
            
            
            
             
              
             1.路由末尾的'/'建议都加上，因为需要的时候浏览器会自动加上，输入时加不加都行 
             
            2.若需要制定参数，将参数写在<>中，视图函数参数要与路由参数一致 
            3.若需要知道参数类型，如：int/float/path等，写在参数前，用':'与参数隔开 
            4.不指定类型，参数默认是string，path其实也是字符串，只是'/'不再是分隔符

请求(request)

 
   
   
    
    
     
     
     
     
      
      
       
       
        
         
          
           
            
           
           
           
           
            
             
            @app.route('/request/') 
            
           def req(): 
               # 完整的请求URL 
               # return request.url 
               # 基本路由地址，不包括get参数 
               # return request.base_url 
               # 只有主机和端口号 
               # return request.host_url 
               # 只包含装饰器中的路由地址 
               # return request.path 
               # 请求方法类型 
               # return request.method 
               # 客户端的IP 
               # return request.remote_addr 
               # 获取GET参数 
               # return request.args['name'] 
               # 获取请求头信息 
               return request.headers['User-Agent']

响应(response)

 
   
   
    
    
     
     
     
     
      
      
       
       
        
         
          
           
            
           
           
           
           
            
             
            @app.route('/response/') 
            
           def response(): 
               # 默认状态码200 
               # return 'OK' 
               # 在响应的后面指定状态码 
               # return 'Page not found', 404 
               # 先构造一个响应（也可以指定状态码），然后返回 
               resp = make_response('这是通过函数构造的响应', 404) 
               return resp

重定向(redirect)

 
 
 
  
  
   
   
   
   
    
    
     
     
      
       
        
         
          
         
         
         
         
          
           
             @app.route('/redirect/') 
          
            def old(): 
                # return '旧的内容' 
                # 重定向，响应指定一个路由地址 
                #return redirect('/new/') 
                # 根据视图函数，反向的构造出来路由地址，传递的参数是视图函数名 
                # return url_for('req') 
                # 构造带参数的路由，直接写在后面即可 
                # return url_for('welcome', name='xiaoming') 
                return redirect(url_for('new')) 
          
            @app.route('/new/') 
            def new(): 
                return '新的内容'

终止(abort)

 
 
 
  
  
  
  
   
   
    
    
     
     
      
       
        
         
        
        
        
        
         
          
         ```python 
         
        # 终止 
        @app.route('/abort/') 
        def err(): 
            # 使用abort函数不是说控制权就归你了，它只是向系统抛出了指定的异常 
            # 异常的处理仍然会按照框架中写好方式进行 
            abort(404) 
            return 'abort测试' 
         
        # 错误页面定制 
        @app.errorhandler(404) 
        def page_not_found(e):   记得 
            return '大哥，你搞错了吧' 
        ```

会话控制(cookie/session) 会话信息是在请求头中传输的，所有的请求信息都在request中

 
 
 
  
  
  
  
   
   
    
    
     
     
      
       
        
         
        
        
        
        
         
          
          ##### 只要是加密或是解密，都需要用到密钥

 
 
 
  
  
  
  
   
   
    
    
     
     
      
       
        
         
        
        
        
        
         
          
         ```python 
         
        # 设置cookie 
        @app.route('/set_cookie/') 
        def set_cookie(): 
            resp = make_response('cookie已设置') 
            # 设置cookie，可以指定过期时间 
            expires = time.time() + 10 
            resp.set_cookie('name', 'xiaoming', expires=expires) 
            return resp 
         
        # 获取cookie 
        @app.route('/get_cookie/') 
        def get_cookie(): 
            return request.cookies.get('name') or '你是哪个二哥' 
           
        # 设置秘钥，用于加密解密的字符串，不只是用于session 
        app.config['SECRET_KEY'] = '123456' 
         
        # 设置session 
        @app.route('/set_session/') 
        def set_session(): 
            session['user'] = 'xiaoqiao' 
            return 'session已设置' 
         
        # 获取session 
        @app.route('/get_session/') 
        def get_session(): 
            return session.get('user', 'who are you ?') 
        ```

flask-script扩展

简介

简单来说，就是一个flask终端运行的解析器；因为在测试完项目后，最好不要改动任何代码，否则会带来风险，所以借助扩展库实现启动，通过传递参数完整不同的启动。可以做到开发完毕后，不修改任何的代码，就可以完成项目的部署，
安装

pip install flask-script

使用

 
   
   
    
    
     
     
     
     
      
      
       
       
        
         
          
           
            
           
           
           
           
            
             
            # 导入类库 
            
           from flask_script import Manager 
           # 创建对象 
           manager = Manager(app) 
           # 启动实例 
           if __name__ == '__main__': 
               # app.run(debug=True, threaded=True, port=5050, host='0.0.0.0') 
               manager.run()

启动：python manage.py runserver

启动参数

 
   
   
    
    
    
    
     
     
      
      
       
       
        
         
          
           
          
          
          
          
           
            
           -?,--help       # 查看启动设置帮助 
           
          -h,--host       # 指定主机 
          -p,--port       # 指定端口 
          --threaded      # 启动多线程 
          -d              # 开启调试模式 
          -r              # 代码修改后自动加载

实例：python manage.py runserver -d -r --threaded

蓝本(blueprint)

说明：

当我们的代码越来越复杂时，将所有的视图函数放在一个文件中很明显时不合适的；如果能够根据功能模块进行划分，就是将不同功能的视图函数分类存放在不同的文件中。存储在不同的文件中，蓝本就是为解决此问题而生的。

使用

 
   
   
    
    
     
     
     
     
      
      
       
       
        
         
          
           
            
           
           
           
           
            
             
            from flask import Blueprint 
            
            
           # 创建蓝本对象 
           user = Blueprint('user', __name__) 
            
           # 添加路由(视图函数) 
           @user.route('/login/') 
           def login(): 
               return '欢迎登录' 
            
           @user.route('/register/') 
           def register(): 
               return '欢迎注册' 
            
           # 新建的蓝本是无法使用的，需要注册后才可使用 
           # 在使用的地方进行注册 
           # 注册蓝本，未注册的蓝本处于休眠状态(无法使用)，可以通过url_prefix指定前缀 
           from user import user 
           app.register_blueprint(user, url_prefix='/user')

扩展

MVC

M：model，模型，数据模型

V：view，视图，负责数据展示

C：controller，控制器，负责业务逻辑的处理
MTV

M：model，模型，就是数据模型

T：templates，模板，负责数据展示

V：view function，视图函数，负责业务逻辑的处理

template 引擎 jinjia2

1.准备工作，目录结构

2渲染模板

render_template()

3.使用变量

在templat下创建一个模板文件var.html

? 模板渲染的作用是什么？

4.使用函数

在模板文件中可以使用特定的函数，对指定的变量处理后再显示

safe渲染时不转义，默认转义。

不要滥用safe，否则可能不安全

5.流程控制

从数据库中以列表的形式去拿数据，然后对它进行遍历从而来显示它

6.文件包含

{# 包含另一个文件，意思就是将被包含的文件内容黏贴到此处#}

7.宏的定义比include更方便

{#定义宏#}

说明：采用类似python中函数的形式进行定义和调用，通常我们可以把特定功能显示定义成一个宏，哪里使用哪里调用即可，避免了相同效果的重复书写

8.模板的继承

9.flask-bootstrap

在使用bootstrap时，发现重写block后原来的显示效果消失，可能是忘了调用super

定义项目基础模板

说明：一个项目中，很多页面都很相似，只有细微的差别，如果每个都定制势必会有大量的重复代码的书写。为了简化这种重复的工作，其它页面继承该基础的模板，只需要稍微定制即可。

渲染

一般来说，至少会提供分支，迭代。还有一些内置函数，如格式化等等，要看的使用引擎是啥。

Nolannk

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
flask学习01

Flask入门WEB工作原理C/S和B/S架构B/S架构工作原理客户端(浏览器) WEB服务器(apache/nginx) uWSGI Python(Flask)Flask框架简介flask是一个非常小的Python Web框架，被称为微型框架；只提供了一个强健的核心，其它功能都是通过扩展来实现。意味着可以根据项目的需求量身打造。
复制链接

扫一扫