day021|python之面向对象进阶1

面向对象进阶

目录

• 面向对象进阶
• 1 继承
  • 1.1 继承入门
    • 1.1.1 继承基础
    • 1.1.2 类的基本使用
  • 1.2 多继承
    • 1.2.1 多继承的基本使用
    • 1.2.2 多继承以后的重复性
  • 1.3 类的类型
    • 1.3.1 新式类
    • 1.3.2 经典类
  • 1.4 继承与抽象
    • 1.4.1 抽象的两个层次
    • 1.4.2 继承
    • 1.4.3 示例
  • 1.5 继承的运用
    • 1.5.1 选课系统
    • 1.5.2 选课系统进阶1.0
  • 1.6 属性查找
    • 1.6.1 对象的属性
    • 1.6.2 案例
  • 1.7 super实现选课系统
  • 1.8 多继承条件下的查找顺序
• 2 派生
  • 2.1 派生基础
  • 2.2 派生的方法
    • 2.2.1 不常用方式
    • 2.2.2 方式一
    • 2.2.3 方式二

1 继承

1.1 继承入门

1.1.1 继承基础

• 什么是继承

  继承是一种新建类的方式，新建的类称为子类，被继承的类称为父类

  继承的特性是：子类会遗传父类的属性和方法

  继承是类与类之间的关系

• 为什么用继承

  可以减少代码冗余

1.1.2 类的基本使用

• 不使用继承

class Animal:
    def run(self):
        print("跑")
    def eat(self):
        print("吃")

class Dog:
    def run(self):
        print("跑")
    def eat(self):
        print("吃")
    def bark(self):
        print("犬吠")

class Person:
    def run(self):
        print("跑")
    def eat(self):
        print("吃")
    def work(self):
        print("工作")

• 使用继承

class Animal:  # Animal作为父类(基类)
    head = 1
    def run(self):
        print("跑")
    def eat(self):
        print("吃")

# Dog子类和Person子类都继承Animal父类
class Dog(Animal):
    def speak(self):
        print("狗吠")

class Person(Animal):
    def work(self):
        print("工作")

dog = Dog()
dog.eat()  # 吃
print(dog.head)  # 1

1.2 多继承

1.2.1 多继承的基本使用

# class Animal():  # 表示没有继承其他类
class Animal():
    def run(self):
        print('走路')

class Coder:
    def work(self):
        print('写代码')

class Person(Animal, Coder):  # 可以继承很多
    def eat(self):
        print("吃饭")

p = Person()
p.run()   # 走路
p.work()  # 写代码
p.eat()   # 吃饭

1.2.2 多继承以后的重复性

• 查找顺序

  对象自己-->类-->父类（先后顺序）

class Animal():
    name = '动物'
    def run(self):
        print('走路')

class Coder:
    name = '社畜'
    def work(self):
        print('写代码')

class Person(Animal, Coder):
    name = 'ccc'
    def eat(self):
        print('吃饭')

p = Person()
p.name = 'zzz'
print(p.name)
# 先看对象自己zzz，没有看类ccc，没有看第一个父类'动物'，没有看后一个父类'社畜'，没有就报错

1.3 类的类型

1.3.1 新式类

• 如果一个类继承了object，那么这个类就是新式类
• python3中所有类都默认继承object（不写也会继承object类），所有类都是新式类

class Student():
    pass
class Teacher(object):
    pass
class School(Student, Teacher):
    pass

# 查看一个类继承了哪些父类用__bases__
print(School.__bases__)  # (<class '__main__.Student'>, <class '__main__.Teacher'>)
print(Teacher.__bases__)  # (<class 'object'>,)
print(Student.__bases__)  # (<class 'object'>,)

1.3.2 经典类

• 没有继承任何父类的类，叫经典类，只有python2才有
• python2中如果要写新式类，需要手动继承object

# 在python2中
class Student(object):  # 新式类
    pass
class Teacher():  # 经典类
    pass
# py2的语法
print Student.__bases__  # (<class 'object'>,)
print Teacher.__bases__  # ()

• 新式类和经典类的属性查找顺序是不一样的

1.4 继承与抽象

1.4.1 抽象的两个层次

• 将对象中比较像的部分抽取成类
• 将类比较像的部分抽取成父类

1.4.2 继承

• 基于抽象的结果，通过编程语言实现他
• 首先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构

1.4.3 示例

class Animal(object):
    def run(self):
        print('走路')

class Human(Animal):
    def work(self):
        print('work')

class Ccc(Human):
    pass

print(Ccc.__bases__)  # (<class '__main__.Human'>,)

1.5 继承的运用

1.5.1 选课系统

• 有学生类、老师类，学生有分数、老师能修改学生分数

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

class Teacher(Person):
    def change_score(self, obj, score):
        obj.score = score

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

ccc = Student('ccc', 20, '男')
print(ccc.__dict__)  # {'name': 'ccc', 'age': 20, 'gender': '男', 'score': 0}

# 将zzz的分数改为100分
zzz = Student('zzz', 18, '女')
teacher = Teacher('ttt', 35, '女')
teacher.change_score(zzz, 100)
print('张三的分数是:', zzz.score)  # 张三的分数是: 100

# 将ccc分数改为96分
teacher.change_score(ccc, 96)
print('ccc的分数是:', ccc.score)  # ccc的分数是: 96

1.5.2 选课系统进阶1.0

1.6 属性查找

1.6.1 对象的属性

• 对象的属性（attribute）：指的是对象的属性和方法

class Student:
    def __init__(self, name):
        self.name = name
    def work(self):
        print('work')

s1 = Student('ccc')
print(s1.name)  # ccc
print(s1.work())  # work None(因为没有返回值，所以打印出来的是None)

1.6.2 案例

• 多层继承关系的属性查找顺序，永远是从最底下开始找起（self.属性）
• 有的情况下ctrl+左键会不准确

class F1(object):
    def s1(self):
        print('F1:s1s1s1')
    def s2(self):
        self.__init__()
        print('F1:s2s2s2')

class F2(F1):
    # def s1(self):
    #     print('F2:s1s1s1')
    def s2(self):
        print('F2:s2s2s2')

class F3(F2):
    # def s1(self):
    #     print('F3:s1s1s1')
    def s2(self):
        self.s1()
        print('F3:s2s2s2')

f3 = F3()
f3.s2()
"""
在自己有s1的情况下:         F3:s1s1s1 F3:s2s2s2
自己没有s1，向父类找s1:     F2:s1s1s1 F3:s2s2s2
父类没有s1，再向父类的父类找:F1:s1s1s1 F3:s2s2s2
"""

1.7 super实现选课系统

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

class Teacher(Person):
    def __init__(self, name, age, gender):
        # self.__init__(name, age, gender) #会出现递归调用，最终报错
        # super(当前类的类名，当前对象) py3以后括号内可以省略
        # super(Teacher, self).__init__()
        super().__init__(name, age, gender)
        self.salary = 1000
    def change_score(self, obj, score):
        obj.score = score

class Student(Person):
    def __init__(self, name, age, gender):
        super().__init__(name, age, gender)
        self.score = 0

teacher = Teacher('ccc', 18, '男')
print(teacher.__dict__)  # {'name': 'ccc', 'age': 18, 'gender': '男', 'salary': 1000}
s1 = Student('zzz', 18, '男')
print(s1.__dict__)  # {'name': 'zzz', 'age': 18, 'gender': '男', 'score': 0}

1.8 多继承条件下的查找顺序

2 派生

2.1 派生基础

• 派生：在子类中新定义的属性和方法，就叫派生
• 父类(基类)、子类(派生类)

class Person:  # 父类,基类
    def run(self):
        print('run')
    def speak(self):
        print('speak')

class Teacher(Person):
    school = 'oldboy'  # 派生属性
    def teach(self):  # 派生方法
        print('教课')

2.2 派生的方法

# 派生类中使用父类的属性和方法
class Person:  # 父类，基类
    school = 'oldboy'
    def run(self):
        print('run')
    def speak(self):
        print('speak')

2.2.1 不常用方式

• 可能存在问题（子类中如果已经有了speak方法，就不会使用父类的）

class Teacher(Person):
    def speak(self):
        print('teacher 的 speak')
    def teach(self):
        # 需要调用父类的speak方法
        self.speak()  # 不是常用方式，此时就不会调用父类的
        print('授课')

teacher = Teacher()
teacher.teach()
# teacher 的 speak
# 授课

2.2.2 方式一

• 指名道姓使用父类的方法

class Teacher(Person):
    def speak(self):
        print('teacher 的 speak')
    def teach(self):
        # 指名道姓用
        Person.speak(self)      # speak
        print('教课')           # 教课
        # 使用父类的属性
        print(Person.school)    # oldboy

teacher = Teacher()
teacher.teach()

2.2.3 方式二

• 通过super关键字（super是一个特殊对象，代指父类对象）

class Teacher(Person):
    def speak(self):
        print('teacher 的 speak')
    def teach(self):
        super().speak()         # speak
        print(super().school)   # oldboy

teacher = Teacher()
teacher.teach()