class UserModel:
    # 屬性定義順序?qū)π蛄谢苤匾?
    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):
    """獲取類屬性定義順序的函數(shù)"""
    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（方法解析順序）遍歷類層次結(jié)構(gòu)
    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__
        # 動態(tài)計算屬性順序
        attributes = [attr for attr in cls.__dict__ if not attr.startswith('__')]
        return attributes
    
    def to_ordered_dict(self):
        """將對象轉(zhuǎn)換為有序字典"""
        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):
        """將對象轉(zhuǎn)換為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):
        """生成創(chuàng)建表的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")

# 生成創(chuàng)建表的SQL
print(User.get_create_table_sql())

from flask import jsonify
from collections import OrderedDict

class APIModel:
    """API響應(yīng)模型基類"""
    
    @classmethod
    def get_response_order(cls):
        """獲取API響應(yīng)字段順序"""
        return cls.__attribute_order__
    
    def to_api_response(self, include_fields=None, exclude_fields=None):
        """轉(zhuǎn)換為API響應(yīng)格式"""
        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:
    """配置節(jié)，保持配置項順序"""
    
    def __init__(self, name):
        self.name = name
        self.__options = OrderedDict()
        self.__option_order = []
    
    def set_option(self, key, value, order_index=None):
        """設(shè)置配置項，可指定順序"""
        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版本的屬性獲取函數(shù)"""
    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"

# 獲取屬性時需要區(qū)分來源
def get_original_attribute_order(cls):
    """獲取原始類屬性順序（排除元類和裝飾器添加的屬性）"""
    original_attrs = []
    # 通過分析類源碼或其他方式獲取原始屬性順序
    # 這可能需要進行靜態(tài)分析或使用其他高級技術(shù)
    return original_attrs

class OptimizedOrderMeta(type):
    """優(yōu)化性能的元類，預(yù)計算屬性順序"""
    def __new__(cls, name, bases, namespace):
        # 在類創(chuàng)建時計算屬性順序
        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__

# 使用緩存結(jié)果，性能最優(yōu)
order = OptimizedClass.get_attribute_order()