面向对象进阶

Posted aheng

tags:

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

面向对象——多态

什么是多态?

多态是同一种事物不同的形态

多态的目的?

多态也称为多态性,目的是为了在不知道对象具体类型的情况下,统一对象调用方法的规范(例如:名字)

多态的表现形式之一就是继承

? 先抽象,再继承

父类:定制一套统一的规范

子类:遵循父类的统一规范

PS:Python中不会强制限制子类必须遵循父类的规范,所以出现了抽象类

# 动物类(父类)
class Animal:
    # 方法 吃
    def eat(self):
        pass

    # 方法 叫
    def spkea(self):
        pass


# 猪类(子类)
class Pig(Animal):
    def eat(self):
        print("bia唧....")

    def spkea(self):
        print("哼哼哼....")


# 猫类(子类)
class Cat(Animal):
    def eat(self):
        print("咬ji 咬ji....")

    def spkea(self):
        print("喵喵喵....")


# 狗类(子类)
class Dog(Animal):
    def eat(self):
        print("舔ji 舔ji....")

    def spkea(self):
        print("汪汪汪....")


animal1 = Pig()
animal2 = Cat()
animal3 = Dog()

# 让动物们叫起来
animal1.spkea()
animal2.spkea()
animal3.spkea()

多态——抽象类

什么是抽象类?

抽象类是在Python内置的abc模块中的

抽象类的作用?

让子类必须遵循父类编写的规范

如何实现抽象类?

父类需要继承abc模块中,metaclass = abc.ABCMeta

然后在父类的方法中要装饰上abc.abstractmethod

PS:在Python中不推荐使用抽象类

PS:子类必须按照父类的方法编写规范,缺一不可。(只要父类中有几个抽象方法,子类就必须要定义几个)

import abc


# 父类
class Animal(metaclass=abc.ABCMeta):
    # 方法  吃
    @abc.abstractmethod
    def eat(self):
        pass

    # 方法  叫
    @abc.abstractmethod
    def speak(self):
        pass


# 猪类
class Pig(Animal):
    def run(self):
        pass

    def eat(self):
        print("吧唧吧唧....")

    def speak(self):
        print("哼哼哼....")

多态——鸭子类型

什么是鸭子类型?

鸭子类型就是不同对象,只要长得像鸭子,动作行为像鸭子,那他就是鸭子

类与类之间不用共同继承一个父类,只需要将它们做得像一种事物即可。

为什么要有鸭子类型?

不同对象,先抽象出相同类型的方法,给他们定制一套统一的规范

所有的类,在定义时都按照统一的规范进进行编写

在Python中强烈推荐使用鸭子类型

# 猪类
class Pig:
    def eat(self):
        print('bia唧...')

    def speak(self):
        print('哼哼哼...')


# 猫类
class Cat:
    def eat(self):
        print('咬ji 咬ji....')

    def speak(self):
        print('喵喵喵...')


# 狗类
class Dog:
    def eat(self):
        print('舔 ji 舔ji...')

    def speak(self):
        print('汪汪汪...')


def SPRAK(animal):
    animal.eat()
    animal.speak()


dog = Dog()
cat = Cat()
pig = Pig()


SPRAK(dog)
SPRAK(cat)
SPRAK(pig)

classmethod与staticmethod装饰器

classmethod与staticmethod都是Python内置的装饰器

classmethod

classmethod是一个装饰器,给在类内部定义的方法装饰,将类内部的方法变为“类的绑定方法”

类的绑定方法:由类来调用,会将谁(类)当做第一个参数传入

staticmethod

classmethod是一个装饰器,给在类内部定义的方法装饰,将类内部的方法变为“非绑定方法”

非绑定方法:可由对象或类来调用,谁来调用都是一个普通方式

# classmethod例子
class DB:
    __date = "kang is very handsome!"

    def __init__(self, user, pwd, role):
        self.user = user
        self.pwd = pwd
        self.role = role

    @classmethod
    def check_db(cls, user, pwd, role):
        obj = cls(user, pwd, role)
        if obj.user == "kang" and obj.pwd == "123" and obj.role == "admin":
            print("检验通过")
            print(cls.__date)
            return cls.__date


# DB.check_db("kang", "123", "admin")
db_obj = DB("kang", "123", "admin")
db_obj.check_db("kang", "123", "admin")


# staticmethod例子
class Foo:
    @staticmethod
    def func(res):
        print(res)


obj = Foo()

obj.func(123)

Foo.func(1234)

isinstance与issubclass

这两个都是Python的内置模块

isinstance:判断对象是否是另一个类的实例

issubclass:判断一个类是否是另一个类的子类

返回的都是True和False

# isinstance:判断一个对象是否是另一个对象的实例
class Foo:
    pass


class Boo:
    pass


foo_obj = Foo()
boo_obj = Boo()

print(isinstance(boo_obj, Boo))     # True
print(isinstance(foo_obj, Foo))     # True
print(isinstance(boo_obj, Foo))     # False


# issubclass:判断一个类是否是另一个类的子类
class Father:
    pass


class Sub(Father):
    pass


class Joo:
    pass


print(issubclass(Sub, Father))      # True
print(issubclass(Joo, Father))      # False

面向对象高级——反射

反射是通过“字符串”对 对象属性或方法进行操作

  • hasatter:通过字符串判断对象的属性或方法是否存在
  • getattr:通过字符串获取对象的属性或方法,找到返回值,找不到报错(如果设置了默认值就返回默认值)
  • setattr:通过字符串设置对象的属性或方法
  • delattr:通过字符串删除对象的属性或方法

反射的四个方法是Python内置的

class Foo:
    def __init__(self, x, y):
        self.x = x
        self.y = y


foo_obj = Foo(10, 20)


# hasatter:通过字符串判断对象的属性或方法是否存在
print(hasattr(foo_obj, "x"))        # True
print(hasattr(foo_obj, "y"))        # True
print(hasattr(foo_obj, "z"))        # False


# getattr:通过字符串获取对象的属性或方法
print(getattr(foo_obj, "x"))        # 10
print(getattr(foo_obj, "y"))        # 20
print(getattr(foo_obj, "z", 30))    # 30


# setattr:通过字符串设置对象的属性或方法
print(setattr(foo_obj, "z", 30))
print(hasattr(foo_obj, "z"))        # True


# delatter:通过字符串删除对象的属性或方法
delattr(foo_obj, "x")
print(hasattr(foo_obj, "x"))

反射的扩展例子

# 反射应用:
class FileControl:

    def run(self):
        while True:
            # 让用户输入上传或下载功能的命令
            user_input = input("请输入  上传(upload)或  下载(download)功能:").strip()
            # 通过用户输入的字符串判断方法是否存在,然后调用相应的方法
            if hasattr(self, user_input):
                func = getattr(self, user_input)
                func()

            else:
                print("输入有误")

    def upload(self):
        print("文件正在上传....")

    def download(self):
        print("文件正在下载....")


file_control_obj = FileControl()
file_control_obj.run()

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

java学习---面向对象进阶

python-前方高能-面向对象-进阶3

python-面向对象进阶

进阶面向对象

python学习笔记-面向对象进阶&异常处理

python学习笔记-面向对象进阶&异常处理