Юникод: ord, chr и кодировки

Компьютер не хранит буквы — он хранит числа. Строка «Привет» для Python — последовательность кодов Юникода: 1052, 1088, 1080… Функции ord (код символа) и chr (символ по коду) открывают этот внутренний мир, а понимание кодировок объясняет самую загадочную ошибку новичков — текст из кракозябр.

ord и chr: символ как число

ord(символ) — код одного символа в таблице Юникода, chr(код) — обратное превращение. Латинские буквы и цифры сидят в таблице компактно и по порядку: коды A-Z идут подряд — этим пользуются для простых преобразований.

print(ord('А'), ord('Я'))
print(chr(1050), chr(1054))

print(chr(ord('a') + 1))

1040 1071
К О
b

Русские буквы тоже живут в Юникоде своими кодами: А — 1040. Последняя строка — классический трюк: код буквы «a» плюс один — «b». Арифметика кодов часто экономит целую таблицу замен.

encode и decode: строка и байты

Строка в Python — абстракция из символов. Для записи в файл или сеть её превращают в байты методом encode('utf-8'), а байты обратно в строку — decode('utf-8'). Русская буква в utf-8 занимает два байта, латинская — один; поэтому байты и символы — разные вещи, и путать их нельзя.

word = 'мир'
encoded = word.encode('utf-8')
print(encoded)
print(len(word), len(encoded))

print(encoded.decode('utf-8'))

b'\xd0\xbc\xd0\xb8\xd1\x80'
3 6
мир

Байтовая строка печатается с префиксом b и кодами вида \xd0 — это те же три символа «мир», но в шести байтах utf-8: каждая русская буква заняла два байта. Обратный decode вернул исходный текст без потерь.

Кракозябры: что это и почему

Кракозябры — это байты одной кодировки, прочитанные как другая. Файл сохранили в cp1251 (старая русская кодировка Windows), а открыли как utf-8 — Python честно показал то, что увидел: «Ïðèâåò» вместо «Привет». Данные не испорчены — испорчена интерпретация; правильная кодировка возвращает текст.

text = 'Привет'
wrong = text.encode('cp1251').decode('latin-1')
print(wrong)

fixed = wrong.encode('latin-1').decode('cp1251')
print(fixed)

Ïðèâåò
Привет

Главный вывод курса по кодировкам: строки в Python всегда юникодные и всегда правильные; проблемы живут на границах — в файлах и сети. Указывайте кодировку явно при open, и кракозябры обойдут вас стороной.

Сколько байт в символе: utf-8

Юникод — это таблица символов, а не формат хранения. Строка из символов превращается в байты по правилам кодировки, и в utf-8 (стандарт Python 3) размер зависит от символа: ASCII занимает один байт, кириллица и латиница с диакритикой — два, а символы вне базовой плоскости — четыре.

for ch in 'aбЯ1':
    print(repr(ch), ord(ch), len(ch.encode('utf-8')))

'a' 97 1
'б' 1073 2
'Я' 1071 2
'1' 49 1

Вот главное различие, которое ломает расчёты: длина строки и число байт — разные вещи. len('привет') вернёт 6 символов, а в файле utf-8 этот текст займёт 12 байт. Для кириллицы всегда удваивайте, для латиницы — нет.

print(len('привет'), len('привет'.encode('utf-8')))
print(len('hello'), len('hello'.encode('utf-8')))

6 12
5 5

Это различие объясняет, почему файл с русским текстом «весит больше, чем кажется», и почему лимит загрузки считают в байтах, а не в символах. Оно же — источник классической ошибки: код, который режет файл по байтам, а потом ищет в нём символы, может разрезать кириллицу пополам и получить «сломанный» текст в виде символа-замены.

Кодировки в реальном файле

Теория становится понятной, когда встречаешь файл, который читается не так. Классический случай: выгрузка из 1С или старого учётного сервера в cp1251, которую открывают в Python как utf-8. Текст вроде бы русский, но вместо букв — «кракозябры», и никакого исключения: кодировка «проходит», просто неправильно.

raw = 'Привет'.encode('cp1251')
print(raw)
print(raw.decode('latin-1'))
print(raw.decode('cp1251'))

b'\xcf\xf0\xe8\xe2\xe5\xf2'
Ïðèâåò
Привет

Второй вывод — те самые «кракозябры»: байты cp1251, прочитанные как latin-1, где каждый байт — отдельный символ. Третий — то, что должно было получиться: та же строка, прочитанная своей кодировкой. Данные не испорчены, испорчено было только понимание, в какой кодировке они записаны.

raw = 'Привет'.encode('cp1251')
try:
    print(raw.decode('utf-8'))
except UnicodeDecodeError as e:
    print('ошибка декодирования:', e.reason)

ошибка декодирования: invalid continuation byte

Параметр errors='replace' подставляет «?» вместо символов, которые не удалось декодировать, и программа работает дальше — но часть текста потеряна навсегда. Для чтения файлов replace лучше, чем падение, но молчаливая потеря данных хуже явной ошибки: лучше узнать о проблеме с кодировкой сразу, чем полгода искать пропавшие символы в отчёте.

Практический порядок работы с файлом всегда одинаков: открыть с явной кодировкой, прочитать, и только потом решать, что делать с сомнительными символами. Если кодировка неизвестна и файл небольшой — можно перебрать варианты и выбрать тот, где нет «кракозябр»; для больших файлов выручает charset_normalizer.

И отдельно про JSON и HTTP — два места, где кодировка задаётся протоколом, а не вами. JSON по спецификации всегда UTF-8, и json.loads разберётся сам. В HTTP ответ почти всегда приходит в UTF-8, но сервер может объявить другую кодировку в заголовке Content-Type — и тогда response.text возьмёт объявленную, а response.content.decode('utf-8') — принудительно UTF-8. Разница видна на страницах с windows-1251, и это отдельная история из курса про requests.

Отдельная боль — символы вне базовой плоскости: эмодзи, некоторые иероглифы. Они занимают четыре байта в utf-8, и Python 3.3+ хранит их в строке как один символ. Поэтому len для строки с эмодзи считает символы, а не байты, — и при срезе по байтам такой символ может разрезаться.

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

Кодировки и escape-последовательности — две стороны одной медали: и то, и другое решает, как символ попадёт в строку и как он оттуда выйдет. Про экранирование подробно в уроке 13, а как строки превращаются в байты при отправке по сети — в уроке про requests.