python的面向对象

python的面向对象

面向过程：以函数为单位，按逻辑顺序执行。

面向对象：以对象（实例）为单位，封装数据和行为。

类（class）：抽象模板，描述一类事物的属性和行为。

对象（object）：类的具体实例。

实例化：通过类创建对象的过程。

抽象化：提取共性，忽略细节。

一、类的创建与调用

class 类名
     类体{变量和方法}
     
变量 = 类名()
变量.变量名 / 方法名

class Student:
    # 类变量（所有实例共享）
    school = "Python大学"

    # 构造方法（初始化实例属性）
    def __init__(self, name, age):
        self.name = name          # 实例属性
        self.age = age

    # 实例方法
    def introduce(self):
        print(f"我叫{self.name}，今年{self.age}岁")

# 实例化
stu1 = Student("Alice", 20)
stu1.introduce()
print(stu1.school)   # 访问类变量

二、私有化（封装）

• 使用 _ 或 __ 表示属性/方法为“保护”或“私有”。
• __ 会触发名称改写（_类名__变量名），防止子类意外覆盖。

class Person:
    def __init__(self, name, age):
        self.name = name          # 公有
        self._gender = "男"       # 保护（约定）
        self.__id = "123456"      # 私有

    def get_id(self):
        return self.__id          # 通过公有方法访问私有属性

p = Person("Bob", 25)
print(p.name)          # 正常
print(p._gender)       # 可以访问，但不建议
# print(p.__id)        # 报错
print(p.get_id())      # 通过方法获取

三、继承

• 单继承--子类继承父类的属性和方法，可重写或扩展。

  class Animal:
      def eat(self):
          print("吃东西")
  
  class Dog(Animal):
      def bark(self):
          print("汪汪叫")
  
  dog = Dog()
  dog.eat()   # 继承自Animal
  dog.bark()
  

• 多继承--一个子类可以继承多个父类。

  class Flyable:
      def fly(self):
          print("飞")
  
  class Swimmable:
      def swim(self):
          print("游泳")
  
  class Duck(Flyable, Swimmable):
      pass
  
  duck = Duck()
  duck.fly()
  duck.swim()
  

  使用超类super()调用父类方法

  class Person:
      def __init__(self, name):
          self.name = name
  
  class Student(Person):
      def __init__(self, name, grade):
          super().__init__(name)   # 调用父类构造
          self.grade = grade
  
  stu = Student("Tom", 6)
  print(stu.name, stu.grade)
  

  mro(方法解析顺序)

  • 多继承时，Python使用C3线性化算法确定方法查找顺序

  • 可通过类名._mro_查看

    print(Duck.__mro__)
    

四、多态

1. 方法重写(Override)

   子类重新定义父类的方法。

   class Cat(Animal):
       def eat(self):          # 重写父类方法
           print("猫吃鱼")
   
   cat = Cat()
   cat.eat()   # 输出：猫吃鱼
   

2. 方法重载(Overload)

   Python 不支持传统意义上的方法重载（同名不同参）。但可通过默认参数或可变参数模拟。

   def add(a, b, c=0):
       return a + b + c
   
   print(add(1, 2))      # 3
   print(add(1, 2, 3))   # 6
   

五、静态方法@staticmethod

• 不需要实例，也不需要类引用。

• 相当于类内部的普通函数，只是逻辑上归属于类。

  class MathUtils:
      @staticmethod
      def add(x, y):
          return x + y
  
  print(MathUtils.add(3, 5))   # 无需实例化
  

六、推导式（4种）

列表推导式：[表达式 for 变量 in 可迭代对象 if 条件]
字典推导式：{键表达式：值表达式 for 变量 in 可迭代对象 if 条件}
集合推导式：{表达式 for 变量 in 可迭代对象 if 条件}
生成器表达式：(表达式 for 变量 in 可迭代对象 if 条件)
 
# 列表推导式（练习中的 Rate 函数使用了类似思想）
nums = [1, 2, 3, 4]
squares = [n**2 for n in nums]   # [1, 4, 9, 16]

# 生成器表达式（惰性求值）
gen = (x for x in range(3))
print(next(gen))  # 0
print(next(gen))  # 1

七、迭代器与生成器

• 迭代器：实现了 __iter__() 和 __next__() 的对象。

• 生成器：使用 yield 的函数，返回生成器对象，支持惰性计算。生成器像单向迭代器，每生成一个元素就"消耗"掉一个，无法回头

  def fib_gen():
      a, b = 1, 1
      while True:
          yield a
          a, b = b, a + b
  
  fib = fib_gen()
  for _ in range(5):
      print(next(fib))   # 1 1 2 3 5
  

八、闭包

三个必要条件：

1. 函数嵌套

2. 内部函数引用外部函数的变量

3. 外部函数返回内部函数

   def outer(x):
       def inner(y):
           return x + y   # 引用外部变量
       return inner
   
   add5 = outer(5)
   print(add5(3))   # 8
   

   注意：若在内部函数中修改外部变量，需用 nonlocal 声明。

   def counter():
       count = 0
       def increment():
           nonlocal count   # 必须声明
           count += 1
           return count
       return increment
   

九、装饰器（Decorator）

装饰器本质是闭包，用于在不修改原函数代码的前提下，增强其功能。

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} took {end-start:.4f} seconds")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)
    print("Finished")

slow_function()

# 手动装饰
decorated_func = timer(slow_function)
decorated_func()

总结：

函数是解决问题的工具，面向对象是组织代码的架构；从函数到面向对象，是从“写出能跑的代码”到“设计能演化的系统”的编程思维升级。