python如何创建一个类和对象_python面向对象编程之类与对象创建-Python教程-PHP中文网

Python中类是创建对象的蓝图，使用class定义，通过实例化生成具体对象；类属性被所有实例共享，而实例属性每个对象独立拥有；特殊方法如__init__、__str__、__eq__等可定制对象行为；需注意可变类属性可能导致的数据共享陷阱。

python如何创建一个类和对象_python面向对象编程之类与对象创建

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)
登录后复制
：字符串表示

北极象沉浸式AI翻译
免费的北极象沉浸式AI翻译 - 带您走进沉浸式AI的双语对照体验

0

查看详情
- __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}")   # ['跑步', '跳跃'] - 这才是我们想要的！

登录后复制

这个“可变类属性”的坑，在设计类时要特别小心。如果你希望每个实例都有自己独立的数据副本，即便它们的初始值相同，也务必在