Python 中的面向对象编程 (OOP)：类和对象解释

阿婷酱_5230

发布时间：2024-09-11 08:10:10

1220人浏览过

来源于dev.to

转载

python 中的面向对象编程 (oop)：类和对象解释

面向对象编程（oop）是软件开发中使用的关键方法。

在本文中，我们将探讨 oop 的主要思想，特别是 python 中的类、对象、继承和多态性。

在本指南结束时，您将了解如何使用 oop 原则组织 python 代码，使您的程序更加模块化、可重用且更易于维护。

什么是面向对象编程？

面向对象编程（oop）围绕数据或对象而不是函数和逻辑来组织软件设计。

立即学习“Python免费学习笔记（深入）”；

对象就像一个容器，具有独特的属性（数据）和行为（功能）。 oop 重点关注几个关键概念：

封装
这意味着将数据（属性）和对该数据进行操作的方法（函数）捆绑到一个单元中，称为类。

它还涉及限制对对象的某些组件的访问，使其更加安全。

抽象
这是隐藏复杂的实现细节并仅显示对象的基本特征的想法。

它降低了复杂性并允许程序员专注于更高级别的交互。

继承
这是一种从现有类（基类）创建新类（派生类）的机制。

新类继承现有类的属性和方法。

多态性
这是使用单个接口来表示不同数据类型的能力。

它允许将对象视为其父类的实例，并且可以在子类中定义与父类中的方法同名的方法。

python 中的 oop 基础知识：类和对象

python 中面向对象编程 (oop) 的核心是类和对象。

课程
类就像创建对象的蓝图。

它定义了对象将具有的一组属性（属性）和操作（方法）。

在 python 中，您可以使用 class 关键字创建一个类。这是一个例子：

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

    def start_engine(self):
        print(f"{self.make} {self.model}'s engine started.")

对象
对象是类的实例。

一旦定义了一个类，您就可以从中创建多个对象（实例）。

每个对象都可以为类中定义的属性拥有自己唯一的值。

以下是创建和使用对象的方法：

my_car = car("toyota", "corolla", 2020)
my_car.start_engine()  # output: toyota corolla's engine started.

在此示例中，my_car 是 car 类的对象。

它有自己的品牌、型号和年份值，您可以使用 start_engine 等方法。

python 中的继承

继承让一个类（子类）具有另一个类（父类）的属性和方法。

这对于重用代码和在类之间设置层次结构非常有用。

这是一个例子：

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

    def drive(self):
        print("driving...")


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

    def start_engine(self):
        print(f"{self.make} {self.model}'s engine started.")


my_car = car("honda", "civic", 2021)
my_car.drive()  # output: driving...
my_car.start_engine()  # output: honda civic's engine started.

在此示例中，car 类继承自 vehicle 类。

因此，car 类可以使用 vehicle 类中定义的驱动方法。

方法重写
有时，子类需要更改或添加从父类继承的方法的行为。

这是通过方法重写完成的。

Li Python Sec Check

Python 安全规范检查工具：基于 CloudBase 规范、腾讯安全指南，LLM 智能分析（默认禁用，优先本地执行）

下载

这是一个例子：

class vehicle:
    def drive(self):
        print("driving a vehicle...")


class car(vehicle):
    def drive(self):
        print("driving a car...")


my_vehicle = vehicle()
my_vehicle.drive()  # output: driving a vehicle...

my_car = car()
my_car.drive()  # output: driving a car...

在此示例中，car 类中的drive 方法覆盖了vehicle 类中的drive 方法，从而允许自定义行为。

多重继承
python 还支持多重继承，即一个类可以从多个基类继承。

这是一个例子：

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

    def drive(self):
        print("driving a vehicle...")


class electric:
    def charge(self):
        print("charging...")


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

    def start_engine(self):
        print(f"{self.make} {self.model}'s engine started.")


class hybridcar(car, electric):
    def switch_mode(self):
        print("switching to electric mode...")


my_hybrid = hybridcar("toyota", "prius", 2022)
my_hybrid.start_engine()  # output: toyota prius's engine started.
my_hybrid.drive()  # output: driving a vehicle...
my_hybrid.charge()  # output: charging...
my_hybrid.switch_mode()  # output: switching to electric mode...

在此示例中，hybridcar 类继承自 car 和 electric，允许它访问两个父类的方法。

python 中的多态性

多态性是一项功能，允许方法根据它们正在使用的对象执行不同的操作，即使这些方法具有相同的名称。

这在处理继承时特别有用，因为它允许您以对每个类都有意义的方式在不同的类中使用相同的方法名称。

函数多态性
这是一个例子：

class dog:
    def speak(self):
        return "woof!"


class cat:
    def speak(self):
        return "meow!"


def make_animal_speak(animal):
    print(animal.speak())


dog = dog()
cat = cat()

make_animal_speak(dog)  # output: woof!
make_animal_speak(cat)  # output: meow!

make_animal_speak 函数通过接受任何具有 talk 方法的对象来演示多态性。

这使得它可以与 dog 和 cat 对象一起使用，尽管它们之间存在差异。

类方法的多态性
当使用类层次结构中的方法时，多态性也会发挥作用。

这是一个例子：

class animal:
    def speak(self):
        raise notimplementederror("subclass must implement abstract method")


class dog(animal):
    def speak(self):
        return "woof!"


class cat(animal):
    def speak(self):
        return "meow!"


animals = [dog(), cat()]

for animal in animals:
    print(animal.speak())

在此示例中，dog 和 cat 都是 animal 的子类。

speak 方法在两个子类中都实现了，允许多态性在迭代动物列表时生效。

封装和数据隐藏

封装是将数据和处理该数据的方法组合成一个单元（称为类）的做法。

它还涉及限制对对象某些部分的访问，这对于保护面向对象编程 (oop) 中的数据至关重要。

私有和公共属性
在 python 中，您可以通过其名称以下划线开头来指示属性是私有的。

虽然这实际上并不会阻止从类外部进行访问，但这是一种约定，表明不应直接访问该属性。

这是一个例子：

class account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = balance  # private attribute

    def deposit(self, amount):
        self._balance += amount

    def withdraw(self, amount):
        if amount <= self._balance:
            self._balance -= amount
        else:
            print("insufficient funds")

    def get_balance(self):
        return self._balance


my_account = account("john", 1000)
my_account.deposit(500)
print(my_account.get_balance())  # output: 1500

在这个例子中，account类有一个私有属性_balance，它可以通过deposit、withdraw和get_balance等方法进行操作。

不鼓励从类外部直接访问 _balance。

先进的面向对象编程概念

对于那些想要加深对 python 中面向对象编程 (oop) 的理解的人，这里有一些高级主题：

类方法
这些方法连接到类本身，而不是连接到类的各个实例。

它们可以更改类的状态，这会影响类的所有实例。

class car:
    total_cars = 0

    def __init__(self, make, model):
        self.make = make
        self.model = model
        car.total_cars += 1

    @classmethod
    def get_total_cars(cls):
        return cls.total_cars

静态方法
这些方法属于该类，但不会更改该类或其实例的状态。

它们是使用@staticmethod装饰器定义的。

class mathoperations:
    @staticmethod
    def add(x, y):
        return x + y

物业装饰
python 中的属性装饰器提供了一种以更 pythonic 的方式定义类属性的 getter、setter 和 deleters 的方法。

class Employee:
    def __init__(self, name, salary):
        self._name = name
        self._salary = salary

    @property
    def salary(self):
        return self._salary

    @salary.setter
    def salary(self, value):
        if value < 0:
            raise ValueError("Salary cannot be negative")
        self._salary = value

在此示例中，salary 属性的访问方式与常规属性类似，但由 getter 和 setter 方法管理。