python多态方法_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', '没有了'))