面向对象编程(四)

面向对象编程(四)

反射实操

# 反射的四个重要方法
# hasattr():根据字符串判断对象里有没有该名字
# getattr():根据字符串获取对象里对应的名字
# setattr():给对象添加数据或者方法
# delattr():根据字符串删除对象里对应键值对

# 模拟cmd终端功能
class MyCMD(object):
    def ls(self):
        print('执行了ls命令')
    def ipconfig(self):
        print('执行了ipconfig命令')
    def cd(self):
        print('执行了cd命令')

obj1 = MyCMD()
while True:
    order = input('请输入命令:').strip()
    if hasattr(obj1,order):
        name = getattr(obj1,order)  # 获取对象中对应的名字
        if callable(name):
            name()  # 如果该名字可调用则执行函数名加括号
        else:
            print(name)  # 如果该名字不可调用则输出
    else:
        print('命令不存在')

面向对象的双下方法

"""
面向对象中的双下方法也有一些人称之为是魔法方法
	有些双下方法不需要刻意调用 到达某个条件会自动触发
		__init__		对象实例化的时候自动触发
"""
1.__str__
	对象被执行打印(print、前端展示)操作的时候自动触发
     该方法必须返回字符串类型的数据
  很多时候用来更加精准的描述对象

2.__del__
	对象被执行(被动、主动)删除操作之后自动执行

3.__getattr__
  对象查找不存在名字的时候自动触发

4.__setattr__
	对象在执行添加属性操作的时候自动触发	>>>	obj.变量名=变量值
 
5.__call__
	对象被加括号调用的时候自动触发

6.__enter__
	对象被执行with上下文管理语法开始自动触发 
  	该方法返回什么as后面的变量名就会得到什么
  
7.__exit__
	对象被执行with上下文管理语法结束之后自动触发

8.__getattribute__
	只要对象查找名字无论名字是否存在都会执行该方法
  如果类中有__getattribute__方法 那么就不会去执行__getattr__方法

9.__new__
	后面专门讲

笔试题讲解

# 1.让字典具备句点符查找值的功能
class MyDict(dict):
    def __getattr__(self, item):  # item就是传进来的字符串
        return self.get(item)  # 返回对应值

    def __setattr__(self, key, value):
        self[key] = value  # 添加键值对

obj1 = MyDict({'name':'petter','age':18,'gender':'male'})
print(obj1.name)  # petter
obj1.height = 185
print(obj1)  # {'name': 'petter', 'age': 18, 'gender': 'male', 'height': 185}

# 2.补全下列代码 使其运行不报错
	"""
	class Context:
			pass
	with Context() as ctx:
			ctx.do_something()
	"""
class Context:
    def __enter__(self):
        print('开始with上下文管理')
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('with上下文管理结束')

    def do_something(self):
            print('do_something被执行')
with Context() as ctx:
        ctx.do_something()

元类简介

# 元类
	类的老祖宗，产生类的类

class Student(object):
    school = '家里蹲大学'
    def test(self):
        return '考试了'
print(type(Student))  # <class 'type'>
print(type(dict))  # <class 'type'>

'''
所有类的默认类型都是type
即type是所有类默认的元类
'''

产生类的两种表现形式(本质是一种)

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

2.type元类
	eg:
        type(类名,父类,类的名称空间)
        cls = type('Teacher',(),{})
        print(cls)  # <class '__main__.Teacher'> 
    
"""
学习元类的目的
	元类能够控制类的创建 也就意味着我们可以高度定制类的行为
		eg:掌握了物品的生产过程 就可以在过程中做任何的额外操作
		
	比如:要求类的名字必须首字母大写
		思考在哪里编写定制化代码
			类的产生过程目前还比较懵 	  元类里面的__init__方法
			对象的产生过程呢 			     类里面的__init__方法
		方法:由已知推未知
"""

元类的基本使用

# 编写元类规定对象的所有数据值转大写
"""元类是不能通过继承的方式直接指定的"""
	需要通过关键字参数的形式修改
  	class C1(metaclass=MyTypeClass):
    	pass
    
# 定制类的产生
# 规定类里面的名字必须全大写了
class MyType(type):
    def __init__(cls, what, bases, dict):
        if not what.isupper():
            raise Exception('新规定，必须全大写')
        super().__init__( what, bases, dict)

class Student(metaclass=MyType):
    name = 'oscar'

obj1 = Student()
obj1.name  # Exception: 新规定，必须全大写

元类进阶操作

# 编写元类规定对象的所有数据值转大写
class MyTypeClass(type):
    def __call__(self, *args, **kwargs):
        for i in self.__dict__:  # 遍历名称空间
            if isinstance(self.__dict__[i],str):  # 如果值是字符串类型
                setattr(self,i,self.__dict__[i].upper())  # 将值转换成大写
        super().__call__(*args, **kwargs)
        return self

class C1(metaclass=MyTypeClass):
    school = 'adassfa'
obj1 = C1()
print(obj1.school)  # ADASSFA

"""
如果你想高度定制类的产生过程
	那么编写元类里面的__init__方法
如果你想高度定制对象的产生过程
	那么编写元类里面的__call__方法
"""

双下new方法

__new__用于产生空对象(类)			骨架
__init__用于实例化对象(类)			血肉
'''
先执行__new__产生框架
再执行__init__把数据填充进去
才形成一个完整的类
'''