# Що нового в Python 3.0

Автор:

  Guido van Rossum

У цій статті пояснюється нові функції в Python 3.0 порівняно з 2.6. Python 3.0, також відомий як «Python 3000» або «Py3K», є першим випуском Python навмисно зворотно несумісним. Python 3.0 було випущено 3 грудня 2008 року. Є більше змін, ніж у типовому випуску, і більше, що є важливим для всіх користувачів Python. Проте, проаналізувавши зміни, ви побачите, що Python справді не дуже змінився — загалом, ми здебільшого виправляємо добре відомі недоліки та бородавки, а також видаляємо багато старих недоліків.

Ця стаття не намагається надати повну специфікацію всіх нових функцій, а натомість намагається дати зручний огляд. Щоб отримати повну інформацію, зверніться до документації для Python 3.0 та/або багатьох PEP, на які посилаються в тексті. Якщо ви хочете зрозуміти повну реалізацію та обґрунтування розробки певної функції, PEP зазвичай містять більше деталей, ніж звичайна документація; але зауважте, що PEP зазвичай не оновлюються після повного впровадження функції.

Через обмеження часу цей документ не такий повний, як мав би бути. Як завжди для нових випусків, файл `Misc/NEWS` у вихідному дистрибутиві містить велику кількість детальної інформації про кожну дрібницю, яку було змінено.

## Поширені камені спотикання

У цьому розділі перераховано ті кілька змін, які, швидше за все, вас збентежать, якщо ви звикли до Python 2.5.

### Друк — це функція

Інструкцію `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 і є таким же ефективним).

- Also, the `dict.iterkeys()`, `dict.iteritems()` and `dict.itervalues()` methods are no longer supported.

- `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()` now behaves like `xrange()` used to behave, except it works with values of arbitrary size. The latter no longer exists.

- `zip()` тепер повертає ітератор.

### Упорядкування порівнянь

Python 3.0 спростив правила впорядкування порівнянь:

- Оператори порівняння порядку (`<`, `<=`, `> =`, `>`) викликають виняток TypeError, коли операнди не мають значущого природного порядку. Таким чином, такі вирази, як `1 < ''`, `0 > None` або `len <= len` більше не є дійсними, і, наприклад, `None < None` викликає `TypeError` замість повернення `False`. Як наслідок, сортування гетерогенного списку більше не має сенсу — усі елементи мають бути порівнюваними між собою. Зауважте, що це не стосується операторів `==` і `!=`: об’єкти різних непорівнюваних типів завжди порівнюються нерівномірно.

- `sorted()` and `list.sort()` no longer accept the cmp argument providing a comparison function. Use the key argument instead. N.B. the key and reverse arguments are now «keyword-only».

- The `cmp()` function should be treated as gone, and the `__cmp__()` special method is no longer supported. Use `__lt__()` for sorting, `__eq__()` with `__hash__()`, and other rich comparisons as needed. (If you really need the `cmp()` functionality, you could use the expression `(a > b) - (a < b)` as the equivalent for `cmp(a, b)`.)

### Цілі числа

- PEP 237: Essentially, `long` renamed to `int`. That is, there is only one built-in integral type, named `int`; but it behaves mostly like the old `long` type.

- PEP 238: Вираз на кшталт `1/2` повертає число з плаваючою точкою. Використовуйте `1//2`, щоб отримати режим скорочення. (Останній синтаксис існував роками, принаймні з Python 2.2.)

- The `sys.maxint` constant was removed, since there is no longer a limit to the value of integers. However, `sys.maxsize` can be used as an integer larger than any practical list or string index. It conforms to the implementation’s «natural» integer size and is typically the same as `sys.maxint` in previous releases on the same platform (assuming the same build options).

- `repr()` довгого цілого числа більше не включає завершальний `L`, тому код, який беззастережно видаляє цей символ, замість цього відсікає останню цифру. (Натомість використовуйте `str()`.)

- Вісімкові літерали більше не мають форми `0720`; замість цього використовуйте `0o720`.

### Текст Vs. Дані замість Unicode Vs. 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. Ця ціннісна поведінка викликала багато сумних облич протягом багатьох років.

- As a consequence of this change in philosophy, pretty much all code that uses Unicode, encodings or binary data most likely has to change. The change is for the better, as in the 2.x world there were numerous bugs having to do with mixing encoded and unencoded text. To be prepared in Python 2.x, start using `unicode` for all unencoded text, and `str` for binary or encoded data only. Then the `2to3` tool will do most of the work for you.

- Ви більше не можете використовувати літерали `u"..."` для тексту Unicode. Однак ви повинні використовувати літерали `b"..."` для двійкових даних.

- Оскільки типи `str` і `bytes` не можна змішувати, ви завжди повинні явно конвертувати між ними. Використовуйте `str.encode()` для переходу від `str` до `bytes` і `bytes.decode()` для переходу від `bytes` до `str`. Ви також можете використовувати `bytes(s, encoding=...)` та `str(b, encoding=...)` відповідно.

- Like `str`, the `bytes` type is immutable. There is a separate mutable type to hold buffered binary data, `bytearray`. Nearly all APIs that accept `bytes` also accept `bytearray`. The mutable API is based on `collections.MutableSequence`.

- Усі зворотні косі риски в необроблених рядкових літералах інтерпретуються буквально. Це означає, що екранування `'\U'` і `'\u'` у необроблених рядках не обробляються спеціально. Наприклад, `r'\u20ac` — це рядок із 6 символів у Python 3.0, тоді як у 2.6 `ur'\u20ac` був одним символом «євро». (Звичайно, ця зміна стосується лише необроблених рядкових літералів; у Python 3.0 символом євро є `'\u20ac'`.)

- The built-in `basestring` abstract type was removed. Use `str` instead. The `str` and `bytes` types don’t have functionality enough in common to warrant a shared base class. The `2to3` tool (see below) replaces every occurrence of `basestring` with `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 імена файлів зберігаються у форматі Юнікод.) Як обхідний шлях, більшість 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. Однак у стандарті Юнікод він все ще уникає контрольних символів і кодових точок зі статусом «недрукований».

- PEP 3120: Стандартне кодування джерела тепер UTF-8.

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

- The `StringIO` and `cStringIO` modules are gone. Instead, import the `io` module and use `io.StringIO` or `io.BytesIO` for text and data respectively.

- Дивіться також Юнікод HOWTO, який було оновлено для Python 3.0.

## Огляд змін синтаксису

У цьому розділі подано короткий огляд усіх синтаксичних змін у Python 3.0.

### Новий синтаксис

- PEP 3107: Function argument and return value annotations. This provides a standardized way of annotating a function’s parameters and return value. There are no semantics attached to such annotations except that they can be introspected at runtime using the `__annotations__` attribute. The intent is to encourage experimentation through metaclasses, decorators or frameworks.

- 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 [з 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):
          ...

  The module-global `__metaclass__` variable is no longer supported. (It was a crutch to make it easier to default to new-style classes without deriving every class from `object`.)

- Розуміння списків більше не підтримує синтаксичну форму `[... для var в item1, item2, ...]`. Замість цього використовуйте `[... для var в (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)

- Класичні заняття зникли.

## Зміни вже присутні в Python 2.6

Оскільки багато користувачів, ймовірно, переходять прямо з Python 2.5 на Python 3.0, цей розділ нагадує читачеві про нові функції, які спочатку були розроблені для Python 3.0, але які були перенесені на Python 2.6. Додаткові описи можна знайти у відповідних розділах Що нового в Python 2.6.

- PEP 343: оператор «з».. Оператор `with` тепер є стандартною функцією, і його більше не потрібно імпортувати з `__future__`. Також перегляньте Написання менеджерів контексту і Модуль contextlib.

- PEP 366: Явний відносний імпорт із основного модуля. Це підвищує корисність опції `-m`, коли модуль, на який посилається, живе в пакеті.

- PEP 370: каталог site-packages для кожного користувача.

- PEP 371: Пакет multiprocessing.

- PEP 3101: Розширене форматування рядків. Примітка: в описі 2.6 згадується метод `format()` як для 8-бітних рядків, так і для рядків Unicode. У версії 3.0 тільки тип `str` (текстові рядки з підтримкою Unicode) підтримує цей метод; тип `bytes` не має. План полягає в тому, щоб згодом зробити це єдиним API для форматування рядків і почати не підтримувати оператор `%` у Python 3.1.

- PEP 3105: друк як функція. Тепер це стандартна функція, і її більше не потрібно імпортувати з `__future__`. Детальніше було наведено вище.

- PEP 3110: Зміни обробки винятків. Синтаксис `except` exc `as` var тепер є стандартним, а `except` exc, var більше не підтримується. (Звичайно, частина `as` var все ще необов’язкова.)

- PEP 3112: Байтові літерали. Нотація рядкового літералу `b"..."` (і його варіанти, такі як `b'...'`, `b"""..."""` і `br" ..."`) тепер створює літерал типу `bytes`.

- PEP 3116: Нова бібліотека введення-виведення. The `io` module is now the standard way of doing file I/O. The built-in `open()` function is now an alias for `io.open()` and has additional keyword arguments encoding, errors, newline and closefd. Also note that an invalid mode argument now raises `ValueError`, not `IOError`. The binary file object underlying a text file object can be accessed as `f.buffer` (but beware that the text object maintains a buffer of itself in order to speed up the encoding and decoding operations).

- PEP 3118: Переглянутий буферний протокол. The old builtin `buffer()` is now really gone; the new builtin `memoryview()` provides (mostly) similar functionality.

- PEP 3119: Абстрактні базові класи. The `abc` module and the ABCs defined in the `collections` module plays a somewhat more prominent role in the language now, and built-in collection types like `dict` and `list` conform to the `collections.MutableMapping` and `collections.MutableSequence` ABCs, respectively.

- PEP 3127: Підтримка цілочисельного літералу та синтаксис. Як згадувалося вище, нова нотація вісімкових літералів є єдиною, що підтримується, і додано двійкові літерали.

- PEP 3129: Декоратори класу.

- PEP 3141: Ієрархія типів чисел. Модуль `numbers` є ще одним новим використанням ABC, що визначає «числову вежу» Python. Також зверніть увагу на новий модуль `fractions`, який реалізує `numbers.Rational`.

## Зміни бібліотеки

Через обмеження часу цей документ не вичерпно охоплює дуже великі зміни стандартної бібліотеки. PEP 3108 є посиланням на основні зміни в бібліотеці. Ось огляд капсули:

- Many old modules were removed. Some, like `gopherlib` (no longer used) and `md5` (replaced by `hashlib`), were already deprecated by PEP 4. Others were removed as a result of the removal of support for various platforms such as Irix, BeOS and Mac OS 9 (see PEP 11). Some modules were also selected for removal in Python 3.0 due to lack of use or because a better replacement exists. See PEP 3108 for an exhaustive list.

- The `bsddb3` package was removed because its presence in the core standard library has proved over time to be a particular burden for the core developers due to testing instability and Berkeley DB’s release schedule. However, the package is alive and well, externally maintained at https://www.jcea.es/programacion/pybsddb.htm.

- Деякі модулі були перейменовані через те, що їхня стара назва не відповідала PEP 8, або з інших причин. Ось список:

  Стара назва | Нова назва
  --- | ---
  _winreg | winreg
  ConfigParser | аналізатор конфігурації
  copy_reg | copyreg
  Чергу | чергу
  SocketServer | сокетсервер
  база розмітки | _markupbase
  репр | reprlib
  test.test_support | test.support

- A common pattern in Python 2.x is to have one version of a module implemented in pure Python, with an optional accelerated version implemented as a C extension; for example, `pickle` and `cPickle`. This places the burden of importing the accelerated version and falling back on the pure Python version on each user of these modules. In Python 3.0, the accelerated versions are considered implementation details of the pure Python versions. Users should always import the standard version, which attempts to import the accelerated version and falls back to the pure Python version. The `pickle` / `cPickle` pair received this treatment. The `profile` module is on the list for 3.1. The `StringIO` module has been turned into a class in the `io` module.

- Деякі пов’язані модулі були згруповані в пакети, і зазвичай назви підмодулів були спрощені. Отримані нові пакети:

  - `dbm` (`anydbm`, `dbhash`, `dbm`, `dumbdbm`, `gdbm`, `whichdb`).

  - `html` (`HTMLParser`, `htmlentitydefs`).

  - `http` (`httplib`, `BaseHTTPServer`, `CGIHTTPServer`, `SimpleHTTPServer`, `Cookie`, `cookielib`).

  - `tkinter` (all `Tkinter`-related modules except `turtle`). The target audience of `turtle` doesn’t really care about `tkinter`. Also note that as of Python 2.6, the functionality of `turtle` has been greatly enhanced.

  - `urllib` (`urllib`, `urllib2`, `urlparse`, `robotparse`).

  - `xmlrpc` (`xmlrpclib`, `DocXMLRPCServer`, `SimpleXMLRPCServer`).

Деякі інші зміни до модулів стандартної бібліотеки, не охоплені PEP 3108:

- Killed `sets`. Use the built-in `set()` class.

- Cleanup of the `sys` module: removed `sys.exitfunc()`, `sys.exc_clear()`, `sys.exc_type`, `sys.exc_value`, `sys.exc_traceback`. (Note that `sys.last_type` etc. remain.)

- Cleanup of the `array.array` type: the `read()` and `write()` methods are gone; use `fromfile()` and `tofile()` instead. Also, the `'c'` typecode for array is gone – use either `'b'` for bytes or `'u'` for Unicode characters.

- Cleanup of the `operator` module: removed `sequenceIncludes()` and `isCallable()`.

- Cleanup of the `thread` module: `acquire_lock()` and `release_lock()` are gone; use `acquire()` and `release()` instead.

- Cleanup of the `random` module: removed the `jumpahead()` API.

- The `new` module is gone.

- The functions `os.tmpnam()`, `os.tempnam()` and `os.tmpfile()` have been removed in favor of the `tempfile` module.

- Модуль `tokenize` змінено для роботи з байтами. Головною точкою входу тепер є `tokenize.tokenize()` замість generate_tokens.

- `string.letters` and its friends (`string.lowercase` and `string.uppercase`) are gone. Use `string.ascii_letters` etc. instead. (The reason for the removal is that `string.letters` and friends had locale-specific behavior, which is a bad idea for such attractively named global «constants».)

- Renamed module `__builtin__` to `builtins` (removing the underscores, adding an „s“). The `__builtins__` variable found in most global namespaces is unchanged. To modify a builtin, you should use `builtins`, not `__builtins__`!

## PEP 3101: Новий підхід до форматування рядків

- Нова система для вбудованих операцій форматування рядка замінює оператор форматування рядка `%`. (Однак оператор `%` все ще підтримується; він буде застарілим у Python 3.1 і пізніше буде видалено з мови.) Прочитайте PEP 3101, щоб отримати повну інформацію.

## Зміни винятків

Було очищено API для виклику та перехоплення винятків і додано нові потужні функції:

- PEP 352: усі винятки мають бути отримані (прямо чи опосередковано) з `BaseException`. Це корінь ієрархії винятків. Це не нова рекомендація, але вимога для успадкування від `BaseException` є новою. (Python 2.6 все ще дозволяв створювати класичні класи та не накладав обмежень на те, що ви можете перехопити.) Як наслідок, виключення рядків остаточно по-справжньому й повністю мертві.

- Майже всі винятки насправді мають походити від `Exception`; `BaseException` слід використовувати лише як базовий клас для винятків, які слід обробляти лише на верхньому рівні, наприклад `SystemExit` або `KeyboardInterrupt`. Рекомендована ідіома для обробки всіх винятків, крім цієї останньої категорії, полягає в використанні `except` `Exception`.

- `StandardError` was removed.

- Exceptions no longer behave as sequences. Use the `args` attribute instead.

- PEP 3109: Raising exceptions. You must now use `raise Exception(args)` instead of `raise Exception, args`. Additionally, you can no longer explicitly specify a traceback; instead, if you have to do this, you can assign directly to the `__traceback__` attribute (see below).

- PEP 3110: Перехоплення винятків. Тепер ви повинні використовувати `крім SomeException як variable` замість `крім SomeException, variable`. Крім того, змінна явно видаляється, коли залишається блок `except`.

- PEP 3134: Exception chaining. There are two cases: implicit chaining and explicit chaining. Implicit chaining happens when an exception is raised in an `except` or `finally` handler block. This usually happens due to a bug in the handler block; we call this a secondary exception. In this case, the original exception (that was being handled) is saved as the `__context__` attribute of the secondary exception. Explicit chaining is invoked with this syntax:

      raise SecondaryException() from primary_exception

  (where primary_exception is any expression that produces an exception object, probably an exception that was previously caught). In this case, the primary exception is stored on the `__cause__` attribute of the secondary exception. The traceback printed when an unhandled exception occurs walks the chain of `__cause__` and `__context__` attributes and prints a separate traceback for each component of the chain, with the primary exception at the top. (Java users may recognize this behavior.)

- PEP 3134: Exception objects now store their traceback as the `__traceback__` attribute. This means that an exception object now contains all the information pertaining to an exception, and there are fewer reasons to use `sys.exc_info()` (though the latter is not removed).

- Покращено кілька повідомлень про винятки, коли Windows не вдається завантажити модуль розширення. Наприклад, `код помилки 193` тепер `%1 не є дійсною програмою Win32`. Рядки тепер мають справу з неанглійськими локалями.

## Інші інші зміни

### Оператори та спеціальні методи

- `!=` тепер повертає протилежність `==`, якщо `==` не повертає `NotImplemented`.

- Поняття «незв’язаних методів» було видалено з мови. Посилаючись на метод як на атрибут класу, тепер ви отримуєте звичайний об’єкт функції.

- `__getslice__()`, `__setslice__()` and `__delslice__()` were killed. The syntax `a[i:j]` now translates to `a.__getitem__(slice(i, j))` (or `__setitem__()` or `__delitem__()`, when used as an assignment or deletion target, respectively).

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

- The `__oct__()` and `__hex__()` special methods are removed – `oct()` and `hex()` use `__index__()` now to convert the argument to an integer.

- Removed support for `__members__` and `__methods__`.

- The function attributes named `func_X` have been renamed to use the `__X__` form, freeing up these names in the function attribute namespace for user-defined attributes. To wit, `func_closure`, `func_code`, `func_defaults`, `func_dict`, `func_doc`, `func_globals`, `func_name` were renamed to `__closure__`, `__code__`, `__defaults__`, `__dict__`, `__doc__`, `__globals__`, `__name__`, respectively.

- `__nonzero__()` is now `__bool__()`.

### Вбудовані

- PEP 3135: Нове `super()`. Тепер ви можете викликати `super()` без аргументів і (припускаючи, що це в звичайному методі екземпляра, визначеному всередині оператора `class`) правильний клас і екземпляр будуть вибрані автоматично. З аргументами поведінка `super()` не змінюється.

- PEP 3111: `raw_input()` was renamed to `input()`. That is, the new `input()` function reads a line from `sys.stdin` and returns it with the trailing newline stripped. It raises `EOFError` if the input is terminated prematurely. To get the old behavior of `input()`, use `eval(input())`.

- Додано нову вбудовану функцію `next()` для виклику методу `__next__()` для об’єкта.

- Змінено стратегію округлення функції `round()` і тип повернення. Точні половинні випадки тепер округлюються до найближчого парного результату замість нуля. (Наприклад, `round(2.5)` тепер повертає `2`, а не `3`.) `round(x[, n])` тепер делегує `x.__round__([ n])` замість того, щоб завжди повертати число з плаваючою точкою. Зазвичай він повертає ціле число, якщо викликається з одним аргументом, і значення того самого типу, що й `x`, коли викликається з двома аргументами.

- Moved `intern()` to `sys.intern()`.

- Removed: `apply()`. Instead of `apply(f, args)` use `f(*args)`.

- Removed `callable()`. Instead of `callable(f)` you can use `isinstance(f, collections.Callable)`. The `operator.isCallable()` function is also gone.

- Removed `coerce()`. This function no longer serves a purpose now that classic classes are gone.

- Removed `execfile()`. Instead of `execfile(fn)` use `exec(open(fn).read())`.

- Removed the `file` type. Use `open()`. There are now several different kinds of streams that open can return in the `io` module.

- Removed `reduce()`. Use `functools.reduce()` if you really need it; however, 99 percent of the time an explicit `for` loop is more readable.

- Removed `reload()`. Use `imp.reload()`.

- Removed. `dict.has_key()` – use the `in` operator instead.

## Зміни збірки та C API

Через обмеження часу ось дуже неповний список змін до C API.

- Було припинено підтримку кількох платформ, зокрема Mac OS 9, BeOS, RISCOS, Irix і Tru64.

- PEP 3118: Новий API буфера.

- PEP 3121: Ініціалізація та завершення модуля розширення.

- PEP 3123: Приведення `PyObject_HEAD` до стандарту C.

- Більше немає підтримки C API для обмеженого виконання.

- `PyNumber_Coerce()`, `PyNumber_CoerceEx()`, `PyMember_Get()`, and `PyMember_Set()` C APIs are removed.

- New C API `PyImport_ImportModuleNoBlock()`, works like `PyImport_ImportModule()` but won’t block on the import lock (returning an error instead).

- Перейменовано слот і метод логічного перетворення C-рівня: `nb_nonzero` тепер `nb_bool`.

- Removed `METH_OLDARGS` and `WITH_CYCLE_GC` from the C API.

## Продуктивність

Кінцевим результатом узагальнень 3.0 є те, що Python 3.0 виконує тест pystone приблизно на 10% повільніше, ніж Python 2.5. Швидше за все, найбільшою причиною є видалення спеціального регістра для малих цілих чисел. Є місце для вдосконалення, але це станеться після випуску 3.0!

## Перенесення на Python 3.0

Для перенесення існуючого вихідного коду Python 2.5 або 2.6 на Python 3.0 найкраща стратегія така:

0. (Обов’язкова умова:) Почніть із чудового тестового покриття.

1. Порт на Python 2.6. Це повинно бути не більше роботи, ніж середнє перенесення з Python 2.x на Python 2. (x+1). Переконайтеся, що всі ваші тести пройдені.

2. (Досі використовується 2.6:) Увімкніть перемикач командного рядка `-3`. Це вмикає попередження про функції, які буде видалено (або змінено) у версії 3.0. Знову запустіть набір тестів і виправте код, про який ви отримуєте попередження, доки попередження не зникнуть, і всі ваші тести все одно пройдуть.

3. Run the `2to3` source-to-source translator over your source code tree. Run the result of the translation under Python 3.0. Manually fix up any remaining issues, fixing problems until all tests pass again.

Не рекомендується намагатися написати вихідний код, який працює без змін під Python 2.6 і 3.0; вам доведеться використовувати дуже спотворений стиль кодування, напр. уникнення операторів `print`, метакласів і багато іншого. Якщо ви підтримуєте бібліотеку, яка має підтримувати як Python 2.6, так і Python 3.0, найкращим підходом є змінити крок 3 вище, відредагувавши версію вихідного коду 2.6 і знову запустивши перекладач `2to3` замість редагування Версія вихідного коду 3.0.

Для перенесення розширень C на Python 3.0 див. Перенесення модулів розширення на Python 3.