python-scala-collections
Guide for translating Python collection operations to idiomatic Scala. Use when converting Python code that uses lists, dictionaries, sets, or involves collection transformations like map, filter, reduce, sorting, and aggregations.
- License 许可
- Apache-2.0
- 最近更新
- 2026-11-14
- Stars
- ★ 0
- Forks
- 1
01 前言 Front Matter
- name
- python-scala-collections
- description
- Guide for translating Python collection operations to idiomatic Scala. Use when converting Python code that uses lists, dictionaries, sets, or involves collection transformations like map, filter, reduce, sorting, and aggregations.
03 SKILL.md 正文
Python to Scala Collections Translation
Collection Creation
Lists
# Python
empty = []
nums = [1, 2, 3]
repeated = [0] * 5
from_range = list(range(1, 11))
// Scala
val empty = List.empty[Int] // or List[Int]()
val nums = List(1, 2, 3)
val repeated = List.fill(5)(0)
val fromRange = (1 to 10).toList
Dictionaries → Maps
# Python
empty = {}
person = {"name": "Alice", "age": 30}
from_pairs = dict([("a", 1), ("b", 2)])
// Scala
val empty = Map.empty[String, Int]
val person = Map("name" -> "Alice", "age" -> 30)
val fromPairs = List(("a", 1), ("b", 2)).toMap
Sets
# Python
empty = set()
nums = {1, 2, 3}
from_list = set([1, 2, 2, 3])
// Scala
val empty = Set.empty[Int]
val nums = Set(1, 2, 3)
val fromList = List(1, 2, 2, 3).toSet
Transformation Operations
Map
# Python
doubled = [x * 2 for x in nums]
doubled = list(map(lambda x: x * 2, nums))
// Scala
val doubled = nums.map(_ * 2)
val doubled = nums.map(x => x * 2)
Filter
# Python
evens = [x for x in nums if x % 2 == 0]
evens = list(filter(lambda x: x % 2 == 0, nums))
// Scala
val evens = nums.filter(_ % 2 == 0)
val evens = nums.filter(x => x % 2 == 0)
Reduce/Fold
# Python
from functools import reduce
total = reduce(lambda a, b: a + b, nums)
total = sum(nums)
product = reduce(lambda a, b: a * b, nums, 1)
// Scala
val total = nums.reduce(_ + _)
val total = nums.sum
val product = nums.foldLeft(1)(_ * _)
// Use foldLeft when you need an initial value
FlatMap
# Python
nested = [[1, 2], [3, 4]]
flat = [x for sublist in nested for x in sublist]
// Scala
val nested = List(List(1, 2), List(3, 4))
val flat = nested.flatten
// or with transformation:
val flat = nested.flatMap(identity)
Common Operations
Length/Size
| Python | Scala |
|---|---|
len(lst) |
lst.length or lst.size |
len(dct) |
map.size |
Access
| Python | Scala |
|---|---|
lst[0] |
lst(0) or lst.head |
lst[-1] |
lst.last |
lst[1:3] |
lst.slice(1, 3) |
lst[:3] |
lst.take(3) |
lst[3:] |
lst.drop(3) |
dct["key"] |
map("key") (throws if missing) |
dct.get("key") |
map.get("key") (returns Option) |
dct.get("key", default) |
map.getOrElse("key", default) |
Membership
# Python
if x in lst: ...
if key in dct: ...
// Scala
if (lst.contains(x)) ...
if (map.contains(key)) ...
Concatenation
# Python
combined = list1 + list2
merged = {**dict1, **dict2}
// Scala
val combined = list1 ++ list2
val merged = map1 ++ map2
Sorting
# Python
sorted_list = sorted(items)
sorted_desc = sorted(items, reverse=True)
sorted_by_key = sorted(items, key=lambda x: x.name)
items.sort() # in-place
// Scala
val sortedList = items.sorted
val sortedDesc = items.sorted(Ordering[Int].reverse)
val sortedByKey = items.sortBy(_.name)
// Note: Scala collections are immutable by default, no in-place sort
Grouping
# Python
from itertools import groupby
from collections import defaultdict
# Group by key
grouped = defaultdict(list)
for item in items:
grouped[item.category].append(item)
// Scala
val grouped = items.groupBy(_.category)
// Returns Map[Category, List[Item]]
Aggregations
# Python
total = sum(nums)
minimum = min(nums)
maximum = max(nums)
average = sum(nums) / len(nums)
// Scala
val total = nums.sum
val minimum = nums.min
val maximum = nums.max
val average = nums.sum.toDouble / nums.length
Finding Elements
# Python
first_even = next((x for x in nums if x % 2 == 0), None)
all_evens = all(x % 2 == 0 for x in nums)
any_even = any(x % 2 == 0 for x in nums)
// Scala
val firstEven = nums.find(_ % 2 == 0) // Returns Option[Int]
val allEvens = nums.forall(_ % 2 == 0)
val anyEven = nums.exists(_ % 2 == 0)
Zipping
# Python
pairs = list(zip(list1, list2))
indexed = list(enumerate(items))
// Scala
val pairs = list1.zip(list2)
val indexed = items.zipWithIndex
Dictionary/Map Operations
# Python
keys = list(dct.keys())
values = list(dct.values())
items = list(dct.items())
for key, value in dct.items():
process(key, value)
# Update
dct["new_key"] = value
updated = {**dct, "new_key": value}
// Scala
val keys = map.keys.toList
val values = map.values.toList
val items = map.toList // List[(K, V)]
for ((key, value) <- map) {
process(key, value)
}
// Update (creates new map, immutable)
val updated = map + ("new_key" -> value)
val updated = map.updated("new_key", value)
Mutable vs Immutable
Python collections are mutable by default. Scala defaults to immutable.
# Python - mutable
lst.append(4)
lst.extend([5, 6])
dct["key"] = value
// Scala - immutable (creates new collection)
val newList = lst :+ 4
val newList = lst ++ List(5, 6)
val newMap = map + ("key" -> value)
// Scala - mutable (when needed)
import scala.collection.mutable
val mutableList = mutable.ListBuffer(1, 2, 3)
mutableList += 4
mutableList ++= List(5, 6)
Caveat for translation tasks: mutable.ListBuffer + var is a legitimate
tool for local accumulators, but choosing it for a public *Builder
class sacrifices the idiomatic-immutability criterion when the task
flags it (pole-(b) signals: "immutable", "proficient Scala developer",
"idiomatic Scala"). Prefer a case class with copy(...) methods — see
python-scala-idioms/SKILL.md → "Idiomatic Scala expressions of Python
TypeVars" §Companion rules.
Enum member casing
The default for Scala enum members is UpperCamelCase per Scala
naming convention. Python SCREAMING_CASE is the opt-in form only when
the Python source's string values are externally observable AND the task
does not flag Scala naming conventions.
Decision rule
| Task statement contains … | Enum casing |
|---|---|
| "Scala naming conventions", "proficient Scala developer", "idiomatic Scala" | UpperCamelCase |
A Python call site using the Python form (TokenType.STRING, Color.RED) that the evaluator will replicate verbatim |
SCREAMING_CASE |
| Neither of the above | UpperCamelCase (Scala default) |
Cross-link: python-scala-idioms/SKILL.md → "Pick the API-shape ↔
idiomatic axis". Pole (a) with a Python-form call site in the task is the
only path to SCREAMING_CASE.
Default (idiomatic) form
class TokenType(Enum):
STRING = "string"
NUMERIC = "numeric"
TEMPORAL = "temporal"
// Scala - UpperCamelCase case objects (idiomatic default)
sealed trait TokenType { def value: String }
object TokenType {
case object String extends TokenType { val value = "string" }
case object Numeric extends TokenType { val value = "numeric" }
case object Temporal extends TokenType { val value = "temporal" }
}
Opt-in form (pole-(a) with Python-form call sites)
// Only when the task shows evaluator code using `TokenType.STRING`:
object TokenType {
case object STRING extends TokenType { val value = "string" }
case object NUMERIC extends TokenType { val value = "numeric" }
case object TEMPORAL extends TokenType { val value = "temporal" }
}
The value field holds the Python string value either way, so most
behavioural comparisons remain unaffected by the casing choice; the choice
is about which identifier appears in TokenType.XXX references in Scala
code the evaluator may introspect or quote.
04 同仓库更多 Skills
video-frame-extraction
Extract frames from video files and save them as images using OpenCV
openai-vision
Analyze images and multi-frame sequences using OpenAI GPT vision models
image-ocr
Extract text content from images using Tesseract OCR via Python, including structured field extraction from receipts and forms
video-frame-extraction
Extract frames from video files and save them as images using OpenCV
openai-vision
Analyze images and multi-frame sequences using OpenAI GPT vision models
image-ocr
Extract text content from images using Tesseract OCR via Python, including structured field extraction from receipts and forms