Since Python 3.9 you can merge two dicts with dict1 | dict2

In K, most of these are are a single built-in operation or simple composition:

|:                 / reverse a string/list
~2!                / is a number even? (works on nested structures, too)
?,                 / intersection of two lists
?:                 / remove duplicates from a list
#:                 / string/list length (normal)
+/~0=              / string/list length (avoid using 'count')
{&/|/x=/:y}        / does y contain all elements of x?
10?"a"             / 10 random letters (a special case of 'draw')
10/                / turn a list of digits into a base-10 number
{x~|x}             / is a string/list a palindrome?
,/                 / flatten a list (one level)
,//                / flatten a list (recursively)
*<#:'=:            / find the most frequent element of a list
,                  / a 'list join' is also a dictionary union

The same, but in Ruby:

reversed_string = "Hello World".reverse

is_even = -> { _1.even? }

intersection = list1 & list2

no_duplicates = list.uniq

length = "Hello World".chars.sum { 1 }

contains_all = list1.all? { list2.include?(_1) }
contains_all = (list2 - list1).empty?
contains_all = (list1 & list2) == list1

random_str = ('a'..'z').to_a.sample(10).join

num = [1, 2, 3, 4, 5].join

is_palindrome = -> { _1 == _1.reverse }

flatten_list = [[[1, 2], [3, 4]], []].flatten

most_frequent = list.tally.max_by {_2}.first
most_Frequent = list.max_by { list.count(_1) }
# the second one is probably much slower

merged_hash = hash1.merge(hash2)
merged_hash = {**hash1, **hash2}

I don’t get the point of this article. None of these is a lifesaver, and you learn all of this early on in your learning of the language. This article could make sense as an advocacy piece of a kind “look at these cool things you can do in this language,” but Python is already ubiquitous these days, so it is difficult to imagine someone who would be interested in what Python has to offer but just didn’t happen to notice this tiny obscure language just yet…

It may be useful to note that the list flattening is not recursive (unlike the ruby answer), only one level is flattened:

>>> sum([[[1], 2], [3, 4]], [])
[[1], 2, 3, 4]

If you’re okay with cheating and eval, there is a one-liner for recursive flattening:

>>> eval('[' + repr([[[1], 2], [3, 4]]).replace('[', '').replace(']', '') + ']')
[1, 2, 3, 4]

Otherwise, a recursive function is decently short:

def flatten(lst):
    for elem in lst:
        if isinstance(elem, list):
            yield from flatten(elem)
        else:
            yield elem

If you have deeply nested lists, I suppose you may want something like this:

def flatten(lst):
    it = iter(lst)
    stack = [it]
    while stack:
        try:
            elem = next(stack[-1])
        except StopIteration:
            stack.pop()
            continue
        if isinstance(elem, list):
            stack.append(iter(elem))
        else:
            yield elem

Most frequent can be done with collections.Counter

from collections import Counter

counter = Counter('abracadabra')
(most_common, _), *_ = counter.most_common(1)

List flattening can be done with itertools.chain:

from itertools  import chain

list(chain.from_iterable(['abc', 'def']))

The string module comes with constant containing all ascii letters for convenience:

import string

print(string.ascii_lowercase)

Contains all as implemented is quadratic. Best to convert list1 to a set first:

set1 = set(list1)
contains_all = all(elem in set1 for elem in list2)

I tried to recreate this with Haskell “one-liners”:

ghci> reverse "Hello World"
"dlroW olleH"
ghci> even 6
True
ghci> import Data.List
ghci> intersect [1, 2, 3] [2, 3, 4]
[2,3]
ghci> nub [1, 2, 3, 2, 4, 3, 2, 1]
[1,2,3,4]
ghci> sum $ map (const 1) [1, 2, 3, 4]
4
ghci> null $ [1, 2, 3] \\ [1, 2, 3, 4]
True
ghci> import System.Random
ghci> getStdGen >>= return . take 10 . randomRs ('a', 'z')
"nkfraprbgg"
ghci> foldl1 (\a b -> 10*a + b) [1, 2, 3, 4]
1234
ghci> (\x -> x == reverse x) "racecar"
True
ghci> concat [[1, 2], [3, 4]]
[1, 2, 3, 4]
ghci> head $ last $ sortOn length $ group $ sort [4,1,3,4,2,3,2,3,4,4]
4
ghci> :module -Data.List
ghci> import Data.Map
ghci> union (fromList [('a', 1), ('b', 2)]) (fromList [('b', 3), ('c', 3)])
fromList [('a',1),('b',2),('c',3)]

And in oK:

  |"Hello World"
"dlroW olleH"
  ~2!6
1
  {x^x^y}[1 2 3;2 3 4]
2 3
  ?1 2 3 2 4 3 2 1
1 2 3 4
  +/{1}'1 2 3 4
4
  {~#x^y}[1 2 3;1 2 3 4]
1
  10?"a"
"zealsptiiu"
  .,/$1 2 3 4
1234
  {x~|x}"racecar"
1
  ,//((1 2;3 4);(5;(6;7 8)))
1 2 3 4 5 6 7 8
  *>=4 1 3 4 2 3 2 3 4 4
4
  [a:1;b:2],[b:3;d:5]
[a:1;b:3;d:5]

the most frequent trick

most_frequent = max(set(my_list), key=my_list.count)

is “accidentally quadratic”, because my_list.count is a linear search and you’re doing it once for each distinct item.

better to use collections.Counter

Since a list can contain duplicate elements, should the intersection of 2 lists have the duplicates as well? I think this depend on the actual definition of the intersection, IIRC it is:

for all x in a, x in “a&b” <=> x in b

This would mean that for:

a = [1, 2, 2, 3]
b = [2, 3, 4]

a&b should be [2, 2, 3] : 1 is not in b, 2 is in b, 2 is in b, 3 is in b. Note how it does not include the 2 and 3 that are in b.

Am I mistaken?

next(g.gi_frame for _ in [1])

It’s a fun one for candidate interviews “explain what happens here”

Can anyone try this using lisp

Are similar one-liners not possible in every well-used scripting language?

The “remove duplicates from a list” example does not preserve order. I can’t think of a one-liner that does, since you need some kind of stateful iteration to keep track of unique elements and that probably warrants multiple lines.