Управляющие символы Python

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

Что такое управляющий символ?

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

msg = "Line one\nLine two"
print(msg)
# Line one
# Line two

Без \n строка выглядела бы как "Line one\nLine two", выводимая в одну строку; с ним парсер подставляет настоящий символ новой строки (кодовая точка Unicode U+000A) до сохранения строки.

Термин escape происходит от идеи, что обратный слэш позволяет определённым символам «вырваться» из их обычного значения — например, кавычке внутри строки, ограниченной такой же кавычкой.

Таблица управляющих последовательностей

Python распознаёт следующие управляющие последовательности внутри строковых литералов как в одинарных, так и в двойных кавычках (включая строки с тройными кавычками):

Регистр имеет значение. \n (перевод строки) полностью отличается от \N{name} (именованный Unicode). \u и \U тоже различаются. Всегда используйте точный регистр, указанный выше.

Часто используемые управляющие последовательности

Перевод строки (\n) и табуляция (\t)

Это две наиболее часто используемые управляющие последовательности:

# \n inserts a line break
poem = "Roses are red,\nViolets are blue."
print(poem)
# Roses are red,
# Violets are blue.

# \t inserts a horizontal tab (usually 8 spaces wide in a terminal)
header = "Name\tAge\tCity"
row    = "Alice\t30\tBerlin"
print(header)
print(row)
# Name    Age     City
# Alice   30      Berlin

Встраивание кавычек внутрь строк

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

# Strategy 1 — different outer quote
msg1 = 'She said "hello"'
msg2 = "it's fine"

# Strategy 2 — escape the quote
msg3 = "She said \"hello\""
msg4 = 'it\'s fine'

print(msg1)  # She said "hello"
print(msg4)  # it's fine

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

Обратный слэш (\\)

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

Возврат каретки (\r) и возврат на шаг (\b)

\r перемещает курсор в начало текущей строки. Символы, выводимые после него, перезаписывают уже существующие. \b перемещает курсор на одну позицию влево.

# \r — carriage return
s = "ABCDE\rXY"
print(s)     # XYcde  (XY overwrites the first two characters)
print(repr(s))  # 'ABCDE\rXY'

# \b — backspace (moves cursor back one position)
s2 = "abc\bd"
print(repr(s2))  # 'abc\x08d'
# terminal may render as: abd  (b erased, d written in its place)

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

Числовые и Unicode-экранирования

Шестнадцатеричное (\xhh)

\x за которым следуют ровно две шестнадцатеричные цифры, вставляет символ с этой кодовой точкой. Работает как в байтовых строках, так и в строках Unicode:

# \x41 = 65 decimal = 'A'
print("\x41\x42\x43")  # ABC

# Useful for non-printable control codes
nul = "\x00"
print(len(nul))    # 1
print(repr(nul))   # '\x00'

Восьмеричное (\ooo)

\ за которым следуют от одной до трёх восьмеричных цифр (0–7), вставляет символ с этой восьмеричной кодовой точкой:

print("\101\102\103")  # ABC  (101 octal = 65 decimal = 'A')

Восьмеричные экранирования унаследованы из C и редко нужны в современном Python. Предпочитайте \x или \u для лучшей читаемости.

Unicode (\uxxxx и \Uxxxxxxxx)

\u принимает ровно четыре шестнадцатеричные цифры; \U принимает ровно восемь. Оба вставляют соответствующий символ Unicode:

print("é")          # é  (Latin small letter e with acute)
print("π")          # π  (Greek small letter pi)
print("\U0001F600")      # 😀  (grinning face emoji)

Именованный Unicode (\N{name})

Вы также можете обращаться к символу Unicode по его официальному имени. Это наиболее читаемая форма для редких символов:

print("\N{SNOWFLAKE}")                      # ❄
print("\N{LATIN SMALL LETTER E WITH ACUTE}") # é
print("\N{BLACK HEART SUIT}")               # ♥

Имена нечувствительны к регистру и берутся из базы данных символов Unicode.

Сырые строки

Сырая строка — это строковый литерал с префиксом r (или R). Внутри сырой строки обратные слэши трактуются как буквальные обратные слэши — никакие управляющие последовательности не обрабатываются.

# Regular string — backslash starts an escape sequence
normal = "C:\new_folder\table.csv"
print(normal)
# C:
# ew_folder	able.csv   ← \n and \t were interpreted!

# Raw string — backslashes are literal
raw = r"C:\new_folder\table.csv"
print(raw)
# C:\new_folder\table.csv

Сырые строки незаменимы при работе с путями Windows и регулярными выражениями, где обратные слэши встречаются часто:

import re

# Without raw string — need to double every backslash
pattern1 = re.compile("\\d+\\.\\d+")

# With raw string — much more readable
pattern2 = re.compile(r"\d+\.\d+")

print(pattern2.findall("pi is 3.14159"))  # ['3.14159']

Ограничение сырых строк

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

# SyntaxError: EOL while scanning string literal
# path = r"C:\folder\"    ← the \" at the end escapes the quote

# Workaround — concatenate a regular string
path = r"C:\folder" + "\\"
print(path)  # C:\folder\

Распространённые ошибки

Нераспознанные управляющие последовательности

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

• Python 3.6–3.11: DeprecationWarning (по умолчанию подавляется; видно с -W all)
• Python 3.12+: SyntaxWarning (отображается по умолчанию)
• В будущей версии это станет SyntaxError

# \d is not a valid Python escape sequence
# python3 -W all script.py  => DeprecationWarning: invalid escape sequence '\d'
s = "\d+"
print(repr(s))     # '\\d+'  — backslash is kept literally for now

# Always use a raw string for regex patterns
import re
print(re.findall(r"\d+", "abc 123"))  # ['123']

Управляющие последовательности в байтовых строках

\u, \U и \N{name} не допускаются внутри байтовых литералов (b"..."). В байтовых строках работают только \x, \ooo, \\, \', \", \n, \t, \r, \b, \f, \a, \v и \0:

b = b"\x41\x42"   # valid — b'AB'
print(b)

# b"é"       # SyntaxError — \u not allowed in bytes

Строки с тройными кавычками по-прежнему обрабатывают экранирования

Строка с тройными кавычками ("""...""" или '''...''') занимает несколько строк и по-прежнему обрабатывает управляющие последовательности. Используйте сырую строку с тройными кавычками, если нужны буквальные обратные слэши:

sql = """
SELECT *
FROM users
WHERE name LIKE '%O\'Brien%'
"""
print(sql)

regex_pattern = r"""
(?x)            # verbose mode
\d{4}           # year
-\d{2}          # month
-\d{2}          # day
"""

Просмотр строк с помощью repr()

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

s = "line1\nline2\ttabbed"
print(s)         # prints with actual newline and tab
print(repr(s))   # 'line1\nline2\ttabbed'

Используйте repr(), когда строка «выглядит правильно» на экране, но ведёт себя неожиданно — скрытые символы вроде \r, \x00 или невидимые пробелы Unicode становятся сразу видны.

Связанные темы

• Строки Python — строковые литералы, стили кавычек и основы строкового типа
• Срезы строк — как извлечь подстроку по индексу
• Изменение строк — встроенные методы строк для преобразования текста
• Конкатенация строк — объединение строк с помощью + и join()
• Форматирование строк — основы %, .format() и f-строк
• F-строки Python — современные форматированные строковые литералы

Практика