Python类与对象入门教程

一分耕耘，一分收获！既然打开了这篇文章《Python 类与对象详解教程》，就坚持看下去吧！文中内容包含等等知识点...希望你能在阅读本文后，能真真实实学到知识或者帮你解决心中的疑惑，也欢迎大佬或者新人朋友们多留言评论，多给建议！谢谢！

类是对象的模板，定义属性和方法；实例化创建具体对象。__init__ 初始化实例，self 指向当前对象。类属性共享，实例属性独有。实例方法操作对象状态，类方法用 @classmethod 装饰，操作类本身；静态方法用 @staticmethod 装饰，不依赖类或实例状态，作为工具函数使用。

Python的类定义，在我看来，就是我们对现实世界或抽象概念进行建模的一种方式，它提供了一个蓝图，而实例化则是根据这个蓝图“生产”出具体的、拥有自己状态和行为的个体——对象。简单来说，类是模板，对象是根据模板制造出来的具体物品。

解决方案

要搞懂Python的类定义与实例化，我们得从最基础的语法结构说起。定义一个类，我们用class关键字，后面跟着类的名称，通常遵循驼峰命名法（如MyClass）。类内部可以包含属性（变量）和方法（函数）。而实例化，就是通过调用这个类名，像调用函数一样，来创建一个对象。

# 类的定义
class Car:
    # 类属性：所有Car对象共享的属性
    wheels = 4

    # __init__ 方法：当对象被创建时自动调用，用于初始化实例属性
    def __init__(self, make, model, year):
        # 实例属性：每个Car对象独有的属性
        self.make = make
        self.model = model
        self.year = year
        self.engine_on = False # 默认引擎关闭

    # 实例方法：操作实例属性的行为
    def start_engine(self):
        if not self.engine_on:
            self.engine_on = True
            print(f"The {self.year} {self.make} {self.model}'s engine is now on.")
        else:
            print("The engine is already running.")

    def stop_engine(self):
        if self.engine_on:
            self.engine_on = False
            print(f"The {self.year} {self.make} {self.model}'s engine is now off.")
        else:
            print("The engine is already off.")

    def display_info(self):
        print(f"Car Info: {self.year} {self.make} {self.model}, Wheels: {Car.wheels}")

# 类的实例化
my_car = Car("Toyota", "Camry", 2020)
your_car = Car("Honda", "Civic", 2022)

# 访问实例属性
print(my_car.make) # 输出: Toyota
print(your_car.model) # 输出: Civic

# 调用实例方法
my_car.start_engine() # 输出: The 2020 Toyota Camry's engine is now on.
my_car.display_info() # 输出: Car Info: 2020 Toyota Camry, Wheels: 4
your_car.start_engine()
your_car.stop_engine()

# 访问类属性
print(Car.wheels) # 输出: 4
print(my_car.wheels) # 也可以通过实例访问，但通常建议通过类名访问类属性

这里面有几个关键点：__init__ 方法是每个类定义中非常核心的一部分，它负责在对象创建时进行初始化。self 参数是Python约定俗成的，它代表了当前正在操作的那个实例对象本身。理解了这些，基本上就掌握了Python面向对象编程的门槛。

__init__ 方法：它是构造函数吗？为什么它如此重要？

很多人刚接触Python类的时候，会习惯性地把__init__方法当成其他语言（比如Java或C++）里的构造函数。但严格来说，它并不是。在Python里，当你说my_object = MyClass(...)的时候，实际上会发生两个步骤：首先，Python会调用__new__方法来创建一个新的实例对象；然后，才会调用这个新创建的实例的__init__方法来对它进行初始化。所以，__init__更准确的称呼是“初始化方法”或“初始化器”。

它的重要性不言而喻。想象一下，你生产了一批汽车，但每辆车出厂时，你总得给它贴上品牌、型号、年份这些标签，对吧？__init__就是干这个活儿的。它确保了每个新创建的Car对象在被使用之前，都拥有了它最基本、最核心的状态。如果没有它，或者它初始化不当，你的对象可能就处于一个“未定义”或“不完整”的状态，后续的操作就容易出错了。在我日常开发中，我总是会花时间仔细考虑__init__里需要哪些参数，以及这些参数如何正确地设置实例的初始状态，这往往决定了一个类是否好用、是否健壮。

类属性与实例属性：什么时候该用谁？

这是另一个初学者常犯迷糊的地方。简单来说，类属性是属于类本身的，所有该类的实例都共享同一个类属性。而实例属性则是每个实例独有的，它们的值可以互不影响。

• 类属性 (Class Attributes)：定义在类内部、方法外部的变量。它们通常用来存储那些与类的所有实例都相关、且值通常不变的数据，或者作为所有实例的默认值。比如上面Car例子中的wheels = 4，所有的汽车都有四个轮子，这是汽车这个“物种”的共性，所以它适合作为类属性。如果某个实例修改了类属性，那可能会影响到所有其他实例（除非你先给实例创建了一个同名的实例属性）。

  class MyClass:
      class_var = "I am a class variable"
  
  obj1 = MyClass()
  obj2 = MyClass()
  
  print(obj1.class_var) # I am a class variable
  print(obj2.class_var) # I am a class variable
  
  MyClass.class_var = "Modified by class" # 通过类修改
  print(obj1.class_var) # Modified by class
  print(obj2.class_var) # Modified by class
  
  obj1.class_var = "Modified by obj1" # 这创建了一个新的实例属性，不再是类属性
  print(obj1.class_var) # Modified by obj1
  print(obj2.class_var) # Modified by class (obj2仍然访问的是类属性)

  我个人觉得，类属性很适合用来做一些常量定义或者作为工厂模式中的共享配置。

• 实例属性 (Instance Attributes)：定义在__init__方法内部，并且通过self.attribute_name来赋值的变量。它们是每个对象独有的状态。比如Car的make、model、year，每辆车的品牌型号年份都不一样，所以它们是实例属性。

  class AnotherClass:
      def __init__(self, value):
          self.instance_var = value
  
  obj_a = AnotherClass("Value A")
  obj_b = AnotherClass("Value B")
  
  print(obj_a.instance_var) # Value A
  print(obj_b.instance_var) # Value B

  选择哪种属性，关键在于你这个数据是“共享的”还是“独有的”。如果所有对象都应该有相同的值，或者这个值代表了类本身的特性，那就用类属性；如果每个对象都有自己独立的状态，那就用实例属性。这是一个非常重要的设计决策，直接影响你代码的内存使用和逻辑清晰度。

方法的种类：普通方法、类方法与静态方法，它们有什么区别？

Python的类不仅仅是数据（属性）的容器，它还定义了操作这些数据（或与类相关）的行为（方法）。在Python中，方法主要分为三种：实例方法、类方法和静态方法。

1. 实例方法 (Instance Methods)： 这是我们最常见的方法类型，比如Car类中的start_engine、stop_engine。它们必须接收self作为第一个参数，这个self就是调用该方法的实例对象本身。实例方法可以访问和修改实例属性，也可以访问类属性。它们是对象行为的核心。

   class Example:
       def instance_method(self):
           print(f"This is an instance method, called by {self}")

   当我需要一个方法去改变某个特定对象的状态时，或者这个方法的操作依赖于该对象的具体数据时，我肯定会用实例方法。

2. 类方法 (Class Methods)： 使用@classmethod装饰器来定义。它接收cls作为第一个参数，这个cls代表的是类本身，而不是实例。类方法可以访问和修改类属性，但不能直接访问实例属性（除非通过cls创建新实例）。它们常用于工厂方法，或者操作类属性，或者与类本身相关的操作。

   class MyClassWithMethods:
       class_level_data = "Shared Data"
   
       @classmethod
       def class_method_example(cls, new_data):
           print(f"This is a class method, called by class {cls.__name__}")
           print(f"Current class data: {cls.class_level_data}")
           cls.class_level_data = new_data # 可以修改类属性
           print(f"New class data: {cls.class_level_data}")

   在我看来，类方法非常适合那些不需要特定实例数据，但又需要操作类本身或者创建类实例的场景。比如，你可能有一个类方法，根据不同的输入参数来创建不同类型的对象。

3. 静态方法 (Static Methods)： 使用@staticmethod装饰器来定义。它不接收self也不接收cls作为第一个参数。静态方法与类或实例都没有直接关系，它就像一个普通的函数，只是恰好被放在了类的命名空间下。它不能访问类属性，也不能访问实例属性。通常用于那些逻辑上与类相关，但又不需要访问类或实例特定数据的工具函数。

   class UtilityClass:
       @staticmethod
       def static_method_example(x, y):
           print("This is a static method.")
           return x + y

   我一般会在什么时候用静态方法呢？当一个函数与类有逻辑上的关联，但它完全不需要访问任何类或实例的状态时。比如，一个数据校验函数，它接收一些参数并返回布尔值，这个函数可能属于某个类，但它本身并不依赖于类的任何内部状态。如果我发现一个方法没有使用self或cls，我就会考虑把它变成一个静态方法，这能让代码更清晰，也暗示了它的独立性。

理解这三种方法的区别，并知道何时使用它们，是写出优雅、高效Python代码的关键。它们提供了不同层次的抽象和控制，让我们可以更灵活地组织代码。

终于介绍完啦！小伙伴们，这篇关于《Python类与对象入门教程》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布文章相关知识，快来关注吧！