一文掌握Python四大核心数据结构：变量、结构体、类与枚举

文章目录

• • [📊 核心概念对比一览](#📊 核心概念对比一览)
  • • [① 基础变量](#① 基础变量)
    • [② 结构体](#② 结构体)
    • [③ 类](#③ 类)
    • [④ 枚举类型](#④ 枚举类型)
  • [💎 关键区别与选用原则](#💎 关键区别与选用原则)

---

掌握变量、结构体、类和枚举等核心概念，是编写清晰、高效且易于维护代码的关键。下面这个对比表格和详细的代码示例，可以帮你快速梳理它们在 Python 中的核心使用步骤与差异。

📊 核心概念对比一览

数据类型	核心使用步骤	核心操作/特点	主要应用场景
​基础变量​	1. 定义/创建2. 赋值/初始化3. 使用/更新	直接存储单个数据，操作简单高效。	存储简单的临时数据，如计数器、标志位等。
​结构体​	1. 定义结构2. 创建实例3. 访问/修改字段	将多个相关的数据项组合成一个整体，用于组织轻量级数据。	组织轻量级数据，如坐标点、学生成绩等。
​类​	1. 定义类2. 实例化3. 通过方法操作属性	封装数据（属性）和行为（方法），支持继承和多态，用于建模复杂实体。	建模具有行为和状态的复杂实体，如图形对象、业务模型等。
​枚举​	1. 定义枚举2. 访问成员3. 比较与使用	定义一组命名的常量集合，提高代码可读性和安全性。	表示固定的、有限的选项，如状态、类型、模式等。

所有编程语言数据类型的使用步骤是相通的，不同的语言只是表示形式不一样。

下面我们通过具体的 Python 代码来详细演示每一种类型的使用。

① 基础变量

基础变量是编程中最基本的数据存储单元，用于保存单个数据对象的引用。

# 1. 定义与赋值（初始化通常与定义同时进行）
name = "Alice"  # 创建字符串变量
count = 10      # 创建整数变量
score = 98.5    # 创建浮点数变量
is_active = True # 创建布尔变量

# 2. 使用变量
print("Name:", name)  # 输出变量的值
total = count + 1     # 在表达式中使用变量
print("Total:", total)

# 3. 重新赋值（更新）
count = 20      # 修改变量指向新的数据
name = "Bob"
print("Updated count:", count)
print("Updated name:", name)

# 4. 同时为多个变量赋值
x, y, z = 1, 2, 3  # 同时为多个变量赋不同的值
a = b = c = 0      # 同时为多个变量赋相同的值
print(f"x={x}, y={y}, z={z}")
print(f"a={a}, b={b}, c={c}")

# 5. 交换变量的值
x, y = y, x  # Python中交换变量值非常简洁
print(f"After swap: x={x}, y={y}")

② 结构体

Python 中没有内置的"结构体"关键字，但可以通过 namedtuple 或 dataclass(Python 3.7+)实现类似功能，用于组织相关的数据项。

from collections import namedtuple
from dataclasses import dataclass

# 方法1: 使用 namedtuple 定义结构体（轻量级，不可变）
PersonTuple = namedtuple('Person', ['name', 'age', 'job'])

# 创建结构体实例
person1 = PersonTuple("Alice", 30, "Engineer")

# 访问字段（属性）
print(f"{person1.name} is {person1.age} years old, working as an {person1.job}.")

# 方法2: 使用 dataclass 定义结构体（更现代，功能更丰富）
@dataclass
class PersonData:
    name: str
    age: int
    job: str

# 创建实例
person2 = PersonData("Bob", 25, "Designer")

# 访问和修改字段（默认是可变的）
person2.age = 26  # 修改字段值
print(f"{person2.name} is now {person2.age} years old.")

# 结构体通常用于纯数据结构，不包含复杂方法

③ 类

类是面向对象编程的核心，将数据（属性）和操作数据的方法封装在一起，可以创建具有状态和行为的对象。

# 1. 定义类
class Car:
    # 类的初始化方法（构造函数），用于设置初始状态
    def __init__(self, make, model, year, color="white"):  # color带有默认值
        # 2. 初始化属性（实例变量）
        self.make = make
        self.model = model
        self.year = year
        self.color = color
        self.mileage = 0  # 设置默认值
        
    # 3. 定义方法（行为）
    def display_info(self):
        """显示汽车信息"""
        return f"{self.year} {self.make} {self.model} ({self.color}), Mileage: {self.mileage}km"
    
    def update_mileage(self, new_mileage):
        """更新里程，确保新里程不小于当前里程"""
        if new_mileage >= self.mileage:
            self.mileage = new_mileage
        else:
            print("Error: New mileage cannot be less than current mileage!")
    
    def paint_car(self, new_color):
        """给汽车重新喷漆"""
        self.color = new_color
        return f"The car has been repainted to {new_color}"

# 使用类
# 2. 实例化（创建类的实例）
my_car = Car("Toyota", "Camry", 2023)

# 3. 访问属性和调用方法
print(my_car.display_info())  # 调用方法

# 更新对象状态
my_car.update_mileage(15000)
print(my_car.display_info())

my_car.paint_car("blue")
print(my_car.display_info())

# 创建另一个实例
your_car = Car("Honda", "Civic", 2022, "red")
print(your_car.display_info())

④ 枚举类型

枚举（Enum）用于定义一组命名的常量，使代码更清晰、安全。

from enum import Enum, auto

# 1. 定义枚举
class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

class Status(Enum):
    """使用auto()自动分配值"""
    PENDING = auto()
    ACTIVE = auto()
    INACTIVE = auto()

class TrafficLight(Enum):
    """有意义的枚举值"""
    RED = "stop"
    YELLOW = "caution"
    GREEN = "go"

# 2. 访问枚举成员
print(Color.RED)        # 输出: Color.RED
print(Color.RED.value)  # 输出: 1

current_status = Status.ACTIVE
print(current_status)   # 输出: Status.ACTIVE

# 3. 比较枚举成员
if current_status == Status.ACTIVE:
    print("The system is active.")

def handle_traffic_light(light):
    """根据交通灯状态采取行动"""
    if light == TrafficLight.RED:
        return "Stop the vehicle!"
    elif light == TrafficLight.YELLOW:
        return "Slow down!"
    elif light == TrafficLight.GREEN:
        return "Proceed with caution."

# 使用枚举
print(handle_traffic_light(TrafficLight.RED))

# 遍历所有枚举成员
print("All color options:")
for color in Color:
    print(f"{color.name}: {color.value}")

# 通过值获取枚举成员
try:
    selected_color = Color(2)
    print(f"Selected color: {selected_color.name}")
except ValueError as e:
    print(f"Invalid color value: {e}")

💎 关键区别与选用原则

理解这些概念的关键区别，能帮助你在实际编程中做出正确选择：

• ​封装层次​：基础变量封装单个数据；结构体封装一组相关数据；类封装数据及操作数据的方法；枚举封装一组相关常量。

• ​可变性 ​：基础变量通常可变；namedtuple 实现的结构体不可变；类的实例通常可变；枚举成员完全不可变。

• ​选用原则​：

  • 管理独立数据 （如计数器、标志位）用基础变量。
  • 表示纯数据集合 （如坐标、配置项），且数据关系紧密，但不需复杂行为时，用结构体 （dataclass 或 namedtuple）。
  • 建模复杂实体 （如银行账户、用户），不仅包含数据还有行为（方法），或需要使用继承、多态等特性时，用类。
  • 定义固定选项集 （如状态码、类型常量），提高代码可读性和避免无效值时，用枚举。

感谢阅读！如果本文对您有所帮助，请不要吝啬您的【点赞】、【收藏】和【评论】，这将是我持续创作优质内容的巨大动力。