Экранирование python что это

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

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

Экранированные последовательности — это последовательности, которые начинаются с символа » \ » за которым следует один или более символов.

Давайте сразу приведем пример:

Обратите внимание на то как функция print() осуществила вывод – в тех местах, где были последовательности ‘ \n ‘ она выполнила переносы строк. Вы, конечно же, догадались, что ‘ \n ‘ – это экранированная последовательность. Единственное, что стоит добавить так это то, что такие последовательности воспринимаются интерпретатором как единственный символ, т.е. несмотря на то что последовательность может состоять из нескольких символов ей соответствует всего один-единственный код. Например:

Таблица последовательностей

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

Последовательность	Назначение
\newline	Если после символа » \ » сразу нажать клавишу Enter то это позволит продолжать запись с новой строки.
\\	Позволяет записать символ обратного слеша.
\’	Позволяет записать один символ апострофа.
\»	Позволяет записать один символ кавычки.
\a	Гудок встроенного в систему динамика.
\b	Backspace, он же возврат, он же «пробел назад» – удаляет один символ перед курсором.
\f	Разрыв страницы.
\n	Перенос строки (новая строка).
\r	Возврат курсора в начало строки.
\t	Горизонтальный отступ слева от начала строки (горизонтальная табуляция).
\v	Вертикальный отступ сверху (вертикальная табуляция).
\xhh	Шестнадцатеричный код символа (две шестнадцатеричные цифры hh).
\ooo	Восьмеричный код символа (три восьмеричные цифры ooo).
\0	Символ Null.
\N	ID (идентификатор) символа в базе данных Юникода, или, проще говоря, его название в таблице Юникода.
\uhhhh	Шестнадцатеричный код 16-битного символа Юникода (символ кодируемый двумя байтами).
\Uhhhhhhhh	Шестнадцатеричный код 32-битного символа Юникода (символ кодируемый четырьмя байтами).
\other	Под other понимается любая другая последовательность символов. Не является экранированной последовательностью (остается без изменений с сохранением в строке символа » \ «).

Примеры

\newline — новая строка

Данный символ позволяет записывать очень длинные «короткие» строки (строки в одинарных кавычках или апострофах) в несколько строк. Как это работает? Просто начните вводить строку, в необходимом месте введите символ » \ » а потом сразу нажмите клавишу Enter и продолжайте ввод строки. Например:

Обратите внимание, что в результирующей строке вообще нет символа » \ «. И не забывайте что пробел тоже является символом, а последовательность \newline не является разделителем:

\\ — обратный слеш

Позволяет указывать в строке необходимое количество обратных слешей, что может пригодиться при работе с файловой системой в Windows или работой с LATEX:

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

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

\’ — апостроф

Последовательность \’ позволяет помещать внутрь строки необходимое количество апострофов:

\» — кавычка

Так же как и \’ позволяет помещать в строку необходимое количество кавычек:

\a — гудок динамика

Последовательность \a заставляет систему издать короткий звуковой гудок, который очень часто используется для предупреждения о чем-либо. Однако, услышите вы этот гудок или нет, как-то зависит от компьютера и операционной системы. Например я сейчас работаю на ноуте под Ubuntu и ничего не слышу, но на стационарном компьютере с Windows 7 все исправно работает. Использовать его или нет решайте сами, но в любом случае, этот символ никогда не выводится на экран:

\b — backspace (пробел назад)

Если вы хоть раз нажимали клавишу Backspace на клавиатуре, то вы уже знаете предназначение этой последовательности – удалять один символ перед курсором:

Если \b находится в конце строки, то удаления не происходит:

Однако, в общем случае все зависит от того сколько символов \b следует подряд друг за другом и что следует за ними:

Данная последовательность используется крайне редко. Но если вы все еще не догадались как она работает, то лучше воспринимайте его не как удаление символов, а как перемещение курсора влево. Например, в строке ‘AAAA\b\b\bC’ мы как бы ничего и не удаляли, на самом деле три символа ‘\b\b\b’ переместили курсор на три позиции влево, на на вторую букву ‘A’ и вместо нее напечатали символ ‘C’ .

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

\f — разрыв страницы

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

Данная последовательность переводит курсор на следующую строку и выполняет отступ, длина которого равна длине предшествоваишей \f части строки:

\n — перенос строки

Последовательность \n до банального проста – это просто перенос следующих за ним символов на следующую строку:

\r — возврат каретки

Последовательность \r возвращает курсор в начало строки, т.е. позволяет печатать одни символы «поверх» других. Например:

Данная последовательность позволяет зделать «полосу загрузки» или осуществлять вывод прогресса решения каких-нибудь задач. Но для этого нужно знать, что функция print() обладает параметром end который по умолчанию установлен в значение ‘\n’ , что заставляет заканчивать каждый вывод переводом на новую строку:

Параметр end определяет каким символом должна заканчиваться строка, т.е. мы можем сами задать такой символ (или символы):

Если мы зделаем end = ‘\r’ , то мы сможем печатать строки «поверх» друг друга, но терминал делает это настолько быстро, что мы не успеем ничего заметить. Обычно, загрузка и выполнение каких-то задач сопровождается небольшими задержками, давайте, мы съимитируем такую задержку с помощью функции sleep() модуля time :

\t — горизонтальная табуляция

Так же как и \n последовательность \t крайне проста – она просто делает один отступ (равносильно нажатию клавиши Tab):

\v — вертикальная табуляция

Последовательность \v очень похожа на \f и точно так же родом из тех времен, когда принтером приходилось управлять чуть ли не на прямую. Вот только эта последовательность в отличии от \f , не заставляла его загружать новую страницу, а перемещала его вниз по странице на указанное количество строк.

Но самое любопытное, что от этих раритетов в некоторых областях даже не собираются отказываться — некоторые документы и стандарты до сих пор используют последовательности \v и \f .

\xhh — шестнадцатеричный код символа

Последовательность \xhh позволяет делать запись строк, используя шестнадцатеричный код символов:

\ooo — восьмеричный код символа

Последовательность \ooo позволяет делать запись строк, используя восьмеричный код символов:

\0 — Null

Данная последовательность ведет себя так, словно ее нет. В старые-добрые времена механических принтеров, эта последовательность обозначала простой, т.е. ничего не делать. Сейчас ее можно до сих пор встретить в языке C, в конце символьных строк, причем далее за » \0 » другие цифры следовать не должны, иначе они будут восприниматься как другая экранированная восьмеричная последовательность. Ну а Python этот символ вообще никак не выводит:

Тем не менее этот символ в строке сохраняется и влияет на ее длину.

\N — идентификатор символа Юникода

Позволяет вводить символы в строку используя их название:

\uhhhh — 16-битный символ Юникода

Позволяет вводить символы в строку используя их двухбайтовый шестнадцатеричный код, причем данный способ позволяет вводить только двухбайтовые символы юникода (UTF-16BE):

\Uhhhhhhhh — 32-битный символ Юникода

Позволяет вводить символы в строку используя их четырехбайтовый шестнадцатеричный код, причем данный способ позволяет вводить только четырехбайтовые символы юникода (UTF-32BE):

\other — не экранированная последовательность

Если за символом » \ » следует что-то другое, не перечисленное в данном списке, то это не считается экранированной последовательностью, а обычной строкой в которой на ряду с остальными символами присутствует и символ » \ «:

Но внимательность все же не помешает:

Всегда экранируйте символ » \ » последовательностью » \\ » или используйте литерал неформатированных строк r’aaaa\bbbb’ .

2. Lexical analysis¶

A Python program is read by a parser. Input to the parser is a stream of tokens, generated by the lexical analyzer. This chapter describes how the lexical analyzer breaks a file into tokens.

Python reads program text as Unicode code points; the encoding of a source file can be given by an encoding declaration and defaults to UTF-8, see PEP 3120 for details. If the source file cannot be decoded, a SyntaxError is raised.

2.1. Line structure¶

A Python program is divided into a number of logical lines.

2.1.1. Logical lines¶

The end of a logical line is represented by the token NEWLINE. Statements cannot cross logical line boundaries except where NEWLINE is allowed by the syntax (e.g., between statements in compound statements). A logical line is constructed from one or more physical lines by following the explicit or implicit line joining rules.

2.1.2. Physical lines¶

A physical line is a sequence of characters terminated by an end-of-line sequence. In source files and strings, any of the standard platform line termination sequences can be used — the Unix form using ASCII LF (linefeed), the Windows form using the ASCII sequence CR LF (return followed by linefeed), or the old Macintosh form using the ASCII CR (return) character. All of these forms can be used equally, regardless of platform. The end of input also serves as an implicit terminator for the final physical line.

When embedding Python, source code strings should be passed to Python APIs using the standard C conventions for newline characters (the \n character, representing ASCII LF, is the line terminator).

2.1.3. Comments¶

A comment starts with a hash character ( # ) that is not part of a string literal, and ends at the end of the physical line. A comment signifies the end of the logical line unless the implicit line joining rules are invoked. Comments are ignored by the syntax.

2.1.4. Encoding declarations¶

If a comment in the first or second line of the Python script matches the regular expression coding[=:]\s*([-\w.]+) , this comment is processed as an encoding declaration; the first group of this expression names the encoding of the source code file. The encoding declaration must appear on a line of its own. If it is the second line, the first line must also be a comment-only line. The recommended forms of an encoding expression are

which is recognized also by GNU Emacs, and

which is recognized by Bram Moolenaar’s VIM.

If no encoding declaration is found, the default encoding is UTF-8. In addition, if the first bytes of the file are the UTF-8 byte-order mark ( b’\xef\xbb\xbf’ ), the declared file encoding is UTF-8 (this is supported, among others, by Microsoft’s notepad).

If an encoding is declared, the encoding name must be recognized by Python (see Standard Encodings ). The encoding is used for all lexical analysis, including string literals, comments and identifiers.

2.1.5. Explicit line joining¶

Two or more physical lines may be joined into logical lines using backslash characters ( \ ), as follows: when a physical line ends in a backslash that is not part of a string literal or comment, it is joined with the following forming a single logical line, deleting the backslash and the following end-of-line character. For example:

A line ending in a backslash cannot carry a comment. A backslash does not continue a comment. A backslash does not continue a token except for string literals (i.e., tokens other than string literals cannot be split across physical lines using a backslash). A backslash is illegal elsewhere on a line outside a string literal.

2.1.6. Implicit line joining¶

Expressions in parentheses, square brackets or curly braces can be split over more than one physical line without using backslashes. For example:

Implicitly continued lines can carry comments. The indentation of the continuation lines is not important. Blank continuation lines are allowed. There is no NEWLINE token between implicit continuation lines. Implicitly continued lines can also occur within triple-quoted strings (see below); in that case they cannot carry comments.

2.1.7. Blank lines¶

A logical line that contains only spaces, tabs, formfeeds and possibly a comment, is ignored (i.e., no NEWLINE token is generated). During interactive input of statements, handling of a blank line may differ depending on the implementation of the read-eval-print loop. In the standard interactive interpreter, an entirely blank logical line (i.e. one containing not even whitespace or a comment) terminates a multi-line statement.

2.1.8. Indentation¶

Leading whitespace (spaces and tabs) at the beginning of a logical line is used to compute the indentation level of the line, which in turn is used to determine the grouping of statements.

Tabs are replaced (from left to right) by one to eight spaces such that the total number of characters up to and including the replacement is a multiple of eight (this is intended to be the same rule as used by Unix). The total number of spaces preceding the first non-blank character then determines the line’s indentation. Indentation cannot be split over multiple physical lines using backslashes; the whitespace up to the first backslash determines the indentation.

Indentation is rejected as inconsistent if a source file mixes tabs and spaces in a way that makes the meaning dependent on the worth of a tab in spaces; a TabError is raised in that case.

Cross-platform compatibility note: because of the nature of text editors on non-UNIX platforms, it is unwise to use a mixture of spaces and tabs for the indentation in a single source file. It should also be noted that different platforms may explicitly limit the maximum indentation level.

A formfeed character may be present at the start of the line; it will be ignored for the indentation calculations above. Formfeed characters occurring elsewhere in the leading whitespace have an undefined effect (for instance, they may reset the space count to zero).

The indentation levels of consecutive lines are used to generate INDENT and DEDENT tokens, using a stack, as follows.

Before the first line of the file is read, a single zero is pushed on the stack; this will never be popped off again. The numbers pushed on the stack will always be strictly increasing from bottom to top. At the beginning of each logical line, the line’s indentation level is compared to the top of the stack. If it is equal, nothing happens. If it is larger, it is pushed on the stack, and one INDENT token is generated. If it is smaller, it must be one of the numbers occurring on the stack; all numbers on the stack that are larger are popped off, and for each number popped off a DEDENT token is generated. At the end of the file, a DEDENT token is generated for each number remaining on the stack that is larger than zero.

Here is an example of a correctly (though confusingly) indented piece of Python code:

The following example shows various indentation errors:

(Actually, the first three errors are detected by the parser; only the last error is found by the lexical analyzer — the indentation of return r does not match a level popped off the stack.)

2.1.9. Whitespace between tokens¶

Except at the beginning of a logical line or in string literals, the whitespace characters space, tab and formfeed can be used interchangeably to separate tokens. Whitespace is needed between two tokens only if their concatenation could otherwise be interpreted as a different token (e.g., ab is one token, but a b is two tokens).

2.2. Other tokens¶

Besides NEWLINE, INDENT and DEDENT, the following categories of tokens exist: identifiers, keywords, literals, operators, and delimiters. Whitespace characters (other than line terminators, discussed earlier) are not tokens, but serve to delimit tokens. Where ambiguity exists, a token comprises the longest possible string that forms a legal token, when read from left to right.

2.3. Identifiers and keywords¶

Identifiers (also referred to as names) are described by the following lexical definitions.

The syntax of identifiers in Python is based on the Unicode standard annex UAX-31, with elaboration and changes as defined below; see also PEP 3131 for further details.

Within the ASCII range (U+0001..U+007F), the valid characters for identifiers are the same as in Python 2.x: the uppercase and lowercase letters A through Z , the underscore _ and, except for the first character, the digits 0 through 9 .

Python 3.0 introduces additional characters from outside the ASCII range (see PEP 3131). For these characters, the classification uses the version of the Unicode Character Database as included in the unicodedata module.

Identifiers are unlimited in length. Case is significant.

The Unicode category codes mentioned above stand for:

Lu — uppercase letters

Ll — lowercase letters

Lt — titlecase letters

Lm — modifier letters

Lo — other letters

Nl — letter numbers

Mn — nonspacing marks

Mc — spacing combining marks

Nd — decimal numbers

Pc — connector punctuations

Other_ID_Start — explicit list of characters in PropList.txt to support backwards compatibility

All identifiers are converted into the normal form NFKC while parsing; comparison of identifiers is based on NFKC.

A non-normative HTML file listing all valid identifier characters for Unicode 14.0.0 can be found at https://www.unicode.org/Public/14.0.0/ucd/DerivedCoreProperties.txt

2.3.1. Keywords¶

The following identifiers are used as reserved words, or keywords of the language, and cannot be used as ordinary identifiers. They must be spelled exactly as written here:

2.3.2. Soft Keywords¶

New in version 3.10.

Some identifiers are only reserved under specific contexts. These are known as soft keywords. The identifiers match , case and _ can syntactically act as keywords in contexts related to the pattern matching statement, but this distinction is done at the parser level, not when tokenizing.

As soft keywords, their use with pattern matching is possible while still preserving compatibility with existing code that uses match , case and _ as identifier names.

2.3.3. Reserved classes of identifiers¶

Certain classes of identifiers (besides keywords) have special meanings. These classes are identified by the patterns of leading and trailing underscore characters:

Not imported by from module import * .

In a case pattern within a match statement, _ is a soft keyword that denotes a wildcard .

Separately, the interactive interpreter makes the result of the last evaluation available in the variable _ . (It is stored in the builtins module, alongside built-in functions like print .)

Elsewhere, _ is a regular identifier. It is often used to name “special” items, but it is not special to Python itself.

The name _ is often used in conjunction with internationalization; refer to the documentation for the gettext module for more information on this convention.

It is also commonly used for unused variables.

System-defined names, informally known as “dunder” names. These names are defined by the interpreter and its implementation (including the standard library). Current system names are discussed in the Special method names section and elsewhere. More will likely be defined in future versions of Python. Any use of __*__ names, in any context, that does not follow explicitly documented use, is subject to breakage without warning.

Class-private names. Names in this category, when used within the context of a class definition, are re-written to use a mangled form to help avoid name clashes between “private” attributes of base and derived classes. See section Identifiers (Names) .

2.4. Literals¶

Literals are notations for constant values of some built-in types.

2.4.1. String and Bytes literals¶

String literals are described by the following lexical definitions:

One syntactic restriction not indicated by these productions is that whitespace is not allowed between the stringprefix or bytesprefix and the rest of the literal. The source character set is defined by the encoding declaration; it is UTF-8 if no encoding declaration is given in the source file; see section Encoding declarations .

In plain English: Both types of literals can be enclosed in matching single quotes ( ‘ ) or double quotes ( " ). They can also be enclosed in matching groups of three single or double quotes (these are generally referred to as triple-quoted strings). The backslash ( \ ) character is used to escape characters that otherwise have a special meaning, such as newline, backslash itself, or the quote character.

Bytes literals are always prefixed with ‘b’ or ‘B’ ; they produce an instance of the bytes type instead of the str type. They may only contain ASCII characters; bytes with a numeric value of 128 or greater must be expressed with escapes.

Both string and bytes literals may optionally be prefixed with a letter ‘r’ or ‘R’ ; such strings are called raw strings and treat backslashes as literal characters. As a result, in string literals, ‘\U’ and ‘\u’ escapes in raw strings are not treated specially. Given that Python 2.x’s raw unicode literals behave differently than Python 3.x’s the ‘ur’ syntax is not supported.

New in version 3.3: The ‘rb’ prefix of raw bytes literals has been added as a synonym of ‘br’ .

New in version 3.3: Support for the unicode legacy literal ( u’value’ ) was reintroduced to simplify the maintenance of dual Python 2.x and 3.x codebases. See PEP 414 for more information.

A string literal with ‘f’ or ‘F’ in its prefix is a formatted string literal; see Formatted string literals . The ‘f’ may be combined with ‘r’ , but not with ‘b’ or ‘u’ , therefore raw formatted strings are possible, but formatted bytes literals are not.

In triple-quoted literals, unescaped newlines and quotes are allowed (and are retained), except that three unescaped quotes in a row terminate the literal. (A “quote” is the character used to open the literal, i.e. either ‘ or " .)

Unless an ‘r’ or ‘R’ prefix is present, escape sequences in string and bytes literals are interpreted according to rules similar to those used by Standard C. The recognized escape sequences are:

Python. Строки. Экранированные последовательности. Неформатированные строки. Многострочные блоки текста

Строки. Экранированные последовательности. Неформатированные строки. Многострочные блоки текста

Содержание

• 1. Общая форма представления экранированной последовательности. Символ \ (обратный слеш)
• 2. Примеры вывода строк, содержащих экранированные последовательности
• 3. Таблица экранированных последовательностей
• 4. Определение длины строки, содержащей экранированную последовательность
• 5. Представление символов в шестнадцатеричной и восьмеричной системах исчисления. Пример
• 6. Представление символа обратного слеша \ . Пример
• 7. Отключение механизма экранирования. Пример
• 8. Многострочные блоки текста. Пример

Поиск на других ресурсах:

1. Общая форма представления экранированной последовательности. Символ \ (обратный слеш)

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

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

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

2. Примеры вывода строк, содержащих экранированные последовательности

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

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

3. Таблица экранированных последовательностей

В таблице приведены экранированные последовательности языка Python.

4. Определение длины строки, содержащей экранированную последовательность

В программе экранированная последовательность может состоять из нескольких символов. При выводе на экран эти несколько символов заменяются одним соответствующим символом.

Пример.

В вышеприведенном коде строка

в программе имеет длину 7 символов. Реальная длина строки равна 3 символам. Это объясняется тем, что строка содержит две экранированных последовательности которые заменяются одиночными символами:

• \n – символ новой строки;
• \172 – код символа z в восьмеричной системе исчисления.

Результат выполнения программы

5. Представление символов в шестнадцатеричной и восьмеричной системах исчисления. Пример

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

Пример.

Результат работы программы

6. Представление символа обратного слеша \ . Пример

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

Пример.

7. Отключение механизма экранирования. Пример

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

Например, если в некоторую переменную s нужно записать полное имя файла, который размещается по следующему маршруту

то строка на языке Python

будет содержать невидимую ошибку: переменная s равна значению

Это связано с тем, что последовательность символов \t рассматривается как один символ табуляции (см. таблицу с п. 3).

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

то есть, перед строкой нужно поставить символ r или R .

Пример.

Как видно из примера, в строке s формируется ошибочное полное имя файла, а в строке s2 формируется правильное имя файла благодаря символу R перед ним.

Результат выполнения программы

8. Многострочные блоки текста. Пример

С помощью тройной кавычки «»»…»»» можно формировать многострочные блоки текста.

Урок 4
Работа со строками

Последовательности в Python
Последовательность(Sequence Type) — итерируемый контейнер, к элементам которого есть эффективный доступ с использованием целочисленных индексов.

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

— изменяемая — неизменяемая — неизменяемая
1. Строка (str, unicode) — неизменяемая

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

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

В таблице перечислены самые часто используемые экранированные последовательности:

«Сырые строки»
Если перед открывающей кавычкой стоит символ ‘r’ (в любом регистре), то механизм экранирования отключается.
Это может быть нужно, например, в такой ситуации:
str = r’C:\new_file.txt’

Итак, строки в Python поддерживают две группы методов:

( list ) ( tuple ) ( range ).

1. Обработки двоичных данных( binary data ) и
2. Текстовых строк( str ).

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

1. Оператор сложения строк +
+ — оператор конкатенации строк. Он возвращает строку, состоящую из совокупности других строк.
Например:

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

Срез (slice) — извлечение из данной строки одного символа или некоторого фрагмента подстроки или подпоследовательности.

Индекс — номер символа в строке (а также в других структурах данных: списках, кортежах). Обратите внимание, что нумерация начинается с 0 . Если указать отрицательное значение индекса, то номер будет отсчитываться с конца, начиная с номера -1 .

Есть три формы срезов:
1. Самая простая форма среза — взятие одного символа строки — S[i] , где S — строка, i — индекс. Пример:

Задачи по темам

Функции поиска
Как вы уже могли заметить, в Python существует две похожих функции для поиска подстроки — find() (относится к группе строковых методов) и index() (общий метод для SequenceType данных) . Разница в том, что find() вернет -1 , если не найдет искомое, а index() выкинет исключение ValueError .

Кроме того, необходимо помнить, что если нужно только удостовериться, что подстрока присутствует внутри строки — можно просто воспользоваться методом in :
>>> ‘Py’ in ‘Python’
True

В Python версии 3.6 был представлен новый способ форматирования строк. Эта функция официально названа литералом отформатированной строки, но обычно упоминается как f-string . Способов форматирования в Python довольно много, но работу с f-строками мы считаем самым удобным и перспективным способом, поэтому рассмотрим именно его.

Одной простой особенностью f-строк, которую вы можете начать использовать сразу, является интерполяция переменной. Вы можете указать имя переменной непосредственно в f-строковом литерале ( f’string’ ), и Python заменит имя соответствующим значением.

Например, предположим, что вы хотите отобразить результат арифметического вычисления. Это можно сделать с помощью простого print() и оператора , , разделяющего числовые значения и строковые: