python 面向对象编程

python 面向对象

Python 是一种面向对象的编程语言，这意味着它支持通过创建对象来构建程序。这种编程范式让代码更具结构性和可重用性。

1. 类与对象

• 类 (Class): 类是创建对象的蓝图或模板。它定义了对象的属性和行为。

  class Dog:
      # 类的构造函数
      def __init__(self, name, breed):
          self.name = name  # 实例属性
          self.breed = breed  # 实例属性
  
      # 类的方法
      def bark(self):
          print(f"它叫 {self.name}!")
  

• 对象 (Object): 对象是类的实例。创建对象时，调用类的构造函数，并传递所需参数。

  my_dog = Dog("二哈", "哈士奇")  # 创建一个 Dog 类的对象
  print(my_dog.name)  # 访问对象的属性
  my_dog.bark()  # 调用对象的方法
  

  ：输出结果

  二哈
  它叫 二哈
  

2. 构造函数与析构函数

• 构造函数 (__init__): 用于在创建对象时初始化对象的属性。

• 析构函数 (__del__): 用于在对象被销毁时执行清理操作。

    class Cat:
      def __init__(self, name):
          self.name = name
          print(f"{self.name} 被创建!")
  
      def __del__(self):
          print(f"{self.name} 被删除!")
  
  my_cat = Cat("小猫")
  del my_cat  # 手动删除对象，触发析构函数
  
  

  :输出结果

  小猫 被创建！
  小猫 被删除！
  
  

3. 类的属性和方法

• 实例属性: 由每个对象单独拥有，通过 self 访问。

• 类属性: 由类本身拥有，所有实例共享，通过类名或 self访问。

  class Bird:
      species = "鸟"  # 类属性
  
      def __init__(self, name):
          self.name = name  # 实例属性
  
  bird1 = Bird("麻雀")
  bird2 = Bird("乌鸦")
  
  print(bird1.species)  # 输出 "鸟"
  print(bird2.species)  # 输出 "鸟"
  Bird.species = "鸟类"  # 修改类属性
  print(bird1.species)  # 输出 "鸟类"
  

4. 方法类型

• 实例方法: 通过 self访问，可以访问和修改对象的属性。实例方法是最常见的。

  class Car:
      def __init__(self, make, model):
          self.make = make
          self.model = model
  
      def display_info(self):
          print(f"Car: {self.make} {self.model}")
  
  my_car = Car("Toyota", "Corolla")
  # 调用实例方法
  my_car.display_info()  # 输出 Car: Toyota Corolla
  

• 类方法 (@classmethod): 通过 cls访问，可以访问和修改类属性。

  class Vehicle:
      num_wheels = 4
  
      @classmethod
      def set_num_wheels(cls, wheels):
          cls.num_wheels = wheels
  
  Vehicle.set_num_wheels(6)
  print(Vehicle.num_wheels)  # 输出 6
  

• 静态方法 (@staticmethod): 不访问类或实例属性，通常用于逻辑上属于类但不依赖于类或实例的数据的功能。

  class MathOperations:
      @staticmethod
      def add(x, y):
          return x + y
  
  print(MathOperations.add(5, 7))  # 输出 12
  

5. 继承

• 继承 : 通过继承，子类可以继承父类的属性和方法，且子类可以重写或扩展父类的方法。

  class Animal:
      def __init__(self, name):
          self.name = name
  
      def speak(self):
          return f"{self.name} 发出声音."
  
  class Dog(Animal):
      def speak(self):
          return f"{self.name} 旺旺."
  
  my_dog = Dog("二哈")
  print(my_dog.speak())  # 输出 "二哈 旺旺."
  

6. 多态

• 多态性: 不同类的对象可以通过相同的接口调用不同的方法实现。多态使代码更灵活和可扩展。

  class Cat(Animal):
      def speak(self):
          return f"{self.name} 喵喵."
  
  def animal_sound(animal):
      print(animal.speak())
  
  my_cat = Cat("小猫")
  my_dog = Dog("二哈")
  
  animal_sound(my_cat)  # 输出 "小猫 喵喵."
  animal_sound(my_dog)  # 输出 "二哈 旺旺."
  

7. 封装

• 封装 : 将数据和方法保护起来，避免外部直接访问和修改，通过公开的方法访问和修改。使用单下划线 _

  表示“受保护”（protected）的成员，使用双下划线 __表示“私有”（private）成员。

  class Account:
      def __init__(self, owner, balance=0):
          self.owner = owner
          self.__balance = balance  # 私有属性
  
      def deposit(self, amount):
          self.__balance += amount
  
      def withdraw(self, amount):
          if amount <= self.__balance:
              self.__balance -= amount
          else:
              print("资金不足！")
  
      def get_balance(self):
          return self.__balance
  
  my_account = Account("zhan", 100)
  my_account.deposit(50)
  print(my_account.get_balance())  # 输出 150
  

8. 抽象类与接口

• 抽象类: 抽象类不能被实例化，通常用于定义接口或抽象方法，由子类实现这些方法。Python 使用 abc模块提供抽象类支持。

  from abc import ABC, abstractmethod
  
  class Shape(ABC):
      @abstractmethod
      def area(self):
          pass
  
      @abstractmethod
      def perimeter(self):
          pass
  
  class Rectangle(Shape):
      def __init__(self, width, height):
          self.width = width
          self.height = height
  
      def area(self):
          return self.width * self.height
  
      def perimeter(self):
          return 2 * (self.width + self.height)
  
  rect = Rectangle(10, 20)
  print(rect.area())  # 输出 200