今日内容

单继承下的属性查找

class Foo:
    def __f1(self): # _Foo__f1()
        print(‘Foo.f1‘)
?
    def f2(self):
        print(‘Foo.f2‘)
        self.f1() # self._Foo__f1()
?
class Bar(Foo): # _Bar__f1()
    def __f1(self):
        print(‘Bar.f1‘)
?
obj = Bar()
obj.f2()

多继承下的属性查找

多继承分为经典类和新式类

菱形继承：

经典类是深度优先

新式类是广度优先（python3中全是新式类）

非菱形继承：

经典类和新式类，属性查找没有顺序要求，都一样

#新式类
class G:
    def test(self):
        print(‘from G‘)
?
?
class E(G):
    def test(self):
        print(‘from E‘)
?
?
class F(G):
    def test(self):
        print(‘from F‘)
?
?
class D(G):
    def test(self):
        print(‘from D‘)
?
?
class B(E):
    def test(self):
        print(‘from B‘)
?
?
class C(F):
    def test(self):
        print(‘from C‘)
?
?
class A(B, C, D):
    def test(self):
        print(‘from A‘)
?
?
f1 = A()
f1.test()
print(A.__mro__)
A--->B--->E--->C--->F--->D--->G
最后去最深的一个非obj的类里找

super与mro

子类想使用父类的属性：
第一种办法：指名道姓
第二种方法：super（）
class people()
    schOOl = "SH"
    def __init__(self, name, age):
        self.name = name
        self.age = age
?
class Student(people):
     
    def __init__(self, name, age, course):
        super().__init__(name, age)
        # People.__init__(self, name, age）
        self.course = course
   
    
    def choose_course(self,course):
        self.course.append(course)
        print(‘%s 选课成功 %s‘ % (self.name, self.courses))
        
class Teacher(people):
    def __init__(self,name, age, level):
        super().__init__(name, age)
        # People.__init__(self, name, age)
        self.level = level
    
    def score(self, stu_obj, num):
        stu_obj.num = num
        print(‘%s老师给%s打了%s分‘ % (self, name, stu_obj, num))
        
        
obj = Student()
print(obj.name)
print(obj.age)
?
?
# 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()
c.test() 
print(C.mro())
#打印结果:
‘‘‘
A---->test
B---->aaa
[<class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘__main__.B‘>, <class ‘object‘>]
‘‘‘
a = A()
A.test() # A---->test 然后报错，因为没有aaa

模块安装

模块地址：https://pypi.org/project/pip/
安装安装包：
pip install SomePackage              # 最新版本
pip install SomePackage==1.0.4       # 指定版本
pip install ‘SomePackage>=1.0.4‘     # 最小版本
卸载包
pip uninstall SomePackage
或者在pycharm里面安装

多态与多态性

多态：一种事物的多种状态
?
继承：解决冗余问题（双刃剑，继承太多也不好）
多态类中的继承：不是让子类遗传父类的属性和方法，是用来给子类定制标准的
import abc # abstract => 抽象
?
# 该类已经是抽象类了(子类只要继承必须实现，父类中不实现)
class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod # (子类只要继承必须实现，父类中不实现)
    def speak(self):
        pass
    def run(self):
        pass
?
class People(Animal):
    def speak(self):
        pass
?
class Dog(Animal):
    def speak(self):
        pass
?
class Pig(Animal):
    def speak(self):
        pass
?
?
obj1 = People()
obj2 = Dog()
obj3 = Pig()
?
?
鸭子类型：约定俗成同时都有某一功能，下次只要有人调用这个功能就是一个父类 （看起来像，叫起来像，就是鸭子）
class People(Animal):
    def speak(self):
        pass
?
class Dog(Animal):
    def speak(self):
        pass
?
class Pig(Animal):
    def speak(self):
        pass
    
多态性:多态带来的特性，在不用考虑对象数据类型的情况下，直接调用对象的方法
    
len()就是多态的测量出多个数据类型的长度
?
class People(Animal):
    def speak(self):
        pass
?
class Dog(Animal):
    def speak(self):
        pass
?
class Pig(Animal):
    def speak(self):
        pass
    
obj1 = People()
obj2 = Dog()
obj3 = Pig()
?
def animel(animel):
    return animel.speak()
?
animel(obj1)

7.14学习日记