Kotlin 中的 Python 列表、集合和映射推导等价物是啥？

Posted 2023-02-23

【中文标题】Kotlin 中的 Python 列表、集合和映射推导等价物是啥？

【英文标题】：What is the equivalent of Python list, set, and map comprehensions in Kotlin?Kotlin 中的 Python 列表、集合和映射推导等价物是什么？

【发布时间】：2018-10-23 17:41:42

【问题描述】：

在 Python 中，映射和集合有列表推导和类似的构造。在 Kotlin 中，任何具有相似名称的文档中都没有任何内容。

这些理解的等价物是什么？例如，在Python 3 Patterns, Recipes and Idioms 中找到的那些。其中包括对以下内容的理解：

列表 设置 字典

注意： 此问题由作者 (Self-Answered Questions) 特意编写和回答，以便提供对 Kotlin 常见问题的惯用答案在 SO。

【问题讨论】：

形式为“什么是语言 Y 中的语言 X 特征的等价物”形式的问题不需要与任何语言 X 标记相关联。

【参考方案1】：

以Python 3 Patterns, Recipes and Idioms 中的示例为例，我们可以使用简单的模式将每个示例转换为 Kotlin。 Python 版本的列表推导包含 3 个部分：

输出表达式 输入列表/序列和变量 可选谓词

这些与 Kotlin 对集合类的功能扩展直接相关。输入序列，后跟 filter lambda 中的可选谓词，后跟 map lambda 中的输出表达式。所以对于这个 Python 示例：

# === PYTHON

a_list = [1, 2, 3, 4, 5, 6]

#                    output | var | input   | filter/predicate 
even_ints_squared = [ e*e  for e in a_list  if e % 2 == 0 ]

print(even_ints_squared)
# output: [ 4, 16, 36 ]

变成

// === KOTLIN

var aList = listOf(1, 2, 3, 4, 5, 6)

//                    input      |   filter      |       output              
val evenIntsSquared = aList.filter  it % 2 == 0 .map  it * it 

println(evenIntsSquared)
// output: [ 4, 16, 36 ]  

请注意，在 Kotlin 版本中不需要该变量，因为在每个 lambda 中都使用了隐含的 it 变量。在 Python 中，您可以使用 () 而不是方括号将它们变成惰性生成器：

# === PYTHON

even_ints_squared = ( e**2 for e in a_list if e % 2 == 0 )

在 Kotlin 中，通过函数调用 asSequence() 更改输入，它更明显地转换为惰性序列：

// === KOTLIN

val evenIntsSquared = aList.asSequence().filter  it % 2 == 0 .map  it * it 

---

Kotlin 中的嵌套推导是通过将一个嵌套在另一个的 map lambda 中创建的。例如，从 Python 中的PythonCourse.eu 中获取这个示例，稍微更改为同时使用集合和列表推导：

# === PYTHON

noprimes = j for i in range(2, 8) for j in range(i*2, 100, i)
primes = [x for x in range(2, 100) if x not in noprimes]
print(primes)
# output: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

变成：

// === KOTLIN

val nonprimes = (2..7).flatMap  (it*2..99).step(it).toList() .toSet()
val primes = (2..99).filterNot  it in nonprimes 
print(primes)    
// output: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

请注意，嵌套推导会生成一个列表列表，该列表使用flatMap() 转换为平面列表，然后使用toSet() 转换为集合。此外，Kotlin 范围是包容性的，而 Python 范围是专有的，因此您会看到范围中的数字略有不同。

您还可以在 Kotlin 中使用带有协同程序的 sequence 生成器来生成值，而无需调用 flatMap() 或 flatten()：

// === KOTLIN

val nonprimes = sequence 
    (2..7).forEach  (it*2..99).step(it).forEach  value -> yield(value)  
.toSet()
val primes = (2..99).filterNot  it in nonprimes 

---

引用的 Python 页面中的另一个示例是生成矩阵：

# === PYTHON

matrix = [ [ 1 if item_idx == row_idx else 0 for item_idx in range(0, 3) ] for row_idx in range(0, 3) ]
print(matrix)
# [[1, 0, 0], 
#  [0, 1, 0], 
#  [0, 0, 1]] 

在 Kotlin 中：

// === KOTLIN

val matrix = (0..2).map  row -> (0..2).map  col -> if (col == row) 1 else 0 
println(matrix)
// [[1, 0, 0], 
//  [0, 1, 0], 
//  [0, 0, 1]]  

或者在 Kotlin 中代替列表，您也可以生成数组：

// === KOTLIN

val matrix2 = Array(3)  row -> 
                          IntArray(3)  col -> if (col == row) 1 else 0  
                       

---

集合推导的另一个例子是生成一组唯一的正确大小写的名称：

# === PYTHON

names = [ 'Bob', 'JOHN', 'alice', 'bob', 'ALICE', 'J', 'Bob' ]

fixedNames =  name[0].upper() + name[1:].lower() for name in names if len(name) > 1 

print(fixedNames)
# output: 'Bob', 'Alice', 'John'

被翻译成 Kotlin：

// === KOTLIN

val names = listOf( "Bob", "JOHN", "alice", "bob", "ALICE", "J", "Bob" )

val fixedNames = names.filter  it.length > 1 
       .map  it.take(1).toUpperCase() + it.drop(1).toLowerCase() 
       .toSet()

println(fixedNames)
// output: [Bob, John, Alice]

---

而且地图理解的例子有点奇怪，但也可以在 Kotlin 中实现。原文：

# === PYTHON

mcase = 'a':10, 'b': 34, 'A': 7, 'Z':3

mcase_frequency =  k.lower() : mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0) for k in mcase.keys() 

print(mcase_frequency)
# output: 'a': 17, 'z': 3, 'b': 34

以及转换后的内容，这里写得更“罗嗦”，以使发生的事情更清楚：

// === KOTLIN

val mcase = mapOf("a" to 10, "b" to 34, "A" to 7, "Z" to 3)

val mcaseFrequency = mcase.map  (key, _) ->
    val newKey = key.toLowerCase()
    val newValue = mcase.getOrDefault(key.toLowerCase(), 0) +
                   mcase.getOrDefault(key.toUpperCase(), 0)
    newKey to newValue
.toMap()

print(mcaseFrequency)
// output: a=17, b=34, z=3

---

进一步阅读：

Kotlin 添加了比列表/集合/映射推导更多的功能，因为您可以对这些集合类型进行广泛的功能转换。有关更多示例，请参阅 What Java 8 Stream.collect equivalents are available in the standard Kotlin library? 。 请参阅 Get Factors of Numbers in Kotlin ，它显示了 Python 理解与 Kotlin 的另一个示例。 请参阅 API 参考指南中的 Kotlin Extensions Functions for Collections。

【讨论】：

非常好的答案，@Jayson！一个小问题：您在几个地方使用.map it - 可以省略吗？

@Tom 将范围迭代转换为范围内项目的列表。我想当时我试图让它懒惰地从迭代器中出来，但 map 无论如何都会转换为列表，所以我正在编辑上面的示例以拥有 toList()

我做了其他轻微的清理工作，使其更加现代。

【参考方案2】：

只是为了练习，最接近 python 的将是：

infix fun <I, O> ((I) -> O).`in`(range: Iterable<I>): List<O> = range.map(this).toList()
infix fun <I> Iterable<I>.`if`(cond: (I) -> Boolean): List<I> = this.filter(cond)

fun main() 
     it: Int -> it + 1  `in` 1..2 `if` it > 0

【参考方案3】：

val newls = (1..100).filter(it % 7 == 0)

在 Kotlin 中相当于下面的 Python 代码

newls = [i for i in 0..100 if i % 7 ==0]