实现Locks锁定属性下供应商出库与入库数量的高效映射需求

作为处理过多类似分销库存映射问题的从业者，我得先划重点：Locks属性是整个流程的不可动摇锚点，所有操作都必须优先保证它的数量一致性约束。咱们一步步拆解，从数据预处理到自动化实现，确保高效又合规：

1. 先把数据“捋顺”：标准化预处理 #

首先得解决数据格式不一致的问题，不然匹配肯定出乱子：

• 把Pack type的1X[Y]格式转成纯数字Y（比如1X12就转成12），这样所有数量都能统一到“单件”维度计算——毕竟供应商出库是整箱，入库可能拆成小包装，统一维度才能对齐总数量
• 把Locks属性的格式彻底统一：比如大小写、空格、编码，必须保证供应商侧和入库侧的Locks值完全一模一样，不然锚点就失效了
• 所有条目都换算成总单件数量：比如供应商出2箱，每箱10件，总数量就是20；入库是4个5件的小包装，总数量也是20，这样两边的数量基数就对齐了

2. 锚点优先：先把Locks属性的数量完全对齐 #

这一步是底线，绝对不能出错：

• 把供应商数据和入库数据都按Locks属性分组，分别统计每组的总单件数
  • 如果某组Locks在两边的总数量相等，直接把这组下的所有供应商条目和入库条目关联起来——这部分是完全合规的，因为Locks属性不允许修改，所以它们肯定是对应的
  • 如果某组Locks两边数量不一样，这绝对是数据异常（要么用户录错了，要么重包装时违反了Locks规则），必须先修正这个问题，不然后面的映射都站不住脚

3. 非Locks属性的灵活映射 #

处理完Locks锚点后，剩下的就是没有锁定属性的产品，这部分可以灵活处理，优先保证总数量对齐：

• 先匹配相同属性组合：按Pack type（单件数）、Branch、Country、Distributor name这些属性的组合分组，两边同组合的条目直接按数量映射——这是最合理的，因为这些属性如果没变，说明只是换了包装方式
• 剩余数量按需分配：如果还有属性不匹配的剩余数量，直接按总数量等额分配就行——因为非Locks属性允许修改，只要总数量对得上，不管是跨Branch分销还是拆包重包装，都可以关联起来
• 举个实际例子：供应商侧有1箱（10件）Branch=广州的非Locks产品，入库侧有5个2件的小包装Branch=深圳，总数量都是10，直接把这两个条目映射，标注清楚是“重包装+跨区域分销”就行

4. 自动化实现的伪代码参考 #

如果要让系统自动做这个映射，我写了个Python风格的伪代码，你可以参考逻辑：

# 假设已经预处理好的数据结构：每条包含locks, pack_qty(单件数), total_units(总单件数), branch, country, distributor_name
supplier_records = [...]
warehouse_records = [...]

# --------------------------
# 步骤1：按Locks分组统计
# --------------------------
supplier_locks_groups = {}
for rec in supplier_records:
    lock_key = rec['locks']
    if lock_key not in supplier_locks_groups:
        supplier_locks_groups[lock_key] = {'total': 0, 'records': []}
    supplier_locks_groups[lock_key]['total'] += rec['total_units']
    supplier_locks_groups[lock_key]['records'].append(rec)

warehouse_locks_groups = {}
for rec in warehouse_records:
    lock_key = rec['locks']
    if lock_key not in warehouse_locks_groups:
        warehouse_locks_groups[lock_key] = {'total': 0, 'records': []}
    warehouse_locks_groups[lock_key]['total'] += rec['total_units']
    warehouse_locks_groups[lock_key]['records'].append(rec)

# --------------------------
# 步骤2：验证并构建Locks映射
# --------------------------
lock_mappings = []
for lock_key in supplier_locks_groups:
    if lock_key not in warehouse_locks_groups:
        raise ValueError(f"异常：Locks属性[{lock_key}]在入库数据中不存在")
    if supplier_locks_groups[lock_key]['total'] != warehouse_locks_groups[lock_key]['total']:
        raise ValueError(f"异常：Locks属性[{lock_key}]数量不匹配，供应商[{supplier_locks_groups[lock_key]['total']}] vs 入库[{warehouse_locks_groups[lock_key]['total']}]")
    # 建立该Locks组的映射
    lock_mappings.append({
        'type': 'LOCKS_MATCH',
        'locks': lock_key,
        'supplier_records': supplier_locks_groups[lock_key]['records'],
        'warehouse_records': warehouse_locks_groups[lock_key]['records']
    })

# --------------------------
# 步骤3：处理非Locks数据的映射
# --------------------------
# 筛选出非Locks的记录
supplier_non_lock = [r for r in supplier_records if not r['locks']]
warehouse_non_lock = [r for r in warehouse_records if not r['locks']]

# 先按其他属性组合匹配
non_lock_mappings = []
# 构建属性组合键：(pack_qty, branch, country, distributor_name)
supplier_attr_groups = {}
for rec in supplier_non_lock:
    attr_key = (rec['pack_qty'], rec['branch'], rec['country'], rec['distributor_name'])
    if attr_key not in supplier_attr_groups:
        supplier_attr_groups[attr_key] = {'total': 0, 'records': []}
    supplier_attr_groups[attr_key]['total'] += rec['total_units']
    supplier_attr_groups[attr_key]['records'].append(rec)

warehouse_attr_groups = {}
for rec in warehouse_non_lock:
    attr_key = (rec['pack_qty'], rec['branch'], rec['country'], rec['distributor_name'])
    if attr_key not in warehouse_attr_groups:
        warehouse_attr_groups[attr_key] = {'total': 0, 'records': []}
    warehouse_attr_groups[attr_key]['total'] += rec['total_units']
    warehouse_attr_groups[attr_key]['records'].append(rec)

# 匹配相同属性组合的条目
for attr_key in supplier_attr_groups:
    if attr_key in warehouse_attr_groups:
        match_units = min(supplier_attr_groups[attr_key]['total'], warehouse_attr_groups[attr_key]['total'])
        non_lock_mappings.append({
            'type': 'ATTRS_MATCH',
            'attr_key': attr_key,
            'supplier_records': supplier_attr_groups[attr_key]['records'],
            'warehouse_records': warehouse_attr_groups[attr_key]['records'],
            'mapped_units': match_units
        })
        # 扣除已匹配的数量
        supplier_attr_groups[attr_key]['total'] -= match_units
        warehouse_attr_groups[attr_key]['total'] -= match_units

# 处理剩余未匹配的数量，按总数量等额分配
supplier_remaining = sum(g['total'] for g in supplier_attr_groups.values())
warehouse_remaining = sum(g['total'] for g in warehouse_attr_groups.values())
if supplier_remaining != warehouse_remaining:
    raise ValueError(f"异常：非Locks剩余数量不匹配，供应商[{supplier_remaining}] vs 入库[{warehouse_remaining}]")

# 收集剩余的记录
supplier_remaining_records = []
for g in supplier_attr_groups.values():
    if g['total'] > 0:
        supplier_remaining_records.extend(g['records'])
warehouse_remaining_records = []
for g in warehouse_attr_groups.values():
    if g['total'] > 0:
        warehouse_remaining_records.extend(g['records'])

# 添加剩余数量的映射
non_lock_mappings.append({
    'type': 'REMAINING_ALLOCATE',
    'supplier_records': supplier_remaining_records,
    'warehouse_records': warehouse_remaining_records,
    'mapped_units': supplier_remaining
})

# --------------------------
# 合并最终映射结果
# --------------------------
final_mappings = lock_mappings + non_lock_mappings

5. 最后别忘了验证 #

映射完成后，一定要做两步验证：

• 检查所有供应商条目的总单件数是否等于入库侧的总单件数
• 检查每个Locks分组的数量是否完全一致
• 输出映射结果时，把每条映射的规则（LOCKS_MATCH/ATTRS_MATCH/REMAINING_ALLOCATE）标清楚，方便后续追溯和核对

内容的提问来源于stack exchange，提问作者Naveen Darisi