84、flask之信号和mateclass元类

本篇导航:

  • flask实例化参数
  • 信号
  • metaclass元类解析

一、flask实例化参数

instance_path和instance_relative_config是配合来用的;
这两个参数是用来找配置文件的,当用app.config.from_pyfile(‘settings.py‘)这种方式导入配置文件的时候会用到

from flask import Flask,request
app = Flask(__name__,instance_path=None, instance_relative_config=True)
app.config.from_pyfile(‘settings.py‘) # C:\Users\Administrator\PycharmProjects\s6day120\1.实例化补充
# instsnce_path:#如果配置了instance_path,就会去找instance里面的文件
# instance_relative_config: #如果设置为True,配置文件就找不到了,就会去找instance里面的settings.py
app.open_session
print(app.config.get("NNN"))
@app.route(‘/index‘) # app.route(‘/index‘)  f(index)
def index():
    print(request)
    return "xx"

if __name__ == ‘__main__‘:
    app.__call__
    app.run()

如果设置了instance_releative_config = True,就找不着settings.py文件了,解决办法:就手动创建一个instance的文件夹



二、信号(blinker)

1、flask的内置信号

Flask框架中的信号基于blinker,其主要就是让开发者可是在flask请求过程中定制一些用户行为。说白了也就是flask在列表里面

预留了几个空列表,在里面存东西。信号通过发送通知来帮助你解耦应用。简言之,信号允许某个发送者通知接收者有事情发生了;、

  

10个信号:
 2. request_started = _signals.signal(‘request-started‘)                # 请求到来前执行
 5. request_finished = _signals.signal(‘request-finished‘)              # 请求结束后执行

 3. before_render_template = _signals.signal(‘before-render-template‘)  # 模板渲染前执行
 4. template_rendered = _signals.signal(‘template-rendered‘)            # 模板渲染后执行

 执行2/3/4/5或不执行时出现异常 got_request_exception = _signals.signal(‘got-request-exception‘)    # 请求执行出现异常时执行

 6. request_tearing_down = _signals.signal(‘request-tearing-down‘)      # 请求执行完毕后自动执行(无论成功与否)
 7. appcontext_tearing_down = _signals.signal(‘appcontext-tearing-down‘)# 请求上下文执行完毕后自动执行(无论成功与否)

 1. appcontext_pushed = _signals.signal(‘appcontext-pushed‘)            # 请求app上下文push时执行

 8. appcontext_popped = _signals.signal(‘appcontext-popped‘)            # 请求上下文pop时执行

 message_flashed = _signals.signal(‘message-flashed‘)        # 调用flask在其中添加数据时,自动触发

1)问题1:

特殊的装饰器(@app.before_first_request ;@app.before_request ; @app.after_request)和信号有什么区别?

  -  触发信号是没有返回值的,写不写返回值都无所谓

  -  特殊的装饰器对返回值是有意义的,当before_request有返回值时就不会执行后续视图函数了,没有返回值的时候才会执行后续函数,而after_request必须有返回值所以特殊装饰器的功能比信号的功能强大

2)问题2:

通过信号可以做权限吗?

  - 本身是做不了的,要想做得用其他的机制配合着来使用,这样做的话会闲的很麻烦,所以我们选择中间件来做

3)问题3:

信号用于做什么呢?

  - 只做一些自定义的操作,而且没有返回值

  - 降低代码之间的耦合

2、flask内置信号源码详细

from flask import Flask,render_template,flash
app = Flask(__name__)

@app.route(‘/index‘)
def index() :
    flash()
    return render_template()

if __name__ == ‘__main__‘:
    app.__call__
    app.run()

# 1 appcontext_pushed = _signals.signal(‘appcontext-pushed‘)  # 请求上下文push时执行
# def wsgi_app(self, environ, start_response):
#     def push(self):
#         def push(self):

# 2 request_started = _signals.signal(‘request-started‘)  # 请求到来前执行
# def wsgi_app(self, environ, start_response):
#     def full_dispatch_request(self):
#         request_started.send(self)

# 3 before_render_template = _signals.signal(‘before-render-template‘)  # 模板渲染前执行
# 4 template_rendered = _signals.signal(‘template-rendered‘)  # 模板渲染后执行
# def render_template(template_name_or_list, **context):
#     def _render(template, context, app):

# 5 request_finished = _signals.signal(‘request-finished‘)  # 请求结束后执行
# def wsgi_app(self, environ, start_response):
#     def full_dispatch_request(self):
#         def finalize_request(self, rv, from_error_handler=False):
#             request_finished.send(self, response=response)

# 2\3\4\5 哪里出错哪里执行都没出错不执行
# got_request_exception = _signals.signal(‘got-request-exception‘)  # 请求执行出现异常时执行
# def wsgi_app(self, environ, start_response):
#     def handle_exception(self, e):

# 6 request_tearing_down = _signals.signal(‘request-tearing-down‘)  # 请求执行完毕后自动执行(无论成功与否)
# def wsgi_app(self, environ, start_response):
#     def auto_pop(self, exc):
#         def pop(self, exc=_sentinel):
#             def do_teardown_request(self, exc=_sentinel):

# 7 appcontext_tearing_down = _signals.signal(‘appcontext-tearing-down‘)  # 请求上下文执行完毕后自动执行(无论成功与否)
# def wsgi_app(self, environ, start_response):
#     def auto_pop(self, exc):
#         def pop(self, exc=_sentinel):
#             # AppContext
#             def pop(self, exc=_sentinel):
#                 def do_teardown_appcontext(self, exc=_sentinel):

# 8 appcontext_popped = _signals.signal(‘appcontext-popped‘)  # 请求上下文pop时执行
# def wsgi_app(self, environ, start_response):
#     def auto_pop(self, exc):
#         def pop(self, exc=_sentinel):
#             # AppContext
#             def pop(self, exc=_sentinel):

# message_flashed = _signals.signal(‘message-flashed‘)  # 调用flask在其中添加数据时,自动触发
# def flash(message, category=‘message‘):



三、metaclass元类解析

1、创建类的流程

2、什么是元类

在Python3中继承type的就是元类

元类示例

1)示例一

# 方式一
class MyType(type):
    ‘‘‘继承type的就是元类‘‘‘
    def __init__(self,*args,**kwargs):
        print("MyType创建的对象",self)   #Foo
        super(MyType,self).__init__(*args,**kwargs)

    def __call__(self, *args, **kwargs):
        obj = super(MyType,self).__call__(*args,**kwargs)
        print("类创建对象",self,obj)   #Foo

class Foo(object,metaclass=MyType): #  对象加括号会去执行__call__方法,__call__方法里面继承了type的__call__方法
                                     ,type的__call__方法里面会先执行__new__方法,再去执行__init__方法。
                                      所以,Foo就是用type创建出来的
    user = "haiyan"
    age = 18

obj = Foo()

2)示例二

# 方式二
class MyType(type):
    def __init__(self, *args, **kwargs):
        print("ssss")
        super(MyType, self).__init__(*args, **kwargs)

    def __call__(cls, *args, **kwargs):
        v = dir(cls)
        obj = super(MyType, cls).__call__(*args, **kwargs)
        return obj
#对象加括号就会去执行__call__方法
class Foo(MyType(‘Zcc‘, (object,), {})):  #MyType(‘Zcc‘, (object,), {})相当于class Zcc(object):pass,也就是创建了一个Zcc的类
    user = ‘haiyan‘
    age = 18

obj = Foo()

3)示例三

# 方式三
class MyType(type):
    def __init__(self, *args, **kwargs):
        print("ssss")
        super(MyType, self).__init__(*args, **kwargs)

    def __call__(cls, *args, **kwargs):
        v = dir(cls)
        obj = super(MyType, cls).__call__(*args, **kwargs)
        return obj
#对象加括号就会去执行__call__方法

def with_metaclass(arg,base):
    print("类对象",MyType(‘Zcc‘, (base,), {}))
    return arg(‘Zcc‘, (base,), {})  #返回一个类对象  <class ‘__main__.Zcc‘>

class Foo(with_metaclass(MyType,object)):  #MyType(‘Zcc‘, (object,), {})相当于class Zcc(object):pass,也就是创建了一个Zcc的类
    user = ‘haiyan‘
    age = 18

obj = Foo()

4)其他

class ASD(type):
    pass

qqq = ASD("qwe", (object,), {})  #用ASD这个元类创建了一个(qwe,并且继承object类的)类

# class ASD(qwe):
#     pass
obj = qqq()
# 能创建类的是元类
# 能创建对象的是类
print(obj)  #<__main__.qwe object at 0x00000000024FFBA8>
print(obj.__class__)  #<class ‘__main__.qwe‘>
print(obj.__class__.__class__)  #<class ‘__main__.ASD‘>
print(obj.__class__.__class__.__class__)  #<class ‘type‘>
print(obj.__class__.__class__.__class__.__class__)  #<class ‘type‘>

原文地址:https://www.cnblogs.com/liluning/p/8297295.html

时间: 2024-10-08 12:35:33

84、flask之信号和mateclass元类的相关文章

QObject提供了QMetaObject元类信息(相当于RTTI和反射),信号与连接,父子关系,调试信息,属性,事件,继承关系,窗口类型,线程属性,时间器,对象名称,国际化

元类信息(相当于RTTI和反射),信号与连接,父子关系,调试信息,属性,事件,继承关系,窗口类型,线程属性,时间器,对象名称,国际化其中元类又提供了:classInfo,className,构造函数,多重祖先元类,method, property, Enumerator, Signal, Slot等等 http://doc.qt.io/qt-5/qobject.html http://doc.qt.io/qt-5/qmetaobject.html 我感觉Qt的出现,除了提供GUI以外,主要就是提

1.元类介绍/2.自定义元类控制类的行为/3.控制类的实例化行为/4.控制类的实例化行为的应用

1.元类介绍 1.储备知识exec()参数1;字符串形式得命令参数2.全局作用域(字典形式),如果不指定默认就使用globals()参数3.局部作用域(字典形式),如果不指定默认就使用locals() 2.python 一切皆对象 ,对象可以怎么用? 2.1. 都可以被引用 x=obj 2.2. 都可以当作函数得参数传入 2.3. 都可以当作函数得返回值 2.4. 都可以当作容器类得元素 li=[func,time] # 类也是对象,Foo=type() 类是属于type() 类 3.什么叫元类

Python元类

学懂元类,首先要知道两句话: 道生一,一生二,二生三.三生万物 我是谁?我从哪里来?我要到那里去? 在Python的世界里,拥有一个永恒的道:type,如此广袤无垠的Python生态圈,都是由type产生出来的. 道生一,一生二,二生三,三生万物. 道:即就是type 一:即是metaclass 二:即是class(或者实例生成器) 三:即是instance 1 关于类 道和一,是我们今天讨论的命题,而二.三.和万物,则是我们常常使用的类.实例.属性和方法,用hello world来举例: 1

元类,异常处理

什么是元类:# 源自一句话:在python中,一切皆对象,而对象都是由类实例化得到的.# 内置的元类是type.# # 1. 调用元类---->自定义的类# 2. 调用自定义的类---->自定义的对象 自定义类:# class关键字创建自定义类的底层的工作原理,分为四步 例如:class OldboyTeacher(object,):# 1. 先拿到类名:'OldboyTeacher'# 2. 再拿到类的基类们:(object,)# 3. 然后拿到类的名称空间???(执行类体代码,将产生的名字

面向对象中关于元类的介绍与异常处理

一.异常处理 1. 什么是异常处理     异常是错误发生的信号,一旦程序出错就会产生一个异常,如果该异常     没有被应用程序处理,那么该异常就会抛出来,程序的执行也随之终止 异常包含三个部分:         1. traceback异常的追踪信息         2. 异常的类型         3. 异常的信息 错误分为两大类:         1. 语法上的错误:在程序运行前就应该立即修正         2. 逻辑上的错误 2. 为何要异常处理 避免程序因为异常而崩溃,所以在应用程

29 异常处理与元类

异常处理 1. 什么是异常处理 异常是错误发生的信号,一旦程序出错就会产生一个异常,如果该异常没有被应用程序处理,那么该异常就会抛出来,程序的执行也随之终止 异常包含三个部分: 1. traceback异常的追踪信息2. 异常的类型3. 异常的信息 错误分为两大类: 1. 语法上的错误:在程序运行前就应该立即修正2. 逻辑上的错误 2. 为何要异常处理 避免程序因为异常而崩溃,所以在应用程序中应该对异常进行处理,从而增强程序的健壮性 3. 如何异常处理 try: f=open('a.txt','

python中通过元类(TYPE)简单实现对象关系映射(ORM)

ORM是创建一个实例对象,用创建他的类名当做数据表名,用创建他的类属性对应数据表的字段,不需要在自己写复杂的sql语句,而是通过对实例对象的操作时,能让代码自动帮我们整理为对应的sql语句. class User(父类): uid = ("uid", "int unsigned") name = ("username", "varchar(20)") password = ("password", &quo

7.28 多态 反射 元类

多态 1.什么是多态 多态指的是一类事物有多种形态 例如: 动物有多种形态: 人,狗,猪 在程序中多态指的是,不同对象可以响应相同方法,并可以有自己不同的实现方式 2.为什么需要多态 案例分析: import abc class Animal(metaclass=abc.ABCMeta): #同一类事物:动物 @abc.abstractmethod def talk(self): pass class People(Animal): #动物的形态之一:人 def talk(self): prin

深刻理解Python中的元类(metaclass)

译注:这是一篇在Stack overflow上很热的帖子.提问者自称已经掌握了有关Python OOP编程中的各种概念,但始终觉得元类(metaclass)难以理解.他知道这肯定和自省有关,但仍然觉得不太明白,希望大家可以给出一些实际的例子和代码片段以帮助理解,以及在什么情况下需要进行元编程.于是e-satis同学给出了神一般的回复,该回复获得了985点的赞同点数,更有人评论说这段回复应该加入到Python的官方文档中去.而e-satis同学本人在Stack Overflow中的声望积分也高达6