python学习-面向对象编程1本章介绍主要 python 面向对象编程的基础概念、类、对象及其属性与方法、继承、多态、

python学习-面向对象编程1

本文介绍 python 面向对象编程，基础概念、类、对象及其属性与方法、继承、多态、封装和高级特性，抽象类及接口。

供自己以后查漏补缺，也欢迎同道朋友交流学习。

引言

上面几篇内容主要介绍的 Python 的基础用法，但我们在真实开发过程中，不会仅仅写个函数、定义属性这样简单了事，而是要基于 类 (class) 和 模块 (module)进行面向对象方式编程。

本章介绍主要 python 面向对象编程的基础概念、类、对象及其属性与方法、继承、多态、封装和高级特性，抽象类及接口。

基础概念

面向对象（Object-Oriented，OO）是一种编程范式，它基于 对象 的概念来设计软件和程序。

这种范式将现实世界中的实体抽象为对象，每个对象都包含数据（属性）和能够对这些数据执行的操作（方法）。

面向对象编程（Object-Oriented Programming，OOP）是实现面向对象思想的一种编程方式。

以下是 OOP 中的一些核心概念的定义和作用：

对象（Object）: 对象是现实世界中事物的抽象，它包含属性（数据）和方法（行为）。在 OOP 中，对象是类的实例。
类（Class）: 作为创建对象的模板，它定义了一组属性和方法，封装数据和行为的集合，提供代码重用和模块化。
封装（Encapsulation）: 隐藏对象的内部状态和行为的实现细节，提高代码的安全性和减少耦合，使得对象的使用更加简单，因为用户不需要了解内部复杂性。
继承（Inheritance）: 继承是一种创建新类的方式，子类可以继承父类的属性和方法，子类可以扩展父类的功能，提高代码的可维护性和扩展性。
多态（Polymorphism）: 多态是指允许不同类的对象对同一消息做出响应的能力，即同一个接口可以被不同的实例以不同的方式实现。

创建和使用

在面向对象编程（OOP）中，类和对象是核心概念。

类的创建

在 Python 中，使用 class 关键字来定义一个类。类可以包含属性和方法。以下是一个简单的类定义示例：

class Animal:
  def __init__(self, name, age):
    self.name = name  # 属性
    self.age = age  # 属性
  def run(self): # 方法
    print(self.name, "正在跑步")

我们使用了 class 定义了一个动物类 Animal，定义了构造函数 __init__() 用于实例化对象，定义了 name 和 age 俩个属性，定义了跑路 run 这个方法。

实例化对象

my_cat = Animal('小黑', 2)
print(my_cat.name) # 小黑
print(my_cat.age) # 2
my_cat.run() # 小黑 正在跑步

特殊方法

在 Python 中，特殊方法（也称为魔术方法或双下方法）是一些有特殊意义的内置方法，它们在特定的操作或内置函数被调用时自动执行。这些方法通常以双下划线（__）开头和结尾。以下是一些常用的特殊方法及其用途：

__str__(self)：当使用 print() 函数或 str() 时调用，应该返回一个可读性强的字符串表示，通常用于用户显示。
__repr__(self)：当使用repr() 函数时调用，或者在交互式解释器中一个对象被表示时调用。

class Animal:
  def __init__(self, name, age):
    self.name = name  # 属性
    self.age = age  # 属性
    
  def run(self):
    print(self.name, "正在跑步")
    
  def __str__(self):
    return f"{self.name} {self.age}"

  def __repr__(self):
    return f"Animal('{self.name}', '{self.age}')"
    
my_cat = Animal('小黑', 2)
print(my_cat)  # 调用 __str__ 输出：小黑 2
print(repr(my_cat))  # 调用 __repr__ 输出：Animal('小黑', '2')
print(my_cat.name) # 输出：小黑
print(my_cat.age) # 输出：2
my_cat.run() # 输出：小黑 正在跑步

继承和多态

继承是面向对象编程中的一个核心概念，它允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。

多态是指允许不同类的对象对同一消息做出响应的能力。换句话说，不同的对象可以对同一个方法名做出不同的响应。

单继承与多重继承

单继承: 指的是一个类只继承一个父类。
多重继承: 允许一个类继承多个父类。

使用super()函数

在 Python 中，super() 函数用于调用父类的方法。它可以在子类中使用，以访问和调用父类的方法。

在子类中调用父类的方法时，super() 函数可以帮助我们避免显式地指定父类的名称，从而提高代码的可读性和可维护性。

class Dog(Animal):
  def __init__(self, name, age, color):
    super().__init__(name, age)
    self.color = color
    
  def run(self):
    return super().run()

my_dog = Dog('小白', 3, '白色')
my_dog.run() # 输出：小白 正在跑步

方法重写

在子类中，我们可以重写父类的方法，以提供不同的实现。

class Parent:
  def show(self):
    print("Parent show method")

class Child(Parent):
  def show(self):  # 重写父类方法
    print("Child show method")

child = Child()
child.show()  # 输出: Child show method

多态

多态通常是通过方法重写实现的。当一个父类引用指向子类对象时，调用的方法是子类重写的方法。

class Animal:
  def make_sound(self):
    raise NotImplementedError("子类必须实现这个方法")

class Dog(Animal):
  def make_sound(self):
    print("Woof")

class Cat(Animal):
  def make_sound(self):
    print("Meow")

def animal_sound(animal):
  animal.make_sound()

dog = Dog()
cat = Cat()

animal_sound(dog)  # 输出: Woof
animal_sound(cat)  # 输出: Meow

Animal 类定义了一个 make_sound 方法，而 Dog 和 Cat 类分别重写了这个方法。

函数 animal_sound 接受一个 Animal 类型的参数，并调用 make_sound 方法。

由于多态，传入 Dog 或 Cat 对象时，会调用相应的 make_sound 实现。

这就是多态的实现，它使得同一个接口可以有不同的行为。

封装和高级特性

私有属性和方法

私有属性和方法通常通过在属性或方法名前加上双下划线（__）来表示。

这会触发名称改写（name mangling），使得这些属性和方法在类外部不可直接访问。

class Animal:
  def __init__(self, name, age, gender):
    self.name = name  # 属性
    self.age = age  # 属性
    self.__gender = gender  # 私有属性
    
  def __get_gender(self):
    return self.__gender # 私有方法
    
  def run(self):
    print(self.name, "正在跑步")
    
my_animal = Animal('黑熊', 5, '雄性')
print(my_animal.__gender) # 报错
print(my_animal.__get_gender()) # 报错

静态方法和类方法

静态方法（@staticmethod）：静态方法不接收类或实例的引用，因此它们无法访问类的状态。它们通常用于实现与类相关但不需要类或实例数据的功能。
类方法（@classmethod）：类方法接收类作为第一个参数（通常命名为cls），它们可以访问和修改类的状态。

class Animal:
  @staticmethod
  def speek():
    print("动物在叫")
    
  @classmethod
  def eat(cls):
    print("动物在吃")

Animal.speek()
Animal.eat()

抽象类和接口

抽象类

抽象类是不能被直接实例化的类，它通常用作基类，为其他类提供公共的接口或实现。

抽象类可以包含抽象方法，这些方法只定义签名，不提供具体的实现。

使用abc模块定义抽象类：

在 Python 中，abc模块提供了ABC（Abstract Base Class）和abstractmethod装饰器，用于定义抽象类和抽象方法。

from abc import ABC, abstractmethod

class Animal(ABC):
  @abstractmethod
  def speek():
    pass
  
  def eat():
    pass  

class Dog(Animal):
  def speek():
    print("汪汪汪")

  def eat():
    print("吃骨头")
    
class Cat(Animal):
  def speek():
    print("喵喵喵")

  def eat():
    print("吃鱼")

Dog.speek() # 输出: 汪汪汪
Dog.eat() # 输出: 吃骨头
Cat.speek() # 输出: 喵喵喵
Cat.eat() # 输出: 吃鱼

接口

在 Python 中，没有直接的接口概念，但可以使用抽象类和抽象方法来模拟接口。

python学习专栏系列

练习代码库地址

python-study