Python中类和对象入门教程 Python中类和对象基本用法（对象.用法.入门教程.Python...）

Python中的类和对象通过类定义对象模板，对象是类的实例，实现数据与行为的封装，支持继承、组合与特殊方法，提升代码复用性、可维护性与现实建模能力。

python中类和对象入门教程 python中类和对象基本用法

Python中的类和对象，其实就是我们构建复杂程序时，手里最趁手的两把“锤子”和“凿子”。它们让我们能把那些抽象的、现实世界中的概念，比如“一辆车”、“一个用户”或者“一份文档”，转化成计算机能够理解和操作的代码实体。简单来说，类是蓝图，定义了这类事物的共同特征和行为；而对象，则是根据这张蓝图制造出来的具体实例，每个实例都有自己的状态。

在Python里，我们用类和对象来组织代码，让它更接近我们思考问题的方式。想想看，如果我们要管理一堆关于“人”的信息，每个“人”都有姓名、年龄、职业这些属性，还能做“打招呼”、“工作”这些动作。用类，我们就能定义一个

Person

的蓝图，然后根据这个蓝图创建无数个具体的“人”对象，每个对象都是独立的个体，但都遵循

Person

类的定义。这不仅让代码结构清晰，也大大提升了代码的复用性和可维护性。解决方案

要真正理解并运用Python中的类和对象，我们得从它们的定义和实例化开始。

一个类，用

class

关键字来定义。它就像一个模板，里面包含了属性（数据）和方法（行为）。比如，我们想创建一个

Dog

类：

class Dog:
    # 这是一个类属性，所有Dog对象共享
    species = "Canis familiaris"

    def __init__(self, name, age):
        # __init__ 是构造方法，在创建对象时自动调用
        # self 指代当前对象实例
        self.name = name  # 实例属性
        self.age = age    # 实例属性

    def bark(self):
        # 这是一个方法，定义了Dog对象的行为
        return f"{self.name} says Woof!"

    def get_age(self, human_years_factor=7):
        # 另一个方法，可以带参数
        return self.age * human_years_factor

上面这段代码，

Dog

就是一个类。

species

是类属性，所有狗都是犬科动物。

__init__

方法很关键，它在每次你创建

Dog

对象的时候都会被调用，用来初始化这个对象的特定状态（比如它的名字和年龄）。

self

这个参数是约定俗成的，它代表了正在被操作的那个对象实例本身。

接着，我们就可以根据这个

Dog

蓝图来创建具体的“狗”了，这些具体的“狗”就是对象（或称实例）：

# 创建Dog对象
my_dog = Dog("Buddy", 3)
another_dog = Dog("Lucy", 5)

# 访问对象的属性
print(f"{my_dog.name} is {my_dog.age} years old.") # 输出：Buddy is 3 years old.
print(f"{another_dog.name} is {another_dog.age} years old.") # 输出：Lucy is 5 years old.

# 调用对象的方法
print(my_dog.bark()) # 输出：Buddy says Woof!
print(f"{another_dog.name} is {another_dog.get_age()} human years old.") # 输出：Lucy is 35 human years old.

# 访问类属性
print(Dog.species) # 输出：Canis familiaris
print(my_dog.species) # 也可以通过实例访问类属性

你会发现，

my_dog

和

another_dog

虽然都是

Dog

类的实例，但它们各自拥有独立的

name

和

age

属性。这就是对象的独立性。而

bark()

和

get_age()

方法，则定义了它们能做什么。这就是类和对象最核心的用法。 Python中类和对象究竟解决了什么问题？为什么我们需要它们？

说实话，刚接触类和对象时，很多人会觉得有点绕，甚至会想：“我用几个函数和字典不也能实现类似的功能吗？”确实，对于一些简单的场景，也许可以。但当项目规模开始扩大，或者你需要处理的数据结构变得复杂时，类和对象的优势就显现出来了，它们解决的核心问题归结起来就是：代码的组织、复用和对现实世界的建模。

想象一下，如果你要开发一个游戏，里面有各种各样的角色：玩家、敌人、NPC。每个角色都有生命值、攻击力、位置等属性，还能执行移动、攻击、施法等动作。如果不用类，你可能会为每个角色类型写一堆独立的函数，用字典存储它们的数据。很快，代码就会变得冗长、难以管理，而且一旦需要修改某个角色的行为，你可能要在很多地方进行重复的改动。

而有了类和对象，情况就完全不同了。我们可以创建一个

Character

基类，定义所有角色共有的属性和行为。然后，

Player

、

Enemy

、

NPC

可以继承这个

Character

类，在此基础上添加它们特有的属性和方法。这样一来：

结构清晰，模块化程度高：所有与“角色”相关的数据和操作都封装在
```
Character
```
类及其子类中，一目了然。
代码复用性强（DRY原则）：共同的行为（比如
```
move()
```
）只需在基类中实现一次，所有子类都能直接使用，避免了重复代码。
易于扩展和维护：如果需要增加一种新的角色类型，只需创建一个新的子类，继承现有功能，再添加独特部分即可，不会影响到其他已有的代码。如果需要修改所有角色的某个基础行为，只需修改基类中的对应方法。
更好地模拟现实世界：类和对象的设计哲学，就是将现实世界中的“实体”及其“行为”映射到代码中，这使得我们的程序逻辑更自然，更容易理解和推理。一个
```
Car
```
对象有
```
color
```
、
```
brand
```
属性，有
```
start()
```
、
```
accelerate()
```
方法，这和我们对真实汽车的认知是吻合的。
封装性：类将数据（属性）和操作数据的方法（行为）捆绑在一起，形成一个独立的单元。外部代码通常只能通过定义好的接口（方法）来与对象交互，而无法直接修改其内部状态，这有助于保护数据不被非法访问或修改，提高了程序的健壮性。

所以，类和对象并非只是语法糖，它们是构建复杂、可维护、可扩展软件系统的基石，是面向对象编程（OOP）的核心思想体现。

在Python中，如何正确地定义和使用类的属性与方法？有哪些常见的陷阱？

正确地定义和使用类的属性与方法，是写出健壮Python代码的关键。这里面有些细微之处，初学者常常会混淆，甚至踩坑。

属性的定义与使用：

我们主要关注两种属性：

实例属性（Instance Attributes）：这些属性是每个对象实例独有的。它们通常在

__init__

方法中通过

self.attribute_name = value

来定义和初始化。比如前面

Dog

类中的

name

和

age

。每个

Dog

对象都有自己的名字和年龄。

class Car:
    def __init__(self, brand, color):
        self.brand = brand  # 实例属性
        self.color = color  # 实例属性

my_car = Car("Tesla", "Red")
another_car = Car("BMW", "Black")
print(my_car.color) # Red
print(another_car.color) # Black

类属性（Class Attributes）：这些属性是属于类本身的，所有该类的实例共享同一个值。它们直接在类定义体中，方法之外定义。比如

Dog.species

。

class Car:
    wheels = 4 # 类属性，所有Car对象都有4个轮子

    def __init__(self, brand, color):
        self.brand = brand
        self.color = color

print(Car.wheels) # 4
my_car = Car("Tesla", "Red")
print(my_car.wheels) # 4 (通过实例访问类属性)

# 陷阱：如果你通过实例去修改类属性，实际上会创建或修改一个同名的实例属性！
my_car.wheels = 6 # 这并没有改变Car.wheels，而是给my_car对象添加了一个名为wheels的实例属性
print(my_car.wheels) # 6
print(Car.wheels) # 4 (类属性没变)
another_car = Car("BMW", "Black")
print(another_car.wheels) # 4 (其他实例的类属性也没变)

# 要修改类属性，应该通过类名来修改
Car.wheels = 5
print(Car.wheels) # 5
print(another_car.wheels) # 5 (现在所有新旧实例（除非它们有自己的同名实例属性）都会看到这个新值)

这个“通过实例修改类属性”的陷阱非常常见，一定要注意。如果你的意图是让所有实例共享一个可变对象（比如一个列表或字典），并且希望通过任何实例的修改都能反映到其他实例上，那么你必须通过类名来修改，或者确保你的逻辑是正确的。

方法的定义与使用：

Python中的方法主要有三种类型：

实例方法（Instance Methods）：最常见，第一个参数必须是

self

，它允许方法访问和修改对象实例的属性。

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

    def greet(self): # 实例方法
        return f"Hello, I'm {self.name}."

user1 = User("Alice")
print(user1.greet())

类方法（Class Methods）：使用

@classmethod

装饰器，第一个参数通常命名为

cls

（代表类本身）。类方法可以访问和修改类属性，也可以用于创建类的不同实例（工厂方法）。

class Product:
    discount_rate = 0.10 # 类属性

    def __init__(self, name, price):
        self.name = name
        self.price = price

    @classmethod
    def set_discount(cls, new_rate): # 类方法
        cls.discount_rate = new_rate
        print(f"Discount rate updated to {cls.discount_rate * 100}%")

    def get_final_price(self):
        return self.price * (1 - self.discount_rate)

p1 = Product("Laptop", 1000)
print(f"Original price of {p1.name}: {p1.get_final_price()}") # 900.0

Product.set_discount(0.15) # 通过类调用类方法
print(f"New price of {p1.name}: {p1.get_final_price()}") # 850.0

# 也可以通过实例调用，但通常不推荐，因为它操作的是类
p1.set_discount(0.20)
print(f"New price again: {p1.get_final_price()}") # 800.0

静态方法（Static Methods）：使用

@staticmethod

装饰器，不接受

self

或

cls

作为第一个参数。它们与类或实例的状态无关，更像是放在类命名空间下的普通函数，只是为了逻辑上的归属。

class MathUtil:
    @staticmethod
    def add(a, b): # 静态方法
        return a + b

    @staticmethod
    def multiply(a, b): # 静态方法
        return a * b

print(MathUtil.add(5, 3)) # 8
print(MathUtil.multiply(5, 3)) # 15
# 静态方法可以通过类名或实例名调用，但它们行为一致，因为不依赖实例或类状态

常见的陷阱：

忘记
```
self
```
参数：在实例方法中，如果忘了写
```
self
```
，Python会报错。
在
```
__init__
```
之外定义实例属性：虽然Python允许你在任何方法中为
```
self
```
添加新属性，但这通常不是好习惯。所有核心属性都应该在
```
__init__
```
中初始化，这样可以确保每个新创建的对象都有一致的初始状态。
误用可变类属性：如果一个类属性是一个可变对象（如列表、字典），并通过实例修改它，那么所有实例都会受到影响。这可能是你想要的，也可能不是。如果不是，那么应该在
```
__init__
```
中为每个实例创建独立的副本。
```
class Student:
    # 陷阱：all_students是一个可变类属性
    all_students = []

    def __init__(self, name):
        self.name = name
        Student.all_students.append(self.name) # 每次创建实例都修改了类属性

s1 = Student("Alice")
s2 = Student("Bob")
print(Student.all_students) # ['Alice', 'Bob'] - 这是共享的
```
如果每个学生实例需要有自己独立的列表，那么
```
all_students
```
应该是一个实例属性，或者在
```
__init__
```
中处理。
过度设计：有时我们会把简单的功能也硬塞进类里，导致类结构过于复杂，反而降低了可读性。记住，不是所有东西都需要成为一个类。

理解这些细节，能帮助我们更有效地利用Python的面向对象特性，写出清晰、可维护的代码。

理解了基础，那么Python中对象之间的关系和一些高级特性是怎样的？

当我们开始用类和对象构建更复杂的系统时，仅仅知道如何定义它们是不够的，还需要理解对象之间如何交互，以及Python提供的一些更高级的机制。这就像你学会了造砖头，下一步就是学习如何用砖头盖房子，还要知道怎么用不同的材料和工具。

1. 对象间的关系：组合（Composition）与继承（Inheritance）

这是面向对象设计中最重要的两个概念，它们描述了类与类、对象与对象之间的关系。

继承（"is-a"关系）：一个类可以从另一个类继承属性和方法。子类（派生类）“是”父类（基类）的一种特殊类型。这促进了代码的复用和扩展。

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

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

class Dog(Animal): # 子类，继承Animal
    def speak(self):
        return f"{self.name} says Woof!"

class Cat(Animal): # 子类，继承Animal
    def speak(self):
        return f"{self.name} says Meow!"

my_dog = Dog("Buddy")
my_cat = Cat("Whiskers")
print(my_dog.speak())
print(my_cat.speak())

这里，

Dog

和

Cat

“是”

Animal

的一种。继承是强耦合关系，子类与父类紧密相连。

组合（"has-a"关系）：一个类包含另一个类的对象作为其属性。这意味着一个对象“拥有”或“包含”另一个对象。这是一种更松散的耦合关系，通常比继承更灵活。
```
class Engine:
    def __init__(self, fuel_type):
        self.fuel_type = fuel_type

    def start(self):
        return f"Engine starting with {self.fuel_type}."

class Car:
    def __init__(self, brand, engine_fuel):
        self.brand = brand
        self.engine = Engine(engine_fuel) # Car对象“拥有”一个Engine对象

    def drive(self):
        return f"{self.brand} is driving. {self.engine.start()}"

my_car = Car("Toyota", "Petrol")
print(my_car.drive())
```
```
Car
```
“拥有”一个
```
Engine
```
。组合允许你将复杂对象分解为更小的、可管理的部分，提高了模块化和可维护性。在实际开发中，当不确定使用继承还是组合时，通常倾向于“组合优于继承”的原则，因为它提供了更大的灵活性。

2. 特殊方法（Dunder Methods / Magic Methods）

Python中的类和对象之所以强大且灵活，很大程度上归功于其丰富的特殊方法（名称前后带有双下划线，如

__init__

、

__str__

）。这些方法允许我们自定义对象的行为，使其能够响应内置操作符、函数或语言特性。

```
__str__(self)
```
和
```
__repr__(self)
```
：
- ```
__str__
```
  ：返回对象的“非正式”字符串表示，供用户阅读（比如
```
print()
```
  函数会调用它）。
- ```
__repr__
```
  ：返回对象的“官方”字符串表示，供开发者阅读，目标是能够通过这个字符串重新创建对象。
```
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(x={self.x}, y={self.y})"
```
p = Point(1, 2) print(p) # 调用 str print(repr(p)) # 调用 repr
```
__len__(self)
```
：让你的对象可以使用
```
len()
```
函数。
```
__add__(self, other)
```
：定义
```
+
```
运算符的行为。
```
__getitem__(self, key)
```
和
```
__setitem__(self, key, value)
```
：让你的对象可以像字典或列表一样通过
```
[]
```
进行索引访问。

这些特殊方法让你的自定义对象能无缝地融入Python的生态系统，行为上更像内置类型，极大地提升了代码的表达力和可用性。

3. 封装：私有属性与受保护属性

Python并没有像Java或C++那样严格的“私有”或“保护”访问修饰符。它依赖于一种约定：

单下划线前缀 (
```
_attribute
```
)：表示该属性或方法是“受保护的”（protected），意味着它不应该被外部直接访问，但子类可以访问。这仅仅是一个约定，从技术上讲，你仍然可以访问它。
双下划线前缀 (
```
__attribute
```
)：这会触发Python的名称修饰（name mangling）机制，将属性名变为
```
_ClassName__attribute
```
。这使得外部代码更难直接访问它，但仍然不是绝对私有，只是增加了访问的复杂性。它主要用于避免子类中的同名属性冲突。

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

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            print(f"Deposited {amount}. New balance: {self.__balance}")
        else:
            print("Deposit amount must be positive.")

    def get_balance(self):
        return self.__balance

# account = BankAccount(100)
# account.deposit(50)
# print(account.__balance) # 这会报错：AttributeError
# print(account._BankAccount__balance) # 但你可以通过这种方式访问它，不推荐
# print(account.get_balance())

理解这些机制，能帮助我们设计出更健壮、更易于维护的面向对象程序。它们不是孤立存在的，而是相互配合，共同构建起Python中灵活而强大的对象模型。

以上就是Python中类和对象入门教程 Python中类和对象基本用法的详细内容，更多请关注知识资源分享宝库其它相关文章！

Python中类和对象入门教程 Python中类和对象基本用法（对象.用法.入门教程.Python...）

最近发表

标签列表

Python中类和对象入门教程 Python中类和对象基本用法（对象.用法.入门教程.Python...）

相关阅读

macOS 14环境下解决google-re2安装中的C++标准兼容性问题（兼容性问题.安装.环境.解决.标准...）

Python中大量文件复制的性能优化策略与实践（复制.性能.优化.实践.策略...）

Pandas DataFrame高效提取Top N值及其行列坐标（高效.坐标.行列.提取.Pandas...）

使用Python根据CSV数据筛选JSON日志条目（条目.筛选.数据.日志.Python...）

macOS 14环境下解决google-re2安装失败的指南（失败.安装.环境.解决.指南...）

macOS 14环境下安装google-re2的兼容性解决方案与步骤详解（兼容性.详解.步骤.解决方案.安装...）

最近发表

标签列表