面向对象进阶
面向对象——多态
什么是多态？
多态是同一种事物，不同的形态
多态的目的？
多态也称为多态性，目的是为了在不知道对象具体类型的情况下，统一对象调用方法的规范（例如：名字）
多态的表现形式之一就是继承
先抽象，再继承
父类：定制一套统一的规范
子类：遵循父类的统一规范
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()
