Python语法进阶篇 --- 封装、继承、多态

🐹🐹🐹🐹🐹一只正在努力学习计算机技术的小仓鼠🐹🐹🐹🐹🐹

面向对象的三大特征：封装、继承、多态

封装

• 概念：封装指将对象中的属性和方法包起来，这些属性和方法只能在对象内部处理，即隐藏对象中不希望被外部访问的属性或方法。封装有助于保证数据的安全性和代码的可维护性。
• 属性分类：
  • xxx：普通属性/方法。在类中，该属性/方法允许在任何地方使用。
  • _xxx：私有属性/方法。在类中，该属性/方法允许外部使用，允许子类继承，但是在另一个.py文件通过from xxx import *无法导入私有属性。一般为了避免与Python关键字冲突而命名的方法。
  • __xxx：隐藏属性/方法。在类中，该属性/方法不允许外部直接访问，不允许子类继承，且在另一个.py文件通过from xxx import *也无法导入隐藏属性。

class Human:hand = 2foot = 2_habit = '吃喝玩乐'__feature = '高等动物'# 普通方法def introduce(self):# 在实例方法中访问隐藏属性Human.__feature = '会学习、会思考的高等动物'print(f'Human is {self.__feature}')# 私有方法def _creature(self):print('Human is in the top of food chain')# 隐藏方法def __disposition(self):print('Human is kindness when they were born')# 直接从实例中调用隐藏方法def getDisposition(self):self.__disposition()
human = Human()
# 访问对象里的普通属性
print(f'Human has {human.hand} hands')
# 访问对象里的私有属性
print(f'Human like {human._habit}')
# 访问对象里的隐藏属性
human.introduce()
# 访问对象里的私有方法
human._creature()
# 访问对象里的隐藏方法
human.getDisposition()

继承

• 概念：类和类之间形成父子关系，子类默认继承父类的所有属性和方法（__init__除外）。
• 单继承

  class Person:
  behaviour = ['eat', 'drink', 'think']
  def create(self):print('Person created')# Person类的子类Girl
  class Girl(Person):def gender(self):print('this is Girl')
  girl = Girl()
  print(girl.behaviour)
  girl.gender()
  

• 多重继承
  • 继承的传递性：子类拥有父类及父类的父类中的属性和方法。
  • A|B(A)|C(B) → C继承B，B继承A → C类同时拥有A类和B类的属性和方法。

  class Grandfather():identify = '爷爷'def identity(self):print(f'{self.identify}')
  class Father(Grandfather):identify = '爸爸'def eat(self):print('I can eat')
  class Son(Father):identify = '儿子'def drink(self):print('I can drink')
  son = Son()
  son.identity()
  

• 方法重写
  • 概念：如果从父类继承的方法不能满足子类的需求，可以在子类中重写父类的方法，这个过程称为方法重写。
  • 覆盖父类方法

    class Person:def money(self):money = 100print(f'{money}需要继承')
    class Man(Person):def money(self):money = 1000print(f'可以继承{int(money*0.8)}元')
    man = Man()
    man.money()
    

  • 扩展父类方法
    • 第一种方式（推荐）：super().方法名()
    • 第二种方式：super(子类名,self).方法名()
    • 第三种方式：父类名.方法名()

    class Father:def money(self):money = 10000print(f'继承款：{money}')
    class Man(Father):def money(self):super().money()my_money = 20000print(f'存款：{my_money}')
    man = Man()
    man.money()
    

• 新式类
  • 概念：继承object类或者该类的子类都是新式类。object类是所有对象的基类，提供了一些内置的属性和方法，可以使用dir查看。在python3中，如果一个类没有继承任何类，则默认继承object类。

  class A(object):pass
  print(dir(object))
  

• 多继承
  • 概念：子类可以拥有多个父类，并且具有所有父类的属性和方法。开发时应避免不同的父亲具有同名方法

    class Father(object):def money(self):print('拥有一百万可以继承')
    class Mother(object):def appearance(self):print('绝世容颜可以继承')def money(self):print('拥有一亿财产')
    class Son(Father, Mother):pass
    son = Son()
    son.appearance()
    # 多个父类中存在方法同名的情况时，调用第一个父类中的实例方法
    son.money()
    # python中内置的属性__mro__可以查看方法的搜索顺序
    print(Son.__mro__)
    

  • 弊端
    • 容易引起冲突
    • 代码设计复杂度增加

多态

• 概念：一个对象具有多种形态，在不同的使用环境中以不同的形态展示其功能，那我们就称该对象具有多态性。
• 前提条件：继承、重写
• 特点
  1. 不关注对象的类型，关注对象具有的行为，也就是对象的实例方法是否同名。
  2. 多态的好处可以增加代码的外部调用灵活度，让代码更加通用，兼容性比较强。
  3. 不同的子类对象，调用相同的父类方法，会产生不同的执行结果。

class Animal(object):def shout(self):print('动物会叫')
class Cat(Animal):def shout(self):print('喵喵喵')
class Dog(Animal):def shout(self):print('汪汪汪')
cat = Cat()
dog = Dog()
cat.shout()
dog.shout()# 定义一个统一的接口，实现一种调用方式得到不同的执行结果
class Animal(object):def eat(self):print('我会干饭')
class Pig(Animal):def eat(self):print('我吃西瓜')
class Dog(Pig):def eat(self):print('我吃狗粮')
# test函数充当接口，以对象为变量，执行不同对象的eat方法
def test(obj):obj.eat()
animal = Animal()
test(animal)
pig = Pig()
test(pig)