• python面向对象基础-封装

    面向对象就是将编程当成一个事务，对外界来说，事务是直接使用，不用去管他内部的情况。而编程就是设置事务能够做什么事。

    类

    类是对一系列具有 相同特征和行为的事务的统称，是一个抽象的概念，不是真实存在的事务。类是用来创建对象的。
    1、特征即是属性
    2、行为即是方法
    语法： 
    1. class obj():
    2.     代码
    3.     ....
    注意：类名要满足标识符命名规则，同时遵循大驼峰命名规则
    对象
    对象（实例）是类创建出来的真实存在的事物。
    语法：
    对象名 = 类名（）
    示例： 
    1. #需求：洗衣机，功能：洗衣服
    2.  
    3. #定义洗衣机类
    4. class Washer():
    5.     def wash(self):
    6.         print("能洗衣服")
    7.  
    8. #创建对象
    9. haier = Washer()
    10.  
    11. #3.验证成果
    12. #使用wash功能 --实例方法/对象方法 -- 对像名.Wash()
    13. #类里面定义的函数称为实例方法
    14. haier.wash()
    15. 注意：类里面定义的函数称为实例方法
    类里面的self参数 
    1. class Washer():
    2.     def wash(self):
    3.         print('洗衣服')
    4.         print(self)
    5.  
    6. haier = Washer()
    7. print(haier)
    8.  
    9. haier.wash()
    10.  
    11. #
    结论
    由于打印对象和打印self得到的内存地址相同，所以 self指的是调用该函数的对象
    案例测试
    1.一个类可以创建多个对象？——可用
    2.多个对象都调用函数的时候，self地址相同——不同 
    1. # 1.一个类可以创建多个对象
    2. #2.多个对象都调用函数的时候，self地址相同
    3. class Washer():
    4.     def wash(self):
    5.         print('洗衣服')
    6.         print(self)
    7.  
    8. harer1 = Washer()
    9. harer1.wash()
    10. harer2 = Washer()
    11. harer2.wash()

    添加和获取对象属性

    属性即使特征，比如：洗衣机的宽度、高度、重量....
    对象属性既 可以在类外面添加和获取，也能在类里面添加和获取。

    类外面添加对象属性

    语法
    对象名.属性名 = 值

    类外面获取对象属性

    语法
    对象名.属性名
    案例体验 
    1. class Washer():
    2.     def wash(self):
    3.         print('洗衣服')
    4.  
    5. haier1 = Washer()
    6.  
    7. # 对象名.属性名 = 值
    8. haier1.width = 400
    9. haier1.height = 500
    10.  
    11. #对象名.属性名
    12. print(f'haier1洗衣机的宽度是{haier1.width}')
    13. print(f'haier1洗衣机的高度是{haier1.height}')

    类里面获取对象属性

    1. #定义类
    2. class Washer():
    3.     def wash(self):
    4.         print('洗衣机')
    5.  
    6.     def print_info(self):
    7.         #self.属性名
    8.         # print(self.width)
    9.         # print(self.height)
    10.         print(f'洗衣机的宽度{self.width}')
    11.         print(f'洗衣机的高度{self.height}')
    12.  
    13. haier1 = Washer()
    14.  
    15. #添加属性
    16. haier1.width = 400
    17. haier1.height = 500
    18. haier1.wash()
    19.  
    20. #对象调用方法
    21. haier1.print_info()

    魔法方法

    在python中，_xx_()的函数叫做魔法方法，指的是具有特殊功能的函数。
    _init_()方法的作用： 初始化对象 
    1. #目标：定义init魔法方法设置初始化属性  并访问调用
    2. """
    3. 1.定义类
    4.     init魔法方法：width 和 height
    5.     添加实例方法：访问实例属性
    7. 2.创建对象
    8. 3.验证成果
    9. """
    10.  
    11. class Washer():
    12.     def __init__(self):
    13.         #添加实例属性
    14.         self.width = 500
    15.         self.height = 800
    16.  
    17.     def print_info(self):
    18.         print(f'洗衣机的宽度是{self.width}')
    19.         print(f'洗衣机的宽度是{self.height}')
    20.  
    21. haier = Washer()
    22. haier.print_info()
    注意： 
    1. _init_()方法，在创建一个对象时默认被调用，不需要手动调用。
    2. _init_(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递过去。
    带参数的_init_()
    当一个类需要创建多个对象，需要对不同对象设置不同的初始值属性时，可 以 使用传参的方式实现。 
    1. #1.定义类：带参数的init:宽度和高度：实例方法：调用实例属性
    2. class Washer():
    3.     def __init__(self,width,height):
    4.         self.widht = width
    5.         self.height = height
    6.  
    7.     def print_info(self):
    8.         print(f'洗衣机的宽度{self.widht},洗衣机的高度{self.height}')
    9.  
    10. #2.创建对象，创建多个对象且属性值不同：调用实例方法
    11. haier1 = Washer(10,20)
    12. haier1.print_info()
    13.  
    14. haier2 = Washer(100,200)
    15. haier2.print_info()
    _str_() 
    1. 当使用print输出对象打的时候，默认打印对象的内存地址。如果类定义了_str_方法，那么就会打印从在这个方法中return的数据。
    2. class Washer():
    3.     def __init__(self):
    4.         self.width = 300
    5.  
    6.     def __str__(self):
    7.         return '解释说明：类的说明或对象状态的说明'
    8.  
    9. haier = Washer()
    10. print(haier) #解释说明：类的说明或对象状态的说明
    _del_()
    当删除对象时，python解释器也会 默认调用_del_()_方法 
    1. class Washer():
    2.     def __init__(self):
    3.         self.width = 300
    4.  
    5. #自动调用
    6.     def __del__(self):
    7.         print('对象一已经删除')
    8.  
    9. haier = Washer()
    面向对象综合应用
    1.烤地瓜
    需求：
    1.被烤的时间和对应的地瓜状态
        0-3分钟：生的
        3-5分钟：半生熟
        5-8分钟：熟的
        超过8分钟：烤糊了
    2.添加调料
        用户按自己的意愿添加调用
    步骤分析
    定义类
        地瓜的属性
            被烤的时间
            地瓜的状态
            添加的调料
        地瓜的方法
            被烤
                用户根据意愿设定每次烤地瓜的时间
                判断地瓜被烤的总时间是在哪个区间，修改地瓜状态
            添加调料
                用户根据意愿设定添加的调料
                将用户添加的调料存储
        显示对象信息
    #1.定义类：初始化属性、被烤和添加调料的方法、显示对象信息的str 
    1. class SweetPotato():
    2.     def __init__(self):
    3.         #定义属性：成员变量
    4.  
    5.         #被烤的时间
    6.         self.cook_time = 0
    7.         #烤的状态
    8.         self.cook_state = '生的'
    9.         #调料列表
    10.         self.condiments = []
    11.  
    12.     #定义方法：成员函数
    13.     def cook(self,time):
    14.         """烤地瓜方法"""
    15.         #1.先计算地瓜整体考过的时间
    16.         self.cook_time += time
    17.         #2.用整体烤过的时间在判断地瓜的状态
    18.         if 0 <= self.cook_time < 3:
    19.             #生的
    20.             self.cook_state = '生的'
    21.         elif 3 <= self.cook_time <5:
    22.             #半生不熟
    23.             self.cook_state = '半生不熟'
    24.         elif 5 <= self.cook_time < 8:
    25.             #熟了
    26.             self.cook_state = '熟了'
    27.         elif self.cook_time >= 8:
    28.             #烤糊了
    29.             self.cook_state = '烤糊了'
    30.  
    31.     def add_condiments(self,condiment):
    32.         #用户意愿的调料追加到调料列表
    33.         self.condiments.append(condiment)
    34.  
    35.     def __str__(self):
    36.         return f'这个地瓜的被烤过的时间是{self.cook_time}分钟，' \
    37.                f'状态是{self.cook_state}，调料有{self.condiments}'
    38.  
    39. #2.创建对象并调用对应的实例方法
    40. digua1 = SweetPotato()
    41. print(digua1)
    42.  
    43. digua1.cook(2)
    44. digua1.add_condiments('辣椒')
    45. print(digua1)
    46.  
    47. #多次调用测试时间是否相加
    48. digua1.cook(2)
    49. digua1.add_condiments('酱油')
    50. print(digua1)
    2.搬家具
        需求
    将小于房子剩余面积的家具摆放到房子中
    步骤分析
    需求涉及两个事务：房子和家具，故该案例涉及两个类：房子类和家具类
    定义房子类
        实例属性
            房子地理位置
            房子占地面积
            房子剩余面积
            房子内家具列表
        实例方法
            容纳家具
        显示房屋信息
    定义家具类
        家具名称
        家具占地面积
    创建对象并调用相关方法 
    1. #家具类
    2. class Furniture():
    3.     def __init__(self,name,area):
    4.         #家具名字
    5.         self.name = name
    6.         #家具占地面积
    7.         self.area = area
    8. #定义房屋类
    9. class Home():
    10.     def __init__(self,address,area):
    11.         #地理位置
    12.         self.address = address
    13.         #房屋面积
    14.         self.area = area
    15.         #剩余面积
    16.         self.free_area = area
    17.         #家具列表
    18.         self.furniture = []
    19.  
    20.     def __str__(self):
    21.         return f'房子地理位置在{self.address},' \
    22.                f'房屋面积是{self.area},剩余面积{self.free_area},家具有{self.furniture}'
    23.  
    24.  
    25.     def add_furniture(self,item):
    26.         """容纳家具"""
    27.         #如果 家具占地面积 <= 房子剩余面积： 可以搬入（家具列表添加家具名字数据并将房子剩余面积更新：
    28.         # 房屋剩余面积 - 该家具的占地面积
    29.         # 否则：提示用户家具太大，剩余面积不足，无法容纳
    30.         # ）
    31.         if item.area <= self.free_area:
    32.             self.furniture.append(item.name)
    33.             self.free_area -= item.area
    34.         else:
    35.             print('用户家具太大，剩余面积不足，无法容纳')
    36.  
    37. #双人床， 6
    38. bed = Furniture('双人床',6)
    39. sofa = Furniture('沙发',10)
    40.  
    41.  
    42. #房子1：北京 2.上海
    43. jia1 = Home('北京',1000)
    44. print(jia1)
    45.  
    46.  
    47. #开始般家具
    48. jia1.add_furniture(bed)
    49. print(jia1)
    50.  
    51.  
    52. ball = Furniture('游泳池',2000)
    53. jia1.add_furniture(ball)
    54. print(jia1)

    面向对象基础总结

    类
        创建类
    class 类名():
        代码
    对象
    对象名 = 类名()
    添加对象属性
        类外面
    对象名 = 类名
        类里面
    self.属性名 = 值
    获取对象属性
    类外面
    对象名.属性名
    类里面
    self.属性名

    魔法方法

    _init_()：初始化
    _str_()：输出对象信息
    _del_()：删除对象时调用
    注意：魔法方法不需要手动调用，它默认会自动调用。
  • 相关阅读:
    网络安全（黑客）自学
    【数据结构初阶-oj题】栈和队列的oj题（入门）
    论文速览 | arxiv 2023, 马氏距离感知训练在分布外检测中的应用
    单片机为什么一直用C语言，不用其他编程语言？
    蓝城兄弟完成私有化交割：从纳斯达克退市 作价6000万美元
    代码随想录怎么样？我是这样刷的
    【Go】-调用企微机器人
    免杀对抗-java语言-shellcode免杀-源码修改+打包exe
    evilhiding：一款好用的shellcode免杀工具
    SpringBoot 项目实战 ~ 8.移动端（用户端）管理
  • 原文地址：https://blog.csdn.net/gyqailxj/article/details/127954768