hundred_or_less_even_seconds = [
    timedelta(seconds=it)
    for it in range(1, 1001)
    if it <= 100 and it % 2 == 0
  ]

Also the map function lets you perform any operations in it. It was a simple example but you could need to perform something slightly more complex than using another standard library function.

I particularly like Kotlin's scope functions:

https://kotlinlang.org/docs/scope-functions.html

I do prefer python over kotlin but IMHO semantically they're both beautiful and some of the least frictive languages I've ever used

.map(blah(x,y), |z|, if let (x,y) == conditional(z))

  foos = (make_foo(bar) for bar in bars)
  acceptable_foos = (foo for foo in foos if acceptable(foo))
  ...

Someone with kotlin experience could comment too, But I don't think it creates four separate lists. The last map function iterates and asks for element from previous function which asks for element from its parent function. So there is only one list.

    import datetime
    import pandas as pd

    hundred_or_less_even_seconds = (
        pd.Series(range(1, 1000))
        .loc[lambda x: x <= 100]
        .loc[lambda x: x % 2 == 0]
        .map(lambda x: datetime.timedelta(seconds=x))
        .to_list()
    )

The main difference imo is that kotlin uses more "syntax" while python uses more "English" to express the same thing. Also the half-open interval for range but that's an arbitrary decision that benefits some cases more than others (although my preference is the closed interval)

    [2*x for x in range(n + 1) if x <= 100]

    {2*x | x in 0..n, x <= 100}

    [2*x | x <- [0..n], x <= 100]

    List(1000) { i -> i+1 }