Python中的类和对象通过类定义对象模板，对象是类的实例，实现数据与行为的封装，支持继承、组合与特殊方法，提升代码复用性、可维护性与现实建模能力。
Python中的类和对象，其实就是我们构建复杂程序时，手里最趁手的两把“锤子”和“凿子”。它们让我们能把那些抽象的、现实世界中的概念，比如“一辆车”、“一个用户”或者“一份文档”，转化成计算机能够理解和操作的代码实体。简单来说，类是蓝图，定义了这类事物的共同特征和行为；而对象，则是根据这张蓝图制造出来的具体实例，每个实例都有自己的状态。
在Python里，我们用类和对象来组织代码，让它更接近我们思考问题的方式。想想看，如果我们要管理一堆关于“人”的信息，每个“人”都有姓名、年龄、职业这些属性，还能做“打招呼”、“工作”这些动作。用类，我们就能定义一个
Person
的蓝图，然后根据这个蓝图创建无数个具体的“人”对象，每个对象都是独立的个体，但都遵循
Person
类的定义。这不仅让代码结构清晰，也大大提升了代码的复用性和可维护性。
解决方案
要真正理解并运用Python中的类和对象，我们得从它们的定义和实例化开始。
一个类，用
class
关键字来定义。它就像一个模板，里面包含了属性（数据）和方法（行为）。比如，我们想创建一个
Dog
类：
立即学习“Python免费学习笔记（深入）”；
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 familiarisprint(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) # Redprint(another_car.color) # Black
类属性（Class Attributes）：这些属性是属于类本身的，所有该类的实例共享同一个值。它们直接在类定义体中，方法之外定义。比如
Dog.species
。
class Car: wheels = 4 # 类属性，所有Car对象都有4个轮子 def __init__(self, brand, color): self.brand = brand self.color = colorprint(Car.wheels) # 4my_car = Car("Tesla", "Red")print(my_car.wheels) # 4 (通过实例访问类属性)# 陷阱：如果你通过实例去修改类属性，实际上会创建或修改一个同名的实例属性！my_car.wheels = 6 # 这并没有改变Car.wheels，而是给my_car对象添加了一个名为wheels的实例属性print(my_car.wheels) # 6print(Car.wheels) # 4 (类属性没变)another_car = Car("BMW", "Black")print(another_car.wheels) # 4 (其他实例的类属性也没变)# 要修改类属性，应该通过类名来修改Car.wheels = 5print(Car.wheels) # 5print(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.0Product.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 * bprint(MathUtil.add(5, 3)) # 8print(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 = ydef __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) # 调用 strprint(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中类和对象基本用法的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1368898.html
微信扫一扫 
支付宝扫一扫 
