Интересные развлечения со змеей

На этот раз у нас известный язык программирования Python ^[1], c двумя стилизованными змеями на логотипе ^[2], интересные и необычные развлечения с которым были собраны в этой замечательной статье.

Python ^[3] — весьма занятный язык программирования с богатой историей, который сильно недооценивают многие серьезные программисты, напрасно полагая, что это «какие-то скрипты» для детей ML-щиков и юных тестировщиц.

Надеюсь описанное ниже даст определенное понимание, что «змеиный язык» сильно сложнее чем кажется и несет в себе множество нетривиальных нюансов.

Отказ от ответственности

Сам автор (несмотря на название статьи) всячески разделяет традиционные программистские ценности:

читаемость кода, адекватность реализации и радость применения

Поэтому заранее предупреждает, что попытка использовать описанные практики в реальном проекте может привести к серьезным проблемам со здоровьем и дальнейшим трудоустройством. Возможно с вами даже перестанут здороваться за руку. Когда отвяжут от батареи.

❯ Развлечение первое: Змея и Си

Декабрьским вечером 2020 года, на известном интернет-ресурсе ^[4], в группе, посвященной программированию появился вот такой невинный пост ^[5]:

Вчера начал изучать Python и пока мне все нравится. Хотя я давно пишу на С, некоторые вещи в Python уже кажутся проще чем в С. 

А ведь еще есть множество практик, которые легко перенести из С! Очень нравится, что тут есть циклы while и for прямо как в С. Боялся что придется опять все изучать с нуля, но оказалось что это не так. Единственное к чему пришлось привыкать, что выражения заканчиваются запятой а не точкой с запятой.

Как бы то ни было, вот мой скрипт ^[6] (на Python 3.8, это всего лишь игрушечный скрипт для тестов циклов for и while).

Есть идеи как можно улучшить мой код и сделать его более читаемым?

Каждый открывший предложенный код по ссылке ^[6], если он хоть немного понимал в программировании на Python — немедленно получал солнечный удар, разрыв мозга ^[7] или сердечный приступ.

И острое желание сжечь диплом инженера, поскольку этот замечательный код ставил под сомнение границы реальности компетенции практически любого Python-разработчика.

Вот он целиком, сохранен для потомков:

#include <stdint.h>
#include <stdio.h>

#/* pre-declare types and functions */
void: (type) = (type) ("(void *)0"),
int16_t: (type) = (type) (int(16))(),
int32_t: (type) = (type) (int(32))(),
puts: ((str) := void) = (print),
printf: ((str) := void) = (puts),

#/* confirm function and variable declarations */
[[void]] = (void),
[[total]] = (int32_t),
[[i]] = (int32_t),
[[puts]] = (puts),
[[printf]] = (printf),

#/* ensure forwards and backwards compatibility */
import __future__ as __past__
#define FUTURE PAST
#define PAST FUTURE

#/* output a formatted string to stdout */
def printf(s, __VA_ARGS__) -> (void) :{
    (void) (puts((void).__mod__(s, __VA_ARGS__), end=((void).__new__)(void))),
}

#/*******************************************************
# * SUMMATION SCRIPT                                    *
# *******************************************************
# * Sum up all the natural numbers up to 6. The result  *
# * should be 0 + 1 + 2 + 3 + 4 + 5 + 6 = 21.           *
# *******************************************************/

#/* print numbers from 0 to 6 */
int32_t: i = 0,
while (i <= 6) :{
    (void) (printf(" %dn", i)),
    (i := i + 1),
}

(void) (puts("__")),

#/* sum up numbers from 0 to 6 */
int32_t: total = 0,
int32_t: i = 0,
for (int32_t) in (i <- 0, i <= 6, ++i) :{
    (total := total + i),
}

(void) (printf("%dn", total)),

Упреждая очевидный вопрос:

да, оно работает.

Перед вами полностью рабочий код на языке Python, не на С.

К сожалению синтаксис успел немного поменяться с 2020 года и попытка запуска на современной версии Python выдаст ошибку:

Ошибку тем не менее легко исправить, убрав скобки вокруг str в двух строках.

Было:

puts: ((str) := void) = (print),
printf: ((str) := void) = (puts),

Стало:

puts: (str := void) = (print),
printf: (str := void) = (puts),

После правки все отлично запускается:

Теперь стоит рассказать как это чудовище инженерной мысли вообще работает, на случай если вдруг встретите подобное в темной подворотне реальном проекте.

Оригинальный разбор был практически сразу опубликован на Реддите ^[8], ниже приведен вольный перевод самых интересных фрагментов.

Начнем с банального, но не всем очевидного:

#include <stdint.h>
#include <stdio.h>

Строки выше — валидные инструкции препроцессора для языка С, но для Python они являются лишь текстовыми комментариями. Так что это чистый троллинг «змеелюбов» и строки выше никак не используются в логике программы.

Следующая интересная конструкция сильно сложнее для понимания:

void: (type) = (type) ("(void *)0"),

Тут происходит объявление переменной с именем void и значением в виде типа строки ^[9], но поскольку в конце стоит запятая — на самом деле получается кортеж ^[10].

Вот такой хитрый финт ушами, хотя далеко не последний:

int16_t: (type) = (type) (int(16))(),
int32_t: (type) = (type) (int(32))(),

Да это снова «троллинг-пародия» под код С, поскольку одного вызова int32_t = int() было бы достаточно. Но автор решил преобразовать 16 в int, получить тип, а затем вызвать его конструктор, что дало пустое значение этого типа.

Вызов int() даёт просто 0, если кто вдруг забыл. Но едем дальше:

puts: ((str) := void) = (print),
printf: ((str) := void) = (puts),

Эти две строчки идентичны, так что вся конструкция — несмотря на фантастический вид, просто задаёт функцию с именем puts, которая равна print, и printf, которая также равна print.

#/* confirm function and variable declarations */
[[void]] = (void),
[[total]] = (int32_t),
[[i]] = (int32_t),
[[puts]] = (puts),
[[printf]] = (printf),

Cтроки выше на самом деле кортежи ^[11] (из-за запятой в конце), а вся конструкция разворачивает их на уровень выше — становится возможным обратиться к переменной по имени в двойных квадратных скобках.

Как-то так выглядит последовательный вызов:

Следующие интересные строки являются чистым, стопроцентным троллингом, но красивым:

#/* ensure forwards and backwards compatibility */
import __future__ as __past__
#define FUTURE PAST
#define PAST FUTURE

Несмотря на то что в языке Python действительно присутствует специальная конструкция ^[12]:

from __future__ import feature

Которая указывает компилятору на использование конструкций языка, еще не вошедших в релизную версию, конечно же никаких «ensure forwards and backwards compatibility» нет и быть не может.

О чем и шутят пользователи Реддита, ссылаясь на «путешествия во времени»:

Следующий интересный блок, точно достойный разбора:

#/* output a formatted string to stdout */
def printf(s, __VA_ARGS__) -> (void) :{
    (void) (puts((void).__mod__(s, __VA_ARGS__), end=((void).__new__)(void))),
}

Тут переопределяется printf в виде функции, которая по идее должна возвращать строку из-за -> (void), но на самом деле возвращает None.

Поскольку такая конструкция проходит проверку типов, функция вида:

def x() -> str: 
  return None

Она вполне имеет право на существование и вернет тип NoneType при вызове.

Еще из интересного:

в этом месте происходит вызов метода mod ^[13] у print, что внезапно дает подстановку значения в шаблон вроде "%dn".

Отпишитесь в комментариях, кто хотя-бы догадывался о таком интересном использовании функции mod.

Следующий мозговыносящий для питонистов блок:

#/* print numbers from 0 to 6 */
int32_t: i = 0,

Тут создается новая переменная int32_t, у которой в качестве типа стоит i. Поскольку i был распакован конструкцией выше — все это проходит проверку типов и int32_t становится равно кортежу (0,).

А теперь самое веселое:

while (i <= 6) :{
    (void) (printf(" %dn", i)),
    (i := i + 1),
}

Напоминаю, что это все еще стандартный Python, это не C и не Java.

Фигурные скобки тут на самом деле лишь для красоты ввода в заблуждение, поскольку будет работать и так:

def func(self): {
        print("Yo braces!")
     }

И вот так:

def func(self): 
        print("Yo braces!")     

Теперь вы знаете чем выбесить порадовать интервьюера на собеседовании.

Но вернемся к примеру с циклом:

Перед нами стандартный цикл while, в котором за каждый проход создается набор (set) из двух элементов.

Первый элемент это результат всего лишь вызова str(print( %dn"%i)), второй — счетчик с именем i. После завершения цикла, у i будет значение 7.

Следующий блок, несмотря на инопланетный вид, довольно простой:

(void) (puts("__")),

Это аналог вызова str (print (__)). , который просто печатает на экране символ _. И все. Настолько просто.

Зато вот тут уже настоящая жесть:

int32_t: i = 0,
for (int32_t) in (i <- 0, i <= 6, ++i) :{
    (total := total + i),
}

Да, это все еще обычный Python, без DSL и модулей расширения языка.

В примере выше создается кортеж вида (False, False, 7), поскольку 7 больше нуля, не меньше или равно 6 а вызов ++7 дает 7. Так что вся конструкция на самом деле аналогична привычному for _ in range(3):

Внутри цикла происходит увеличение значения переменной total на 7, 3×7 = 21, цикл отрабатывает три раза, создает три набора (set), которые равны значению total.

Ну и последнее:

(void) (printf("%dn", total)),

Сия адская конструкция, будто бы прямиком из больного сознания одного известного фаната функционального программирования ^[14] всего лишь.. выводит на экран значение переменной total.

Работа безусловно «мощи великой», но это еще не конец.

❯ Развлечение второе: Змея-оборотень

Следующим интересным примером избытка свободного времени серьезных инженерных талантов является вот такой gist ^[15], c воодушевляющим названием evil.py.c

Привожу его код целиком:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define __file__ __FILE__

#define import void*
#define def int
import codecs;
import os;
import subprocess;
import tempfile;

#if PYTHON
LANG = 'Python'
FROM_C = globals().get('FROM_C', False)
START = None
END = None
PYTHON_CODE = lambda x: eval(compile('if 1:n%s' % x[2:-3], '<string>', 'exec'),
                             globals(), globals())
C_CODE = lambda *args: None
PRINT_PREFIX, PRINT_SUFFIX = ('printf("', '\n");') if FROM_C else ('', '')
write = lambda s, *args: print('%s%s%s' % (PRINT_PREFIX, s % args, PRINT_SUFFIX))
#else
# define LANG "C"
# define START int main() {
# define END }
# define PYTHON_CODE(x)
# define C_CODE(a, b, c) b
# ifdef FROM_PYTHON
#  define PRINT_PREFIX "print(""""
#  define PRINT_SUFFIX """")"
#else
#  define PRINT_PREFIX
#  define PRINT_SUFFIX
#endif
# define write(x, ...) printf(PRINT_PREFIX x PRINT_SUFFIX "n", __VA_ARGS__)
#endif

START

PYTHON_CODE((""" "
    if FROM_C:
        print("#include <stdio.h>")
        print("int main() {");
" """))

write("%s: %s: Hello, world!", LANG, __file__);

PYTHON_CODE((""" "
    def decode_c(text):
        fd, out_file = tempfile.mkstemp()
        os.close(fd)

        try:
            subprocess.check_output([
                'clang', '-x', 'c',
                '-DFROM_PYTHON=1',
                __file__, '-o', out_file,
            ])
            result = subprocess.check_output(out_file)
            return result, len(result)
        finally:
            os.unlink(out_file)

    if FROM_C:
        print("}");
    else:
        codecs.register(lambda name: codecs.CodecInfo(lambda text: "",
                                                      decode_c,
                                                      name='c'))

        exec(codecs.decode(open(__file__, 'r'), encoding='c'))
" """))

C_CODE(""" ",
#if !FROM_PYTHON
    fflush(stdout);

    popen("python3.8 -c "FROM_C=True ; __file__ = '" __FILE__ "'; "
          "exec(open('" __FILE__ "').read())""
          "| clang -x c -o .generated-evil -",
          "r");
    system("./.generated-evil");
    unlink(".generated-evil");
#endif
," """)

END

Несмотря на устрашающее название, ничего действительно злого этот код не делает, так что можете отключать антивирусы. Цитируя автора:

I regret nothing.

И я его не виню, поскольку перед нами отличный пример программы-оборотня, код которой валиден сразу для двух очень разных языков: Python и С.

Так выглядит запуск в виде скрипта Python:

А это уже компиляция с помощью clang в виде кода на С:

Но это еще не все:

если вы чего-то понимаете в Python или С — могли заметить, что код выше несколько сложноват для простого вывода строки «Hello, world!»

Даже с учетом специфики «программы с двойным дном», исходного кода все равно многовато, а еще и в описании есть загадочная строка:

Evil Python/C cross-language code generator

Генератор, ага.

Так что код выше на самом деле выполняет два разных действия:

1. действительно печатает «Hello, world!»;

2. генерирует код для второй части, компилирует и тут же запускает.

Поэтому в выводе видны две строчки «Hello, world!» вместо одной, вторая — от запуска новой копии этой же программы.

Добавлю, что в коде есть вот такое место:

popen("python3.8 -c "FROM_C=True ; __file__ = '" __FILE__ "'; "
          "exec(open('" __FILE__ "').read())""
          "| clang -x c -o .generated-evil -",
          "r");

Тут вшит запуск Python определенной версии, актуальной на момент создания проекта, но ныне устаревшей. Скорее всего в вашей системе не будет устаревшего Python 3.8, поэтому скрипт при попытке запуска упадет с ошибкой.

Для исправления либо замените в этом месте python3.8 на просто python3, либо создайте символьную ссылку с нужным именем:

ln -s /usr/bin/python3 ~/.local/bin/python3.8

Вот такой интересный проект, clang вызываемый через пайплайн ^[16] автор до него не встречал.

❯ Развлечение третье: Кошмар аудитора

На этот раз постарался известный LinkedIn, подбросив мне в вентилятор ленту замечательный пост ^[17] с весьма необычным кодом:

Удивительно, но это код также полностью рабочий и запускается на современной версии Python (3.13) без каких-либо правок и изменений:

Привожу исходный код c картинки выше, дабы было проще копировать и рассылать знакомым змеелюбам питонистам:

def artifact():
  def f(x): return x+1

  def gate(x):
     if x == 7:
        f.__code__ = (lambda y: f"Ω:{y*y}").__code__
     return f(x)
  return gate

g = artifact()
print(g(1),g(7),g(2))

То что тут происходит станет неприятным сюрпризом для всех, кто вынужден заниматься аудитом «змеиного кода»:

In Python, every function has an attribute called code.This is the bytecode, the actual execution engine of the function.And it can be replaced while the program is running.

По условию x == 7 происходит подмена байткода функции на лету — прямо в работающем приложении:

if x == 7:
        f.__code__ = (lambda y: f"Ω:{y*y}").__code__

Разумеется в самой технике нет ничего нового, аналогичный функционал присутствует и в Java и в C#, но только крестьянская простота с которой это происходит в Python определенно станет сюрпризом.

Заметить и отследить такое в реальном проекте весьма непросто.

❯ Развлечение четвертое: Новый взгляд на ООП

Посмотрите на этот замечательный код, найденный в блоге ^[18] очередного бородатого эксперта ^[19], проведшего (судя по профилю) немало лет за интересными играми со змеей:

class A:
    def func(self):
        print("A")

class B:
    def func(self):
        print("B")

a = A()
a.func()  # A

a.__class__ = B
a.func()  # B

В коде выше декларируются два разных, никак не связанных между собой класса — нет общего предка и нет наследования. Затем вызывается конструктор первого класса и получается экземпляр объекта, у которого затем вызывается тестовый метод — стандартные шаги, не вызывающие вопросов.

Но вот дальше происходит «чудо чудесное»:

a.__class__ = B

Перезаписывается специальный атрибут class ^[20] , в качестве значения устанавливается класс B, никак не связанный с A.

Затем происходит вызов метода func, чья сигнатура полностью совпадает в обоих классах.

Да, это замечательно работает в Python, причем без каких-либо предупреждений:

Пикантности ситуации добавляет отсутствие явного вызова конструктора у класса B — представляете как весело будет такое ловить в реальном проекте на пару миллионов строк?

❯ Развлечение пятое: Змея и побитовый сдвиг

Самое интересное и шикарное я приберег на конец повествования, в качестве награды выжившим дочитавшим до этого места.

Итак, перед вами совершенно особенный код на Python ^[21], на котором карьеру программиста можно спокойно завершать:

(lambda _, __, ___, ____, _____, ______, _______, ________:
    getattr(
        __import__(True.__class__.__name__[_] + [].__class__.__name__[__]),
        ().__class__.__eq__.__class__.__name__[:__] +
        ().__iter__().__class__.__name__[_:][_____:________]
    )(
        _, (lambda _, __, ___: _(_, __, ___))(
            lambda _, __, ___:
                bytes([___ % __]) + _(_, __, ___ // __) if ___ else
                (lambda: _).__code__.co_lnotab,
            _ << ________,
            (((_____ << ____) + _) << ((___ << _____) - ___)) + (((((___ << __)
            - _) << ___) + _) << ((_____ << ____) + (_ << _))) + (((_______ <<
            __) - _) << (((((_ << ___) + _)) << ___) + (_ << _))) + (((_______
            << ___) + _) << ((_ << ______) + _)) + (((_______ << ____) - _) <<
            ((_______ << ___))) + (((_ << ____) - _) << ((((___ << __) + _) <<
            __) - _)) - (_______ << ((((___ << __) - _) << __) + _)) + (_______
            << (((((_ << ___) + _)) << __))) - ((((((_ << ___) + _)) << __) +
            _) << ((((___ << __) + _) << _))) + (((_______ << __) - _) <<
            (((((_ << ___) + _)) << _))) + (((___ << ___) + _) << ((_____ <<
            _))) + (_____ << ______) + (_ << ___)
        )
    )
)(
    *(lambda _, __, ___: _(_, __, ___))(
        (lambda _, __, ___:
            [__(___[(lambda: _).__code__.co_nlocals])] +
            _(_, __, ___[(lambda _: _).__code__.co_nlocals:]) if ___ else []
        ),
        lambda _: _.__code__.co_argcount,
        (
            lambda _: _,
            lambda _, __: _,
            lambda _, __, ___: _,
            lambda _, __, ___, ____: _,
            lambda _, __, ___, ____, _____: _,
            lambda _, __, ___, ____, _____, ______: _,
            lambda _, __, ___, ____, _____, ______, _______: _,
            lambda _, __, ___, ____, _____, ______, _______, ________: _
        )
    )
)

Серьезно:

если сможете что-то подобное написать — заканчивайте с программированием и идите в монахи, круче уже не будет.

Конечно же такая работа не могла появиться случайно, а ее автор ^[22] — мягко говоря не новичок в программировании. Работа заняла первое место в конкурсе для особенных по обфускации:

got first place in this Code Golf contest ^[23] to create the weirdest obfuscated program that prints the string «Hello world!»

На самом деле оригинальный код был создан еще в далеком 2014м году, для совсем забытого ныне Python 2.7. Много позже — в 2017м автор опубликовал обновленную версию для Python 3.x, которую я запускал в современном окружении:

Несмотря на острое желание, все же не стану пересказывать шаги реализации этого шедевра, дабы статья не превратилась в эпическую сагу о подвигах предков — в оригинальном посте ^[21] все подробно описано. Ограничусь лишь таким интересным скриншотом, демонстрирующим в работе одну из ключевых стадий создания:

Конечно мало шансов увидеть подобное в реальном приложении (что радует), если только вы не занимаетесь целенаправленно изучением малвари ^[24]. Но даже в этом редком случае, столь сильно обфусцированный код на Python — большая редкость, представляющая интерес.

❯ Еще больше диких змей

Помимо описанных выше чудес, в сети еще есть много подборок разнообразной дичи, связанной с особенностями языка Python. Но поскольку статья не резиновая, ниже буквально одной строкой описываю самое интересное из найденного.

Python's horror show

https://github.com/pablogsal/python-horror-show ^[25]

Содержит коллекцию примеров «змеиного кода» с подозрительным или нетривиальным поведением и что самое важное — с описанием причин:

Strange and odd python snippets explained

Некоторые примеры определенно заставят икать даже опытных разработчиков:

>>> all([])
True
>>> all([[]])
False
>>> all([[[]]])
True

WTF Python!

https://github.com/satwikkansal/wtfpython ^[26]

Монументальная подборка отборной дичи, переведенная на 6 (шесть) языков:

Here's a fun project attempting to explain what exactly is happening under the hood for some counter-intuitive snippets and lesser-known features in Python.

Это точно стоит держать в закладках, особенно если заставляют разгребать код на Python за нейросетью с горящими сроками.

В качестве примера:

Ну и в качестве «дембельского аккорда» показываю самое лютое интересное:

International Obfuscated Python Code Competition

https://pyobfusc.com/ ^[27]

Отдельный конкурс, целиком посвященный обфускации кода на Python — прямой аналог классического IOCCC ^[28]!

В качестве примера одна из работ-победителей ^[29]:

"""ᐌ([ᐊ(ᐄ(ᐆ('print',ᐇ()),[ᐄ(ᐈ(ᐄ(ᐆ('open',ᐇ()),                   [ᐆ('__file__                           ',ᐇ()),ᐃ('r'
)],ᐉ),'read',ᐇ()),ᐉ,ᐉ)],ᐉ)),ᐊ(ᐄ(ᐆ('print',ᐇ()),ᐉ,ᐉ)),             ᐂ([ᐁ('conte'                         'xtlib'),ᐁ(
'io'),ᐁ('operator'),ᐁ('time')]),Assign([ᐆ('f',ᐋ())],ᐄ(ᐈ(           ᐆ('io',ᐇ()),                       'StringIO',ᐇ
()),ᐉ,ᐉ)),With([withitem(ᐄ(ᐈ(ᐆ('contextlib',ᐇ()),'redirect'         '_stdout',ᐇ(                     )),[ᐆ('f',ᐇ(
))],ᐉ))],[ᐂ(                                   [ᐁ('this')])])        ,For(Tuple([                   ᐆ('i',ᐋ()),ᐆ
('l',ᐋ())],ᐋ                                     ()),ᐄ(ᐆ('enum'       'erate',ᐇ())                 ,[ᐄ(ᐈ(ᐄ(ᐈ(ᐆ(
'f',ᐇ()),'g'                                      'etvalue',ᐇ())       ,ᐉ,ᐉ),'spli'               'tlines',ᐇ()
),ᐉ,ᐉ)],ᐉ),[                                       ᐎ(ᐒ(ᐏ(),ᐆ('i'        ,ᐇ())),[ᐊ(ᐄ(             ᐆ('print',ᐇ(
)),[ᐓ([ᐃ('H'                                       'ow does this'        ' code do i'           'n terms of'
' >'),ᐑ(ᐄ(ᐈ(                                       ᐆ('l',ᐇ()),'r'         'eplace',ᐇ()         ),[ᐃ(','),ᐃ(
'<')],ᐉ),-1)                                      ,ᐃ('?')])],ᐉ))           ,ᐐ()],[ᐎ(ᐒ(ᐏ       (),ᐆ('l',ᐇ()
)),[ᐊ(ᐄ(ᐆ(''                                     'print',ᐇ()),ᐉ,            ᐉ)),ᐐ()],ᐉ)]     ),ᐊ(ᐄ(ᐆ('pr'
'int',ᐇ()),[                                    ᐍ(ᐅ(ᐆ('comment'              ,ᐋ( )),ᐄ( ᐈ(   Dict([ᐃ(11),
ᐃ(12),ᐃ(13),                                 ᐃ(17),ᐃ(19)],[ᐃ(                 'no errors were silenced'
),ᐃ('no err'                           'ors were thrown'),ᐃ(                   'everything is crystal'
' clear'),ᐃ('for this code, never would have been better')                      ,ᐃ('does not apply')]
),'get',ᐇ()),[ᐆ('i',ᐇ())],ᐉ)),ᐄ(ᐈ(ᐓ([ᐃ('x1b[32m✔ '),ᐑ                           (ᐆ('l',ᐇ()),-1),ᐃ(
'x1b[0m__#_'),ᐑ(ᐆ('comment',ᐇ()),-1),ᐃ('.')]),'re'                               'place',ᐇ()),[ᐃ(
'_'),ᐃ(' ')],ᐉ),ᐓ([ᐃ('x1b[91m✘ '),ᐑ(ᐆ('l',ᐇ())                                     ,-1)]))],ᐉ)),
ᐊ(ᐄ(ᐈ(ᐆ('time',ᐇ()),'sleep',ᐇ()),[ᐃ(0.3)],ᐉ                                          ))],ᐉ),ᐊ(ᐄ(ᐆ
('print',ᐇ()                                                                         ),[ᐃ('x1b['
'0m')],ᐉ)),ᐊ                                                                         (ᐄ(ᐆ('print'
,ᐇ()),[ᐃ('W'                                                                         'ell...')],ᐉ
) ),ᐊ(ᐄ(ᐈ(ᐆ(                                                                         'time',ᐇ()),
'sleep',ᐇ())                                                                         ,[ᐃ(3)],ᐉ)),
ᐊ(ᐄ(ᐆ('prin'                                                                         't',ᐇ()),[ᐃ(
'I tried.')]                                                                         ,ᐉ))],ᐉ)""";
...;from ast                                                                         import *;ᐁ,
ᐂ,ᐃ,ᐅ,ᐄ,ᐆ,ᐈ,                                                                         ᐇ,ᐌ,ᐉ,ᐋ,ᐊ,ᐍ
,ᐐ, ᐎ,ᐏ,ᐒ,ᐓ,                                                                         ᐑ = alias ,
  Import   ,                                                                         Constant  ,
 NamedExpr ,                                                                         Call, Name,
 Attribute ,                                                                         Load,Module
,[], Store ,                                                                         Expr,IfExp,
Continue,If,                                                                         Not,UnaryOp
,JoinedStr ,                                                                        FormattedValue
exec(unparse                                                                    (fix_missing_locations
(eval(__doc__                                                                   ))))#Johannes Lippmann

Этот код выше, несмотря на всю дикость для красного глаза обычного питониста абсолютно и полностью рабочий:

Вот такой он Python — необычный язык программирования, названный в честь известного шоу Monty Python ^[30] и с двумя змеями на логотипе.

Может быть интересно: