元类

最新推荐文章于 2024-06-24 10:05:24 发布
最新推荐文章于 2024-06-24 10:05:24 发布
阅读量180 收藏
点赞数
分类专栏： 笔记 文章标签： python 类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37719875/article/details/108080908
版权

一：元类介绍

“元类就是深度的魔法,99%的用户应该根本不必为此操心”。

如果你想搞清楚究竟是否需要用到元类，那么你就不需要它

那些实际用到元类的人都非常清楚地知道他们需要做什么，而且根本不需要解释为什么要用元类。”

—— Python界的领袖 Tim Peters

一切都源自一句话：在Python中，一切皆对象

元类：类他爹

定义类，可以控制对象的产生

元类，可以控制类的产生

# 元类==>People类==>obj类
class People(object):
    shcool = 'Chongqing University'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say(self):
        print(f'Hello{self.name}')

obj = People('wyj',18)
# 调用People类 ==> 对象obj
# 调用元类 ==> People类

# 查看类(类型)
print(type(obj)) # <class '__main__.People'>
print(type(People)) # <class 'type'>

结论：
默认的元类是type,默认情况下我们用class关键字定义的类都是有type产生的

二：class关键字底层都做了哪些事

1.先拿到一个类名

class_name = 'People'

2.然后拿到类的父类

class_bases = (object,)

3.在运行内体代码，将产生的名字放到名称空间中

class_dic={}
class_body='''
    shcool = 'Chongqing University'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say(self):
        print(f'Hello{self.name}')
'''
exec(class_body,{},class_dic)
# print(class_dic)

补充：exec的使用

dic = {}    # 空字典
s = '''
a = 1
b = 2
c = 3
'''

exec(s, {}, dic)
print(dic)

4.调用元类（传入类的3大要素：类名、基类、类的名称空间）得到1个元类的对象，然后将元类的变量赋值给People（这个People就是我们用class自定义的类）

People = type(class_name,calss_bases,calss_dic)

5.完整思路

# 先拿类名
class_name = 'People'
# 拿到类的父类
class_bases = (object,)
# 在拿到类的名称空间(运行内体代码得到)
class_dic = {}
class_body = '''
    shcool = 'Chongqing University'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say(self):
        print(f'Hello{self.name}')
'''

exec(class_body, {}, class_dic)
# 4.调用元类（传入类的3大要素：类名、基类、类的名称空间）得到1个元类的对象，然后将元类的变量赋值给People（这个People就是我们用class自定义的类）
People = type(class_name,calss_bases,calss_dic)

三：自定义元类

1.先拿到一个类名：People

2.拿到类的父类：（object,）

3.在拿到类的名称空间（运行类体代码得到的）{…}

4.调用元类（传入类的3大要素：类名、基类、类的名称空间）得到一个元类的对象，然后将元类的变量

People = Mymeta(‘People’, (object,), {…})

1.自定义元类

只有继承了type的类才是自定义的元类
可以通过自定义元类来规范类的生产

import re


class Mymeta(type):  # 只有继承了type的类 才是自定义的元类
    def __init__(self, class_name, class_bases, class_dic):
        print(self)  # 类
        # print(class_name)
        # print(class_bases)
        # print(class_dic)

        # 规范类名
        if not re.match('[A-Z]', class_name):
            raise BaseException('类名必须用驼峰体')

        # 至少继承一个类
        if len(class_bases) == 0:
            raise BaseException('至少继承一个类')

        # 文档注释
        # print('文档注释：', class_dic.get('__doc__'))
        doc = class_dic.get('__doc__')
        if not (doc and len(doc.strip()) > 0):
            raise BaseException('必须要有文档注释，并且注释内容不能为空')


# People = Mymeta('People', (object,), {...})
class People(object, metaclass=Mymeta):
    '''
    这是我的文档注释
    '''
    school = 'Chongqing University'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say(self):
        print(f'Hello {self.name}!')

2.探究可否调用

①自定义的类实例化的对象和其他int、list都不可用

class Foo:
    pass


obj1 = Foo()

obj2 = int(10)

obj3 = list([1, 2, 3])


# obj1()
# TypeError: 'Foo' object is not callable

# obj2()
# TypeError: 'int' object is not callable

# obj3()
# TypeError: 'list' object is not callable

②自定义的类加上==__call__方法后，实例化的对象，是可以直接通过加()==被调用的

调用对象其实就是在调用类对象类中定义的绑定方法：__call__

class Foo:
    def __call__(self, *args, **kwargs):
        print('=========')
        print(self)
        print(args)
        print(kwargs)


obj1 = Foo()
obj1(1, 2, 3, a=1, b=2) # 调用对象 其实就是在调用对象类中 定义的绑定方法：__call__
# (1, 2, 3)
# {'a': 1, 'b': 2}

3.自定义元类控制类的调用

import re

class Mymate(type): # 只有继承了type的类才是自定义类
    def __init__(self,class_name, class_bases, class_dic):
        print(self)  # 类
        # print(class_name)
        # print(class_bases)
        # print(class_dic)

        # 规范类名
        if not re.match('[A-Z]', class_name):
            raise BaseException('类名必须用驼峰体')

        # 至少继承一个类
        if len(class_bases) == 0:
            raise BaseException('至少继承一个类')

        # 文档注释
        # print('文档注释：', class_dic.get('__doc__'))
        doc = class_dic.get('__doc__')
        if not (doc and len(doc.strip()) > 0):
            raise BaseException('必须要有文档注释，并且注释内容不能为空')

    def __call__(self, *args, **kwargs):
        # 1.先创建一个空对象
        # 2.调用类的__init__方法，将空对象连同括号内的参数 一同传给__init__
        # 3.将初始化好的对象 赋值给变量名obj
        return 123
    
# People = Mymeta('People', (object,), {...})
class People(object,metaclass=Mymate):
    '''
        这是文档注释
    '''
    shcool = 'Chongqing University'
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def say(self):
        print(f'Hello{self.name}')


people_obj = People()  # <class '__main__.People'>

print(people_obj)  # 123

4.自定义元类 控制类的调用 - 进阶

import re


class Mymate(type):  # 只有继承了type的类才是自定义类
    def __init__(self, class_name, class_bases, class_dic):
        print(self)  # 类
        # print(class_name)
        # print(class_bases)
        # print(class_dic)

        # 规范类名
        if not re.match('[A-Z]', class_name):
            raise BaseException('类名必须用驼峰体')

        # 至少继承一个类
        if len(class_bases) == 0:
            raise BaseException('至少继承一个类')

        # 文档注释
        # print('文档注释：', class_dic.get('__doc__'))
        doc = class_dic.get('__doc__')
        if not (doc and len(doc.strip()) > 0):
            raise BaseException('必须要有文档注释，并且注释内容不能为空')

    def __call__(self, *args, **kwargs):
        # 1.先创建一个人空对象
        people_obj = object.__new__(self)
        # 2.调用类的__init__方法，将空对象连同括号内的参数 一同传给__init__
        self.__init__(people_obj, *args, **kwargs)
        # 3.将初始化好的对象 赋值给变量名obj
        return people_obj


class People(object, metaclass=Mymate):
    '''
        这是文档注释
    '''
    shcool = 'Chongqing University'

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say(self):
        print(f'Hello{self.name}')


people_obj = People('wyj', 18)  # <class '__main__.People'>

print(people_obj)
print(people_obj.name)  # wyj
print(people_obj.age)  # 18
print(people_obj.say)  # <bound method People.say of <__main__.People object at 0x0147A550>>

# 调用People类做的事情：
# 1、先创建一个人的空对象
# 2、调用人类内的__init__方法，然后将人的空对象连同括号内的参数的参数一同传给__init__
# 3、将初始化好的人对象赋值给变量名people_obj

5.自定义元类 将类的属性隐藏

import re


class Mymeta(type):  # 只有继承了type的类 才是自定义的元类
    def __init__(self, class_name, class_bases, class_dic):
        print(self)  # 类
        # print(class_name)
        # print(class_bases)
        # print(class_dic)

        # 规范类名
        if not re.match('[A-Z]', class_name):
            raise BaseException('类名必须用驼峰体')

        # 至少继承一个类
        if len(class_bases) == 0:
            raise BaseException('至少继承一个类')

        # 文档注释
        # print('文档注释：', class_dic.get('__doc__'))
        doc = class_dic.get('__doc__')
        if not (doc and len(doc.strip()) > 0):
            raise BaseException('必须要有文档注释，并且注释内容不能为空')

    # people_obj = People() 触发了下面的__call__
    def __call__(self, *args, **kwargs):
        # 1.先创建一个人的空对象
        people_obj = object.__new__(self)
        # 2.调用类的__init__方法，将空对象连同括号内的参数 一同传给__init__
        # People.__init__
        self.__init__(people_obj, *args, **kwargs)
        print(people_obj.__dict__)
        people_obj.__dict__ = {'_%s__%s' % (self.__name__, k): v for k, v in people_obj.__dict__.items()}
        # 3.将初始化好的人对象 赋值给变量名people_obj
        return people_obj


# People = Mymeta('People', (object,), {...})
class People(object, metaclass=Mymeta):
    '''
    这是我的文档注释
    '''
    school = 'Chongqing University'

    #      people_obj,'wyj',18
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say(self):
        print(f'Hello {self.name}!')


people_obj = People('wyj', 18)
# <class '__main__.People'>
# {'name': 'wyj', 'age': 18}

print(people_obj.__dict__)
# {'_People__name': 'wyj', '_People__age': 18}
一只细猪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python元类详解
既然选择远方，便只顾风雨兼程！
10-22 2866
Python从设计之初就是一门面向对象的语言，它有一个重要的概念，即一切皆对象。Python与java的区别：Java虽然也是面向对象编程的语言，但是血统没有Python纯正。比如Java的八种基本数据类型之一int，在持久化的时候，就需要包装成Integer类对象。但是在python中，一切皆对象。数字、字符串、元组、列表、字典、函数、方法、类、模块等等都是对象，包括你的代码。MetaClass元类，本质也是一个类，但和普通类的用法不同，它可以对类内部的定义（包括类属性和类方法）进行动态的修改。
Python 元类实例解析
09-20
主要介绍了 Python 元类实例解析,此文的主要任务就是给大家彻底讲明白什么是元类，需要的朋友可以参考下
元类的使用
henry_rhy的博客
06-23 302
在Python里一切都是对象（object），基本数据类型，如数字，字符串，函数都是对象。对象可以由类（class）进行创建。那么既然一切都是对象，那么类是对象吗？是的，类也是对象，那么又是谁创造了类呢？答案也很简单，也是类，一个能创作类的类，称之为元类（type)1. 类的定义对象是通过类创建的，如下面的代码： 解析：可以看见对象 Mywork 是类 Work 创建的实例。然但是可以看到Work的类型时由一个叫 type 的类创建的实例。即 Mywork —》 Work —》 type 创建上面的例
Python元类编程
非-浪的博客
05-26 211
文章目录__new__typemetaclass new type metaclass https://zhuanlan.zhihu.com/p/98440398
（十一）元类
Sean_0819的博客
08-04 128
元类
Python--元类
weixin_43988680的博客
04-01 5886
一、元类介绍 二、class 关键字创建类的流程分析 三、自定义元类 四、__new__方法 五、__call__方法 六、总结类的调用与类产生对象的步骤分析
Python3元类
miuric的博客
10-28 2458
介绍 元类是类的类对象，换言之类是元类的实例，Python中默认的元类为type，可以通过自定义元类的方式实现对类创建的控制。 类对象的创建顺序 class Base: a = 1 b = 2 print('class defined') def __new__(cls, *args, **kwargs): print(cls.__name__,...
Python元类和新型类-对象是类的实例，那类又是谁的实例？
有一分热，发一分光。
02-19 6279
既然对象是以类为模板生成的，那么类又是以什么为模板生成的？ 元类具有动态改变类的能力，给编程带来了更方便的动态性和能力。 新型类相比于传统类，支持更多特性和机制，有更多的弹性。......
深刻理解Python中的元类(metaclass)
带翅膀的猫的博客
08-19 3960
注：这是一篇在Stack overflow上很热的帖子。提问者自称已经掌握了有关Python OOP编程中的各种概念，但始终觉得元类(metaclass)难以理解。他知道这肯定和自省有关，但仍然觉得不太明白，希望大家可以给出一些实际的例子和代码片段以帮助理解，以及在什么情况下需要进行元编程。于是e-satis同学给出了神一般的回复，该回复获得了985点的赞同点数，更有人评论说这段回复应该加入到Py...
python 元类与装饰器
热门推荐
言之。
02-08 1万+
直接上代码 class MyType(type): def __init__(self, *args, **kwargs): print("MyType.__init__") super().__init__(*args, **kwargs) def __new__(cls, *args, **kwargs): print("MyType.__new__") new_cls = super().__new__(cls, *ar
Python如何定义有可选参数的元类
12-17
你想定义一个元类，允许类定义时提供可选参数，这样可以控制或配置类型的创建过程。 解决方案 在定义类的时候，Python允许我们使用 “metaclass“关键字参数来指定特定的元类。 例如使用抽象基类： from abc import...
Python 类与元类的深度挖掘 I【经验】
12-24
上一篇介绍了 Python 枚举类型的标准库，除了考虑到其实用性，还有一个重要的原因是其实现过程是一个非常好的学习、理解 Python 类与元类的例子。因此接下来两篇就以此为例，深入挖掘 Python 中类与元类背后的机制。...
Python 使用元类type创建类对象常见应用详解
09-18
主要介绍了Python 使用元类type创建类对象,结合实例形式详细分析了Python元类的概念、功能及元类type创建类对象的常见应用技巧,需要的朋友可以参考下
iOS中的类、元类以及isa示例详解
08-28
从初学OC的时候就听人提起过OC对象中的isa指针，用来指向对象所属的类，从而可以在调用方法时通过isa指针找到相应的方法和属性，下面这篇文章主要给大家介绍了关于iOS中类、元类以及isa的相关资料，需要的朋友可以...
Windows系统上更换pip源的详细指南
2402_85758349的博客
06-21 633
Python的包管理工具pip允许用户从Python包索引(PyPI)下载和安装第三方库。然而，默认的PyPI源有时可能因为网络问题或地理位置导致访问速度较慢。更换为更快的源可以显著提高下载和安装Python包的速度。本文将详细介绍如何在Windows系统上更换pip的源。
生命在于学习——Python人工智能原理（4.1）
易水哲的博客
06-19 2012
前言：人工智能基础结束了，本章开启Python的学习，之前我写过Python的学习了，不过是偏向网络安全方向的学习，这次算是完完全全的学习。
小红书商家电话采集软件使用指南
最新发布
qq_34629423的博客
06-24 402
步骤一：安装Python和相关库 首先，确保你的电脑已经安装了Python运行环境（建议安装Python3版本）。步骤三：编写代码 在你喜欢的编辑器中创建一个新的Python文件，例如"shangjia_phone_crawler.py"。步骤二：获取商家列表页面URL 在小红书App中，进入你想要采集的商家列表页面，并复制该页面的URL地址。然后，按照提示输入商家列表页面的URL地址，回车确认。使用小红书商家电话采集软件可以提高商家电话的采集效率，以下是使用指南及附带代码。
通过xml配置实现数据动态导入导出Excel
u010465417的博客
06-19 1012
spring-dj-excel-common.jar 一个可以通过动态配置 xml 建立 Excel 与数据关系现实数据导入导出的 spring 组件包，在 xml 配置文件里，你可以很方便的定义 Excel - sheet 表列头文本与数据表、数据实体属性的对应关系，对于创建 Excel 文件，你可以通过增加某一标签列的子项实现列头跨列展示效果，同时你也可以通过设置列头对应的样式属性 headStyle 来设置sheet表列头的文字、颜色、边框的展示效果，你也可以针对每一列进行单独的样式设置。
python 元类例子
01-19
元类是Python中非常特殊且强大的概念，它允许我们在定义类时动态地修改类的行为。下面是一个简单的例子来介绍元类的使用： ```python class MyMeta(type): def __new__(cls, name, bases, attrs): # 修改类的行为...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值