Что нового в Python 3.0¶

Печать - это функция¶

Оператор print был заменен функцией print() с аргументами в виде ключевых слов, которые заменяют большую часть специального синтаксиса старого оператора print (PEP 3105). Примеры:

Old: print "The answer is", 2*2
New: print("The answer is", 2*2)

Old: print x,           # Trailing comma suppresses newline
New: print(x, end=" ")  # Appends a space instead of a newline

Old: print              # Prints a newline
New: print()            # You must call the function!

Old: print >>sys.stderr, "fatal error"
New: print("fatal error", file=sys.stderr)

Old: print (x, y)       # prints repr((x, y))
New: print((x, y))      # Not the same as print(x, y)!

Вы также можете настроить разделитель между элементами, например:

print("There are <", 2**32, "> possibilities!", sep="")

который производит:

There are <4294967296> possibilities!

Примечание:

• Функция print() не поддерживает функцию «softspace» старого оператора print. Например, в Python 2.x, print "A\n", "B" будет писать "A\nB\n"; но в Python 3.0, print("A\n", "B") пишет "A\n B\n".

• Поначалу вы будете часто набирать старое print x в интерактивном режиме. Пора переучивать свои пальцы на ввод print(x) вместо этого!

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

Представления и итераторы вместо списков¶

Некоторые известные API больше не возвращают списки:

• Методы dict dict.keys(), dict.items() и dict.values() возвращают «представления» вместо списков. Например, это больше не работает: k = d.keys(); k.sort(). Вместо этого используйте k = sorted(d) (это работает и в Python 2.5 и так же эффективно).

• Также больше не поддерживаются методы dict.iterkeys(), dict.iteritems() и dict.itervalues().

• map() и filter() возвращают итераторы. Если вам действительно нужен список, а входные последовательности имеют одинаковую длину, быстрое решение - обернуть map() в list(), например list(map(...)), но лучшим решением часто является использование понимания списка (особенно если в исходном коде используется lambda) или переписывание кода так, чтобы он вообще не нуждался в списке. Особую сложность представляет map(), вызываемый для побочных эффектов функции; правильным преобразованием является использование обычного цикла for (поскольку создание списка было бы просто расточительным).

  Если входные последовательности не одинаковой длины, map() остановится на окончании самой короткой из последовательностей. Для полной совместимости с map() из Python 2.x, также оберните последовательности в itertools.zip_longest(), например, map(func, *sequences) станет list(map(func, itertools.zip_longest(*sequences))).

• range() теперь ведет себя так же, как раньше xrange(), за исключением того, что работает со значениями произвольного размера. Последнего больше не существует.

• zip() теперь возвращает итератор.

Сравнение заказов¶

В Python 3.0 упрощены правила упорядочивания сравнений:

• Операторы сравнения порядка (<, <=, >=, >) вызывают исключение TypeError, когда операнды не имеют значимого естественного порядка. Таким образом, выражения типа 1 < '', 0 > None или len <= len больше не действительны, а, например, None < None вызывает TypeError вместо возврата False. Следствием этого является то, что сортировка неоднородного списка больше не имеет смысла - все элементы должны быть сравнимы друг с другом. Обратите внимание, что это не относится к операторам == и !=: объекты разных несравнимых типов всегда сравниваются неравноценно друг с другом.

• builtin.sorted() и list.sort() больше не принимают аргумент cmp, предоставляющий функцию сравнения. Вместо этого используйте аргумент key. N.B. Аргументы key и reverse теперь «только для ключевых слов».

• Функцию cmp() следует считать исчезнувшей, а специальный метод __cmp__() больше не поддерживается. Используйте __lt__() для сортировки, __eq__() с __hash__(), и другие богатые сравнения по мере необходимости. (Если вам действительно нужна функциональность cmp(), вы можете использовать выражение (a > b) - (a < b) как эквивалент для cmp(a, b)).

Целые числа¶

• PEP 237: По сути, long переименован в int. То есть, существует только один встроенный интегральный тип, названный int; но он ведет себя в основном как старый тип long.

• PEP 238: Выражение типа 1/2 возвращает плавающее число. Используйте 1//2, чтобы получить усечение. (Последний синтаксис существует уже много лет, по крайней мере, начиная с Python 2.2).

• Константа sys.maxint была удалена, поскольку больше не существует ограничения на значение целых чисел. Однако sys.maxsize может использоваться как целое число, большее, чем любой практический индекс списка или строки. Оно соответствует «естественному» размеру целого числа в реализации и обычно совпадает с sys.maxint в предыдущих выпусках на той же платформе (при условии одинаковых опций сборки).

• Длинное целое число repr() больше не включает завершающий символ L, поэтому код, который безоговорочно удаляет этот символ, вместо него отрезает последнюю цифру. (Вместо этого используйте str()).

• Восьмеричные литералы больше не имеют форму 0720; вместо них используется 0o720.

Текст против данных вместо Юникода против 8-бита¶

Все, что вы думали, что знаете о двоичных данных и Unicode, изменилось.

• Python 3.0 использует понятия текст и (двоичные) данные вместо строк Unicode и 8-битных строк. Весь текст является Юникодом; однако кодированный Юникод представлен в виде двоичных данных. Для хранения текста используется тип str, для хранения данных - bytes. Самое большое отличие от ситуации в версии 2.x заключается в том, что любая попытка смешать текст и данные в Python 3.0 приводит к появлению TypeError, тогда как если бы вы смешивали Unicode и 8-битные строки в Python 2.x, это сработало бы, если бы 8-битная строка содержала только 7-битные (ASCII) байты, но вы бы получили UnicodeDecodeError, если бы она содержала не-ASCII значения. Это специфическое для значений поведение вызывало множество грустных лиц на протяжении многих лет.

• Вследствие этого изменения в философии практически весь код, использующий Unicode, кодировки или двоичные данные, скорее всего, должен измениться. Изменения к лучшему, так как в мире 2.x было множество ошибок, связанных со смешиванием кодированного и некодированного текста. Чтобы быть готовым в Python 2.x, начните использовать unicode для всего некодированного текста и str только для двоичных или кодированных данных. Тогда инструмент 2to3 сделает за вас большую часть работы.

• Вы больше не можете использовать литералы u"..." для текста Unicode. Однако вы должны использовать литералы b"..." для двоичных данных.

• Поскольку типы str и bytes нельзя смешивать, вы всегда должны явно конвертировать между ними. Используйте str.encode() для перехода от str к bytes, а bytes.decode() для перехода от bytes к str. Вы также можете использовать bytes(s, encoding=...) и str(b, encoding=...) соответственно.

• Как и str, тип bytes является неизменяемым. Существует отдельный изменяемый тип для хранения буферизованных двоичных данных, bytearray. Почти все API, которые принимают bytes, также принимают bytearray. Мутабельный API основан на collections.MutableSequence.

• Все обратные косые черты в необработанных строковых литералах интерпретируются буквально. Это означает, что эскейпы '\U' и '\u' в необработанных строках не обрабатываются специальным образом. Например, r'\u20ac' - это строка из 6 символов в Python 3.0, тогда как в 2.6 ur'\u20ac' был единственным символом «евро». (Конечно, это изменение затрагивает только необработанные строковые литералы; в Python 3.0 символом евро является '\u20ac').

• Встроенный абстрактный тип basestring был удален. Вместо него используйте str. Типы str и bytes не имеют достаточно общей функциональности, чтобы требовать общего базового класса. Инструмент 2to3 (см. ниже) заменяет каждое вхождение basestring на str.

• Файлы, открытые как текстовые (все еще режим по умолчанию для open()), всегда используют кодировку для отображения между строками (в памяти) и байтами (на диске). Бинарные файлы (открытые с помощью b в аргументе mode) всегда используют байты в памяти. Это означает, что если файл открыт с использованием неправильного режима или кодировки, ввод-вывод, скорее всего, будет громко завершен, вместо того чтобы тихо выдать неверные данные. Это также означает, что даже пользователям Unix придется указывать правильный режим (текстовый или двоичный) при открытии файла. Существует зависящая от платформы кодировка по умолчанию, которая на Unixy платформах может быть установлена с помощью переменной окружения LANG (а иногда и с помощью некоторых других специфических для платформы переменных окружения, связанных с локалью). Во многих случаях, но не во всех, системное значение по умолчанию - UTF-8; вы никогда не должны полагаться на это значение. Любое приложение, читающее или записывающее больше, чем чистый ASCII текст, должно иметь возможность переопределить кодировку. Больше нет необходимости использовать потоки с поддержкой кодировки в модуле codecs.

• Начальные значения sys.stdin, sys.stdout и sys.stderr теперь являются текстовыми файлами только с уникодом (т.е. являются экземплярами io.TextIOBase). Чтобы читать и записывать байтовые данные с помощью этих потоков, необходимо использовать их атрибут io.TextIOBase.buffer.

• Имена файлов передаются в API и возвращаются из них в виде строк (Unicode). Это может вызвать проблемы, связанные с конкретной платформой, поскольку на некоторых платформах имена файлов представляют собой произвольные байтовые строки. (С другой стороны, в Windows имена файлов хранятся как Unicode). В качестве обходного пути большинство API (например, open() и многие функции в модуле os), которые принимают имена файлов, принимают объекты bytes, а также строки, а некоторые API имеют возможность запросить возвращаемое значение bytes. Так, os.listdir() возвращает список экземпляров bytes, если аргумент является экземпляром bytes, а os.getcwdb() возвращает текущий рабочий каталог в виде экземпляра bytes. Обратите внимание, что когда os.listdir() возвращает список строк, имена файлов, которые не могут быть правильно декодированы, опускаются вместо того, чтобы выдать ошибку UnicodeError.

• Некоторые системные API, такие как os.environ и sys.argv, также могут создавать проблемы, когда байты, предоставляемые системой, не могут быть интерпретированы с использованием кодировки по умолчанию. Установка переменной LANG и повторный запуск программы, вероятно, является лучшим подходом.

• PEP 3138: repr() в строке больше не экранирует символы, не являющиеся символами ASCII. Однако он по-прежнему экранирует управляющие символы и точки кода с непечатаемым статусом в стандарте Unicode.

• PEP 3120: Кодировка источника по умолчанию теперь UTF-8.

• PEP 3131: Теперь в идентификаторах разрешены не ASCII-буквы. (Однако стандартная библиотека остается только ASCII, за исключением имен участников в комментариях).

• Модули StringIO и cStringIO исчезли. Вместо них импортируйте модуль io и используйте io.StringIO или io.BytesIO для текста и данных соответственно.

• См. также Юникод HOWTO, который был обновлен для Python 3.0.

Новый синтаксис¶

• PEP 3107: Аннотации аргументов и возвращаемого значения функции. Это стандартизированный способ аннотирования параметров и возвращаемого значения функции. К таким аннотациям не прилагается никакой семантики, кроме того, что они могут быть проанализированы во время выполнения с помощью атрибута __annotations__. Цель состоит в том, чтобы поощрять эксперименты с использованием метаклассов, декораторов или фреймворков.

• PEP 3102: Аргументы только для ключевых слов. Именованные параметры, встречающиеся после *args в списке параметров, должны быть указаны с использованием синтаксиса ключевого слова в вызове. Вы также можете использовать голую строку * в списке параметров, чтобы указать, что вы не принимаете список аргументов переменной длины, но у вас есть аргументы только с ключевыми словами.

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

• PEP 3104: nonlocal. С помощью nonlocal x теперь можно присваивать непосредственно переменной во внешней (но неглобальной) области видимости. nonlocal - это новое зарезервированное слово.

• PEP 3132: Расширенная распаковка итерабельных функций. Теперь вы можете писать такие вещи, как a, b, *rest = some_sequence. И даже *rest, a = stuff. Объект rest всегда является (возможно пустым) списком; правая часть может быть любой итерируемой. Пример:

  (a, *rest, b) = range(5)
  

  Это устанавливает a в 0, b в 4, а rest в [1, 2, 3].

• Словарные понимания: {k: v for k, v in stuff} означает то же самое, что и dict(stuff), но является более гибким. (Это подтверждает PEP 274. :-)

• Литералы множеств, например, {1, 2}. Обратите внимание, что {} - это пустой словарь; для пустого множества используйте set(). Также поддерживаются понимания множеств; например, {x for x in stuff} означает то же самое, что и set(stuff), но является более гибким.

• Новые восьмеричные литералы, например, 0o720 (уже в 2.6). Старые восьмеричные литералы (0720) исчезли.

• Новые двоичные литералы, например 0b1010 (уже в 2.6), и новая соответствующая встроенная функция bin().

• Байтовые литералы вводятся с ведущим b или B, и существует новая соответствующая встроенная функция bytes().

Измененный синтаксис¶

• PEP 3109 и PEP 3134: новый синтаксис оператора raise: raise [expr [from expr]]. См. ниже.

• as и with теперь являются зарезервированными словами. (На самом деле, с версии 2.6.)

• True, False и None являются зарезервированными словами. (В версии 2.6 уже частично введены ограничения на None).

• Переход от except exc, var к except exc as var. См. PEP 3110.

• PEP 3115: Новый синтаксис метакласса. Вместо:

  class C:
      __metaclass__ = M
      ...
  

  теперь вы должны использовать:

  class C(metaclass=M):
      ...
  

  Переменная module-global __metaclass__ больше не поддерживается. (Это был костыль для облегчения перехода по умолчанию к классам нового стиля без выведения каждого класса из object).

• Понимание списков больше не поддерживает синтаксическую форму [... for var in item1, item2, ...]. Вместо нее используйте [... for var in (item1, item2, ...)]. Также обратите внимание, что списковые вычисления имеют другую семантику: они ближе к синтаксическому сахару для выражения генератора внутри конструктора list(), и, в частности, управляющие переменные цикла больше не просачиваются в окружающую область видимости.

• Эллипсис* (...) может использоваться в качестве атомарного выражения в любом месте. (Ранее он был разрешен только в срезах.) Кроме того, теперь он должен быть написан как .... (Ранее он также мог быть написан как . . ., по простой случайности грамматики).

Удаленный синтаксис¶

• PEP 3113: Распаковка параметров кортежа удалена. Вы больше не можете писать def foo(a, (b, c)): .... Вместо этого используйте def foo(a, b_c): b, c = b_c.

• Удалены обратные знаки (вместо них используйте repr()).

• Удалено <> (вместо него используйте !=).

• Удалено ключевое слово: exec() больше не является ключевым словом; оно осталось в виде функции. (К счастью, синтаксис функции был принят и в 2.x.) Также обратите внимание, что exec() больше не принимает аргумент потока; вместо exec(f) вы можете использовать exec(f.read()).

• Целочисленные литералы больше не поддерживают трейлинг l или L.

• Строковые литералы больше не поддерживают ведущие u или U.

• Синтаксис from module import * разрешен только на уровне модуля, внутри функций он больше не используется.

• Единственным приемлемым синтаксисом для относительного импорта является from .[module] import name. Все формы import, не начинающиеся с ., интерпретируются как абсолютный импорт. (PEP 328)

• Классические классы исчезли.

Операторы и специальные методы¶

• != теперь возвращает противоположное ==, если == не возвращает NotImplemented.

• Концепция «несвязанных методов» была удалена из языка. При ссылке на метод как на атрибут класса, вы теперь получаете обычный объект функции.

• __getslice__(), __setslice__() и __delslice__() были убиты. Синтаксис a[i:j] теперь переводится как a.__getitem__(slice(i, j)) (или __setitem__() или __delitem__(), когда используется как цель присваивания или удаления, соответственно).

• PEP 3114: стандартный метод next() был переименован в __next__().

• Специальные методы __oct__() и __hex__() удалены – oct() и hex() теперь используют __index__() для преобразования аргумента в целое число.

• Удалена поддержка __members__ и __methods__.

• Атрибуты функций с именем func_X были переименованы в форму __X__, освобождая эти имена в пространстве имен атрибутов функций для атрибутов, определяемых пользователем. Так, func_closure, func_code, func_defaults, func_dict, func_doc, func_globals, func_name были переименованы в __closure__, __code__, __defaults__, __dict__, __doc__, __globals__, __name__ соответственно.

• __nonzero__() теперь __bool__().

Встроенные модули¶

• PEP 3135: Новый super(). Теперь вы можете вызывать super() без аргументов, и (при условии, что это обычный метод экземпляра, определенный внутри оператора class) нужный класс и экземпляр будут выбраны автоматически. При наличии аргументов поведение super() остается неизменным.

• PEP 3111: raw_input() была переименована в input(). То есть, новая функция input() читает строку из sys.stdin и возвращает ее с вычеркнутой новой строкой. При преждевременном завершении ввода она выдает сообщение EOFError. Чтобы получить старое поведение input(), используйте eval(input()).

• Добавлена новая встроенная функция next() для вызова метода __next__() на объекте.

• Стратегия округления функции round() и тип возврата изменились. Точные половинные случаи теперь округляются до ближайшего четного результата, а не от нуля. (Например, round(2.5) теперь возвращает 2, а не 3). round(x[, n]) теперь делегируется x.__round__([n]) вместо того, чтобы всегда возвращать float. Обычно он возвращает целое число при вызове с одним аргументом и значение того же типа, что и x при вызове с двумя аргументами.

• Переместил intern() на sys.intern().

• Удалено: apply(). Вместо apply(f, args) используйте f(*args).

• Убрано callable(). Вместо callable(f) можно использовать isinstance(f, collections.Callable). Функция operator.isCallable() также исчезла.

• Удалено coerce(). Эта функция больше не служит цели теперь, когда классические классы исчезли.

• Удалено execfile(). Вместо execfile(fn) используйте exec(open(fn).read()).

• Удален тип file. Используйте open(). Теперь существует несколько различных видов потоков, которые open может возвращать в модуле io.

• Убрано reduce(). Используйте functools.reduce(), если это действительно необходимо; однако в 99 процентах случаев явный цикл for более читабелен.

• Удалено reload(). Используйте imp.reload().

• Удалено. dict.has_key() – вместо него используйте оператор in.