Руководство по Unicode¶Unicode HOWTO

История кодировок символов¶History of Character Codes

В 1968 году был стандартизирован американский стандартный код для обмена информацией, более известный под аббревиатурой ASCII. ASCII определил числовые коды для различных символов, значения которых находятся в диапазоне от 0 до 127. Например, строчной букве «a» присвоено значение кода 97.

ASCII был стандартом, разработанным в США, поэтому он определял только символы без диакритических знаков. Буква 'e' была, а 'é' или 'Í' – нет. Это означало, что языки, требующие диакритических знаков, не могли быть точно представлены в ASCII. (На самом деле отсутствие диакритических знаков имеет значение и для английского, в котором есть такие слова, как 'naïve' и 'café', а некоторые издательства требуют написания вроде 'coöperate'.)

Некоторое время люди просто писали программы, которые не отображали диакритические знаки. Помню, как смотрел на программы на Apple ][ BASIC, опубликованные во франкоязычных изданиях в середине 1980-х, в которых были такие строки:

PRINT "MISE A JOUR TERMINEE"
PRINT "PARAMETRES ENREGISTRES"

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

В 1980-х почти все персональные компьютеры были 8-битными, то есть байты могли хранить значения от 0 до 255. Коды ASCII доходили только до 127, поэтому некоторые машины назначали значения от 128 до 255 символам с диакритическими знаками. Однако разные машины имели разные коды, что приводило к проблемам при обмене файлами. Со временем появились различные широко используемые наборы значений для диапазона 128–255. Некоторые были настоящими стандартами, определёнными Международной организацией по стандартизации, а некоторые были де-факто соглашениями, придуманными той или иной компанией и получившими распространение.

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

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

Изначально Unicode использовал 16-битные символы вместо 8-битных. 16 бит дают 2^16 = 65 536 различных значений, что позволяет представлять множество символов из разных алфавитов; первоначальной целью было включить в Unicode алфавиты всех человеческих языков. Оказалось, что даже 16 бит недостаточно для достижения этой цели, и современная спецификация Unicode использует более широкий диапазон кодов: от 0 до 1 114 111 (0x10ffff в шестнадцатеричной системе).

Существует связанный стандарт ISO – ISO 10646. Unicode и ISO 10646 изначально были разными проектами, но спецификации были объединены в версии Unicode 1.1.

(Это обсуждение истории Unicode сильно упрощено. Не думаю, что среднестатистическому программисту на Python нужно беспокоиться об исторических деталях; обращайтесь к сайту консорциума Unicode, указанному в разделе «Ссылки», за дополнительной информацией.)

Определения¶Definitions

Символ – это наименьший возможный компонент текста. 'A', 'B', 'C' и т.д. – всё это разные символы. Также как 'È' и 'Í'. Символы – это абстракции, и они варьируются в зависимости от языка или контекста. Например, символ ома (Ω) обычно рисуется очень похоже на заглавную букву омега (Ω) в греческом алфавите (в некоторых шрифтах они могут даже совпадать), но это два разных символа с разными значениями.

Стандарт Unicode описывает, как символы представлены с помощью кодовых точек. Кодовая точка – это целое число, обычно записываемое в шестнадцатеричной системе. В стандарте кодовая точка записывается в виде U+12ca и означает символ со значением 0x12ca (4810 в десятичной системе). Стандарт Unicode содержит множество таблиц, перечисляющих символы и соответствующие им кодовые точки:

0061    'a'; LATIN SMALL LETTER A
0062    'b'; LATIN SMALL LETTER B
0063    'c'; LATIN SMALL LETTER C
...
007B    '{'; LEFT CURLY BRACKET

Строго говоря, из этих определений следует, что бессмысленно говорить «это символ U+12ca». U+12ca – это кодовая точка, которая представляет некоторый конкретный символ; в данном случае она представляет символ «ETHIOPIC SYLLABLE WI». В неформальном контексте это различие между кодовыми точками и символами иногда забывается.

Символ отображается на экране или на бумаге с помощью набора графических элементов, который называется глифом. Глиф для заглавной A, например, представляет собой две диагональные и одну горизонтальную черту, хотя точные детали зависят от используемого шрифта. Большинству кода на Python не нужно беспокоиться о глифах; определение правильного глифа для отображения обычно является задачей GUI-инструментария или рендерера шрифтов терминала.

Кодировки¶Encodings

Резюмируя предыдущий раздел: строка Unicode – это последовательность кодовых точек, представляющих собой числа от 0 до 0x10ffff. Эта последовательность должна быть представлена в памяти в виде набора байтов (то есть значений от 0 до 255). Правила преобразования строки Unicode в последовательность байтов называются кодировкой.

Первая кодировка, которая может прийти в голову – это массив 32-битных целых чисел. В этом представлении строка «Python» будет выглядеть так:

   P           y           t           h           o           n
0x50 00 00 00 79 00 00 00 74 00 00 00 68 00 00 00 6f 00 00 00 6e 00 00 00
   0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

Такое представление интуитивно понятно, но его использование порождает ряд проблем.

1. Оно не является переносимым: разные процессоры по-разному упорядочивают байты.

2. Это очень расточительно по памяти. В большинстве текстов большинство кодовых точек меньше 127 или меньше 255, поэтому много места занято нулевыми байтами. Приведенная выше строка занимает 24 байта по сравнению с 6 байтами, необходимыми для ASCII-представления. Увеличение использования оперативной памяти не так важно (настольные компьютеры имеют мегабайты ОЗУ, и строки обычно не такие большие), но увеличение использования дискового пространства и пропускной способности сети в 4 раза недопустимо.

3. Оно несовместимо с существующими C-функциями, такими как strlen(), поэтому пришлось бы использовать новое семейство функций для работы с широкими строками.

4. Многие интернет-стандарты определены в терминах текстовых данных и не могут обрабатывать содержимое с встроенными нулевыми байтами.

Обычно люди не используют эту кодировку, предпочитая другие кодировки, которые более эффективны и удобны. UTF-8, вероятно, самая распространённая поддерживаемая кодировка; она будет рассмотрена ниже.

Кодировки не обязаны поддерживать все возможные символы Unicode, и большинство из них этого не делает. Например, кодировка по умолчанию в Python – это 'ascii'. Правила преобразования строки Unicode в кодировку ASCII просты: для каждой кодовой точки:

1. Если кодовая точка < 128, каждый байт равен значению кодовой точки.

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

Latin-1, также известная как ISO-8859-1, является аналогичной кодировкой. Кодовые точки Unicode 0–255 идентичны значениям Latin-1, поэтому преобразование в эту кодировку просто требует преобразования кодовых точек в байтовые значения; если встречается кодовая точка больше 255, строка не может быть закодирована в Latin-1.

Кодировки не обязательно должны быть простыми однозначными отображениями, как Latin-1. Рассмотрим EBCDIC от IBM, которая использовалась на мейнфреймах IBM. Значения букв не были в одном блоке: от 'a' до 'i' имели значения от 129 до 137, а от 'j' до 'r' – от 145 до 153. Если бы вы хотели использовать EBCDIC в качестве кодировки, вам, вероятно, пришлось бы использовать какую-нибудь таблицу поиска для выполнения преобразования, но это в значительной степени внутренняя деталь.

UTF-8 – одна из наиболее часто используемых кодировок. UTF расшифровывается как «Unicode Transformation Format», а «8» означает, что в кодировке используются 8-битные числа. (Существует также кодировка UTF-16, но она используется реже, чем UTF-8.) UTF-8 использует следующие правила:

1. Если кодовая точка меньше 128, она представляется соответствующим значением байта.

2. Если кодовая точка находится между 128 и 0x7ff, она преобразуется в два значения байтов от 128 до 255.

3. Кодовые точки больше 0x7ff преобразуются в последовательности из трёх или четырёх байтов, где каждый байт последовательности находится в диапазоне от 128 до 255.

UTF-8 обладает несколькими удобными свойствами:

1. Она может обрабатывать любую кодовую точку Юникода.

2. Строка Unicode преобразуется в строку байтов, не содержащую встроенных нулевых байтов. Это позволяет избежать проблем с порядком байтов и даёт возможность обрабатывать строки UTF-8 такими функциями C, как strcpy(), и передавать их по протоколам, которые не поддерживают нулевые байты.

3. Любая строка ASCII также является корректным текстом UTF-8.

4. UTF-8 довольно компактна; большинство кодовых точек преобразуются в два байта, а значения меньше 128 занимают только один байт.

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

Ссылки¶References

На сайте Unicode Consortium по адресу <http://www.unicode.org> есть таблицы символов, глоссарий и PDF-версии спецификации Unicode. Будьте готовы к сложному чтению. <http://www.unicode.org/history/> – это хронология происхождения и развития Unicode.

В помощь изучающим стандарт Юкка Корпела написал вводное руководство по чтению таблиц символов Unicode, доступное по адресу <https://www.cs.tut.fi/~jkorpela/unicode/guide.html>.

Ещё одну хорошую вводную статью написал Джоэл Спольски <http://www.joelonsoftware.com/articles/Unicode.html>. Если это введение не прояснило для вас ситуацию, попробуйте прочитать эту альтернативную статью, прежде чем продолжать.

Статьи в Википедии часто полезны; см. статьи «character encoding» <http://en.wikipedia.org/wiki/Character_encoding> и UTF-8 <http://en.wikipedia.org/wiki/UTF-8>, например.

Тип Unicode ¶The Unicode Type

Строки Unicode представлены экземплярами типа unicode, одного из встроенных типов Python. Он происходит из абстрактного типа basestring, который также является предком типа str; поэтому проверить, является ли значение строковым типом, можно с помощью isinstance(value, basestring). Внутри Python представляет строки Unicode как 16- или 32-битные целые числа в зависимости от того, как был скомпилирован интерпретатор Python.

Конструктор unicode() имеет сигнатуру unicode(string[, encoding, errors]). Все его аргументы должны быть 8-битными строками. Первый аргумент преобразуется в Unicode с использованием указанной кодировки; если опустить аргумент encoding, для преобразования используется кодировка ASCII, поэтому символы больше 127 будут трактоваться как ошибки:

>>> unicode('abcdef')
u'abcdef'
>>> s = unicode('abcdef')
>>> type(s)
<type 'unicode'>
>>> unicode('abcdef' + chr(255))    
Traceback (most recent call last):
...
UnicodeDecodeError: 'ascii' codec can't decode byte 0xff in position 6:
ordinal not in range(128)

Аргумент errors определяет реакцию, когда входную строку невозможно преобразовать по правилам кодировки. Допустимые значения этого аргумента: ‘strict’ (вызвать исключение UnicodeDecodeError), ‘replace’ (добавить U+FFFD, ‘REPLACEMENT CHARACTER’) или ‘ignore’ (просто исключить символ из результата Unicode). Следующие примеры показывают различия:

>>> unicode('\x80abc', errors='strict')     
Traceback (most recent call last):
    ...
UnicodeDecodeError: 'ascii' codec can't decode byte 0x80 in position 0:
ordinal not in range(128)
>>> unicode('\x80abc', errors='replace')
u'\ufffdabc'
>>> unicode('\x80abc', errors='ignore')
u'abc'

Кодировки задаются строками, содержащими их имена. Python 2.7 поставляется примерно со 100 различными кодировками; полный список см. в справочнике по библиотеке Python в разделе Стандартные кодировки. Некоторые кодировки имеют несколько имен; например, ‘latin-1’, ‘iso_8859_1’ и ‘8859’ – это синонимы одной и той же кодировки.

Односимвольные строки Юникода можно также создать с помощью встроенной функции unichr(). Она принимает целое число и возвращает строку Юникода длиной 1, содержащую соответствующую кодовую точку. Обратная операция – встроенная функция ord(), которая принимает односимвольную строку Юникода и возвращает значение кодовой точки:

>>> unichr(40960)
u'\ua000'
>>> ord(u'\ua000')
40960

Экземпляры типа unicode имеют много тех же методов, что и 8-битный строковый тип, для таких операций, как поиск и форматирование:

>>> s = u'Was ever feather so lightly blown to and fro as this multitude?'
>>> s.count('e')
5
>>> s.find('feather')
9
>>> s.find('bird')
-1
>>> s.replace('feather', 'sand')
u'Was ever sand so lightly blown to and fro as this multitude?'
>>> s.upper()
u'WAS EVER FEATHER SO LIGHTLY BLOWN TO AND FRO AS THIS MULTITUDE?'

Обратите внимание: аргументы этих методов могут быть строками Unicode или 8-битными строками. Перед выполнением операции 8-битные строки будут преобразованы в Unicode; при этом будет использоваться кодировка ASCII по умолчанию, поэтому символы больше 127 приведут к исключению:

>>> s.find('Was\x9f')                   
Traceback (most recent call last):
    ...
UnicodeDecodeError: 'ascii' codec can't decode byte 0x9f in position 3:
ordinal not in range(128)
>>> s.find(u'Was\x9f')
-1

Большая часть кода Python, работающего со строками, поэтому будет работать и со строками Unicode без каких-либо изменений. (Коду ввода-вывода требуется более серьёзная адаптация для Unicode; подробнее об этом позже.)

Ещё один важный метод – .encode([encoding], [errors='strict']), который возвращает 8-битную строковую версию строки Unicode, закодированную в запрошенной кодировке. Параметр errors аналогичен параметру конструктора unicode(), но с одной дополнительной возможностью: помимо ‘strict’, ‘ignore’ и ‘replace’ можно также передать ‘xmlcharrefreplace’, использующий символьные ссылки XML. Следующий пример показывает различные результаты:

>>> u = unichr(40960) + u'abcd' + unichr(1972)
>>> u.encode('utf-8')
'\xea\x80\x80abcd\xde\xb4'
>>> u.encode('ascii')                       
Traceback (most recent call last):
    ...
UnicodeEncodeError: 'ascii' codec can't encode character u'\ua000' in
position 0: ordinal not in range(128)
>>> u.encode('ascii', 'ignore')
'abcd'
>>> u.encode('ascii', 'replace')
'?abcd?'
>>> u.encode('ascii', 'xmlcharrefreplace')
'ꀀabcd޴'

8-битные строки Python имеют метод .decode([encoding], [errors]), который интерпретирует строку с использованием заданной кодировки:

>>> u = unichr(40960) + u'abcd' + unichr(1972)   # Собрать строку
>>> utf8_version = u.encode('utf-8')             # Закодировать в UTF-8
>>> type(utf8_version), utf8_version
(<type 'str'>, '\xea\x80\x80abcd\xde\xb4')
>>> u2 = utf8_version.decode('utf-8')            # Декодировать с использованием UTF-8
>>> u == u2                                      # Две строки совпадают
True

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

Наиболее часто используемой частью модуля codecs является функция codecs.open(), которая будет рассмотрена в разделе, посвящённом вводу и выводу.

Литералы Unicode в исходном коде Python¶Unicode Literals in Python Source Code

В исходном коде Python литералы Unicode записываются как строки с префиксом ‘u’ или ‘U’: u'abcdefghijk'. Конкретные кодовые точки можно записать с помощью управляющей последовательности \u, после которой следуют четыре шестнадцатеричные цифры, задающие кодовую точку. Управляющая последовательность \U аналогична, но требует 8 шестнадцатеричных цифр, а не 4.

Литералы Unicode также могут использовать те же управляющие последовательности, что и 8-битные строки, включая \x, но \x принимает только две шестнадцатеричные цифры, поэтому не может выразить произвольную кодовую точку. Восьмеричные escape-последовательности могут доходить до U+01ff, что в восьмеричной системе равно 777.

>>> s = u"a\xac\u1234\u20ac\U00008000"
... #      ^^^^ двузначная шестнадцатеричная escape-последовательность
... #          ^^^^^^ четырёхзначная Unicode escape-последовательность
... #                      ^^^^^^^^^^ восьмизначная Unicode escape-последовательность
>>> for c in s:  print ord(c),
...
97 172 4660 8364 32768

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

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

Python поддерживает запись литералов Unicode в любой кодировке, но необходимо объявить используемую кодировку. Это делается путём включения специального комментария либо в первую, либо во вторую строку исходного файла:

#!/usr/bin/env python
# -*- coding: latin-1 -*-

u = u'abcdé'
print ord(u[-1])

Синтаксис вдохновлён нотацией Emacs для указания локальных переменных файла. Emacs поддерживает множество различных переменных, но Python поддерживает только ‘coding’. Символы -*- указывают Emacs, что комментарий специальный; они не имеют значения для Python, но являются соглашением. Python ищет coding: name или coding=name в комментарии.

Если не включить такой комментарий, по умолчанию будет использоваться кодировка ASCII. Версии Python до 2.4 были евроцентричными и по умолчанию использовали Latin-1 для строковых литералов; в Python 2.4 символы больше 127 по-прежнему работают, но выдают предупреждение. Например, следующая программа не имеет объявления кодировки:

#!/usr/bin/env python
u = u'abcdé'
print ord(u[-1])

При запуске на Python 2.4 будет выведено следующее предупреждение:

amk:~$ python2.4 p263.py
sys:1: DeprecationWarning: Non-ASCII character '\xe9'
     in file p263.py on line 2, but no encoding declared;
     see https://www.python.org/peps/pep-0263.html for details

Python 2.5 и выше более строги и выдадут синтаксическую ошибку:

amk:~$ python2.5 p263.py
File "/tmp/p263.py", line 2
SyntaxError: Non-ASCII character '\xc3' in file /tmp/p263.py
  on line 2, but no encoding declared; see
  https://www.python.org/peps/pep-0263.html for details

Свойства Unicode¶Unicode Properties

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

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

import unicodedata

u = unichr(233) + unichr(0x0bf2) + unichr(3972) + unichr(6000) + unichr(13231)

for i, c in enumerate(u):
    print i, '%04x' % ord(c), unicodedata.category(c),
    print unicodedata.name(c)

# Получить числовое значение второго символа
print unicodedata.numeric(u[1])

При запуске выводится:

0 00e9 Ll LATIN SMALL LETTER E WITH ACUTE
1 0bf2 No TAMIL NUMBER ONE THOUSAND
2 0f84 Mn TIBETAN MARK HALANTA
3 1770 Lo TAGBANWA LETTER SA
4 33af So SQUARE RAD OVER S SQUARED
1000.0

Коды категорий – это аббревиатуры, описывающие природу символа. Они сгруппированы в категории, такие как «Буква», «Число», «Пунктуация» или «Символ», которые, в свою очередь, делятся на подкатегории. Взяв коды из приведённого выше вывода, 'Ll' означает «Буква, строчная», 'No' – «Число, прочее», 'Mn' – «Знак, некомбинируемый», а 'So' – «Символ, прочее». Список кодов категорий см. на странице <http://www.unicode.org/reports/tr44/#General_Category_Values>.

Ссылки¶References

Типы Unicode и 8-битных строк описаны в справочнике по библиотеке Python в разделе Типы последовательностей – str, unicode, list, tuple, bytearray, buffer, xrange.

Документация модуля unicodedata.

Документация модуля codecs.

Марк-Андре Лембург выступил с докладом на EuroPython 2002 под названием «Python и Unicode». PDF-версия его слайдов доступна по адресу <https://downloads.egenix.com/python/Unicode-EPC2002-Talk.pdf> и представляет собой отличный обзор архитектуры поддержки Unicode в Python.

Имена файлов в Unicode¶Unicode filenames

Большинство широко используемых сегодня операционных систем поддерживают имена файлов, содержащие произвольные символы Unicode. Обычно это реализуется преобразованием строки Unicode в некую кодировку, которая зависит от системы. Например, Mac OS X использует UTF-8, а Windows – настраиваемую кодировку; в Windows Python использует имя «mbcs» для обозначения текущей настроенной кодировки. В Unix-системах кодировка файловой системы существует только в том случае, если установлены переменные окружения LANG или LC_CTYPE; если они не установлены, используется кодировка ASCII.

Функция sys.getfilesystemencoding() возвращает кодировку для использования в текущей системе, на случай если потребуется выполнить кодирование вручную, но в этом нет особой необходимости. При открытии файла для чтения или записи обычно можно просто передать строку Unicode в качестве имени файла, и она будет автоматически преобразована в нужную кодировку:

filename = u'filename\u4500abc'
f = open(filename, 'w')
f.write('blah\n')
f.close()

Функции модуля os, такие как os.stat(), также принимают имена файлов Unicode.

Функция os.listdir(), возвращающая имена файлов, ставит вопрос: должна ли она возвращать версию имён файлов в Unicode или 8-битные строки с закодированными версиями? os.listdir() делает и то, и другое в зависимости от того, передан ли путь к каталогу как 8-битная строка или строка Unicode. Если передать путь как строку Unicode, имена файлов будут декодированы с использованием кодировки файловой системы и будет возвращён список строк Unicode, а при передаче 8-битного пути будут возвращены 8-битные версии имён файлов. Например, если предположить, что кодировка файловой системы по умолчанию – UTF-8, выполнение следующей программы:

fn = u'filename\u4500abc'
f = open(fn, 'w')
f.close()

import os
print os.listdir('.')
print os.listdir(u'.')

выдаст следующий результат:

amk:~$ python t.py
['.svn', 'filename\xe4\x94\x80abc', ...]
[u'.svn', u'filename\u4500abc', ...]

Первый список содержит имена файлов в кодировке UTF-8, а второй список – версии в Unicode.

Советы по написанию программ с поддержкой Unicode¶Tips for Writing Unicode-aware Programs

В этом разделе приводятся некоторые рекомендации по написанию программного обеспечения, работающего с Unicode.

Самый важный совет:

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

Если попытаться написать функции обработки, принимающие как строки Unicode, так и 8-битные строки, программа будет уязвима для ошибок в местах объединения строк разных типов. Кодировка Python по умолчанию – ASCII, поэтому при появлении символа со значением ASCII > 127 во входных данных, возникнет UnicodeDecodeError, так как ASCII не может обработать такой символ.

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

Включайте в тестовые данные символы > 127, а ещё лучше – символы > 255.

При работе с данными из веб-браузера или другого ненадёжного источника распространённый приём – проверять строку на недопустимые символы перед её использованием в генерируемой командной строке или сохранением в базу данных. Если это делается, следует проверять строку в том виде, в котором она будет использована или сохранена; кодировки могут маскировать символы. Это особенно важно, если входные данные также задают кодировку; многие кодировки не затрагивают часто проверяемые символы, но Python включает такие кодировки, как 'base64', которые изменяют каждый символ.

Например, предположим, есть система управления контентом, которая принимает имя файла в Unicode, и нужно запретить пути с символом '/'. Можно написать такой код:

def read_file (filename, encoding):
    if '/' in filename:
        raise ValueError("'/' not allowed in filenames")
    unicode_name = filename.decode(encoding)
    f = open(unicode_name, 'r')
    # ... вернуть содержимое файла ...

Однако, если злоумышленник сможет указать кодировку 'base64', он сможет передать 'L2V0Yy9wYXNzd2Q=' – это base-64-кодированная форма строки '/etc/passwd', чтобы прочитать системный файл. Приведённый выше код ищет символы '/' в закодированной форме и пропускает опасный символ в результирующей декодированной форме.

Ссылки¶References

PDF-слайды презентации Марка-Андре Лембурга «Writing Unicode-aware Applications in Python» доступны по адресу <https://downloads.egenix.com/python/LSM2005-Developing-Unicode-aware-applications-in-Python.pdf> и освещают вопросы кодировок символов, а также интернационализацию и локализацию приложений.