Python基础：面向对象编程（OOP）

  在Python中，面向对象编程（Object-Oriented Programming,OOP)是一种编程范式，通过使用对象、类、继承、封装、多态等概念组织代码和数据。可能会涉及到的概念：
  类（Class）：类是一个抽象的概念，用于描述一类对象的共同特征，定义了对象的属性（成员变量）和方法（成员函数）。
  对象（Object）： 对象是类的一个实例，具体化了类的定义，拥有类定义的属性和方法。
  类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
  局部变量：定义在方法中的变量，只作用于当前实例的类。
  实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用self修饰的变量。
  类方法：类中定义的函数。
  继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。派生类可以扩展或修改继承的内容，实现代码的重用和层次化的设计。
  封装：封装是将对象的状态（属性）和行为（方法）封装在一起，通过访问控制限制外部对对象内部数据的直接访问。通过双下划线前缀来创建私有属性和方法，实现基本的封装。
  多态：同一种操作作用于不同的对象上时，可以产生不同的行为。

1. 类定义语法

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

  与函数定义 (def 语句) 一样，类定义必须先执行才能生效。把类定义放在 if 语句的分支里或函数内部试试。
  在实践中，类定义内的语句通常都是函数定义，但也可以是其他语句。类里的函数定义一般是特殊的参数列表，这是由方法调用的约定规范所指明的
  当进入类定义时，将创建一个新的命名空间，并将其用作局部作用域 — 因此，所有对局部变量的赋值都是在这个新命名空间之内。 特别的，函数定义会绑定到这里的新函数名称。

2. Class对象

  类对象支持2种操作：属性引用和实例化
  属性引用 使用 Python 中所有属性引用所使用的标准语法: obj.name。 有效的属性名称是类对象被创建时存在于类命名空间中的所有名称。 因此，如果类定义是这样的:

class myClass:
    """ A simple example class."""
    i = 12345
    def f(self):
        return 'hello,world!'
# myClass.i
# myClass.f
myClass.__doc__ # 输出 ' A simple example class.'

  那么 MyClass.i和 MyClass.f 就是有效的属性引用，将分别返回一个整数和一个函数对象。
  类属性也可以被赋值，因此可以通过赋值来更改 MyClass.i 的值。
__doc__也是一个有效的属性，将返回所属类的文档字符串: “A simple example class”。

  类的 实例化使用函数表示法。 可以把类对象视为是返回该类的一个新实例的不带参数的函数。
  实例化操作 (“调用”类对象) 会创建一个空对象。 许多类都希望创建的对象实例是根据特定初始状态定制的。 因此一个类可能会定义名为 __init__() 的特殊方法。当一个类定义了 __init__() 方法时，类的实例化会自动为新创建的类实例发起调用 __init__()。

class Dog:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    
    def bark(self):
        return "Woof!"

# 创建一个Dog类的实例
my_dog = Dog('Scott',3)
# 访问对象的属性和调用对象的方法
print(f'狗的名字是：{my_dog.name}')
print(f'它叫的声音：{my_dog.bark()}')

3. 继承

  简单示例：

# 父类
class Animal:
    def __init__(self,name):
        self.name = name
    
    def speak(self):
        pass

# 子类1 
class Dog(Animal):
    def speak(self):
        return f'{self.name} says Woof!'
    
# 子类2
class Cat(Animal):
    def speak(self):
        return f'{self.name} says Meow!'

# 创建子类的实例
my_dog = Dog('Buddy')
my_cat = Cat('MaDa')

print(my_dog.speak())
print(my_cat.speak())

  多重继承：

# 第一个父类
class Engine:
    def start(self):
        print("Engine started")

    def stop(self):
        print("Engine stopped")

# 第二个父类
class ElectricMotor:
    def charge(self):
        print("Charging electric motor")

    def discharge(self):
        print("Discharging electric motor")

# 子类继承自两个父类
class HybridCar(Engine, ElectricMotor):
    def drive(self):
        print("Driving hybrid car")

# 创建子类的实例
my_hybrid_car = HybridCar()
# 调用继承自 Engine 类的方法
my_hybrid_car.start()  # 输出: Engine started
my_hybrid_car.stop()   # 输出: Engine stopped
# 调用继承自 ElectricMotor 类的方法
my_hybrid_car.charge()    # 输出: Charging electric motor
my_hybrid_car.discharge()  # 输出: Discharging electric motor
# 调用子类自己的方法
my_hybrid_car.drive()  # 输出: Driving hybrid car

  运行结果：

4. 封装

  封装是面向对象编程中的一个重要概念，它通过将数据（属性）和操作数据的方法（方法）捆绑在一起，以限制对数据的直接访问和修改。在Python中，封装可以通过使用私有属性和方法来实现。

class Car:
    def __init__(self, make, model, year):
        self.__make = make  # 私有属性
        self.__model = model
        self.__year = year
        self.__fuel = 100  # 初始油量为100%

    # 公有方法，用于获取汽车的制造商
    def get_make(self):
        return self.__make

    # 公有方法，用于获取汽车的型号
    def get_model(self):
        return self.__model

    # 公有方法，用于获取汽车的年份
    def get_year(self):
        return self.__year

    # 公有方法，用于获取汽车的剩余油量
    def get_fuel(self):
        return self.__fuel

    # 公有方法，用于加油
    def refuel(self, amount):
        if amount > 0:
            self.__fuel += amount
            print("Refueling... Current fuel level:", self.__fuel, "%")
        else:
            print("Invalid amount for refueling")

    # 私有方法，用于驾驶
    def __drive(self, distance):
        fuel_needed = distance / 10  # 假设每行驶10公里消耗1%油量
        if fuel_needed <= self.__fuel:
            self.__fuel -= fuel_needed
            print("Driving... Current fuel level:", self.__fuel, "%")
        else:
            print("Not enough fuel to drive")

    # 公有方法，用于外部调用驾驶操作
    def drive(self, distance):
        self.__drive(distance)

# 创建Car类的实例
my_car = Car("Toyota", "Camry", 2023)
# 使用公有方法获取汽车的信息
print("Make:", my_car.get_make())
print("Model:", my_car.get_model())
print("Year:", my_car.get_year())
# 使用公有方法获取剩余油量
print("Fuel Level:", my_car.get_fuel(), "%")
# 使用公有方法加油
my_car.refuel(20)
# 使用公有方法再次获取剩余油量
print("Fuel Level after refueling:", my_car.get_fuel(), "%")
# 使用公有方法驾驶
my_car.drive(50)

  运行结果：

5. 多态

  多态是面向对象编程的一个重要概念，它允许不同的对象对相同的方法进行调用，产生不同的行为。

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

def animal_sound(animal):
    return animal.speak()

# 创建不同类的实例
my_dog = Dog()
my_cat = Cat()
# 调用相同的函数，但产生不同的行为
print(animal_sound(my_dog))  # 输出: Woof!
print(animal_sound(my_cat))  # 输出: Meow!

6. 类变量、局部变量、实例变量

  类变量在整个类中共享，对所有实例可见。
  实例变量属于特定实例，每个实例都有自己的副本。
  局部变量只在方法或函数内部可见，超出作用域后被销毁。

class MyClass:
    # 类变量
    class_variable = "I am a class variable"

    def __init__(self, instance_variable):
        # 实例变量
        self.instance_variable = instance_variable

    def method(self, local_variable):
        # 局部变量
        print("Class Variable:", MyClass.class_variable)
        print("Instance Variable:", self.instance_variable)
        print("Local Variable:", local_variable)

# 创建类的实例
obj = MyClass(instance_variable="I am an instance variable")
# 访问类变量
print("Accessing Class Variable outside the class:", MyClass.class_variable)
# 访问实例变量
print("Accessing Instance Variable:", obj.instance_variable)
# 调用方法，传递局部变量
obj.method(local_variable="I am a local variable")

  运行结果：

  class_variable 是一个类变量，它属于类而不是类的实例。可以通过类名或实例来访问。
  instance_variable是一个实例变量，它属于类的实例。每个实例都有自己的实例变量副本。
  local_variable 是一个局部变量，它只在方法的作用域内可见，方法结束后就会被销毁。