python 面向对象（4）

python 面向对象（4）

反射的实际案例：

# 利用面向对象编写系统的终端功能
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)

面向对象双下方法：

双下str：

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

#代码示例：
class Course(object):

    def __init__(self, name, price):
        self.name = name
        self.price = price

    def __str__(self):
        return "func is __str__ ,课程:{},价格:{}".format(self.name, self.price)

#
python = Course("English", 250)

print(python)  # func is __str__ ,课程:English,价格:250

print("%s" % (python))  # func is __str__ ,课程:English,价格:250

print([python])  
#[<__main__.Course object at 0x0000023A660794E0>]

双下str和双下repr区别

# 如果str存在,repr也存在
     那么print(obj)和使用字符串格式化format,%s这两种方式 调用的都是__str__
     而repr(obj)和%r格式化字符串,都会调用__repr__
# 如果str不存在,repr存在
     那么print(obj),字符串格式化format,%s,%r 和repr(obj)都调用__repr__
# 如果str存在,repr不存在
     那么print(obj)和使用字符串格式化format,%s这两种方式 调用的都是__str__
     repr(obj)和%r格式化字符串 都会打印出内存地址

双下del:

#__del__
	对象被执行(被动、主动)删除操作之后自动执行
    
# 代码示例：
class A(object):
    def __init__(self, name,age):
        self.name = name
        self.age = age


    def __del__(self):
        print("hhhh")


f = A("jason", 18)
print(f.__dict__)  # {'name': 'Tom', 'age': 45}

del f.name   
'''只和del obj语法有关系 在执行del obj之前会来执行一下__del__中的内容'''
print(f.__dict__)
#{'age': 18} hhhh

双下getattr, setattr, delattr, getattribute:

# __getattr__
 	对象查找不存在名字的时候自动触发
#__setattr__
	对象在执行添加属性操作的时候自动触发	>>>	obj.变量名=变量值
#__getattribute__
	只要对象查找名字无论名字是否存在都会执行该方法
  如果类中有__getattribute__方法 那么就不会去执行__getattr__方法

#代码示例：
class A(object):

    def __setattr__(self, key, value):
        print("执行了__setattr__方法")
        print(key, value)

    def __getattr__(self, item):
        print("执行了__getattr__方法")

    def __delattr__(self, item):
        print("执行了__delattr__方法")

    def __getattribute__(self, item):
        print("执行了__getattribute__方法")


f = A()
f.name = 'jason'  # 将会执行__setattr__

f.name  # 将会执行__getattribute__或者__getattr__ 当两者都存在的时候 先执行__getattribute__ 如果两者都没有 报错

del f.name  # 将会执行__delattr__

双下call:

#__call__
	对象被加括号调用的时候自动触发

#代码示例：
class A(object):
    def __init__(self, name,):
        self.name = name

    def __call__(self, *args, **kwargs):
        print("name " + self.name)


f = A("Tom")
f()  # name Tom

A("jason",)()  # name Mack   
''' 对象+()就会调用__call__()方法'''

双下enter,exit:

#__enter__
	对象被执行with上下文管理语法开始自动触发 
  	该方法返回什么as后面的变量名就会得到什么
    
#__exit__
	对象被执行with上下文管理语法结束之后自动触发
    
# 代码示例：
class A(object):
    def __enter__(self):
        print("开始的时候触发")
        return 'zz'	
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('结束的时候触发')

with A() as f:
    print('hhaha')

print(f) #f 是__enter__返回的值 没有返回值默认是None

#输出结果：
开始的时候触发
hhaha
结束的时候触发
zz

双下方法练习：

1.让字典具备句点符查找值得功能

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)

2.运行不报错

#补全代码使其不报错：
	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()

---

元类

# 元类的介绍
Python当中万物皆对象，我们用class关键字定义的类本身也是一个对象，负责产生该对象的类称之为元类，元类可以简称为类的类

元类的主要目的是为了控制类的创建行为

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是Python的一个内建元类，用来直接控制生成类，在python当中任何class定义的类其实都是type类实例化的结果。

只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类，自定义元类可以控制类的产生过程，类的产生过程其实就是元类

的调用过程'''

产生类的两种形式

一个类由三大组成部分，分别是

1、类名class_name

2、继承关系class_bases

3、类的名称空间class_dict

#方式1：使用class关键字（python解释器转化为第二种）
class A(object):
    pass
	print(A)  # <class '__main__.A'>
    
#方式2：通过type关键字，依次传入以上三个参数即可
type(类名,父类,类的名称空间)
  	res = type('A', (), {})
		print(res)  # <class '__main__.A'>
'''
学习元类的目的
	元类能够控制类的创建 也就意味着我们可以高度定制类的行为
		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("类名的首字母必须大写 你个SD")
        super().__init__(cls_name, cls_bases, cls_dict)

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

元组的进阶操作

1.回想__call__方法
	对象加括号会自动执行产生该对象的类里面的__call__,并且该方法返回什么对象加括号就会得到什么
  推导:类加括号会执行元类的里面的__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

	"""强制规定:类在实例化产生对象的时候 对象的独有数据必须采用关键字参数"""
  # obj1 = MyClass('jason')
  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
"""

---