Python中类是创建对象的蓝图，使用class定义，通过实例化生成具体对象；类属性被所有实例共享，而实例属性每个对象独立拥有；特殊方法如__init__、__str__、__eq__等可定制对象行为；需注意可变类属性可能导致的数据共享陷阱。
Python中创建一个类和对象，核心在于使用
class关键字定义一个蓝图，然后通过调用这个蓝图来“实例化”具体的对象。说白了，类就是你设计图纸，对象就是你根据图纸造出来的具体东西。
解决方案
要创建一个类，我们首先用
class关键字，后面跟着你给类起的名字，通常首字母大写，这是个约定俗成的习惯。然后是冒号，接着就是类的具体内容。
class MyFirstClass:
# 这是一个类属性，所有实例共享
language = "Python"
# __init__ 方法是一个特殊方法，当创建新对象时它会自动运行。
# 这里的self代表正在创建的那个对象本身。
def __init__(self, name, version):
self.name = name # 实例属性
self.version = version # 实例属性
print(f"一个名为 {self.name} 的新对象被创建了！")
# 这是一个实例方法，可以访问对象的属性
def display_info(self):
print(f"对象名称: {self.name}, 版本: {self.version}, 编程语言: {MyFirstClass.language}")
# 另一个方法，演示如何修改属性
def update_version(self, new_version):
self.version = new_version
print(f"{self.name} 的版本已更新为 {self.version}")
# 创建对象（实例化）
# 这就相当于你拿着图纸去造东西了，每次造出来的都是一个独立的新东西。
obj1 = MyFirstClass("HelloApp", "1.0")
obj2 = MyFirstClass("DataProcessor", "2.1")
# 访问对象的属性
print(f"obj1 的名字是: {obj1.name}")
print(f"obj2 的版本是: {obj2.version}")
# 调用对象的方法
obj1.display_info()
obj2.display_info()
# 修改对象属性并再次显示
obj1.update_version("1.1")
obj1.display_info()
# 访问类属性
print(f"所有MyFirstClass的实例都使用: {MyFirstClass.language}")
print(f"obj1 也能访问类属性: {obj1.language}")在这个例子里，
MyFirstClass就是我们定义的类。
__init__方法是构造函数，它会在你创建对象时自动执行，用来初始化对象的属性。
self这个参数有点意思，它总是指向当前正在操作的对象本身，你通过它来设置和访问实例的属性和方法。
obj1和
obj2就是根据
MyFirstClass这个蓝图创建出来的两个独立的对象。它们各自有自己的
name和
version，但都共享
language这个类属性。
Python中类和对象的本质区别是什么？为什么我们需要面向对象编程？
在我看来，类和对象的关系，就像是“模具”和“铸件”一样。类，它是一个抽象的、概念性的“模具”，定义了某种事物的共同特征和行为模式。比如，我们可以定义一个“汽车”类，它规定了所有汽车都应该有品牌、颜色、速度等属性，以及启动、加速、刹车等行为。这个“模具”本身是不能开上路的，它只是一份设计规范。
立即学习“Python免费学习笔记（深入）”；
而对象，则是根据这个“模具”实际“铸造”出来的具体实例。当我实例化一个“汽车”对象时，我得到的是一辆具体的、有特定品牌（比如“特斯拉”）、特定颜色（比如“红色”）、当前速度（比如“0km/h”）的汽车。这辆具体的汽车才能被开动、加速。每个对象都是独立的，即使它们来自同一个类，它们的属性值也可能不同。
那么，我们为什么要用面向对象编程（OOP）呢？这真是一个老生常谈但又不得不提的问题。对我而言，OOP的吸引力在于它能让我们的代码更贴近现实世界的思维模式。当我们处理复杂系统时，自然而然地会把问题分解成一个个独立的“事物”或“实体”，每个实体有自己的状态和行为。
- 模块化和封装性：对象把数据（属性）和操作数据的方法（行为）捆绑在一起，形成一个独立的单元。这就像一个黑箱，你只需要知道它能做什么，而不需要关心它内部是怎么实现的。这大大降低了系统的复杂性，也方便团队协作。
- 代码复用：一旦你定义了一个类，就可以创建任意多个该类的对象，每个对象都拥有类定义的属性和方法。这避免了重复编写相同的代码，提高了开发效率。
- 易于维护和扩展：如果需求发生变化，你通常只需要修改类定义，所有基于该类创建的对象都会随之改变。要增加新功能，可以创建新的类，或者通过继承现有类来扩展，而不会影响到原有代码。
- 抽象：类允许我们关注事物的本质特征，而忽略不重要的细节。比如“动物”类可以抽象出所有动物的共性，而“狗”类则在此基础上增加狗特有的属性和行为。这种分层抽象让系统结构更清晰。
说白了，OOP就是一种组织代码的强大工具，它能帮助我们构建出更健壮、更灵活、更易于理解和管理的大型软件系统。
除了__init__
，Python类中还有哪些常用的特殊方法（魔术方法）？
Python的特殊方法，也常被称为“魔术方法”或“双下划线方法”（dunder methods），它们是Python语言内部用于实现特定行为的钩子。
__init__无疑是最常用、最基础的一个，因为它负责对象的初始化。但除了它，还有很多其他特殊方法能让你的类功能更强大，行为更“Pythonic”。
我们来聊几个我在日常开发中经常会用到的：
-
__str__(self)
和__repr__(self)
：字符串表示
PHP Apache和MySQL 网页开发初步下载本书全面介绍PHP脚本语言和MySOL数据库这两种目前最流行的开源软件，主要包括PHP和MySQL基本概念、PHP扩展与应用库、日期和时间功能、PHP数据对象扩展、PHP的mysqli扩展、MySQL 5的存储例程、解发器和视图等。本书帮助读者学习PHP编程语言和MySQL数据库服务器的最佳实践，了解如何创建数据库驱动的动态Web应用程序。
-
__str__
：这个方法定义了当对象被str()
函数调用或在print()
函数中被打印时，应该返回什么样的“用户友好”的字符串表示。它通常是为终端用户准备的，力求可读性。 -
__repr__
：这个方法定义了对象的“官方”字符串表示。它应该是一个明确的、无歧义的字符串，理想情况下，它应该是一个合法的Python表达式，能够重建出该对象（如果可能的话）。它主要面向开发者，用于调试和日志记录。 -
一个经验法则：如果只实现一个，通常是
__repr__
。如果__str__
没有实现，print()
会退而求其次调用__repr__
。
class Product: def __init__(self, name, price): self.name = name self.price = price def __str__(self): return f"产品: {self.name}, 价格: ${self.price:.2f}" def __repr__(self): # 理想情况下，repr应该能重建对象 return f"Product(name='{self.name}', price={self.price})" my_product = Product("Laptop", 1200.50) print(my_product) # 调用 __str__ print(str(my_product)) # 调用 __str__ print(repr(my_product)) # 调用 __repr__ # 在交互式解释器中直接输入对象名，也会调用 __repr__ -
-
__eq__(self, other)
：相等性比较- 这个方法定义了当使用
==
运算符比较两个对象时，应该如何判断它们是否相等。如果不实现，默认会比较对象的内存地址，这通常不是我们想要的。
class Point: def __init__(self, x, y): self.x = x self.y = y def __eq__(self, other): if not isinstance(other, Point): # 确保other也是Point类型 return NotImplemented return self.x == other.x and self.y == other.y p1 = Point(1, 2) p2 = Point(1, 2) p3 = Point(3, 4) print(p1 == p2) # True print(p1 == p3) # False print(p1 == (1, 2)) # False, 因为__eq__里判断了类型这里
NotImplemented
是个不错的实践，它告诉Python“我不知道怎么比较这个类型，你看看other
对象有没有实现它的__eq__
”。 - 这个方法定义了当使用
这些只是冰山一角，还有用于算术运算（
__add__,
__sub__）、容器行为（
__len__,
__getitem__）、上下文管理（
__enter__,
__exit__）等等。掌握这些特殊方法，能让你写的类与Python的内置行为无缝集成，用起来更顺手。
Python类属性和实例属性有什么不同？它们的使用场景和潜在坑点？
理解类属性和实例属性的区别，对于写出健壮、可维护的Python代码至关重要。我见过不少初学者在这里犯迷糊，导致一些意想不到的行为。
-
实例属性 (Instance Attributes)
-
定义：通常在
__init__
方法中，通过self.attribute_name = value
来定义。 - 特性：每个对象（实例）都有自己独立的一套实例属性。它们的值可以不同，互不影响。
-
使用场景：存储每个对象特有的数据。比如，一个
Car
对象的color
、speed
，一个User
对象的username
、email
。
class Car: def __init__(self, brand, color): self.brand = brand # 实例属性 self.color = color # 实例属性 car1 = Car("Tesla", "Red") car2 = Car("BMW", "Blue") print(f"Car1: {car1.brand}, {car1.color}") # Tesla, Red print(f"Car2: {car2.brand}, {car2.color}") # BMW, Blue car1.color = "Black" # 修改car1的颜色，不影响car2 print(f"Car1 after change: {car1.color}") # Black print(f"Car2 after change: {car2.color}") # Blue -
定义：通常在
-
类属性 (Class Attributes)
- 定义：直接在类定义内部，但在任何方法之外定义。
- 特性：所有该类的实例共享同一个类属性。你可以通过类名或实例名来访问它。如果通过实例名修改类属性，实际上是创建了一个同名的实例属性，并不会修改原始的类属性（除非是可变对象）。
-
使用场景：
- 存储所有实例共有的常量，比如
PI = 3.14159
。 - 存储所有实例共享的配置，比如数据库连接池。
- 记录类的实例数量。
- 作为默认值，当实例没有定义某个属性时，会向上查找类属性。
- 存储所有实例共有的常量，比如
class Robot: population = 0 # 类属性，所有Robot实例共享 def __init__(self, name): self.name = name # 实例属性 Robot.population += 1 # 每次创建新实例，人口计数器加一 def say_hi(self): print(f"你好，我是 {self.name}。") def how_many(self): print(f"目前有 {Robot.population} 个机器人。") robot1 = Robot("R2D2") robot1.say_hi() robot1.how_many() robot2 = Robot("C3PO") robot2.say_hi() robot2.how_many() print(f"通过类名访问人口: {Robot.population}") # 2
潜在的坑点：
最大的坑，也是最常让人困惑的，发生在当类属性是一个可变对象（如列表、字典）时。
如果你将一个可变对象作为类属性，然后通过实例去修改这个可变对象，那么这个修改会影响到所有其他实例，因为它们都共享同一个底层对象。
class Player:
# 这是一个可变类属性，所有Player实例共享同一个skills列表
skills = ["跑步", "跳跃"]
def __init__(self, name):
self.name = name
def add_skill(self, skill):
self.skills.append(skill) # 注意：这里修改的是类属性的skills列表
player1 = Player("Alice")
player2 = Player("Bob")
print(f"Alice's skills (initially): {player1.skills}") # ['跑步', '跳跃']
print(f"Bob's skills (initially): {player2.skills}") # ['跑步', '跳跃']
player1.add_skill("游泳") # Alice添加了技能
print(f"Alice's skills (after add): {player1.skills}") # ['跑步', '跳跃', '游泳']
print(f"Bob's skills (after add): {player2.skills}") # 哎呀！Bob的技能也变成了 ['跑步', '跳跃', '游泳']
# 正确的做法是，如果每个实例需要独立的技能列表，应该在__init__中初始化为实例属性
class PlayerCorrect:
def __init__(self, name):
self.name = name
self.skills = ["跑步", "跳跃"] # 每次创建实例时，都给它一个独立的skills列表
player_c1 = PlayerCorrect("Charlie")
player_c2 = PlayerCorrect("David")
player_c1.add_skill("游泳") # 这里会报错，因为PlayerCorrect没有add_skill方法，需要自己实现
# 重新实现add_skill方法，但这次是修改实例的skills
class PlayerCorrected:
def __init__(self, name):
self.name = name
self.skills = ["跑步", "跳跃"] # 每个实例有自己的skills列表
def add_skill(self, skill):
self.skills.append(skill) # 修改的是实例的skills列表
player_c1 = PlayerCorrected("Charlie")
player_c2 = PlayerCorrected("David")
player_c1.add_skill("游泳")
print(f"Charlie's skills: {player_c1.skills}") # ['跑步', '跳跃', '游泳']
print(f"David's skills: {player_c2.skills}") # ['跑步', '跳跃'] - 这才是我们想要的！这个“可变类属性”的坑，在设计类时要特别小心。如果你希望每个实例都有自己独立的数据副本，即便它们的初始值相同，也务必在
__init__方法中将其定义为实例属性。
