python入门五：类

geminigoth

173人浏览 · 2026-06-16 10:30:00

geminigoth · 2026-06-16 10:30:00 发布

1 创建和使用类

面向对象编程时最有效的软件编写方法之一。在面向对象编程中，编写表示现实世界中的事物和情景的类(class),并基于这些类来创建对象(object)。在编写类时，要定义一批对象都具备这种通用行为。然后，可根据需要赋予每个对象独特的个性。

根据类来创建对象称为实例化，是可以使用类的实例。使用类几乎可以模拟任何东西。

1.1 创建类

class Dog:
    #模拟狗属性和行为
    def __init__(self,name,age):
        #初始化属性：name 和 age
        self.name = name
        self.age = age

    #定义sit方法
    def sit(self):
        print(f"{self.name} 现在坐下")

    #定义eat方法
    def eat(self):
        print(f"{self.name} 吃骨头")

    def speak(self):
        print(f"你的名字是:{self.name}。今年{self.age}岁了")

代码解释：

1、首先定义一个名为Dog的类。根据约定，在Python中，首字母大写的名称指的是类。定义类时不加括号。

2、__init__()方法：是一个特殊方法，每当创建Dog实例时，Python都会自动运行这个方法。这个方法的名称中，开头和末尾各有两个下划线，是一种约定。本方法包含三个形参：self、name和age。在这个方法的定义中，形参self必不可少，而且必须位于其他形参的前面。Python在调用这方法来创建Dog实例时，将自动传入实参self。每个与实例相关联的方法调用都会自动创建实参self，该实参是一个指向实例本身的引用，让实例能够访问类中属性和方法。当创建Dog实例时，Python将调用Dog类的__init__（）方法。将通过实参向Dog（）传递名字和年龄；self则会自动传递。因此每当创建Dog实例时，只需要给最后的两个形参(name和age)赋值。

在__init__()方法内定义了两个变量都有前缀self。以self为前缀的变量可供类中的所有方法使用，可以通过类的任意实例来访问。self.name = name获取与形参name相关联的值，并将其赋给变量name，然后该变量被关联到当前创建的实例。像这样可以通过实例访问的变量称为属性。

还定义了三个方法：由于这些方法执行时不需要额外的信息，因此只有一个形参self。后面创建的实例能够访问这些方法。

1.2 根据类创建实例

实例如下：

dog_1 = Dog('wangcai',4)
print(f"你的名字是:{dog_1.name},今年{dog_1.age}岁了")
dog_1.sit()
dog_1.eat()
dog_1.speak()

创建一个名为'wangcai'、年龄为4岁的🐶。在处理这行代码时，Python调用Dog类的__init__()方法，并传入实参'wangcai'和4。__init__()方法创建一个表示特定🐶的实例，并且使用提供的值设置name和age属性。接下来，Python返回一个表示这条🐶的示例，然后将这个示例赋值给dog_1。

2 使用类和实例

可以使用类来模拟现实世界的很多场景。类编写好后，大部分时间将花在创建类的实例上。你需要完成的首要任务之一就是修改实例的属性。既可以直接修改实例的属性，也可以编写方法以特定的方式进行修改。

2.1 创建一个类

class Car:
    def __init__(self,make,model,year):
        #初始化属性
        self.make = make
        self.model = model
        self.year = year
    def get_descript(self):
        #返回描述信息
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()
my_car_1 = Car("Ford","Mustang",2020)
print(my_car_1.get_descript())

2.2 给属性指定默认值

有些属性无需通过形参来定义，可以在__init__()方法中为其指定默认值。下面来添加一个名为odometer_reading的属性，定义汽车的里程数，初始值为0。并创建一个read_odometer()的方法获取汽车的里程数。

class Car:
    def __init__(self,make,model,year):
        #初始化属性
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0

    def get_descript(self):
        #返回描述信息
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()

    def read_odometer(self):
        return self.odometer_reading

my_car_1 = Car("Ford","Mustang",2020)
print(my_car_1.get_descript())
print(my_car_1.read_odometer())

2.3 修改属性的值

可以用三种方式修改属性的值：直接通过实例修改、通过方法设置、通过方法递增(增加特定的值)

2.3.1 直接修改属性的值

修改上面实例中的里程数

class Car:
    def __init__(self,make,model,year):
        #初始化属性
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0

    def get_descript(self):
        #返回描述信息
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()

    def read_odometer(self):
        return self.odometer_reading

my_car_1 = Car("Ford","Mustang",2020)
print(my_car_1.get_descript())
my_car_1.odometer_reading = 100
print(my_car_1.read_odometer())

在创建实例后，只用点号直接访问指定的属性，并对该属性赋值。

2.3.2 通过方法修改属性的值

在Car类中新增update_odometer方法，用来更新属性。

class Car:
    def __init__(self,make,model,year):
        #初始化属性
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0

    def get_descript(self):
        #返回描述信息
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()

    def read_odometer(self):
        return self.odometer_reading
    # 修改里程数，此时增加一个形参
    def update_odometer(self,odometer_reading):
        self.odometer_reading = odometer_reading

my_car_1 = Car("Ford","Mustang",2020)
print(my_car_1.get_descript())
#调用更新方法时，需要传入具体的实参
my_car_1.update_odometer(200)
print(my_car_1.read_odometer())

2.3.3 通过方法让属性的值递增

在Car中新增increment_odometer方法

class Car:
    def __init__(self,make,model,year):
        #初始化属性
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0

    def get_descript(self):
        #返回描述信息
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()

    def read_odometer(self):
        return self.odometer_reading
    # 修改里程数，此时增加一个形参
    def update_odometer(self,odometer_reading):
        self.odometer_reading = odometer_reading

    # 修改里程数，根据传入的形参递增
    def increment_odometer(self,miles):
        self.odometer_reading += miles

my_car_1 = Car("Ford","Mustang",2020)
print(my_car_1.get_descript())
#调用更新方法时，需要传入具体的实参
my_car_1.increment_odometer(300)
print(my_car_1.read_odometer())

3 继承

在编写类时，并非总是从头开始。如果要编写的类是一个既有的类的特殊版本，可使用继承。当一个类继承另一个类时，将自动获得后者的所有属性和方法。原有的类称为父类，新的类称为子类。子类不仅继承了父类的所有属性和方法，还可以定义自己的属性和方法。

3.1 子类的init方法

在父类的基础上编写子类，通常要调用父类的__init__方法。将会初始化在父类的__init__()方法中定义的所有属性，从而让子类也可以使用这些属性。

例如，在上面的基础上，编写子类ElectricCar，继承父类Car。这样，只需编写子类特有的属性和方法即可。

class Car:
    def __init__(self,make,model,year):
        #初始化属性
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0

    def get_descript(self):
        #返回描述信息
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()

    def read_odometer(self):
        return self.odometer_reading
    # 修改里程数，此时增加一个形参
    def update_odometer(self,odometer_reading):
        self.odometer_reading = odometer_reading

    # 修改里程数，根据传入的形参递增
    def increment_odometer(self,miles):
        self.odometer_reading += miles

my_car_1 = Car("Ford","Mustang",2020)
print(my_car_1.get_descript())
#调用更新方法时，需要传入具体的实参
my_car_1.increment_odometer(300)
print(my_car_1.read_odometer())
#定义子类，继承Car类
class ElectricCar(Car):
    def __init__(self,make,model,year):
        #初始化父类的属性
        super().__init__(make,model,year)
my_car_2 = ElectricCar('tesla','model',2020)
print(my_car_2.get_descript())

代码说明：

创建子类时，父类必须包含在当前文件中，且位于子类前面。接下来，在定义子类时，必须在括号里指定父类的名称。__init__()方法接受创建Car实例所需的信息。

super()是一个特殊的函数，可以调用父类的方法。

super().__init__(make,model,year)

这样代码代表调用父类Car的__init__()方法，从而让子类实例包含这个方法定义的所有属性。父类也称超类。

3.2 为子类定义属性和方法

当子类继承父类后，就可以添加区分子类和父类所需的新属性和新方法。下面新增子类特有的属性(电池)，以及一个描述该属性的方法。

#定义子类，继承Car类
class ElectricCar(Car):
    def __init__(self,make,model,year):
        #初始化父类的属性
        super().__init__(make,model,year)
        #初始化子类特有的属性
        self.battery_size = 90

    #创建子类特有的方法
    def get_desc_battery_size(self):
        print(f"电池的容量是: {self.battery_size}")
my_car_2 = ElectricCar('tesla','model',2020)
print(my_car_2.get_descript())
my_car_2.get_desc_battery_size()

3.3 重写父类的方法

在使用子类模拟实物的行为时，如果父类中的一些方法不能满足子类的需求，就可以用下面的办法重写父类的方法：在子类中定义一个与要重写的父类方法相同的名字。这样，Python将忽略父类的方法，只会关注子类中定义的相应方法。

例如：父类中有一个fill_gas_tank()方法，它对子类来说毫无意义，因此可以在子类中重写这个方法。

class Car:
    def __init__(self,make,model,year):
        #初始化属性
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0

    def get_descript(self):
        #返回描述信息
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()

    def read_odometer(self):
        return self.odometer_reading
    # 修改里程数，此时增加一个形参
    def update_odometer(self,odometer_reading):
        self.odometer_reading = odometer_reading

    # 修改里程数，根据传入的形参递增
    def increment_odometer(self,miles):
        self.odometer_reading += miles

    #父类的该方法对子类无用
    def fill_gas_tank(self,tank_size):
        self.gas_tank = tank_size


my_car_1 = Car("Ford","Mustang",2020)
print(my_car_1.get_descript())
#调用更新方法时，需要传入具体的实参
my_car_1.increment_odometer(300)
print(my_car_1.read_odometer())

#定义子类，继承Car类
class ElectricCar(Car):
    def __init__(self,make,model,year):
        #初始化父类的属性
        super().__init__(make,model,year)
        #初始化子类特有的属性
        self.battery_size = 90

    #创建子类特有的方法
    def get_desc_battery_size(self):
        print(f"电池的容量是: {self.battery_size}")

    # 重写父类的方法
    def fill_gas_tank(self):
        print(f"该方法对子类不使用")
my_car_2 = ElectricCar('tesla','model',2020)
print(my_car_2.get_descript())
my_car_2.get_desc_battery_size()
my_car_2.fill_gas_tank()

3.4 将实例用作属性

在使用代码模拟实物时，可能会发现自己给类添加了太多细节：属性和方法越来越多，文件越来越长。在这种情况下，可能需要将类的一部分提取出来，作为一个独立的类。将大型类拆分成多个协同工作的小雷，这种方法称为组合。

例如，在不断给ElectricCar类添加细节时，会发现其中包含很多专门对汽车电池的属性和方法。在这种情况下，可以将这些属性和方法提取出来，放到一个名为Battery的类中，并将一个Battery实例作为ElectricCar类的属性。

class Car:
    def __init__(self,make,model,year):
        #初始化属性
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0

    def get_descript(self):
        #返回描述信息
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()

    def read_odometer(self):
        return self.odometer_reading
    # 修改里程数，此时增加一个形参
    def update_odometer(self,odometer_reading):
        self.odometer_reading = odometer_reading

    # 修改里程数，根据传入的形参递增
    def increment_odometer(self,miles):
        self.odometer_reading += miles

    #父类的该方法对子类无用
    def fill_gas_tank(self,tank_size):
        self.gas_tank = tank_size


# 定义Battery类
class Battery:
    def __init__(self, battery_size=40):
        # 初始化电池的属性
        self.battery_size = battery_size

    def describe_battery(self):
        # 打印电池容量
        print(f"这台车拥有{self.battery_size}-KWH 电量")

#定义子类，继承Car类
class ElectricCar(Car):
    def __init__(self,make,model,year):
        #初始化父类的属性
        super().__init__(make,model,year)
        #初始化子类特有的属性
        self.battery = Battery()


my_car_1 = ElectricCar('tesla', 'model s', 2020)
my_car_1.battery.describe_battery();

4 导入类

随着不断给类添加功能，文件可能变得很长，即使使用继承和组合也如此。遵循Python的整体理念，应该让文件尽量整洁。Python允许将类存储到模块中，然后在主程序中导入所需的模块。

4.1 导入单个类

下面创建一个只包含Car类的模块。car.py

class Car:
    #模拟汽车
    def __init__(self,make,model,year):
        #初始化汽车属性
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
        
    def get_desc_name(self):
        #返回格式规范的描述
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()
    
    def read_odometer(self):
        #打印汽车的行驶里程
        print(f"This car has {self.odometer_reading} miles on it.")
        
    def update_odometer(self, mileage):
        #把里程表设置为指定的值，不允许往回调
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("You can't do that!")
            
    def increment_odometer(self, miles):
        #让里程表读数增加指定的值
        self.odometer_reading += miles

然后再创建另一个文件——my.car.py，在其中导入Car类并创建实例：

from car import Car
car1 = Car('audi', 'a4', 2017)
print(car1.get_desc_name())
car1.odometer_reading = 100
car1.read_odometer()
car1.update_odometer(200)
car1.increment_odometer(300)
car1.read_odometer()

import语句让Python打开模块car并导入其中的Car类。

4.2 在一个模块中存储多个类

尽管同一个模块中的类之间应该存在某种相关性，但其实可以根据需要再一个模块中存储任意数量的类。Battery类和ElectricCar类都可以模拟汽车，下面将它们加入到car.py中。

class Car:
    #模拟汽车
    def __init__(self,make,model,year):
        #初始化汽车属性
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0

    def get_desc_name(self):
        #返回格式规范的描述
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()

    def read_odometer(self):
        #打印汽车的行驶里程
        print(f"This car has {self.odometer_reading} miles on it.")

    def update_odometer(self, mileage):
        #把里程表设置为指定的值，不允许往回调
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("You can't do that!")

    def increment_odometer(self, miles):
        #让里程表读数增加指定的值
        self.odometer_reading += miles
        
class Battery:
    #模拟电动汽车电池
    def __init__(self,battery_size=50):
        self.battery_size = battery_size
        
    def get_desc_battery(self):
        #打印电池容量
        print(f"This car has a {self.battery_size} kwh battery.")
        
    def get_range(self):
        #打印电池续航里程
        if self.battery_size == 100:
            range = 240
        elif self.battery_size == 150:
            range = 300
        
        print(f"汽车还能行驶{self.range} 公里.")

class ElectricCar(Car):
    #模拟电动汽车
    def __init__(self, make,model,year):
        #先初始化父类属性，在初始化电动汽车特有的属性
        super.__init__(make,model,year)
        self.battery = Battery()

现在创建一个名为my_electric_car.py的文件，导入ElectricCar类，并创建一辆电动汽车：

from car import ElectricCar

my_car_01 = ElectricCar('BYD','han',2024)
print(my_car_01.get_desc_name())
my_car_01.battery.get_desc_battery()
my_car_01.battery.get_range()

4.3 从一个模块中导入多个类

可以根据需要，在程序文件中导入任意数量的类。如果在同一个程序中创建燃油汽车和电动汽车，就需要将Car类和ElectricCar类都导入。下面创建my_cars.py文件。

from car import Car,ElectricCar
my_car01 = Car('bmw',1999,2000)
print(my_car01.get_desc_name())
my_car02 = ElectricCar('tesla','model',2023)
print(my_car02.get_desc_name())

4.4 导入整个模块

还可以先导入整个模块，在使用点号访问需要的类。这种导入方法很简单，代码也易读。由于创建类实例的代码都包含模块名，因此不会与当前文件使用的任何名称发生冲突。

修改上面的my_cars.py文件。

import car
my_car_01 = car.Car('BYD','han',2024)
print(my_car_01.get_desc_name())
my_car_02 = car.ElectricCar('tesla', 'model', 2023)
print(my_car_02.get_desc_name())

4.5 在一个模块中导入另一个模块

有时候，需要将类分散到多个模块中，避免模块太大或者在同一个模块中存储不相关的类。在将类存储在多个模块中时，可能会发现一个模块中的类依赖另一个模块中的类。在这种情况下，可在前一个模块中导入必要的类。

下面将Car类存储在一个模块中，并将ElectricCar和Battery类存储到另一个模块中。将第二个模块命名为electric_car.py。electric_car.py代码如下：

from car import Car
class Battery:
    #模拟电动汽车电池
    def __init__(self,battery_size=100,range=100):
        self.battery_size = battery_size
        self.range = range

    def get_desc_battery(self):
        #打印电池容量
        print(f"This car has a {self.battery_size} kwh battery.")

    def get_range(self):

        #打印电池续航里程
        if self.battery_size == 100:
            self.range = 240
        elif self.battery_size == 150:
            self.range = 300

        print(f"汽车还能行驶{self.range} 公里.")

class ElectricCar(Car):
    #模拟电动汽车
    def __init__(self, make,model,year):
        #先初始化父类属性，在初始化电动汽车特有的属性
        super().__init__(make,model,year)
        self.battery = Battery()

在更新car.py，使其只包含car的定义

class Car:
    #模拟汽车
    def __init__(self,make,model,year):
        #初始化汽车属性
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0

    def get_desc_name(self):
        #返回格式规范的描述
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()

    def read_odometer(self):
        #打印汽车的行驶里程
        print(f"This car has {self.odometer_reading} miles on it.")

    def update_odometer(self, mileage):
        #把里程表设置为指定的值，不允许往回调
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("You can't do that!")

    def increment_odometer(self, miles):
        #让里程表读数增加指定的值
        self.odometer_reading += miles

修改my_cars.py，使其分别从每个模块中导入类：

from car import Car
from electric_car import ElectricCar
my_car01 = Car('bmw',1999,2000)
print(my_car01.get_desc_name())
my_car02 = ElectricCar('tesla','model',2023)
print(my_car02.get_desc_name())

4.6 使用别名

当使用模块来组织项目代码时，别能能发挥很大作用。在导入类时，可以给它指定别名。假设在程序中需要创建大量的电动汽车实例，需要反复输入ElectricCar，很繁琐，可以在import语句中给ElectricCar指定一个简单的别名：

from electric_car import ElectricCar as EC

后面需要创建电动汽车实例时，可以用这个别名：

my_car_01 = ec('BYD','han',2024)

还可以给模块指定别名。

import electric_car as ec
my_car_01 = ec.ElectricCar("subaru", "9000", 2018)
print(my_car_01.get_desc_name())

AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

2026最新AI Agent高频面试题（分类型精简详解）

本文梳理AI Agent高频面试考点，覆盖基础概念、架构、推理规划、工具调用、记忆、RAG融合、多智能体与工程落地。区分Agent、Workflow与普通工具调用，讲解ReAct、Plan‑and‑Execute等主流范式，分析三级记忆机制与上下文溢出的解决办法，对比传统RAG与Agent‑RAG差异，介绍多智能体协作模式。同时总结落地痛点、优化手段和安全风控要点，划分初/中/高级面试复习重点，可