python学习 day26之高阶面向对象

在子类派生的新方法中重用父类功能的方式二

• 方式一：指名道姓地调用某一个类的函数
• 方式二：调用super(自己的类名,self)会返回一个特殊的对象,super(自己的类名,self).属性,会参照属性查找发起的那个类的mro列表去它父类中查找属性
  特点： 严格依赖于继承关系

class A:
    def test(self):
        print('A---->test')
        super().aaa()
class B:
    def test(self):
        print('B---->test')

    def aaa(self):
        print('B---->aaa')

class C(A,B):
    def aaa(self):
        print('C----->aaa')

c=C()
print(C.mro())
c.test()
"""
A---->test
B---->aaa
"""

组合:把另外一个类的对象赋值给当前对象的属性

组合表达的是一种有的关系

class Teacher:
    def __init__(self, name, age, gender, level):
        self.name = name
        self.age = age
        self.gender = gender
        self.level = level

    def tell(self):
        print("%s:%s" % (self.name, self.age))

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

class Course:
    def __init__(self, name, price, period):
        self.name = name
        self.price = price
        self.period = period

    def tell(self):
        print('<%s:%s:%s>' % (self.name, self.price, self.period))

tea1 = Teacher("egon", 18, "male", 10)
stu1 = Student("xxx", 19, "male")

python = Course("python开放", 30000, "3mons")
linux = Course("linux课程", 30000, "3mons")

tea1.courses = [python,linux]
stu1.course = python

# tea,stu  # 超级对象

# stu1.course.tell()
for course_obj in tea1.courses:
    course_obj.tell()

多态性与鸭子类型

同一种事物有多种形态
例如:动物这种事物有多种形态,如人\狗\猪

但其实我们完全可以不依赖于继承，只需要制造出外观和行为相同对象，同样可以实现不考虑对象类型而使用对象，这正是Python崇尚的“鸭子类型”（duck typing）：“如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子”。比起继承的方式，鸭子类型在某种程度上实现了程序的松耦合度

• 特性: 我们可以在不考虑某一个对象具体类型的前提下,直接使用该对象

父类有的功能,子类一定有:

import abc

class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def speak(self):
        pass

    @abc.abstractmethod
    def run(self):
        pass


Animal()  # Animal的作用是用来制定标准的

class People(Animal):
    def speak(self):
        print("啊啊啊啊")

    def run(self):
        print("咻咻咻...")

class Dog(Animal):
    def giao(self):
        print("汪汪汪")

class Pig(Animal):
    def heheng(self):
        print("哼哼哼")

peo1=People()
d1=Dog()
p1=Pig()

peo1.jiao()
d1.giao()
p1.heheng()




peo1.speak()
d1.speak()
p1.speak()

def speak(animal):
    animal.speak()

speak(peo1)
speak(d1)

speak(p1)

鸭子类型🦆

class People:
    def speak(self):
        print("啊啊啊啊")

    def run(self):
        print("咻咻咻...")

class Dog:
    def speak(self):
        print("汪汪汪")

    def run(self):
        print("狂奔...")

class Pig:
    def speak(self):
        print("哼哼")

    def run(self):
        print("咣咣咣...")

peo1=People()
d1=Dog()
p1=Pig()

peo1.run()
d1.run()
p1.run()

内置函数

isinstance(x, (type, ……))：判断x是否为形参元组中的众多类型的一种，符合返回True，不符合返回False

issubclass(class1, class2)：判断class1是否是class2的子类，class1 == class2时也返回True

类相关的内置方法

str：在print含有该方法的对象时执行

class People:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        # print('===>')
        return "<%s:%s>" %(self.name,self.age)

obj = People("egon", 18)

print(obj)  # print(obj.__str__())

del：在数据从内存被清除时执行

class People:
    def __init__(self, name, age,f):
        self.name = name
        self.age = age
        self.f = f

    def __del__(self):
        print('===>')
        # 回收资源
        self.f.close()

obj = People("egon", 18,open("a.txt",'w',encoding='utf-8'))

反射

通过字符串的方法名，来增删改查对象内的属性

举例开始：有这么个类，生成了Foo这么个对象：

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

    def f1(self):
        print('from f1')

obj = Foo(111, 222)

用字符串操作对象内属性：

res = dir(obj)  # 拿到对象内所有方法名的字符串
print(res)
print(obj.__dict__[res[-1]])  # 拿到对象内最后定义的那个属性
print(obj.__dict__['x'])  # 查看对象内名为x的属性

内置函数：hasattr，getattr，delattr， hasattr（重点*****）

import re

for attr in dir(obj):
    if not re.search("^__.*__$",attr):
        res=getattr(obj,attr)
        print(res)

print(hasattr(obj,'x'))  # 判断对象内是否有属性x
print(getattr(obj,'xxx',None))  # obj.xxx ，没有则返回None，默认会报错
setattr(obj,"xxx",1111)  # obj.xxx = 1111

delattr(obj,"xxx")  # del obj.xxx 新增属性

额外一嘴之import字符串

m=__import__("time")  # import time as m