Python基础—12-面向对象（02）

面向对象

面向对象三大特点

• 封装：既可对数据结构进行封装，又可对处理数据的方法进行封装
• 继承：强调的父子类的关系
• 多态：不同对象调用相同的方法，会有不同的响应

类的继承

• 相关概念

  • 继承：父类的属性和方法，子类直接拥有，称为继承
  • 派生：子类在父类的基础上衍生出新的特征(属性和行为)
  • 总结：其实他们是一回事，只是描述问题的侧重点不同(继承强调相同点，派生强调不同点)

• 继承语法

  # class Animal(object):
  # 当没有指定父类时，默认继承object
  class Animal:
      def __init__(self, name):
          self.name = name
  
      def eat(self):
          print('小动物喜欢一天到晚出个不停')
  
  # 继承自Animal
  class Dog(Animal):
      pass
  
  d = Dog('旺财')
  # 可以拥有父类的方法
  d.eat()
  # 也可以拥有父类的属性
  print(d.name)

• 派生示例

  class Animal:
      def run(self):
          print('小动物喜欢成天跑个不停')
  
  class Cat(Animal):
      def eat(self):
          print('猫喜欢吃老鼠')
  
  tom = Cat()
  
  tom.run()
  # 多出来的行为
  tom.eat()
  
  # 多出来的属性
  tom.color = '蓝色'
  print(tom.color)

• 重写方法

  • 若父类的方法完全不合适，可以进行覆盖重写
  • 若父类的方法不够完善，可以添枝加叶进行完善
  • 示例：

  class Animal:
      def eat(self):
          print('小动物一天到晚的出个不停')
  
      def run(self):
          print('小动物一天到晚的四处连跑')
  
  class Cat(Animal):
      # 父类的方法完全不合适，覆盖重写
      def run(self):
          print('俺走的是猫步')
  
      # 父类的方法部分合适，需要添加内容进行完善
      def eat(self):
          # 保留父类的内容，不建议使用此方式
          # Animal.eat(self)
          # super(Cat, self).eat()
          # 类名及self可以不传
          super().eat()
          print('不过俺喜欢吃鱼')
  
  jiafei = Cat()
  jiafei.run()
  jiafei.eat()

• 多继承：一个子类可以拥有多个父类

  class A:
      def eat(self):
          print('eat func in class A')
  
  class B:
      def eat(self):
          print('eat func in class B')
  
  class C(A, B):
      def eat(self):
          # 这种方案是默认的继承顺序进行选择的父类方法
          # super().eat()
          # 人为指定调用某个父类的方法
          B.eat(self)
  
  c = C()
  c.eat()

访问权限

• 权限

  • 公有的：类中的普通的属性和方法，默认都是公有的；可以在类内、类外、子类中使用
  • 私有的：定义时在前面添加两个'_'，就变成了私有的；只能在类内使用，不能在类外及子类中使用

• 示例：

  class Person:
      def __init__(self, name):
          self.name = name
          self.__age = 20
  
      def eat(self):
          print('民以食为天')
  
      def __test(self):
          print('__test')
  
  xiaoming = Person('小明')
  print(xiaoming.name)
  xiaoming.eat()
  # 不能在类外使用
  print(xiaoming.__age)
  xiaoming._Person__test()
  print(xiaoming.dict)
  # 尽管可以这样访问私有属性，但是强烈建议不要这样使用
  print(xiaoming._Person__age)
  
  class Man(Person):
      def introduce(self):
        # 不能在子类中使用
        # print(self.__age)
        print('我叫{}'.format(self.name))
        self.eat()   
  
  m = Man('诸葛')
  m.introduce()

类属性

• 说明：定义类时，写在方法外的属性，通常会写在类的开头，这样的属性称为类属性

• 示例：

  class Person:
        # 类属性，通过类名访问，属于整个类，而不是某个对象
        # nation = '中国'
  
        # 限制可以使用的属性，提高访问的效率
        # 也可以提高访问速度，减少内存使用
        __slots__ = ('name', 'age', 'nation')
  
        def __init__(self, name):
            self.name = name
            self.nation = 'china'
  
  p1 = Person('小明')
  p2 = Person('小红')
  print(p1.name, p2.name)
  print(Person.nation)
  # p1.nation = 'china'
  print(p1.nation)
  print(p2.nation)
  # print(Person.nation)
  
  p1.age = 20
  # p1.height = 180
  
  # 特殊的类属性
  # 表示类名的字符串
  print(Person.__name__)
  
  # 表示父类构成的元组
  print(Person.__bases__)
  
  # 存储类的相关信息
  print(Person.__dict__)
  
  # 限制可以使用的属性
  print(Person.__slots__)

类方法

• 说明：

  • 定义时使用classmethod装饰器装饰的方法
  • 使用时通过类名调用

• 作用：

  • 可以创建对象或者简洁的创建对象
  • 对外提供简单易用的接口

• 示例1：创建对象

  class Person:
        def eat(self):
            print('我喜欢吃麻辣烫，不要麻椒和辣椒')
  
        @classmethod
        def test(cls):
            print(cls)
            print('类方法')
  
        # 创建对象，或者简洁的创建对象
        @classmethod
        def create(cls):
            p = cls()
            p.age = 1
            return p
  
    p1 = Person()
    p1.eat()
  
    # 通过类名调用
    Person.test()
    # 创建或简洁的创建对象
    p2 = Person.create()
    print(type(p2))  

• 示例2：提供接口

  class Number:
      def __init__(self, num1, num2):
          self.num1 = num1
          self.num2 = num2
  
      def add(self):
          return self.num1 + self.num2
  
      def sub(self):
          return self.num1 - self.num2
  
      def mul(self):
          return self.num1 * self.num2
  
      def div(self):
          if self.num2 == 0:
              return None
          return self.num1 / self.num2
  
      # 对外提供简单易用的接口
      @classmethod
      def pingfanghe(cls, num1, num2):
          n1 = cls(num1, num1)
          n12 = n1.mul()
  
          n2 = cls(num2, num2)
          n22 = n2.mul()
  
          n3 = cls(n12, n22)
          return n3.add()
  
  he = Number.pingfanghe(3, 4)
  print(he)

静态方法

• 说明：

  • 使用staticmethod装饰器装饰的方法(方法没有cls参数)
  • 通过类名进行调用

• 示例：

  class Person:
      @staticmethod
      def test():
          print('static method test')
  
      # 创建对象
      @staticmethod
      def create():
          p = Person()
          return p
  
  Person.test()
  p = Person.create()
  print(p) 

• 总结：

  • 凡是静态方法完成的功能都可以是类方法完成
  • 若方法中没有使用到类名(cls)，可以使用静态方法

多态特性

• 定义：不同的对象，调用相同的方法，有不同的响应，称为多态

• 示例：

  class Animal:
      def run(self):
          pass
  
  class Dog(Animal):
      def run(self):
            print('狗通常走S型')
  
  class Cat(Animal):
      def run(self):
            print('猫平时走猫步，偶尔突然加速')
  
  def test(obj):
      obj.run()
  
  d = Dog()
  c = Cat()
  test(d)
  test(c)

属性函数

• 说明：将成员方法当做属性一样进行访问

• 作用：保护特定属性，或者对特定属性进行处理

• 示例：

  class User:
        def __init__(self, username, password):
            self.username = username
            self.__password = password
  
        # 该方法可以像成员属性一样访问
        @property
        def password(self):
            print('有人想查看密码')
            return '想偷看密码，没门'
            # return self.__password
  
        # 在设置密码时，会自动调用
        @password.setter
        def password(self, password):
            print('@password.setter', password)
            self.__password = '加密' + password + '加密'
  
  u = User('xiaoming', '')
  # print(u.password())
  print(u.password)
  
  # 设置密码，会自动调用setter方法
  u.password = 'abcde'