python学习-Day29

目录

• 今日内容详细
  • • 反射实际案例
    • 面向对象的双下方法
      • __ str __
      • __ del __
      • __ getattr __
      • __ setattr __
      • __ call __
      • __ enter __
      • __ exit __
      • __ getattribute __
      • __ new __
    • 试题讲解
      • 让字典具备句点符查找值的功能
      • 补全下列代码 使其运行不报错
  • 元类
    • 简介
    • 产生类的两种表现形式(本质是一种)
      • class关键字
      • type元类
      • 学习元类的目的
    • 元类的基本使用
    • 元类操作
    • 双下new方法

今日内容详细

反射实际案例

# 利用面向对象编写系统终端功能
class WinCmd(object):
    def ls(self):
        print('windows系统正在执行ls命令')
    def dir(self):
        print('windows系统正在执行dir命令')
    def cd(self):
        print('windows系统正在执行cd命令')

class LinuxCmd(object):
    def ls(self):
        print('Linux系统正在执行ls命令')
    def dir(self):
        print('Linux系统正在执行dir命令')
    def cd(self):
        print('Linux系统正在执行cd命令')

obj = WinCmd()
obj1 = LinuxCmd()

"""反射提供了一种不需要考虑代码的前提下 操作数据和功能"""

def run(obj):
    while True:
        cmd = input('请输入您的指令>>>:')
        if hasattr(obj, cmd):
            func_name = getattr(obj, cmd)
            func_name()
        else:
            print('cmd command not found')
run(obj1)
run(obj)

面向对象的双下方法

有些双下方法不需要刻意调用 到达某个条件会自动触发

__ init __ 对象实例化的时候自动触发

__ str __

对象被执行打印(print、前端展示)操作的时候自动触发
     该方法必须返回字符串类型的数据
  很多时候用来更加精准的描述对象

__ del __

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

__ getattr __

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

__ setattr __

对象在执行添加属性操作的时候自动触发	>>>	obj.变量名=变量值

__ call __

# 对象被加括号调用的时候自动触发
对象加括号会自动执行产生该对象的类里面的__call__,并且该方法返回什么对象加括号就会得到什么

__ enter __

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

__ exit __

对象被执行with上下文管理语法结束之后自动触发

__ getattribute __

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

__ new __

__new__用于产生空对象(类)		骨架
__init__用于实例化对象(类)		血肉

"""
	不是所有的地方都可以直接调用__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
"""

试题讲解

让字典具备句点符查找值的功能

# 定义一个类继承字典
  class MyDict(dict):
      def __getattr__(self, item):
          return self.get(item)

      def __setattr__(self, key, value):
          self[key] = value
  '''要区别是名称空间的名字还是数据k:v键值对'''

  obj = MyDict({'name':'jason','age':18})
  # 1.具备句点符取v
  # print(obj.name)
  # print(obj.age)
  # 2.具备句点符设k:v
  # obj['gender'] = 'male'
  obj.pwd = 123  # 给字典名称空间添加名字  不是数据k:v
  print(obj)

补全下列代码 使其运行不报错

"""
	class Context:
			pass
	with Context() as ctx:
			ctx.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()

元类

简介

对象都是由类实例化得到的，类也是对象(一切皆对象)，而类又是由元类产生的，元类也是一种类

元类就是产生类的类，默认情况下type就是所有类的元类

# print(type(123))
# print(type([12, 33, 44]))
# print(type({'name':'jason','pwd':123}))

# type查看的其实是当前对象所属的类名称

class MyClass(object):
    pass
obj = MyClass()
print(type(obj))
print(type(MyClass))  # <class 'type'>

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

class Teacher(MyClass):
    pass
print(type(Teacher))  # <class 'type'>

'''type就是所有类默认的元类'''

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

class关键字

class C1(object):
    pass
	print(C1)  # <class '__main__.C1'>

type元类

# type(类名,父类,类的名称空间)
  	res = type('C1', (), {})
		print(res)  # <class '__main__.C1'>

学习元类的目的

"""
	元类能够控制类的创建 也就意味着我们可以高度定制类的行为
	eg:掌握了物品的生产过程 就可以在过程中做任何的额外操作
"""

元类的基本使用

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

class C1(metaclass=MyTypeClass):
    	pass

class MyTypeClass(type):
    def __init__(cls, cls_name, cls_bases, cls_dict):
        # print(cls, cls_name, cls_bases, cls_dict)
        if not cls_name.istitle():
            raise Exception("类名的首字母必须大写 笨~")
        super().__init__(cls_name, cls_bases, cls_dict)

class C1(metaclass=MyTypeClass):
    school = '清华大学'

class a(metaclass=MyTypeClass):
    school = '清华大学'

元类操作

# 类加括号会执行元类的里面的__call__该方法返回什么其实类加括号就会得到什么

"""
类里面的__init__方法和元类里面的__call__方法执行的先后顺序
"""
class MyTypeClass(type):
	def __call__(self, *args, **kwargs):
		print('__call__ run')
		super().__call__(*args, **kwargs)
class MyClass(metaclass=MyTypeClass):
	def __init__(self, name):
		print('__init__ run')
		self.name = name
	obj = MyClass('jason')

# 定制对象的产生过程
class MyTypeClass(type):
	def __call__(self, *args, **kwargs):
		# print('__call__ run')
		# print(args,kwargs)
		if args:
			raise Exception('必须全部采用关键字参数')
		super().__call__(*args, **kwargs)

class MyClass(metaclass=MyTypeClass):
	def __init__(self, name):
		# print('__init__ run')
		self.name = name

"""
强制规定:类在实例化产生对象的时候 对象的独有数据必须采用关键字参数
"""

	obj2 = MyClass(name='jason')

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

双下new方法

__new__用于产生空对象(类)			骨架
__init__用于实例化对象(类)		血肉

"""
并不是所有的地方都可以直接调用__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