> **Источник:** https://python-all.ru/3.2/whatsnew/2.6.html
>
> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.

---

# Что нового в Python 2.6

| Автор: | А. М. Кухлинг (amk at amk.ca) |
| --- | --- |

В этой статье описываются новые возможности Python 2.6, выпущенного 1 октября 2008 года. График выпуска описан в [**PEP 361**](https://python-all.ru/3.2/whatsnew/2.6.html).

Главная тема Python 2.6 – подготовка путей миграции на Python 3.0, где язык был существенно переработан. Там, где это возможно, Python 2.6 включает новые возможности и синтаксис из 3.0, оставаясь при этом совместимым с существующим кодом – старые возможности и синтаксис не удаляются. Когда сделать это невозможно, Python 2.6 старается помочь: он добавляет функции совместимости в модуле `future_builtins` и ключ *-3*, который предупреждает об использовании конструкций, ставших недопустимыми в 3.0.

В стандартную библиотеку добавлено несколько значимых новых пакетов, например модули [`multiprocessing`](https://python-all.ru/3.2/library/multiprocessing.html#module-multiprocessing) и [`json`](https://python-all.ru/3.2/library/json.html#module-json), однако новых возможностей, не связанных с Python 3.0, не так много.

Python 2.6 также содержит ряд улучшений и исправлений ошибок по всему исходному коду. Поиск по журналам изменений показывает, что между Python 2.5 и 2.6 было применено 259 патчей и исправлено 612 ошибок. Обе цифры, вероятно, занижены.

Эта статья не пытается дать полную спецификацию новых возможностей, а вместо этого предоставляет удобный обзор. За подробностями обращайтесь к документации Python 2.6. Если вы хотите понять обоснование дизайна и реализации, обратитесь к PEP для конкретной новой возможности. По возможности «Что нового в Python» ссылается на элемент ошибки/патча для каждого изменения.

## Python 3.0

Цикл разработки версий Python 2.6 и 3.0 был синхронизирован: альфа- и бета-релизы для обеих версий выходили в одни и те же дни. Разработка версии 3.0 повлияла на многие возможности в версии 2.6.

Python 3.0 – это масштабное перепроектирование Python, которое нарушает совместимость с серией 2.x. Это означает, что существующий код Python потребует некоторой конвертации, чтобы работать на Python 3.0. Однако не все изменения в 3.0 обязательно нарушают совместимость. В тех случаях, когда новые возможности не приводят к нарушению существующего кода, они были перенесены в 2.6 и описаны в этом документе в соответствующих разделах. Некоторые из возможностей, заимствованных из 3.0:

- Метод [`__complex__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__complex__) для преобразования объектов в комплексное число.
- Альтернативный синтаксис перехвата исключений: `except TypeError as exc`.
- Добавление [`functools.reduce()`](https://python-all.ru/3.2/library/functools.html#functools.reduce) как синонима встроенной функции `reduce()`.

В Python 3.0 появилось несколько новых встроенных функций, а у некоторых существующих изменилась семантика. Функции, которые являются новыми в 3.0, например [`bin()`](https://python-all.ru/3.2/library/functions.html#bin), просто добавлены в Python 2.6, а существующие встроенные функции не менялись; вместо этого в модуле `future_builtins` представлены версии с новой семантикой из 3.0. Код, написанный с прицелом на совместимость с 3.0, может при необходимости использовать `from future_builtins import hex, map`.

Новый ключ командной строки *-3* включает предупреждения об особенностях, которые будут удалены в Python 3.0. Запустив код с этим ключом, можно оценить, сколько работы потребуется для переноса кода на 3.0. Значение этого ключа доступно в коде Python как логическая переменная `sys.py3kwarning`, а в C-расширениях – как `Py_Py3kWarningFlag`.

> **См. также**
>
> Серия PEP 3xxx, содержащая предложения для Python 3.0. [**PEP 3000**](https://python-all.ru/3.2/whatsnew/2.6.html) описывает процесс разработки Python 3.0. Начните с [**PEP 3100**](https://python-all.ru/3.2/whatsnew/2.6.html), который описывает общие цели Python 3.0, а затем изучите PEP с более высокими номерами, предлагающие конкретные функции.

## Изменения в процессе разработки

Во время разработки 2.6 процесс разработки Python претерпел два существенных изменения: мы перешли с системы отслеживания ошибок SourceForge на настраиваемую установку Roundup, а документация была преобразована из LaTeX в reStructuredText.

### Новая система отслеживания ошибок: Roundup

Долгое время разработчики Python были всё более недовольны системой отслеживания ошибок SourceForge. Решение SourceForge, предоставляемое как услуга, не допускает значительной настройки; например, невозможно было настроить жизненный цикл задач.

Поэтому комитет по инфраструктуре Python Software Foundation объявил конкурс на системы отслеживания ошибок, попросив добровольцев настроить различные продукты и импортировать некоторые ошибки и патчи из SourceForge. Были рассмотрены четыре различные системы: [Jira](https://python-all.ru/3.2/whatsnew/2.6.html), [Launchpad](https://python-all.ru/3.2/whatsnew/2.6.html), [Roundup](https://python-all.ru/3.2/whatsnew/2.6.html) и [Trac](https://python-all.ru/3.2/whatsnew/2.6.html). В конечном итоге комитет остановился на Jira и Roundup как на двух кандидатах. Jira – коммерческий продукт, который бесплатно предоставляет размещённые экземпляры для проектов свободного программного обеспечения; Roundup – проект с открытым исходным кодом, требующий добровольцев для его администрирования и сервера для его размещения.

После публикации призыва добровольцев новая установка Roundup была развернута на [http://bugs.python.org](https://python-all.ru/3.2/whatsnew/2.6.html). Одна установка Roundup может обслуживать несколько трекеров, и этот сервер теперь также размещает трекеры задач для Jython и веб-сайта Python. В будущем он, безусловно, найдет и другие применения. Там, где это возможно, в этом выпуске «Что нового в Python» приводятся ссылки на соответствующие элементы ошибок/патчей для каждого изменения.

Хостинг для системы отслеживания ошибок Python любезно предоставлен [Upfront Systems](https://python-all.ru/3.2/whatsnew/2.6.html) из Стелленбоша, Южная Африка. Мартин фон Лёвис приложил большие усилия для импорта существующих ошибок и патчей из SourceForge; его скрипты для этой операции импорта находятся по адресу [http://svn.python.org/view/tracker/importer/](https://python-all.ru/3.2/whatsnew/2.6.html) и могут быть полезны другим проектам, желающим перейти с SourceForge на Roundup.

> **См. также**
>
> **[http://bugs.python.org](https://python-all.ru/3.2/whatsnew/2.6.html)**
>
> Система отслеживания ошибок Python.
>
> **[http://bugs.jython.org](https://python-all.ru/3.2/whatsnew/2.6.html):**
>
> Система отслеживания ошибок Jython.
>
> **[http://roundup.sourceforge.net/](https://python-all.ru/3.2/whatsnew/2.6.html)**
>
> Загрузки и документация Roundup.
>
> **[http://svn.python.org/view/tracker/importer/](https://python-all.ru/3.2/whatsnew/2.6.html)**
>
> Сценарии преобразования Мартина фон Лёвиса.

### Новый формат документации: reStructuredText с использованием Sphinx

Документация Python писалась с использованием LaTeX с момента запуска проекта около 1989 года. В 1980-х и начале 1990-х большинство документации распечатывалось для последующего изучения, а не просматривалось онлайн. LaTeX широко использовался, поскольку он обеспечивал привлекательный печатный вывод, оставаясь при этом простым в написании после освоения основных правил разметки.

Сегодня LaTeX всё ещё используется для написания публикаций, предназначенных для печати, но ландшафт инструментов программирования изменился. Мы больше не распечатываем кипы документации; вместо этого мы просматриваем её онлайн, и HTML стал самым важным форматом для поддержки. К сожалению, конвертация LaTeX в HTML довольно сложна, и Фред Л. Дрейк-младший, многолетний редактор документации Python, потратил много времени на поддержание процесса конвертации. Время от времени предлагали перевести документацию в SGML, а затем в XML, но выполнить хорошую конвертацию – большая задача, и никто не взял на себя необходимое для завершения работы время.

В ходе цикла разработки 2.6 Георг Брандль вложил много усилий в создание нового инструментария для обработки документации. Получившийся пакет называется Sphinx и доступен по адресу [http://sphinx.pocoo.org/](https://python-all.ru/3.2/whatsnew/2.6.html).

Sphinx ориентируется на вывод HTML, создавая привлекательно оформленный и современный HTML; печатный вывод по-прежнему поддерживается через конвертацию в LaTeX. Входной формат – reStructuredText, синтаксис разметки с поддержкой пользовательских расширений и директив, широко используемый в сообществе Python.

Sphinx – это самостоятельный пакет, который можно использовать для написания документации, и почти два десятка других проектов ([перечислены на веб-сайте Sphinx](https://python-all.ru/3.2/whatsnew/2.6.html)) приняли Sphinx в качестве своего инструмента документирования.

> **См. также**
>
> **[Документирование Python](https://python-all.ru/3.2/devguide/documenting.html)**
>
> Описывает, как писать документацию для Python.
>
> **[Sphinx](https://python-all.ru/3.2/whatsnew/2.6.html)**
>
> Документация и код для инструментария Sphinx.
>
> **[Docutils](https://python-all.ru/3.2/whatsnew/2.6.html)**
>
> Базовый парсер reStructuredText и набор инструментов.

## PEP 343: Оператор ‘with’

В предыдущей версии, Python 2.5, оператор ‘[`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with)‘ был добавлен как опциональная возможность, включаемая директивой `from __future__ import with_statement`. В версии 2.6 этот оператор больше не требует специального включения, то есть [`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with) теперь всегда является ключевым словом. Остальная часть раздела представляет собой копию соответствующего раздела из документа «Что нового в Python 2.5»; если вы знакомы с оператором ‘[`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with)‘ из Python 2.5, этот раздел можно пропустить.

Инструкция ‘[`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with)‘ делает код понятнее: ранее для гарантии выполнения кода очистки приходилось использовать блоки `try...finally`. В этом разделе я расскажу о том, как обычно используется эта инструкция. В следующем разделе я рассмотрю детали реализации и покажу, как создавать объекты для работы с этой инструкцией.

Оператор ‘[`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with)‘ – это управляющая конструкция, имеющая следующую базовую структуру:

```python
with expression [as variable]:
    with-block
```

Выражение вычисляется, и в результате должен получиться объект, поддерживающий протокол управления контекстом (то есть имеющий методы [`__enter__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__enter__) и [`__exit__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__exit__)).

Метод [`__enter__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__enter__) объекта вызывается до выполнения *блока with* и, следовательно, может выполнить код настройки. Он также может возвращать значение, которое при наличии *переменной* привязывается к этому имени. (Обратите внимание: *variable* – это *не* результат вычисления *expression*.)

После завершения выполнения *блока with* вызывается метод [`__exit__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__exit__) объекта, даже если блок возбудил исключение, и поэтому может выполнить код очистки.

Некоторые стандартные объекты Python теперь поддерживают протокол управления контекстом и могут использоваться с инструкцией ‘[`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with)‘. Файловые объекты – один из примеров:

```python
with open('/etc/passwd', 'r') as f:
    for line in f:
        print line
        ... more processing code ...
```

После выполнения этой инструкции файловый объект *f* будет автоматически закрыт, даже если цикл [`for`](https://python-all.ru/3.2/reference/compound_stmts.html#for) возбудил исключение где-то посередине блока.

> **Примечание**
>
> В этом случае *f* – это тот же объект, созданный [`open()`](https://python-all.ru/3.2/library/functions.html#open), поскольку `file.__enter__()` возвращает *self*.

Блокировки и переменные условия модуля [`threading`](https://python-all.ru/3.2/library/threading.html#module-threading) также поддерживают инструкцию ‘[`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with)‘:

```python
lock = threading.Lock()
with lock:
    # Критическая секция кода
    ...
```

Блокировка захватывается перед выполнением блока и всегда освобождается после завершения блока.

Функция `localcontext()` в модуле [`decimal`](https://python-all.ru/3.2/library/decimal.html#module-decimal) упрощает сохранение и восстановление текущего десятичного контекста, который задаёт желаемую точность и правила округления для вычислений:

```python
from decimal import Decimal, Context, localcontext

# Отображается с точностью по умолчанию в 28 знаков
v = Decimal('578')
print v.sqrt()

with localcontext(Context(prec=16)):
    # Весь код в этом блоке использует точность в 16 знаков.
    # Исходный контекст восстанавливается при выходе из блока.
    print v.sqrt()
```

### Написание контекстных менеджеров

Внутреннее устройство инструкции ‘[`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with)‘ довольно сложное. Большинство людей будут использовать ‘[`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with)‘ только вместе с существующими объектами и не нуждаются в знании этих деталей, поэтому можно пропустить остальную часть этого раздела, если захочется. Авторам новых объектов потребуется разобраться в деталях реализации и стоит продолжить чтение.

Объяснение протокола управления контекстом на высоком уровне:

- Выражение вычисляется и должно дать объект, называемый «менеджер контекста». Менеджер контекста должен иметь методы [`__enter__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__enter__) и [`__exit__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__exit__).
- Вызывается метод [`__enter__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__enter__) менеджера контекста. Возвращённое значение присваивается *VAR*. Если конструкция `as VAR` отсутствует, значение просто игнорируется.
- Код внутри *блока* выполняется.
- Если *BLOCK* вызывает исключение, метод [`__exit__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__exit__) менеджера контекста вызывается с тремя аргументами – информацией об исключении (`type, value, traceback` – те же значения, что возвращает [`sys.exc_info()`](https://python-all.ru/3.2/library/sys.html#sys.exc_info), а если исключения не было – `None`). Возвращаемое значение метода определяет, будет ли исключение возбуждено повторно: любое ложное значение повторно возбуждает исключение, а `True` – подавляет его. Подавлять исключение приходится крайне редко, потому что иначе автор кода, содержащего оператор ‘[`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with)‘, никогда не узнает, что что-то пошло не так.
- Если *BLOCK* не возбудил исключение, метод [`__exit__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__exit__) всё равно вызывается, но *type*, *value* и *traceback* равны `None`.

Рассмотрим пример. Мы не будем приводить подробный код, а лишь в общих чертах опишем методы, необходимые для базы данных, поддерживающей транзакции.

(Для тех, кто не знаком с терминологией баз данных: набор изменений в базе данных группируется в транзакцию. Транзакции могут быть либо зафиксированы (committed) – это означает, что все изменения записаны в базу данных, либо откачены (rolled back) – что означает, что все изменения отменены, а база данных не изменена. За дополнительной информацией обращайтесь к любому учебнику по базам данных.)

Предположим, что существует объект, представляющий подключение к базе данных. Наша цель – позволить пользователю написать такой код:

```python
db_connection = DatabaseConnection()
with db_connection as cursor:
    cursor.execute('insert into ...')
    cursor.execute('delete from ...')
    # ... дополнительные операции ...
```

Транзакция должна быть зафиксирована, если код в блоке выполняется без ошибок, или откатана при возникновении исключения. Вот базовый интерфейс для `DatabaseConnection`, который я буду предполагать:

```python
class DatabaseConnection:
    # Интерфейс базы данных
    def cursor(self):
        "Returns a cursor object and starts a new transaction"
    def commit(self):
        "Commits current transaction"
    def rollback(self):
        "Rolls back current transaction"
```

Метод [`__enter__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__enter__) довольно прост: ему нужно только начать новую транзакцию. Для данного приложения результирующий объект курсора был бы полезен, поэтому метод будет возвращать его. Затем пользователь может добавить `as cursor` в свою инструкцию ‘[`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with)‘, чтобы привязать курсор к имени переменной.

```python
class DatabaseConnection:
    ...
    def __enter__(self):
        # Код для запуска новой транзакции
        cursor = self.cursor()
        return cursor
```

Метод [`__exit__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__exit__) самый сложный, потому что в нём должна выполняться основная работа. Метод должен проверить, произошло ли исключение. Если исключения не было, транзакция фиксируется. Если было исключение, транзакция откатывается.

В приведённом ниже коде выполнение просто дойдёт до конца функции, вернув значение по умолчанию `None`. `None` – ложное значение, поэтому исключение будет автоматически возбуждено повторно. При желании можно сделать это явнее и добавить оператор [`return`](https://python-all.ru/3.2/reference/simple_stmts.html#return) в отмеченном месте.

```python
class DatabaseConnection:
    ...
    def __exit__(self, type, value, tb):
        if tb is None:
            # Исключения нет, поэтому фиксация
            self.commit()
        else:
            # Произошло исключение, поэтому откат
            self.rollback()
            # return False
```

### Модуль contextlib

Модуль [`contextlib`](https://python-all.ru/3.2/library/contextlib.html#module-contextlib) предоставляет несколько функций и декоратор, которые полезны при написании объектов для использования с оператором '[`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with)'.

Декоратор называется `contextmanager()` и позволяет написать одну функцию-генератор вместо определения нового класса. Генератор должен выдать ровно одно значение. Код до [`yield`](https://python-all.ru/3.2/reference/simple_stmts.html#yield) выполняется как метод [`__enter__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__enter__), а возвращаемое значение yield становится значением, которое будет связано с переменной в предложении [`as`](https://python-all.ru/3.2/reference/compound_stmts.html#with) оператора ‘[`with`](https://python-all.ru/3.2/reference/compound_stmts.html#as)‘ (если оно есть). Код после [`yield`](https://python-all.ru/3.2/reference/simple_stmts.html#yield) выполняется в методе [`__exit__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__exit__). Любое исключение, возникшее в блоке, будет возбуждено оператором [`yield`](https://python-all.ru/3.2/reference/simple_stmts.html#yield).

Используя этот декоратор, наш пример с базой данных из предыдущего раздела можно было бы записать так:

```python
from contextlib import contextmanager

@contextmanager
def db_transaction(connection):
    cursor = connection.cursor()
    try:
        yield cursor
    except:
        connection.rollback()
        raise
    else:
        connection.commit()

db = DatabaseConnection()
with db_transaction(db) as cursor:
    ...
```

В модуле [`contextlib`](https://python-all.ru/3.2/library/contextlib.html#module-contextlib) также есть функция `nested(mgr1, mgr2, ...)`, которая объединяет несколько менеджеров контекста, чтобы не писать вложенные операторы ‘[`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with)‘. В этом примере один оператор ‘[`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with)‘ одновременно начинает транзакцию базы данных и захватывает блокировку потока:

```python
lock = threading.Lock()
with nested (db_transaction(db), lock) as (cursor, locked):
    ...
```

Наконец, функция `closing()` возвращает свой аргумент, чтобы его можно было привязать к переменной, и вызывает метод `.close()` аргумента в конце блока.

```python
import urllib, sys
from contextlib import closing

with closing(urllib.urlopen('http://www.yahoo.com')) as f:
    for line in f:
        sys.stdout.write(line)
```

> **См. также**
>
> **[**PEP 343**](https://python-all.ru/3.2/whatsnew/2.6.html) – Оператор «with»**
>
> PEP написан Гвидо ван Россумом и Ником Когланом; реализован Майком Блэндом, Гвидо ван Россумом и Нилом Норвицем. В PEP показан код, генерируемый для оператора ‘
>
> [`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with)
>
> ‘, что может быть полезно для понимания его работы.
>
> Документация к модулю [`contextlib`](https://python-all.ru/3.2/library/contextlib.html#module-contextlib).

## PEP 366: Явные относительные импорты из главного модуля

Опция [*-m*](https://python-all.ru/3.2/using/cmdline.html#cmdoption-m) в Python позволяет запускать модуль как сценарий. При запуске модуля, находящегося внутри пакета, относительные импорты работали некорректно.

Исправление для Python 2.6 добавляет атрибут `__package__` к модулям. Если этот атрибут присутствует, относительные импорты будут выполняться относительно значения этого атрибута, а не атрибута `__name__`.

Импортеры в стиле PEP 302 могут затем устанавливать `__package__` по мере необходимости. Модуль [`runpy`](https://python-all.ru/3.2/library/runpy.html#module-runpy), реализующий флаг [*-m*](https://python-all.ru/3.2/using/cmdline.html#cmdoption-m), теперь делает это, так что относительные импорты теперь будут правильно работать в скриптах, запускаемых изнутри пакета.

## PEP 370: Персональный каталог `site-packages`

При запуске Python пути поиска модулей `sys.path` обычно включает каталог, путь которого заканчивается на `"site-packages"`. Этот каталог предназначен для хранения локально установленных пакетов, доступных всем пользователям машины или конкретной установки.

Python 2.6 вводит соглашение о каталогах site, специфичных для пользователя. Каталог зависит от платформы:

- Unix и Mac OS X: `~/.local/`
- Windows: `%APPDATA%/Python`

Внутри этого каталога будут подкаталоги, специфичные для версий, такие как `lib/python2.6/site-packages` в Unix/Mac OS и `Python26/site-packages` в Windows.

Если каталог по умолчанию не устраивает, его можно переопределить с помощью переменной окружения. [`PYTHONUSERBASE`](https://python-all.ru/3.2/using/cmdline.html#envvar-PYTHONUSERBASE) задаёт корневой каталог, используемый для всех версий Python, поддерживающих эту возможность. В Windows каталог для данных приложения можно изменить, установив переменную окружения `APPDATA`. Также можно изменить файл `site.py` для вашей установки Python.

Эту возможность можно полностью отключить, запустив Python с опцией [*-s*](https://python-all.ru/3.2/using/cmdline.html#cmdoption-s) или установив переменную окружения [`PYTHONNOUSERSITE`](https://python-all.ru/3.2/using/cmdline.html#envvar-PYTHONNOUSERSITE).

> **См. также**
>
> **[**PEP 370**](https://python-all.ru/3.2/whatsnew/2.6.html) – Персональный каталог `site-packages`**
>
> PEP написан и реализован Кристианом Хеймсом.

## PEP 371: Пакет `multiprocessing`

Новый пакет [`multiprocessing`](https://python-all.ru/3.2/library/multiprocessing.html#module-multiprocessing) позволяет программам Python создавать новые процессы, которые будут выполнять вычисления и возвращать результат родительскому процессу. Родительский и дочерние процессы могут общаться с помощью очередей и каналов, синхронизировать свои операции с помощью блокировок и семафоров, а также могут совместно использовать простые массивы данных.

Модуль [`multiprocessing`](https://python-all.ru/3.2/library/multiprocessing.html#module-multiprocessing) изначально был точной эмуляцией модуля [`threading`](https://python-all.ru/3.2/library/threading.html#module-threading), использующей процессы вместо потоков. Эта цель была отброшена на пути к Python 2.6, но общий подход модуля остаётся похожим. Основным классом является `Process`, которому передаётся вызываемый объект и набор аргументов. Метод `start()` запускает вызываемый объект в подпроцессе, после чего можно вызвать метод `is_alive()`, чтобы проверить, работает ли ещё подпроцесс, и метод `join()`, чтобы дождаться завершения процесса.

Вот простой пример, где подпроцесс вычисляет факториал. Функция, выполняющая вычисление, написана так, что она работает значительно дольше, когда входной аргумент кратен 4.

```python
import time
from multiprocessing import Process, Queue

def factorial(queue, N):
    "Compute a factorial."
    # Если N кратно 4, эта функция будет выполняться намного дольше
    if (N % 4) == 0:
        time.sleep(.05 * N/4)

    # Вычислить результат
    fact = 1L
    for i in range(1, N+1):
        fact = fact * i

    # Поместить результат в очередь
    queue.put(fact)

if __name__ == '__main__':
    queue = Queue()

    N = 5

    p = Process(target=factorial, args=(queue, N))
    p.start()
    p.join()

    result = queue.get()
    print 'Factorial', N, '=', result
```

`Очередь` используется для передачи результата факториала. Объект `очереди` хранится в глобальной переменной. Дочерний процесс будет использовать значение переменной на момент его создания; поскольку это `очередь`, родительский и дочерний процессы могут общаться через этот объект. (Если бы родитель изменил значение глобальной переменной, значение дочернего процесса не изменилось бы, и наоборот.)

Два других класса, `Pool` и `Manager`, предоставляют интерфейсы более высокого уровня. `Pool` создаёт фиксированное количество рабочих процессов, и затем запросы могут быть распределены между рабочими процессами вызовом `apply()` или `apply_async()` для добавления одного запроса, и [`map()`](https://python-all.ru/3.2/library/functions.html#map) или `map_async()` для добавления нескольких запросов. Следующий код использует `Pool` для распределения запросов между 5 рабочими процессами и получения списка результатов:

```python
from multiprocessing import Pool

def factorial(N, dictionary):
    "Compute a factorial."
    ...
p = Pool(5)
result = p.map(factorial, range(1, 1000, 10))
for v in result:
    print v
```

Это даёт следующий вывод:

```python
1
39916800
51090942171709440000
8222838654177922817725562880000000
33452526613163807108170062053440751665152000000000
...
```

Другой интерфейс высокого уровня, класс `Manager`, создаёт отдельный серверный процесс, который может хранить главные копии структур данных Python. Другие процессы могут затем обращаться к этим структурам данных и изменять их с помощью прокси-объектов. Следующий пример создаёт общий словарь вызовом метода [`dict()`](https://python-all.ru/3.2/library/stdtypes.html#dict); затем рабочие процессы вставляют значения в словарь. (Блокировка не выполняется автоматически, что в этом примере не важно. Методы `Manager` также включают `Lock()`, `RLock()` и `Semaphore()` для создания общих блокировок.)

```python
import time
from multiprocessing import Pool, Manager

def factorial(N, dictionary):
    "Compute a factorial."
    # Вычислить результат
    fact = 1L
    for i in range(1, N+1):
        fact = fact * i

    # Сохранить результат в словаре
    dictionary[N] = fact

if __name__ == '__main__':
    p = Pool(5)
    mgr = Manager()
    d = mgr.dict()         # Создать общий словарь

    # Запустить задачи с помощью пула
    for N in range(1, 1000, 10):
        p.apply_async(factorial, (N, d))

    # Отметить пул как закрытый – больше задач добавить нельзя
    p.close()

    # Ожидать завершения задач
    p.join()

    # Вывести результаты
    for k, v in sorted(d.items()):
        print k, v
```

Это выведет следующий результат:

```python
1 1
11 39916800
21 51090942171709440000
31 8222838654177922817725562880000000
41 33452526613163807108170062053440751665152000000000
51 15511187532873822802242430164693032110632597200169861120000...
```

> **См. также**
>
> Документация для модуля [`multiprocessing`](https://python-all.ru/3.2/library/multiprocessing.html#module-multiprocessing).
>
> **[**PEP 371**](https://python-all.ru/3.2/whatsnew/2.6.html) – Добавление пакета multiprocessing**
>
> PEP написан Джесси Ноллером и Ричардом Удкерком; реализован Ричардом Удкерком и Джесси Ноллером.

## PEP 3101: Расширенное форматирование строк

В Python 3.0 оператор *%* дополнен более мощным методом форматирования строк [`format()`](https://python-all.ru/3.2/library/functions.html#format). Поддержка метода [`str.format()`](https://python-all.ru/3.2/library/stdtypes.html#str.format) была перенесена в Python 2.6.

В версии 2.6 как 8-битные, так и строки Unicode имеют метод *.format()*, который рассматривает строку как шаблон и принимает аргументы для форматирования. Шаблон форматирования использует фигурные скобки (*{*, *}*) в качестве специальных символов:

```python
>>> # Подставить позиционный аргумент 0 в строку
>>> "User ID: {0}".format("root")
'User ID: root'
>>> # Использовать именованные аргументы-ключевые слова
>>> "User ID: {uid}   Last seen: {last_login}".format(
...    uid="root",
...    last_login = "5 Mar 2008 07:20")
'User ID: root   Last seen: 5 Mar 2008 07:20'
```

Фигурные скобки можно экранировать, удваивая их:

```python
>>> "Empty dict: {{}}".format()
"Empty dict: {}"
```

Имена полей могут быть целыми числами, указывающими на позиционные аргументы, например `{0}`, `{1}` и т.д., или именами именованных аргументов. Также можно указывать составные имена полей, которые читают атрибуты или получают доступ к ключам словаря:

```python
>>> import sys
>>> print 'Platform: {0.platform}\nPython version: {0.version}'.format(sys)
Platform: darwin
Python version: 2.6a1+ (trunk:61261M, Mar  5 2008, 20:29:41)
[GCC 4.0.1 (Apple Computer, Inc. build 5367)]'

>>> import mimetypes
>>> 'Content-type: {0[.mp4]}'.format(mimetypes.types_map)
'Content-type: video/mp4'
```

Обратите внимание, что при использовании нотации в стиле словаря, например `[.mp4]`, не нужно заключать строку в кавычки; значение будет найдено по ключу `.mp4`. Строки, начинающиеся с цифры, преобразуются в целое число. Внутри строки формата нельзя писать более сложные выражения.

До сих пор мы показывали, как указать, какое поле подставить в результирующую строку. Точное форматирование также можно контролировать, добавляя двоеточие и спецификатор формата. Например:

```python
>>> # Поле 0: выравнивание влево, заполнить до 15 символов
>>> # Поле 1: выравнивание вправо, заполнить до 6 символов
>>> fmt = '{0:15} ${1:>6}'
>>> fmt.format('Registration', 35)
'Registration    $    35'
>>> fmt.format('Tutorial', 50)
'Tutorial        $    50'
>>> fmt.format('Banquet', 125)
'Banquet         $   125'
```

Спецификаторы формата могут ссылаться на другие поля через вложение:

```python
>>> fmt = '{0:{1}}'
>>> width = 15
>>> fmt.format('Invoice #1234', width)
'Invoice #1234  '
>>> width = 35
>>> fmt.format('Invoice #1234', width)
'Invoice #1234                      '
```

Выравнивание поля в заданной ширине можно указать:

| Символ | Эффект |
| --- | --- |
| \< (по умолчанию) | Выравнивание влево |
| \> | Выравнивание вправо |
| ^ | По центру |
| = | (Только для числовых типов) Заполнение после знака. |

Спецификаторы формата также могут включать тип представления, который управляет форматированием значения. Например, числа с плавающей запятой могут быть отформатированы как обычное число или в экспоненциальной нотации:

```python
>>> '{0:g}'.format(3.75)
'3.75'
>>> '{0:e}'.format(3.75)
'3.750000e+00'
```

Доступны различные типы представления. Обратитесь к документации Python 2.6 за [*полным списком*](https://python-all.ru/3.2/library/string.html#formatstrings); вот пример:

| `b` | Двоичный. Выводит число по основанию 2. |
| --- | --- |
| `c` | Символьный. Преобразует целое число в соответствующий символ Unicode перед выводом. |
| `d` | Десятичное целое. Выводит число в системе с основанием 10. |
| `o` | Восьмеричный формат. Выводит число в системе с основанием 8. |
| `x` | Шестнадцатеричный. Выводит число по основанию 16, используя строчные буквы для цифр старше 9. |
| `e` | Экспоненциальная запись. Выводит число в научной нотации с использованием буквы 'e' для обозначения экспоненты. |
| `g` | Общий формат. Выводит число в формате с фиксированной точкой, если только число не слишком велико, в этом случае переключается на экспоненциальную нотацию 'e'. |
| `n` | Число. Аналогично 'g' (для чисел с плавающей запятой) или 'd' (для целых чисел), но с использованием текущей локали для вставки соответствующих разделителей разрядов. |
| `%` | Проценты. Умножает число на 100 и выводит в фиксированном формате ('f'), с последующим знаком процента. |

Классы и типы могут определить метод [`__format__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__format__), чтобы управлять тем, как они форматируются. Он получает один аргумент – спецификатор формата:

```python
def __format__(self, format_spec):
    if isinstance(format_spec, unicode):
        return unicode(str(self))
    else:
        return str(self)
```

Существует также встроенная функция [`format()`](https://python-all.ru/3.2/library/functions.html#format), которая форматирует одно значение. Она вызывает метод [`__format__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__format__) типа с переданным спецификатором:

```python
>>> format(75.6564, '.2f')
'75.66'
```

> **См. также**
>
> **[*Синтаксис строк форматирования*](https://python-all.ru/3.2/library/string.html#formatstrings)**
>
> Справочная документация по полям формата.
>
> **[**PEP 3101**](https://python-all.ru/3.2/whatsnew/2.6.html) - Расширенное форматирование строк**
>
> PEP написан Талином. Реализован Эриком Смитом.

## PEP 3105: `print` как функция

Инструкция `print` становится функцией [`print()`](https://python-all.ru/3.2/library/functions.html#print) в Python 3.0. Превращение [`print()`](https://python-all.ru/3.2/library/functions.html#print) в функцию позволяет заменить её, написав `def print(...)` или импортировав новую функцию откуда-то ещё.

В Python 2.6 есть импорт `__future__`, который удаляет `print` как синтаксис языка, позволяя вместо этого использовать функциональную форму. Например:

```python
>>> from __future__ import print_function
>>> print('# of entries', len(dictionary), file=sys.stderr)
```

Сигнатура новой функции:

```python
def print(*args, sep=' ', end='\n', file=None)
```

Параметры:

> - *args*: позиционные аргументы, значения которых будут выведены.
> - *sep*: разделитель, который будет выводиться между аргументами.
> - *end*: завершающий текст, который будет выведен после того, как все аргументы будут выведены.
> - *file*: файловый объект, в который будет отправлен вывод.

> **См. также**
>
> **[**PEP 3105**](https://python-all.ru/3.2/whatsnew/2.6.html) - Сделать print функцией**
>
> PEP написан Георгом Брандлом.

## PEP 3110: Изменения в обработке исключений

Одна ошибка, которую иногда допускают программисты Python, – написание следующего кода:

```python
try:
    ...
except TypeError, ValueError:  # Неверно!
    ...
```

Вероятно, автор пытается перехватить исключения [`TypeError`](https://python-all.ru/3.2/library/exceptions.html#TypeError) и [`ValueError`](https://python-all.ru/3.2/library/exceptions.html#ValueError), но этот код на самом деле делает нечто иное: он перехватывает [`TypeError`](https://python-all.ru/3.2/library/exceptions.html#TypeError) и связывает полученный объект исключения с локальным именем `"ValueError"`. Исключение [`ValueError`](https://python-all.ru/3.2/library/exceptions.html#ValueError) не будет перехвачено вовсе. Правильный код указывает кортеж исключений:

```python
try:
    ...
except (TypeError, ValueError):
    ...
```

Эта ошибка возникает из-за неоднозначности использования запятой: обозначает ли она два разных узла в дереве разбора или один узел, являющийся кортежем?

Python 3.0 устраняет эту неоднозначность, заменяя запятую словом «as». Чтобы перехватить исключение и сохранить объект исключения в переменной `exc`, нужно написать:

```python
try:
    ...
except TypeError as exc:
    ...
```

Python 3.0 будет поддерживать только использование «as» и, следовательно, интерпретирует первый пример как перехват двух разных исключений. Python 2.6 поддерживает как запятую, так и «as», поэтому существующий код продолжит работать. Поэтому рекомендуется использовать «as» при написании нового кода Python, который будет выполняться только в 2.6.

> **См. также**
>
> **[**PEP 3110**](https://python-all.ru/3.2/whatsnew/2.6.html) - Перехват исключений в Python 3000**
>
> PEP написан и реализован Коллином Уинтером.

## PEP 3112: Байтовые литералы

Python 3.0 принимает Unicode в качестве основного строкового типа языка и обозначает 8-битные литералы иначе: либо как `b'string'`, либо с помощью конструктора [`bytes`](https://python-all.ru/3.2/library/functions.html#bytes). Для обратной совместимости Python 2.6 добавляет [`bytes`](https://python-all.ru/3.2/library/functions.html#bytes) как синоним для типа [`str`](https://python-all.ru/3.2/library/functions.html#str), а также поддерживает нотацию `b''`.

Тип [`str`](https://python-all.ru/3.2/library/functions.html#str) в 2.6 отличается от типа [`bytes`](https://python-all.ru/3.2/library/functions.html#bytes) в 3.0 по нескольким параметрам; самое заметное – конструктор совершенно другой. В 3.0 `bytes([65, 66, 67])` состоит из 3 элементов и содержит байты, соответствующие `ABC`; в 2.6 `bytes([65, 66, 67])` возвращает 12-байтовую строку, представляющую результат [`str()`](https://python-all.ru/3.2/library/functions.html#str) от списка.

Основное применение [`bytes`](https://python-all.ru/3.2/library/functions.html#bytes) в Python 2.6 будет заключаться в написании проверок типа объекта, таких как `isinstance(x, bytes)`. Это поможет конвертеру 2to3, который не может определить, предполагается ли в коде 2.x, что строки содержат символы или 8-битные байты; теперь можно использовать либо [`bytes`](https://python-all.ru/3.2/library/functions.html#bytes), либо [`str`](https://python-all.ru/3.2/library/functions.html#str), чтобы точно выразить своё намерение, и полученный код также будет корректен в Python 3.0.

Существует также импорт `__future__`, который приводит к тому, что все строковые литералы становятся строками Unicode. Это означает, что управляющие последовательности `\u` можно использовать для включения символов Unicode:

```python
from __future__ import unicode_literals

s = ('\u751f\u3080\u304e\u3000\u751f\u3054'
     '\u3081\u3000\u751f\u305f\u307e\u3054')

print len(s)               # 12 символов Unicode
```

На уровне C Python 3.0 переименует существующий 8-битный строковый тип, называемый `PyStringObject` в Python 2.x, в [`PyBytesObject`](https://python-all.ru/3.2/c-api/bytes.html#PyBytesObject). Python 2.6 использует `#define`, чтобы обеспечить возможность использования имён [`PyBytesObject()`](https://python-all.ru/3.2/c-api/bytes.html#PyBytesObject), [`PyBytes_Check()`](https://python-all.ru/3.2/c-api/bytes.html#PyBytes_Check), [`PyBytes_FromStringAndSize()`](https://python-all.ru/3.2/c-api/bytes.html#PyBytes_FromStringAndSize) и всех остальных функций и макросов, используемых со строками.

Экземпляры типа [`bytes`](https://python-all.ru/3.2/library/functions.html#bytes) неизменяемы, как и строки. Новый тип [`bytearray`](https://python-all.ru/3.2/library/functions.html#bytearray) хранит изменяемую последовательность байтов:

```python
>>> bytearray([65, 66, 67])
bytearray(b'ABC')
>>> b = bytearray(u'\u21ef\u3244', 'utf-8')
>>> b
bytearray(b'\xe2\x87\xaf\xe3\x89\x84')
>>> b[0] = '\xe3'
>>> b
bytearray(b'\xe3\x87\xaf\xe3\x89\x84')
>>> unicode(str(b), 'utf-8')
u'\u31ef \u3244'
```

Массивы байтов поддерживают большинство методов строковых типов, таких как `startswith()`/`endswith()`, `find()`/`rfind()`, а также некоторые методы списков, например `append()`, `pop()` и `reverse()`.

```python
>>> b = bytearray('ABC')
>>> b.append('d')
>>> b.append(ord('e'))
>>> b
bytearray(b'ABCde')
```

Существует также соответствующий C API с функциями [`PyByteArray_FromObject()`](https://python-all.ru/3.2/c-api/bytearray.html#PyByteArray_FromObject), [`PyByteArray_FromStringAndSize()`](https://python-all.ru/3.2/c-api/bytearray.html#PyByteArray_FromStringAndSize) и другими.

> **См. также**
>
> **[**PEP 3112**](https://python-all.ru/3.2/whatsnew/2.6.html) - Байтовые литералы в Python 3000**
>
> PEP написан Джейсоном Орендорфом; портирован в 2.6 Кристианом Хаймсом.

## PEP 3116: Новая библиотека ввода-вывода

Встроенные файловые объекты Python поддерживают ряд методов, но файлоподобные объекты не обязательно поддерживают их все. Объекты, имитирующие файлы, обычно поддерживают `read()` и `write()`, но могут не поддерживать, например, [`readline()`](https://python-all.ru/3.2/library/readline.html#module-readline). Python 3.0 вводит многоуровневую библиотеку ввода-вывода в модуле [`io`](https://python-all.ru/3.2/library/io.html#module-io), которая отделяет буферизацию и обработку текста от базовых операций чтения и записи.

Модуль [`io`](https://python-all.ru/3.2/library/io.html#module-io) предоставляет три уровня абстрактных базовых классов:

- `RawIOBase` определяет низкоуровневые операции ввода-вывода: `read()`, `readinto()`, `write()`, `seek()`, `tell()`, `truncate()` и `close()`. Большинство методов этого класса обычно отображаются на один системный вызов. Также есть методы `readable()`, `writable()` и `seekable()` для определения того, какие операции разрешены для данного объекта.

  Python 3.0 имеет конкретные реализации этого класса для файлов и сокетов, но Python 2.6 не перестраивал свои файловые объекты и сокеты таким образом.
- `BufferedIOBase` – это абстрактный базовый класс, который буферизует данные в памяти, чтобы уменьшить количество используемых системных вызовов, делая обработку ввода-вывода более эффективной. Он поддерживает все методы `RawIOBase` и добавляет атрибут `raw`, содержащий базовый низкоуровневый объект.

  Есть пять конкретных классов, реализующих этот ABC. `BufferedWriter` и `BufferedReader` предназначены для объектов, поддерживающих только запись или только чтение, которые имеют метод `seek()` для произвольного доступа. Объекты `BufferedRandom` поддерживают чтение и запись на одном и том же базовом потоке, а `BufferedRWPair` предназначен для таких объектов, как TTY, которые имеют операции чтения и записи, действующие на несвязанных потоках данных. Класс `BytesIO` поддерживает чтение, запись и позиционирование в буфере в памяти.
- `TextIOBase`: предоставляет функции для чтения и записи строк (напомним, в Python 3.0 строки будут Unicode), а также поддержку [*универсальных символов новой строки*](https://python-all.ru/3.2/glossary.html#term-universal-newlines). `TextIOBase` определяет метод [`readline()`](https://python-all.ru/3.2/library/readline.html#module-readline) и поддерживает итерацию по объектам.

  Есть две конкретные реализации. `TextIOWrapper` оборачивает буферизованный объект ввода-вывода, поддерживая все методы для текстового ввода-вывода и добавляя атрибут `buffer` для доступа к базовому объекту. `StringIO` просто буферизует всё в памяти, никогда ничего не записывая на диск.

  (В Python 2.6 [`io.StringIO`](https://python-all.ru/3.2/library/io.html#io.StringIO) реализован на чистом Python, поэтому он довольно медленный. Поэтому пока следует придерживаться существующего модуля `StringIO` или `cStringIO`. Рано или поздно модуль [`io`](https://python-all.ru/3.2/library/io.html#module-io) Python 3.0 будет переписан на C для ускорения, и, возможно, реализация на C будет перенесена в версии 2.x.)

В Python 2.6 базовые реализации не были перестроены, чтобы основываться на классах модуля [`io`](https://python-all.ru/3.2/library/io.html#module-io). Этот модуль предоставляется, чтобы упростить написание кода, совместимого с Python 3.0, и избавить разработчиков от необходимости писать собственные реализации буферизации и текстового ввода-вывода.

> **См. также**
>
> **[**PEP 3116**](https://python-all.ru/3.2/whatsnew/2.6.html) - Новый ввод-вывод**
>
> PEP написан Дэниелом Штуцбахом, Майком Вердоне и Гвидо ван Россумом. Код – Гвидо ван Россум, Георг Брандль, Вальтер Дёрвальд, Джереми Хилтон, Мартин фон Лёвис, Тони Лаундс и другие.

## PEP 3118: Пересмотренный буферный протокол

Протокол буфера – это C-уровневый API, который позволяет типам Python обмениваться указателями на свои внутренние представления. Например, файл, отображаемый в память, можно рассматривать как буфер символов, и это позволяет другому модулю, например [`re`](https://python-all.ru/3.2/library/re.html#module-re), обрабатывать такие файлы как строку символов для поиска.

Основными пользователями буферного протокола являются пакеты для численных расчетов, такие как NumPy, которые предоставляют доступ к внутреннему представлению массивов, чтобы вызывающие могли записывать данные напрямую в массив, а не через более медленный API. Данный PEP обновляет буферный протокол с учетом опыта разработки NumPy, добавляя ряд новых возможностей, таких как указание формы массива или блокировка области памяти.

Самая важная новая функция C API – это `PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags)`, которая принимает объект и набор флагов и заполняет структуру `Py_buffer` информацией о представлении объекта в памяти. Объекты могут использовать эту операцию для блокировки памяти, пока внешний вызывающий код может изменять содержимое, поэтому существует соответствующая функция `PyBuffer_Release(Py_buffer *view)`, чтобы сообщить, что внешний вызывающий код завершил работу.

Аргумент *flags* функции [`PyObject_GetBuffer()`](https://python-all.ru/3.2/c-api/buffer.html#PyObject_GetBuffer) задаёт ограничения на возвращаемую память. Некоторые примеры:

> - `PyBUF_WRITABLE` указывает, что память должна быть доступна для записи.
> - `PyBUF_LOCK` запрашивает блокировку только для чтения или исключительную блокировку памяти.
> - `PyBUF_C_CONTIGUOUS` и `PyBUF_F_CONTIGUOUS` запрашивают C-непрерывный (последнее измерение изменяется быстрее всего) или Fortran-непрерывный (первое измерение изменяется быстрее всего) макет массива.

Два новых кода аргументов для [`PyArg_ParseTuple()`](https://python-all.ru/3.2/c-api/arg.html#PyArg_ParseTuple), `s*` и `z*`, возвращают заблокированные буферные объекты для параметра.

> **См. также**
>
> **[**PEP 3118**](https://python-all.ru/3.2/whatsnew/2.6.html) - Пересмотр буферного протокола**
>
> PEP написан Трэвисом Олифантом и Карлом Бэнксом; реализован Трэвисом Олифантом.

## PEP 3119: Абстрактные базовые классы

Некоторые объектно-ориентированные языки, такие как Java, поддерживают интерфейсы, объявляя, что класс имеет заданный набор методов или поддерживает определённый протокол доступа. Абстрактные базовые классы (или ABC) – это аналогичная возможность для Python. Поддержка ABC состоит из модуля [`abc`](https://python-all.ru/3.2/library/abc.html#module-abc), содержащего метакласс `ABCMeta`, специальной обработки этого метакласса встроенными функциями [`isinstance()`](https://python-all.ru/3.2/library/functions.html#isinstance) и [`issubclass()`](https://python-all.ru/3.2/library/functions.html#issubclass), а также набора базовых ABC, которые разработчики Python считают широко полезными. Вероятно, будущие версии Python добавят больше ABC.

Let’s say you have a particular class and wish to know whether it supports dictionary-style access. The phrase “dictionary-style” is vague, however. It probably means that accessing items with `obj[1]` works. Does it imply that setting items with `obj[2] = value` works? Or that the object will have `keys()`, `values()`, and `items()` methods? What about the iterative variants such as `iterkeys()`? [`copy()`](https://python-all.ru/3.2/library/copy.html#module-copy) and `update()`? Iterating over the object with [`iter()`](https://python-all.ru/3.2/library/functions.html#iter)?

Модуль [`collections`](https://python-all.ru/3.2/library/collections.html#module-collections) в Python 2.6 содержит несколько разных ABC, отражающих эти различия. `Iterable` означает, что класс определяет [`__iter__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__iter__), а `Container` – что класс определяет метод [`__contains__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__contains__) и, следовательно, поддерживает выражения `x in y`. Базовый интерфейс словаря – получение и установка элементов, а также `keys()`, `values()` и `items()` – определяется ABC `MutableMapping`.

Можно наследовать свои классы от конкретной ABC, чтобы указать, что они поддерживают интерфейс этой ABC:

```python
import collections

class Storage(collections.MutableMapping):
    ...
```

В качестве альтернативы можно написать класс без наследования от нужного ABC и вместо этого зарегистрировать класс, вызвав метод `register()` этого ABC:

```python
import collections

class Storage:
    ...

collections.MutableMapping.register(Storage)
```

Для классов, которые вы пишете, наследование от ABC, вероятно, понятнее. Метод `register()` полезен, когда вы написали новый ABC, который может описать существующий тип или класс, или если вы хотите объявить, что какой-то сторонний класс реализует ABC. Например, если вы определили ABC `PrintableType`, то вполне допустимо сделать так:

```python
# Зарегистрировать типы Python
PrintableType.register(int)
PrintableType.register(float)
PrintableType.register(str)
```

Классы должны следовать семантике, заданной ABC, но Python не может это проверить; автор класса должен сам понять требования ABC и реализовать код соответствующим образом.

Чтобы проверить, поддерживает ли объект определённый интерфейс, можно теперь написать:

```python
def func(d):
    if not isinstance(d, collections.MutableMapping):
        raise ValueError("Mapping object expected, not %r" % d)
```

Не думайте, что теперь нужно начинать писать множество проверок, как в примере выше. У Python сложилась сильная традиция утиной типизации, где явная проверка типов никогда не выполняется, а код просто вызывает методы объекта, полагаясь, что эти методы существуют, и возбуждает исключение, если их нет. Будьте осмотрительны при проверке ABC и делайте это только в случае крайней необходимости.

Можно создавать собственные ABC, используя `abc.ABCMeta` в качестве метакласса в определении класса:

```python
from abc import ABCMeta, abstractmethod

class Drawable():
    __metaclass__ = ABCMeta

    @abstractmethod
    def draw(self, x, y, scale=1.0):
        pass

    def draw_doubled(self, x, y):
        self.draw(x, y, scale=2.0)

class Square(Drawable):
    def draw(self, x, y, scale):
        ...
```

В приведённом выше ABC `Drawable` метод `draw_doubled()` отображает объект в двойном размере и может быть реализован через другие методы, описанные в `Drawable`. Поэтому классам, реализующим этот ABC, не нужно предоставлять собственную реализацию `draw_doubled()`, хотя они могут это сделать. Однако реализация `draw()` обязательна; ABC не может предоставить полезную общую реализацию.

К методам, которые обязательно должны быть реализованы, можно применить декоратор `@abstractmethod`, например к `draw()`; тогда Python будет возбуждать исключение для классов, не определяющих этот метод. Обратите внимание, что исключение возбуждается только при попытке создать экземпляр подкласса, в котором отсутствует данный метод:

```python
>>> class Circle(Drawable):
...     pass
...
>>> c = Circle()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class Circle with abstract methods draw
>>>
```

Абстрактные атрибуты данных можно объявить с помощью декоратора `@abstractproperty`:

```python
from abc import abstractproperty
...

@abstractproperty
def readonly(self):
   return self._x
```

Тогда подклассы должны определить свойство `readonly()`.

> **См. также**
>
> **[**PEP 3119**](https://python-all.ru/3.2/whatsnew/2.6.html) – Введение абстрактных базовых классов**
>
> PEP написан Гвидо ван Россумом и Талином. Реализован Гвидо ван Россумом. Портирован в 2.6 Бенджамином Арангуреном при участии Алекса Мартелли.

## PEP 3127: Поддержка и синтаксис целочисленных литералов

Python 3.0 изменяет синтаксис восьмеричных (основание 8) целочисленных литералов, добавляя префикс «0o» или «0O» вместо ведущего нуля, а также добавляет поддержку двоичных (основание 2) целочисленных литералов с префиксом «0b» или «0B».

Python 2.6 не отказывается от поддержки ведущего нуля для восьмеричных чисел, но добавляет поддержку «0o» и «0b»:

```python
>>> 0o21, 2*8 + 1
(17, 17)
>>> 0b101111
47
```

Встроенная функция [`oct()`](https://python-all.ru/3.2/library/functions.html#oct) по-прежнему возвращает числа с ведущим нулём, а новая встроенная функция [`bin()`](https://python-all.ru/3.2/library/functions.html#bin) возвращает двоичное представление числа:

```python
>>> oct(42)
'052'
>>> future_builtins.oct(42)
'0o52'
>>> bin(173)
'0b10101101'
```

Встроенные функции [`int()`](https://python-all.ru/3.2/library/functions.html#int) и `long()` теперь принимают префиксы «0o» и «0b», когда запрашивается основание 8 или 2, либо когда аргумент *base* равен нулю (что означает, что используемое основание должно определяться из строки):

```python
>>> int ('0o52', 0)
42
>>> int('1101', 2)
13
>>> int('0b1101', 2)
13
>>> int('0b1101', 0)
13
```

> **См. также**
>
> **[**PEP 3127**](https://python-all.ru/3.2/whatsnew/2.6.html) – Поддержка и синтаксис целочисленных литералов**
>
> PEP написан Патриком Мопином; портирован в 2.6 Эриком Смитом.

## PEP 3129: Декораторы классов

Декораторы были расширены с функций на классы. Теперь допустимо написать:

```python
@foo
@bar
class A:
  pass
```

Это эквивалентно:

```python
class A:
  pass

A = foo(bar(A))
```

> **См. также**
>
> **[**PEP 3129**](https://python-all.ru/3.2/whatsnew/2.6.html) - Декораторы классов**
>
> PEP написан Коллином Уинтером.

## PEP 3141: Иерархия типов для чисел

Python 3.0 добавляет несколько абстрактных базовых классов для числовых типов, вдохновлённых числовой башней Scheme. Эти классы были перенесены в Python 2.6 как модуль [`numbers`](https://python-all.ru/3.2/library/numbers.html#module-numbers).

Самый общий ABC – это `Number`. Он не определяет никаких операций и существует только для того, чтобы можно было проверить, является ли объект числом, с помощью `isinstance(obj, Number)`.

`Complex` является подклассом `Number`. Комплексные числа поддерживают основные операции сложения, вычитания, умножения, деления и возведения в степень, а также позволяют получить действительную и мнимую части и сопряжённое число. Встроенный комплексный тип Python является реализацией `Complex`.

`Real` является подклассом `Complex` и добавляет операции, которые работают только с вещественными числами: `floor()`, `trunc()`, округление, взятие остатка по модулю N, целочисленное деление и сравнения.

Числа `Rational` происходят от `Real`, имеют свойства `numerator` и `denominator` и могут быть преобразованы в числа с плавающей запятой. Python 2.6 добавляет простой класс рациональных чисел `Fraction` в модуле [`fractions`](https://python-all.ru/3.2/library/fractions.html#module-fractions). (Он называется `Fraction`, а не `Rational`, чтобы избежать конфликта имён с [`numbers.Rational`](https://python-all.ru/3.2/library/numbers.html#numbers.Rational).)

Целые числа `Integral` происходят от `Rational` и могут сдвигаться влево и вправо с помощью `<<` и `>>`, комбинироваться с помощью побитовых операций, таких как `&` и `|`, а также использоваться в качестве индексов массивов и границ срезов.

В Python 3.0 PEP немного переопределяет существующие встроенные функции [`round()`](https://python-all.ru/3.2/library/functions.html#round), [`math.floor()`](https://python-all.ru/3.2/library/math.html#math.floor), [`math.ceil()`](https://python-all.ru/3.2/library/math.html#math.ceil) и добавляет новую, [`math.trunc()`](https://python-all.ru/3.2/library/math.html#math.trunc), которая была перенесена в Python 2.6. [`math.trunc()`](https://python-all.ru/3.2/library/math.html#math.trunc) округляет к нулю, возвращая ближайшее целое `Integral`, находящееся между аргументом функции и нулём.

> **См. также**
>
> **[**PEP 3141**](https://python-all.ru/3.2/whatsnew/2.6.html) – Иерархия типов для чисел**
>
> PEP написан Джеффри Яскиным.
>
> [Числовая башня Scheme](https://python-all.ru/3.2/whatsnew/2.6.html) из руководства по Guile.
>
> [Типы чисел Scheme](https://python-all.ru/3.2/whatsnew/2.6.html) из спецификации R5RS Scheme.

### Модуль [`fractions`](https://python-all.ru/3.2/library/fractions.html#module-fractions)

Чтобы дополнить иерархию числовых типов, модуль [`fractions`](https://python-all.ru/3.2/library/fractions.html#module-fractions) предоставляет класс рациональных чисел. Рациональные числа хранят свои значения в виде числителя и знаменателя, образующих дробь, и могут точно представлять такие числа, как `2/3`, которые числа с плавающей запятой могут лишь аппроксимировать.

Конструктор `Fraction` принимает два целых значения `Integral`, которые будут числителем и знаменателем результирующей дроби.

```python
>>> from fractions import Fraction
>>> a = Fraction(2, 3)
>>> b = Fraction(2, 5)
>>> float(a), float(b)
(0.66666666666666663, 0.40000000000000002)
>>> a+b
Fraction(16, 15)
>>> a/b
Fraction(5, 3)
```

Для преобразования чисел с плавающей запятой в рациональные числа тип float теперь имеет метод `as_integer_ratio()`, который возвращает числитель и знаменатель дроби, равной тому же значению с плавающей запятой:

```python
>>> (2.5) .as_integer_ratio()
(5, 2)
>>> (3.1415) .as_integer_ratio()
(7074029114692207L, 2251799813685248L)
>>> (1./3) .as_integer_ratio()
(6004799503160661L, 18014398509481984L)
```

Обратите внимание: значения, которые могут быть лишь аппроксимированы числами с плавающей запятой, например 1./3, не упрощаются до аппроксимируемого числа; дробь пытается соответствовать значению с плавающей запятой **в точности**.

Модуль [`fractions`](https://python-all.ru/3.2/library/fractions.html#module-fractions) основан на реализации Шурда Мулендера (Sjoerd Mullender), которая долгое время находилась в каталоге `Demo/classes/` в Python. Эта реализация была значительно обновлена Джеффри Яскином (Jeffrey Yasskin).

## Прочие изменения языка

Некоторые небольшие изменения, внесённые в ядро языка Python:

- Каталоги и zip-архивы, содержащие файл `__main__.py`, теперь можно запускать напрямую, передавая их имя интерпретатору. Каталог или zip-архив автоматически вставляется как первый элемент в sys.path. (Предложение и начальный патч от Энди Чу (Andy Chu), затем доработано Филлипом Дж. Иби (Phillip J. Eby) и Ником Когланом (Nick Coghlan); [issue 1739468](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Функция [`hasattr()`](https://python-all.ru/3.2/library/functions.html#hasattr) перехватывала и игнорировала все ошибки, предполагая, что они означают, что метод [`__getattr__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__getattr__) каким-то образом не сработал и возвращаемое значение [`hasattr()`](https://python-all.ru/3.2/library/functions.html#hasattr) поэтому будет `False`. Однако эту логику не следует применять к [`KeyboardInterrupt`](https://python-all.ru/3.2/library/exceptions.html#KeyboardInterrupt) и [`SystemExit`](https://python-all.ru/3.2/library/exceptions.html#SystemExit); Python 2.6 больше не будет отбрасывать такие исключения, когда [`hasattr()`](https://python-all.ru/3.2/library/functions.html#hasattr) сталкивается с ними. (Исправлено Бенджамином Петерсоном (Benjamin Peterson); [issue 2196](https://python-all.ru/3.2/whatsnew/2.6.html).)
- При вызове функции с использованием синтаксиса `**` для передачи именованных аргументов больше не требуется использовать словарь Python; теперь подойдёт любое отображение:

  ```python
  >>> def f(**kw):
  ...    print sorted(kw)
  ...
  >>> ud=UserDict.UserDict()
  >>> ud['a'] = 1
  >>> ud['b'] = 'string'
  >>> f(**ud)
  ['a', 'b']
  ```

  (Автор: Александр Белопольский (Alexander Belopolsky); [issue 1686487](https://python-all.ru/3.2/whatsnew/2.6.html).)

  Также стало разрешено указывать именованные аргументы после аргумента `*args` в вызове функции.

  ```python
  >>> def f(*args, **kw):
  ...     print args, kw
  ...
  >>> f(1,2,3, *(4,5,6), keyword=13)
  (1, 2, 3, 4, 5, 6) {'keyword': 13}
  ```

  Раньше это приводило бы к синтаксической ошибке. (Автор: Амори Форжо д’Арк (Amaury Forgeot d’Arc); [issue 3473](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Новая встроенная функция `next(iterator, [default])` возвращает следующий элемент из указанного итератора. Если передан аргумент *default*, он будет возвращён, когда *iterator* исчерпан; в противном случае будет возбуждено исключение [`StopIteration`](https://python-all.ru/3.2/library/exceptions.html#StopIteration). (Перенесено в [issue 2719](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Теперь кортежи имеют методы `index()` и `count()`, соответствующие методам `index()` и `count()` списков:

  ```python
  >>> t = (0,1,2,3,4,0,1,2)
  >>> t.index(3)
  3
  >>> t.count(0)
  2
  ```

  (Автор: Рэймонд Хеттингер)
- Встроенные типы теперь имеют улучшенную поддержку расширенного синтаксиса срезов, принимая различные комбинации `(start, stop, step)`. Раньше поддержка была частичной, и некоторые граничные случаи не работали. (Реализовано Томасом Воутерсом (Thomas Wouters).)
- Свойства теперь имеют три атрибута: `getter`, `setter` и `deleter`, которые являются декораторами, предоставляющими удобные сокращения для добавления функции чтения, записи или удаления к существующему свойству. Использовать их можно так:

  ```python
  class C(object):
      @property
      def x(self):
          return self._x

      @x.setter
      def x(self, value):
          self._x = value

      @x.deleter
      def x(self):
          del self._x

  class D(C):
      @C.x.getter
      def x(self):
          return self._x * 2

      @x.setter
      def x(self, value):
          self._x = value / 2
  ```
- Несколько методов встроенных типов множеств теперь принимают несколько итерируемых объектов: `intersection()`, `intersection_update()`, `union()`, `update()`, `difference()` и `difference_update()`.

  ```python
  >>> s=set('1234567890')
  >>> s.intersection('abc123', 'cdf246')  # Пересечение всех входных данных
  set(['2'])
  >>> s.difference('246', '789')
  set(['1', '0', '3', '5'])
  ```

  (Автор: Raymond Hettinger.)
- Добавлено много возможностей для чисел с плавающей запятой. Функция [`float()`](https://python-all.ru/3.2/library/functions.html#float) теперь преобразует строку `nan` в значение IEEE 754 Not A Number, а `+inf` и `-inf` – в положительную или отрицательную бесконечность. Это работает на любой платформе с семантикой IEEE 754. (Предложено Кристианом Хаймсом; [issue 1635](https://python-all.ru/3.2/whatsnew/2.6.html).)

  Другие функции модуля [`math`](https://python-all.ru/3.2/library/math.html#module-math), `isinf()` и `isnan()`, возвращают true, если их аргумент с плавающей запятой является бесконечным или Not A Number. ([issue 1640](https://python-all.ru/3.2/whatsnew/2.6.html))

  Были добавлены функции преобразования чисел с плавающей запятой в шестнадцатеричные строки ([issue 3008](https://python-all.ru/3.2/whatsnew/2.6.html)). Эти функции преобразуют числа с плавающей запятой в строковое представление и обратно, не внося ошибок округления при преобразовании между десятичной и двоичной системами. Числа с плавающей запятой имеют метод [`hex()`](https://python-all.ru/3.2/library/functions.html#hex), возвращающий строковое представление, а метод `float.fromhex()` преобразует строку обратно в число:

  ```python
  >>> a = 3.75
  >>> a.hex()
  '0x1.e000000000000p+1'
  >>> float.fromhex('0x1.e000000000000p+1')
  3.75
  >>> b=1./3
  >>> b.hex()
  '0x1.5555555555555p-2'
  ```
- Числовая тонкость: при создании комплексного числа из двух чисел с плавающей запятой в системах, поддерживающих знаковые нули (-0 и +0), конструктор [`complex()`](https://python-all.ru/3.2/library/functions.html#complex) теперь сохраняет знак нуля. (Исправлено Марком Т. Дикинсоном; [issue 1507](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Классы, которые наследуют метод [`__hash__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__hash__) от родительского класса, могут установить `__hash__ = None`, чтобы указать, что класс не является хешируемым. Это заставит `hash(obj)` вызывать исключение [`TypeError`](https://python-all.ru/3.2/library/exceptions.html#TypeError), и класс не будет считаться реализующим ABC `Hashable`.

  Это следует делать, когда вы определили метод `__cmp__()` или [`__eq__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__eq__), который сравнивает объекты по их значению, а не по идентичности. Все объекты имеют метод хеширования по умолчанию, использующий `id(obj)` в качестве хеш-значения. Нет аккуратного способа удалить метод [`__hash__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__hash__), унаследованный от родительского класса, поэтому присваивание `None` было реализовано как переопределение. На уровне C расширения могут установить `tp_hash` в [`PyObject_HashNotImplemented()`](https://python-all.ru/3.2/c-api/object.html#PyObject_HashNotImplemented). (Исправлено Ником Коглан и Амори Форжо д'Арк; [issue 2235](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Исключение [`GeneratorExit`](https://python-all.ru/3.2/library/exceptions.html#GeneratorExit) теперь наследуется от [`BaseException`](https://python-all.ru/3.2/library/exceptions.html#BaseException) вместо [`Exception`](https://python-all.ru/3.2/library/exceptions.html#Exception). Это означает, что обработчик исключений вида `except Exception:` не будет случайно перехватывать [`GeneratorExit`](https://python-all.ru/3.2/library/exceptions.html#GeneratorExit). (Предложено Чедом Остином; [issue 1537](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Объекты-генераторы теперь имеют атрибут `gi_code`, который ссылается на исходный объект кода, лежащий в основе генератора. (Предложено Коллином Уинтером; [issue 1473257](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Встроенная функция [`compile()`](https://python-all.ru/3.2/library/functions.html#compile) теперь принимает именованные аргументы, а также позиционные параметры. (Предложено Томасом Воутерсом; [issue 1444529](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Конструктор [`complex()`](https://python-all.ru/3.2/library/functions.html#complex) теперь принимает строки, содержащие комплексные числа в скобках, то есть `complex(repr(cplx))` теперь будет возвращать исходное значение. Например, `complex('(3+4j)')` теперь возвращает значение (3+4j). ([issue 1491866](https://python-all.ru/3.2/whatsnew/2.6.html))
- Метод строки `translate()` теперь принимает `None` в качестве параметра таблицы перевода, который рассматривается как тождественное преобразование. Это упрощает выполнение операций, которые только удаляют символы. (Предложено Бенгтом Рихтером и реализовано Рэймондом Хеттингером; [issue 1193128](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Встроенная функция [`dir()`](https://python-all.ru/3.2/library/functions.html#dir) теперь проверяет наличие метода [`__dir__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__dir__) у получаемых объектов. Этот метод должен возвращать список строк, содержащих имена допустимых атрибутов объекта, и позволяет объекту контролировать значение, которое возвращает [`dir()`](https://python-all.ru/3.2/library/functions.html#dir). Объекты, имеющие методы [`__getattr__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__getattr__) или [`__getattribute__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__getattribute__), могут использовать это для рекламирования псевдоатрибутов, которые они будут поддерживать. ([issue 1591665](https://python-all.ru/3.2/whatsnew/2.6.html))
- Объекты методов экземпляра имеют новые атрибуты для объекта и функции, составляющих метод; новый синоним для `im_self` – это `__self__`, а `im_func` также доступен как `__func__`. Старые имена по-прежнему поддерживаются в Python 2.6, но исчезли в 3.0.
- Малоизвестное изменение: при использовании функции [`locals()`](https://python-all.ru/3.2/library/functions.html#locals) внутри инструкции [`class`](https://python-all.ru/3.2/reference/compound_stmts.html#class) результирующий словарь больше не возвращает свободные переменные. (Свободные переменные в данном случае – это переменные, на которые есть ссылки в инструкции [`class`](https://python-all.ru/3.2/reference/compound_stmts.html#class), но которые не являются атрибутами класса.)

### Оптимизации

- Модуль [`warnings`](https://python-all.ru/3.2/library/warnings.html#module-warnings) был переписан на C. Это позволяет вызывать предупреждения из парсера и может также ускорить запуск интерпретатора. (Предложено Нилом Норвитцем и Бреттом Кэнноном; [issue 1631171](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Объекты типов теперь имеют кэш методов, который может сократить работу, необходимую для поиска правильной реализации метода для конкретного класса; после кэширования интерпретатору не нужно обходить базовые классы, чтобы определить, какой метод вызвать. Кэш очищается, если базовый класс или сам класс изменяется, поэтому кэш должен оставаться корректным даже в условиях динамической природы Python. (Оригинальная оптимизация реализована Армином Риго, обновлена для Python 2.6 Кевином Джейкобсом; [issue 1700288](https://python-all.ru/3.2/whatsnew/2.6.html).)

  По умолчанию это изменение применяется только к типам, входящим в ядро Python. Модули расширения могут быть несовместимы с этим кэшем, поэтому они должны явно добавить `Py_TPFLAGS_HAVE_VERSION_TAG` в поле `tp_flags` модуля, чтобы включить кэш методов. (Чтобы быть совместимым с кэшем методов, код модуля расширения не должен напрямую обращаться и изменять член `tp_dict` любого из реализуемых типов. Большинство модулей этого не делают, но интерпретатор Python не может это определить. См. [issue 1878](https://python-all.ru/3.2/whatsnew/2.6.html) для обсуждения.)
- Вызовы функций с именованными аргументами стали значительно быстрее за счет быстрого сравнения указателей, что обычно экономит время полного сравнения строк. (Предложено Рэймондом Хеттингером после первоначальной реализации Антуана Питу; [issue 1819](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Все функции модуля [`struct`](https://python-all.ru/3.2/library/struct.html#module-struct) были переписаны на C благодаря работе на спринте Need For Speed. (Предложено Рэймондом Хеттингером.)
- Некоторые стандартные встроенные типы теперь устанавливают бит в своих объектах типа. Это ускоряет проверку, является ли объект подклассом одного из этих типов. (Автор: Neal Norwitz.)
- Строки Unicode теперь используют более быстрый код для обнаружения пробельных символов и разрывов строк; это ускоряет метод `split()` примерно на 25% и `splitlines()` на 35%. (Предложено Антуаном Питу.) Использование памяти сокращено за счет применения pymalloc для данных строк Unicode.
- Инструкция `with` теперь сохраняет метод [`__exit__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__exit__) в стеке, что дает небольшое ускорение. (Реализовано Джеффри Яскиным.)
- Для уменьшения использования памяти сборщик мусора теперь очищает внутренние списки свободных блоков при сборке мусора самого старшего поколения объектов. Это может вернуть память операционной системе быстрее.

### Изменения в интерпретаторе

Две опции командной строки зарезервированы для использования другими реализациями Python. Ключ [*-J*](https://python-all.ru/3.2/using/cmdline.html#cmdoption-J) зарезервирован для использования Jython для специфических опций Jython, таких как ключи, передаваемые нижележащей JVM. [*-X*](https://python-all.ru/3.2/using/cmdline.html#cmdoption-X) зарезервирован для опций, специфичных для конкретной реализации Python, такой как CPython, Jython или IronPython. Если любая из этих опций используется с Python 2.6, интерпретатор сообщит, что опция в настоящее время не используется.

Python теперь можно запретить запись файлов `.pyc` или `.pyo`, указав ключ [*-B*](https://python-all.ru/3.2/using/cmdline.html#cmdoption-B) интерпретатору Python или установив переменную окружения [`PYTHONDONTWRITEBYTECODE`](https://python-all.ru/3.2/using/cmdline.html#envvar-PYTHONDONTWRITEBYTECODE) перед запуском интерпретатора. Эта настройка доступна программам Python через переменную `sys.dont_write_bytecode`, и код Python может изменить значение, чтобы изменить поведение интерпретатора. (Предложено Нилом Норвитцем и Георгом Брандлем.)

Кодировку, используемую для стандартного ввода, вывода и стандартной ошибки, можно указать, установив переменную окружения [`PYTHONIOENCODING`](https://python-all.ru/3.2/using/cmdline.html#envvar-PYTHONIOENCODING) перед запуском интерпретатора. Значение должно быть строкой вида `<encoding>` или `<encoding>:<errorhandler>`. Часть *encoding* задает имя кодировки, например `utf-8` или `latin-1`; необязательная часть *errorhandler* определяет, что делать с символами, которые не могут быть обработаны кодировкой, и должна быть одним из значений: “error”, “ignore” или “replace”. (Предложено Мартином фон Лёвисом.)

## Новые и улучшенные модули

Как и в каждом релизе, стандартная библиотека Python получила ряд улучшений и исправлений ошибок. Вот частичный список наиболее заметных изменений, отсортированный по алфавиту по именам модулей. Обратитесь к файлу `Misc/NEWS` в дереве исходных кодов для получения более полного списка изменений или просмотрите журналы Subversion для получения всех подробностей.

- Модули [`asyncore`](https://python-all.ru/3.2/library/asyncore.html#module-asyncore) и [`asynchat`](https://python-all.ru/3.2/library/asynchat.html#module-asynchat) снова активно поддерживаются, и было применено несколько патчей и исправлений ошибок. (Поддерживается Джозией Карлсоном; см. [issue 1736190](https://python-all.ru/3.2/whatsnew/2.6.html) для одного патча.)
- Модуль `bsddb` также получил нового сопровождающего, Хесуса Сеа Авиона, и теперь пакет доступен как автономный. Веб-страница пакета: [www.jcea.es/programacion/pybsddb.htm](https://python-all.ru/3.2/whatsnew/2.6.html). Планируется удалить пакет из стандартной библиотеки в Python 3.0, поскольку частота его выпусков намного выше, чем у Python.

  Модуль `bsddb.dbshelve` теперь использует самый высокий доступный протокол сериализации вместо того, чтобы ограничиваться протоколом 1. (Предложено У. Барнсом.)
- Модуль [`cgi`](https://python-all.ru/3.2/library/cgi.html#module-cgi) теперь будет читать переменные из строки запроса HTTP POST запроса. Это позволяет использовать действия формы с URL, содержащими строки запроса, например “/cgi-bin/add.py?category=1”. (Предложено Александром Фиори и Нубисом; [issue 1817](https://python-all.ru/3.2/whatsnew/2.6.html).)

  Функции `parse_qs()` и `parse_qsl()` были перенесены из модуля [`cgi`](https://python-all.ru/3.2/library/cgi.html#module-cgi) в модуль `urlparse`. Версии, все еще доступные в модуле [`cgi`](https://python-all.ru/3.2/library/cgi.html#module-cgi), будут вызывать сообщения [`PendingDeprecationWarning`](https://python-all.ru/3.2/library/exceptions.html#PendingDeprecationWarning) в 2.6 ([issue 600362](https://python-all.ru/3.2/whatsnew/2.6.html)).
- Модуль [`cmath`](https://python-all.ru/3.2/library/cmath.html#module-cmath) подвергся значительной доработке, предложенной Марком Дикинсоном и Кристианом Хаймсом. Было добавлено пять новых функций:

  - `polar()` преобразует комплексное число в полярную форму, возвращая модуль и аргумент комплексного числа.
  - `rect()` делает обратное, преобразуя пару модуль, аргумент обратно в соответствующее комплексное число.
  - `phase()` возвращает аргумент (также называемый углом) комплексного числа.
  - `isnan()` возвращает True, если либо вещественная, либо мнимая часть его аргумента является NaN.
  - `isinf()` возвращает True, если либо вещественная, либо мнимая часть его аргумента бесконечна.

  Ревизии также улучшили числовую надёжность модуля [`cmath`](https://python-all.ru/3.2/library/cmath.html#module-cmath). Для всех функций вещественная и мнимая части результатов точны до нескольких единиц последнего разряда (ulps), когда это возможно. Подробности см. в [issue 1381](https://python-all.ru/3.2/whatsnew/2.6.html). Также исправлены разрезы ветвей для `asinh()`, `atanh()` и `atan()`.

  Тесты для модуля были существенно расширены; почти 2000 новых тестов проверяют алгебраические функции.

  На платформах IEEE 754 модуль [`cmath`](https://python-all.ru/3.2/library/cmath.html#module-cmath) теперь обрабатывает специальные значения IEEE 754 и исключения с плавающей запятой в соответствии с Приложением ‘G’ стандарта C99.
- Новый тип данных в модуле [`collections`](https://python-all.ru/3.2/library/collections.html#module-collections): `namedtuple(typename, fieldnames)` – это фабричная функция, которая создаёт подклассы стандартного кортежа, поля которых доступны как по имени, так и по индексу. Например:

  ```python
  >>> var_type = collections.namedtuple('variable',
  ...             'id name type size')
  >>> # Имена разделяются пробелами или запятыми
  >>> # 'id, name, type, size' также будет работать
  >>> var_type._fields
  ('id', 'name', 'type', 'size')

  >>> var = var_type(1, 'frequency', 'int', 4)
  >>> print var[0], var.id    # Эквивалентно
  1 1
  >>> print var[2], var.type  # Эквивалентно
  int int
  >>> var._asdict()
  {'size': 4, 'type': 'int', 'id': 1, 'name': 'frequency'}
  >>> v2 = var._replace(name='amplitude')
  >>> v2
  variable(id=1, name='amplitude', type='int', size=4)
  ```

  Некоторые места в стандартной библиотеке, которые возвращали кортежи, были изменены так, чтобы возвращать экземпляры `namedtuple`. Например, метод `Decimal.as_tuple()` теперь возвращает именованный кортеж с полями `sign`, `digits` и `exponent`.

  (Автор: Raymond Hettinger.)
- Ещё одно изменение в модуле [`collections`](https://python-all.ru/3.2/library/collections.html#module-collections): тип `deque` теперь поддерживает необязательный параметр *maxlen*; если он указан, размер дека будет ограничен не более чем *maxlen* элементами. Добавление новых элементов в полный дек приводит к отбрасыванию старых.

  ```python
  >>> from collections import deque
  >>> dq=deque(maxlen=3)
  >>> dq
  deque([], maxlen=3)
  >>> dq.append(1) ; dq.append(2) ; dq.append(3)
  >>> dq
  deque([1, 2, 3], maxlen=3)
  >>> dq.append(4)
  >>> dq
  deque([2, 3, 4], maxlen=3)
  ```

  (Автор: Raymond Hettinger.)
- Объекты `Morsel` модуля `Cookie` теперь поддерживают атрибут `httponly`. В некоторых браузерах куки с этим атрибутом недоступны для чтения или изменения через JavaScript. (Автор: Arvin Schnell; [issue 1638033](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Новый метод окна в модуле [`curses`](https://python-all.ru/3.2/library/curses.html#module-curses), `chgat()`, изменяет атрибуты отображения для заданного числа символов на одной строке. (Автор: Fabian Kreutz.)

  ```python
  # Текст жирным шрифтом, начинающийся с y=0, x=21
  # и влияющий на остальную часть строки
  stdscr.chgat(0, 21, curses.A_BOLD)
  ```

  Класс `Textbox` в модуле [`curses.textpad`](https://python-all.ru/3.2/library/curses.html#module-curses.textpad) теперь поддерживает редактирование как в режиме вставки, так и в режиме замены. Режим вставки включается передачей истинного значения для параметра *insert\_mode* при создании экземпляра `Textbox`.
- Методы `strftime()` модуля [`datetime`](https://python-all.ru/3.2/library/datetime.html#module-datetime) теперь поддерживают код формата `%f`, который разворачивается в количество микросекунд в объекте, дополненное слева нулями до шести знаков. (Автор: Skip Montanaro; [issue 1158](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Модуль [`decimal`](https://python-all.ru/3.2/library/decimal.html#module-decimal) был обновлён до версии 1.66 [Общей спецификации десятичных чисел](https://python-all.ru/3.2/whatsnew/2.6.html). Новые возможности включают некоторые методы для основных математических функций, таких как `exp()` и `log10()`:

  ```python
  >>> Decimal(1).exp()
  Decimal("2.718281828459045235360287471")
  >>> Decimal("2.7182818").ln()
  Decimal("0.9999999895305022877376682436")
  >>> Decimal(1000).log10()
  Decimal("3")
  ```

  Метод `as_tuple()` объектов `Decimal` теперь возвращает именованный кортеж с полями `sign`, `digits` и `exponent`.

  (Реализовано Facundo Batista и Mark Dickinson. Поддержка именованных кортежей добавлена Raymond Hettinger.)
- Класс `SequenceMatcher` модуля [`difflib`](https://python-all.ru/3.2/library/difflib.html#module-difflib) теперь возвращает именованные кортежи, представляющие совпадения, с атрибутами `a`, `b` и `size`. (Автор: Raymond Hettinger.)
- В конструктор класса [`ftplib.FTP`](https://python-all.ru/3.2/library/ftplib.html#ftplib.FTP), а также в метод `connect()`, был добавлен необязательный параметр `timeout`, задающий таймаут в секундах. (Добавлено Facundo Batista.) Кроме того, методы `storbinary()` и `storlines()` класса `FTP` теперь принимают необязательный параметр *колбэк*, который будет вызываться с каждым блоком данных после его отправки. (Автор: Phil Schwartz; [issue 1221598](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Встроенная функция `reduce()` также доступна в модуле [`functools`](https://python-all.ru/3.2/library/functools.html#module-functools). В Python 3.0 эта встроенная функция была удалена, и `reduce()` доступна только из [`functools`](https://python-all.ru/3.2/library/functools.html#module-functools); в настоящее время планов удалять её из серии 2.x нет. (Исправление: Christian Heimes; [issue 1739906](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Когда это возможно, модуль [`getpass`](https://python-all.ru/3.2/library/getpass.html#module-getpass) теперь использует `/dev/tty` для вывода приглашения и чтения пароля, при необходимости переключаясь на стандартный поток ошибок и стандартный ввод. Если пароль может отображаться на терминале, перед показом приглашения выводится предупреждение. (Автор: Gregory P. Smith.)
- Функция [`glob.glob()`](https://python-all.ru/3.2/library/glob.html#glob.glob) теперь может возвращать имена файлов в Unicode, если использовался путь в Unicode и в каталоге есть соответствующие имена в Unicode. ([issue 1001604](https://python-all.ru/3.2/whatsnew/2.6.html))
- Новая функция в модуле [`heapq`](https://python-all.ru/3.2/library/heapq.html#module-heapq), `merge(iter1, iter2, ...)`, принимает любое количество итерируемых объектов, возвращающих данные в отсортированном порядке, и возвращает новый генератор, который выдает содержимое всех итераторов, также в отсортированном порядке. Например:

  ```python
  >>> list(heapq.merge([1, 3, 5, 9], [2, 8, 16]))
  [1, 2, 3, 5, 8, 9, 16]
  ```

  Ещё одна новая функция, `heappushpop(heap, item)`, добавляет *item* в *heap*, затем извлекает и возвращает наименьший элемент. Это эффективнее, чем последовательный вызов `heappush()` и `heappop()`.

  [`heapq`](https://python-all.ru/3.2/library/heapq.html#module-heapq) теперь реализован так, что использует только сравнение «меньше», вместо ранее использовавшегося сравнения «меньше или равно». Это приводит к тому, что использование [`heapq`](https://python-all.ru/3.2/library/heapq.html#module-heapq) для типа совпадает с поведением метода `list.sort()`. (Автор: Raymond Hettinger.)
- В конструкторы классов `httplib.HTTPConnection` и `HTTPSConnection` был добавлен необязательный параметр `timeout`, задающий таймаут в секундах. (Добавлено Facundo Batista.)
- Большинство функций модуля [`inspect`](https://python-all.ru/3.2/library/inspect.html#module-inspect), таких как `getmoduleinfo()` и `getargs()`, теперь возвращают именованные кортежи. Помимо поведения как у кортежей, элементы возвращаемого значения также можно получить как атрибуты. (Автор: Raymond Hettinger.)

  Некоторые новые функции в модуле включают `isgenerator()`, `isgeneratorfunction()`, и `isabstract()`.
- Модуль [`itertools`](https://python-all.ru/3.2/library/itertools.html#module-itertools) приобрёл несколько новых функций.

  `izip_longest(iter1, iter2, ...[, fillvalue])` создаёт кортежи из каждого из элементов; если некоторые итерируемые объекты короче других, недостающие значения устанавливаются в *fillvalue*. Например:

  ```python
  >>> tuple(itertools.izip_longest([1,2,3], [1,2,3,4,5]))
  ((1, 1), (2, 2), (3, 3), (None, 4), (None, 5))
  ```

  `product(iter1, iter2, ..., [repeat=N])` возвращает декартово произведение переданных итерируемых объектов – набор кортежей, содержащих все возможные комбинации элементов, возвращаемых каждым итерируемым объектом.

  ```python
  >>> list(itertools.product([1,2,3], [4,5,6]))
  [(1, 4), (1, 5), (1, 6),
   (2, 4), (2, 5), (2, 6),
   (3, 4), (3, 5), (3, 6)]
  ```

  Необязательный именованный аргумент *repeat* используется для вычисления произведения итерируемого объекта или набора итерируемых объектов самих на себя, повторённого *N* раз. С одним итерируемым аргументом возвращаются кортежи из *N* элементов:

  ```python
  >>> list(itertools.product([1,2], repeat=3))
  [(1, 1, 1), (1, 1, 2), (1, 2, 1), (1, 2, 2),
   (2, 1, 1), (2, 1, 2), (2, 2, 1), (2, 2, 2)]
  ```

  С двумя итерируемыми объектами возвращаются кортежи из *2N* элементов.

  ```python
  >>> list(itertools.product([1,2], [3,4], repeat=2))
  [(1, 3, 1, 3), (1, 3, 1, 4), (1, 3, 2, 3), (1, 3, 2, 4),
   (1, 4, 1, 3), (1, 4, 1, 4), (1, 4, 2, 3), (1, 4, 2, 4),
   (2, 3, 1, 3), (2, 3, 1, 4), (2, 3, 2, 3), (2, 3, 2, 4),
   (2, 4, 1, 3), (2, 4, 1, 4), (2, 4, 2, 3), (2, 4, 2, 4)]
  ```

  `combinations(iterable, r)` возвращает подпоследовательности длины *r* из элементов *iterable*.

  ```python
  >>> list(itertools.combinations('123', 2))
  [('1', '2'), ('1', '3'), ('2', '3')]
  >>> list(itertools.combinations('123', 3))
  [('1', '2', '3')]
  >>> list(itertools.combinations('1234', 3))
  [('1', '2', '3'), ('1', '2', '4'),
   ('1', '3', '4'), ('2', '3', '4')]
  ```

  `permutations(iter[, r])` возвращает все перестановки длины *r* из элементов итерируемого объекта. Если *r* не указан, по умолчанию берётся количество элементов, производимых итерируемым объектом.

  ```python
  >>> list(itertools.permutations([1,2,3,4], 2))
  [(1, 2), (1, 3), (1, 4),
   (2, 1), (2, 3), (2, 4),
   (3, 1), (3, 2), (3, 4),
   (4, 1), (4, 2), (4, 3)]
  ```

  `itertools.chain(*iterables)` – существующая функция в [`itertools`](https://python-all.ru/3.2/library/itertools.html#module-itertools), которая получила новый конструктор в Python 2.6. `itertools.chain.from_iterable(iterable)` принимает один итерируемый объект, который должен возвращать другие итерируемые объекты. `chain()` затем вернёт все элементы первого итерируемого объекта, затем все элементы второго и так далее.

  ```python
  >>> list(itertools.chain.from_iterable([[1,2,3], [4,5,6]]))
  [1, 2, 3, 4, 5, 6]
  ```

  (Всё добавлено Рэймондом Хеттингером.)
- Класс `FileHandler` модуля [`logging`](https://python-all.ru/3.2/library/logging.html#module-logging) и его подклассы `WatchedFileHandler`, `RotatingFileHandler` и `TimedRotatingFileHandler` теперь имеют необязательный параметр *delay* в своих конструкторах. Если *delay* равен true, открытие файла журнала откладывается до первого вызова `emit()`. (Автор: Vinay Sajip.)

  `TimedRotatingFileHandler` также имеет параметр конструктора *utc*. Если аргумент равен true, при определении момента полуночи и генерации имён файлов будет использоваться время UTC; в противном случае – местное время.
- В модуль [`math`](https://python-all.ru/3.2/library/math.html#module-math) было добавлено несколько новых функций:

  - [`isinf()`](https://python-all.ru/3.2/library/math.html#math.isinf) и [`isnan()`](https://python-all.ru/3.2/library/math.html#math.isnan) определяют, является ли заданное число с плавающей точкой положительной или отрицательной бесконечностью или NaN (Not a Number – не числом) соответственно.
  - [`copysign()`](https://python-all.ru/3.2/library/math.html#math.copysign) копирует знаковый бит числа IEEE 754, возвращая абсолютное значение *x*, объединённое со знаковым битом *y*. Например, `math.copysign(1, -0.0)` возвращает -1.0. (Автор: Christian Heimes.)
  - [`factorial()`](https://python-all.ru/3.2/library/math.html#math.factorial) вычисляет факториал числа. (Автор: Raymond Hettinger; [issue 2138](https://python-all.ru/3.2/whatsnew/2.6.html).)
  - [`fsum()`](https://python-all.ru/3.2/library/math.html#math.fsum) суммирует поток чисел из итерируемого объекта, стараясь избежать потери точности за счёт использования частичных сумм. (Авторы: Jean Brouwers, Raymond Hettinger и Mark Dickinson; [issue 2819](https://python-all.ru/3.2/whatsnew/2.6.html).)
  - [`acosh()`](https://python-all.ru/3.2/library/math.html#math.acosh), [`asinh()`](https://python-all.ru/3.2/library/math.html#math.asinh) и [`atanh()`](https://python-all.ru/3.2/library/math.html#math.atanh) вычисляют обратные гиперболические функции.
  - [`log1p()`](https://python-all.ru/3.2/library/math.html#math.log1p) возвращает натуральный логарифм от *1+x* (по основанию *e*).
  - `trunc()` округляет число в сторону нуля, возвращая ближайшее `Integral`, находящееся между аргументом функции и нулём. Добавлено в рамках обратного портирования [иерархии типов чисел из PEP 3141](https://python-all.ru/3.2/whatsnew/2.6.html#pep-3141).
- Модуль [`math`](https://python-all.ru/3.2/library/math.html#module-math) был улучшен для более согласованного поведения на разных платформах, особенно в части обработки исключений с плавающей точкой и специальных значений IEEE 754.

  По возможности модуль следует рекомендациям стандарта C99 относительно специальных значений IEEE 754. Например, `sqrt(-1.)` теперь почти на всех платформах должно вызывать [`ValueError`](https://python-all.ru/3.2/library/exceptions.html#ValueError), в то время как `sqrt(float('NaN'))` должно возвращать NaN на всех платформах IEEE 754. Там, где приложение F стандарта C99 рекомендует сигнализировать «деление на ноль» или «недопустимая операция», Python будет вызывать [`ValueError`](https://python-all.ru/3.2/library/exceptions.html#ValueError). Там, где приложение F рекомендует сигнализировать «переполнение», Python будет вызывать [`OverflowError`](https://python-all.ru/3.2/library/exceptions.html#OverflowError). (См. [issue 711019](https://python-all.ru/3.2/whatsnew/2.6.html) и [issue 1640](https://python-all.ru/3.2/whatsnew/2.6.html).)

  (Добавлено Кристианом Хаймсом и Марком Дикинсоном.)
- Объекты [`mmap`](https://python-all.ru/3.2/library/mmap.html#module-mmap) теперь имеют метод `rfind()`, который ищет подстроку, начиная с конца строки и двигаясь в обратном направлении. Метод `find()` также получил параметр *end*, задающий индекс, на котором следует остановить поиск. (Автор: John Lenton.)
- Модуль [`operator`](https://python-all.ru/3.2/library/operator.html#module-operator) получил функцию `methodcaller()`, которая принимает имя и необязательный набор аргументов и возвращает вызываемый объект, который будет вызывать именованную функцию с переданными ему аргументами. Например:

  ```python
  >>> # Эквивалентно lambda s: s.replace('old', 'new')
  >>> replacer = operator.methodcaller('replace', 'old', 'new')
  >>> replacer('old wine in old bottles')
  'new wine in new bottles'
  ```

  (Добавлено Георгом Брандлом по предложению Грегори Петросяна.)

  Функция `attrgetter()` теперь принимает имена с точками и выполняет соответствующий поиск атрибутов:

  ```python
  >>> inst_name = operator.attrgetter(
  ...        '__class__.__name__')
  >>> inst_name('')
  'str'
  >>> inst_name(help)
  '_Helper'
  ```

  (Добавлено Георгом Брандлом по предложению Барри Уорсо.)
- Модуль [`os`](https://python-all.ru/3.2/library/os.html#module-os) теперь включает в себя несколько новых системных вызовов. `fchmod(fd, mode)` и `fchown(fd, uid, gid)` изменяют режим и владельца открытого файла, а `lchmod(path, mode)` изменяет режим символической ссылки. (Авторы: Georg Brandl и Christian Heimes.)

  `chflags()` и `lchflags()` являются обёртками для соответствующих системных вызовов (где они доступны) и изменяют флаги файла. Константы значений флагов определены в модуле [`stat`](https://python-all.ru/3.2/library/stat.html#module-stat); некоторые возможные значения включают `UF_IMMUTABLE`, указывающий, что файл нельзя изменять, и `UF_APPEND`, указывающий, что данные можно только добавлять в файл. (Автор: M. Levinson.)

  `os.closerange(low, high)` эффективно закрывает все файловые дескрипторы от *low* до *high*, игнорируя любые ошибки и не включая сам *high*. Эта функция теперь используется модулем [`subprocess`](https://python-all.ru/3.2/library/subprocess.html#module-subprocess) для ускорения запуска процессов. (Автор: Georg Brandl; [issue 1663329](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Метод `clear()` объекта `os.environ` теперь будет не только очищать ключи объекта, но и сбрасывать переменные окружения с помощью [`os.unsetenv()`](https://python-all.ru/3.2/library/os.html#os.unsetenv). (Автор: Martin Horcicka; [issue 1181](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Функция [`os.walk()`](https://python-all.ru/3.2/library/os.html#os.walk) теперь имеет параметр `followlinks`. Если он установлен в True, функция будет следовать символическим ссылкам на каталоги и обходить их содержимое. Для обратной совместимости значение по умолчанию этого параметра – false. Учтите, что функция может войти в бесконечную рекурсию, если есть символическая ссылка, указывающая на родительский каталог. ([issue 1273829](https://python-all.ru/3.2/whatsnew/2.6.html))
- В модуле [`os.path`](https://python-all.ru/3.2/library/os.path.html#module-os.path) функция `splitext()` была изменена: теперь она не разделяет строку по начальным точкам. Это даёт лучшие результаты при работе с «точечными» файлами Unix. Например, `os.path.splitext('.ipython')` теперь возвращает `('.ipython', '')` вместо `('', '.ipython')`. ([issue 1115886](https://python-all.ru/3.2/whatsnew/2.6.html))

  Новая функция `os.path.relpath(path, start='.')` возвращает относительный путь от пути `start` (если он указан) или от текущего рабочего каталога к целевому пути `path`. (Автор: Richard Barran; [issue 1339796](https://python-all.ru/3.2/whatsnew/2.6.html).)

  В Windows [`os.path.expandvars()`](https://python-all.ru/3.2/library/os.path.html#os.path.expandvars) теперь будет раскрывать переменные окружения, заданные в форме «%var%», а «~user» будет раскрываться в путь к домашнему каталогу пользователя. (Автор: Josiah Carlson; [issue 957650](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Отладчик Python, предоставляемый модулем [`pdb`](https://python-all.ru/3.2/library/pdb.html#module-pdb), получил новую команду: «run» перезапускает отлаживаемую программу Python и может опционально принимать новые аргументы командной строки для программы. (Автор: Rocky Bernstein; [issue 1393667](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Функция [`pdb.post_mortem()`](https://python-all.ru/3.2/library/pdb.html#pdb.post_mortem), используемая для начала отладки по трассировке, теперь будет использовать трассировку, возвращаемую [`sys.exc_info()`](https://python-all.ru/3.2/library/sys.html#sys.exc_info), если трассировка не указана. (Автор: Facundo Batista; [issue 1106316](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Модуль [`pickletools`](https://python-all.ru/3.2/library/pickletools.html#module-pickletools) теперь имеет функцию `optimize()`, которая принимает строку, содержащую pickle, и удаляет некоторые неиспользуемые коды операций, возвращая более короткий pickle, содержащий ту же структуру данных. (Автор: Raymond Hettinger.)
- В модуль [`pkgutil`](https://python-all.ru/3.2/library/pkgutil.html#module-pkgutil) была добавлена функция `get_data()`, которая возвращает содержимое ресурсных файлов, входящих в установленный пакет Python. Например:

  ```python
  >>> import pkgutil
  >>> print pkgutil.get_data('test', 'exception_hierarchy.txt')
  BaseException
   +-- SystemExit
   +-- KeyboardInterrupt
   +-- GeneratorExit
   +-- Exception
        +-- StopIteration
        +-- StandardError
   ...
  ```

  (Автор: Paul Moore; [issue 2439](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Объекты `Parser` модуля `pyexpat` теперь позволяют устанавливать свой атрибут `buffer_size` для изменения размера буфера, используемого для хранения символьных данных. (Автор: Achim Gaedke; [issue 1137](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Модуль `Queue` теперь предоставляет варианты очередей, которые извлекают элементы в разном порядке. Класс `PriorityQueue` хранит элементы очереди в куче и извлекает их в порядке приоритета, а `LifoQueue` извлекает сначала наиболее недавно добавленные элементы, то есть ведёт себя как стек. (Автор: Raymond Hettinger.)
- Объекты `Random` модуля [`random`](https://python-all.ru/3.2/library/random.html#module-random) теперь можно упаковывать с помощью pickle на 32-битной системе и распаковывать на 64-битной, и наоборот. К сожалению, это изменение также означает, что объекты `Random` из Python 2.6 невозможно правильно распаковать в более ранних версиях Python. (Автор: Shawn Ligocki; [задача 1727780](https://python-all.ru/3.2/whatsnew/2.6.html).)

  Новая функция `triangular(low, high, mode)` возвращает случайные числа, подчиняющиеся треугольному распределению. Возвращаемые значения находятся между *low* и *high* (не включая сам *high*), а *mode* – наиболее часто встречающееся значение в распределении. (Авторы: Wladmir van der Laan и Raymond Hettinger; [issue 1681432](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Длительные поиски по регулярному выражению, выполняемые модулем [`re`](https://python-all.ru/3.2/library/re.html#module-re) будут проверять доставку сигналов, поэтому продолжительные поиски теперь можно прерывать. (Предложено Джошем Хойтом и Ральфом Шмиттом; [issue 846388](https://python-all.ru/3.2/whatsnew/2.6.html).)

  Модуль регулярных выражений реализован путём компиляции байт-кода для крошечной виртуальной машины, специфичной для регулярных выражений. Недоверенный код может напрямую создавать вредоносные строки байт-кода и вызывать сбои, поэтому Python 2.6 включает верификатор байт-кода регулярных выражений. (Предложено Гвидо ван Россумом на основе работы для Google App Engine; [issue 3487](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Модуль [`rlcompleter`](https://python-all.ru/3.2/library/rlcompleter.html#module-rlcompleter), его метод `Completer.complete()` теперь будет игнорировать исключения, возникающие при вычислении имени. (Исправлено Лоренцем Кваком; [issue 2250](https://python-all.ru/3.2/whatsnew/2.6.html).)
- В модуле [`sched`](https://python-all.ru/3.2/library/sched.html#module-sched) экземпляры `scheduler` теперь имеют доступный только для чтения атрибут [`queue`](https://python-all.ru/3.2/library/queue.html#module-queue), который возвращает содержимое очереди планировщика, представленное в виде списка именованных кортежей с полями `(time, priority, action, argument)`. (Предложено Раймондом Хеттингером; [issue 1861](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Модуль [`select`](https://python-all.ru/3.2/library/select.html#module-select) теперь содержит функции-обёртки для системных вызовов `epoll()` в Linux и `kqueue()` в BSD. К существующим объектам `poll` добавлен метод `modify()`; `pollobj.modify(fd, eventmask)` принимает файловый дескриптор или файловый объект и маску событий, изменяя записанную маску событий для этого файла. (Предложено Кристианом Хаймсом; [issue 1657](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Функция [`shutil.copytree()`](https://python-all.ru/3.2/library/shutil.html#shutil.copytree) теперь имеет необязательный аргумент *ignore*, который принимает вызываемый объект. Этот вызываемый объект будет получать путь к каждому каталогу и список его содержимого и возвращать список имён, которые будут игнорироваться, а не копироваться.

  Модуль [`shutil`](https://python-all.ru/3.2/library/shutil.html#module-shutil) также предоставляет функцию `ignore_patterns()` для использования с этим новым параметром. `ignore_patterns()` принимает произвольное количество шаблонов в стиле glob и возвращает вызываемый объект, который будет игнорировать все файлы и каталоги, соответствующие любому из этих шаблонов. Следующий пример копирует дерево каталогов, но пропускает как каталоги `.svn`, так и резервные файлы Emacs, имена которых заканчиваются на '~':

  ```python
  shutil.copytree('Doc/library', '/tmp/library',
                  ignore=shutil.ignore_patterns('*~', '.svn'))
  ```

  (Предложено Тареком Зиаде; [issue 2663](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Интеграция обработки сигналов с циклами событий графического интерфейса, такими как Tkinter или GTk+, долгое время была проблемой; большинство программ в итоге используют опрос, пробуждаясь каждую долю секунды, чтобы проверить, не произошли ли какие-либо события GUI. Теперь модуль [`signal`](https://python-all.ru/3.2/library/signal.html#module-signal) может сделать это более эффективно. Вызов `signal.set_wakeup_fd(fd)` устанавливает файловый дескриптор для использования; при получении сигнала в этот файловый дескриптор записывается один байт. Также существует функция на уровне C, [`PySignal_SetWakeupFd()`](https://python-all.ru/3.2/c-api/exceptions.html#PySignal_SetWakeupFd), для установки дескриптора.

  Циклы событий будут использовать это, открывая канал для создания двух дескрипторов: один для чтения, один для записи. Дескриптор записи будет передан `set_wakeup_fd()`, а дескриптор чтения будет добавлен в список дескрипторов, отслеживаемых циклом событий через `select()` или `poll()`. При получении сигнала будет записан байт, и основной цикл событий проснётся, что избавит от необходимости опроса.

  (Предложено Адамом Олсеном; [issue 1583](https://python-all.ru/3.2/whatsnew/2.6.html).)

  Функция `siginterrupt()` теперь доступна из кода Python и позволяет изменять, могут ли сигналы прерывать системные вызовы. (Предложено Ральфом Шмиттом.)

  Функции `setitimer()` и `getitimer()` также были добавлены (там, где они доступны). `setitimer()` позволяет устанавливать интервальные таймеры, которые вызовут отправку сигнала процессу по истечении заданного времени, измеряемого в реальном времени, затраченном процессорном времени или суммарном времени процесса и системы. (Предложено Гильерме Поло; [issue 2240](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Модуль [`smtplib`](https://python-all.ru/3.2/library/smtplib.html#module-smtplib) теперь поддерживает SMTP через SSL благодаря добавлению класса `SMTP_SSL`. Этот класс поддерживает интерфейс, идентичный существующему классу `SMTP`. (Предложено Монти Тейлором.) Оба конструктора классов также имеют необязательный параметр `timeout`, задающий тайм-аут для начальной попытки подключения, измеряемый в секундах. (Предложено Факундо Батистой.)

  В модуль также была добавлена реализация протокола LMTP ([**RFC 2033**](https://python-all.ru/3.2/whatsnew/2.6.html)). LMTP используется вместо SMTP при передаче электронной почты между агентами, которые не управляют почтовой очередью. (LMTP реализован Лейфом Хедстрёмом; [issue 957003](https://python-all.ru/3.2/whatsnew/2.6.html).)

  `SMTP.starttls()` теперь соответствует [**RFC 3207**](https://python-all.ru/3.2/whatsnew/2.6.html) и забывает любые знания, полученные от сервера, не полученные в результате самого согласования TLS. (Патч предложен Биллом Феннером; [issue 829951](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Модуль [`socket`](https://python-all.ru/3.2/library/socket.html#module-socket) теперь поддерживает TIPC ([http://tipc.sf.net](https://python-all.ru/3.2/whatsnew/2.6.html)), высокопроизводительный протокол, не основанный на IP, предназначенный для использования в кластерных средах. Адреса TIPC представляют собой кортежи из 4 или 5 элементов. (Автор: Alberto Bertogli; [issue 1646](https://python-all.ru/3.2/whatsnew/2.6.html).)

  Новая функция `create_connection()` принимает адрес и подключается к нему, используя необязательное значение тайм-аута, возвращая подключённый объект сокета. Эта функция также определяет тип адреса и подключается с использованием IPv4 или IPv6 по ситуации. Чтобы ваш код работал с IPv6, может быть достаточно использовать `create_connection()` вместо `socket(socket.AF_INET, ...)`.
- Базовые классы модуля `SocketServer` теперь поддерживают вызов метода `handle_timeout()` после периода бездействия, заданного атрибутом сервера `timeout`. (Предложено Майклом Помранингом.) Метод `serve_forever()` теперь принимает необязательный интервал опроса, измеряемый в секундах, определяющий, как часто сервер будет проверять запрос на завершение работы. (Предложено Педро Вернеком и Джеффри Яскиным; [issue 742598](https://python-all.ru/3.2/whatsnew/2.6.html), [issue 1193577](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Модуль [`sqlite3`](https://python-all.ru/3.2/library/sqlite3.html#module-sqlite3), поддерживаемый Герхардом Херингом, обновлён с версии 2.3.2 в Python 2.5 до версии 2.4.1.
- Модуль [`struct`](https://python-all.ru/3.2/library/struct.html#module-struct) теперь поддерживает тип C99 `_Bool`, с использованием символа формата `'?'`. (Предложено Дэвидом Ремалем.)
- Объекты `Popen`, предоставляемые модулем [`subprocess`](https://python-all.ru/3.2/library/subprocess.html#module-subprocess), теперь имеют методы `terminate()`, `kill()` и `send_signal()`. В Windows `send_signal()` поддерживает только сигнал `SIGTERM`, и все эти методы являются псевдонимами функции Win32 API `TerminateProcess()`. (Предложено Кристианом Хаймсом.)
- Новая переменная в модуле [`sys`](https://python-all.ru/3.2/library/sys.html#module-sys), `float_info`, представляет собой объект, содержащий информацию, полученную из файла `float.h` о поддержке чисел с плавающей точкой на платформе. Атрибуты этого объекта включают `mant_dig` (количество цифр в мантиссе), `epsilon` (наименьшая разница между 1.0 и следующим представимым большим значением) и несколько других. (Предложено Кристианом Хаймсом; [issue 1534](https://python-all.ru/3.2/whatsnew/2.6.html).)

  Another new variable, `dont_write_bytecode`, controls whether Python writes any `.pyc` or `.pyo` files on importing a module. If this variable is true, the compiled files are not written. The variable is initially set on start-up by supplying the [*-B*](https://python-all.ru/3.2/using/cmdline.html#cmdoption-B) switch to the Python interpreter, or by setting the [`PYTHONDONTWRITEBYTECODE`](https://python-all.ru/3.2/using/cmdline.html#envvar-PYTHONDONTWRITEBYTECODE) environment variable before running the interpreter. Python code can subsequently change the value of this variable to control whether bytecode files are written or not. (Contributed by Neal Norwitz and Georg Brandl.)

  Информация об аргументах командной строки, переданных интерпретатору Python, доступна через чтение атрибутов именованного кортежа, доступного как `sys.flags`. Например, атрибут `verbose` истинен, если Python был запущен в подробном режиме, `debug` истинен в режиме отладки и т.д. Все эти атрибуты доступны только для чтения. (Предложено Кристианом Хаймсом.)

  Новая функция `getsizeof()` принимает объект Python и возвращает объём памяти, используемый объектом, измеряемый в байтах. Встроенные объекты возвращают корректные результаты; сторонние расширения могут этого не делать, но могут определить метод `__sizeof__()` для возврата размера объекта. (Предложено Робертом Шуппенисом; [issue 2898](https://python-all.ru/3.2/whatsnew/2.6.html).)

  Теперь можно определить текущие функции профилировщика и трассировщика, вызвав [`sys.getprofile()`](https://python-all.ru/3.2/library/sys.html#sys.getprofile) и [`sys.gettrace()`](https://python-all.ru/3.2/library/sys.html#sys.gettrace). (Предложено Георгом Брандлем; [issue 1648](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Модуль [`tarfile`](https://python-all.ru/3.2/library/tarfile.html#module-tarfile) теперь поддерживает tar-файлы POSIX.1-2001 (pax) в дополнение к уже поддерживаемым форматам POSIX.1-1988 (ustar) и GNU tar. Формат по умолчанию – GNU tar; укажите параметр `format`, чтобы открыть файл в другом формате:

  ```python
  tar = tarfile.open("output.tar", "w",
                     format=tarfile.PAX_FORMAT)
  ```

  Новые параметры `encoding` и `errors` задают кодировку и схему обработки ошибок для преобразования символов. `'strict'`, `'ignore'` и `'replace'` – три стандартных способа обработки ошибок в Python; `'utf-8'` – специальное значение, которое заменяет плохие символы их представлением в UTF-8. (Преобразование символов происходит потому, что формат PAX поддерживает имена файлов в Юникоде, по умолчанию используется кодировка UTF-8.)

  Метод `TarFile.add()` теперь принимает аргумент `exclude`, который является функцией, используемой для исключения определённых имён файлов из архива. Функция должна принимать имя файла и возвращать true, если файл следует исключить, или false, если его следует архивировать. Функция применяется как к имени, изначально переданному `add()`, так и к именам файлов в рекурсивно добавляемых каталогах.

  (Все изменения выполнены Lars Gustäbel.)
- Необязательный параметр `timeout` был добавлен в конструктор класса [`telnetlib.Telnet`](https://python-all.ru/3.2/library/telnetlib.html#telnetlib.Telnet), задающий тайм-аут в секундах. (Добавлено Факундо Батистой.)
- Класс [`tempfile.NamedTemporaryFile`](https://python-all.ru/3.2/library/tempfile.html#tempfile.NamedTemporaryFile) обычно удаляет созданный временный файл при закрытии. Теперь это поведение можно изменить, передав `delete=False` конструктору. (Предложено Дэмиеном Миллером; [issue 1537850](https://python-all.ru/3.2/whatsnew/2.6.html).)

  Новый класс `SpooledTemporaryFile` ведёт себя как временный файл, но хранит данные в памяти до превышения максимального размера. При достижении этого предела содержимое записывается во временный файл на диске. (Автор: Dustin J. Mitchell.)

  Классы `NamedTemporaryFile` и `SpooledTemporaryFile` оба работают как контекстные менеджеры, поэтому можно написать `with tempfile.NamedTemporaryFile() as tmp: ...`. (Автор: Alexander Belopolsky; [issue 2021](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Модуль `test.test_support` получил несколько контекстных менеджеров, полезных для написания тестов. `EnvironmentVarGuard()` – это контекстный менеджер, который временно изменяет переменные окружения и автоматически восстанавливает их старые значения.

  Ещё один контекстный менеджер, `TransientResource`, может обрамлять вызовы ресурсов, которые могут быть недоступны; он перехватывает и игнорирует указанный список исключений. Например, сетевой тест может игнорировать определённые ошибки при подключении к внешнему веб-сайте:

  ```python
  with test_support.TransientResource(IOError,
                                  errno=errno.ETIMEDOUT):
      f = urllib.urlopen('https://sf.net')
      ...
  ```

  Наконец, `check_warnings()` сбрасывает фильтры предупреждений модуля `warning` и возвращает объект, который будет записывать все возникающие предупреждения ([issue 3781](https://python-all.ru/3.2/whatsnew/2.6.html)):

  ```python
  with test_support.check_warnings() as wrec:
      warnings.simplefilter("always")
      # ... код, вызывающий предупреждение ...
      assert str(wrec.message) == "function is outdated"
      assert len(wrec.warnings) == 1, "Multiple warnings raised"
  ```

  (Автор: Бретт Кэннон.)
- Модуль [`textwrap`](https://python-all.ru/3.2/library/textwrap.html#module-textwrap) теперь может сохранять существующие пробелы в начале и конце новых строк, если указать `drop_whitespace=False` в качестве аргумента:

  ```python
  >>> S = """This  sentence  has a bunch   of
  ...   extra   whitespace."""
  >>> print textwrap.fill(S, width=15)
  This  sentence
  has a bunch
  of    extra
  whitespace.
  >>> print textwrap.fill(S, drop_whitespace=False, width=15)
  This  sentence
    has a bunch
     of    extra
     whitespace.
  >>>
  ```

  (Автор: Dwayne Bailey; [issue 1581073](https://python-all.ru/3.2/whatsnew/2.6.html).)
- API модуля [`threading`](https://python-all.ru/3.2/library/threading.html#module-threading) изменяется для использования свойств, таких как `daemon`, вместо методов `setDaemon()` и `isDaemon()`, а некоторые методы переименованы с использованием подчёркиваний вместо верблюжьего регистра; например, метод `activeCount()` переименован в `active_count()`. Версии модуля 2.6 и 3.0 поддерживают одни и те же свойства и переименованные методы, но старые методы не удаляются. Дата устаревания старых API в Python 3.x не установлена; старые API не будут удалены ни в одной версии 2.x. (Реализовано несколькими людьми, в первую очередь Бенджамином Петерсоном.)

  Потоковые объекты `Thread` модуля [`threading`](https://python-all.ru/3.2/library/threading.html#module-threading) получили свойство `ident`, возвращающее идентификатор потока – ненулевое целое число. (Автор: Gregory P. Smith; [issue 2871](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Модуль [`timeit`](https://python-all.ru/3.2/library/timeit.html#module-timeit) теперь принимает как вызываемые объекты, так и строки для измеряемого выражения и кода настройки. Были добавлены две вспомогательные функции для создания экземпляров `Timer`: `repeat(stmt, setup, time, repeat, number)` и `timeit(stmt, setup, time, number)` создают экземпляр и вызывают соответствующий метод. (Автор: Erik Demaine; [issue 1533909](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Модуль `Tkinter` теперь принимает списки и кортежи для опций, разделяя элементы пробелами перед передачей результирующего значения в Tcl/Tk. (Автор: Guilherme Polo; [issue 2906](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Модуль [`turtle`](https://python-all.ru/3.2/library/turtle.html#module-turtle) для черепашьей графики был значительно улучшен Gregor Lingl. Новые возможности модуля включают:

  - Улучшенная анимация движения и поворота черепахи.
  - Управление движением черепахи с помощью новых методов `delay()`, `tracer()` и `speed()`.
  - Возможность задавать новые формы для черепахи и определять новую систему координат.
  - Черепахи теперь имеют метод `undo()`, который может отменять действия.
  - Простая поддержка реакции на события ввода, такие как активность мыши и клавиатуры, что позволяет писать простые игры.
  - Файл `turtle.cfg` можно использовать для настройки начального вида экрана черепахи.
  - Докстринги модуля могут быть заменены новыми докстрингами, переведёнными на другой язык.

  ([issue 1513695](https://python-all.ru/3.2/whatsnew/2.6.html))
- Необязательный параметр `timeout` был добавлен в функцию `urllib.urlopen()` и конструктор класса `urllib.ftpwrapper`, а также в функцию `urllib2.urlopen()`. Параметр задаёт тайм-аут в секундах. Например:

  ```python
  >>> u = urllib2.urlopen("http://slow.example.com",
                          timeout=3)
  Traceback (most recent call last):
    ...
  urllib2.URLError: <urlopen error timed out>
  >>>
  ```

  (Добавлено Facundo Batista.)
- База данных Unicode, предоставляемая модулем [`unicodedata`](https://python-all.ru/3.2/library/unicodedata.html#module-unicodedata), обновлена до версии 5.1.0. (Обновлено Martin von Löwis; [issue 3811](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Функции `formatwarning()` и `showwarning()` модуля [`warnings`](https://python-all.ru/3.2/library/warnings.html#module-warnings) получили необязательный аргумент *line*, который можно использовать для передачи строки исходного кода. (Добавлено в рамках [issue 1631171](https://python-all.ru/3.2/whatsnew/2.6.html), в котором часть модуля [`warnings`](https://python-all.ru/3.2/library/warnings.html#module-warnings) была переписана на C.)

  Новая функция `catch_warnings()` – это контекстный менеджер, предназначенный для тестирования, позволяющий временно изменять фильтры предупреждений, а затем восстанавливать их исходные значения ([issue 3781](https://python-all.ru/3.2/whatsnew/2.6.html)).
- Классы XML-RPC `SimpleXMLRPCServer` и `DocXMLRPCServer` теперь можно предотвратить от немедленного открытия и привязки к своему сокету, передав True в качестве параметра конструктора `bind_and_activate`. Это можно использовать для изменения атрибута экземпляра `allow_reuse_address` перед вызовом методов `server_bind()` и `server_activate()` для открытия сокета и начала прослушивания соединений. (Автор: Peter Parente; [issue 1599845](https://python-all.ru/3.2/whatsnew/2.6.html).)

  `SimpleXMLRPCServer` также имеет атрибут `_send_traceback_header`; если он истинен, исключение и форматированная трассировка возвращаются в виде HTTP-заголовков «X-Exception» и «X-Traceback». Эта функция предназначена только для отладки и не должна использоваться на производственных серверах, так как трассировки могут раскрыть пароли или другую конфиденциальную информацию. (Автор: Alan McIntyre в рамках его проекта для Google Summer of Code 2007.)
- Модуль `xmlrpclib` больше не преобразует автоматически [`datetime.date`](https://python-all.ru/3.2/library/datetime.html#datetime.date) и [`datetime.time`](https://python-all.ru/3.2/library/datetime.html#datetime.time) в тип `xmlrpclib.DateTime`; семантика преобразования была не всегда корректна для всех приложений. Код, использующий `xmlrpclib`, должен преобразовывать экземпляры `date` и [`time`](https://python-all.ru/3.2/library/time.html#module-time) самостоятельно. ([issue 1330538](https://python-all.ru/3.2/whatsnew/2.6.html)) Код также может обрабатывать даты до 1900 года (автор: Ralf Schmitt; [issue 2014](https://python-all.ru/3.2/whatsnew/2.6.html)) и 64-битные целые числа, представленные с помощью `<i8>` в ответах XML-RPC (автор: Riku Lindblad; [issue 2985](https://python-all.ru/3.2/whatsnew/2.6.html)).
- Класс `ZipFile` модуля [`zipfile`](https://python-all.ru/3.2/library/zipfile.html#module-zipfile) теперь имеет методы `extract()` и `extractall()`, которые распаковывают один файл или все файлы архива в текущий каталог или в указанный каталог:

  ```python
  z = zipfile.ZipFile('python-251.zip')

  # Распаковать один файл, записывая его относительно
  # в каталог /tmp.
  z.extract('Python/sysmodule.c', '/tmp')

  # Распаковать все файлы из архива.
  z.extractall()
  ```

  (Автор: Alan McIntyre; [issue 467924](https://python-all.ru/3.2/whatsnew/2.6.html).)

  Методы [`open()`](https://python-all.ru/3.2/library/functions.html#open), `read()` и `extract()` теперь могут принимать как имя файла, так и объект `ZipInfo`. Это полезно, если архив случайно содержит дублирующееся имя файла. (Автор: Graham Horler; [issue 1775025](https://python-all.ru/3.2/whatsnew/2.6.html).)

  Наконец, [`zipfile`](https://python-all.ru/3.2/library/zipfile.html#module-zipfile) теперь поддерживает имена файлов в Unicode для архивов. (Автор: Alexey Borzenkov; [issue 1734346](https://python-all.ru/3.2/whatsnew/2.6.html).)

### Модуль [`ast`](https://python-all.ru/3.2/library/ast.html#module-ast)

Модуль [`ast`](https://python-all.ru/3.2/library/ast.html#module-ast) предоставляет представление Python-кода в виде абстрактного синтаксического дерева (AST), и Armin Ronacher добавил набор вспомогательных функций, выполняющих различные распространённые задачи. Они будут полезны для пакетов HTML-шаблонов, анализаторов кода и подобных инструментов, обрабатывающих код Python.

Функция `parse()` принимает выражение и возвращает AST. Функция `dump()` выводит представление дерева, подходящее для отладки:

```python
import ast

t = ast.parse("""
d = {}
for i in 'abcdefghijklm':
    d[i + i] = ord(i) - ord('a') + 1
print d
""")
print ast.dump(t)
```

Это выводит глубоко вложенное дерево:

```python
Module(body=[
  Assign(targets=[
    Name(id='d', ctx=Store())
   ], value=Dict(keys=[], values=[]))
  For(target=Name(id='i', ctx=Store()),
      iter=Str(s='abcdefghijklm'), body=[
    Assign(targets=[
      Subscript(value=
        Name(id='d', ctx=Load()),
          slice=
          Index(value=
            BinOp(left=Name(id='i', ctx=Load()), op=Add(),
             right=Name(id='i', ctx=Load()))), ctx=Store())
     ], value=
     BinOp(left=
      BinOp(left=
       Call(func=
        Name(id='ord', ctx=Load()), args=[
          Name(id='i', ctx=Load())
         ], keywords=[], starargs=None, kwargs=None),
       op=Sub(), right=Call(func=
        Name(id='ord', ctx=Load()), args=[
          Str(s='a')
         ], keywords=[], starargs=None, kwargs=None)),
       op=Add(), right=Num(n=1)))
    ], orelse=[])
   Print(dest=None, values=[
     Name(id='d', ctx=Load())
   ], nl=True)
 ])
```

Метод `literal_eval()` принимает строку или AST, представляющее литеральное выражение, анализирует и вычисляет его, а затем возвращает полученное значение. Литеральное выражение – это выражение Python, содержащее только строки, числа, словари и т.д., но без инструкций или вызовов функций. Если нужно вычислить выражение, но нельзя принять риск безопасности при использовании [`eval()`](https://python-all.ru/3.2/library/functions.html#eval), `literal_eval()` выполнит это безопасно:

```python
>>> literal = '("a", "b", {2:4, 3:8, 1:2})'
>>> print ast.literal_eval(literal)
('a', 'b', {1: 2, 2: 4, 3: 8})
>>> print ast.literal_eval('"a" + "b"')
Traceback (most recent call last):
  ...
ValueError: malformed string
```

The module also includes `NodeVisitor` and `NodeTransformer` classes for traversing and modifying an AST, and functions for common transformations such as changing line numbers.

### Модуль `future_builtins`

Python 3.0 вносит множество изменений в набор встроенных функций, и большинство из них нельзя перенести в серию Python 2.x, так как это нарушит совместимость. Модуль `future_builtins` предоставляет версии этих встроенных функций, которые можно импортировать при написании кода, совместимого с Python 3.0.

Функции в этом модуле в настоящее время включают:

- `ascii(obj)`: эквивалентно [`repr()`](https://python-all.ru/3.2/library/functions.html#repr). В Python 3.0 [`repr()`](https://python-all.ru/3.2/library/functions.html#repr) будет возвращать строку Unicode, а [`ascii()`](https://python-all.ru/3.2/library/functions.html#ascii) будет возвращать чистую ASCII-байтовую строку.
- `filter(predicate, iterable)`, `map(func, iterable1, ...)`: в версии 3.0 эти функции возвращают итераторы, в отличие от встроенных функций 2.x, которые возвращали списки.
- `hex(value)`, `oct(value)`: вместо вызова методов `__hex__()` или `__oct__()` эти версии будут вызывать метод [`__index__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__index__) и преобразовывать результат в шестнадцатеричное или восьмеричное представление. [`oct()`](https://python-all.ru/3.2/library/functions.html#oct) будет использовать новую нотацию `0o` для своего результата.

### Модуль [`json`](https://python-all.ru/3.2/library/json.html#module-json): JavaScript Object Notation

Новый модуль [`json`](https://python-all.ru/3.2/library/json.html#module-json) поддерживает кодирование и декодирование типов Python в JSON (Javascript Object Notation). JSON – это легковесный формат обмена данными, часто используемый в веб-приложениях. Дополнительную информацию о JSON можно найти по адресу [http://www.json.org](https://python-all.ru/3.2/whatsnew/2.6.html).

[`json`](https://python-all.ru/3.2/library/json.html#module-json) поставляется с поддержкой декодирования и кодирования большинства встроенных типов Python. Следующий пример кодирует и декодирует словарь:

```python
>>> import json
>>> data = {"spam" : "foo", "parrot" : 42}
>>> in_json = json.dumps(data) # Закодировать данные
>>> in_json
'{"parrot": 42, "spam": "foo"}'
>>> json.loads(in_json) # Декодировать в объект Python
{"spam" : "foo", "parrot" : 42}
```

Также можно написать собственные декодеры и кодеры для поддержки большего количества типов. Также поддерживается pretty-printing JSON-строк.

[`json`](https://python-all.ru/3.2/library/json.html#module-json) (изначально назывался simplejson) был написан Бобом Ипполито.

### Модуль [`plistlib`](https://python-all.ru/3.2/library/plistlib.html#module-plistlib): парсер Property-List

Формат `.plist` широко используется в Mac OS X для хранения базовых типов данных (чисел, строк, списков и словарей) путём их сериализации в XML-подобный формат. Он напоминает сериализацию типов данных XML-RPC.

Несмотря на то, что этот формат в основном используется в Mac OS X, в нём нет ничего специфичного для Mac, и реализация на Python работает на любой платформе, которую поддерживает Python, поэтому модуль [`plistlib`](https://python-all.ru/3.2/library/plistlib.html#module-plistlib) был перенесён в стандартную библиотеку.

Использовать модуль просто:

```python
import sys
import plistlib
import datetime

# Создать структуру данных
data_struct = dict(lastAccessed=datetime.datetime.now(),
                   version=1,
                   categories=('Personal','Shared','Private'))

# Создать строку, содержащую XML.
plist_str = plistlib.writePlistToString(data_struct)
new_struct = plistlib.readPlistFromString(plist_str)
print data_struct
print new_struct

# Записать структуру данных в файл и прочитать её обратно.
plistlib.writePlist(data_struct, '/tmp/customizations.plist')
new_struct = plistlib.readPlist('/tmp/customizations.plist')

# read/writePlist принимает как файлоподобные объекты, так и пути.
plistlib.writePlist(data_struct, sys.stdout)
```

### Улучшения ctypes

Томас Хеллер продолжал поддерживать и улучшать модуль [`ctypes`](https://python-all.ru/3.2/library/ctypes.html#module-ctypes).

[`ctypes`](https://python-all.ru/3.2/library/ctypes.html#module-ctypes) теперь поддерживает тип данных `c_bool`, представляющий тип C99 `bool`. (Предложено Дэвидом Ремалем; [issue 1649190](https://python-all.ru/3.2/whatsnew/2.6.html).)

Типы строк, буферов и массивов [`ctypes`](https://python-all.ru/3.2/library/ctypes.html#module-ctypes) получили улучшенную поддержку расширенного синтаксиса срезов, где можно указывать различные комбинации `(start, stop, step)`. (Реализовано Томасом Ваутерсом.)

Все типы данных [`ctypes`](https://python-all.ru/3.2/library/ctypes.html#module-ctypes) теперь поддерживают методы `from_buffer()` и `from_buffer_copy()`, которые создают экземпляр ctypes на основе предоставленного буферного объекта. `from_buffer_copy()` копирует содержимое объекта, а `from_buffer()` использует ту же область памяти.

Новое соглашение о вызовах указывает [`ctypes`](https://python-all.ru/3.2/library/ctypes.html#module-ctypes) очищать переменные `errno` или Win32 LastError при каждом обёрнутом вызове. (Реализовано Томасом Хеллером; [issue 1798](https://python-all.ru/3.2/whatsnew/2.6.html).)

Теперь можно получить значение переменной Unix `errno` после вызова функции. При создании обёрнутой функции можно передать `use_errno=True` в качестве именованного параметра функции `DLL()`, а затем вызывать методы модуля `set_errno()` и `get_errno()` для установки и получения значения ошибки.

Переменная Win32 LastError аналогичным образом поддерживается функциями `DLL()`, `OleDLL()` и `WinDLL()`. Необходимо передать `use_last_error=True` в качестве именованного параметра, а затем вызывать методы модуля `set_last_error()` и `get_last_error()`.

Функция `byref()`, используемая для получения указателя на экземпляр ctypes, теперь имеет необязательный параметр *offset*, который представляет собой количество байтов, добавляемое к возвращаемому указателю.

### Улучшенная поддержка SSL

Билл Янссен внёс значительные улучшения в поддержку Secure Sockets Layer в Python 2.6, добавив новый модуль [`ssl`](https://python-all.ru/3.2/library/ssl.html#module-ssl), построенный на основе библиотеки [OpenSSL](https://python-all.ru/3.2/whatsnew/2.6.html). Этот новый модуль предоставляет более тонкий контроль над согласованным протоколом, используемыми сертификатами X.509 и лучше поддерживает написание SSL-серверов (в отличие от клиентов) на Python. Существующая поддержка SSL в модуле [`socket`](https://python-all.ru/3.2/library/socket.html#module-socket) не была удалена и продолжает работать, хотя она будет удалена в Python 3.0.

Чтобы использовать новый модуль, сначала необходимо обычным способом создать TCP-соединение, а затем передать его функции [`ssl.wrap_socket()`](https://python-all.ru/3.2/library/ssl.html#ssl.wrap_socket). Можно указать, требуется ли сертификат, и получить информацию о сертификате, вызвав метод `getpeercert()`.

> **См. также**
>
> Документация по модулю [`ssl`](https://python-all.ru/3.2/library/ssl.html#module-ssl).

## Устаревания и удаления

- Строковые исключения удалены. Попытка их использовать вызывает [`TypeError`](https://python-all.ru/3.2/library/exceptions.html#TypeError).
- Продолжаются изменения интерфейса [`исключения`](https://python-all.ru/3.2/library/exceptions.html#Exception), обусловленные [**PEP 352**](https://python-all.ru/3.2/whatsnew/2.6.html). Для версии 2.6 атрибут `message` устарел в пользу атрибута `args`.
- (Режим предупреждений о 3.0) В Python 3.0 будет реорганизована стандартная библиотека: многие устаревшие модули будут удалены, а другие переименованы. Python 2.6, запущенный в режиме предупреждений о 3.0, будет выдавать предупреждения об этих модулях при их импорте.

  Список устаревших модулей: `audiodev`, `bgenlocations`, `buildtools`, `bundlebuilder`, `Canvas`, `compiler`, `dircache`, `dl`, `fpformat`, `gensuitemodule`, `ihooks`, `imageop`, `imgfile`, `linuxaudiodev`, `mhlib`, `mimetools`, `multifile`, `new`, `pure`, `statvfs`, `sunaudiodev`, `test.testall`, и `toaiff`.
- Модуль `gopherlib` был удалён.
- Модули `MimeWriter` и `mimify` устарели; вместо них используйте пакет [`email`](https://python-all.ru/3.2/library/email.html#module-email).
- Модуль `md5` устарел; используйте модуль [`hashlib`](https://python-all.ru/3.2/library/hashlib.html#module-hashlib).
- Модуль `posixfile` устарел; [`fcntl.lockf()`](https://python-all.ru/3.2/library/fcntl.html#fcntl.lockf) обеспечивает лучшую блокировку.
- Модуль `popen2` устарел; используйте модуль [`подпроцесс`](https://python-all.ru/3.2/library/subprocess.html#module-subprocess).
- Модуль `rgbimg` был удалён.
- Модуль `sets` объявлен устаревшим; лучше использовать встроенные типы [`set`](https://python-all.ru/3.2/library/stdtypes.html#set) и [`frozenset`](https://python-all.ru/3.2/library/stdtypes.html#frozenset).
- Модуль `sha` устарел; вместо него используйте модуль [`hashlib`](https://python-all.ru/3.2/library/hashlib.html#module-hashlib).

## Изменения в сборке и C API

Изменения процесса сборки Python и C API включают:

- Python теперь нужно компилировать компиляторами C89 (спустя 19 лет!). Это означает, что в исходном коде Python удалены собственные реализации `memmove()` и `strerror()`, которые есть в стандартной библиотеке C89.
- Python 2.6 можно собрать с помощью Microsoft Visual Studio 2008 (версия 9.0), и это новый компилятор по умолчанию. Файлы сборки находятся в каталоге `PCbuild`. (Реализовано Кристианом Хаймсом.)
- На Mac OS X Python 2.6 можно скомпилировать как универсальную сборку с четырьмя архитектурами. Скрипт **configure** принимает ключ *--with-universal-archs=\[32-bit|64-bit|all\]*, который определяет, собирать ли двоичные файлы для 32-разрядных архитектур (x86, PowerPC), 64-разрядных (x86-64 и PPC-64) или для обеих. (Предложено Рональдом Оссуреном.)
- Модуль BerkeleyDB теперь имеет объект C API, доступный как `bsddb.db.api`. Этот объект могут использовать другие расширения на C, которые хотят применять модуль `bsddb` для своих целей. (Предложено Дунканом Грисби.)
- Новый интерфейс буферов, описанный ранее в разделе [PEP 3118](https://python-all.ru/3.2/whatsnew/2.6.html#pep-3118-revised-buffer-protocol), добавляет функции [`PyObject_GetBuffer()`](https://python-all.ru/3.2/c-api/buffer.html#PyObject_GetBuffer) и [`PyBuffer_Release()`](https://python-all.ru/3.2/c-api/buffer.html#PyBuffer_Release), а также несколько других.
- Использование Python библиотеки C stdio теперь потокобезопасно, по крайней мере настолько, насколько потокобезопасна сама библиотека. Раньше существовала потенциальная ошибка: если один поток закрывал файловый объект, пока другой поток читал из него или записывал в него. В Python 2.6 файловые объекты имеют счётчик ссылок, управляемый функциями `PyFile_IncUseCount()` и `PyFile_DecUseCount()`. Файловый объект нельзя закрыть, пока счётчик ссылок не станет равен нулю. `PyFile_IncUseCount()` должна вызываться, пока GIL ещё удерживается, перед выполнением операции ввода-вывода с использованием указателя `FILE *`, а `PyFile_DecUseCount()` должна вызываться сразу после повторного захвата GIL. (Предложено Антуаном Питру и Грегори П. Смитом.)
- Одновременный импорт модулей в двух разных потоках больше не приводит к взаимоблокировке; теперь вместо этого возникает исключение [`ImportError`](https://python-all.ru/3.2/library/exceptions.html#ImportError). Новая функция API, [`PyImport_ImportModuleNoBlock()`](https://python-all.ru/3.2/c-api/import.html#PyImport_ImportModuleNoBlock), сначала ищет модуль в `sys.modules`, а затем пытается импортировать его после захвата блокировки импорта. Если блокировка импорта удерживается другим потоком, возбуждается [`ImportError`](https://python-all.ru/3.2/library/exceptions.html#ImportError). (Предложено Кристианом Хаймсом.)
- Несколько функций возвращают информацию о поддержке чисел с плавающей запятой на платформе. [`PyFloat_GetMax()`](https://python-all.ru/3.2/c-api/float.html#PyFloat_GetMax) возвращает максимальное представимое значение с плавающей запятой, а [`PyFloat_GetMin()`](https://python-all.ru/3.2/c-api/float.html#PyFloat_GetMin) – минимальное положительное значение. [`PyFloat_GetInfo()`](https://python-all.ru/3.2/c-api/float.html#PyFloat_GetInfo) возвращает объект, содержащий больше информации из файла `float.h`, например `"mant_dig"` (количество цифр в мантиссе), `"epsilon"` (наименьшая разница между 1.0 и следующим большим представимым значением) и несколько других. (Предложено Кристианом Хаймсом; [issue 1534](https://python-all.ru/3.2/whatsnew/2.6.html).)
- C-функции и методы, использующие [`PyComplex_AsCComplex()`](https://python-all.ru/3.2/c-api/complex.html#PyComplex_AsCComplex), теперь принимают аргументы, имеющие метод [`__complex__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__complex__). В частности, функции модуля [`cmath`](https://python-all.ru/3.2/library/cmath.html#module-cmath) теперь будут принимать объекты с этим методом. Это обратный порт изменения из Python 3.0. (Предложено Марком Дикинсоном; [issue 1675423](https://python-all.ru/3.2/whatsnew/2.6.html).)
- C API Python теперь включает две функции для сравнения строк без учёта регистра: `PyOS_stricmp(char*, char*)` и `PyOS_strnicmp(char*, char*, Py_ssize_t)`. (Предложено Кристианом Хаймсом; [issue 1635](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Многие расширения на C определяют собственные небольшие макросы для добавления целых чисел и строк в словарь модуля в функции `init*`. Python 2.6 наконец определяет стандартные макросы для добавления значений в модуль: [`PyModule_AddStringMacro`](https://python-all.ru/3.2/c-api/module.html#PyModule_AddStringMacro) и `PyModule_AddIntMacro()`. (Предложено Кристианом Хаймсом.)
- Некоторые макросы были переименованы как в Python 3.0, так и в 2.6, чтобы яснее показать, что это макросы, а не функции. `Py_Size()` стал `Py_SIZE()`, `Py_Type()` стал `Py_TYPE()`, а `Py_Refcnt()` стал `Py_REFCNT()`. Макросы со смешанным регистром по-прежнему доступны в Python 2.6 для обратной совместимости. ([issue 1629](https://python-all.ru/3.2/whatsnew/2.6.html))
- Distutils теперь помещает расширения на C, которые он собирает, в другой каталог при работе с отладочной версией Python. (Предложено Коллином Уинтером; [issue 1530959](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Некоторые базовые типы данных, такие как целые числа и строки, поддерживают внутренние списки свободных объектов, которые можно повторно использовать. Структуры данных для этих списков теперь следуют соглашению об именовании: переменная всегда называется `free_list`, счётчик всегда называется `numfree`, и всегда определяется макрос `Py<typename>_MAXFREELIST`.
- Новая цель Makefile, «make patchcheck», подготавливает исходное дерево Python к созданию патча: исправляет завершающие пробелы во всех изменённых файлах `.py`, проверяет, была ли изменена документация, и сообщает, обновлены ли файлы `Misc/ACKS` и `Misc/NEWS`. (Предложено Бреттом Кэнноном.)

  Еще одна новая цель, «make profile-opt», компилирует двоичный файл Python с использованием профильно-ориентированной оптимизации GCC. Она компилирует Python с включенным профилированием, запускает набор тестов для получения набора результатов профилирования, а затем компилирует с использованием этих результатов для оптимизации. (Автор: Грегори П. Смит.)

### Изменения для конкретных платформ: Windows

- Поддержка Windows 95, 98, ME и NT4 прекращена. Python 2.6 требует по крайней мере Windows 2000 SP4.
- Новый компилятор по умолчанию в Windows – Visual Studio 2008 (версия 9.0). Каталоги сборки для Visual Studio 2003 (версия 7.1) и 2005 (версия 8.0) были перемещены в каталог PC/. Новый каталог `PCbuild` поддерживает кросс-компиляцию для X64, отладочные сборки и профильную оптимизацию (PGO). Сборки с PGO примерно на 10% быстрее обычных. (Предложено Кристианом Хаймсом с помощью Амори Форжо д’Арка и Мартина фон Лёвиса.)
- Модуль [`msvcrt`](https://python-all.ru/3.2/library/msvcrt.html#module-msvcrt) теперь поддерживает как обычные, так и широкосимвольные варианты консольного I/O API. Функция `getwch()` считывает нажатие клавиши и возвращает значение Unicode, так же как и функция `getwche()`. Функция `putwch()` принимает символ Unicode и выводит его на консоль. (Предложено Кристианом Хаймсом.)
- [`os.path.expandvars()`](https://python-all.ru/3.2/library/os.path.html#os.path.expandvars) теперь будет раскрывать переменные окружения в форме «%var%», а «~user» будет раскрываться в путь к домашнему каталогу пользователя. (Предложено Джозайей Карлсоном; [issue 957650](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Сокетные объекты модуля [`socket`](https://python-all.ru/3.2/library/socket.html#module-socket) теперь имеют метод `ioctl()`, который предоставляет ограниченный интерфейс к системному интерфейсу `WSAIoctl()`.
- Модуль `_winreg` теперь имеет функцию `ExpandEnvironmentStrings()`, которая раскрывает ссылки на переменные окружения, такие как `%NAME%`, во входной строке. Объекты-дескрипторы, предоставляемые этим модулем, теперь поддерживают протокол контекста, поэтому их можно использовать в операторах [`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with). (Предложено Кристианом Хаймсом.)

  `_winreg` также имеет лучшую поддержку систем x64, предоставляя функции `DisableReflectionKey()`, `EnableReflectionKey()` и `QueryReflectionKey()`, которые включают и отключают отражение реестра для 32-разрядных процессов, работающих в 64-разрядных системах. ([issue 1753245](https://python-all.ru/3.2/whatsnew/2.6.html))
- Объект `Record` модуля [`msilib`](https://python-all.ru/3.2/library/msilib.html#module-msilib) получил методы `GetInteger()` и `GetString()`, которые возвращают значения полей как целое число или строку. (Предложено Флорисом Брюнноге; [issue 2125](https://python-all.ru/3.2/whatsnew/2.6.html).)

### Изменения для конкретных платформ: Mac OS X

- При компиляции фреймворк-сборки Python теперь можно указать имя фреймворка, передав опцию *--with-framework-name=* скрипту **configure**.
- Модуль `macfs` был удалён. Это, в свою очередь, потребовало удаления функции `macostools.touched()`, поскольку она зависела от модуля `macfs`. ([issue 1490190](https://python-all.ru/3.2/whatsnew/2.6.html))
- Многие другие модули Mac OS объявлены устаревшими и будут удалены в Python 3.0: `_builtinSuites`, `aepack`, `aetools`, `aetypes`, `applesingle`, `appletrawmain`, `appletrunner`, `argvemulator`, `Audio_mac`, `autoGIL`, `Carbon`, `cfmfile`, `CodeWarrior`, `ColorPicker`, `EasyDialogs`, `Explorer`, `Finder`, `FrameWork`, `findertools`, `ic`, `icglue`, `icopen`, `macerrors`, `MacOS`, `macfs`, `macostools`, `macresource`, `MiniAEFrame`, `Nav`, `Netscape`, `OSATerminology`, `pimp`, `PixMapWrapper`, `StdSuites`, `SystemEvents`, `Terminal` и `terminalcommand`.

### Изменения для конкретных портов: IRIX

Ряд старых модулей, специфичных для IRIX, объявлены устаревшими и будут удалены в Python 3.0: `al` и `AL`, `cd`, `cddb`, `cdplayer`, `CL` и `cl`, `DEVICE`, `ERRNO`, `FILE`, `FL` и `fl`, `flp`, `fm`, `GET`, `GLWS`, `GL` и `gl`, `IN`, `IOCTL`, `jpeg`, `panelparser`, `readcd`, `SV` и `sv`, `torgb`, `videoreader` и `WAIT`.

## Перенос на Python 2.6

В этом разделе перечислены ранее описанные изменения и другие исправления ошибок, которые могут потребовать изменений в коде:

- Классы, которые не должны быть хешируемыми, должны устанавливать `__hash__ = None` в своих определениях, чтобы указать на этот факт.
- Строковые исключения удалены. Попытка их использовать вызывает [`TypeError`](https://python-all.ru/3.2/library/exceptions.html#TypeError).
- Метод [`__init__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__init__) класса [`collections.deque`](https://python-all.ru/3.2/library/collections.html#collections.deque) теперь очищает все существующие содержимое deque перед добавлением элементов из итерируемого объекта. Это изменение приводит поведение в соответствие с `list.__init__()`.
- [`object.__init__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__init__) ранее принимал произвольные позиционные и именованные аргументы, игнорируя их. В Python 2.6 это больше не допускается и приводит к [`TypeError`](https://python-all.ru/3.2/library/exceptions.html#TypeError). Это повлияет на методы [`__init__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__init__), которые в конечном итоге вызывают соответствующий метод у [`object`](https://python-all.ru/3.2/library/functions.html#object) (возможно, через использование [`super()`](https://python-all.ru/3.2/library/functions.html#super)). См. обсуждение в [issue 1683368](https://python-all.ru/3.2/whatsnew/2.6.html).
- Конструктор `Decimal` теперь принимает начальные и конечные пробелы при передаче строки. Ранее он возбуждал исключение `InvalidOperation`. С другой стороны, метод `create_decimal()` объектов `Context` теперь явно запрещает лишние пробелы, возбуждая исключение `ConversionSyntax`.
- Из-за случайности в реализации, при передаче пути к файлу встроенной функции [`__import__()`](https://python-all.ru/3.2/library/functions.html#__import__) она фактически импортировала указанный файл. Однако это никогда не предполагалось работать, и теперь реализация явно проверяет этот случай и возбуждает [`ImportError`](https://python-all.ru/3.2/library/exceptions.html#ImportError).
- C API: функции [`PyImport_Import()`](https://python-all.ru/3.2/c-api/import.html#PyImport_Import) и [`PyImport_ImportModule()`](https://python-all.ru/3.2/c-api/import.html#PyImport_ImportModule) теперь по умолчанию используют абсолютные импорты, а не относительные. Это повлияет на расширения C, которые импортируют другие модули.
- C API: типы данных расширений, которые не должны быть хешируемыми, должны определять свой слот `tp_hash` как [`PyObject_HashNotImplemented()`](https://python-all.ru/3.2/c-api/object.html#PyObject_HashNotImplemented).
- В модуле [`socket`](https://python-all.ru/3.2/library/socket.html#module-socket) исключение [`socket.error`](https://python-all.ru/3.2/library/socket.html#socket.error) теперь наследуется от [`IOError`](https://python-all.ru/3.2/library/exceptions.html#IOError). Ранее оно не было подклассом `StandardError`, но теперь им стало через [`IOError`](https://python-all.ru/3.2/library/exceptions.html#IOError). (Реализовано Грегори П. Смитом; [issue 1706815](https://python-all.ru/3.2/whatsnew/2.6.html).)
- Модуль `xmlrpclib` больше не преобразует автоматически [`datetime.date`](https://python-all.ru/3.2/library/datetime.html#datetime.date) и [`datetime.time`](https://python-all.ru/3.2/library/datetime.html#datetime.time) в тип `xmlrpclib.DateTime`; семантика преобразований не обязательно была корректной для всех приложений. Код, использующий `xmlrpclib`, должен преобразовывать экземпляры `date` и [`time`](https://python-all.ru/3.2/library/time.html#module-time). ([issue 1330538](https://python-all.ru/3.2/whatsnew/2.6.html))
- (Режим предупреждений для версии 3.0) Класс [`Исключение`](https://python-all.ru/3.2/library/exceptions.html#Exception) теперь выводит предупреждение при доступе через срез или по индексу; возможность использования [`Исключение`](https://python-all.ru/3.2/library/exceptions.html#Exception) как кортежа постепенно убирается.
- (Режим предупреждений для версии 3.0) Сравнения на неравенство между двумя словарями или двумя объектами, не реализующими методы сравнения, теперь выводят предупреждения. `dict1 == dict2` всё ещё работает, но `dict1 < dict2` постепенно убирается.

  Сравнения между ячейками (cells), которые являются деталью реализации правил области видимости Python, также вызывают предупреждения, поскольку такие сравнения полностью запрещены в 3.0.

## Благодарности

Автор хотел бы поблагодарить следующих людей за предложения, исправления и помощь с различными черновиками этой статьи: Georg Brandl, Steve Brown, Nick Coghlan, Ralph Corderoy, Jim Jewett, Kent Johnson, Chris Lambacher, Martin Michlmayr, Antoine Pitrou, Brian Warner.