http://docs.hylang.org/en/latest/

В пітоні є проблема - рядок з одного символа, і символ неможливо відрізнити за типом.

З одного символа, який у свою чергу, складається з одного односимвольного рядка, і т.д.
Якщо ж ми хочемо уникнути цього рекурсивного визначення, пітонівський рядок можна розглядати як масив кодів символів.

Підловили. Символ - рядок довжиною 1.

Черговий костиль:

class DT:
    def __getattr__(self, name):return eval(
        'lambda x, *args, **kwargs:x.'+name+'(*args, **kwargs)')
dt=DT()

Маючи його, наведений вище приклад можна зробити ось так:

(list(map (dt.__neg__, [1,2.2,3,4.4,5])))

Якщо вже мова зайшла за Clojure та його нащадків, поговорімо про таку корисну річ, як «->>» — макрос для розгортання вкладених виразів.

Для чого це взагалі потрібно? Працюючи з серією вкладених викликів спискових/ітераторних функцій (таких як map, filter, reduce та ін.), ми неминуче зіткнемося з характерною ліспівською батареєю дужок наприкінці виразу. І хоча сучасні редактори та середовища розробки дозволяють швидко знайти парну дужку, читати такі вирази очима доволі незручно, та й ризик помилки зростає. І якщо в Common Lisp чи Scheme з цим якось миряться (бо як же інакше?), а в Python просто міняють функціональний стиль на процедурний, то в Clojure можна цього уникнути:

(->> lst
 (map f1)
 (filter f2)
 (map f3)
 (map f4)
 (reduce f5)
)

що після обробки макросів трансформується в

(reduce f5 (map f4 (map f3 (filter f2 (map f1 lst)))))

тобто, кожен вираз зі списку підставляється в наступний вираз останнім аргументом.

Тепер повернімось до пітона. В принципі, зовсім необов'язково пакувати все в один вираз — його можна переписати як серію присвоєнь:

x=lst
x=map(f1, x)
x=filter(f2, x)
x=map(f3, x)
x=map(f4, x)
x=reduce(f5, x)

Хоча любителям функціонального стилю може сподобатися така функція:

def rarg(x): 
    return lambda *args, **kwargs:\
        rarg(args[0](*args[1:]+(x,), **kwargs)) if args else x

Маючи її, наведений вище приклад можна переписати так:

(rarg(lst)
 (map, f1)
 (filter, f2)
 (map, f3)
 (map, f4)
 (reduce, f5)
())

Або більш зручний для демонстрації приклад:

>>> rarg('qwertyuiop')(filter, lambda c:c>'q')(map, repr)(', '.join)()
"'w', 'r', 't', 'y', 'u'"

Перестань писати лямбди, це тобі не лісп.

Хвостова рекурсія (тобто, кінцевий виклик функції з функції, при якому дані попередньої функції вивільняються зі стеку, що дозволяє здійснювати нескінченну рекурсію без переповнення). Це основний засіб організації циклів у Scheme. Python не має вбудованих засобів для хвостової оптимізації. Так само, ці засоби відсутні в JVM, що не завадило Clojure їх реалізувати.

Clojure має два варіанти організації хвостової рекурсії: loop...recur i trampoline. Перший на апаратному рівні реалізується як цикл і є синтаксичним аналогом іменованого let у Scheme. Другий являє собою доволі простий костиль, який, проте, дозволяє робити оптимізовані рекурсивні виклики між кількома різними функціями.

Реалізується trampoline елементарно:

def trampoline(f):
    while callable(f):f=f()
    return f

Щоб перевірити, що це справді працює, можна запустити простеньку функцію:

def cnt(n):
    print(n)
    return (lambda:cnt(n-1)) if n else 0

trampoline(cnt(1000000))

Ми побачимо, як на екран буде виведено числа від 1000000 до 0, при цьому кількість пам'яті, яку споживає python, помітно не збільшиться. Для порівняння, якщо зробити так:

def cnt1(n):
    print(n)
    return (cnt1(n-1)) if n else 0

cnt1(1000000)

ми отримаємо екран, заповнений повідомленнями про помилку через досягнення максимальної глибини рекурсії.

Можна спробувати скористатися моїм попереднім костилем

for i in cfor(0, lambda x: x<10, lambda x: x+0.1):
    print(i)

Хоча простіше зробити так:

for i in map(lambda x: x*0.1, range(100)):
    print(i)

Оскільки операції з float'ами дають первну похибку, результати цих двох реалізацій можуть відрізнятись (бо в першому випадку float додається до float при кожному проходженні, у другому для рахунку використовується int, який потім щоразу множиться на float).

Варіант із цілим кроком має давати меншу похибку; якщо ж треба зробити цикл для довільного діапазону, я б зробив це так:

minval=1234
maxval=1342
step=0.1
for i in map(lambda x: x*step, range(int(minval/step), int(maxval/step))):
    print(i)