Python面向对象快速入门 - MeowRain的技术博客

面向对象编程（Object-Oriented Programming，简称 OOP）是一种程序设计思想。在 Python 中，一切皆对象。掌握 OOP 是进阶 Python 编程的关键一步。

本文将带你快速理解 Python 面向对象的核心概念。

1. 类 (Class) 与对象 (Object)#

类是创建对象的蓝图（模板），对象是类的具体实例。

比喻：

类：汽车的设计图纸。
对象：根据图纸制造出来的具体的一辆辆汽车（如你的宝马、他的奔驰）。

定义类与创建对象#

1
# 定义一个类
2
class Dog:
3
    pass
4

5
# 创建对象（实例化）
6
dog1 = Dog()
7
dog2 = Dog()
8

9
print(dog1)  # <__main__.Dog object at ...>
10
print(dog1 == dog2) # False，它们是两个不同的对象

2. 构造方法与属性#

在类中，我们可以定义属性（变量）来描述对象的特征。

`init` 方法#

__init__ 是一个特殊方法（构造方法），在创建对象时自动调用，用于初始化对象的属性。

self：代表类的实例（对象）本身。在定义类的方法时，第一个参数通常是 self。

1
class Cat:
2
    def __init__(self, name, age):
3
        self.name = name  # 实例属性
4
        self.age = age    # 实例属性
5

6
# 创建对象时传入参数
7
tom = Cat("Tom", 3)
8
jerry = Cat("Jerry", 2)
9

10
print(f"{tom.name} is {tom.age} years old.")
11
# 输出: Tom is 3 years old.

3. 方法 (Methods)#

方法就是定义在类内部的函数，用来描述对象的行为。

1
class Person:
2
    def __init__(self, name):
3
        self.name = name
4

5
    def say_hello(self):
6
        print(f"Hello, my name is {self.name}.")
7

8
p = Person("Alice")
9
p.say_hello()
10
# 输出: Hello, my name is Alice.

4. 封装 (Encapsulation)#

封装是指将数据（属性）和操作数据的方法绑定在一起，并隐藏对象的内部实现细节。

在 Python 中，通过在属性名前加双下划线 __ 将其变为私有属性（Private），外部无法直接访问。

1
class BankAccount:
2
    def __init__(self, balance):
3
        self.__balance = balance  # 私有属性
4

5
    def deposit(self, amount):
6
        if amount > 0:
7
            self.__balance += amount
8
            print(f"Deposited {amount}")
9

10
    def get_balance(self):
11
        return self.__balance
12

13
account = BankAccount(100)
14
account.deposit(50)
15
print(account.get_balance()) # 输出: 150
16

17
# print(account.__balance) # 报错！无法直接访问私有属性

5. 继承 (Inheritance)#

继承允许我们创建一个新类（子类），从现有的类（父类）继承属性和方法。这提高了代码的复用性。

1
# 父类
2
class Animal:
3
    def speak(self):
4
        print("Animal speaks")
5

6
# 子类继承父类
7
class Dog(Animal):
8
    def speak(self):
9
        print("Woof!")  # 重写父类方法
10

11
class Cat(Animal):
12
    pass
13

14
dog = Dog()
15
dog.speak() # 输出: Woof!
16

17
cat = Cat()
18
cat.speak() # 输出: Animal speaks (直接继承父类方法)

`super()` 函数#

子类可以使用 super() 调用父类的方法，常用于扩展父类的 __init__ 方法。

1
class Bird(Animal):
2
    def __init__(self, name, can_fly):
3
        super().__init__() # 调用父类构造方法（如果有的话）
4
        self.name = name
5
        self.can_fly = can_fly

6. 多态 (Polymorphism)#

多态指“多种形态”。不同的子类对象调用相同的方法，产生不同的行为。

上面的 Dog 和 Cat 都继承自 Animal 并调用 speak() 方法，但表现不同，这就是多态。

1
def animal_sound(animal):
2
    animal.speak()
3

4
dog = Dog()
5
cat = Cat()
6

7
animal_sound(dog) # 输出: Woof!
8
animal_sound(cat) # 输出: Animal speaks

总结#

类是模板，对象是实例。
属性描述特征，方法描述行为。
封装保护数据安全。
继承实现代码复用。
多态提供灵活的接口。

掌握这些概念，你就迈入了 Python 面向对象编程的大门！

分类

1. 类 (Class) 与 对象 (Object)#