Что значит b перед строкой python

(1) Строки в Python, начинающиеся с r или R, представляют (неэкранированные) исходные строки.

Объясните, что XXX в строке r «XXX» — это общий символ.

По сравнению с обычными символами, другие относительно специальные символы могут содержать escape-символы, то есть символы с обратной косой чертой и соответствующие буквы, которые представляют соответствующие специальные значения. Например, наиболее распространенный «\ n» означает разрыв строки, «\ t» означает Вкладка и т. Д.

И если он начинается с r, это означает, что все следующие символы являются обычными символами, то есть, если это «\ n», то это означает обратную косую черту, букву n, а не разрыв строки.

Символы, начинающиеся с r, часто используются в регулярных выражениях и соответствуют модулю re.

(2) Строка, начинающаяся с u или U, представляет собой строку Unicode.

Юникод — это стандартный метод написания международных текстов. Если вы хотите писать текст не на английском языке, вам понадобится редактор, поддерживающий Unicode.

Точно так же Python позволяет обрабатывать текст Unicode — вам просто нужно добавить к строке префикс u или U.

Это не только для китайского, но и для любой строки, что означает, что строка закодирована в Unicode. К

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

Появляются искаженные символы. К

Рекомендуется, чтобы все методы кодирования использовали utf8

(3) Строка, начинающаяся с b или B b: байт

По умолчанию str в spython3.x — это unicode (в py2.x), bytes — это str в (py2.x), а префикс «b» представляет байты.

В python2.x префикс b не имеет определенного значения, просто для совместимости с формулировкой python3.x

Что означает префикс b перед строкой Python?

В исходном коде Python я наткнулся на небольшую строку b перед строкой, например:

Я знаю о префиксе u , обозначающем строку Unicode, и префиксе r для необработанного строкового литерала.

Что означает b и в каком виде исходного кода он полезен, поскольку кажется, что он в точности похож на обычную строку без префикса?

2 ответа

Это bytes буквальный Python3. Этот префикс отсутствует в Python 2.5 и старше (он эквивалентен простой строке 2.x, тогда как обычная строка 3.x эквивалентна литералу с префиксом u в 2.x). В Python 2.6+ это эквивалентно простой строке, для совместимости с 3.x.

Если вы видите, что оно используется в исходном коде Python 3, выражение создает <> объект, а не обычный Unicode << X1>> объект. Если вы видите, что это отражено в вашей оболочке Python или как часть списка, dict или другого содержимого контейнера, то вы видите объект bytes , представленный с использованием этой нотации.

Объекты bytes в основном содержат последовательность целых чисел в диапазоне 0–255, но когда они представлены, Python отображает эти байты как кодовые точки ASCII, чтобы их было легче читать. Любые байты за пределами печатаемого диапазона символов ASCII отображаются как escape-последовательности (например, \n , \x82 и т. д.). И наоборот, для определения байтовых значений можно использовать как символы ASCII, так и управляющие последовательности; для значений ASCII используется их числовое значение (например, b’A’ == b’\x41′ )

Поскольку объект bytes состоит из последовательности целых чисел, вы можете создать объект bytes из любой другой последовательности целых чисел со значениями в диапазоне 0–255, например списка:

А индексирование возвращает вам целые числа (но нарезка дает новое значение bytes ; в приведенном выше примере value[0] дает вам 72 , но value[:1] равно b’H’ 72 — это кодовая точка ASCII для заглавной буквы H ).

bytes модель двоичных данных , включая закодированный текст . Если ваше значение bytes действительно содержит текст, вам необходимо сначала его декодировать, используя правильный кодек. Если данные закодированы как UTF-8, например, вы можете получить значение Unicode str с помощью:

И наоборот, чтобы перейти от текста в объекте str к bytes , вам необходимо закодировать . Вам необходимо выбрать кодировку для использования; по умолчанию используется UTF-8, но то, что вам понадобится, сильно зависит от вашего варианта использования:

Вы также можете использовать конструктор bytes(strvalue, encoding) , чтобы сделать то же самое.

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

Python 2 версий 2.6 и 2.7 также поддерживает создание строковых литералов с использованием синтаксиса строковых литералов b’..’ , чтобы упростить код, работающий как на Python 2, так и на Python 3.

Объекты bytes неизменяемы, как и строки str . Используйте объект bytearray() , если вам нужен изменяемый значение в байтах.

Строки в Python

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

(от англ. strings) – это неизменяемые упорядоченные последовательности символов Юникода, которые используются в Python для хранения и представления текстовой информации. По умолчанию в скриптах используется кодировка UTF-8 .

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

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

Создание строк в Python

Вписать литерал строки в код программы на языке Python довольно легко. Достаточно заключить требуемую последовательность символов в одинарные, двойные или тройные кавычки (см. пример №1 ).

Пример №1. Создание литералов строк в Python.

Использование для создания строк сразу нескольких видов кавычек обусловлено тем, что это дает возможность использовать в литералах, заключенных в кавычки одного типа, кавычки другого типа (см. пример №2 ). При этом допускается использование кавычек любого разрешенного типа внутри строковых литералов, заключенных в кавычки того же типа, предварительно экранировав их при помощи обратного слеша \ .

Пример №2. Порядок использования кавычек внутри строк.

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

использовать обратный слеш \ в требуемом месте переноса строки;
использовать строки в тройных кавычках, которые как раз и предназначены для оформления больших блоков текста внутри исходного кода;
разбить строку на несколько частей и затем объединить их при помощи символа + , при этом не забыв использовать круглые скобки, как показано в примере №3 .

Пример №3. Использование многострочных блоков текста в коде.

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

Экранированные последовательности

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

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

Перечислим использующиеся в Python экранированные последовательности:

\0 – символ Null (не является признаком конца строки);
\a – звонок;
\b – забой, т.е. возврат на одну позицию ( \u0008 );
\v – вертикальная табуляция ( \u000B );
\t – горизонтальная табуляция ( \u0009 );
\n – перевод строки ( \u000A );
\f – подача страницы, т.е. ее очистка;
\r – возврат каретки ( \u000D );
\» – двойная кавычка ( \u0022 );
\’ – одинарная кавычка ( \u0027 );
\\ – обратный слеш ( \u005C );
\ooo – восьмеричный код символа (не более трех цифр);
\xhh – символ Latin-1 , заданный двумя цифрами в шестнадцатеричной системе счисления;
\N – идентификатор ID базы данных Юникода (т.е. название символа в базе);
\uhhhh – 16 -битный символ Юникода, заданный четырьмя цифрами в шестнадцатеричной системе счисления;
\uhhhhhhhh – 32 -битный символ Юникода в шестнадцатеричном представлении;
\другое – не является экранированной последовательностью (символ обратного слеша сохраняется).

Использование некоторых управляющих последовательностей показано в примере №4 .

Пример №4. Использование экранированных последовательностей в строках.

Использовав кнопку «Результат» (как и всегда, когда она присутствует в блоке), мы увидим, что вывод первых двух строк на экран будет совершенно идентичным, т.к. экранированные последовательности представляют собой символы Юникода. Кроме того, в последней строке обратный слеш ничего не экранирует, ведь после него не стоят символы какой-нибудь управляющей последовательности.

Бывают случаи, когда нужно подстраховаться и запретить экранированные последовательности в строке. Хорошим примером может служить строка с адресом, например, ‘D:\python\new_tests\test_1.py’ . В таких ситуациях перед строкой нужно использовать символ r , который отключает для строки механизм экранирования (см. пример №5 ).

Пример №5. Подавление экранирования в строках.

Как видим, в нашем случае последовательность \n интерпретируется как символ новой строки, а последовательность \t замещается символом горизонтальной табуляции. Ситуация исправляется либо за счет использования неформатированной строки, либо экранированием обратных слешей.

Cледует добавить, что неформатированные строки не могут заканчиваться неэкранированным символом обратного слеша, т.к. он будет экранировать кавычки в конце строки. В таких случаях можно добавить его отдельно при помощи конкатенации (например, r’D:\text’ + ‘\\’ ), продублировать и затем удалить при помощи среза (например, r’D:\text\\'[:-1] ) или не использовать подавление вообще, экранировав все слеши в обычной строке (например, ‘D:\\text\\’ ).

Доступ по индексу и срезы строк

Как говорилось выше, строки в Python представляют собой неизменяемые упорядоченные последовательности символов Юникода. И хотя изменить строку нельзя, доступ к ее отдельным символам можно получить при помощи операции индексирования. Для этого нужно указать в квадратных скобках после имени или литерала строки порядковый номер символа в последовательности, не забывая, что нумерация символов в строке начинается с нуля (см. пример №6 ).

Пример №6. Доступ к символам строки по индексу.

В отличие от многих других языков программирования в Python доступ к символам строки возможен также и по отрицательным индексам. В этом случае можно считать, что отсчет ведется с конца строки и начинается с -1 . Более того, в Python для строк (и других упорядоченных последовательностей) доступна операция извлечения среза, которая без особых усилий позволяет извлекать не только отдельные символы, но и целые диапазоны символов, не прибегая при этом к специальным методам или встроенным функциям (см. пример №7 ).

Пример №7. Порядок извлечения срезов строк.

При извлечении срезов следует помнить, что нумерация символов в строках начинается с нуля, а символ с индексом второго предела, указанного в квадратных скобках, не будет присутствовать в срезе. Например, в срезе str_1[0:5] будут присутствовать первые пять символов с индексами от 0 до 4 , но не включая символ с индексом 5 .

Добавим, что один или оба предела среза можно опускать. Если не указывать первый предел, интерпретатор будет начинать срез с первого символа строки (с индексом 0 ). При отсутствии второго предела срез будет идти до конца строки. Если опустить оба предела, мы получим копию строки от первого до последнего символа. Более того, при необходимости разрешается указывать и третий предел, который будет задавать шаг среза (см. пример №8 ).

Пример №8. Порядок использования шага среза у строк.

Как видим, шаг среза также может иметь отрицательное значение. В этом случае отсчет символов и шагов ведется в противоположном направлении, а границы среза указываются справа налево, т.е. индекс символа, стоящего правее в последовательности должен указываться первым. Например, в срезе примера str_1[-15:3:-3] отсчет ведется справа налево, начиная с 15 -го символа, отсчитываемого с конца строки, до символа с индексом 3 , который находится левее и в срез не включается.

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

Операторы строк в Python

С оператором сложения + применительно к строкам мы уже познакомились выше. Он используется для объединения строк в одну. Соответственно комбинированный оператор += добавляет целевую строку в конец текущей. Еще одним арифметическим оператором, который применим к строкам, является оператор умножения * (соответствующий ему комбинированный оператор имеет вид *= ). Однако в отличие от чисел здесь он служит для повторения строки указанное число раз (см. пример №9 ).

Пример №9. Использование операторов + и * применительно к строкам.

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

Теперь давайте познакомимся с оператором проверки на вхождение in , который применительно к строкам совершает поиск требуемой подстроки (левый операнд) в целевой строке (правый операнд). В случае успеха операция возвращает True , иначе – False (см. пример №10 ).

Пример №10. Использование оператора in применительно к строкам.

Как видно из примера, оператор in может использоваться не только самостоятельно, но и совместно с оператором отрицания not , который инверсирует возвращаемое логическое значение оператора in . Например, операция ‘ли’ not in ‘Питон’ вернет True вместо False .

Забегая вперед добавим, что оператор in входит также и в состав инструкции цикла for , который обычно используется, когда возникает необходимость в обходе, например, всех элементов последовательности или атрибутов объекта. Синтаксис цикла for в Python имеет следующий вид:

В ходе выполнения цикла for интерпретатор один за другим присваивает переменной заголовка элементы объекта и выполняет для них инструкции тела цикла (см. пример №11 ). Если цикл нужно прервать, используется инструкция break , которая передает управление инструкции, следующей сразу за циклом. Кроме того, в цикле for разрешается использовать необязательный блок else , инструкции которого выполняются только после удачного завершения цикла (т.е. при отсутствии ошибки или прерывания за счет использования инструкции break ).

Пример №11. Использование цикла for для обхода символов строки.

Функции и методы строк в Python

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

str.capitalize() – возвращает копию строки, переводя первый символ строки в верхний регистр, а все остальные в нижний (см. пример №12 ).
str.title() – возвращает копию строки, в которой первые символы каждого слова преобразованы в символы верхнего регистра, а все остальные символы – в символы нижнего регистра.
str.upper() – возвращает копию строки, в которой все символы приведены к верхнему регистру.
str.lower() – возвращает копию строки, в которой все символы приведены к нижнему регистру.
str.swapcase() – возвращает копию строки, в которой все символы верхнего регистра преобразованы в символы нижнего регистра, а все символы нижнего регистра – в символы верхнего регистра.

Пример №12. Методы строк (часть 1).

str.count(sub[, start[, end]]) – возвращает число вхождений подстроки sub в строку str или в срез строки str[start:end] , если он задан (см. пример №13 ). При этом подсчитываются только непересекающиеся последовательности символов, т.е. в строке aaaa будет найдено всего две строки aa .
str.find(sub[, start[, end]]) – возвращает индекс первого вхождения подстроки sub в строку str или в срез строки str[start:end] , если он задан. В случае неудачного поиска метод возвращает -1 . Обратите внимание, что при использовании среза отсчет индекса искомой подстроки все равно отсчитывается от начала всей строки (тоже самое касается и аналогичных методов ниже).
str.index(sub[, start[, end]]) – также возвращает индекс первого вхождения подстроки sub в строку str или в срез строки str[start:end] , если он задан. Однако в случае неудачного поиска метод вызывает исключение ValueError .
str.rfind(sub[, start[, end]]) – возвращает индекс последнего вхождения подстроки sub в строку str или в срез строки str[start:end] , если он задан. В случае неудачного поиска метод возвращает -1 .
str.rindex(sub[, start[, end]]) – также возвращает индекс последнего вхождения подстроки sub в строку str или в срез строки str[start:end] , если он задан. Однако в случае неудачного поиска метод вызывает исключение ValueError .

Пример №13. Методы строк (часть 2).

str.ljust(width[, ﬁllchar]) – возвращает копию строки, выровненную по левому краю в строке с длиной width . Недостающие символы по умолчанию заполняются пробелами или символом ﬁllchar , если данный необязательный аргумент будет задан. Кроме того, если width < len(str) , то будет возвращена копия исходной строки без каких-либо изменений (см. пример №14 ).
str.rjust(width[, ﬁllchar]) – возвращает копию строки, выровненную по правому краю в строке с длиной width . Недостающие символы по умолчанию заполняются пробелами или символом ﬁllchar , если данный необязательный аргумент будет задан. Кроме того, если width < len(str) , то будет возвращена копия исходной строки без каких-либо изменений.
str.center(width[, ﬁllchar]) – возвращает копию строки, отцентрированную в строке с длиной width . Недостающие символы по умолчанию заполняются пробелами или символом ﬁllchar , если данный необязательный аргумент будет задан. Кроме того, если width < len(str) , то будет возвращена копия исходной строки без каких-либо изменений.
str.expandtabs(tabsize=8) – возвращает копию строки, в которой символы табуляции замещены пробелами с шагом 8 (по умолчанию) или в соответствии со значением необязательного аргумента tabsize . Если какая-то подстрока не помещается внутри одного столбца, то ширина данного столбца будет увеличена до необходимых размеров.
str.zfill(width) – возвращает копию строки, в которой исходная строка str дополняется нулями слева так, чтобы длина новой строки стала равна width .

Пример №14. Методы строк (часть 3).

str.replace(old, new[, count]) – возвращает копию строки, в которой все подстроки old заменены на подстроки new . Если указан аргумент count , метод производит только указанное количество замен (см. пример №15 ).
str.strip([chars]) – возвращает копию строки, из которой удалены начальные и завершающие пробельные символы (по умолчанию) или символы, входящие в строку chars .
str.lstrip([chars]) – возвращает копию строки, из которой удалены начальные пробельные символы (по умолчанию) или символы, входящие в строку chars .
str.rstrip([chars]) – возвращает копию строки, из которой удалены завершающие пробельные символы (по умолчанию) или символы, входящие в строку chars .

Пример №15. Методы строк (часть 4).

str.split(sep=None, maxsplit=-1) – выполняет разбиение исходной строки на подстроки по пробельным символам (по умолчанию) или подстроке sep , если она задана, и возвращает их в виде списка. Следует добавить, что когда аргумент sep не указывается, интерпретатор считает все подряд идущие пробельные символы одним пробелом, а разбиение пустой строки или строки, состоящей из одних пробельных символов, возвращает пустой список. Однако, если разбить пустую строку, использовав отличный от пробела разделитель, метод вернет список с пустой строкой (см. пример №16 ). Если указан аргумент maxsplit , метод производит только указанное количество разбиений, которые будут выполнены слева направо. По умолчанию строка разбивается по всем имеющимся разделителям.
str.rsplit(sep=None, maxsplit=-1) – тоже самое, что и предыдущий метод. Однако в этом случае разбиение выполняется с конца строки, т.е. справа налево.
str.splitlines([keepends]) – возвращает список строк, выполняя разбиение строки по символам перевода строки и по умолчанию удаляя их. Однако, если указать необязательный аргумент keepends=True , символы перевода строки будут сохранены. К допустимым символам перевода строки относятся: \n – перенос строки, \r – возврат каретки, \r\n – возврат каретки и перенос строки, \v или \x0b – вертикальный отступ, \f или \x0c – разрыв страницы, \x1c – разделитель файлов, \x1d – разделитель групп, \x1e – разделитель строк, \x85 – следующая строка, \u2028 – разделитель строк, \u2029 – разделитель абзацев.
str.partition(sep) – разбивает строку в направлении слева направо по первому найденному разделителю sep и возвращает кортеж из трех элементов: строка до разделителя, сам разделитель и строка после разделителя. Если разделитель найден не будет, метод вернет кортеж так же состоящий из трех элементов: исходная строка str и две пустые строки.
str.rpartition(sep) – разбивает строку в направлении справа налево (т.е. поиск разделителя ведется с конца строки) по первому с конца разделителю sep и возвращает кортеж из трех элементов: строка до разделителя, сам разделитель и строка после разделителя. Если разделитель найден не будет, метод вернет кортеж так же состоящий из трех элементов: две пустые строки, а также сама исходная строка str .
str.join(iterable) – возвращает строку, полученную объединением всех элементов итерируемого (т.е. элементы которого можно пересчитать) объекта iterable через разделитель str , который может быть пустой строкой. Отметим, все элементы передаваемой последовательности должны быть строками, иначе будет вызвана ошибка.

Пример №16. Методы строк (часть 5).

str.startswith(preﬁx[, start[, end]]) – возвращает True , если строка str или срез строки str[start:end] , если он задан, начинается последовательностью символов preﬁx . В противном случае метод возвращает False (см. пример №17 ).
str.endswith(suffix[, start[, end]]) – возвращает True , если строка str или срез строки str[start:end] , если он задан, заканчивается последовательностью символов suffix . В противном случае метод возвращает False .
str.isidentifier() – возвращает True , если строка str не пустая и является допустимым идентификатором. В противном случае метод возвращает False .
str.isspace() – возвращает True , если строка str не пустая и состоит только из пробельных символов. В противном случае метод возвращает False .
str.isascii() – возвращает True , если строка str не пустая и содержит только символы ASCII . В противном случае метод возвращает False .
str.isdigit() – возвращает True , если строка str не пустая и содержит только символы ASCII , обозначающие цифры десятичной системы счисления. В противном случае метод возвращает False .
str.isalpha() – возвращает True , если строка str не пустая и состоит только из алфавитных символов Юникода . В противном случае метод возвращает False .
str.isdecimal() – возвращает True , если строка str не пустая и содержит только символы Юникода , обозначающие цифры десятичной системы счисления. В противном случае метод возвращает False .
str.isnumeric() – возвращает True , если строка str не пустая и состоит только из символов Юникода , которые используются для обозначения цифр (не только десятичной системы счисления). В противном случае метод возвращает False .
str.isalnum() – возвращает True , если строка str не пустая и состоит только из алфавитных символов и символов Юникода , которые используются для обозначения цифр (не только десятичной системы счисления). В противном случае метод возвращает False .
str.isprintable() – возвращает True , если строка str пустая или содержит только печатаемые символы, включая пробел, но не символ перевода строки. В противном случае метод возвращает False .
str.istitle() – возвращает True , если строка str не пустая и при этом имеет формат строки заголовка. В противном случае метод возвращает False .
str.islower() – возвращает True , если строка str имеет хотя бы один символ, который может быть представлен в нижнем регистре, и все такие символы находятся в нижнем регистре. В противном случае метод возвращает False .
str.isupper() – возвращает True , если строка str имеет хотя бы один символ, который может быть представлен в верхнем регистре, и все такие символы находятся в верхнем регистре. В противном случае метод возвращает False .
str.encode(encoding=’utf-8′, errors=’strict’) – возвращает новую строку типа bytes в кодировке utf-8 (по умолчанию) или в кодировке, определяемой аргументом encoding . Параметр errors определяет порядок обработки ошибок в процессе кодировки (см. подраздел «Error Handlers» в разделе «Binary Data Services» стандартной библиотеки).

Пример №17. Методы строк (часть 6).

len(str) – встроенная функция, которая применительно к строкам возвращает длину строки, т.е. количество символов в ней (см. пример №18 ).
ord(c) – встроенная функция, которая возвращает порядковый номер символа Юникода переданного в качестве аргумента c .
chr(i) – встроенная функция, которая возвращает символ Юникода , номер которого равен значению аргумента i .

Как видим, для строк в Python предусмотрен действительно широкий арсенал методов. При чем некоторые из них мы здесь даже не упоминали. Однако это всего лишь пару методов, которые с легкостью можно найти в стандартной библиотеке в подразделе Text Sequence Type — str раздела «Built-in types» .

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

В определении заголовка функции передаваемые аргументы перечисляются через запятую. При этом разрешается присваивать аргументам значения, которые будут использоваться, как значения по умолчанию, если при вызове функции будет передано меньшее количество аргументов. Тело функции представляет собой обычный программный код, который будет выполняться каждый раз при вызове функции. Вызов функции осуществляется при помощи имени функции и круглых скобок с передаваемыми функции значениями аргументов, которые также должны перечисляться через запятую (см. пример №19 ). Если аргументы передаются без имен, их называют , т.к. интерпретатор сопоставляет их с порядком следования в заголовке определения функции. Кроме того, имеется возможность передавать функциям аргументы, явно указывая их имена и значения. Такие аргументы называются и могут передаваться функции в любом порядке, но только после позиционных аргументов, если такие присутствуют в вызове функции. Необязательная инструкция return возвращает результат вызывающей программе в месте вызова функции.

Пример №19. Создание пользовательской функции.

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

Метод форматирования строк

В процессе написания программ довольно часто возникают ситуации, когда в строку требуется вставить значения, динамически появляющиеся в процессе выполнения программы, например, получаемые в результате пользовательского ввода, чтения данных из файла или вычисления математического выражения. В Python для таких случаев предусмотрен специальный метод str.format() , называемый строк, который принимает произвольное количество позиционных или именованных аргументов и выполняет их подстановку в соответствующих местах (полях) строки str , относительно которой он был вызван (см. пример №20 ).

Пример №20. Метод форматирования строк (часть 1).

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

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

Пример №21. Метод форматирования строк (часть 2).

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

Далее, помимо подстановки в строку значений аргументов имеется возможность их предварительного форматирования в соответствии с формальным синтаксисом выражения
<[field_name][!conversion_flag][:format_spec]>, где

field_name – необязательный порядковый номер или имя именованного аргумента, за которым может следовать необязательный неотрицательный индекс элемента последовательности в виде [index] , необязательное имя ключа словаря в виде [key_name] (кавычки для строковых ключей нужно опускать) или необязательное имя атрибута объекта в виде [ . attribute_name] (еще раз посмотрите пример №21 ).
conversion_flag – необязательный флаг конвертации, указывающийся после восклицательного знака и позволяющий указать, какую из встроенных функций нужно применить к значению в форматированной строке: s – удобное для человеческого восприятия представление через str() (используется по умолчанию), r – внутреннее представление через repr() или a – форма внутреннего представления через ascii() , когда вместо символов не входящих в набор ASCII выводятся соответствующие экранированные последовательности для символов Юникода (см. пример №22 ).
format_spec – необязательная спецификация формата, которая указывается после двоеточия (см. синтаксис ниже).

Пример №22. Метод форматирования строк (часть 3).

Итак, спецификация format_spec указывается после двоеточия и в общем виде имеет вид:
[[fill] align] [sign] [#] [0] [width] [grouping_option] [.precision] [type] , где

fill – символ, выступающий в роли заполнителя, который не может быть символом < или >(по умолчанию используется пробел);

align – задает выравнивание вставляемого значения:

< – выравнивание будет выполняться по левому краю, соответственно символы заполнителя будут размещаться по правому краю (используется по умолчанию для всех объектов, кроме чисел);
> – выравнивание будет выполняться по правому краю, соответственно символы заполнителя будут размещаться по левому краю (для чисел это значение используется по умолчанию);
= – применяется только к числовым значениям, добавляя указанное количество символов заполнителя слева от числа, но после знака числа;
^ – выравнивание будет выполняться по центру, соответственно символы заполнителя будут размещаться слева и справа от значения (см. пример №23 );

Пример №23. Метод форматирования строк (часть 4).

sign – применяется только для чисел, и может принимать следующие значения:

знак минуса (-) – отрицательные числа будут отображаться со знаком — , положительные – вообще без знака (используется по умолчанию);
знак плюса (+) – положительные числа будут отображаться со знаком + , отрицательные – со знаком — ;
символ пробела ( ) – для положительных чисел вместо знака + будет отображаться пробел, а для отрицательных – знак — (см. пример №24 );

Пример №24. Метод форматирования строк (часть 5).

символ # – используется только для чисел:

целые числа – задает префикс в нужной системе счисления: #b – число будет выведено в двоичной СС; #o – число будет выведено в восьмеричной СС; #x – число будет выведено в шестнадцатеричной СС;
вещественные числа – гарантирует наличие десятичной точки (нужно просто указать решетку без всяких дополнительных символов), при этом, если type установлен в g или G , то конечные нули сохраняются;
комплексные числа – также гарантирует наличие десятичной точки как у действительной, так и у мнимой части числа, при этом, если type установлен в g или G , то конечные нули сохраняются (см. пример №25 );

Пример №25. Метод форматирования строк (часть 6).

символ 0 – используется только для чисел, и указывает на необходимость заполнения чисел нулями до ширины, задаваемой параметром width ;
width – задает минимальную ширину поля для подставляемого значения;

grouping_option – задает разделитель разрядов тысяч:

запятая (,) – задает разделение посредством запятой; при этом для получения разделителей, используемых в конкретных локалях, лучше опускать этот параметр, используя для параметра type значение n ;
символ нижнего подчеркивания (_) – задает разделение посредством нижнего подчеркивания в числах с плавающей запятой и целых числах с кодом d ; при этом для целых чисел с кодом b , o , x или X разделители будут вставлены через каждые 4 цифры, а для чисел с другими кодами будет вызвано исключение (см. пример №26 );

Пример №26. Метод форматирования строк (часть 7).

precision – управляет точностью вещественных чисел или задает максимальную ширину поля для строк, точнее:

для строк – задает максимальную ширину поля для подставляемого значения;
для целых чисел – не используется вообще;
для вещественных чисел – если type установлен в g или G , то параметр задает общее количество отображаемых цифр числа; если type установлен в f или F , то параметр задает количество отображаемых цифр числа после десятичной точки (см. пример №27 );

Пример №27. Метод форматирования строк (часть 8).

type – задает тип подставляемых данных и способ их отображения при помощи следующих кодовых символов:

s – строковый формат (используется по умолчанию);
d – используется по умолчанию для целых чисел и перед выводом преобразует их в десятичную систему счисления;
b – преобразует целые числа в двоичную систему счисления;
c – преобразует целые числа в соответствующие символы Юникода в 16 -ом представлении: число сначала переводится в 16 -ю систему счисления, после чего формируется соответствующая экранированная последовательность Юникода вида \uhhhh , которая и представляет целевой символ;
o – преобразует целые числа в восьмеричную систему счисления;
x – преобразует целые числа в шестнадцатеричную систему счисления, используя строчные буквы из последовательности abcdef для обозначения цифр превыщающих 9 ;
X – преобразует целые числа в шестнадцатеричную систему счисления, используя заглавные буквы из последовательности ABCDEF для обозначения цифр превыщающих 9 ;
e – преобразует вещественные числа в экспоненциальную форму, в которой показатель степени обозначается строчной буквой e , а точность равна 6 знакам после запятой; спецификатор работает и с целыми числами, предварительно преобразуя их в вещественный тип;
E – перед выводом преобразует вещественные числа в экспоненциальную форму, в которой показатель степени обозначается заглавной буквой E , а точность равна 6 знакам после запятой; спецификатор работает и с целыми числами, предварительно преобразуя их в вещественный тип;
f – перед выводом преобразует вещественные числа в стандартную форму с точностью до 6 знаков после запятой;
F – аналогичен f , однако для обозначения inf и nan используется верхний регистр символов;
g – для вывода используется общий формат, т.е. для небольших чисел параметр действует как f , а для очень больших – как символ e ;
G – для вывода используется общий формат, т.е. для небольших чисел параметр действует как F , а для очень больших – как символ E ;
n – для целых чисел параметр аналогичен значению d , а для вещественных – аналогичен значению g ; в обоих случаях параметр учитывает региональные настройки, используя характерный для текущего региона символ-разделитель целой и дробной части числа и разделитель разрядов; по умолчанию в качестве разделителя целой и дробной части числа используется точка, а в качестве разделителя разрядов – пустая строка;
% – число умножается на 100 с последующим переключением на код f и отображением знака процента в конце (см. пример №28 ).

Пример №28. Метод форматирования строк (часть 9).

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

Пример №29. Метод форматирования строк (часть 10).

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

Краткие итоги параграфа

Строки используются в Python для хранения и представления текстовой информации и представляют собой неизменяемые упорядоченные последовательности символов Юникода . По умолчанию в скриптах используется кодировка UTF-8 .
Чтобы создать литерал строки, достаточно заключить требуемую последовательность символов в одинарные (например, ‘строка’ ), двойные (например, «строка» ) или тройные кавычки (например, »’строка»’ или «»»строка»»» ). При этом допускается использование кавычек одного типа внутри строковых литералов, заключенных в кавычки другого типа (например, ‘_ «F» _’ ), либо внутри строковых литералов, заключенных в кавычки того же типа, предварительно экранировав их при помощи обратного слеша \ (например, ‘_ \’F\’ _’ ).
Если строковый литерал получается довольно длинным, возникает необходимость в его переносе на другую строку программного кода. Сделать это можно несколькими способами: использовать обратный слеш ( \ ) в требуемом месте переноса строки; использовать строки в тройных кавычках, которые как раз и предназначены для оформления больших блоков текста внутри исходного кода; разбить строку на несколько частей и затем объединить их при помощи символа плюса ( + ), при этом не забыв использовать круглые скобки.
Если символ отсутствует на клавиатуре, отобразить его внутри строкового литерала исходного кода программы можно при помощи соответсвующей экранированной (управляющей) последовательности. Например, для отображения символа греческого алфавита Ω можно использовать управляющую последовательность \u03A9 .
Несмотря на то, что строки в Python представляют собой неизменяемые упорядоченные последовательности символов Юникода , доступ к ее отдельным символам можно получить при помощи операции индексирования. Для этого нужно указать в квадратных скобках после имени или литерала строки порядковый номер символа в последовательности, не забывая, что нумерация символов в строке начинается с нуля. Более того, доступ к символам строки возможен также и по отрицательным индексам. В этом случае можно считать, что отсчет ведется с конца строки и начинается с -1 . Например, операция ‘12345’[3] вернет нам символ ‘4’ , а ‘12345’[-3] вернет нам символ ‘3’ .
Также для строк (как и других упорядоченных последовательностей) доступна операция извлечения среза, которая без особых усилий позволяет извлекать не только отдельные символы, но и целые диапазоны символов, не прибегая при этом к специальным методам или встроенным функциям. Например, операция среза ‘0123456789’[1:7:2] вернет нам новую строку ‘135’ , в которой будет присутствовать каждый второй символ из диапазона индексов от 1 до 7 , но не включая сам конечный предел 7 .
Что касается знакомых нам арифметических операторов, то + используется для объединения строк в одну (например, операция конкатенации ‘по’ + ‘езд’ вернет строку ‘поезд’ ), а комбинированный оператор += добавляет целевую строку в конец текущей (например, инструкции s = ‘по’ и s += ‘езд’ сохранят в переменной строку ‘поезд’ ). Оператор умножения * и соответсвующий ему комбинированный оператор *= служат для получения копии строки, состоящей из повторений исходной строки указанное число раз (например, операция ‘-‘*5 вернет строку ‘——‘ ).
Дополнительно мы познакомились с оператором отрицания not и оператором проверки на вхождение in , который применительно к строкам совершает поиск требуемой подстроки (левый операнд) в целевой строке (правый операнд). В случае успеха операция с участием in возвращает True , иначе – False . Например, ‘gi’ in ‘georgian’ вернет нам True . В тоже время, если использовать оператор in в паре с оператором отрицания not , то на выходе операции ‘gi’ not in ‘georgian’ мы получим False .
Далее мы познакомились с рядом методов типа str , которые позволяют выполнять широкий спектр операций над строками. Для их использования не нужно импортировать никаких модулей, т.к. они уже встроены в сам интерпретатор. Для вызова метода нужно просто использовать синтаксис точки для доступа к атрибутам объекта. Например, чтобы получить копию строки, в которой все символы будут в верхнем регистре, можно использовать инструкцию s = ‘abcdef’.upper() . Методов очень много, поэтому необязательно запоминать их все. Наиболее простые и часто использующиеся запомнятся автоматически, а остальные всегда можно найти в стандартной библиотеке в разделе «Built-in types» ⇨ «Text Sequence Type – str» .
Отдельно был рассмотрен метод форматирования строк, который позволяет подставлять значения различных типов непосредственно в указанные места (поля) строки, обозначаемые фигурными скобками. Опять же, на выходе мы получаем измененную копию строки, а не саму строку. Метод обладает довольно внушительным набором функциональных возможностей для довольно точного форматирования строк.
Также мы первично познакомились с циклом for для обхода элементов требуемой последовательности и инструкцией объявления функции def , позволяющей нам создавать свои собственные функции.

Вопросы и задания для самоконтроля

1. Как мы узнали, в Python строки представляют из себя упорядоченные последовательности символов Юникода . Можно ли поменять местами два соседних символа строки, удалить символ из строки? Почему? Показать решение.

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

2. Какие из представленых литералов относятся к типу str : [‘зимний’, ‘летний’] , ‘3.4’ , 5.0 , «Питон» ? Проверьте типы программно. Показать решение.

Строки¶

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

Литералы строк¶

Работа со строками в Python очень удобна. Существует несколько литералов строк, которые мы сейчас и рассмотрим.

Строки в апострофах и в кавычках¶

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

Служебные символы¶

Экранированные последовательности позволяют вставить символы, которые сложно ввести с клавиатуры.

Экранированная последовательность	Назначение
\n	Перевод строки
\a	Звонок
\b	Забой
\f	Перевод страницы
\r	Возврат каретки
\t	Горизонтальная табуляция
\v	Вертикальная табуляция
\N	Идентификатор ID базы данных Юникода
\uhhhh	16-битовый символ Юникода в 16-ричном представлении
\Uhhhh…	32-битовый символ Юникода в 32-ричном представлении
\xhh	16-ричное значение символа
\ooo	8-ричное значение символа
\0	Символ Null (не является признаком конца строки)

«Сырые» строки¶

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

Но, несмотря на назначение, «сырая» строка не может заканчиваться символом обратного слэша. Пути решения:

Строки в тройных апострофах или кавычках¶

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

Функции и методы строк¶

Конкатенация (сложение)¶

Дублирование строки¶

Длина строки (функция len)¶

Доступ по индексу¶

Как видно из примера, в Python возможен и доступ по отрицательному индексу, при этом отсчет идет от конца строки.

Извлечение среза¶

Оператор извлечения среза: [X:Y] . X – начало среза, а Y – окончание;

символ с номером Y в срез не входит. По умолчанию первый индекс равен 0 , а второй — длине строки.

Кроме того, можно задать шаг, с которым нужно извлекать срез.

Другие функции и методы строк¶

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

Поэтому все строковые методы возвращают новую строку, которую потом следует присвоить переменной.

Функция или метод	Назначение
S = ‘str’; S = «str»; S = »’str»’; S = «»»str»»»	Литералы строк
S = «s\np\ta\nbbb»	Экранированные последовательности
S = r»C:\temp\new»	Неформатированные строки (подавляют экранирование)
S = b»byte»	Строка байтов
S1 + S2	Конкатенация (сложение строк)
S1 * 3	Повторение строки
S[i]	Обращение по индексу
S[i:j:step]	Извлечение среза
len(S)	Длина строки
S.find(str, [start],[end])	Поиск подстроки в строке. Возвращает номер первого вхождения или -1
S.rfind(str, [start],[end])	Поиск подстроки в строке. Возвращает номер последнего вхождения или -1
S.index(str, [start],[end])	Поиск подстроки в строке. Возвращает номер первого вхождения или вызывает ValueError
S.rindex(str, [start],[end])	Поиск подстроки в строке. Возвращает номер последнего вхождения или вызывает ValueError
S.replace(шаблон, замена[, maxcount])	Замена шаблона на замену. maxcount ограничивает количество замен
S.split(символ)	Разбиение строки по разделителю
S.isdigit()	Состоит ли строка из цифр
S.isalpha()	Состоит ли строка из букв
S.isalnum()	Состоит ли строка из цифр или букв
S.islower()	Состоит ли строка из символов в нижнем регистре
S.isupper()	Состоит ли строка из символов в верхнем регистре
S.isspace()	Состоит ли строка из неотображаемых символов (пробел, символ перевода страницы ( \f ), «новая строка» ( \n ), «перевод каретки» ( \r ), «горизонтальная табуляция» ( \t ) и «вертикальная табуляция» ( \v ))
S.istitle()	Начинаются ли слова в строке с заглавной буквы
S.upper()	Преобразование строки к верхнему регистру
S.lower()	Преобразование строки к нижнему регистру
S.startswith(str)	Начинается ли строка S с шаблона str
S.endswith(str)	Заканчивается ли строка S шаблоном str
S.join(список)	Сборка строки из списка с разделителем S
ord(символ)	Символ в его код ASCII
chr(число)	Код ASCII в символ
S.capitalize()	Переводит первый символ строки в верхний регистр, а все остальные в нижний
S.center(width, [fill])	Возвращает отцентрованную строку, по краям которой стоит символ fill (пробел по умолчанию)
S.count(str, [start],[end])	Возвращает количество непересекающихся вхождений подстроки в диапазоне [начало, конец] ( 0 и длина строки по умолчанию)
S.expandtabs([tabsize])	Возвращает копию строки, в которой все символы табуляции заменяются одним или несколькими пробелами, в зависимости от текущего столбца. Если TabSize не указан, размер табуляции полагается равным 8 пробелам
S.lstrip([chars])	Удаление пробельных символов в начале строки
S.rstrip([chars])	Удаление пробельных символов в конце строки
S.strip([chars])	Удаление пробельных символов в начале и в конце строки
S.partition(шаблон)	Возвращает кортеж, содержащий часть перед первым шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий саму строку, а затем две пустых строки
S.rpartition(sep)	Возвращает кортеж, содержащий часть перед последним шаблоном, сам шаблон, и часть после шаблона. Если шаблон не найден, возвращается кортеж, содержащий две пустых строки, а затем саму строку
S.swapcase()	Переводит символы нижнего регистра в верхний, а верхнего – в нижний
S.title()	Первую букву каждого слова переводит в верхний регистр, а все остальные в нижний
S.zfill(width)	Делает длину строки не меньшей width , по необходимости заполняя первые символы нулями
S.ljust(width, fillchar=» «)	Делает длину строки не меньшей width , по необходимости заполняя последние символы символом fillchar
S.rjust(width, fillchar=» «)	Делает длину строки не меньшей width , по необходимости заполняя первые символы символом fillchar
S.format(args, *kwargs)	Форматирование строки

Форматирование строк¶

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

Если для подстановки требуется только один аргумент, то значение — сам аргумент:

А если несколько, то значениями будут являться все аргументы со строками подстановки (обычных или именованных):

Однако метод format умеет большее. Вот его синтаксис:

Теперь спецификация формата:

Выравнивание производится при помощи символа-заполнителя. Доступны следующие варианты выравнивания:

Флаг	Значение
<	Символы-заполнители будут справа (выравнивание объекта по левому краю) (по умолчанию).
>	выравнивание объекта по правому краю.
=	Заполнитель будет после знака, но перед цифрами. Работает только с числовыми типами.
^	Выравнивание по центру.

Опция «знак» используется только для чисел и может принимать следующие значения: