标签：__ obj name self 元类 print 方法 def

总结

一、反射实际案例

二、面向对象的双下方法

三、元类

四、元类进阶

五、双下new方法

一、反射实际案例

# 反射提供了使用者不需要考虑代码，操作系统的数据和功能的方法
#  利用面向对象编写系统终端功能
class WinCmd(object):
    def ls(self):
        print('windows系统正在执行ls命令')
    def dir(self):
        print('windows系统正在执行dir命令')
    def cd(self):
        print('windows系统正在执行cd命令')
obj = WinCmd()
def run(obj):
    while True:
        cmd = input('请输入您的指令>>>:').strip()
        if hasattr(obj, cmd):
            func_name = getattr(obj,cmd)
            func_name()
        else:
            print('cmd command not found')  # 指令没有找到
run(obj)
# 通过输入指令，来进行运行
# 同理我们也可以模拟linux系统
class LinuxCmd(object):
    def ls(self):
        print(' Linux系统正在执行ls命令')
    def dir(self):
        print(' Linux系统正在执行dir命令')
    def cd(self):
        print(' Linux系统正在执行cd命令')


obj = LinuxCmd()
def run(obj):
    while True:
        cmd = input('请输入您的指令>>>:').strip()
        if hasattr(obj, cmd):
            func_name = getattr(obj,cmd)
            func_name()
        else:
            print('cmd command not found')  # 指令没有找到
run(obj)
# 只需要增加对象就可以

二、面向对象的双下方法

"""
  面向对象中的双下方法很神奇，而且有些双下方法不需要可以的调用，到达某个条件就会自动触发
  eg:
    __init__ 在对象实例化的时候 就会自动触发
"""

• 双下str方法（str）

__srt__
 对象被执行打印(print、前端展示)操作的时候自动触发
 这个方法必须返回字符串类型的数据，如果不是直接报错
 '用来更加精准的描述对象'  
    class student(object):
    def __init__(self, name):
        self.name = name

    def __str__(self):
        print('哎嘿哎嘿')
        return '芜湖'

obj = student('owen')
print(obj)
# 图为：
def __str__(self):
        print('哎嘿哎嘿')
        return 123
 # 当返回不是字符串时，报错

• 双下del（del)

__del__
 对象被执行(被动、主动)删除操作之后自动执行
    # 被动操作
    class student(object):
    def __init__(self, name):
        self.name = name
    def __str__(self):
        print('哎嘿哎嘿')
        return '芜湖'
    def __del__(self):
        print('del执行')
obj = student('owen')
print('起飞')

# 主动操作
class student(object):
    def __init__(self, name):
        self.name = name
    def __str__(self):
        print('哎嘿哎嘿')
        return '芜湖'
    def __del__(self):
        print('del执行')
obj = student('owen')
del obj
print('起飞')

• 双下gettattr(getattr)

对象查找不存在名字的时候自动触发
class Student(object):
    def __init__(self, name):
        self.name = name

    def __getattr__(self, item):
        print('执行getattr',item)
obj = Student('owen')
print(obj.name)
print(obj.age)

• 双下setattr(setattr)

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

    def __setattr__(self, key, value):
        print('触发setattr')
        print(key, value)
obj = Student('owen')
obj.age = 10

• 双下call（call）

# 可以支持对象加括号，可以传值，还可以返回值
class Student(object):
    def __init__(self, name):
        self.name = name

    def __call__(self, *args, **kwargs):
        print('执行call', args, kwargs)
        return '起飞'
 # obj()
obj = Student('owen')
print(obj(111))

• 双下enter(enter) 和 双下exit（exit）

# 之所以放他们在一块是因为他们固定在一起，要不然直接报错
class Student(object):
    def __init__(self, name):
        self.name = name

    def __enter__(self):
        # 对象被执行with上下文管理语法开始自动触发 
  	    # 该方法返回什么as后面的变量名就会得到什么
  
        print('执行enter')

    def __exit__(self, exc_type, exc_val, exc_tb):
       # 对象被执行with上下文管理语法结束之后自动触发
        print('执行exit')


obj = Student('owen')
with obj as f:
    print(111)
print(222)

• 双下getattribute(getattribute)

# 只要对象查找名字无论名字是否存在都会执行该方法
  # 如果类中有__getattribute__方法 那么就不会去执行__getattr__方法
class Student(object):
    def __init__(self, name):
        self.name = name

    def __getattribute__(self, item):
        print('执行getattribute')

obj = Student('owen')
print(obj.name)

笔试题讲解

1.让字典具备句点符查找值的功能
# 我们要区分名称空间的名字还是数据k:v键值对
class MyDict(dict):
    def __getattr__(self, item):
        return self.get(item)
    def __setattr__(self, key, value):
        self[key] = value
obj = MyDict({'name':'owen', 'age': 20})
print(obj.name)
print(obj.age)
obj.gender = 'male'
print(obj)

2.补全下列代码 使其运行不报错
原题：
"""
	class Context:
			pass
	with Context() as ctx:
			ctx.do_something()
	"""
# 书写 
1. 看到with方法就知道定义双下enter和双下exit
2.变量名加点绑定方法增加一个do_something方法
class Context:
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        pass
    def do_something(self):
        pass
	with Context() as ctx:
    ctx.do_something()

三、元类

1、含义

# 元类——产生类的类
print(type(111))  # <class 'int'>
print(type([11, 22, 33]))  # print(type([11, 22, 33]))
我们这里使用type查看就是当前对象所属的类名称
class MyClass(object):
    pass
obj = MyClass()
print(type(obj))  # <class '__main__.MyClass'>
print(type(MyClass))  # <class 'type'>

class Student:
    pass
print(type(Student))  # <class 'type'>

# 所以我们在这里得到
""" type 就是所有类的默认的元类 """

2、产生类的两种表现形式

1.class关键字
class MyClass(object):
    pass
print(MyClass)
# <class '__main__.MyClass'>

2.type元类
type(类名，父类，类的名称空间)
res = type(MyClass,(),{})
print(res)
# <class '__main__.MyClass'>
"""
  我们学习元类主要因为
    元类能够控制类的创建，相当于我们可以高度定制类的行为。
    eg:我们掌握了物品的生产过程，就可以在生产过程中做任何的额外操作
  实际应用：要求类的名字必须首字母大写
  因为我们现在对类的产生过程还没有那么了解，所以我们思考对象的产生过程为>>>>>类里面的__init__方法，所以我们判断类的产生过程为>>>>>元类里面的__init__方法

"""

3、元类的基本使用

""" 元类是不能通过继承的方式来直接指定 ，需要通过关键字参数(metaclass)的形式来修改"""

class MyTypeClass(type):
    def __init__(self,cls_name, cls_bases, cls_dict):  # 双下init黄色就是表达这个init方法被修改
        print(self,cls_name, cls_bases, cls_dict)  # <class '__main__.M1'> M1 () {'__module__': '__main__', '__qualname__': 'M1', 'school': '安徽大学'}
        if not cls_name.istitle():  # 判断首字母是不是小写
            raise Exception('类名首字母要大写呀')
        super().__init__(cls_name, cls_bases, cls_dict)

class M1(metaclass=MyTypeClass):
    school = '安徽大学'

四、元类进阶操作

# 思考__call__操作方法
 对象加括号会制动执行产生这个对象的类里面的__call__，并且这个方法返回什么对象加括号就会得到什么
    so：类加括号会执行元类的里面的__call__该方法返回什么，类加括号就会得到什么
class MyTypeClass(type):
    def __call__(self,*args, **kwargs):
        return 'bibibibi'
class MyClass(metaclass=MyTypeClass):
    pass
obj = MyClass()
print(obj)

"""类里面的__init__方法和元类里面的__call__方法执行的先后顺序"""

class MyTypeClass(type):
    def __call__(self,*args, **kwargs):
        print('__call__ run')
        # super().__init__(*args, **kwargs)
class MyClass(metaclass=MyTypeClass):
    def __init__(self, name):
        print('__init__ run')
        self.name = name
obj = MyClass()
# __call__ run
这里就是先走双下call，所以一个对象的产生先经历元类里面的双下call

"""强制规定:类在实例化产生对象的时候 对象的独有数据必须采用关键字参数"""
class MyTypeClass(type):
    def __call__(self,*args, **kwargs):
        if args:
            raise Exception('必须全部用关键字参数')
        super().__call__(*args, **kwargs)
class MyClass(metaclass=MyTypeClass):
    def __init__(self, name):
        self.name = name
# obj = MyClass('owen')  # 报错
obj = MyClass(name= 'owen')
"""
如果想高度定制类的产生过程
	那么编写元类里面的__init__方法
如果想高度定制对象的产生过程
	那么编写元类里面的__call__方法
"""

五、双下new方法

"""
__new__用来产生空对象(类)   相当于人的骨架
__init__用来实例化对象(类)  相当于人的血肉
"""
class MyTypeClass(type):
    def __new__(cls, *args, **kwargs):
        obj = type.__new__(cls, *args, **kwargs)
        return obj
class MyClass(metaclass=MyTypeClass):
    def __init__(self,name):
        self.name = name

obj = MyClass('owen')
print(obj)  # <__main__.MyClass object at 0x0000021373C891D0>

完整版本：
"""
注意:并不是所有的地方都可以直接调用__new__ 该方法过于底层
	如果是在元类的__new__里面 可以直接调用
		class Meta(type):
      def __new__(cls, *args, **kwargs):
          obj = type.__new__(cls,*args,**kwargs)
          return obj
	如果是在元类的__call__里面 需要间接调用
		class Mate(type):
    	def __call__(self, *args, **kwargs):
         obj = object.__new__(self) # 创建一个空对象
         self.__init__(obj,*args,**kwargs) # 让对象去初始化
         return obj
"""

标签：__,obj,name,self,元类,print,方法,def
来源： https://www.cnblogs.com/lsw8898/p/16132424.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。