面向对象高级进阶

Posted mofujin

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了面向对象高级进阶相关的知识,希望对你有一定的参考价值。

  一、反射

  定义:通俗的理解其实反省,自省的意思

          反射值的时一个对象具备在增 删  改 查 得的属性你能力

  操作方法:通过操作字符串操作属性 

  反射:设计的四个函数:hasattr ,get attr, setattr , dleattr  者四个 函数就是普通内置函数,没有双下划线,就像print,sort,len()  区别于__getattr__  函数操作


# 使用场景:
# 反射其实就是对属性增删改查,如果直接使用内置dict,太过于繁琐,不好理解
# 反射是框架的基石,为什么


1.1 实列一:
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age


p = Person("Sen", 18)

if hasattr(p, name):
    # print(getattr(p,‘name‘))
    setattr(p, id, 123)  # 注意setattr 设置值的时候是有三个值的(对象,‘key’ ,value)
    print(p.id)
    # delattr(p, ‘id‘)  # ttributeError: ‘Person‘ object has no attribute ‘id‘
    # print(p.id)  # 此时‘id’已被删除
  print(p, ‘id‘) 此时是不会取到对象的值的

1.2 案例二:默认Djiang中间件 实现对象 的调用

前戏:

 

# 使用场景:
    # 反射其实就是对属性增删改查,如果直接使用内置dict,太过于繁琐,不好理解
    # 反射是框架的基石,为什么因位框架设计者补课不可能提前知道你的对象到底是怎么
    # 设计的所以你提供给框架的对象 必须通过判断验证之后才能正常使用
    # 判断就是反射要做的事情,当然也可以通过__dict__也可以实现的,其实这些方法也就对__dict__的操作进行了封装


# 需求:要实现一个用于处理用户的终端指令的小框架
# 框架:已经实现了最基础的架构代码逻辑,就是所有项目都是一样的部分

 

# 框架 的根据配置 文件拿到所需的类
class WinCmd:
    def cd(self):
        print(windcmd 切换目录。。。 )

    def delete(self):
        print(windcmd ..。删库)

    def dir(self):
        print(wind 列出当前的所有文件)


class LinCmd:
    def cd(self):
        print(lindcmd 切换目录。。。 )

    def rm(self):
        print(lindcmd ..。删库)

    def ls(self):
        print(lincmd  列出所有文件)

通过模块导入对象 实列化 调用

# 导入刚才的库
from day24.lib import my_work


def run(my_work):
    while True:
        cmd = input(输入指令)
        if cmd == exit:
            break
        if hasattr(my_work,cmd):
            func = getattr(my_work,cmd)
            func() #

        else:
            print(不支持)
    print(再见!!!)


wind = my_work.WinCmd()
run(wind)

很明显上述中我们的设计框架中写死必须用某个类,这是不合理的 以为我们无法提前预知对方的类在什么地方以及类名 所以我们应该为框架的使用者提供一个配置文件,要求对方将类写入文件 然后框架自己可以加载需要的模块

 实现代码:

 

  二、元类


"""该文件为框架的配置文件"""
# 作为框架的使用者,在配置文件中指定你配合框架的类是哪个

CLASS_PATH = ‘lib.my_work.WinCmd‘
# 导入刚才的库
import importlib

from day24.lib import my_work
from day24 import settings

def run(my_work):
    while True:
        cmd = input(输入指令)
        if cmd == exit:
            break
        if hasattr(my_work,cmd):
            func = getattr(my_work,cmd)
            func() #

        else:
            print(不支持)
    print(再见!!!)
# 创建一个插件对象 调用库框架来使用
# wind = my_work.WinCmd()
# run(wind)
# 很明显这种实现不是完全的合理

# 所以需要 根据文件拿到需要的类
path = settings.CLASS_PATH


# 从配中单独拿出来 模块路径 和 类名称
print(path.rsplit(‘.‘,1)) # [‘lib.my_work‘, ‘WinCmd‘] 者按照点切割的列表解压赋值
module_path, class_name = path.rsplit(‘.‘, 1)

# res = path.rsplit(‘.‘,1)
print(class_name)
# 拿到模块
mk = importlib.import_module(module_path)
print(mk) # <module ‘lib.my_work‘ from ‘D:\\datas\\day24\\lib\\my_work.py‘>
print(class_name)
# 拿到类
cls = getattr(mk,class_name)
print(cls)
obj = cls()

# 调用框架
run(obj) 实现代码 调
 obj 也就是这个类的实列对象class WinCmd  
"""
在框架设计中 我们不可能提前知道 框架的用户要提供类相关的信息
"""
import importlib
import abc

# 拿到模块 根据模块的路径
pl = importlib.import_module("libs.plugins")
print(pl)
# 从模块中取出类
cls = getattr(pl,"WinCMD")
print(cls)


# 实例化产生对象
obj = cls()
obj.cd()

二、元类

  2.1 定义:什么元类:用于创建类的类,万物皆对象,类也是对象(类对象)对象是通过 类实列化产生,类对象也是另一个了实例化产生的

       默认情况下所有类的元类都是type  类的类是type

  

# type 可以自定义类 拦截的类的产生

# 我们的需求是创建类对象做一些限制
# 实现方法一 既然是创建想到了初识化方法 我们只要找到类对象的类(元类)
# 覆盖init 方法就能实现需求

# 只要继承type类 那么这个类就变成了一个元类
# 自定义类 first

实现代码:

lass MyClass(type):  # 元类
    # 拦截在父类产生Student 初始化走 的__init__
    def __init__(self,class_name,bases,dict):  # self Student 类对象、
        print(self)  # 类 对象 <class ‘__main__.Student‘>
        print(class_name)  # 类名
        print(bases)
        print(dict)
        super().__init__(class_name, bases, dict)  # 重写父类放入方法
        if not class_name.istitle():  # 限制类的产生过程 必需满足我们限制的条件
            raise Exception(大哥不能呐必需是首字母大写)
        else:
            print(创建类成功)

我们要自定义的类

class Student(metaclass=MyClass):  # 自定义这个类怎么 重新type
   def __init__(self,name,age,b):
       self.name = name
       self.age = age
       self.b = b

a = Student(KOKO,(1,2),b=1)  # 实列化
#  __new__
print(a.__dict__)  # ‘name‘: ‘KOKO‘, ‘age‘: (1, 2), ‘ui‘: 

  方法二其实就是内部本质先走元类自己的__new__ 1.元类中构建类再  返回类对象

# 默认继承type 的类称为元类

# 类的创建第二种方法__new__

# __new__是帮我们创建类对象的初始化进行添加限制
class Myself(type):  # 继承type >>>元类
    def __new__(cls, *args, **kwargs):
        # cls 是Myself
        # 方法一
        # return super().__new__(cls,*args,**kwargs)  # 必需返回给__init 生成相应的类,并返回
        # 方法二
        obj = type.__new__(cls, *args, **kwargs)  # 在元类中该函数用来构建类本身
        return obj  # 返回一个对象  给__init__  # 在类中,该函数用来构建类实例

    def __init__(self, a, b, c):
        super().__init__(a, b, c)
        print(实列创建类)


class Teacher(metaclass=Myself):  # 限制老师类的产生
    pass
   属性

Teacher()

 

分为两个阶段:
1.类的生成:由元类生成;
2.实例的生成:由上述生成的类接着生成。

具体描述:

结合上一篇文章中,我们总结出生成一个类实例的全部过程:
1.类首先查找内部__metaclass__属性是否被自定义元类赋值,若赋值则准备用该自定义元类生成类,否则用type作为元类生成类;
2.解释器调用该元类的__new__函数(该函数为静态函数),并将要实例化的类中定义的各种属性传递给该函数固定的四个参数:其中cls是该元类本身,name是要被实例化的类的类名,bases是该类父类组成的元组,attrs则是该类属性名:属性值,函数名:函数对象组成的字典。
3.最终通过type类生成该类,并返回。
4.该类生成后,调用类中的__new__函数(该函数是静态函数)创建该类的实例,并返回该实例;
5.该实例接着调用它的__init__函数初始化实例,这样一个完整的实例就被生成出来了。

5,自定义元类的核心
由于是元类构建了类,因此若要更改某些固定类(str,int等)的用法,就必须在元类中做文章了。而元类的核心是__new__函数,自然在该函数内做文章。比如可以通过atrris字典为元类添加新的属性和函数,或改变以往的属性或函数等。这样的改变会传播到所有用该元类创建的类中。

总结:
__new__函数:
1.在元类中该函数用来构建类本身;
2.在类中,该函数用来构建类实例;
---------------------
   元类中__call__  

 

当你调用类对象时会自动触发元类中的__call__方法 ,并将这个类本身作为第一个参数传入,以及后面的一堆参数

覆盖元类中的call之后,这个类就无法产生对象,必须调用super().__call__来完成对象的创建
并返回其返回值

 

 

使用场景:

当你想要控制对象的创建过程时,就覆盖call方法  对象创建过程__call__

当你想要控制类的创建过程时,就覆盖init方法     控制类的创建  __init__

案例:



# 元类中的__call__方法 在对象加括号 会自动触发类中的__call__ 方法
# 覆盖父类的__call__ 这个类无法差生对象 必须调用super().__call__
# 来完成对象的创建,并返回其返回值



#实现将对象的所有属性名称转为大写
# 实现一

class Mytype(type):
# 控制对象的产生
def __call__(self, *args, **kwargs):
if args:
raise Exception(‘不能用位置参数‘)
return super().__call__(*args,**kwargs) # 必须返回这个对象



class Person(metaclass=Mytype):
def __init__(self,name,age):
self.name =name
self.age =age


a = Person(name=‘jcsk‘,age=19)

print(a.name)
print(a.age)

 

 

 

单列的实现

class Single(type):
def __call__(self, *args, **kwargs):
print(self) # Student 类
if hasattr(self, ‘obj‘):
return getattr(self, ‘obj‘)

obj = super().__call__(*args, **kwargs) # 没有则有创建
print(obj) # 实例化的对象
print(‘新开的试试看看‘)
self.obj = obj # 并保存到self 对象自己的名称空间中
return obj


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


a = Student(‘jj‘, 12) #
Student(‘mm‘, 12)
Student(‘kk‘, 12)
Student(‘pp‘, 12)
Student(‘tt‘, 12)

# l = [2, 1, 3, 5]  # 冒泡算是遍历里里面的元素 由第一个和第二个做比较 如是:按大到小进行编排

# 列表的个数
#
# 先比较 2,1 得到2 1 1 3 1 5
# 第一圈 0 索引
# >>> 元素比较元素次数 次数len-1 3

# 第二圈 1 索引
# 2 3 2 5 2和1已经再第一次拿到最小值了 不用再比较 比较元素次数 为2 len -1 -1
# l2 = [3, 5, 2, 1]


# 第三圈 2 索引
# 3 5 3和2 再 第二圈已经比较过了

# l3 = [5, 3, 2, 1]

# 需求要用函数的方法实现 找关系
s = [2, 3, 5, 1,10,309]
for i in range(len(s) - 1): # 元素比较的次数 第一次 顾头不顾尾range(3) 0 1 2 三次比较
# print(i) # 0 1 2 3 元素的索引下标
for j in range(len(s) - 1 - i): # i相当于圈数的索引i =1 第二次 顾头不顾尾range(2) 0 1 三次比较
if s[j] < s[j+1]:
# 解压赋值
s[j], s[j+1] = s[j+1], s[j]
print(s)


class Num:
def __init__(self,name,age):
self.age = name
self.age = age
def __str__(self):
return self.age

def __gt__(self, other):

return self.age > other.age


a1 = Num(‘json‘,‘48‘)
a2 = Num(‘json‘,‘19‘)
a3 = Num(‘json‘,‘26‘)

排序的 ????
stu = [a1.age, a2.age, a3.age]
for i in range(len(stu)-1):
for j in range(len(stu)-1-i):
if stu[j]>stu[j+1]:
stu[j],stu[j+1] = stu[j],stu[j+1]
print(stu)




以上是关于面向对象高级进阶的主要内容,如果未能解决你的问题,请参考以下文章

进击的Python第七章:Python的高级应用面向对象编程进阶

Python面向对象进阶之高级编程

JS高级学习路线——面向对象进阶

面向对象高级进阶

JS高级进阶JavaScript初识面向对象

python------面向对象进阶