Обратные строки и инструменты работы с ними в Python

Строки – один из важных и очень популярных элементов программирования в Python. Довольно сложно найти приложение, которое в своем коде не будет использовать строки или строковые данные. Исходя из этого, Python располагает достойной коллекцией разнообразных операторов, функций и методов для работы с этим чрезвычайно популярным, но относительно сложным типом данных.

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

В этой статье мы с вами освоим следующие действия:

• быстрое создание перевернутых строк методом нарезки
• использование обратных копий существующих строк с помощью инструментов reversed() и .join()
• применение итераций и рекурсий для ручного изменения существующих строк
• проведение обратной итерации по используемым строкам
• сортировка строк в обратном порядке с применением sorted()

Примечание: Для извлечения максимальной пользы от материала в данной статье, желательно иметь представление об основах работы со строками, циклами for и рекурсией .while.

Инструменты Python для “переворота” строк

Для решения некоторых конкретных задач в процессе создания кода может возникнуть необходимость работы со строками в обратном порядке.

Давайте представим, что у нас есть строка, которая содержит отрывок из букв украинского алфавита: “КЛМНОПР”. А нам нужно обратить эту строку, чтобы получить буквы в обратном порядке: “РПОНМЛК”. Давайте подумаем, что нам необходимо сделать для этого, и какими инструментами языка Python воспользоваться, чтобы решить эту задачу?

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

Язык программирования Python предлагает нам два простых способа создания обратных копий строк.

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

А второй способ, по сути, еще проще – можно применить встроенную функцию reversed() для создания итератора, который возвращает символы используемой строки в обратном порядке.

Переворот строк и применение функции slice

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

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

Давайте рассмотрим синтаксис, который позволяет нам разрезать строки:  

stroka[start:stop:shag]

Наши смещения обозначены здесь, как start, stop, shag. Данный синтаксис является читабельным и благозвучным: его можно легко понять, если прочесть подобно предложению на английском языке: мы извлекаем из строки stroka все символы от start до stop, по одному за каждый шаг shag.

Указывать цифровые значения каждого смещения вовсе не обязательно, так как они имеют значения по умолчанию:

• start – 0
• stop – len (длина строки в символах)
• shag – 1

Эти значения используются в том случае, если не указываются другие. Значение start представляет собой индекс первого символа в срезе, а значение stop останавливает процесс на конечном символе среза. В случае же, если stop приравнивается к значению по умолчанию (len), срез осуществляется до конца обрабатываемой строки. Значение же shag указывает, через сколько символов будет проходить срез при каждой итерации.

Примечание: Важно понимать, что процедура среза завершается при достижении индекса, равного, либо меньшего, чем значение stop.  Следовательно, в завершающем срезе уже не будет присутствовать элемент с таким же индексом.

Значение смещения shag позволяет точно определить, какие символы в строке нам нужно извлекать, а какие – пропускать.  Давайте на примере приведенного ниже кода рассмотрим некоторые варианты значений shag и получаемые при этом результаты:

bukvy = "КкЛлМмНн"
 
print(bukvy[::])     # Получение всех символов при значениях смещения по умолчанию
# результат - 'КкЛлМмНн'
 
print(bukvy[:])      # Получение всех символов при значениях смещения по умолчанию
# результат - 'КкЛлМмНн'
 
print(bukvy[::2])    # Получение каждого второго символа от 0 и до конца строки
# результат - 'КЛМН'
 
print(bukvy[1::2])   # Получение каждого второго символа от 1 и до конца строки
# результат - 'клмн'

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

Для примера, давайте попробуем установить значение shag равным -1, что в результате даст нам срез, возвращающий символы нашей строки в обратном порядке:

bukvy = "КЛМНОПР"    # исходное значение строки
 
print(bukvy[::-1])   # вывод на консоль обратной строки - 'РПОНМЛК'
 
print(bukvy)         # вывод на консоль исходной строки без изменений 'КЛМНОПР'

Как мы видим, процедура нарезки при таких параметрах смещения возвращает нам копию заданной в bukvy строки в обратном порядке. При этом содержимое исходной строки не изменяется.

Подобного результата можно достичь и с помощью функции .slice(). Давайте посмотрим на синтаксис данной функции:

slice(start, stop, shag)

Мы видим уже знакомые нам три аргумента, как и в операторе среза. Данная встроенная в Python функция возвращает нам объект среза в виде набора индексов подобно тому, как функция range(start, stop, shag) генерирует соответствующий список чисел.

Чаще всего, slice() применяется для эмуляции процедуры среза [::-1] и более быстрого изменения строк. Давайте поместим данную функцию в квадратные скобки с переменной для нашей строки и посмотрим, как все работает:

bukvy = "КЛМНОПР"    # исходное значение строки
print(bukvy[slice(None, None, -1)])
# РПОНМЛК

В этом коде мы наблюдаем аналогичную ситуацию, как и в случае со срезами и смещениями. Присвоение значения None первым двум аргументам функции slice() вызывает использование этих значений по умолчанию, а значение shag, равное -1, указывает направление нарезки. Таким образом, все три аргумента функции slice() обеспечивают в нашем случае нарезку полной строки справа налево, от ее начала и до конца.

Использование .join() и reverse() для создания обратных строк

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

Давайте подробно рассмотрим работу данного способа на практическом примере:

privetstviye = reversed("Привет!")  # итерация строки
 
print(next(privetstviye))           # вывод нового символа
# !
print(next(privetstviye))
# т
print(next(privetstviye))
# е
print(next(privetstviye))
# в
print(next(privetstviye))
# и
print(next(privetstviye))
# р
print(next(privetstviye))
# П

Как мы видим, функция reversed() принимает строку privetstviye как аргумент, и проводит итерацию символов строки в обратном порядке, слева направо. Вызов оператора next с той же строкой privetstviye в качестве аргумента, выдает нам по одному символу строки за каждый вызов.

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

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

perevertysh = "".join(reversed("Привет!"))
print(perevertysh)
# !тевирП

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

Создание перевернутых строк вручную

Итак, мы с вами изучили основные инструменты и функции Python, позволяющие быстро и относительно просто реверсировать строки. Эти знания безусловно позволят решить нам большинство задач с обращением строк.

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

Обращение строк в цикле

Первый способ, который мы с вами опробуем, основан на цикле for с использованием оператора конкатенации +. Этот оператор работает с двумя строковыми операндами (исходными строками), которые объединяются между собой и сохраняются в виде новой строки. Данный процесс называется так же, как и сам оператор – конкатенация.

В примере ниже показан код, который выполняет переворот строки с применением цикла и конкатенация:

def perevorot_stroki(text):                 # переворот строки
    perevertysh = ""
    for simvol in text:                     # цикл для обработки строки
        # сложение строки с очередным ее символом в обратном порядке
        perevertysh = simvol + perevertysh
    return perevertysh
 
print(perevorot_stroki("Привет!"))          # перевернутая строка
# !тевирП

Определенная в данном коде пользовательская функция perevorot_stroki() использует цикл, где при каждой итерации от исходной (принимаемой в качестве аргумента) строки text “откусывается” символ simvol,  который затем накапливаемым итогом объединяется с вновь формируемой перевернутой строкой perevertysh. При этом, данная строка perevertysh изначально (до цикла) приравнивается к пустой строке. Но в процессе итераций в цикле для этой строки происходит постепенное (побуквенное) накопление символов, начиная с конца исходной строки. А уже в конце цикла, строка perevertysh представляет собой полное перевернутое содержимое исходной строки text.

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

Кроме цикла for, для создания обратной копии строки, мы можем также воспользоваться циклом while. Далее давайте рассмотрим пример кода на основе этого цикла. 

def perevorot_stroki(text):
   perevertysh = ""
   index = len(text) - 1             # индексирование последнего символа строки
   while index >= 0:                 # цикл от индекса до нуля
        perevertysh += text[index]   # объединение строки и индексированного символа
        index -= 1
   return perevertysh
 
print(perevorot_stroki("Привет!"))   # реверсивная копия исходной строки
# !тевирП

Вначале данного кода мы определяем index последнего символа в исходной строке с помощью встроенной Python функции len(). После этого, цикл while начинает свою работу от прежде определенного нами значения index последнего символа исходной text и до нуля включительно. При каждой итерации, с помощью расширенного оператора присваивания += создается новая строка, которая объединяет уже сформированное содержимое строки perevertysh с соответствующим символом строки text. После же завершения цикла, в конечном итоге, получается новая строка, являющаяся реверсивной копией исходной строки text.

Рекурсия для переворота строк

Еще одним интересным способом получения обратных строк является использование рекурсии.

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

Ниже приведен пример рекурсивной функции, создающей обратную копию той исходной строки, которая ей принимается в качестве аргумента:

def perevorot_stroki(text):
    # базовый случай для проверки необходимости выхода из функции
    if len(text) == 1:
        # выход из функции
        return text
    # рекурсивный вызов этой же функции
    return perevorot_stroki(text[1:]) + text[:1]
 
# реверсивная копия исходной строки
print(perevorot_stroki("Привет!"))
# !тевирП

Давайте подробно рассмотрим все действия в нашем примере.

В начале функции мы проверяем длину текущего значения исходной строки text на базовый случай и, если в процессе проверки выясняется, что эта исходная строка содержит всего лишь один символ, то происходит выход из функции и возврат сформированной строки, обратно вызывающей стороне. Также, как мы видим в коде, функция perevorot_stroki() вызывает саму себя, что, в сущности, и является примером вышеописанного рекурсивного случая. Причем, в качестве аргумента для рекурсивного вызова функции perevorot_stroki используется срез [1:] исходной строки  со всеми символами строки text, кроме первого. Также к срезу [1:] при рекурсивном вызове вышеназванной функции в качестве аргумента добавляется еще и строка text[:1], содержащая первый символ из исходной строки text. 

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

ochen_dlinnoye_privetstviye = "Привет!" * 1_000
print(perevorot_stroki(ochen_dlinnoye_privetstviye))

Traceback (most recent call last):
    ...
RecursionError: maximum recursion depth exceeded while calling a Python object

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

С этой целью, естественно, прежде нам придется определить текущие предельно допустимое значение рекурсий для нашего интерпретатора Python. Это значение легко можно узнать с помощью функции getrecursionlimit() из модуля sys. По умолчанию обычно для Python последних версий устанавливается значение, равное 1000. Для изменения данного предельно допустимого значения мы можем воспользоваться функцией setrecursionlimit() из того же модуля. Таким образом, эти две функции позволят нам осуществить оптимальную настройку рекурсии, так чтобы в коде выполнялись все необходимые нам задачи.

Реверс строк с помощью функции reduce()

В случае приверженности принципам функционального программирования для реверса (переворота) строк нам также имеет смысл ознакомиться с функцией reduce() из Python модуля functools.

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

Вот так выглядит пример использования функции reduce() для создания перевернутой строки:

from functools import reduce                   # импорт функции из модуля
 
def perevorot_stroki(text):
     # объединение двух строк в обратном порядке
     return reduce(lambda a, b: b + a, text)
 
print(perevorot_stroki("Привет!"))             # обратная копия исходной строки
# !тевирП

В качестве функции-аргумента для reduce() в данном коде используется одноразовая анонимная lambda функция, которая призвана объединять две строки (символы из строки text) в обратном порядке до тех все символы в данной строке, переданной в качестве второго аргумента функции reduce(), не закончатся.

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

Реверсивная итерация строк

Иногда возникает необходимость выполнить итерацию существующих строк в обратном порядке, другими словами – провести обратную итерацию.

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

• встроенная функция reversed()
• оператора нарезки [: : -1]

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

Встроенная функция reversed()

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

Стоит учесть, что основное назначение reversed() – это реализация обратной итерации для всех возможных типов итерируемых объектов в Python. Но, в нашем случае, вышеназванная функция использует лишь строку в качестве аргумента и возвращает итератор, который, в свою очередь, генерирует нам символы из исходной строки в обратном порядке.

Вот так выглядит код, в котором реализован перебор строки в обратном порядке с помощью функции reversed():

privetstviye = "Привет!"                # строка приветствия
 
for simvol in reversed(privetstviye):   # цикл c реверсом символов строки
     print(simvol)                      # вывод символов строки
# !
# т
# е
# в
# и
# р
# П
 
print(reversed(privetstviye))
# <reversed object at 0x000001CECE0A5BA0>

Не правда ли, удачное использование цикла for в вышеприведенном примере выглядит довольно простым и читабельным, а сама функция reversed() ясно обозначает свое действие над аргументом и сообщает, что не будет производить никаких других действий над исходной строкой.

Поскольку функция reversed() в цикле возвращает соответствующий итератор, то она также является эффективной и в отношении использования памяти.

Осуществление нарезки оператором [::-1]

Для выполнения обратной итерации по строкам, кроме функции reversed(), также можно применить так называемый расширенный синтаксис срезов, которой уже использовался нами раннее при рассмотрении примера с инструментом нарезки строки bukvy[::-1].

В отличие от функции reversed(), нарезку строки оператором [::-1] нельзя назвать эффективной, как в отношении использования памяти, так и с точки зрения удобочитаемости. Однако использование данного оператора обеспечивает достаточно быстрый перебор и получение обратной копии исходной строки:

privetstviye = "Привет!"            # строка приветствия
 
for simvol in privetstviye[::-1]:   # цикл с нарезкой символов строки
     print(simvol)                  # вывод символов строки
# !
# т
# е
# в
# и
# р
# П
 
print(privetstviye[::-1])           # нарезка строки
# !тевирП

Давайте поподробнее рассмотрим, как же работает наш код:

• Сначала мы вызываем оператор среза для строки privetstviye с тем, чтобы создать ее обратную копию.
• далее от этой вновь созданной обратной копии строки в цикле “откусывается” по одному символу за итерацию.
• затем данный откусываемый от обратной строки символ записывается в переменную simvol, который при каждой итерации выводится на консоль функцией print().

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

Создание пользовательской реверсивной строки

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

Например, для переворота Python списков непосредственно в том же месте памяти, где они изначально находились, без создания новых объектов мы можем воспользоваться базовым для списков методом .reverse().

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

Давайте рассмотрим пример, того, как все же реализовать вышеописанный способ:

from collections import UserString     # вызов UserString из модуля collections
 
class ObratnayaStroka(UserString):     # создание подкласса строки
     def reverse(self):                # переворот строки
         self.data = self.data[::-1]   # нарезка обратной строки

Давайте разберемся по порядку, что происходит в нашем примере:

Подкласс ObratnayaStroka наследуется от класса UserString, выступающего в качестве оболочки для встроенного типа данных str и определенного в Python модули collections сугубо для создания соответствующих str объектов с той или иной спецификой. Данный класс Userstring в модули collections специально создавался с тем, чтобы можно было максимально удовлетворить потребности в создании собственных строковых классов с дополнительным набором функций.

По сути, класс Userstring обеспечивает ту же функциональность, что и обычная строка Python. Но, при этом, он еще и добавляет общедоступный атрибут с именем .data, являющемся тем самым, оборачиваемым классом, строковым объектом, предоставляющим нам непосредственный доступ к строке и позволяющим осуществлять над ней любые необходимые нам операции.

Как видно из раннее приведенного кода, внутри нашего подкласса ObratnayaStroka мы создаем метод .reverse(), который через атрибут .data выполняет переворот исходной строки, переназначая ее затем обратно в тот же атрибут .data. Таким образом, вызов метода .reverse() для вновь созданного при помощи подкласса ObratnayaStroka строкового объекта, выполняет переворот строки на том же самом месте в памяти и не создает нового объекта. Вместе с тем, по итогу выполнения вышеназванного метода на месте исходной строки создастся новая строка, содержащая те же исходные данные, но только в обратном порядке.

На практике, все это работает следующим образом:

text = ObratnayaStroka("Привет!")     # создание строки
print(text)
# Привет!
 
text.reverse()                        # переворот строки на месте
print(text)
# !тевирП

При вызове метода .reverse() для строки text, он будет действовать подобно ситуации, при которой исходная строка изменяется на месте. Однако, на самом деле мы сначала создаем новую (переворачиваемую) строку в каком-то ином уголке компьютерной памяти и, только потом присваиваем значение этой новой строки обратно исходной строке.

Следует обратить внимание, что теперь исходная строка text хранится в обратном порядке.

Поскольку подкласс ObratnayaStroka и его родительский класс UserString предоставляют нам тот же функционал, что и базовый суперкласс str, то мы можем использовать раннее рассмотренную внутреннюю Python функцию reversed() для обратной итерации, как говорится, прямо из коробки:

text = ObratnayaStroka("Привет!")  # создание строки
 
for simvol in reversed(text):      # поддержка обратной итерации прямо из коробки
     print(simvol)                 # вывод символов строки в обратном порядке
# !
# т
# е
# в
# и
# р
# П
 
print(text)                        # вывод исходной строки
# Привет!

В этом коде мы вызываем внутреннюю Python функцию reversed() со строкой text в качестве аргумента при запуски цикла for. Вызов данной функции, абсолютно аналогично действиям над обычной строкой, возвращает нам тот же самый итератор. Это объясняется тем, что поведение нашего подкласса ObratnayaStroka и его родительского класса UserString полностью наследуется от суперкласса str. Из вышеприведенного кода также мы видим, что вызов Python функции reversed() абсолютно никак не затрагивает наше исходную строку, сохраненную в переменной text. 

Сортировка строк Python в обратном порядке

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

Для решения вышеописанной задачи, обычно используют встроенную в Python функцию sorted(), возвращающую все те же, переданные ей в виде определенной последовательности, данные, но только либо в порядке возрастания, либо в порядке убывания.

Кроме исходной последовательности данных (итерируемого объекта), функция sorted() в качестве поименованного аргумента принимает также и ключевое слово reverse, определяющее порядок сортировки. По умолчанию, этот аргумент reverse установлен в значение False, что означает сортировку по возрастанию. Если же значение этого аргумента будет установлено в True, то сортировка нашего итерируемого объекта будет производится в порядке убывания:

glasnyye = "еаяои"
 
vyvod = sorted(glasnyye)                 # Сортировка по возрастанию
print(vyvod)
# ['а', 'е', 'и', 'о', 'я']
 
vyvod = sorted(glasnyye, reverse=True)   # Сортировка по убыванию
print(vyvod)
# ['я', 'о', 'и', 'е', 'а']

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

Поскольку функция sorted() возвращает список, а не строку, которую она получает в качестве своего аргумента, то нам бы не мешало бы заново преобразовать вышеназванный список в результирующую (отсортированную) строку. Удобнее всего для этого воспользоваться методом .join(), который мы с вами применяли в предыдущих разделах данной статьи:

glasnyye = "еаяои"
 
vyvod = "".join(sorted(glasnyye, reverse=True))    # создание строки из списка
print(vyvod)
# яоиеа

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

Также мы можем применить функцию sorted() для перебора строки в обратном отсортированном порядке:

# цикл для перебора строки в обратном порядке
for glasnaya in sorted(glasnyye, reverse=True):
     # вывод строки
     print(glasnaya)
# я
# о
# и
# е
# а

Благодаря данному разделу статьи, мы наглядно убедились в том, что функция sorted() позволяет сортировать итерируемые объекты по возрастанию без значения аргумента reverse, и по убыванию – со значением True для данного аргумента. Вообще, использование функции sorted() в сочетании с поименованным аргументом reverse представляет собой весьма удобный универсальный инструмент для сортировки, содержащихся в строках, символов в любом нужном для нас порядке.

Выводы

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

В частности, благодаря этой статье мы с вами научились:

• быстро создавать обратные строки с помощью оператора нарезки
• применять функцию reversed() и метод .join() для создания обратных копий исходных строк
• использовать итерацию и рекурсию для создания обратных строк вручную
• выполнять перебор строки в обратном порядке
• сортировать строки по убыванию с помощью функции sorted() и ее аргумента reverse.

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