元类对象

# 1、在元类中控制把自定义类的数据属性都变成大写

class Mymeta(type):
    def __new__(cls, name,bases,attrs):
        update_attrs = {}
        for k,v in attrs.items():
            if not callable(v) and not k.startswith(‘__‘):
                update_attrs[k.upper()]=v
            else:
                update_attrs[k] = v
        return type.__new__(cls,name,bases,update_attrs)
class Chinese(metaclass=Mymeta):
    country=‘China‘
    tag=‘sdgfsdgds‘
    def walk(self):
        print(1)
print(Chinese.__dict__)

1.元类帮其完成创建对象,以及初始化操作;

2.要求实例化时传参必须为关键字形式,否则抛出异常TypeError: must use keyword argument

3.key作为用户自定义类产生对象的属性,且所有属性变成大写

class Mymeta(type):
    def __call__(self, *args, **kwargs):
        if args:
            raise TypeError(‘must use keyword argument for key function‘)
        obj = object.__new__(self)
        for k, v in kwargs.items():
            obj.__dict__[k.upper()] = v
        return obj

class Chinese(metaclass=Mymeta):
    country=‘China‘
    tag=‘sdgfsdgds‘
    def walk(self):
        print(1)
p=Chinese(name=‘adasd‘,age=18,sex=‘男‘)
print(p.__dict__)

3、在元类中控制自定义的类产生的对象相关的属性全部为隐藏属性

class Mymeta(type):
    def __call__(self, *args, **kwargs):
        #控制Foo的调用过程,即Foo对象的产生过程
        obj = self.__new__(self)
        self.__init__(obj, *args, **kwargs)
        obj.__dict__={‘_%s__%s‘ %(self.__name__,k):v for k,v in obj.__dict__.items()}
        return obj

class Foo(metaclass=Mymeta):  # Foo=Mymeta(...)
    def __init__(self, name, age,sex):
        self.name=name
        self.age=age
        self.sex=sex
obj=Foo(‘lili‘,18,‘male‘)
print(obj.__dict__)

4、基于元类实现单例模式

#步骤五:基于元类实现单例模式
# 单例:即单个实例,指的是同一个类实例化多次的结果指向同一个对象,用于节省内存空间
# 如果我们从配置文件中读取配置来进行实例化,在配置相同的情况下,就没必要重复产生对象浪费内存了
#settings.py文件内容如下
HOST=‘1.1.1.1‘
PORT=3306

#方式一:定义一个类方法实现单例模式
import settings

class Mysql:
    __instance=None
    def __init__(self,host,port):
        self.host=host
        self.port=port

    @classmethod
    def singleton(cls):
        if not cls.__instance:
            cls.__instance=cls(settings.HOST,settings.PORT)
        return cls.__instance

obj1=Mysql(‘1.1.1.2‘,3306)
obj2=Mysql(‘1.1.1.3‘,3307)
print(obj1 is obj2) #False

obj3=Mysql.singleton()
obj4=Mysql.singleton()
print(obj3 is obj4) #True

#方式二:定制元类实现单例模式
import settings

class Mymeta(type):
    def __init__(self,name,bases,dic): #定义类Mysql时就触发
        # 事先先从配置文件中取配置来造一个Mysql的实例出来
        self.__instance = object.__new__(self)  # 产生对象
        self.__init__(self.__instance, settings.HOST, settings.PORT)  # 初始化对象
        # 上述两步可以合成下面一步
        # self.__instance=super().__call__(*args,**kwargs)
        super().__init__(name,bases,dic)

    def __call__(self, *args, **kwargs): #Mysql(...)时触发
        if args or kwargs: # args或kwargs内有值
            obj=object.__new__(self)
            self.__init__(obj,*args,**kwargs)
            return obj
        return self.__instance

class Mysql(metaclass=Mymeta):
    def __init__(self,host,port):
        self.host=host
        self.port=port

obj1=Mysql() # 没有传值则默认从配置文件中读配置来实例化,所有的实例应该指向一个内存地址
obj2=Mysql()
obj3=Mysql()
print(obj1 is obj2 is obj3)
obj4=Mysql(‘1.1.1.4‘,3307)

#方式三:定义一个装饰器实现单例模式
import settings

def singleton(cls): #cls=Mysql
    _instance=cls(settings.HOST,settings.PORT)

    def wrapper(*args,**kwargs):
        if args or kwargs:
            obj=cls(*args,**kwargs)
            return obj
        return _instance
    return wrapper

@singleton # Mysql=singleton(Mysql)
class Mysql:
    def __init__(self,host,port):
        self.host=host
        self.port=port

obj1=Mysql()
obj2=Mysql()
obj3=Mysql()
print(obj1 is obj2 is obj3) #True

obj4=Mysql(‘1.1.1.3‘,3307)
obj5=Mysql(‘1.1.1.4‘,3308)
print(obj3 is obj4) #False

原文地址:https://www.cnblogs.com/bk134/p/12708155.html

时间: 04-15

元类对象的相关文章

Objective-C对象之类对象和元类对象

作者:wangzz 原文地址:http://blog.csdn.net/wzzvictory/article/details/8592492 转载请注明出处 如果觉得文章对你有所帮助,请通过留言或关注微信公众帐号wangzzstrive来支持我,谢谢! 作为C语言的超集,面向对象成为Objective-C与C语言的最大区别,因此,对象是Objective-C中最重要的部分之一.目前面向对象的语言有很多,Objective-C中的对象又和其他语言中的对象有什么区别呢?下面来简单介绍Objectiv

24-oc类工厂方法和类对象基本概念

类工厂方法 用于快速创建对象的类方法, 我们称之为类工厂方法 类工厂方法应用场景 类工厂方法中主要用于给对象分配存储空间和初始化这块存储空间 类工厂方法使用规范 规范: 一定是类方法 + 方法名称以类的名称开头, 首字母小写 一定有返回值, 返回值是id/instancetype 在类工厂方法实现中,调用本类的构造方法,创建实例对象,并返回实例对象 自定义类工厂方法是苹果的一个规范, 一般情况下, 我们会给一个类提供自定义构造方法和自定义类工厂方法用于创建一个对象 类工厂方法在继承中的注意点 以

OC基础(十)类的本质及isa指针和元类的简单介绍

一.类的基本概念: 1.类其实也是一个对象, 这个对象会在这个类第一次被使用的时候创建 2.只要有了类对象, 将来就可以通过类对象来创建实例对象 3.实例对象中有一个isa指针, 指向创建自己的类对象 4.类对象中保存了当前对象所有的对象方法 5.当给一个实例对象发送消息的时候, 会根据实例对象中的isa指针去对应的类对象中查找 6.所有类对象的继承关系就是元类对象的继承关系 二.isa指针 1.每一个对象都包含一个isa指针.这个指针指向当前对象所属的类. 2.[d bark];表示给d所指向

类和元类

声明 本文译自class and metaclasses.非原创 类和元类十个鸡生蛋,蛋生鸡的混沌逻辑 正文 Objective-C是一中类基础的对象系统.每一个类都是类的实例;对象的isa指针指向它所属的类.类描述了对象的数据:分配的大小和实例变量类型以及布局形式.类也定义了对象的行为:选择器去应答实现的实例方法. 类的方法列表是一簇实例方法,对象可以应答的选择器.当你给一下实例发送消息,objc_msgSend()检索对象的类(或父类)的方法列表决定调用哪个方法. 每个类也是一个对象.它有一

【原创】Python 对象创建过程中元类, __new__, __call__, __init__ 的处理

原始type: type是最原始的元类,其__call__方法是在你使用" t_class = type(classname_string, base_classes_tuple, attributes_dict)" 这种语法来使用时, 在__call__方法内使用又会调用type的__new__和__init__方法来创建classname_string的具体类,并初始化类信息.当type(***)调用完成, classname_string代表的类可以用来创建实例了. 元类调用过程

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以外,主要就是提

Python基础- 类和对象(使用、继承、派生、组合、接口、多态、封装、property、staticmethod、classmethod、反射、slots、上下文管理协议、元类)

标签: python对象 2017-07-01 16:28 79人阅读 评论(0) 收藏 举报  分类: python(11)  版权声明:本文为广大朋友交流学习,如有纰漏望不吝赐教,若存在版权侵犯请及时与我联系 目录(?)[+] 一.初识类和对象 在python3中类型就是类 先定义类在产生相对应的对象,也就是现有了概念再有了实体 class Garen: camp = 'Demacia' def attack(self): print('attack') 1.如何使用类 在python3:

8.python之面相对象part.9(初识元类part.1)

初步认识元类 #本篇文章介绍的元类,以及type以python3以上版本为准. 一.关于元类的前言. 在python中,一切皆对象,当然,类也是一个对象. class c1: pass obj1 = c1() 从上面这段例子可以看到,obj1是c1这个类创建出来的一个对象,obj1是由c1去产生的,如果按照前面的理论来理解,类也是一个对象,那么c1是由谁创建出来的呢? #type函数可以查看类型,也可以用来查看对象的类,二者是一样的 print(type(obj1)) # 输出:<class '

Python----面向对象---元类介绍

一.储备知识exec 参数1:字符串形式的命令 参数2:全局作用域(字典形式),如果不指定默认就使用globals() 参数3:局部作用域(字典形式),如果不指定默认使用locals() 示例代码如下: 1 g = { 2 'x': 1, 3 'y': 2 4 } 5 6 l = {} 7 8 exec(''' 9 global x, m 10 x = 10 11 m = 100 12 13 z = 3 14 ''', g, l) 15 16 print(g) 17 print(l) 18 19

面向对象,元类,控制类,对象的创建

""" call 调用的意思 ? 在在对象被调用时 执行 函数 类 自定义元类 的目的 ? 1.可以通过call 来控制对象的创建过程 ? 2.可用控制类的创建过程 """ 自定义一个元类 元类也是一个类 但是需要继承type class MyMeta(type):?self 表示要创建对象的那个类(Person) *args是调用Person类时传入的参数??  def __call__(self, *args, **kwargs):??