Перенос кода с Python 2 на Python 3¶Porting Python 2 Code to Python 3

from __future__ import print_function¶

Это не только приучает писать print() как функцию вместо оператора, но и даёт все преимущества, которые функция имеет по сравнению с оператором Python 2 (six предоставляет функцию, если поддерживается Python 2.5 или старше).

from __future__ import unicode_literals¶

Если используется этот future-оператор, то все строковые литералы в Python 2 будут считаться Unicode (как уже происходит в Python 3). Если не использовать этот future-оператор, то следует помечать все текстовые строки префиксом u и поддерживать только Python 3.3 или новее. Но настоятельно рекомендуется сделать что-то одно (six предоставляет функцию, если не хочется использовать future-оператор и требуется поддержка Python 3.2 или старше).

Байтовые/строковые литералы¶Bytes/string literals

Это очень важный момент. Добавляйте префикс b к строкам Python 2, которые предназначены для хранения байтов, чтобы чётко разграничить, что является, а что не является текстовой строкой Python 3 (six предоставляет функцию для совместимости с Python 2.5).

Этот момент нельзя переоценить: убедитесь, что вы знаете, какими должны быть все ваши строковые литералы Python 2 в Python 3. Любой строковый литерал, который должен обрабатываться как байты, должен иметь префикс b. Любой строковый литерал, который должен быть Unicode/текстом в Python 2, должен либо иметь литерал u (поддерживается, но игнорируется в Python 3.3 и новее), либо в начале файла должно быть from __future__ import unicode_literals. Но ключевой момент – вы должны знать, как Python 3 будет обрабатывать каждый ваш строковый литерал, и помечать их соответствующим образом.

Существуют некоторые различия между байтовыми литералами в Python 2 и Python 3 из-за того, что в Python 2 тип bytes является просто псевдонимом str. Смотрите раздел Handle Common “Gotchas”, чтобы знать, чего остерегаться.

from __future__ import absolute_import¶

Более подробно обсуждается ниже, но вам следует использовать этот future-оператор, чтобы случайно не применить неявные относительные импорты.

from __future__ import absolute_import¶

Неявные относительные импорты (например, импорт spam.bacon из spam.eggs с помощью оператора import bacon) не работают в Python 3. Этот future-оператор отходит от этого и позволяет использовать явные относительные импорты (например, from . import bacon).

В Python 2.5 необходимо использовать оператор __future__, чтобы иметь возможность использовать явные относительные импорты и предотвратить неявные. В Python 2.6 явные относительные импорты доступны и без этого оператора, но всё равно стоит использовать оператор __future__ для предотвращения неявных относительных импортов. В Python 2.7 оператор __future__ не нужен. Другими словами, если вы не поддерживаете только Python 2.7 или версию старше 2.5, используйте этот оператор __future__.

Помечайте все строки Unicode префиксом u¶Mark all Unicode strings with a u prefix

Хотя в Python 2.6 есть оператор __future__, который автоматически заставляет Python 2 обрабатывать все строковые литералы как Unicode, в Python 2.5 такого сокращённого пути нет. Это означает, что вам нужно просмотреть все строковые литералы и пометить их префиксом u, чтобы явно превратить их в текстовые строки, где это необходимо, и поддерживать только Python 3.3 или новее. В противном случае используйте проект вроде six, который предоставляет функцию для обработки всех текстовых строковых литералов.

Перехват текущего возбуждённого исключения¶Capturing the Currently Raised Exception

В Python 2.5 и ранее синтаксис для доступа к текущему исключению:

try:
  raise Exception()
except Exception, exc:
  # Текущее исключение: 'exc'.
  pass

Этот синтаксис изменился в Python 3 (и был перенесён в Python 2.6 и новее) на:

try:
  raise Exception()
except Exception as exc:
  # Текущее исключение: 'exc'.
  # В Python 3 'exc' ограничено блоком; в Python 2.6/2.7 оно "утекает".
  pass

Из-за этого изменения синтаксиса необходимо изменить способ перехвата текущего исключения в Python 2.5 и ранее на:

try:
  raise Exception()
except Exception:
  import sys
  exc = sys.exc_info()[1]
  # Текущее исключение: 'exc'.
  pass

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

from __future__ import division¶

Хотя того же результата можно добиться, используя аргумент -Qnew Python, использование этого future-оператора снимает требование, чтобы пользователи использовали этот флаг для получения ожидаемого поведения деления в Python 3 (например, 1/2 == 0.5; 1//2 == 0).

Указывайте при открытии файла в двоичном режиме¶Specify when opening a file as binary

Если вы не работали в Windows, возможно, вы не всегда утруждали себя добавлением режима b при открытии двоичного файла (например, rb для чтения в двоичном режиме). В Python 3 двоичные файлы и текстовые файлы чётко различаются и взаимно несовместимы; подробнее см. модуль io. Поэтому необходимо принять решение, будет ли файл использоваться для двоичного доступа (чтение и/или запись байтовых данных) или текстового доступа (чтение и/или запись данных Unicode).

Текстовые файлы¶Text files

Текстовые файлы, созданные с помощью open() в Python 2, возвращают байтовые строки, тогда как в Python 3 они возвращают строки Unicode. В зависимости от стратегии переноса это может быть проблемой.

Если требуется, чтобы текстовые файлы возвращали строки Unicode в Python 2, есть две возможности:

• В Python 2.6 и выше используйте io.open(). Поскольку io.open() по сути та же функция и в Python 2, и в Python 3, это поможет устранить любые возможные проблемы.
• Если требуется совместимость с версиями ниже 2.6, тогда используйте codecs.open(). Это гарантирует, что в Python 2 вы получите строки Unicode.

Наследуйте от object¶Subclass object

Классы нового стиля существуют с Python 2.2. Необходимо убедиться, что вы наследуете от object, чтобы избежать странных крайних случаев с порядком разрешения методов и т.д. Это по-прежнему полностью допустимо в Python 3 (хотя и не нужно, так как все классы неявно наследуют от object).

Работа с дихотомией байтов и строк¶Deal With the Bytes/String Dichotomy

Одна из самых больших проблем при портировании кода на Python 3 – это обработка дихотомии байтов и строк. Поскольку Python 2 позволял типу str хранить текстовые данные, люди со временем стали довольно небрежно разграничивать, какие экземпляры str содержат текст, а какие – байты. В Python 3 уже нельзя быть таким беспечным, и необходимо правильно обрабатывать разницу. Ключ к решению этой проблемы – убедиться, что каждый строковый литерал в вашем коде Python 2 помечен синтаксически или функционально как байтовые или текстовые данные. После этого нужно убедиться, что ваши API спроектированы так, чтобы либо обрабатывать конкретный тип, либо быть правильно полиморфными.

>>> b"" == ""
False

$ python3 -b
>>> b"" == ""
__main__:1: BytesWarning: Comparison between bytes and string
False

$ python3 -bb
>>> b"" == ""
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
BytesWarning: Comparison between bytes and string

Индексирование байтовых объектов¶Indexing bytes objects

Еще одно потенциально удивительное изменение – это поведение индексирования байтовых объектов в Python 3:

>>> b"xyz"[0]
120

Действительно, байтовые объекты Python 3 (а также объекты bytearray) являются последовательностями целых чисел. Но код, перенесенный из Python 2, часто предполагает, что индексирование байтовой строки дает другую байтовую строку, а не целое число. Чтобы согласовать оба поведения, используйте срезы:

>>> b"xyz"[0:1]
b'x'
>>> n = 1
>>> b"xyz"[n:n+1]
b'y'

Единственная оставшаяся ловушка в том, что выход за границы при срезе возвращает пустой байтовый объект вместо возбуждения IndexError:

>>> b"xyz"[3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: index out of range
>>> b"xyz"[3:4]
b''

__str__()/__unicode__()¶

В Python 2 объекты могут определять как строковое, так и unicode представление себя. В Python 3, однако, существует только строковое представление. Это становится проблемой, поскольку люди могут нечаянно делать в своих методах __str__() вещи, которые приводят к непредсказуемым результатам (например, бесконечная рекурсия, если использовать идиому unicode(self).encode('utf8') в качестве тела метода __str__()).

Можно использовать mixin-класс для обхода этого. Это позволяет определить только метод __unicode__() для вашего класса, а mixin выведет __str__() за вас (код из http://lucumr.pocoo.org/2011/1/22/forwards-compatible-python/):

import sys

class UnicodeMixin(object):

  """Миксин-класс для определения правильных методов __str__/__unicode__
  методов в Python 2 или 3.

  if sys.version_info[0] >= 3: # Python 3
      def __str__(self):
          return self.__unicode__()
  else:  # Python 2
      def __str__(self):
          return self.__unicode__().encode('utf8')


class Spam(UnicodeMixin):

  def __unicode__(self):
      return u'spam-spam-bacon-spam'  # 2to3 удалит префикс 'u'.

Не индексируйте исключения¶Don’t Index on Exceptions

В Python 2 следующее работало:

>>> exc = Exception(1, 2, 3)
>>> exc.args[1]
2
>>> exc[1]  # Только Python 2!
2

Но в Python 3 индексирование непосредственно исключения является ошибкой. Необходимо убедиться, что индексирование производится только по атрибуту BaseException.args, который представляет собой последовательность, содержащую все аргументы, переданные методу __init__().

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

Не используйте __getslice__ и компанию¶Don’t use __getslice__ & Friends

Уже некоторое время считалось устаревшим, но Python 3 наконец отказался от поддержки __getslice__() и т.д. Полностью переходите на __getitem__() и ее друзей.

Обновление doctest-ов¶Updating doctests

Не забывайте также делать их совместимыми с Python 2/3. Если вы написали монолитный набор доктестов (например, одну строку документации, содержащую все доктесты), вам стоит хотя бы подумать о разбиении доктестов на более мелкие части, чтобы их было проще исправлять. В противном случае, возможно, стоит потратить время и усилия на перенос тестов в unittest.

Обновление map для несбалансированных входных последовательностей¶Update map for imbalanced input sequences

В Python 2, когда map передавалось более одной входной последовательности, он дополнял более короткие последовательности значениями None, возвращая последовательность такой же длины, как самая длинная входная последовательность.

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