Python面向对象编程入门教程-原创手记-慕课网

概述

本文介绍了Python面向对象编程的基础概念，包括类和对象的定义、属性和方法的使用以及构造函数的初始化。详细讲解了类的继承、封装与数据隐藏、多态性以及特殊方法（魔术方法）的应用。通过实例和代码示例，帮助读者理解如何在Python中实现面向对象编程的各个特性。文中还强调了面向对象设计中的几个重要原则，如单一职责原则、开闭原则和里氏替换原则。

Python面向对象编程入门教程

Python面向对象基础概念

类和对象

在Python中，面向对象编程是通过定义类（Class）和对象（Object）来实现的。类是创建对象的模板，它定义了对象的数据属性和行为方法。对象是类的实例，每个对象都包含类定义的数据属性和方法。

类的定义

在Python中，可以使用class关键字来定义一个类：

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        return "汪！"

在上述代码中，定义了一个名为Dog的类。Dog类有两个属性（name和age）和一个方法（bark）。

创建对象

要创建一个对象，可以调用类的构造函数：

my_dog = Dog("小白", 3)

上述代码创建了一个名为my_dog的Dog对象，并传递了"小白"作为名字，3作为年龄。

访问对象属性和方法

通过对象可以访问其属性和方法：

print(my_dog.name)  # 输出 "小白"
print(my_dog.age)  # 输出 3
print(my_dog.bark())  # 输出 "汪！"

属性和方法

类中的属性是数据成员，方法是函数成员。属性可以有默认值，也可以通过构造函数在对象创建时进行初始化。

属性

属性通常是数据成员，可以通过self关键字在类的方法中访问：

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

方法

方法是定义在类中的函数，可以通过对象调用。方法的第一个参数通常是self，它代表调用该方法的对象实例：

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

    def info(self):
        return f"{self.brand} {self.model}"

    def start_engine(self):
        return "发动机启动了！"

初始化方法（构造函数）

构造函数是创建对象时自动调用的方法，通常被命名为__init__。构造函数用于初始化对象的属性。

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

    def info(self):
        return f"{self.brand} {self.model}"

    def start_engine(self):
        return "发动机启动了！"

在上述代码中，__init__方法用于初始化brand和model属性。

类的继承

继承的概念

继承是一种机制，允许一个类（子类）继承另一个类（父类）的属性和方法。这有助于代码重用和扩展。

定义子类

在定义子类时，通过在括号中指定父类来实现继承：

class Animal:
    def __init__(self, name):
        self.name = name

    def make_sound(self):
        return "动物的声音！"

class Dog(Animal):
    def make_sound(self):
        return "汪！"

在上述代码中，Dog类继承了Animal类，并重写了make_sound方法。

子类的定义

子类可以访问父类的属性和方法：

class Animal:
    def __init__(self, name):
        self.name = name

    def make_sound(self):
        return "动物的声音！"

class Dog(Animal):
    def make_sound(self):
        return "汪！"

my_dog = Dog("小白")
print(my_dog.name)  # 输出 "小白"
print(my_dog.make_sound())  # 输出 "汪！"

超类方法的重写

子类可以重写父类的方法以提供不同的实现：

class Animal:
    def __init__(self, name):
        self.name = name

    def make_sound(self):
        return "动物的声音！"

class Dog(Animal):
    def make_sound(self):
        return "汪！"

my_dog = Dog("小白")
print(my_dog.make_sound())  # 输出 "汪！"

子类的扩展定义

子类可以进一步扩展父类的功能：

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

    def info(self):
        return f"{self.brand} {self.model}"

    def start_engine(self):
        return "发动机启动了！"

class Vehicle(Car):
    def __init__(self, brand, model, year):
        super().__init__(brand, model)
        self.year = year

    def get_year(self):
        return self.year

在上述代码中，Vehicle类继承了Car类，并添加了一个新的属性year和一个方法get_year。

封装与数据隐藏

私有属性和方法

封装是将数据和行为封装在一个类中的概念，通过将属性和方法设为私有（private）来实现。

私有属性

私有属性在类外部不可直接访问，通常通过__前缀来声明：

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.__model = model

    def get_model(self):
        return self.__model

私有方法

私有方法同样使用__前缀来声明：

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.__model = model

    def __get_model(self):
        return self.__model

    def display_info(self):
        return f"{self.brand} {self.__get_model()}"

属性的访问控制

可以通过公有方法来访问和修改私有属性：

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.__model = model

    def get_model(self):
        return self.__model

    def set_model(self, model):
        self.__model = model

    def display_info(self):
        return f"{self.brand} {self.get_model()}"

my_car = Car("Toyota", "Corolla")
print(my_car.display_info())  # 输出 "Toyota Corolla"
my_car.set_model("Camry")
print(my_car.display_info())  # 输出 "Toyota Camry"

多态性

多态是一种允许不同类的对象以相同方式响应的能力。多态可以通过方法重载（重写）和动态类型转换来实现。

方法重载

在Python中，方法重载通常通过不同的参数来实现。虽然Python本身不支持严格的重载，但可以通过默认参数或可变参数来实现类似效果：

class Animal:
    def make_sound(self):
        return "动物的声音！"

class Dog(Animal):
    def make_sound(self, times=1):
        return "汪！" * times

动态类型转换

动态类型转换允许在运行时将一个对象转换为另一个对象：

class Animal:
    def __init__(self, name):
        self.name = name

    def make_sound(self):
        return "动物的声音！"

class Dog(Animal):
    def make_sound(self):
        return "汪！"

def make_noise(animal):
    print(animal.make_sound())

my_dog = Dog("小白")
make_noise(my_dog)  # 输出 "汪！"

特殊方法（魔术方法）

常用魔术方法介绍

魔术方法（也称为特殊方法）是Python中用于实现特殊功能的方法。它们通常以__开头和结尾，例如__init__和__len__。

常用魔术方法

__init__：初始化方法
__str__：用于返回对象的字符串表示
__repr__：用于返回对象的“官方”字符串表示
__len__：返回对象的长度
__getitem__：用于对象的索引操作
__setitem__：用于对象的赋值操作
__delitem__：用于对象的删除操作

示例

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"Point({self.x}, {self.y})"

    def __repr__(self):
        return f"Point({self.x}, {self.y})"

    def __len__(self):
        return 2

    def __getitem__(self, index):
        if index == 0:
            return self.x
        elif index == 1:
            return self.y
        else:
            raise IndexError("Index out of range")

    def __setitem__(self, index, value):
        if index == 0:
            self.x = value
        elif index == 1:
            self.y = value
        else:
            raise IndexError("Index out of range")

    def __delitem__(self, index):
        raise TypeError("Point objects are immutable and cannot be deleted")

p = Point(3, 4)
print(p)  # 输出 "Point(3, 4)"
print(str(p))  # 输出 "Point(3, 4)"
print(repr(p))  # 输出 "Point(3, 4)"
print(len(p))  # 输出 2
print(p[0])  # 输出 3
p[0] = 5
print(p[0])  # 输出 5
del p[0]  # 抛出 TypeError

魔术方法的实际应用

魔术方法可以用于实现更复杂的数据结构和行为。例如，实现一个简单的向量类：

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)

    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 + v2)  # 输出 "Vector(4, 6)"
print(v1 - v2)  # 输出 "Vector(-2, -2)"
print(v1 * 2)  # 输出 "Vector(2, 4)"

面向对象设计原则

单一职责原则

单一职责原则（SRP）指出一个类应该只有一个改变的理由。也就是说，一个类应该只有一个职责，避免将职责过度集中在一个类上。

例子

class OrderService:
    def create_order(self):
        pass

    def cancel_order(self):
        pass

    def get_order_details(self):
        pass

上述代码中，OrderService类只有一个职责，即处理与订单相关的操作。

开闭原则

开闭原则（OCP）指出软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。这意味着我们应该通过增加新的代码而不是修改现有代码来扩展功能。

例子

class DiscountCalculator:
    def calculate_discount(self, original_price):
        pass

class StandardDiscountCalculator(DiscountCalculator):
    def calculate_discount(self, original_price):
        return original_price * 0.1  # 10% 的折扣

class SpecialDiscountCalculator(DiscountCalculator):
    def calculate_discount(self, original_price):
        return original_price * 0.2  # 20% 的折扣

上述代码中，通过继承和重写，可以在不修改现有代码的情况下扩展新的折扣计算方式。

里氏替换原则

里氏替换原则（LSP）指出任何父类可以出现的地方，子类都可以出现。这意味着子类应该能够替换父类而不影响代码的正确性。

例子

class Animal:
    def make_sound(self):
        raise NotImplementedError("Subclasses must implement this method")

class Dog(Animal):
    def make_sound(self):
        return "汪！"

class Cat(Animal):
    def make_sound(self):
        return "喵！"

def make_animal_sound(animal):
    print(animal.make_sound())

dog = Dog()
cat = Cat()
make_animal_sound(dog)  # 输出 "汪！"
make_animal_sound(cat)  # 输出 "喵！"

上述代码中，Dog和Cat类都可以替换Animal类，而不会影响代码的正确性。

通过以上内容，我们介绍了Python面向对象编程的基本概念和高级特性。希望这些知识可以帮助你更好地理解和应用面向对象编程的思想。