Что нового в Python 3.0¶What’s New In Python 3.0

Print – функция¶Print Is A Function

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

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

Old: print x,           # Завершающая запятая подавляет перевод строки
New: print(x, end=" ")  # Добавляет пробел вместо перевода строки

Old: print              # Выводит перевод строки
New: print()            # Необходимо вызвать функцию!

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

Old: print (x, y)       # выводит repr((x, y))
New: print((x, y))      # Не то же самое, что 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(), так что для крупных проектов это, как правило, не проблема.

Представления и итераторы вместо списков¶Views And Iterators Instead Of Lists

Некоторые известные 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() теперь возвращает итератор.

Сравнения на упорядочивание¶Ordering Comparisons

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

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

• builtin.sorted() и list.sort() больше не принимают аргумент cmp, задающий функцию сравнения. Вместо него используйте аргумент key. Примечание: аргументы key и reverse теперь являются только ключевыми (keyword-only).

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

Целые числа¶Integers

• 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 вместо этого.

Текст и данные вместо Unicode и 8-битных строк¶Text Vs. Data Instead Of Unicode Vs. 8-bit

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

• Python 3.0 использует понятия текста и (двоичных) данных вместо строк Unicode и 8-битных строк. Весь текст – это Unicode; однако закодированный Unicode представляется в виде двоичных данных. Типом для хранения текста является 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' в Python 3.0 – это строка из 6 символов, тогда как в 2.6 ur'\u20ac' был одним символом «евро». (Разумеется, это изменение затрагивает только сырые строковые литералы; символ евро в Python 3.0 – это '\u20ac'.)

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

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

• Начальные значения sys.stdin, sys.stdout и sys.stderr теперь являются текстовыми файлами, предназначенными только для Unicode (т.е. они являются экземплярами 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-only, за исключением имён участников в комментариях.)

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

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

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

• 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().

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

• 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):
      ...
  

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

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

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

Удалённый синтаксис¶Removed Syntax

• 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)

• Классические классы удалены.

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

• != теперь возвращает противоположность ==, если только == не возвращает 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__().

Встроенные функции¶Builtins

• 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.