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__
__init__
，Python类中还有哪些常用的特殊方法（魔术方法）？
Python的特殊方法，也常被称为“魔术方法”或“双下划线方法”（dunder methods），它们是Python语言内部用于实现特定行为的钩子。
__init__
无疑是最常用、最基础的一个，因为它负责对象的初始化。但除了它，还有很多其他特殊方法能让你的类功能更强大，行为更“Pythonic”。
我们来聊几个我在日常开发中经常会用到的：
__str__(self)
和
__repr__(self)
：字符串表示
__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.yp1 = Point(1, 2)p2 = Point(1, 2)p3 = Point(3, 4)print(p1 == p2) # Trueprint(p1 == p3) # Falseprint(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
、
。
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, Redprint(f"Car2: {car2.brand}, {car2.color}") # BMW, Bluecar1.color = "Black" # 修改car1的颜色，不影响car2print(f"Car1 after change: {car1.color}") # Blackprint(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方法，但这次是修改实例的skillsclass 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__
方法中将其定义为实例属性。
以上就是python如何创建一个类和对象_python面向对象编程之类与对象创建的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1372795.html
微信扫一扫 
支付宝扫一扫 
