7.1 类与对象：Python 面向对象编程的魔法

最新推荐文章于 2024-09-11 18:01:31 发布

野老杂谈

最新推荐文章于 2024-09-11 18:01:31 发布

阅读量1k

点赞数 24

分类专栏：遇见Python：初识、了解与热恋文章标签： python 开发语言面向对象编程类与对象编程基础

本文链接：https://blog.csdn.net/u010225915/article/details/141028900

版权

遇见Python：初识、了解与热恋专栏收录该内容

56 篇文章 1 订阅

订阅专栏

欢迎来到我的博客，很高兴能够在这里和您见面！欢迎订阅相关专栏：
工💗重💗hao💗：野老杂谈
⭐️ 全网最全IT互联网公司面试宝典：收集整理全网各大IT互联网公司技术、项目、HR面试真题.
⭐️ AIGC时代的创新与未来：详细讲解AIGC的概念、核心技术、应用领域等内容。
⭐️ 全流程数据技术实战指南：全面讲解从数据采集到数据可视化的整个过程，掌握构建现代化数据平台和数据仓库的核心技术和方法。
⭐️ 构建全面的数据指标体系：通过深入的理论解析、详细的实操步骤和丰富的案例分析，为读者提供系统化的指导，帮助他们构建和应用数据指标体系，提升数据驱动的决策水平。
⭐️《遇见Python：初识、了解与热恋》：涵盖了Python学习的基础知识、进阶技巧和实际应用案例，帮助读者从零开始逐步掌握Python的各个方面，并最终能够进行项目开发和解决实际问题。

摘要

面向对象编程（OOP）是 Python 编程中的一大亮点，类与对象是其核心概念。本文将通过通俗易懂的语言和幽默风趣的故事，深入浅出地介绍 Python 中的类与对象，并提供丰富的代码示例和图表示例，帮助读者全面掌握这一重要概念。

标签： Python、面向对象编程、类与对象、编程基础、代码示例

什么是类与对象？

在 Python 编程的世界里，类就像是建筑蓝图，而对象则是根据蓝图建造出来的具体建筑。我们先从一个故事开始。

故事：小明的机器人

小明是个爱折腾的小孩，他决定造一个机器人。他先画了一张详细的图纸（类），然后根据图纸造出了第一个机器人（对象）。

# 例子：定义一个类 Robot
class Robot:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print(f"Hi, I am {self.name} and I am {self.age} years old.")

# 创建一个对象
robot1 = Robot("Robo", 5)
robot1.introduce()

定义类和创建对象

定义类就像画图纸，我们需要定义类的属性和方法。属性是对象的特征，而方法是对象的行为。

定义类

类的定义使用 class 关键字，类的属性在 __init__ 方法中定义，而方法则是在类中定义的函数。

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

    def bark(self):
        print(f"{self.name} says: Woof!")

创建对象

对象是类的实例化，通过调用类的构造方法 __init__ 来创建对象。

dog1 = Dog("Buddy", "Golden Retriever")
dog1.bark()  # 输出: Buddy says: Woof!

类的属性与方法

类的属性用于存储对象的数据，方法用于定义对象的行为。让我们看看如何定义和使用它们。

类的属性

类的属性分为实例属性和类属性。实例属性是每个对象独有的，而类属性是所有对象共享的。

class Car:
    wheels = 4  # 类属性

    def __init__(self, brand, model):
        self.brand = brand  # 实例属性
        self.model = model

    def drive(self):
        print(f"The {self.brand} {self.model} is driving.")

# 创建对象
car1 = Car("Toyota", "Corolla")
car2 = Car("Honda", "Civic")

print(car1.wheels)  # 输出: 4
print(car2.wheels)  # 输出: 4

类的方法

类的方法可以访问和修改对象的属性。

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

    def greet(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

    def have_birthday(self):
        self.age += 1
        print(f"Happy Birthday {self.name}! You are now {self.age} years old.")

# 创建对象
person1 = Person("Alice", 30)
person1.greet()
person1.have_birthday()

类的继承

类的继承让我们可以创建一个类，并继承另一个类的所有属性和方法，从而实现代码的重用。

基本继承

我们定义一个基类 Animal 和一个派生类 Cat。

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

    def speak(self):
        raise NotImplementedError("Subclass must implement this method")

class Cat(Animal):
    def speak(self):
        print(f"{self.name} says: Meow")

# 创建对象
cat1 = Cat("Whiskers")
cat1.speak()  # 输出: Whiskers says: Meow

多重继承

Python 允许类继承多个类，这叫做多重继承。

class Walker:
    def walk(self):
        print("Walking...")

class Swimmer:
    def swim(self):
        print("Swimming...")

class Duck(Walker, Swimmer):
    def quack(self):
        print("Quacking...")

# 创建对象
duck1 = Duck()
duck1.walk()
duck1.swim()
duck1.quack()

类的多态性

多态性让不同类的对象可以通过同样的接口调用不同的方法，从而实现接口的统一。

class Bird:
    def speak(self):
        print("Tweet")

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

def make_animal_speak(animal):
    animal.speak()

# 创建对象
bird = Bird()
dog = Dog("Buddy")

make_animal_speak(bird)  # 输出: Tweet
make_animal_speak(dog)   # 输出: Woof

类的封装与私有属性

封装是面向对象编程的重要概念，它保护对象的内部状态不被外部直接访问和修改。Python 通过定义私有属性实现封装。

私有属性

私有属性通过在属性名之前加上两个下划线 __ 实现。

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance  # 私有属性

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount

    def get_balance(self):
        return self.__balance

# 创建对象
account = BankAccount("John", 1000)
account.deposit(500)
account.withdraw(300)
print(account.get_balance())  # 输出: 1200

类与对象的高级特性

类方法与静态方法

类方法和静态方法是类的高级特性，它们通过装饰器实现。

class Math:
    @staticmethod
    def add(a, b):
        return a + b

    @classmethod
    def multiply(cls, a, b):
        return a * b

# 调用静态方法
print(Math.add(5, 3))  # 输出: 8

# 调用类方法
print(Math.multiply(5, 3))  # 输出: 15

魔法方法

魔法方法是带有双下划线的特殊方法，它们让我们可以定义对象的行为。

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 __str__(self):
        return f"Vector({self.x}, {self.y})"

# 创建对象
v1 = Vector(2, 3)
v2 = Vector(3, 4)

v3 = v1 + v2
print(v3)  # 输出: Vector(5, 7)

实战演练——创建一个简单的游戏

通过一个实际案例，进一步理解如何使用类与对象。

案例：简单的冒险游戏

定义角色类
定义怪物类
定义游戏逻辑

class Character:
    def __init__(self, name, hp, attack):
        self.name = name
        self.hp = hp
        self.attack = attack

    def attack_target(self, target):
        target.hp -= self.attack
        print(f"{self.name} attacks {target.name} for {self.attack} damage!")

class Monster:
    def __init__(self, name, hp, attack):
        self.name = name
        self.hp = hp
        self.attack = attack

    def attack_target(self, target):
        target.hp -= self.attack
        print(f"{self.name} attacks {target.name} for {self.attack} damage!")

# 创建角色和怪物
hero = Character("Hero", 100, 20)
monster = Monster("Goblin", 50, 10)

# 游戏逻辑
while monster.hp > 0 and hero.hp > 0:
    hero.attack_target(monster)
    if monster.hp > 0:
        monster.attack_target(hero)

if hero.hp > 0:
    print(f"{hero.name} wins!")
else:
    print(f"{monster.name} wins!")