以Python 3 Patterns, Recipes and Idioms为例，我们可以使用一个简单的模式将其转换为Kotlin。
1.输出表达式
1.输入列表/序列和变量
1.任选 predicate
这些直接关联到集合类的Kotlin函数扩展。输入序列，后面是filter lambda中的可选 predicate ，后面是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版本中不需要变量，因为隐含的it变量在每个lambda中使用。在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]

而这个例子对于Map理解来说有点古怪，但在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比列表/集合/Map解析增加了更多的功能，因为它可以对这些集合类型进行广泛的函数转换。
• 参见Get Factors of Numbers in Kotlin，它展示了Python理解与Kotlin理解的另一个例子。
• 请参见API参考指南中的Kotlin Extensions Functions for Collections。

仅就练习而言，最接近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}
}

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

相当于以下Python代码

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

Map理解

import kotlin.math.sqrt

val numbers = "1,2,3,4".split(",")

val roots = numbers.associate { n -> n.toInt() to sqrt(n.toFloat()) }

println(roots)  // prints {1=1.0, 2=1.4142135, 3=1.7320508, 4=2.0}

如果键是源列表的未转换元素，则更简单：

val roots = numbers.associateWith { n -> sqrt(n.toFloat()) }