• Python之第十一章 面向对象 --- 三大特征

    目录

    Python之第十一章 面向对象 --- 三大特征

    面向对象三大特征 --- 封装

    1.在Python代码中，封装有两层含义：

    2.封装中的私有属性和私有方法

    3.私有属性的访问限制

    4.私有属性设置与访问接口

    5.私有方法

    6.封装的意义

    7.@property装饰器封装

    面向对象三大特征 --- 继承

    1.继承的基本概念

    2.名词解释

    3.继承的基本语法

    4.单继承

    5.多继承

    6.方法重写

    7.super关键字

    面向对象三大特征 --- 多态

    1.概念

    2.实例

    3.优点

    Python之第十一章 面向对象 --- 三大特征

    面向对象三大特征 --- 封装

    1.在Python代码中，封装有两层含义：

            把现实世界中的主体中的属性和方法书写到类的里面的操作，这种操作称为封装

    1. class Person():
    2.     # 封装属性
    3.     # 封装方法

    注意：

            封装可以为属性和方法添加私有权限

    2.封装中的私有属性和私有方法

            属性和方法分类 ---

                    公有（属性、方法）：无论在类的内部还是外部都可以对属性和方法进行操作

                    私有（属性、方法）：外部直接应用或修改类内部的数据不安全，所以不允许在类的外部对类内部的属性和方法进行操作 --- 通过封装私有属性或方法实现

    3.私有属性的访问限制

            方法 --- 在属性名或方法名前面增加两个下划线

            例：

    1. class Girl():
    2.     def __init__(self, name):
    3.         self.name = name
    4.         self.__age = 18  # 私有属性
    5. ​
    6. ​
    7. fangfang = Girl('方方')
    8. print(fangfang.name)
    9. print(fangfang.__age) # 报错 无法访问

    注意：

            以上代码运行可知，私有属性不能在类的外部访问，若需要在外部访问私有属性可以通过定义访问接口（函数）来实现

            类中的私有属性和方法不能被类继承

    4.私有属性设置与访问接口

            Python中一般定义函数名为‘get_xx’都是用来获取私有属性，通过‘set_xxx’来修改私有属性

            例：

    1. class Girl():
    2.     def __init__(self, name):
    3.         self.name = name
    4.         self.__age = 18  # 私有属性
    5. ​
    6.     def get_age(self):  # 用于引用访问属性
    7.         # 本人访问时直接访问
    8.         # 外人访问时加上限制条件
    9.         return self.__age
    10. ​
    11.     def set_age(self, age):  # 用于修改属性
    12.         self.__age = age
    13. ​
    14. ​
    15. fangfang = Girl('方方')
    16. fangfang.set_age(19)
    17. ​
    18. print(fangfang.name)
    19. ​
    20. print(fangfang.get_age())

    5.私有方法

            定义方式与私有属性基本一致，在方法名前面增加两个下划线 _ _ 方法名（）

    6.封装的意义

            封装数据属性 --- 明确区分内外，控制外部对隐藏的属性进行操作

            例：

    1. class People():
    2.     def __init__(self, name, age):
    3.         self.__name = name
    4.         self.__age = age
    5. ​
    6.     def tell_info(self):
    7.         print('Name:<%s> Age:<%s>' % (self.__name, self.__age))
    8. ​
    9.     def set_info(self, name, age):
    10.         if not isinstance(name, str):  # isinstance()判断name是否为字符串
    11.             print('名字必须为字符串类型')
    12.             return
    13.         if not isinstance(age, int):  # 判断age是否为整数型
    14.             print('年龄必须为数字')
    15.         self.__name = name
    16.         self.__age = age
    17. ​
    18. ​
    19. p = People('jack', 18)
    20. p.tell_info()
    21. ​
    22. p.set_info('andy', 10)
    23. p.tell_info()
    24. ​
    25. p.set_info(123, 19)
    26. p.tell_info()
    27. ​
    28. 结果：
    29. Name: Age:<18>
    30. Name: Age:<10>
    31. 名字必须为字符串类型
    32. Name: Age:<10>

            封装方法的意义 --- 降低程序复杂度

    1. class Atm:
    2.     def __card(self):
    3.         print('请插卡')
    4. ​
    5.     def __auth(self):
    6.         print('用户认证')
    7. ​
    8.     def __input(self):
    9.         print('请输入取款金额：')
    10. ​
    11.     def __print_bill(self):
    12.         print('打印账单')
    13. ​
    14.     def __take_money(self):
    15.         print('取款')
    16. ​
    17.     def withdraw(self): # 定义一个对外提供服务的公共方法
    18.         self.__card()
    19.         self.__auth()
    20.         self.__input()
    21.         self.__print_bill()
    22.         self.__take_money()
    23. ​
    24. ​
    25. atm = Atm()
    26. atm.withdraw()

    7.@property装饰器封装

            作用 --- 通过@property装饰器讲一个方法转为属性，从而实现用于计算的属性，转换后可以通过方法名来访问，不需要小括号，代码更简洁

            格式 ---

    1. @property
    2. def 方法名(self):
    3.     方法体

    方法名要求小写，最后作为属性名存在

    方法体中一般return结束

            例

    1. class Rect():
    2.     def __init__(self, width, height):
    3.         self.width = width
    4.         self.height = height
    5. ​
    6.     @property
    7.     def area(self):
    8.         return self.width * self.height
    9. ​
    10. ​
    11. rect = Rect(600, 800)
    12. print('面积为：', rect.area)  # 调用时方法名变为属性，不需要小括号

    面向对象三大特征 --- 继承

    1.继承的基本概念

            类是用来描述现实世界中同一组事物的共有性的抽象模型

            类也有上下级和范围之分，如：生物->动物->不如动物->灵长类动物->人类->黄种人

            描述共性和个性之间的关系

    2.名词解释

            继承 --- 一个类从另一个已有的类获得其他成员的相关特性，称为继承

            派生 -- 从一个已有的类产生一个新的类，称为派生

    注意：

            继承和派生其实是从不同角度方向来描述相同的概念，本质上为一个东西

            父类 --- 也称为基类，就是指已有被继承的类

            子类 --- 也称为派生类和扩展类

            扩展 --- 在子类中增加一些自己特有的特性，称为扩展，没有扩展则继承无意义

            单继承 --- 一个类只能继承自一个其他的类，不能继承多个其他类。使用较多

            多继承 --- 一个类共同继承了多个父类

    3.继承的基本语法

            假设A类要继承B类中的所有属性和方法（私有除外）

    1. class B(object):
    2.     pass
    3. ​
    4. ​
    5. class A(B): # A继承B
    6.     pass
    7. ​
    8. a = A()

    例：Person类与Teacher、Student类之间的继承

    1. class Person(object):
    2.     def eat(self):
    3.         print('i an eat food !')
    4. ​
    5.     def speak(self):
    6.         print('i can speak !')
    7. ​
    8. ​
    9. class Teacher(Person):  # 继承Person类
    10.     pass
    11. ​
    12. ​
    13. class Student(Person):
    14.     pass
    15. ​
    16. ​
    17. teacher1 = Teacher()
    18. teacher1.eat()
    19. teacher1.speak()
    20. ​
    21. student1 = Student()
    22. student1.eat()
    23. student1.speak()

    4.单继承

            单继承 --- 一个类能继承自一个其他类，不能多继承

            格式 ---

    1. 1.定义一个父类
    2. class Person（object）：
    3.     pass
    4.     
    5. 2.定义一个子类
    6. class Teacher(Person):
    7.     pass

            类object --- 类object是所有类的父类，在该类中定义了所有类的公有默认方法，如：new( )、 init( )，当定义类时，只有类名没有继承相关参数，此时可以省略object

            单继承 --- 具有传递性 如：A类继承B类，B类继承C类，根据传递性，A类也就会自动继承C类中的所有公共属性和方法。

    5.多继承

            定义 --- Python少数几个支持多继承的语言，允许一个类继承多个类

            格式 ---

    1. class B(object):
    2.     pass
    3.     
    4. class C(object):
    5.     pass
    6.     
    7. class A(B,C):
    8.     pass

            例：

    1. class GasolineCar(object):  # 汽油车
    2.     def run_with_gasoline(self):
    3.         print('I can with gasoline')
    4. ​
    5. ​
    6. class EletriCar(object):  # 电动车
    7.     def run_with_eletric(self):
    8.         print('I can with eletric')
    9. ​
    10. ​
    11. class HybridCar(GasolineCar, EletriCar):
    12.     pass
    13. ​
    14. ​
    15. tesla = HybridCar()
    16. tesla.run_with_eletric()
    17. tesla.run_with_gasoline()
    18. ​

    注意：

            尽量少用多进程，容易造成名称冲突

    6.方法重写

            扩展特性 --- 继承让子类拥有了父类的所有公共属性和方法，但如果仅仅是为了继承属性和方法就失去了继承的意义，应该子类拥有自己的属性和方法

            重写 --- 也叫做覆盖，子类成员与父类成员名字相同时，从父类继承的成员会重新定义，此时起效的为子类中定义的成员

    注意：

            类方法的调用顺序 --- 先在子类中查找，若找不到则在父类中查找

    7.super关键字

            super（）--- 调用父类属性和方法

            完整的写法：

    super(当前类名称，self).属性或方法（）

            Python3版本以后

    1. super().属性
    2. # 或
    3. super()方法名()

            例：Car

    1. class Car(object):
    2.     def __init__(self, brand, model, color):
    3.         self.brand = brand
    4.         self.model = model
    5.         self.color = color
    6. ​
    7.     def run(self):
    8.         print('I can run')
    9. ​
    10. ​
    11. class GasolineCar(Car):  # 继承Car类
    12.     def __init__(self, brand, model, color):
    13.         super().__init__(brand, model, color)  # 调用父类Car的__init__()方法
    14. ​
    15.     def run_with_gasoline(self):
    16.         print('I can with gasoline')
    17. ​
    18. ​
    19. class EletriCar(Car):  # 电动车父类
    20.     def __init__(self, brand, model, color):
    21.         super().__init__(brand, model, color)
    22.         self.battery = 70
    23. ​
    24.     def run(self):
    25.         print(f'I can run with eetric,remain:{self.battery}')
    26. ​
    27. ​
    28. bmw = GasolineCar('宝马', 'x5', '白色')
    29. bmw.run()
    30. ​
    31. tesla = EletriCar('特斯拉', 'Model S', '黑色')
    32. tesla.run()

    MRO属性或方法

            作用 --- 获得类的层次结构

            格式 ---

    1. 类名.__mro_ _
    2. #或
    3. 类名.mro()

            例：上述Car的例子

    1. class Car(object):
    2.     def __init__(self, brand, model, color):
    3.         self.brand = brand
    4.         self.model = model
    5.         self.color = color
    6. ​
    7.     def run(self):
    8.         print('I can run')
    9. ​
    10. ​
    11. class GasolineCar(Car):  # 继承Car类
    12.     def __init__(self, brand, model, color):
    13.         super().__init__(brand, model, color)  # 调用父类Car的__init__()方法
    14. ​
    15.     def run_with_gasoline(self):
    16.         print('I can with gasoline')
    17. ​
    18. ​
    19. class EletriCar(Car):  # 电动车父类
    20.     def __init__(self, brand, model, color):
    21.         super().__init__(brand, model, color)
    22.         self.battery = 70
    23. ​
    24.     def run(self):
    25.         print(f'I can run with eetric,remain:{self.battery}')
    26. ​
    27. print(EletriCar.__mro__) # 查看集成化层次结构
    28. print(EletriCar.mro())
    29. ​
    30. 结果：
    31. (<class '__main__.EletriCar'>, <class '__main__.Car'>, <class 'object'>)
    32. [<class '__main__.EletriCar'>, <class '__main__.Car'>, <class 'object'>]

    面向对象三大特征 --- 多态

    1.概念

            指事物的多种状态，是一种适用对象的放射式，子类重写了父类方法，调用不同子类对象时的相同父类方法，可以产生不同的执行结果。

    1. 多态依赖于继承

    2. 子类方法必须重写父类方法

            过程 --- 首先定义一个父类，其可能拥有多个子类对象，当调用一个公共方法时，传递的对象不同则返回结果不同

            公共接口 --- 是多态的体现，随着传入参数不同，返回结果不同

     

    2.实例

    1. class Fruit(object):
    2.     # 公共方法
    3.     def makejuice(self):
    4.         print('I can make juice')
    5. ​
    6. ​
    7. class Apple(Fruit):
    8.     def makejuice(self):
    9.         print('I can make apple juice')
    10. ​
    11. ​
    12. class Banana(Fruit):
    13.     def makejuice(self):
    14.         print('I can make banana juice')
    15. ​
    16. ​
    17. class Orange(Fruit):
    18.     def makejuice(self):
    19.         print('I can make orange juice')
    20. ​
    21. ​
    22. class Peach(Fruit):
    23.     def makejuice(self):
    24.         print('I can make peach juice')
    25. ​
    26. ​
    27. # 定义公共接口，相当于上述类的进入接口
    28. ​
    29. def servce(obj):
    30.     obj.makejuice()
    31. ​
    32. ​
    33. apple = Apple()
    34. banana = Banana()
    35. orange = Orange()
    36. peach = Peach()
    37. ​
    38. for i in (apple, banana, orange, peach):
    39.     servce(i)
    40.     
    41. 结果：
    42. I can make apple juice
    43. I can make banana juice
    44. I can make orange juice
    45. I can make peach juice

    3.优点

            调用灵活，有了多态，更容易编写通用代码，实现通用的编程，适应不同变化需求

     
​
  • 相关阅读:
    python入门练习题(含C++解法)
    MySQL 关键特性一：插入缓冲、双写缓冲
    外包公司程序员的水平真的很垃圾吗？
    Stream强化
    OFDM信号的时移特性（非整数采样点时移）
    c++排序算法
    Java 之 IO流
    东北大学acm暑期夏令营指针与引用初步
    音视频关键技术盘点！小白入行指南
    BUUCTF key不在这里
  • 原文地址：https://blog.csdn.net/qq_57289939/article/details/127987323