# 列表排序
id_list = [5, 2, 9, 1, 7] 

sorted_list = sorted(id_list)

# 单条件排序
@dataclass  # from dataclasses import dataclass
class Box:
    weight: int
    # 其他字段...
box_data = [Box(10), Box(5), Box(20)]

box_data.sort(key=lambda x: x.weight, reverse=True)  # 降序

# 多条件排序 
@dataclass  # from dataclasses import dataclass
class Order:
    time_priority: int
    total_vol: int
    # 其他字段...
order_map: Dict[int, Order] = {  # from typing import Dict, List
    1: Order(time_priority=3, total_vol=100),
    2: Order(time_priority=1, total_vol=200),
    3: Order(time_priority=2, total_vol=150),
}
packed_orders: List[int] = [1, 2, 3]

# 排序：先按 time_priority 升序，再按 total_vol 降序
packed_orders.sort(
    key=lambda order: (-order_map[order].time_priority,order_map[order].total_vol), 
    reverse=True)

// 列表排序
std::vector<int> id_list = {5, 2, 9, 1, 7}; 

auto sorted_list = id_list; // 先拷贝一份
std::sort(sorted_list.begin(), sorted_list.end()); 

// 单条件排序
struct Box { int weight; 
             // 其他字段 };
std::vector<Box> box_data = { {10}, {5}, {20} };

std::sort(box_data.begin(), box_data.end(), [](const Box& a, const Box& b) {
	return a.weight > b.weight; });  // > 降序

// 多条件排序 
struct Order {
    int timePriority;
    int totalVol;
    // 其他字段
};
std::unordered_map<int, Order> orderMap; 
std::vector<int> packedOrders = {1, 2, 3}; 

// 排序：timePriority升序，totalVol降序
std::sort(packedOrders.begin(), packedOrders.end(), 
		  [](const auto& a, const auto& b) {
	return std::make_tuple(-orderMap[a]->timePriority, orderMap[a]->totalVol) >
		   std::make_tuple(-orderMap[b]->timePriority, orderMap[b]->totalVol);
});