Кодобред

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

Кратко о ФП в Python и почему не хватает пайплайнов на примере

В Python из базовых средств есть довольно удобные map(), reduce(), filter(), лямбда-функции, итераторы и генераторы. Малознакомым с этим всем советую данную статью. В целом это оно всё позволяет быстро и естественно описывать преобразования над списками, кортежами, и тд. Очень часто(у меня и знакомых питонистов) то, что получается однострочник по сути набор последовательных преобразований, фильтраций, например:
Kata с CodeWars: Найти

Задачка довольно простая, к сожалению(но к счастью для этого поста), решений лучше чем в лоб нет.

Моё решение:

def sum_dig_pow(a, b): # range(a, b + 1) will be studied by the function    powered_sum = lambda x: sum([v**(i+1) for i,v in enumerate(map(lambda x: int(x), list(str(x))))])    return [i for i in range(a,b+1) if powered_sum(i)==i]

С использованием средств ФП как есть получается скобочный ад "изнутри наружу". Это мог бы исправить пайплайн.

Пайплайны функций

Под сим я подразумеваю такое в идеальном случае (оператор "|" личное предпочтение):

# f3(f2(f1(x)))f1 | f2 | f3 >> xpipeline = f1 | f2 | f3 pipeline(x)pipeline2 = f4 | f5pipeline3 = pipeline | pipeline2 | f6...

Тогда powered_sum может стать(код не рабочий):

powered_sum = str | list | map(lambda x: int(x), *args) | enumerate | [v**(i+1) for i,v in *args] | sum

Как по мне, такой код легче писать и читать. args в целом выглядят чужеродно. В реальности, не лазя в кишки питона получилось сделать такое(далеко от любых идеалов):

from copy import deepcopyclass CreatePipeline:    def __init__(self, data=None):        self.stack = []        if data is not None:            self.args = data    def __or__(self, f):        new = deepcopy(self)        new.stack.append(f)        return new    def __rshift__(self, v):        new = deepcopy(self)        new.args = v        return new    def call_logic(self, *args):        for f in self.stack:            if type(args) is tuple:                args = f(*args)            else:                args = f(args)        return args    def __call__(self, *args):        if 'args' in self.__dict__:            return self.call_logic(self.args)        else:            return self.call_logic(*args)

Естественно, это один большой костыль, состряпанный ради интереса, даже без kwargs, хотя в похожих случаях и не так важно.

pipe = CreatePipeline()powered_sum = pipe | str | list | (lambda l: map(lambda x: int(x), l)) | enumerate | (lambda e: [v**(i+1) for i,v in e]) | sum

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

Частичное применение функций

Рассмотрим на примере простейшей функции(код не рабочий):

def f_partitial (x,y,z):    return x+y+zv = f_partial(1,2)# type(v) = что-нибудь частично применённая функция f_partial, оставшиеся аргументы: ['z']print(v(3))# Эквивалентprint(f_partial(1,2,3))

Такая возможность была бы полезна для пайпа и другого разного(насколько фантазии хватит). Тогда пример с учётом имеющейся реализации pipe может стать таким:

powered_sum = pipe | str | list | map(lambda x: int(x)) | enumerate | (lambda e: [v**(i+1) for i,v in e]) | sum# map будет вызван ещё раз со вторым аргументом# map(lambda x: int(x))(данные) при вызове

map(lambda x: int(x)) в пайплайне выглядит более лаконично в целом и в терминах последовательных преобразований данных.
Кривенькая неполная реализация на уровне языка:

from inspect import getfullargspecfrom copy import deepcopyclass CreatePartFunction:    def __init__(self, f):        self.f = f        self.values = []    def __call__(self, *args):        args_f = getfullargspec(self.f)[0]        if len(args) + len(self.values) < len(args_f):            new = deepcopy(self)            new.values = new.values + list(args)            return new        elif len(self.values) + len(args) == len(args_f):            return self.f(*tuple(self.values + list(args)))

Реализация примера с учётом данного костыля дополнения:

# костыль для обхода поломки inspect над встроенным mapm = lambda f, l: map(f, l)# создаём частично применяемую функцию на основе обычной питоньейpmap = CreatePartFunction(m)powered_sum = pipe | str | list | pmap(lambda x: int(x)) | enumerate | (lambda e: [v**(i+1) for i,v in e]) | sum

При более чем двойном вызове в строке(что в целом не особо нужно), придётся уже расставлять скобки, потому что питон подумает, что вызывается аргумент, то есть:

def f (x,y,z):    return x+y+zf = CreatePartFunction(f)# работаетprint(f(1,2,3))# работаетprint(f(1,2)(3))print(f(1)(2,3))# не работает# 2(3) - int не callableprint(f(1)(2)(3))# работаетprint((f(1)(2))(3))

Итоги

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

Создание меню на BASH задача сама по себе не сложная: "case тебе в руки и echo в спину". Решая её в очередной раз, мне захотелось добавить возможность отображать текст на других языках. Осталось решить, как сделать сам процесс локализации меню более удобным. Если оно большое, то решение "в лоб" превратит его в громоздкую копипасту. Здесь я хотел бы поделиться тем, как решил эту проблему для себя. Надеюсь для кого то это будет не безынтересным.

Чтобы статья не вылилась в скучную простыню с излишком кода, решил разбить её на две части. В первой рассмотрим создание и добавление дополнительных языков. Во второй создание многоуровнего меню и сохранение настроек

Мне не хотелось бы разбивать скрипт на несколько частей и хранить локализацию в отдельных файлах. Скрипт тем и удобен, что его проще использовать одним файлом. Поэтому тексты будем хранить в массивах.

Реализация будет состоять из:

• буквенного кода языка
• массива слов
• преобразователя косвенных ссылок для обращения к массиву
• обращения к элементам массива
• создания меню

Теперь рассмотрим подробнее

Зададим язык, добавив короткий буквенный код языка (ru, en), для начала английский:

langset=en

Добавим массивы слов и предложений (по количеству языков):

language_en=( "English" "Quit" "Hi, Habr!" )language_ru=( "Русский" "Выход" "Привет, Хабр!" )

Создадим косвенную ссылку и сформируем из неё новый массив в переменной lng:

lng="language_$langset[@]"; lng=("${!lng}")

То есть здесь для переменной lng создаётся значение, состоящее из части имени массива со словами и кода заданного языка из переменной langset. Далее создаётся массив, который при langset=en будет равен language_en, а при langset=ru будет равен language_ru.
Если языков будет много, то такой подход позволит избавиться от многочисленных if-elif или case. Чтобы изменить язык, достаточно будет добавить массив с переводом и установить язык в переменной langset.

Запустим всё это в консоли:

language_en=( "English" "Quit" "Hi, Habr!" )language_ru=( "Русский" "Выход" "Привет, Хабр!" )langset=enlng="language_$langset[@]"; lng=("${!lng}")echo "${lng[2]}"# Вывод: Hi, Habr!langset=rulng="language_$langset[@]"; lng=("${!lng}")echo "${lng[2]}"# Вывод: Привет, Хабр!

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

Построение меню

А теперь попробуем создать скрипт.
Для примера я взял меню управления командами Git через CLI (command line interface). Это немного надуманно, но хорошо подходит для примера, так как в Git много команд и как раз можно построить единое по своей задаче меню с множеством параметров.

Для начала задаем язык и массив с пунктами меню как это уже делали выше. Ради удобства, я разделил массив на две части: первая это непосредственно меню, вторая информационные сообщения и приглашения командной строки, которые необходимо будет вывести по ходу работы.

#!/bin/bash# Код языкаlangset=en# Пункты менюlanguage_en=( "English" "Quit" "Main menu" "Git: add ALL files/commit" "Git init" "Change language" "Language selection" )message_en=( "English" "Select item" "Wrong! This item does not exist" "Added all files" "Enter you commit" "Changes recorded" "Select a language" "The language has been changed to" "Start the program again" "Menu for language change" )language_ru=( "Русский" "Выход" "Основное меню" "Git: добавить ВСЕ файлы/коммит" "" "" "Выбор языка" )message_ru=( "Русский" "Выберите пункт" "Неверно! Этого пункта не существует" "Добавление всех файлов" "Введите ваш коммит" "Изменения зарегистрированы" "Выберите язык" "Язык изменен на" "Запустите программу заново" "Меню для смены языка" )language_de=( "Deutsch" )message_de=( "Deutsch" "" "" "" "" "" "" "" "Starten Sie das Programm neu" )

Пройдемся по массивам и создадим новые для lng и msg, которые и будут использоваться:

languages() {    lng="language_$langset[@]"; lng=("${!lng}")    msg="message_$langset[@]"; msg=("${!msg}")    for b in ${!language_en[@]} ${!message_en[@]} ; do        if [[ ! ${lng[$b]} ]] ; then            lng[$b]=${language_en[$b]}        fi        if [[ ! ${msg[$b]} ]] ; then            msg[$b]=${message_en[$b]}        fi    done}languages

Чтобы при необходимости иметь возможность применять языковые настройки (это пригодится в следующей статье), заключим всё в функцию и тут же вызовем её.

Небольшое отступление: я уверен, почти всем встречались наполовину переведённые приложения. Особенно этим грешат кастомные прошивки для телефонов. Мне никогда это не нравилось, но в данном случае я всё же решил предусмотреть такую возможность неполного перевода. Это позволит при добавлении нового языка не дублировать все элементы массива, а добавить только те, которые пользователю хотелось бы перевести.

Для этого в цикле сравним созданный массив с англоязычным (английский считаем языком по умолчанию): если записи не существует (либо элемент массива пуст), дополним англоязычным вариантом.

Теперь, когда с языками разобрались, приступим к построению меню. Тут всё стандартно: бесконечный цикл, внутри него цикл для вывода элементов на экран и выбор вариантов через case.

Формируем массив для вывода на экран. Только те пункты, которые нам нужны:

local menu0=([1]="${lng[3]}" "${lng[4]}" "${lng[5]}" "${lng[1]}")

Здесь делаем индексацию с 1, чтобы выводить индекс как соответствующий пункт меню.

Добавляем шапку, пробегаемся по индексам через ${!menu0[@]} и выводим на экран:

echoecho "---${lng[2]}---"for op in "${!menu0[@]}" ; do     echo "$op ) ${menu0[$op]}"doneecho ---------- 

Далее предложим пользователю выбрать необходимый пункт. Будем ожидать нажатие цифровой клавиши через read -s -n1 -p. Где -s не отображать введённые данные (чаще используется для ввода паролей). Мы же потом сами отобразим введеный текст в более удобном формате. -p строка приглашения для вывода подсказки. -n1 параметр, считывающий число симмволов ввода. Здесь мы заранее знаем, что пунктов меню будет не более 9 (то есть числа из одной цифры), поэтому при нажатии одного любого символа программа продолжит работу дальше. Не надо будет нажимать Enter для ввода. Немного непривычно, поэтому можно убрать.

# read со строкой приглашенияread -s -n1 -p "${msg[1]}: " item#вывод нажатой клавишиecho "[$item]->: ${menu0[$item]}"

Ну и заключительный оператор выбора case с обработкой введенного значения:

case $item in        # Команды Git, без обработки ошибок (репозитория ведь может и не быть)    1 )     git add .        read -p "${msg[4]}: " comm        git commit -m "$comm"        echo "${msg[5]}" ;;    2 ) git init ;;    3 ) echo "${msg[9]}" ;;        # Выход    4 ) exit ;;        # Обработка остальных клавиш и вывод сообщения об ошибке    * ) echo "[$item]->: ${msg[2]}"; sleep 2 ;;esac        

Здесь case сделан упрощенным, только для примера. В следующей статье я буду использовать его в более универсальном варианте.

#!/bin/bash# Код языкаlangset=ru# Меню и сообщенияlanguage_en=( "English" "Quit" "Main menu" "Git: add ALL files/commit" "Git init" "Change language" "Language selection" )message_en=( "English" "Select item" "Wrong! This item does not exist" "Added all files" "Enter you commit" "Changes recorded" "Select a language" "The language has been changed to" "Start the program again" "There will be a menu for changing the language" )language_ru=( "Русский" "Выход" "Основное меню" "Git: добавить ВСЕ файлы/коммит" "" "" "Выбор языка" )message_ru=( "Русский" "Выберите пункт" "Неверно! Этого пункта не существует" "Добавление всех файлов" "Введите ваш коммит" "Изменения зарегистрированы" "Выберите язык" "Язык изменен на" "Запустите программу заново" "Здесь будет меню для смены языка" )language_de=( "Deutsch" )message_de=( "Deutsch" "" "" "" "" "" "" "" "Starten Sie das Programm neu" )languages() {    # Косвенные ссылки и создание нового массива    lng="language_$langset[@]"; lng=("${!lng}")    msg="message_$langset[@]"; msg=("${!msg}")    # Сравнение массивов для проверки на пропущенные элементы    for b in ${!language_en[@]} ${!message_en[@]} ; do        if [[ ! ${lng[$b]} ]] ; then            lng[$b]=${language_en[$b]}        fi        if [[ ! ${msg[$b]} ]] ; then            msg[$b]=${message_en[$b]}        fi    done}languagesmain() {    # Создание и вывод меню на экран    local menu0=([1]="${lng[3]}" "${lng[4]}" "${lng[5]} [$langset]" "${lng[1]}")    while true ; do         echo        echo "---${lng[2]}---"        for op in "${!menu0[@]}" ; do             echo "$op ) ${menu0[$op]}"        done        echo ----------        # Ожидание ввода значения        read -s -n1 -p "${msg[1]}: " item        echo "[$item]->: ${menu0[$item]}"        # Оператор выбора        case $item in                # Команды Git, без обработки ошибок (репозитория ведь может и не быть)            1 ) #               git add .                read -p "${msg[4]}: " comm#               git commit -m "$comm"                echo "${msg[5]}" ;;            2 ) #               git init ;;            3 ) echo "${msg[9]}" ;;                # Выход            4 ) exit ;;                # Обработка остальных клавиш и вывод сообщения об ошибке            * ) echo "[$item]->: ${msg[2]}"; sleep 2 ;;        esac                done}mainexit 0

Это первая статья из двух. В следующей рассмотрим создание многоуровнего меню, разукрасим вывод (как же без этого), а также попробуем сохранить настройки, то есть задать код языка прямо из меню, не открывая Shell-скрипт в текстовом редакторе.

Спасибо, что дочитали до конца. Надеюсь, было не скучно :)

PS1='$PWD\n# '

printf -v line "%${COLUMNS}s"

line=${line// /-} # заменить все пробелы на -

printf -v line "%${COLUMNS}s"line=${line// /-}PS1='\n$line\n$PWD\n$line\n# '

info () {    printf -v line "%${COLUMNS}s"    line=${line// /-}    printf "\n$line\n$PWD\n$line\n# "}PS1='$(info)'

info () {    name_lenght="{ $HOSTNAME }"    name_lenght=${#name_lenght}    top_line_left=$[(COLUMNS-name_lenght)/2]    top_line_right=$[COLUMNS-(top_line_left+name_lenght)]    printf -v top_line "%${top_line_left}s{_S_${HOSTNAME}_S_}%${top_line_right}s"    printf -v bot_line "%${COLUMNS}s"    bot_line=${bot_line// /-}    top_line=${top_line// /-}    top_line=${top_line//_S_/ }    printf "\n$top_line\n$PWD\n$bot_line\n# "}PS1='$(info)'

RED='\e[31m' # красныйGRN='\e[32m' # зелёныйYLW='\e[33m' # жёлтыйBLU='\e[34m' # синийMGN='\e[35m' # пурпурныйDEF='\e[0m'  # вернуть значения по умолчаниюBLD='\e[1m'  # жирноDIM='\e[2m'  # тускло

info () {    name_lenght="{ $HOSTNAME }"    name_lenght=${#name_lenght}    top_line_left=$[(COLUMNS-name_lenght)/2]    top_line_right=$[COLUMNS-(top_line_left+name_lenght)]    printf -v top_line "%${top_line_left}s{_S_$DEF$BLD$HOSTNAME${DEF}_S_$GRN}%${top_line_right}s"    printf -v bot_line "%${COLUMNS}s"    bot_line=$GRN${bot_line// /-}$DEF    top_line=${top_line// /-}    top_line=$GRN${top_line//_S_/ }$DEF    printf "\n$top_line\n$BLD$BLU$PWD$DEF\n$bot_line\n# "}PS1='$(info)'

printf -v date "%(%a %d %b %T)T"

center_space=$[COLUMNS-${#date}-${#PWD}]((center_space<0)) && center_space=1...printf "\n$top_line\n$BLD$BLU$PWD$DEF%${center_space}s$DIM$date\n$bot_line\n# "

    git_tst= git_clr=    [[ -d .git ]] && {        git_tst=(GIT $(git status -sb))        git_tst="${git_tst[*]} " # простой для теста        git_clr=(GIT $(git -c color.ui=always status -sb))        git_clr="${git_clr[*]} " # цветной для вывода    }    ...    center_space=$[COLUMNS-${#date}-${#PWD}-${#git_tst}]    ...    printf "\n$top_line\n$BLD$BLU$PWD$DEF%${center_space}s${git_clr[*]}$DIM$date\n$bot_line\n\$ "

eyes=(O o    )

en=${#eyes[@]}

mouth='_'

face () {    printf "$YLW${eyes[$[RANDOM%en]]}$mouth${eyes[$[RANDOM%en]]}$DEF"}

face_tst='O_o  o_O'...center_space=$[COLUMNS-${#date}-${#PWD}-${#git_tst}-${#face_tst}]printf "\n$top_line\n$(face) $BLD$BLU$PWD$DEF%${center_space}s$git_clr$DIM$date $(face)\n$bot_line\n\$ "

info () {    error=$?    ...}

face () {    [[ $error -gt 0 ]] && ecolor=$RED || ecolor=$YLW    printf "$ecolor${eyes[$[RANDOM%en]]}$YLW$mouth$ecolor${eyes[$[RANDOM%en]]}$DEF"}

[[ $debian_chroot ]] && chrt="($debian_chroot)" || chrt=...name_lenght="{ $HOSTNAME$chrt }"...printf -v top_line "%${top_line_left}s{_S_$DEF$BLD$HOSTNAME$chrt${DEF}_S_$GRN}%${top_line_right}s"

PS1='$(info)'; case "$TERM" in xterm*|rxvt*) PS1="\[\e]0;$(face 1) \w\a\]$PS1";; esac

face () {    [[ $error -gt 0 ]] && ecolor=$RED || ecolor=$YLW    [[ $1 ]] && printf "${eyes[$[RANDOM%en]]}$mouth${eyes[$[RANDOM%en]]}" \             || printf "$ecolor${eyes[$[RANDOM%en]]}$YLW$mouth$ecolor${eyes[$[RANDOM%en]]}$DEF"}

RED='\e[31m' # красныйGRN='\e[32m' # зелёныйYLW='\e[33m' # жёлтыйBLU='\e[34m' # синийMGN='\e[35m' # пурпурныйDEF='\e[0m'  # вернуть значения по умолчаниюBLD='\e[1m'  # жирноDIM='\e[2m'  # тусклоeyes=(O o    ) en=${#eyes[@]} mouth='_'face () {    [[ $error -gt 0 ]] && ecolor=$RED || ecolor=$YLW    [[ $1 ]] && printf "${eyes[$[RANDOM%en]]}$mouth${eyes[$[RANDOM%en]]}" \             || printf "$ecolor${eyes[$[RANDOM%en]]}$YLW$mouth$ecolor${eyes[$[RANDOM%en]]}$DEF"}info () { error=$? git_tst= git_clr=    [[ -d .git ]] && {        git_tst=(GIT $(git status -sb))        git_tst="${git_tst[*]} " # простой для теста        git_clr=(GIT $(git -c color.ui=always status -sb))        git_clr="${git_clr[*]} " # цветной для вывода    }    [[ $debian_chroot ]] && chrt="($debian_chroot)" || chrt=    name_lenght="{ $HOSTNAME$chrt }"    name_lenght=${#name_lenght}    face_tst='O_o  o_O'    top_line_left=$[(COLUMNS-name_lenght)/2]    top_line_right=$[COLUMNS-(top_line_left+name_lenght)]    printf -v top_line "%${top_line_left}s{_S_$DEF$BLD$HOSTNAME$chrt${DEF}_S_$GRN}%${top_line_right}s"    printf -v bot_line "%${COLUMNS}s"    printf -v date  "%(%a %d %b %T)T"    top_line=${top_line// /-}    top_line=$GRN${top_line//_S_/ }$DEF    bot_line=$GRN${bot_line// /-}$DEF    center_space=$[COLUMNS-${#date}-${#PWD}-${#git_tst}-${#face_tst}]    ((center_space<0)) && center_space=1    printf "\n$top_line\n$(face) $BLD$BLU$PWD$DEF%${center_space}s$git_clr$DIM$date $(face)\n$bot_line\n\$ "}PS1='$(info)'; case "$TERM" in xterm*|rxvt*) PS1="\[\e]0;$(face 1) \w\a\]$PS1";; esac