Что нового в 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() не поддерживает функцию «мягкого пространства» старого оператора 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. Примечание. Аргументы 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-разрядного¶

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

• В 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"..." для текста в Юникоде. Однако вы должны использовать литералы 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' был единственным символом «euro». (Конечно, это изменение затрагивает только необработанные строковые литералы; в Python 3.0 символом euro является '\u20ac'.)

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

• Файлы, открытые в виде текстовых файлов (по-прежнему используется режим по умолчанию для open()), всегда используют кодировку для сопоставления строк (в памяти) и байтов (на диске). Двоичные файлы (открытые с помощью b в аргументе mode) всегда используют байты в памяти. Это означает, что если файл открыт с использованием неправильного режима или кодировки, то, скорее всего, произойдет громкий сбой ввода-вывода, вместо того чтобы автоматически выдавать неверные данные. Это также означает, что даже пользователям Unix придется указывать правильный режим (текстовый или двоичный) при открытии файла. Существует зависящая от платформы кодировка по умолчанию, которую на платформах Unixy можно задать с помощью переменной окружения 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, за исключением имен авторов в комментариях.)

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

• Смотрите также РУКОВОДСТВО по работе с Юникодом, который был обновлен для 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() больше не принимает аргумент stream; вместо exec(f) вы можете использовать exec(f.read()).

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

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

• Модуль from ** 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]) вместо того, чтобы всегда возвращать значение с плавающей точкой. Обычно он возвращает целое число при вызове с одним аргументом и значение того же типа, что и 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.