Python面向对象编程 Class详解_Python

一、概念

1️⃣ 面向过程编程（procedural programming）/prəˈsiːdʒərəl/
以“步骤”为核心，比如c语言，一步一步执行
2️⃣ 面向对象编程（oop）
以“对象”为核心，比如java、c++、python，把现实世界抽象成“类”和“对象”

类 (class)：类就是制造对象的一个模板或蓝图。它定义了一类事物共有的属性（数据）和行为（方法）。
对象 (object)：根据类创建出来的具体实例。
属性（attributes）/əˈtrɪbjuːts/：属性就是对象的特点或信息
方法（methods）/ˈmeθədz/：法就是对象能做的动作或功能。

四大特性

封装 (encapsulation)/ɪnˌkæpsjuˈleɪʃ(ə)n/：封装是将数据和操作数据的方法绑定在一起，并对外隐藏内部细节。通过控制访问权限（如 private, public），我们只暴露必要的接口
继承 (inheritance)/ɪnˈherɪtəns/：继承允许一个类（子类）获取另一个类（父类）的属性和方法。子类可以在保留父类功能的基础上，增加新的功能或修改既有功能。
多态 (polymorphism)/ˌpɑːlɪˈmɔːrˌfɪzəm/：多态是指“同一种行为，在不同的对象上有不同的表现形式”。比如“动物”类有一个“叫”的方法。当它是“狗”对象时，输出“汪汪”；当它是“猫”对象时，输出“喵喵”。
抽象 (abstraction)/æbˈstrækʃn/：抽象是简化现实世界复杂性的过程。只关注与当前目标相关的特性，而忽略无关的细节。比如在开发“挂号系统”时，我们只需要“病人”的姓名、病历号，而不需要知道他的身高或喜欢的颜色。

二、实操

2.1 创建第一个类

#定义类
class car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

    def get_info(self):
        return f"{self.year} {self.make} {self.model}"
        
    def start_engine(self):
        info = self.get_info() # 类的方法内部也可以互相调用
        print(f"{info} 启动了！")
#创建对象        
car1 = car("toyota", "camry", 2020)
#调用方法
print(car1.get_info())
car1.start_engine()

----输出：
2020 toyota camry
2020 toyota camry 启动了！

解析
class （类），是用来定义一个类的关键字，在这里，我们定义了一个名为 car的类。【类】
__init__ （构造函数），核心就是为了初始化，不写此函数需要手动赋值
get_info() ：类中的方法**【方法】**
car1:使用car类创建出car1对象**【对象】**
car1.get_info()：对象调用类里get_info方法
self: 当前这个对象自己
make, model, year: 传入的参数 【属性】
make, model, year 在 __init__ 的括号里是形参（占位符）；而你在 car(“toyota”, “camry”, 2020) 里传入的是实参（具体的值）

如果出现中文乱码：在代码开始位置加入

import sys
import io
sys.stdout = io.textiowrapper(sys.stdout.buffer, encoding='utf-8')

2.2 修改属性值

动态修改属性：
可以在创建对象之后，通过直接访问属性来修改它们的值。

#修改属性的值
car1.year = 2021
print(car1.get_info())

动态添加新属性：
可以添加类定义里根本没有的属性。

car1.color = "red" # 可以动态添加属性
print(f"{car1.get_info()} 的颜色是 {car1.color}")

使用内置函数修改：
setattr(obj, name, val) 设置属性值
getattr(obj, name) 获取属性值
delattr(obj, name) 删除属性
hasattr(obj, name) 检查是否有某属性
带有参数的方法：

class car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

    def get_info(self,start):# start 是临时传入的变量
        return f"{self.year} {self.make} {self.model}{start}"
    
          
car1 = car("toyota", "camry", 2020)

print(car1.get_info("启动了")) #输出2020 toyota camry启动了

2.3 类的继承

子承父业

class car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        
    def get_info(self):
        return f"{self.year} {self.make} {self.model}"    

class electriccar(car):
    def __init__(self, make, model, year, battery_size):
        #super()函数调用父类的构造方法，初始化父类的属性
        super().__init__(make, model, year)
        #子类特有的属性
        self.battery_size = battery_size

#子类特有的方法
    def get_battery_info(self):
        return f"battery size: {self.battery_size} kwh"
         
car1 = car("toyota", "camry", 2020)
car2 = electriccar("toyota", "camry", 2020, 100)
print(car1.get_info())#输出：2020 toyota camry
print(car2.get_battery_info())#输出：battery size: 100 kwh
print(car2.get_info() + " " + car2.get_battery_info())#输出：2020 toyota camry battery size: 100 kwh

super() :它是子类向父类“借东西”的工具。super().init(…) 的意思是：先把父类里定义好的初始化逻辑跑一遍
如果子类想修改父类方法，直接重写即可

 def get_info(self):
        # 调用父类的方法获取基础信息，再加上电车特有的信息
        basic_info = super().get_info()
        return f"{basic_info} (纯电动模式)"
print(car2.get_info()) #输出2020 toyota camry (纯电动模式)

2.4 类的特殊方法

名称前后都有双下划线
a. 生命周期类（对象的创建与销毁）
__init__(self, …)`: 初始化方法。在创建对象时自动调用，用于设置初始属性。

__new__(self, ...): 创建实例的方法。在 __init__ 之前执行，通常在自定义元类或单例模式时才用到。

__del__(self): 析构方法。当对象被销毁（垃圾回收）时触发。
b. 字符串表示类（让对象“好看”）
这是开发中最常用的，用来定义当你 print 一个对象时显示什么。
__str__ ： print(obj) 或 str(obj)给用户看的，返回友好的描述
__repr__ ：直接输入对象名或 repr(obj)给开发者看的，返回准确的调试信息

class car:
    def __init__(self, make, model):
        self.make = make
        self.model = model

    def __str__(self):
        return f"这是一辆 {self.make} {self.model}"

car = car("toyota", "camry")
print(car)  # 输出: 这是一辆 toyota camry
#平时调用是直接

c. 算术运算符类（让对象能加减乘除）
如果你想让两个对象相加（比如 car1 + car2），你需要定义这些方法：
__add__(self, other): 对应 +
__sub__(self, other): 对应 -
__mul__(self, other): 对应 *
__eq__(self, other)： 对应 ==
d. 长度与容器类（让对象像列表一样工作）
__len__(self): 对应 len(obj)。
__getitem__(self, key): 对应 obj[key]，让对象可以像字典或列表一样取值。
__contains__(self, item): 对应 item in obj。

2.5 类的访问控制

在 python 中，类的访问控制主要依靠命名约定和名称修饰，来提示开发者哪些属性和方法不应该被外部代码直接访问或修改。

访问类型	格式	外部访问
public	name	✅
protected	_name	⚠️
private	__name	❌

class example:
    def __init__(self):
        self._protected_var = "这是一个受保护的属性"
    def _protected_method(self):
        return "这是一个受保护的方法"

obj=example()
print(obj._protected_var)  # 输出: 这是一个受保护的属性
print(obj._protected_method())  # 输出: 这是一个受保护的方法

class example:
    def __init__(self):
        self.__private_var = "这是一个私有的属性"
    def __private_method(self):
        return "这是一个私有方法"

obj=example()      
# print(obj.__private_var)  # 输出: 报错  
# print(obj.__private_method())  # 输出: 报错     
print(obj._example__private_var)  # 输出: 这是一个私有的属性
print(obj._example__private_method())  # 输出: 这是一个私有方法

getter (访问器) 和 setter (修改器)：

class user:
    def __init__(self, age):
        self.__age = age

    def get_age(self):
        return self.__age

    def set_age(self, value):
        self.__age = value

u = user(20)
u.set_age(21)   
print(u.get_age())

pythonic 风格（使用 @property装饰器）
在不修改原函数代码的前提下，给函数添加额外的功能。
在代码中，装饰器以 @装饰器名 的形式放在函数定义的上方.

class user:
    def __init__(self,age):
        self.__age=age
    @property
    def age(self):
        return self.__age
    @age.setter
    def age(self,value):
        if value < 0:
            print("年龄不能为负数")
        else:
            self.__age = value

user = user(25)
print(user.age)  # 输出: 25
user.age = -5  # 输出: 年龄不能为负数
print(user.age)  # 输出: 25 (年龄没有改变)