python—面向对象

面向对象概述

Python面向对象编程（OOP）是一种程序设计方法，它将数据（属性）和行为（方法）封装成对象，并通过类来定义这些对象。面向对象编程的核心概念包括封装、继承和多态。下面将详细解释这些概念，并结合文章中的相关信息进行归纳。

一、面向对象的基本概念

类（Class）

- 类是一个模板或蓝图，它定义了一组属性和方法，用于创建对象。
- 在Python中，可以使用class关键字来定义一个类。例如：

python 复制代码

class Person:  
    def __init__(self, name, age):  
        self.name = name  
        self.age = age  
    def say_hello(self):  
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

对象（Object）

- 对象是类的实例，它是具有特定属性和方法的实体。
- 通过实例化类来创建对象。例如：

python 复制代码

person1 = Person("Alice", 25)  
person1.say_hello()  # 输出: Hello, my name is Alice and I am 25 years old.

二、面向对象的三大特性

封装（Encapsulation）

- 封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面（即方法）。
- 在Python中，封装通常通过私有属性（以双下划线开头的属性）和私有方法（以双下划线开头的方法）来实现。但需要注意的是，Python中的封装并不是严格的，因为可以通过一些特殊方式访问私有属性和方法。
- 封装保证了模块具有较好的独立性，使得程序维护修改较为容易。

继承（Inheritance）

- 继承是一种面向对象编程的概念，它允许开发人员创建一个新类（子类或派生类），该类继承了现有类（父类或基类）的属性和方法。
- 通过继承，子类可以重用父类的代码，从而减少代码的重复性。
- Python支持多重继承，即一个子类可以继承多个父类。
- 示例：

python 复制代码

class Student(Person):  
    def __init__(self, name, age, major):  
        super().__init__(name, age)  
        self.major = major  
    def say_hello(self):  
        super().say_hello()  
        print(f"I am studying {self.major}.")

多态（Polymorphism）

- 多态是一种面向对象编程的概念，它允许开发人员使用相同的接口来处理不同类型的对象。
- 在Python中，多态是基于动态类型的，这意味着可以在运行时决定要调用哪个方法。
- 示例：

python 复制代码

def introduce(person):  
    person.say_hello()  
person1 = Person("Alice", 25)  
person2 = Student("Bob", 20, "Computer Science")  
introduce(person1)  
introduce(person2)

三、面向对象编程的优点

开发时间短，效率高：由于面向对象编程的可重用性，可以在应用程序中大量采用成熟的类库，从而缩短开发时间。
可靠性高：所开发的程序更强壮，因为面向对象编程强调封装和模块化，使得程序的各个部分相对独立，减少了错误传播的可能性。
易于维护、更新和升级：继承和封装使得应用程序的修改带来的影响更加局部化，降低了维护成本。

综上所述，Python面向对象编程是一种强大的程序设计方法，它通过类、对象以及封装、继承和多态等特性，提高了程序的可重用性、可靠性和可维护性。

面向过程 vs 面向对象

面向过程：

- 步骤：分析出解决问题的步骤，然后逐步实现。
- 例子：婚礼筹办包括发请柬（选照片、措词、制作）、宴席（场地、找厨师、准备桌椅餐具等）、婚礼仪式（定流程、请主持人）。
- 公式：程序 = 算法 + 数据结构
- 优点：所有环节、细节自己掌控。
- 缺点：考虑所有细节，工作量大。

面向对象：

- 步骤：找出解决问题的人（对象），然后分配职责。
- 例子：婚礼筹办时，发请柬找摄影公司，宴席找酒店，婚礼仪式找婚庆公司。
- 公式：程序 = 对象 + 交互
- 思想层面：

- - 可模拟现实情景，更接近于人类思维。
  - 有利于梳理归纳、分析解决问题。

核心概念

封装：根据职责将属性和方法封装到一个抽象的类中。
继承：实现代码的重用，相同的代码不需要重复的编写。
多态：不同的子类对象调用相同的父类方法，产生不同的执行结果。

示例代码

在Dog类中封装方法game：

python 复制代码

class Dog:  
    def game(self):  
        print("Dog is playing.")

定义XiaoTianDog继承自Dog，并重写game方法：

python 复制代码

class XiaoTianDog(Dog):  
    def game(self):  
        print("XiaoTianDog is playing fetch.")

定义Person类，封装一个和狗玩的方法：

python 复制代码

class Person:  
    def play_with_dog(self, dog):  
        dog.game()  
 
# 使用示例  
dog = XiaoTianDog()  
person = Person()  
person.play_with_dog(dog)  # 输出：XiaoTianDog is playing fetch.

单例设计模式

单例设计模式：确保一个类仅有一个实例，并提供一个全局访问点。
Python 中的单例实现（简化版）：

python 复制代码

class Singleton:  
    _instance = None  
    def __new__(cls, *args, **kwargs):  
        if not cls._instance:  
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)  
        return cls._instance

内置函数 dir()

- 用途：传入标识符/数据，可以查看该对象内的所有属性及方法。
- 示例：dir(object) 将列出对象object的所有属性和方法。
- 技巧：利用dir()函数可以帮助快速了解对象的属性和方法，减少死记硬背的需要。
- 注意：dir()返回的列表中，部分以双下划线（__）开头和结尾的方法是Python的内置方法或特殊属性，它们具有特殊意义。

对象属性与方法访问

1. 对象方法内部访问属性：在对象的方法内部，可以直接访问该对象的属性。
2. 对象间属性独立性：同一个类创建的多个对象之间，其属性是互不干扰的，每个对象维护自己独立的属性状态。

摆放家具需求

- 房子（House）类

- - 属性：户型、总面积、家具名称列表（初始为空）。
  - 说明：新房子在创建时不包含任何家具。

- 家具（HouseItem）类

- - 属性：名字、占地面积。
  - 示例家具及其占地面积：

- - - 席梦思(bed)：4平米
    - 衣柜(chest)：2平米
    - 餐桌(table)：1.5平米

- 需求实现

1. 1. 将席梦思、衣柜、餐桌三件家具添加到房子中。
  2. 打印房子信息时，需包含户型、总面积、剩余面积（总面积减去所有家具占地面积之和）、家具名称列表。

剩余面积计算

- 在添加家具到房子时，需要更新房子的剩余面积。这通常通过遍历家具列表，累加各家具占地面积，并从总面积中减去得到。

示例代码框架

python 复制代码

class HouseItem:  
    def __init__(self, name, area):  
        self.name = name  
        self.area = area  
  
class House:  
    def __init__(self, layout, total_area):  
        self.layout = layout  
        self.total_area = total_area  
        self.furniture_list = []  
  
    def add_furniture(self, furniture):  
        self.furniture_list.append(furniture)  
        self.update_remaining_area()  
  
    def update_remaining_area(self):  
        self.remaining_area = self.total_area - sum(item.area for item in self.furniture_list)  
  
    def __str__(self):  
        return f"户型: {self.layout}, 总面积: {self.total_area}, 剩余面积: {self.remaining_area}, 家具名称列表: {[item.name for item in self.furniture_list]}"  
  
# 使用示例  
house = House("三室一厅", 100)  
house.add_furniture(HouseItem("bed", 4))  
house.add_furniture(HouseItem("chest", 2))  
house.add_furniture(HouseItem("table", 1.5))  
print(house)

1. 变则疏之

原则：将可能发生变化的地方独立封装，避免影响其他类。
应用：在设计系统时，识别出可能变化的部分，如业务逻辑、数据格式等，将它们封装在独立的类或模块中，以便在需要时进行修改或替换，而不影响整体架构的稳定性。

2. 高内聚

原则：类中各个方法都在完成一项任务（单一职责的类）。
应用：确保每个类只负责一个相对独立的功能模块，避免一个类包含过多不相关的功能，以提高代码的可读性和可维护性。

3. 低耦合

原则：类与类的关联性与依赖度要低（每个类独立），让一个类的改变尽量少地影响其他类。
应用：通过接口、抽象类等方式降低类之间的直接依赖，增强系统的灵活性和可扩展性。例如，使用依赖注入、事件驱动等设计模式来降低类之间的耦合度。

注意：

过高的内聚可能导致高耦合（如类中仅包含一个方法），这在实际开发中应避免。
过低的耦合可能导致低内聚（如类中包含所有方法），同样不利于系统的维护和扩展。

通过遵循上述原则，可以设计出更加健壮、灵活和易于维护的面向对象系统。