一篇文章告诉你什么是python中的面向对象

1、面对对象的概念

在Python中，面向对象编程（Object-Oriented Programming, OOP）是一种广泛使用的编程范式。它基于“对象”的概念来组织软件设计，使得代码更加模块化、易于理解和维护。面向对象编程的核心概念包括类（Class）、对象（Object）、继承（Inheritance）、封装（Encapsulation）和多态（Polymorphism）。

以上是官方的解释，其实要想弄清楚什么是面向对象，我们得先搞清楚什么是面向过程。在面向过程编程中，我们关注的是完成任务的一系列步骤或过程。举个大象装进冰箱的例子。如果我们用面向过程的方法来描述“把大象塞冰箱”这个任务，我们可能会这样描述：

1. 打开冰箱门。
2. 把大象放进去。
3. 关上冰箱门。

这个例子中，我们关注的是如何一步步地完成任务，即执行一系列预定义的步骤。这些步骤被看作是相互独立的函数或过程，它们之间通过数据传递来交互。

面向对象编程中，我们关注的是由属性和方法组成的对象。每个对象都是类的一个实例，类定义了对象的结构（属性）和行为（方法）。现在，我们用面向对象的方法来重新描述“把大象塞冰箱”这个任务。

首先，我们定义一个冰箱类，它包含了一些属性和方法：

class Refrigerator:  
    def __init__(self, is_open=False):  
        self.is_open = is_open  
  
    def open_door(self):  
        self.is_open = True  
        print("冰箱门打开了。")  
  
    def close_door(self):  
        self.is_open = False  
        print("冰箱门关上了。")  
  
    def put_elephant_in(self):  
        if self.is_open:  
            print("大象被放进冰箱了。")  
        else:  
            print("冰箱门没有打开，无法放入大象。")

然后，我们创建一个Refrigerator对象，并使用它的方法来完成任务：

fridge = Refrigerator()  
fridge.open_door()  # 执行第一步：打开冰箱门  
fridge.put_elephant_in()  # 执行第二步：把大象放进去（这里假设大象已经被某种方式处理了）  
fridge.close_door()  # 执行第三步：关上冰箱门

所以，面向过程编程关注的是如何一步步地执行任务，而面向对象编程则关注于如何通过对象来组织代码，让代码更加模块化和易于理解。在面向对象编程中，我们利用类来定义对象的结构和行为，并通过对象之间的交互来完成任务。

2、面向对象中的实例属性和类属性

类和实例是面向对象编程（OOP）中的两个核心概念。面向对象编程是一种编程范式，它使用“对象”来设计软件。实例可以包含属性（就是数据）以及操作这些数据的方法。类（Class）是创建实例的模板，它定义了实例应有的属性和方法。

2.1类（Class）

在Python中，你可以使用class关键字来定义一个类。类名通常使用驼峰命名法（CamelCase），即每个单词的首字母大写，除了第一个单词。类里面包含了各种对象、方法和属性。

class MyClass:  
    # 类属性（通常用于定义所有实例共享的变量，但更常见的是使用实例属性）  
    class_attribute = "I am shared by all instances."  
  
    def __init__(self, name):  
        # 实例属性（每个实例都有自己独立的变量）  
        self.name = name  
  
    def greet(self):  
        # 方法（对象可以执行的操作）  
        print(f"Hello, my name is {self.name}!")

2.2实例（对象）

在python中，对象就相当于实例，可以把对象看作是实例。实例是类的具体实现。当你使用类来创建一个对象时，你就创建了一个类的实例。每个实例都是独一无二的，它有自己的属性和方法（尽管方法本身是共享的，但每个实例都可以独立地调用它们，并且可能基于其自己的属性产生不同的结果）。

在Python中，你可以使用类名后跟圆括号（可能包含传递给__init__方法的参数）来创建类的实例

# 创建MyClass的实例  
instance1 = MyClass("Alice")  
instance2 = MyClass("Bob")  
  
# 访问实例的属性和方法  
print(instance1.name)  # 输出: Alice  
instance1.greet()      # 输出: Hello, my name is Alice!  
  
print(instance2.name)  # 输出: Bob  
instance2.greet()      # 输出: Hello, my name is Bob!

3、面向对象中的实例方法和类方法

在Python中，类（Class）可以定义两种主要类型的方法：实例方法（Instance Methods）和类方法（Class Methods）。此外，还有一种静态方法（Static Methods），但这里我们主要关注实例方法和类方法。

3.1实例方法

实例方法是类中定义的最常见类型的方法。（实例方法就是对象中的方法）它们至少需要一个名为self的参数（虽然在定义时可以命名为其他名称，但按照惯例，它总是被命名为self），该参数是对类实例本身的引用。通过实例方法，你可以访问和修改实例的属性。

class Person:  
    def __init__(self, name, age):  
        self.name = name  # 实例属性  
        self.age = age    # 实例属性  
  
    def greet(self):  # 实例方法  
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")  
  
# 创建Person类的实例  
person1 = Person("Alice", 30)  
  
# 调用实例方法  
person1.greet()  # 输出: Hello, my name is Alice and I am 30 years old.

上面的例子中，greet是一个实例方法，它通过self参数访问了实例的name和age属性。

3.2类方法

类方法是通过装饰器@classmethod定义的。与实例方法不同，类方法的第一个参数不是self，而是cls（虽然你也可以使用其他名称，但cls是更常见的命名约定）。这个参数是对类本身的引用，而不是类的实例。类方法通常用于创建或返回与类本身紧密相关但不依赖于类实例的对象。

from datetime import datetime  
  
class DateUtil:  
    @classmethod  
    def get_current_date(cls):  # 类方法  
        return datetime.now().strftime("%Y-%m-%d")  
  
# 无需创建实例即可调用类方法  
today = DateUtil.get_current_date()  
print(today)  # 输出当前日期，如 "2023-04-01"  
  
# 但如果你创建了实例，也可以通过实例调用类方法  
date_util_instance = DateUtil()  
print(date_util_instance.get_current_date())  # 同样输出当前日期

在上面的例子中，get_current_date是一个类方法，它返回当前的日期字符串。由于这个方法不需要访问或修改实例的状态，因此它被定义为类方法。注意，尽管我们可以通过类的实例来调用类方法，但类方法是与类本身相关联的，而不是与类的任何特定实例相关联。

4、继承

在Python中，面向对象编程（OOP）的一个重要特性是继承（Inheritance）。继承允许我们定义一个类（称为子类或派生类）来继承另一个类（称为父类或基类）的属性和方法。这种机制支持代码的重用，并且有助于组织具有层次结构的类。

4.1继承的基本概念

• 父类（基类）：被继承的类，提供了基本的属性和方法。
• 子类（派生类）：继承自父类的类，可以添加新的属性或方法，也可以重写（Override）继承自父类的方法。

4.2如何实现继承

在Python中，继承是通过在定义子类时在类名后的括号中指定父类名来实现的。如果没有指定父类，则默认继承自object类，object是所有Python类的基类。

class Parent:  
    def __init__(self, name):  
        self.name = name  
  
    def greet(self):  
        print(f"Hello, my name is {self.name}")  
  
class Child(Parent):  # Child类继承自Parent类  
    def __init__(self, name, age):  
        super().__init__(name)  # 调用父类的__init__方法  
        self.age = age  
  
    def greet(self):  
        # 重写greet方法  
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")  
  
# 创建Child类的实例  
child_instance = Child("Alice", 10)  
child_instance.greet()  # 输出: Hello, my name is Alice and I am 10 years old.

4.3继承的特性

• 属性继承：子类继承了父类的所有属性（除非在子类中重新定义了同名属性）。

• 方法继承：子类继承了父类的所有方法（除非在子类中重写了这些方法）。

• 方法重写：子类可以定义与父类同名的方法，这称为方法重写。在子类实例上调用该方法时，将执行子类中的版本。

• super()函数：在子类中，可以使用super()函数来调用父类的方法。这在子类需要扩展父类方法时非常有用。

• 多重继承：Python支持多重继承，即一个类可以继承自多个父类。然而，多重继承可能会导致复杂的继承关系和潜在的冲突，因此应谨慎使用。

4.4继承的注意事项

• 当重写父类方法时，通常建议调用父类的原始方法（如果需要的话），以确保子类保留了父类的行为。这可以通过super()函数来实现。

• 继承并不是一种替代代码复用的手段，而是一种组织和结构化代码的方式。在某些情况下，组合（Composition）可能是更好的选择。

• 过度使用继承可能会导致代码变得复杂和难以维护。因此，在设计类时，应仔细考虑是否真的需要继承。

• 在Python中，由于动态类型的特性，继承的行为可能比在其他静态类型语言中更加灵活和强大。然而，这也要求开发者对Python的面向对象编程机制有更深入的理解。

5、多态

在Python中，面向对象编程（OOP）的另一个核心概念是多态（Polymorphism）。多态允许我们以统一的接口来处理不同的对象，即使这些对象属于不同的类，只要它们继承自同一个基类或者实现了相同的接口（在Python中，接口通常通过抽象基类来实现，但并非强制要求）。多态提高了程序的灵活性和可扩展性。

5.1多态的基本概念

多态意味着“多种形态”或“多种形式”。在面向对象编程中，多态指的是同一个操作（如方法调用）可以作用于不同的对象上，并产生不同的行为。这通常是通过继承和方法重写来实现的。Python中，多态的实现相对简单，因为Python是一种动态类型语言。

5.2如何实现多态

Python中的多态主要是通过继承和方法重写来实现的，但由于Python的动态类型特性，我们不需要像在一些静态类型语言中那样显式地声明接口或类型。

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!"  
  
def make_it_speak(animal):  
    print(animal.speak())  
  
# 创建Dog和Cat的实例  
dog = Dog()  
cat = Cat()  
  
# 调用make_it_speak函数，传入不同类型的对象  
make_it_speak(dog)  # 输出: Woof!  
make_it_speak(cat)  # 输出: Meow!

在上面的例子中，Animal类定义了一个speak方法，但它没有具体实现（通过抛出NotImplementedError异常来指示子类必须实现该方法）。Dog和Cat类继承自Animal类并重写了speak方法，提供了各自的实现。make_it_speak函数接受一个Animal类型的参数，但实际上它可以接受任何Animal的子类实例。当调用animal.speak()时，Python解释器会根据对象的实际类型来调用相应的方法，这就是多态的体现。

5.3多态的特性

• 提高代码的灵活性和可扩展性：多态允许我们以统一的接口来处理不同类型的对象，从而可以在不修改现有代码的情况下添加新的类型。

• 减少代码冗余：通过继承和多态，我们可以避免在不同的类中编写重复的代码，从而提高代码的可重用性。

• 提高代码的可读性和可维护性：使用多态可以使代码更加清晰和易于理解，因为它隐藏了对象的具体类型，只关注于对象的接口。

5.4多态的注意事项

• 在使用多态时，应该确保子类正确地实现了父类中的抽象方法（如果父类中有的话）。在Python中，这通常是通过约定俗成的方式来实现的，但你也可以使用abc模块来定义抽象基类（Abstract Base Classes, ABCs）和抽象方法。

• 多态并不意味着可以随意地将任何对象传递给需要特定类型参数的函数或方法。虽然Python是动态类型的，但你也应该遵循类型约定和接口契约，以确保代码的正确性和健壮性。

6、封装

6.1封装的基本概念

在Python中，面向对象的封装（Encapsulation）是面向对象编程（OOP）的一个核心概念。封装将对象的数据（属性）和操作数据的方法（行为）组合成一个独立的单元，并隐藏对象的内部实现细节，仅对外暴露有限的接口（即公共方法和属性）。这样做的目的是保护对象的数据不被随意访问和修改，同时提供对数据的受控访问。

6.2如何实现封装

在Python中，封装主要通过私有属性（方法）和公有属性（方法）的访问控制来实现。

• 私有属性（方法）：在Python中，私有属性（方法）通常通过在属性（方法）名前加上两个下划线（__）来定义。这些属性（方法）在类外部是不可直接访问的。但是，需要注意的是，Python中的私有属性（方法）并不是真正的私有，而是一种命名约定（name mangling）。Python会将这样的属性（方法）名改写为_类名__属性名的形式，以避免子类中的同名属性（方法）覆盖它们。但是，这并不意味着你可以随意访问它们，因为从外部代码的角度来看，这些属性（方法）仍然是不可见的。

• 公有属性（方法）：没有前缀（或以一个下划线_开头的，尽管这通常表示受保护的属性或方法，但在Python中并不强制限制访问）的属性（方法）是公有的，可以在类的外部被直接访问和修改。

class BankAccount:  
    def __init__(self, owner, balance=0):  
        self.__owner = owner  # 私有属性  
        self.__balance = balance  # 私有属性  
  
    def deposit(self, amount):  
        if amount > 0:  
            self.__balance += amount  
            print(f"{amount} deposited. New balance is {self.__balance}")  
        else:  
            print("Deposit amount must be positive.")  
  
    def withdraw(self, amount):  
        if 0 < amount <= self.__balance:  
            self.__balance -= amount  
            print(f"{amount} withdrawn. New balance is {self.__balance}")  
        elif amount > self.__balance:  
            print("Insufficient funds.")  
        else:  
            print("Withdrawal amount must be positive.")  
  
    # 提供了一个公有方法来获取余额（封装的一部分是提供受控的访问）  
    def get_balance(self):  
        return self.__balance  
  
# 使用BankAccount类  
account = BankAccount("Alice", 100)  
account.deposit(50)  # 调用公有方法  
print(account.get_balance())  # 通过公有方法获取余额  
# account.__balance = 200  # 这会抛出AttributeError，因为__balance是私有的

在上面的例子中，BankAccount类有两个私有属性__owner和__balance，以及三个公有方法deposit、withdraw和get_balance。外部代码不能直接访问__owner和__balance属性，但可以通过deposit、withdraw和get_balance方法来操作这些属性。这样，BankAccount类就封装了它的内部状态，并通过受控的接口来提供对这些状态的访问和修改。

6.3封装的特性

• 隐藏内部实现：封装隐藏了对象的内部细节，使得外部代码只能通过定义好的接口来访问对象，从而减少了外部对对象内部状态的直接依赖。

• 增加数据安全性：通过封装，可以控制对对象属性的访问权限，防止外部代码直接修改对象的敏感数据，从而提高了数据的安全性。

• 提高代码的可维护性：封装使得代码更加模块化，每个类都负责自己的特定任务。当需要修改类的内部实现时，只需要在类内部进行修改，而不需要修改使用该类的外部代码，从而提高了代码的可维护性。

6.4封装的注意事项

• 过度封装：虽然封装是一个好特性，但过度封装可能会导致代码难以理解和维护。如果某个属性或方法没有明确的理由需要被封装，那么最好将其设为公有。
• 不必要的复杂性：有时候，为了封装而封装可能会引入不必要的复杂性。在决定是否封装某个属性或方法时，应该权衡其带来的好处和可能引入的复杂性。
• 子类访问父类的私有属性：在Python中，子类不能直接访问父类的私有属性（由于name mangling）。如果子类需要访问这些属性，应该通过父类提供的公有方法来进行。
• 重写方法时的封装考虑：当子类重写父类的方法时，应该确保遵守父类的封装约定。如果父类中的某个方法被设计为私有方法，那么子类中的对应方法也应该保持私有，除非有明确的理由需要将其改为公有。