如何将Python字典转换为Scala等价类型（Map）？

针对你70万条目的静态硬编码Python字典转Scala不可变Map的需求，推荐以下几个易快速实现的方案，按优先级排序：

方案1：Python脚本直接生成Scala硬编码Map（最快实现） #

利用Python脚本读取原字典，直接转换为Scala的Map语法，一次性生成可直接使用的Scala代码。适合静态数据的一次性转换，无需依赖第三方库。

步骤&代码示例 #

1. 将原Python脚本中MyData的字典内容提取出来（或直接读取整个文件），用以下Python脚本转换：

import ast

# 读取原Python字典文件
with open('mydata.py', 'r', encoding='utf-8') as f:
    content = f.read()

# 提取MyData对应的字典对象（处理末尾的省略号）
data_str = content.split('MyData = ')[1].rstrip(', ....\n')
data_dict = ast.literal_eval(data_str)

# 递归转换为Scala语法
def to_scala(obj):
    if isinstance(obj, dict):
        items = []
        for k, v in obj.items():
            # Scala Map的键值对格式："key" -> value
            items.append(f'"{k}" -> {to_scala(v)}')
        return f'Map({", ".join(items)})'
    elif isinstance(obj, list):
        elements = [to_scala(e) for e in obj]
        return f'List({", ".join(elements)})'
    elif isinstance(obj, str):
        # 转义字符串中的双引号避免语法错误
        escaped_str = obj.replace('"', '\\"')
        return f'"{escaped_str}"'
    else:
        return str(obj)

# 生成Scala代码，指定精确类型（也可根据需要调整）
scala_code = f'''
// 自动生成的Scala不可变Map
val MyData: Map[String, Map[String, Map[String, Any]]] = {to_scala(data_dict)}
'''

# 保存到Scala文件
with open('MyData.scala', 'w', encoding='utf-8') as f:
    f.write(scala_code)

2. 运行该Python脚本，得到的MyData.scala文件可直接引入到你的Scala项目中使用。

注意点 #

• 如果原字典中的字符串包含双引号，脚本已处理转义；若有其他特殊字符，可自行扩展to_scala函数处理。
• 生成的Scala文件可能体积较大，但因为是静态硬编码，运行时无需额外解析，效率较高。

方案2：生成带Case Class的类型安全代码（更规范） #

原字典的子结构固定（包含name/id/realms/iso字段），可以定义Scala Case Class来替代最内层的Map[String, Any]，获得类型安全和更好的代码可读性。

步骤&代码示例 #

1. 修改上述Python脚本的to_scala函数，识别最内层字典并转换为Case Class实例：

def to_scala(obj):
    if isinstance(obj, dict):
        # 判断是否是最内层的业务数据结构
        if all(key in obj for key in ['name', 'id', 'realms', 'iso']):
            escaped_name = obj['name'].replace('"', '\\"')
            escaped_id = obj['id'].replace('"', '\\"')
            escaped_iso = obj['iso'].replace('"', '\\"')
            return f'RealmData("{escaped_name}", "{escaped_id}", {to_scala(obj["realms"])}, "{escaped_iso}")'
        else:
            items = []
            for k, v in obj.items():
                items.append(f'"{k}" -> {to_scala(v)}')
            return f'Map({", ".join(items)})'
    elif isinstance(obj, list):
        elements = [to_scala(e) for e in obj]
        return f'List({", ".join(elements)})'
    elif isinstance(obj, str):
        escaped_str = obj.replace('"', '\\"')
        return f'"{escaped_str}"'
    else:
        return str(obj)

# 生成包含Case Class定义的Scala代码
scala_code = f'''
// 定义业务数据结构
case class RealmData(name: String, id: String, realms: List[String], iso: String)

// 自动生成的类型安全不可变Map
val MyData: Map[String, Map[String, RealmData]] = {to_scala(data_dict)}
'''

2. 运行脚本生成Scala代码，引入项目后可直接按类型访问字段（如MyData("590")("69035").name），无需类型转换。

方案3：JSON文件加载（适合超大数据量） #

如果生成的Scala硬编码文件过大导致编译缓慢，可以将Python字典导出为JSON，在Scala中通过JSON库加载转换为Map/Case Class。

步骤&代码示例 #

1. Python导出JSON：

import ast
import json

with open('mydata.py', 'r', encoding='utf-8') as f:
    content = f.read()
data_str = content.split('MyData = ')[1].rstrip(', ....\n')
data_dict = ast.literal_eval(data_str)

# 导出为JSON文件
with open('mydata.json', 'w', encoding='utf-8') as f:
    json.dump(data_dict, f, ensure_ascii=False)

2. Scala加载JSON（以Circe库为例）：
   首先在sbt.build中添加依赖：

libraryDependencies ++= Seq(
  "io.circe" %% "circe-core" % "0.14.6",
  "io.circe" %% "circe-parser" % "0.14.6"
)

然后编写Scala加载代码：

import io.circe._
import io.circe.parser._

// 定义业务数据结构
case class RealmData(name: String, id: String, realms: List[String], iso: String)

object RealmData {
  // 自动生成JSON解码器
  implicit val decoder: Decoder[RealmData] = Decoder.forProduct4("name", "id", "realms", "iso")(RealmData.apply)
}

object DataLoader {
  // 加载JSON并转换为不可变Map，仅初始化一次
  val MyData: Map[String, Map[String, RealmData]] = {
    val jsonContent = scala.io.Source.fromFile("mydata.json", "utf-8").mkString
    decode[Map[String, Map[String, RealmData]]](jsonContent) match {
      case Right(data) => data
      case Left(error) => throw new RuntimeException(s"加载数据失败: ${error.getMessage}")
    }
  }
}

优点 #

• Scala代码简洁，编译速度快；
• 数据与代码分离，后续修改数据无需重新编译代码。

内容的提问来源于stack exchange，提问作者Alex Kerr