• 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', '111111')
      # print(u.password())
      print(u.password)
      
      # 设置密码,会自动调用setter方法
      u.password = 'abcde'    
  • 相关阅读:
    Day 19
    Day 18
    Day17
    Day 16
    正则表达式(仅可输入中文英文数字以及英文逗号)
    Linux安装Nginx 并搭建图片服务器
    Mysql创建用户表并利用存储过程添加100万条随机用户数据
    Dubbo(高性能、轻量级的开源Java RPC框架) & RPC(远程过程调用)
    Redis
    OSI (开放系统互联(Open System Interconnection))
  • 原文地址:https://www.cnblogs.com/swjblog/p/9677658.html
Copyright © 2020-2023  润新知