精华内容
下载资源
问答
  • Meta:Python元编程-源码

    2021-05-10 12:42:05
    一个纯Python模块,其中包含一个用于处理和分析python抽象语法树和字节码的框架。 例子 这显示了如何将python源代码带到代码对象并从python内部再次返回: import meta , ast source = ''' a = 1 b = 2 c = (a ** b...
  • Python MetaClass.pdf

    2021-08-06 15:38:06
    Python MetaClass.pdf
  • 首先,在认识metaclass之前,你需要认识下python中的class。python中class的奇怪特性借鉴了smalltalk语言。大多数语言中,classes仅仅是用于描述怎样创建一个对象的代码端。在某种程度上说,python中的class也是这样...
  • Python-Metar Python-metar是一个Python软件包,用于解释METAR和SPECI编码的天气报告。 METAR和SPECI是编码的航空天气报告。 官方编码方案在世界气象组织(WMO)编码手册A卷(I.1卷)(WMO-306 IiA)中进行了规定...
  • python metaclass

    千次阅读 2011-09-05 13:56:30
    学习python这么久对pythonmetaclass还是一知半解,网上找了找,发现stackoverflow太强大了:  http://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python 这个回

    学习python这么久对python的metaclass还是一知半解,网上找了找,发现stackoverflow太强大了: 
    http://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python
    这个回答很详细,太厉害了,这里自己总结一下,免的忘记。

    1. 类也是对象(class are object), 类在内存中也占有一段空间,所以

    class Foo(object):pass
    id(Foo) #有值
    Foo.bar = 'bar'  #给类添加一个属性

    2. 可以动态的创建类
    type(class_name, class_parents, class_dict), 比如
    def echo_bar(self): print self.bar
    Foo = type('Foo', (object, ), {'bar':'bar', 'echo_bar', echo_bar})

    3. metaclass是创建类的'stuff',一般也可以理解成对象是类创建的, 类是metaclass创建的。
    type is the metaclass Python uses to create all classes behind the scenes.
    Everything, and I mean everything, is an object in Python. That includes ints, strings, functions and classes. All of them are objects. And all of them have been created from a class.
    You can call it a 'class factory' if you wish.
    4. __metaclass__属性
    可以给类添加__metaclass__属性,在创建类时, python会查找(在自身,子类,模块中)是否定义了__metaclass__,有则用之来创建类, 否则用type来创建类
    所以可以通过定义__metaclass__来改变类的创建方式,__metaclass__可以是任何可执行的东西,所以不一定需要是类。 这里就直接引用他的例子了。

    # the metaclass will automatically get passed the same argument
    # that you usually pass to `type`
    def upper_attr(future_class_name, future_class_parents, future_class_attr):
      """
        Return a class object, with the list of its attribute turned 
        into uppercase.
      """
    
      # pick up any attribute that doesn't start with '__'
      attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__'))
      # turn them into uppercase
      uppercase_attr = dict((name.upper(), value) for name, value in attrs)
    
      # let `type` do the class creation
      return type(future_class_name, future_class_parents, uppercase_attr)
    
    __metaclass__ = upper_attr # this will affect all classes in the module
    
    class Foo(object): 
      # we can define __metaclass__ here instead to affect only this class
      bar = 'bip'
    
    print hasattr(Foo, 'bar')
    # Out: False
    print hasattr(Foo, 'BAR')
    # Out: True
    
    f = Foo()
    print f.BAR
    # Out: 'bip'
    

    # remember that `type` is actually a class like `str` and `int`
    # so you can inherit from it
    class UpperAttrMetaclass(type): 
        # __new__ is the method called before __init__
        # it's the method that creates the object and returns it
        # while __init__ just initializes the object passed as parameter
        # you rarely use __new__, except when you want to control how the object
        # is created.
        # here the created object is the class, and we want to customize it
        # so we override __new__
        # you can do some stuff in __init__ too if you wish
        # some advanced use involves overriding __call__ as well, but we won't
        # see this
        def __new__(upperattr_metaclass, future_class_name, 
                    future_class_parents, future_class_attr):
    
            attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__'))
            uppercase_attr = dict((name.upper(), value) for name, value in attrs)
    
            return type(future_class_name, future_class_parents, uppercase_attr)

    class UpperAttrMetaclass(type): 
    
        def __new__(upperattr_metaclass, future_class_name, 
                    future_class_parents, future_class_attr):
    
            attrs = ((name, value) for name, value in future_class_attr.items() if not name.startswith('__'))
            uppercase_attr = dict((name.upper(), value) for name, value in attrs)
    
            # reuse the type.__new__ method
            # this is basic OOP, nothing magic in there
            return type.__new__(upperattr_metaclass, future_class_name, 
                                future_class_parents, uppercase_attr)


    Django中Model使用__metaclass__的例子

    class Model(object):
         __metaclass__ = ModelBase
         _deferred = False
    .....
    






    展开全文
  • CodeMetaPy的目标是生成JSON-LD文件codemeta.json,其中包含描述Python软件包的软件元数据。 有关用于定义软件元数据的CodeMeta项目的更多常规信息,请参见 。 特别是,新用户可能希望从《用户指南》开始,而那些想...
  • python metaclass应用.pdf

    2021-08-10 16:39:52
    python metaclass应用.pdf
  • Python中安装meta模块

    2021-01-14 08:35:54
    Python中安装meta模块用于meta分析 搜索PythonMeta,官网有大牛上传的软件包。 如何安装pip以及,如何使用pip安装第三方软件包:Python pip安装与使用 菜鸟教程 cmd输入安装指令 安装成功~好耶

    在Python中安装meta模块用于meta分析

    搜索PythonMeta,官网有大牛上传的软件包。
    作者信息
    下载whl格式
    如何安装pip以及,如何使用pip安装第三方软件包:Python pip安装与使用 菜鸟教程

    cmd输入安装指令自动下载并安装
    安装成功~好耶

    展开全文
  • 本文实例讲述了pythonmetaclass原理与用法。分享给大家供大家参考,具体如下: 什么是 metaclass. metaclass (元类)就是用来创建类的类。在前面一篇文章《python动态创建类》里我们提到过,可以用如下的一个观点来...
  • 理解python metaclass

    万次阅读 多人点赞 2018-06-12 16:35:32
    原文地址:...metaclass在python中永远是一个争议的话题。许多开发者避免使用它们,而我认为这很大程度上是有任意的工作流程和查找规则引起的,它们没能很好的解释。同时...

    原文地址:https://blog.ionelmc.ro/2015/02/09/understanding-python-metaclasses/

    现存的文章没有说明白metaclass是如何在Python中工作的,所以在这里我给出我的理解。metaclass在python中永远是一个争议的话题。许多开发者避免使用它们,而我认为这很大程度上是有任意的工作流程和查找规则引起的,它们没能很好的解释。同时,对于metaclass,总有几个你需要理解关键概念。

    如果你没听说过metaclass,那么他们为减少样板和更好的API提供了很多有趣的机会。为了使metaclass尽可能简单,我将假设创造的类型将读取他。这意味着我们将跳过整个难题——为了A而不是B使用metaclass。

    这篇文章使用Python3,如果中间有特殊的python2需要注意,将会在脚注用小字说明(脚注我没翻译,看原文吧)。

    快速的概述

    在我们深入细节之前,一个概括性的说明是必不可少的。

    class是一个对象,跟其他普通的对象一样,是某个东西的实例:比如metaclass。默认的metaclass是type。不幸的是,对于向后的兼容性,type有点乱:他同样可以用作一个function来返回一个对象的class。

    class Foobar:
         pass
    print(type(Foobar))
    foo = Foobar()
    print(type(foo))

    返回值

    <class 'type'>
    <class '__main__.Foobar'>

    如果你熟悉isinstance函数,你会知道这些:

    print(isinstance(foo, Foobar))
    # True
    print(isinstance(Foobar, type))
    # True

    foo是Foobar的实例,Foobar是type的实例,也就是下图,class是metaclass的实例。

    接着让我继续来建造class。

    简单的metaclass使用

    我们能使用type直接的创建class,并不需要其他的class声明:

    MyClass = type('MyClass', (), {})
    print(MyClass)

    返回值

    <class '__main__.MyClass'>

    class type(name, bases, dict)

    使用1个参数,返回对象的类型。就像object.__class__。内置函数isinstance()被用来测试对象的类型,因为他会考虑到子类。

    用3个参数,返回一个新类型对象。本质上,这是类声明的一种动态形式。

    参数name是一个字符串,表示类名称,并记录为__name__属性;

    参数bases是一个元组,一个个记下基础类,并记录为__bases__属性,

    参数dict是一个字典,包含类本体的命名空间并被赋值到标准字典。并记录为__dict__属性。

    举个例子下面两个声明创建了相同类型的对象:

    class X:
        a = 1
    X = type('X', (object,), dict(a=1))

    在3.6版发生改变,type的子类不能重写type.__new__ ,不久将不再使用单参数的样式获取对象的类型。


    class声明并不仅仅是语法糖,他还会做一些额外的事情,比如设置合适的__qualname__和__doc__属性或者调用__prepare__。

    我们可以自定义一个metaclass,并使用它:

    class Meta(type):
        pass
    class Complex(metaclass=Meta):
        pass
    class Complex2(Meta):
        pass
    print(type(Complex))
    print(Complex)
    print(type(Complex2))
    print(type(type))
    print(Complex2)

    返回值

    <class '__main__.Meta'>
    <class '__main__.Complex'>
    <class 'type'>
    <class 'type'>
    <class '__main__.Complex2'>

    现在我们大概了解了我们将要处理的事情。。。

    我这里加了一个Complex2()类,为了说明这里是设置metaclass而不是继承。

    魔术方法

    魔术方法是python的一个特点:他们允许程序员重写变量操作符号和对象的行为。调用者需要这样来重写:

    class Funky:
    	def __call__(self):
    		print("Look at me, I work like a function!")
    f = Funky()
    f()

    返回值就是print的那句话了。像function一样工作。

    metaclass依赖一些魔术方法,所以多了解一些是非常有用的。

    slots(定位,跟踪)

    当你在class中定义一个魔术方法的时候,function除了__dict__中的条目之外,在整个类结构中,作为一个描述着这个class的指针一样结束。这个结构对于每一个魔术方法有一个字段。出于一些原因这些字段被称为type slots。

    现在,这里有另一个特征,通过__slots__属性执行,一个拥有__slots__的class创造的实例不包含__dict__(这将使用更少的内存)。副作用是实例不能出现未在__slots__中指定的字段:如果你尝试设置一个不存在于__slots__中的字段,那么将会获得一个报错。

    本文提及的单独的slots都是type slots不是__slots__。(类里的魔术方法

    class Foobar:
    	"""
    	 A class that only allows these attributes: "a", "b" or "c"
    	"""
    	__slots__ = "a", "b", "c"
    
    foo = Foobar()
    foo.a = 1
    # foo.x = 2

    样例中去掉最后一行注释,foo.x = 2会报错。

    对象属性查找

    这里很容易出错,因为和python2的就样式相比有很多细小的不同。

    假设我们有一个类和一个实例,并且实例是类的实例,获取(评估:原文用evaluate)实例的footbar大概相当于下面这样:

    为Class.__getattribute__ (tp_getattro)调用type slot。默认会执行下面:
    	Class.__dict__是否有一个foobar元素是一个数据描述符?
    		如果有,返回Class.__dict__['foobar'].__get__(instance, Class)
    	instance.__dict__是否有一个foobar元素?
    		如果有,返回instance.__dict__['foobar']
    	Class.__dict__是否有一个foobar元素但并不是数据描述符?
    		如果有,返回Class.__dict__['foobar'].__get__(instance, klass)
    	Class.__dict__是否有一个foobar元素?
    		如果有,返回Class.__dict__['foobar']
    如果属性还没找到,如果有Class.__getattr__,就会调用Class.__getattr__('foobar')

    如果你还不清楚,请看下图:


    为了避免点号'.'带来的混淆,图里用了冒号':'。

    类属性查找

    当你查找(评估:原文用evaluate)一些类似于class的foobar,由于class需要能够支持classmathod和staticmethod装饰器,所以和查找实例的foobar有一点不同。

    假设类是metaclass的实例,查找(评估:原文用evaluate)class的foobar相当于下面这样:

    为Metaclass.__getattribute__ (tp_getattro)调用type slot。默认会执行下面:
    	Metaclass.__dict__是否有一个foobar元素是一个数据描述符?
    		如果有,返回Metaclass.__dict__['foobar'].__get__(Class, Metaclass)
    	Class.__dict__是否有一个foobar元素是一个描述符(任何种类)?
    		如果有,返回Class.__dict__['foobar'].__get__(None, Class)
    	Class.__dict__是否有一个foobar元素?
    		如果有,返回Class.__dict__['foobar']
    	Metaclass.__dict__是否有一个foobar元素不是一个数据描述符?
    		如果有,返回Metaclass.__dict__['foobar'].__get__(Class, Metaclass)
    	Metaclass.__dict__是否有一个foobar元素?
    		如果有,返回Metaclass.__dict__['foobar']
    如果属性还没找到,并且有Metaclass.__getattr__,就会调用Metaclass.__getattr__('foobar')

    整个流程如下图:


    魔术方法查看

    对于魔术方法来说,查找已经完成了,直接在大结构上用slots。

    对象的类是否有关于魔术方法的slot(大概就像c语言中object->ob_type->tp_<魔术方法>)?如果有,就使用,如果是NULL,那么选项不被支持。
    在C中:
    object->ob_type是对象的类
    ob_type->tp_<魔术方法>是type slot

    这看起来很简单,然而type slots在你function的外包装上到处都是,所以描述符就按照预期工作:

    class Magic:
    	@property
    	def __repr__(self):
    		def inner():
    			return "It works!"
    		return inner
    
    print(repr(Magic()))

    这是否意味着这些地方并没有遵守规则,并且用不同的方式找到了slot?很遗憾是的,继续。。。

    __new__方法

    __new__方法是class和metaclass之间最容易混淆的方法之一。他有一些非常特别的约定。

    当__init__只是一个初始化装置(当__init__被调用的时候,实例已经被创建了)的时候,__new__方法是一个创造者(因为他返回新的实例)。

    假设有下面的class:

    class Foobar:
        def __new__(cls):
            return super().__new__(cls)

    现在你重新调用之前的部分,你将期待__new__将会在metaclass上查找,但是很遗憾,对于这种情况他并不是很有用,所以他查找的很安静。

    当Foobar类希望这个魔术方法在他本身查找,而不是像其他的魔术方法在父级。这一点非常重要,因为class和metaclass都能定义方法:

    Foobar.__new__被用来重建Foobar实例

    type.__new__被用来创建Foobar类(例子中的type的实例)

    __prepare__方法

    这个方法被第要用在class本体被执行之前并且他必须返回一个类似字典的对象,这个对象被用来作为class本体的所有代码的本地命名空间。(在类中namespace参数可以取到__prepare__的返回值)在python3的时候加入。

    如果你的__prepare__返回一个对象x:

    class Class(metaclass=Meta):
        a = 1
        b = 2
        c = 3

    将对x做如下改变:

    x['a'] = 1
    x['b'] = 2
    x['c'] = 3

    这个x对象需要看起来像个字典。注意这个x对象最终将成为Metaclass.__new__的参数,如果他不是一个dict的实例,你需要在调用super().__new__之前转换它。

    我们用__prepare__返回一个对象,这个对象只能执行__getitem__和__setitem__:

    class DictLike:
        def __init__(self):
            self.data = {}
        def __getitem__(self, name):
            print('__getitem__(%r)' % name)
            return self.data[name]
        def __setitem__(self, name, value):
            print('__setitem__(%r, %r)' % (name, value))
            self.data[name] = value
    class CustomNamespaceMeta(type):
        def __prepare__(name, bases):
            return DictLike()

    然而,__new__将会抱怨:

    class Foobar(metaclass=CustomNamespaceMeta):
    	a = 1
    	b = 2
    __getitem__('__name__')
    __setitem__('__module__', '__main__')
    __setitem__('__qualname__', 'Foobar')
    __setitem__('a', 1)
    __setitem__('b', 2)
    Traceback (most recent call last):
      File "test.py", line 99, in <module>
        class Foobar(metaclass=CustomNamespaceMeta):
    TypeError: type.__new__() argument 3 must be dict, not DictLike

    我们必须把它转化成真正的字典(或者他的一个子类):

    class FixedCustomNamespaceMeta(CustomNamespaceMeta):
    	def __new__(mcs, name, bases, namespace):
    		return super().__new__(mcs, name, bases, namespace.data)

    接着,一切跟我期待的一样:

    class Foobar(metaclass=FixedCustomNamespaceMeta):
    	a = 1
    	b = 2
    __getitem__('__name__')
    __setitem__('__module__', '__main__')
    __setitem__('__qualname__', 'Foobar')
    __setitem__('a', 1)
    __setitem__('b', 2)

    下面这段代码我添了点东西,上面理解了你可以不看:

    class DictLike:
    	def __init__(self):
    		self.data = {}
    	def __getitem__(self, name):
    		print('__getitem__(%r)' % name)
    		return self.data[name]
    	def __setitem__(self, name, value):
    		print('__setitem__(%r, %r)' % (name, value))
    		self.data[name] = value
    class CustomNamespaceMeta(type):
    	def __prepare__(name, bases):
    		d = DictLike()
    		print(d)
    		print(d.__dict__)
    		return d
    
    class FixedCustomNamespaceMeta(CustomNamespaceMeta):
    	def __new__(mcs, name, bases, namespace):
    		print(mcs)
    		print(name)
    		print(namespace)
    		print(namespace.__dict__)
    
    		return super().__new__(mcs, name, bases, namespace.data)
    class Foobar(metaclass=FixedCustomNamespaceMeta):
    	a = 1
    	b = 2

    返回值

    <__main__.DictLike object at 0x04F53790>
    {'data': {}}
    __getitem__('__name__')
    __setitem__('__module__', '__main__')
    __setitem__('__qualname__', 'Foobar')
    __setitem__('a', 1)
    __setitem__('b', 2)
    <class '__main__.FixedCustomNamespaceMeta'>
    Foobar
    <__main__.DictLike object at 0x04F53790>
    {'data': {'__module__': '__main__', '__qualname__': 'Foobar', 'a': 1, 'b': 2}}

    返回值中可以看出namespace和__prepare__的返回值是一个东西。

    把他们放在一起

    先介绍一下实例是如何构建的:


    如何读这个泳道图:

    水平的两块泳道代表你定义function的地方。

    实心的线意味着function被调用了。

    从Metaclass.__call__到Class.__new__的线意味着Metaclass.__call__将调用Class.__new__。

    虚线意味着有一些东西要返回。

    Class.__new__返回了一个Class的实例。

    Metaclass.__call__返回了一切Class.__new__返回的东西(如果他返回了一个class实例,他也要在上面调用class.__init__)。

    写数字红圆圈记录了调用顺序。

    创造一个class也非常的相似:


    简单的写下:

    Metaclass.__prepare__只是返回命名空间对象(一个类似字典的对象,像之前解释的那样)。

    Metaclass.__new__返回Class对象

    Metaclass.__call__返回一切Metaclass__new__ 返回的(返回一个metaclass的实例,他同样在实例上调用了Metaclass.__init__)。

    无论是metaclass还是class,如果__new__没有返回实例,那么就不会触发__init__

    所以,你会发现metaclass允许你定制对象生命周期中几乎所有的部分。

    metaclass都是callable(callable是任何可以被调用的东西)

    如果你重新看一遍这篇文章,你会注意到可以通过Metaclass.__call__做一个实例。这意味着你能把任何callable作为metaclass。

    class Foo(metaclass=print):
    	pass
    print(Foo)

    返回

    Foo () {'__module__': '__main__', '__qualname__': 'Foo'}
    None

    如果你使用function作为metaclass,那么子类不能继承你的function的metaclass,但是type会返回function的返回值的类型。

    def func(*arg,**kwargs):
    	return 'func'
    class Foo(metaclass=func):
    	pass
    print(Foo)
    print(type(Foo))
    
    func
    <class 'str'>

    子类继承metaclass

    与类装饰器相比,一个有利点就是子类继承了metaclass。

    This is a consequence of the fact that Metaclass(...) returns an object which usually has Metaclass as the __class__.

    这是Metaclass(...)返回对象的结果,对象通常把Metaclass作为__class__。

    管理多个metaclass

    相对于相同的class允许有多个baseclass,每一个baseclass可能有不同的metaclass,但是有个转折:一切必须是线性的-继承树必须有单一的叶子。

    举个例子,双叶子的情况是不被接受的:

    class Meta1(type):
        pass
    class Meta2(type):
        pass
    class Base1(metaclass=Meta1):
        pass
    class Base2(metaclass=Meta2):
        pass
    class Foobar(Base1, Base2):
        pass

    这种情况会报错:

    Traceback (most recent call last):
      File "test.py", line 135, in <module>
        class Foobar(Base1, Base2):
    TypeError: metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases

    下面这个就可以(并且将用叶子作为metaclass)

    class Meta(type):
        pass
    class SubMeta(Meta):
        pass
    class Base1(metaclass=Meta):
        pass
    class Base2(metaclass=SubMeta):
        pass
    class Foobar(Base1, Base2):
        pass
    print(type(Foobar))
    <class '__main__.SubMeta'>

    方法签名

    (我第一次听到这个东西,他是指方法名称和参数以及参数类型)

    这里还有缺少一些重要的细节,比如方法的签名。让我们来看下class和metaclass与那些重要的被执行材料。

    注意额外的**kwargs——那些你可以在class声明时忽略的额外的关键字参数。

    class Meta(type):
        @classmethod
        def __prepare__(mcs, name, bases, **kwargs):
            print('  Meta.__prepare__(mcs=%s, name=%r, bases=%s, **%s)' % ( mcs, name, bases, kwargs ))
            return {}

    之前提到过,__prepare__返回一个对象,这个对象不是dict实例,所以你需要确保你的__new__能够掌控它。

        def __new__(mcs, name, bases, attrs, **kwargs):
            print('  Meta.__new__(mcs=%s, name=%r, bases=%s, attrs=[%s], **%s)' % (mcs, name, bases, ', '.join(attrs), kwargs))
            return super().__new__(mcs, name, bases, attrs)

    很少见__init__在metaclass中被执行,因为他没多大用处——当__init__被调用的时候,class已经被创建好了。这相当于拥有类装饰器但又有点不同,当生成子类的时候,__init__将被执行,但是类装饰器不被子类调用。

        def __init__(cls, name, bases, attrs, **kwargs):
            print('  Meta.__init__(cls=%s, name=%r, bases=%s, attrs=[%s], **%s)' % (cls, name, bases, ', '.join(attrs), kwargs))
            return super().__init__(name, bases, attrs)

    __call__方法将在你创造类实例的时候调用。

        def __call__(cls, *args, **kwargs):
            print('  Meta.__call__(cls=%s, args=%s, kwargs=%s)' % (cls, args, kwargs))
            return super().__call__(*args, **kwargs)

    使用Meta,注意extra=1:

    class Class(metaclass=Meta, extra=1):
        def __new__(cls, myarg):
            print('  Class.__new__(cls=%s, myarg=%s)' % (cls, myarg))
            return super().__new__(cls)
        def __init__(self, myarg):
            print('  Class.__init__(self=%s, myarg=%s)' % (self, myarg))
            self.myarg = myarg
            return super().__init__()
        def __str__(self):
            return "<instance of Class; myargs=%s>" % (getattr(self, 'myarg', 'MISSING'),)

    返回值

      Meta.__prepare__(mcs=<class '__main__.Meta'>, name='Class', bases=(), **{'extra': 1})
      Meta.__new__(mcs=<class '__main__.Meta'>, name='Class', bases=(), attrs=[__module__, __qualname__, __new__, __init__, __str__, __classcell__], **{'extra': 1})
      Meta.__init__(cls=<class '__main__.Class'>, name='Class', bases=(), attrs=[__module__, __qualname__, __new__, __init__, __str__, __classcell__], **{'extra': 1})

    注意当生成类实例的时候,Meta.__call__被调用

    Class(1)
      Meta.__call__(cls=<class '__main__.Class'>, args=(1,), kwargs={})
      Class.__new__(cls=<class '__main__.Class'>, myarg=1)
      Class.__init__(self=<instance of Class; myargs=MISSING>, myarg=1)
    <instance of Class; myargs=1>
    

    展开全文
  • 主要介绍了python单例模式与metaclass,文章介绍了单例模式的实现方式
  • Python METAR parser-开源

    2021-04-28 09:37:45
    用于解释METAR编码的天气报告的python
  • 主要介绍了python metaclass(元类)的相关资料,帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • Meta learning using one-shot learning, MAML, Reptile, and Meta-SGD with TensorFlow
  • 本文先简单介绍了Python中的类,然后是主要内容,涉及Metaclass的相关内容,还是不错的,这里分享给大家,供需要的朋友参考。
  • 主要介绍了Python使用metaclass实现Singleton模式的方法,实例分析了Python基于metaclass实现单例模式的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • python meta编程

    千次阅读 2018-01-01 09:59:12
    装饰器是一个函数,接受一个函数作为输入并返回一个新的函数作为输出。 timethis.py: import time from functools import wraps def timethis(func): @wraps(func) def wrapper(*args,**kwargs): ...
    装饰器是一个函数,接受一个函数作为输入并返回一个新的函数作为输出。
    timethis.py:
    import time
    from functools import wraps
    
    def timethis(func):
        @wraps(func)
        def wrapper(*args,**kwargs):
            start=time.time()
            result=func(*args,**kwargs)
            end=time.time()
            print(func.__name__,end-start)
            return result
        return wrapper

    countdown.py:
    
    
    from timethis import timethis
    
    
    @timethis
    def countdown(n: int):
        """
        Counts down
        """
        while n > 0:
            n -= 1
    
    
    countdown(1000000)
    print(countdown.__name__)
    print(countdown.__doc__)
    print(countdown.__annotations__)
    
    from inspect import signature
    
    print(signature(countdown))
    

    展开全文
  • metaclass in python

    2008-03-12 11:23:00
    python 的东西虽然概念上容易理解 ,但是实际用起来却也不都是那么容易的。这个 metaclass 就是典型一例。虽然早知道了它是什么,不过要说出它具体能干点啥,一时半会还真想不起来。 先看看官方文档中的定义吧: __...
  • Python中元类Metaclass

    2020-07-21 19:56:38
    谈谈Python中的Metaclass(一) 谈谈Python中的Metaclass(二) Github Python Master参考 使用元类实现单例模式 Python-Master:元类与元编程 补充知识: Python super()函数 Python getattr()函数 ...
  • Python中的metaclass

    2017-08-16 05:21:27
    一文带你完全读懂Python中的metaclass
  • python当中的metaclass使用

    千次阅读 2019-04-16 11:43:27
    python当中的metaclass 简单介绍 python中对象也是类,类作为一种特别的对象存在,特别之处就在于可以作为一个模板来生成对象(所有的类都是),暂且把python中的类称为类对象,类对象使用class定义。 除了class...
  • 为了让更多的人看到本文,请各位读者动动小手,点击右上角【...】,将本文分享到朋友圈,thanks!Python类的定义再简单不过了。不过你有想过动态定义一个Python类吗?What...
  • Pythonmetaclass解释

    千次阅读 2013-08-26 14:51:14
    首先,在认识metaclass之前,你需要认识下python中的class。python中class的奇怪特性借鉴了smalltalk语言。大多数语言中,classes仅仅是用于描述怎样创建一个对象的代码端。在某种程度上说,python中的class也是这样...
  • Python3的metaclass

    2018-07-21 09:44:55
    Python3的版本中,创建类的时候可以填入metaclass属性,它的作用是用metaclass指定的对象来构建这个类具体内容,来看一个栗子 def upper_attrs(classname, parents, attrs): newAttrs = {} for name, value in...
  • python中的metaclass

    千次阅读 2019-06-22 20:34:56
    传说metaclass在python中是个“逆天”的存在,有人认为它是“阿拉丁神灯”,无所不能;有人认为它是“潘多拉魔盒”,会蛊惑程序员去滥用,释放“恶魔”,然后悲剧就产生了。就连硅谷一线大厂要想使用metaclass都得...
  • Python中我们用type函数可以动态地创建一个元类,同样也可以用__metaclass__属性来指定一个元类,接下来我们就来具体举例讲解Pythonmetaclass元类的创建与使用

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 118,282
精华内容 47,312
关键字:

metapython

python 订阅