面向对象的魔法方法及元类

标签：__ name self 魔法 及元类 面向对象 print type class

魔法方法 

类中定义的双下方法都可以叫做魔法方法，其特定情况下可以自动触发运行

1. __init__
对象添加独有数据的时候自动触发
2. __str__
对象执行打印操作时自动触发
3. __call__
对象加括号调用的时候自动触发
4. __getattr__
对象点不存在的名字时自动触发
5. __getattribute__
对象点名字就会自动触发,其存在就不会执行__getattr__
6. __setattr__
给对象添加或修改数据的时候自动触发 对象.名字 = 值
7.__exit__
with上下文管理语法结束自动触发
8.__enter__
当对象被当作with上下文管理操作的开始自动触发，
    方法返回什么，as后面的变量名就会接收到什么

元类介绍

# 1.查看数据类型使用type
s1 = 'hello'
print(type(s1))    # <class 'str'>
# 2.type方法是用来查看产生对象的类名
class Student:
    pass
obj =Student()
print(type(obj))  # <class '__main__.Student'>
# 3.python中一切皆对象，使用type查看类名显示什么
class A:pass
class B:pass
print(type(A),type(B))  # <class 'type'> <class 'type'>

"""
最后我们得出结论：我们定义的类都是由type类产生的>>也就是产生类的类(元类)
"""

两种创建类的方式

# 方法1:利用元类type:    type(类名，类的父类，类的名称空间）
res = type('Teacher', (object,), {'name': 'tony'})
print(res)         # <class '__main__.Teacher'>
print(res.__dict__)   # 产生Teacher类名称空间，拿到Teacher类下的所有名字

了解知识：
"""
1.手动写键值对: 针对绑定方法不好定义
2.内置方法exec：能够运行字符串类型的代码并产生名称空间 
"""   


# 方法2：使用关键字class定义

class Teacher:
    school_name = '清华大学'

    def func(self):
        pass
print(Teacher)    # <class '__main__.Teacher'>
print(Teacher.__dict__)

通过元类定制对象/定制类的产生行为

    类：

对象是由类名加括号产生  ： __init__
类是由元类加括号产生    ： __init__
# 1.自定义元类：继承type的类也被称为元类
class MyMetaClass(type):
    def __init__(self, what, bases = None, dict = None):
        if not what.istitle():
            raise TypeError('python定义类，类名首字母必须大写')
        super().__init__(what,bases,dict)

# 2.利用关键字metaclass指定类的元类
# class myclass(metaclass=MyMetaClass):
#     func = '类名小写可不可以'    # 直接报错

class Teacher(metaclass=MyMetaClass):
    info = '每天上课很辛苦'        # 正常运行

print(Teacher)            # <class '__main__.Teacher'>
print(Teacher.__dict__)   # {'__module__': '__main__', 'info': '每天上课很辛苦', '__dict__': <attribute '__dict__' of 'Teacher' objects>, '__weakref__': <attribute '__weakref__' of 'Teacher' objects>, '__doc__': None}

    对象：

对象+()会执行产生该对象类里面的 : __call__
类+()会执行产生该类的类里面的：__call__



class MyMetaClass(type):
    def __call__(self, *args, **kwargs):
        # 1.产生一个空对象
        # 2.调用__init__给对象添加独有的数据
        # 3.返回创建好的对象
        if args:
            raise TypeError('传入对象独有的数据要按照关键字传参')
        return super().__call__(*args,**kwargs)

class Student(metaclass=MyMetaClass):
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

obj = Student(name='jason',age=18,gender = 'male')
print(obj.__dict__)   # {'name': 'jason', 'age': 18, 'gender': 'male'}

 

魔法方法__new__

 

__new__：可以产生一个空对象


class Myclass(type):
    def __call__(self, *args, **kwargs):
        obj = self.__new__(self)
        self.__init__(obj,*args, **kwargs)
        return obj

class Student(metaclass=Myclass):
    def __init__(self,name):
        self.name = name

obj = Student('tony')
print(obj.name)   # tony

 

 

设计模式之单例模式

1. IT行业里由23种设计模式
2. 单例模式：
    类加括号无论执行多少次永远只产生一个对象
3. 为什么要做单例？
    当类中有许多强大的方法，我们需要在程序中多个地方使用。不做单例就会浪费存储空间
    使用单例模式，整个程序就用一个对象

 

标签：__,name,self,魔法,及元类,面向对象,print,type,class
From： https://www.cnblogs.com/juzijunjun/p/16871033.html