Python类与对象详解：从基础语法到面向对象编程核心概念

七月

发布时间：2026-10-12| 2人浏览过

原创

本文深入解析Python中的类与对象，涵盖类定义语法、实例变量与类变量的区别、__init__构造函数的作用以及方法的实现。详细讲解面向对象编程（OOP）核心概念，包括继承机制、多态性表现及抽象类的实现，通过代码示例展示如何构建可复用、低耦合的Python程序结构。

一、什么是Python类？

在Python中，类被视为创建特定对象的蓝图。它提供了一种构建软件的结构化方式。核心问题在于如何实现这一目标？类允许我们将数据和函数以逻辑且易于重用的方式进行分组，并在需要时实例化。参考下图进行理解。

在第一张图片（A）中，展示了一张被视为“类”的房屋蓝图。利用同一份蓝图，我们可以构建多栋房屋，这些具体的房屋即为“对象”。使用类可以为程序带来一致性，使其以更简洁、高效的方式运行。属性是通过点表示法访问的数据成员，包括类变量和实例变量；而方法则是定义在类中的函数，用于描述对象的行为。

类变量是指被该类的所有不同对象或实例所共享的变量。
实例变量是每个实例独有的变量。它通常在方法内部定义，且仅归属于类的当前特定实例。
方法，也称为函数，是在类内部定义的，用于描述对象的具体行为。

接下来，让我们看看在PyCharm环境中类是如何工作的。首先，我们需要了解Python类的语法结构。

语法如下：

class Class_name:
statement-1
.
.
statement-N

在上述代码中，“class”语句用于创建一个新的类定义。类名紧跟在Python关键字“class”之后，并以冒号结尾。以下是一个创建Python类的具体示例：

class employee:
 pass
 #no attributes and methods
 emp_1=employee()
 emp_2=employee()
 #instance variable can be created manually
 emp_1.first='aayushi'
 emp_1.last='Johari'
 emp_1.email='aayushi@edureka.co'
 emp_1.pay=10000
 
emp_2.first='test'
 emp_2.last='abc'
 emp_2.email='test@company.com'
 emp_2.pay=10000
 print(emp_1.email)
 print(emp_2.email)

输出结果如下：

aayushi@edureka.co

test@company.com

如果不想手动设置这些变量怎么办？代码量较大时容易出错。为了实现自动化，我们可以使用“__init__”方法。为此，我们需要深入理解Python类中的方法和属性具体指代什么。

二、Python类中的方法和属性

2.1、Python类中的方法

若没有功能支持，创建类是不完整的。因此，可以通过设置各种属性来定义功能，这些属性充当了与相关数据和功能的容器。在Python中，函数也被称为方法。关于“__init__”方法，它是一种特殊函数，每当实例化该类的新对象时自动调用。你可以将其视为初始化方法，或者如果你熟悉C++、Java等其他面向对象编程语言，可以将其理解为构造函数。当我们在类中定义方法时，它们会自动接收实例作为第一个参数。接下来，让我们继续使用Python类，并通过此方法接收名字、姓氏和薪水。

class employee:
    def __init__(self, first, last, sal):
        self.fname=first
        self.lname=last
        self.sal=sal
        self.email=first + '.' + last + '@company.com'
 
emp_1=employee('aayushi','johari',350000)
emp_2=employee('test','test',100000)
print(emp_1.email)
print(emp_2.email)

在“__init__”方法中，我们设置了这些实例变量（self、first、last、sal）。这里的self代表实例本身，这意味着每当我们编写self.fname=first时，其效果等同于emp_1.first='aayushi'。随后，我们创建了员工类的实例，并传递了__init__方法中指定的值。该方法将实例作为参数传入，从而自动完成赋值，无需手动操作。

接下来，我们希望执行某些特定操作。为此，我们将向此类添加一个方法。假设我们需要显示员工全名的功能，让我们实际实现这一点。

class employee:
    def __init__(self, first, last, sal):
        self.fname=first
        self.lname=last
        self.sal=sal
        self.email=first + '.' + last + '@company.com'
 
    def fullname(self):
            return '{}{}'.format(self.fname,self.lname)
 
emp_1=employee('aayushi','johari',350000)
emp_2=employee('test','test',100000)
print(emp_1.email)
print(emp_2.email)
print(emp_1.fullname())
print(emp_2.fullname())

输出结果如下：

aayushi.johari@company.com

test.test@company.com

aayushijohari

TESTTEST

如上文所示，我在类中创建了一个名为“fullname”的方法。Python类中的每个方法都会自动将实例作为第一个参数。在此方法中，我编写了打印全名并返回该值的逻辑。接着，我使用了“self”，以确保该方法适用于所有实例。因此，每次调用该方法时，它都会针对当前实例进行操作。

继续使用Python类，存在一些在所有实例之间共享的变量，这些被称为类变量。而实例变量对于每个实例可以是唯一的，例如姓名、电子邮件、薪水等。这是否复杂？让我们通过一个例子来理解。请参阅以下代码以了解工资年度增长的计算方式。

class employee:
    perc_raise =1.05
    def __init__(self, first, last, sal):
        self.fname=first
        self.lname=last
        self.sal=sal
        self.email=first + '.' + last + '@company.com'
 
    def fullname(self):
            return '{}{}'.format(self.fname,self.lname)
    def apply_raise(self):
        self.sal=int(self.sal*1.05)
 
emp_1=employee('aayushi','johari',350000)
emp_2=employee('test','test',100000)
 
print(emp_1.sal)
emp_1.apply_raise()
print(emp_1.sal)

输出结果如下：

350000

367500

如上文所示，我先打印了工资，然后应用了1.5%的增长。要访问这些类变量，我们需要通过类本身或类的实例来进行访问。现在，让我们进一步了解Python类中的各种属性。

2.2、Python类中的属性

Python中的属性定义了对象、元素或文件的特征。属性主要分为两种类型：

内置类属性：Python类中存在各种内置属性，例如__dict__、__doc__、__name__等。沿用之前的例子，我想查看employee1的所有键值对。为此，你可以简单地编写以下包含类命名空间的语句：

打印语句

（emp_1.__dict__）

执行之后，你会得到如下输出：

{'fname': 'aayushi', 'lname': 'johari', 'sal': 350000, 'email': 'aayushi.johari@company.com'}

用户定义的属性：属性是在类定义中创建的。我们可以为类的现有实例动态创建新属性。属性也可以绑定到类名上。

接下来，我们涉及public（公有）、protected（受保护）和private（私有）属性。让我们详细了解它们的具体区别：

接下来，让我们了解Python类中最重要的组件，即对象。

正如我们上面讨论的，对象可用于访问不同的属性。它用于创建类的实例。实例是在运行时创建的类的具体对象。

给你一个快速浏览，对象主要是看到周围的一切。例如：狗是动物类的对象，我是人类类的对象。同样，同一个电话类可以有不同的对象。这与我们已经讨论过的函数调用非常相似。让我们通过一个例子来理解这一点：

class MyClass:
 
   def func(self):
      print('Hello')
 
# create a new MyClass
ob = MyClass()
ob.func()

继续使用python类，让我们了解各种OOP概念。

三、面向对象的概念

OOPs指的是Python中的面向对象编程。严格来说，Python并非完全面向对象，因为它包含一些过程式函数。现在，你或许想知道过程式编程和面向对象编程之间的区别。为了消除疑问：在过程式编程中，整个代码被写入一个长流程，即使它可能包含函数和子例程。由于数据和逻辑混合在一起，代码难以管理。而当我们谈论面向对象编程时，程序被拆分为独立的对象或几个小程序。每个对象代表应用程序的不同部分，拥有自己的数据和逻辑来进行通信。例如，一个网站包含不同的对象，如图像、视频等。

面向对象编程包括Python类、对象、继承、多态、抽象等概念，下面让我们详细了解这些主题。

3.1、Python类：继承

继承允许我们从基类（父类）中继承属性和方法。这非常有用，因为我们可以创建子类并从父类中获取所有功能。然后，我们可以在不影响父类的情况下覆盖和添加新功能。让我们通过一个例子来理解父类和子类的概念。

正如我们在图像中看到的，孩子继承了父亲的属性。同样，在Python中，涉及两个类：

1. 父类（Super或Base类）

2. 子类（子类或派生类）

继承属性的类称为子类，而被继承属性的类称为父类。

继承是指创建包含其父类专业化的子类的能力。它进一步分为四种类型，即单继承、多级继承、分层继承和多重继承。请参考下图以获得更好的理解。

让我们继续使用Python类并了解继承是如何有用的。

比如说，我想为员工类型创建类。我将创建'developers'和'managers'作为子类，因为开发人员和经理都有姓名、电子邮件和薪水，所有这些功能都在员工类中。因此，我们不必复制子类的代码，而是可以通过从员工类继承来简单地重用代码。

class employee:
    num_employee=0
    raise_amount=1.04
    def __init__(self, first, last, sal):
        self.first=first
        self.last=last
        self.sal=sal
        self.email=first + '.' + last + '@company.com'
        employee.num_employee+=1
    def fullname (self):
        return '{} {}'.format(self.first, self.last)
    def apply_raise (self):
        self.sal=int(self.sal * raise_amount)
class developer(employee):
    pass
 
emp_1=developer('aayushi', 'johari', 1000000)
print(emp_1.email)

输出结果：

aayushi.johari@company.com

正如您在上面的输出中看到的，employee类的所有详细信息都可以在developer类中找到。现在，如果我想将开发人员的raise_amount更改为10%怎么办？让我们看看它是如何实际完成的。

class employee:
    num_employee=0
    raise_amount=1.04
    def __init__(self, first, last, sal):
        self.first=first
        self.last=last
        self.sal=sal
        self.email=first + '.' + last + '@company.com'
        employee.num_employee+=1
    def fullname (self):
        return '{} {}'.format(self.first, self.last)
    def apply_raise (self):
        self.sal=int(self.sal* raise_amount)
 
class developer(employee):
    raise_amount = 1.10
 
emp_1=developer('aayushi', 'johari', 1000000)
print(emp_1.raise_amount)

如您所见，它已将工资增长百分比从4%更新为10%。现在，如果我想再添加一个属性，比如在__init__方法中使用一种编程语言，但它在我们的父类中不存在。有什么解决办法吗？是的！我们可以复制整个员工逻辑并这样做，但它会再次增加代码大小。因此，为了避免这种情况，让我们考虑以下代码：

class employee:
    num_employee=0
    raise_amount=1.04
    def __init__(self, first, last, sal):
        self.first=first
        self.last=last
        self.sal=sal
        self.email=first + '.' + last + '@company.com'
        employee.num_employee+=1
    def fullname (self):
        return '{} {}'.format(self.first, self.last)
    def apply_raise (self):
        self.sal=int(self.sal* raise_amount)
class developer(employee):
    raise_amount = 1.10
    def __init__(self, first, last, sal, prog_lang):
        super().__init__(first, last, sal)
        self.prog_lang=prog_lang
 
emp_1=developer('aayushi', 'johari', 1000000, 'python')
print(emp_1.prog_lang)

因此，只用一点点代码，我就进行了更改。我使用了super().__init__(first, last, pay)，它继承了基类的属性。总之，继承用于重用代码并降低程序的复杂性。

3.2、Python类：多态性

计算机科学中的多态性是指为不同的底层形式呈现相同接口的能力。实际上，多态意味着如果类B从类A继承，它不必继承关于类A的所有内容，它可以做一些与类A不同的事情。它最常用于处理继承。Python是隐式多态的，它能够重载标准运算符，以便它们根据上下文具有适当的行为。

让我们通过一个例子来理解：

class Animal:
    def __init__(self,name):
        self.name=name
        def talk(self):
            pass
class Dog(Animal):
            def talk(self):
                print('Woof')
class Cat(Animal):
    def talk(self):
        print('MEOW!')
c= Cat('kitty')
c.talk()
d=Dog(Animal)
d.talk()

输出结果：

Meow!Woof

接下来，让我们转向另一个面向对象的编程概念，即抽象。

3.3、Python类：抽象

抽象用于通过建模适合问题的类来简化复杂的现实。在这里，我们有一个无法实例化的抽象类。这意味着您不能为这些类创建对象或实例。它只能用于继承您称为基类的某些功能。因此，您可以继承功能，但同时，您无法创建此特定类的实例。让我们通过下面的例子来理解抽象类的概念：

from abc import ABC, abstractmethod     
 
class Employee(ABC):
    @abstractmethod
 
    def calculate_salary(self,sal):
        pass
 
class Developer(Employee):
 
    def calculate_salary(self,sal):
        finalsalary= sal*1.10
        return  finalsalary
 
emp_1 = Developer()
print(emp_1.calculate_salary(10000))

输出结果：