python多态和一些内置方法

python多态和一些内置方法

什么是多态：

多态指的是同一种类型的事物，不同的形态

多态的目的：

“多态”也称之为“多态性”，目的是为了在不知道对象具体类型的情况下，同一对象调用方法的规范（比如：名字）

 

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

先抽象，在继承

 

父类：定制一套统一的规范。（比如：方法的统一）

子类：遵循父类的统一规范。 （比如：子类遵循父类方法名的统一）

注意：在python中不会强制限制子类， 必须要遵循父类的规范，所以出现了抽象类。

​
​
# 动物类
class Animal:
    def eat(self):
        pass
​
    def speak(self):
        pass
​
class Pig(Animal):
    def eat(self):
        print('吧唧 吧唧...')
​
​
class Cat(Animal):
    def eat(self):
        print('喵喵喵...')
​
class Dag(Animal):
    def eat(self):
        print('汪汪汪...')
​
a1 = Pig()
a2 = Cat()
a3 = Dag()
​
a1.eat()
a2.eat()
a3.eat()

抽象类

什么是抽象类？

在python内置中的abc模块中，有一个抽象类。

抽象类的作用：

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

如何实现抽象类

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

在父类的方法中，需要装饰上 abc.abseractmethod

 

注意： 在python中不推荐使用抽象类

 

自己不虚按照父类的方法编写规范，缺一不可。

（只要父类中有几个抽象方法，子类就必须要定义几个）

import abc
​
​
# 父类
class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def eat(self):
        pass
​
    @abc.abstractmethod
    def speak(self):
        pass
​
​
class Pig(Animal):
    def eat(self):
        print('biajibiaji ')
​
    def speak(self):
        print('哼哼哼')
​
a1 = Pig()
​
a1.eat()
a1.speak()

鸭子类型

什么是鸭子类型：

不同的对象，只要长得像鸭子， 动作行为像鸭子，那它就是鸭子

鸭子是多态的一种表现形式

为什么要有鸭子类型： 不同对象，先抽象出相同的类型的方法， 给他们制定一套统一的规范，

所有的类，在定义是都按照统一的规范进行书写

多态的三种表现形式

1、继承父类 ***

2、继承抽象类 ***

3、鸭子类型 **** 耦合度低， 程序可扩展性高

 

注意：在python中，强烈推荐使用鸭子类型

 

lass 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('汪汪汪...')
​
​
dog = Dog()
pig = Pig()
cat = Cat()
​
# dog.speak()
# pig.speak()
# cat.speak()
​
​
# 多态之炫技
def SPEAK(animal):
    animal.speak()
    
    
# SPEAK(dog)
# SPEAK(pig)
# SPEAK(cat)
​

classnethod和staticmethod

classnethod和staticmethod都是python解释器的内置装饰器（重要）

classmethod:

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

staticmethod:

翻译：静态方法

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

对象的绑定方法：

由对象来调用，由谁来调用，会将谁（对象）当做第一个参数传入

类的绑定方法： 由类来调用，由谁来调用，会将谁（类）当做第一个参数传入

非绑定方法：

可以由对象或类来调用，谁来调用都是一个普通方法（普通函数）， 方法需要传入几个参数，就要传入几个

class DB:
    __data = 'haowuliaoa'
    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 == 'jinyi' and obj.pwd == '123' and obj.role == 'admin':
            print('检验通过')
            print(cls.__data)
            return cls.__data
        else:
            print('验证不通过')
​
DB.check_db('jinyi', '123', 'admin')
​
​
​
class Foo:
    @staticmethod
    def func(res):
        print(res)
​
obj = Foo()
​
# 对象调用非绑定方法
obj.func(123)
​
# 类调用非绑定方法
Foo.func(123)

isinstance与issubclass

isinstance与issubclass是python的内置模块

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

如果是：True

如果不是：False

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

如果是：Ture

如果不是：False

class Feacher:
    pass
​
class Sub(Feacher):
    pass
​
​
class Foo:
    pass
​
​
print(issubclass(Foo, Feacher))
print(issubclass(Sub, Feacher))
​

反射

反射指的是通过“字符串”对对象的属性进行操作

---

hasattr：通过“字符串”判断对象的属性或方法是否存在

getattr：通过“字符串”获取对象的属性或方法

setattr：通过“字符串”设置对象的属性或方法

delattr：通过“字符串”删除对象的属性或方法

 

注意：反射的四个方法是python中内置的

class Foo:
    def __init__(self, x, y):
        self.x = x
        self.y = y
​
obj = Foo(10, 20)
​
# hasattr: 通过 “字符串” 判断对象的属性或方法是否存在。
# 判断
print(hasattr(obj, 'x'))
​
# getattr: 通过 “字符串” 获取对象的属性或方法。
# 查
print(getattr(obj, 'y'))
res = getattr(obj, 'q', '不存在')
print(res)
​
# setattr: 通过 “字符串” 设置对象的属性或方法。
# 增  改
setattr(obj, 'q', 30)
print(getattr(obj, 'q'))
​
# delattr: 通过 “字符串” 删除对象的属性或方法。
delattr(obj, 'q')
print(getattr(obj, 'q', '没有了'))