Python获取类属性的定义顺序的实战指南

class UserModel:
    # 属性定义顺序对序列化很重要
    user_id: int
    username: str
    email: str
    created_at: datetime

class ExampleClass:
    attribute1 = "value1"
    attribute2 = "value2" 
    attribute3 = "value3"

# 获取属性定义顺序
attributes = list(ExampleClass.__dict__.keys())
# 过滤掉特殊方法和非属性成员
filtered_attributes = [attr for attr in attributes if not attr.startswith('__')]
print(filtered_attributes)
# 输出: ['attribute1', 'attribute2', 'attribute3']

import inspect

class MyClass:
    def __init__(self):
        self.first_attribute = "first"
        self.second_attribute = "second" 
        self.third_attribute = "third"

def get_class_attribute_order(class_obj):
    """获取类属性定义顺序的函数"""
    attributes = []
    # 使用inspect.getmembers检查类成员
    for name, obj in inspect.getmembers(class_obj, lambda obj: not inspect.isroutine(obj)):
        # 过滤掉特殊方法
        if not name.startswith("__") and not name.endswith("__"):
            attributes.append(name)
    return attributes

class_instance = MyClass()
attribute_order = get_class_attribute_order(MyClass)
print(attribute_order)
# 输出: ['first_attribute', 'second_attribute', 'third_attribute']

class BaseClass:
    base_attr1 = "base1"
    base_attr2 = "base2"

class DerivedClass(BaseClass):
    derived_attr1 = "derived1" 
    derived_attr2 = "derived2"

def get_class_attributes_with_inheritance(cls):
    """获取包含继承属性的顺序列表"""
    attributes = {}
    # 按照MRO（方法解析顺序）遍历类层次结构
    for base_class in reversed(cls.__mro__):
        for attr_name, attr_value in base_class.__dict__.items():
            if not attr_name.startswith('__'):
                attributes[attr_name] = attr_value
    return list(attributes.keys())

# 获取派生类的属性顺序
attr_order = get_class_attributes_with_inheritance(DerivedClass)
print(attr_order)
# 输出: ['base_attr1', 'base_attr2', 'derived_attr1', 'derived_attr2']

class AttributeOrderMeta(type):
    """记录属性定义顺序的元类"""
    def __new__(cls, name, bases, namespace):
        # 提取类属性（排除特殊方法）
        attributes = [key for key in namespace if not key.startswith('__')]
        # 将属性顺序存储在类的__attribute_order__中
        namespace['__attribute_order__'] = attributes
        return super().__new__(cls, name, bases, namespace)

class OrderedClass(metaclass=AttributeOrderMeta):
    attr_z = "z"
    attr_a = "a" 
    attr_m = "m"
    
    def __init__(self):
        self.instance_attr = "instance"  # 实例属性不影响类属性顺序

# 直接访问属性顺序
print(OrderedClass.__attribute_order__)
# 输出: ['attr_z', 'attr_a', 'attr_m']

import json
from collections import OrderedDict

class Serializable:
    """支持按定义顺序序列化的基类"""
    @classmethod
    def get_attribute_order(cls):
        """获取类属性定义顺序"""
        if hasattr(cls, '__attribute_order__'):
            return cls.__attribute_order__
        # 动态计算属性顺序
        attributes = [attr for attr in cls.__dict__ if not attr.startswith('__')]
        return attributes
    
    def to_ordered_dict(self):
        """将对象转换为有序字典"""
        ordered_dict = OrderedDict()
        for attr_name in self.get_attribute_order():
            if hasattr(self, attr_name):
                ordered_dict[attr_name] = getattr(self, attr_name)
        return ordered_dict
    
    def to_json(self, indent=None):
        """将对象转换为JSON字符串，保持字段顺序"""
        return json.dumps(self.to_ordered_dict(), indent=indent)

class User(Serializable):
    user_id = None
    username = None
    email = None
    
    def __init__(self, user_id, username, email):
        self.user_id = user_id
        self.username = username
        self.email = email

# 使用示例
user = User(1, "john_doe", "john@example.com")
print(user.to_json(indent=2))
# 输出保持属性定义顺序的JSON

class OrderedAttribute:
    """支持顺序管理的描述符"""
    def __init__(self, order_index):
        self.order_index = order_index
    
    def __set_name__(self, owner, name):
        self.name = name
        # 在所有者类中注册属性顺序
        if not hasattr(owner, '__attribute_order__'):
            owner.__attribute_order__ = []
        owner.__attribute_order__.append(name)
        # 保持顺序排序
        owner.__attribute_order__.sort(key=lambda x: getattr(owner.__dict__.get(x), 'order_index', 0))

class OrderedClass:
    attr_first = OrderedAttribute(1)
    attr_second = OrderedAttribute(2)
    attr_third = OrderedAttribute(3)
    
    def __init__(self):
        self.attr_first = "first"
        self.attr_second = "second"
        self.attr_third = "third"

# 属性顺序按照order_index排序
print(OrderedClass.__attribute_order__)
# 输出: ['attr_first', 'attr_second', 'attr_third']

class ORMModel:
    """ORM模型基类"""
    @classmethod
    def get_field_order(cls):
        """获取字段顺序，用于生成DDL语句"""
        field_order = []
        for attr_name in cls.__attribute_order__:
            if hasattr(cls, attr_name) and isinstance(getattr(cls, attr_name), Field):
                field_order.append(attr_name)
        return field_order
    
    @classmethod
    def get_create_table_sql(cls):
        """生成创建表的SQL语句，保持字段顺序"""
        fields = []
        for attr_name in cls.get_field_order():
            field_obj = getattr(cls, attr_name)
            fields.append(f"{attr_name} {field_obj.field_type}")
        
        sql = f"CREATE TABLE {cls.__tablename__} (\n"
        sql += ",\n".join(f"  {field}" for field in fields)
        sql += "\n);"
        return sql

class Field:
    def __init__(self, field_type):
        self.field_type = field_type

class User(ORMModel):
    __tablename__ = "users"
    
    id = Field("INTEGER PRIMARY KEY")
    name = Field("VARCHAR(100)")
    email = Field("VARCHAR(255)")
    created_at = Field("TIMESTAMP")

# 生成创建表的SQL
print(User.get_create_table_sql())

from flask import jsonify
from collections import OrderedDict

class APIModel:
    """API响应模型基类"""
    
    @classmethod
    def get_response_order(cls):
        """获取API响应字段顺序"""
        return cls.__attribute_order__
    
    def to_api_response(self, include_fields=None, exclude_fields=None):
        """转换为API响应格式"""
        response_data = OrderedDict()
        field_order = self.get_response_order()
        
        for field in field_order:
            # 字段过滤逻辑
            if include_fields and field not in include_fields:
                continue
            if exclude_fields and field in exclude_fields:
                continue
            if hasattr(self, field):
                response_data[field] = getattr(self, field)
        
        return response_data

class Product(APIModel):
    product_id = None
    product_name = None
    price = None
    category = None
    
    def __init__(self, product_id, name, price, category):
        self.product_id = product_id
        self.product_name = name
        self.price = price
        self.category = category

# 在Flask路由中使用
@app.route('/api/products/<int:product_id>')
def get_product(product_id):
    product = Product.query.get(product_id)
    return jsonify(product.to_api_response())

import configparser
from collections import OrderedDict

class ConfigSection:
    """配置节，保持配置项顺序"""
    
    def __init__(self, name):
        self.name = name
        self.__options = OrderedDict()
        self.__option_order = []
    
    def set_option(self, key, value, order_index=None):
        """设置配置项，可指定顺序"""
        self.__options[key] = value
        if order_index is not None:
            self.__option_order.append((order_index, key))
            self.__option_order.sort()
        else:
            self.__option_order.append((len(self.__option_order), key))
    
    def get_options_ordered(self):
        """按顺序获取配置项"""
        return OrderedDict((key, self.__options[key]) for _, key in self.__option_order)
    
    def save_to_file(self, filename):
        """保存配置到文件，保持顺序"""
        config = configparser.ConfigParser()
        config.read_dict({self.name: self.get_options_ordered()})
        
        with open(filename, 'w') as f:
            config.write(f)

# 使用示例
app_config = ConfigSection("Application")
app_config.set_option("name", "MyApp", 1)
app_config.set_option("version", "1.0.0", 2)
app_config.set_option("debug", "True", 3)

app_config.save_to_file("app.conf")

import sys

def get_class_attributes_compatible(cls):
    """兼容不同Python版本的属性获取函数"""
    if sys.version_info >= (3, 7):
        # Python 3.7+ 直接使用__dict__
        attributes = [attr for attr in cls.__dict__ if not attr.startswith('__')]
        return attributes
    else:
        # 早期版本使用inspect或其他方法
        try:
            from inspect import getmembers
            attributes = []
            for name, obj in getmembers(cls, lambda obj: not callable(obj)):
                if not name.startswith('__'):
                    attributes.append(name)
            return attributes
        except ImportError:
            # 回退方案
            return sorted([attr for attr in cls.__dict__ if not attr.startswith('__')])

def add_timestamp_decorator(cls):
    """添加时间戳属性的类装饰器"""
    cls.created_at = "2023-01-01"
    cls.updated_at = "2023-01-01"
    return cls

class MetaClass(type):
    def __new__(cls, name, bases, namespace):
        # 元类添加的属性
        namespace['meta_added'] = 'meta'
        return super().__new__(cls, name, bases, namespace)

@add_timestamp_decorator
class ExampleClass(metaclass=MetaClass):
    original_attr = "original"

# 获取属性时需要区分来源
def get_original_attribute_order(cls):
    """获取原始类属性顺序（排除元类和装饰器添加的属性）"""
    original_attrs = []
    # 通过分析类源码或其他方式获取原始属性顺序
    # 这可能需要进行静态分析或使用其他高级技术
    return original_attrs

class OptimizedOrderMeta(type):
    """优化性能的元类，预计算属性顺序"""
    def __new__(cls, name, bases, namespace):
        # 在类创建时计算属性顺序
        attributes = [key for key in namespace if not key.startswith('__')]
        namespace['__cached_attribute_order__'] = attributes
        return super().__new__(cls, name, bases, namespace)

class OptimizedClass(metaclass=OptimizedOrderMeta):
    attr1 = "value1"
    attr2 = "value2"
    
    @classmethod
    def get_attribute_order(cls):
        """直接返回缓存的属性顺序"""
        return cls.__cached_attribute_order__

# 使用缓存结果，性能最优
order = OptimizedClass.get_attribute_order()