> **Источник:** https://python-all.ru/2.7/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/2.7/whatsnew/2.6.html).

Основная тема Python 2.6 – подготовка пути к миграции на Python 3.0, крупное перепроектирование языка. По возможности Python 2.6 включает новые возможности и синтаксис из версии 3.0, оставаясь совместимым с существующим кодом за счёт того, что не удаляет старые возможности или синтаксис. Когда это невозможно, Python 2.6 старается сделать всё возможное, добавляя функции совместимости в модуле [`future_builtins`](https://python-all.ru/2.7/library/future_builtins.html#module-future_builtins) и ключ [`-3`](https://python-all.ru/2.7/using/cmdline.html#cmdoption-3) для предупреждения об использовании, которое станет неподдерживаемым в версии 3.0.

В стандартную библиотеку были добавлены некоторые важные новые пакеты, такие как модули [`multiprocessing`](https://python-all.ru/2.7/library/multiprocessing.html#module-multiprocessing) и [`json`](https://python-all.ru/2.7/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/2.7/reference/datamodel.html#object.__complex__) для преобразования объектов в комплексное число.
- Альтернативный синтаксис для перехвата исключений: `except TypeError as exc`.
- Добавление [`functools.reduce()`](https://python-all.ru/2.7/library/functools.html#functools.reduce) как синонима для встроенной функции [`reduce()`](https://python-all.ru/2.7/library/functions.html#reduce).

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

Новый ключ командной строки [`-3`](https://python-all.ru/2.7/using/cmdline.html#cmdoption-3) включает предупреждения о возможностях, которые будут удалены в Python 3.0. Вы можете запускать код с этим ключом, чтобы увидеть, сколько работы потребуется для переноса кода на 3.0. Значение этого ключа доступно в коде Python как логическая переменная [`sys.py3kwarning`](https://python-all.ru/2.7/library/sys.html#sys.py3kwarning), а в коде расширений C – как `Py_Py3kWarningFlag`.

> **См. также**
>
> Серия PEP 3xxx, содержащая предложения для Python 3.0. [**PEP 3000**](https://python-all.ru/2.7/whatsnew/2.6.html) описывает процесс разработки Python 3.0. Начните с [**PEP 3100**](https://python-all.ru/2.7/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/2.7/whatsnew/2.6.html), [Launchpad](https://python-all.ru/2.7/whatsnew/2.6.html), [Roundup](https://python-all.ru/2.7/whatsnew/2.6.html) и [Trac](https://python-all.ru/2.7/whatsnew/2.6.html). В конечном итоге комитет остановился на Jira и Roundup как на двух кандидатах. Jira – коммерческий продукт, который бесплатно предоставляет размещённые экземпляры для проектов свободного программного обеспечения; Roundup – проект с открытым исходным кодом, требующий добровольцев для его администрирования и сервера для его размещения.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Некоторые стандартные объекты Python теперь поддерживают протокол управления контекстом и могут использоваться с оператором ‘[`with`](https://python-all.ru/2.7/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/2.7/reference/compound_stmts.html#for) вызвал исключение в середине блока.

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

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

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

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

Функция `localcontext()` в модуле [`decimal`](https://python-all.ru/2.7/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/2.7/reference/compound_stmts.html#with)’ довольно сложен. Большинство людей будут использовать ‘[`with`](https://python-all.ru/2.7/reference/compound_stmts.html#with)’ только с существующими объектами и не нуждаются в знании этих деталей, поэтому вы можете пропустить остальную часть этого раздела, если захотите. Авторам новых объектов потребуется понять детали базовой реализации, и им стоит продолжить чтение.

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

- Выражение вычисляется и должно дать объект, называемый «контекстный менеджер». Контекстный менеджер должен иметь методы [`__enter__()`](https://python-all.ru/2.7/reference/datamodel.html#object.__enter__) и [`__exit__()`](https://python-all.ru/2.7/reference/datamodel.html#object.__exit__).
- Вызывается метод [`__enter__()`](https://python-all.ru/2.7/reference/datamodel.html#object.__enter__) контекстного менеджера. Возвращённое значение присваивается *VAR*. Если конструкция `as VAR` отсутствует, значение просто игнорируется.
- Код внутри *блока* выполняется.
- Если *блок* вызывает исключение, метод [`__exit__()`](https://python-all.ru/2.7/reference/datamodel.html#object.__exit__) контекстного менеджера вызывается с тремя аргументами: сведениями об исключении (`type, value, traceback`, те же значения, которые возвращает [`sys.exc_info()`](https://python-all.ru/2.7/library/sys.html#sys.exc_info), а также могут быть `None`, если исключение не произошло). Возвращаемое значение метода определяет, будет ли исключение возбуждено повторно: любое ложное значение вызывает повторное возбуждение, а `True` приведёт к его подавлению. Подавлять исключение нужно редко, потому что если это сделать, автор кода, содержащего оператор '[`with`](https://python-all.ru/2.7/reference/compound_stmts.html#with)', никогда не узнает, что что-то пошло не так.
- Если *блок* не вызвал исключения, метод [`__exit__()`](https://python-all.ru/2.7/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/2.7/reference/datamodel.html#object.__enter__) довольно прост: ему нужно только начать новую транзакцию. В данном приложении результирующий объект курсора будет полезным результатом, поэтому метод вернёт его. Затем пользователь может добавить `as cursor` к своему оператору '[`with`](https://python-all.ru/2.7/reference/compound_stmts.html#with)', чтобы привязать курсор к имени переменной.

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

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

В приведённом ниже коде выполнение просто дойдёт до конца функции, вернув значение по умолчанию `None`. Значение `None` ложно, поэтому исключение будет автоматически возбуждено повторно. При желании можно сделать это более явно и добавить оператор [`return`](https://python-all.ru/2.7/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/2.7/library/contextlib.html#module-contextlib) предоставляет несколько функций и декоратор, которые полезны при написании объектов для использования с оператором '[`with`](https://python-all.ru/2.7/reference/compound_stmts.html#with)'.

Декоратор называется `contextmanager()` и позволяет написать одну функцию-генератор вместо определения нового класса. Генератор должен генерировать ровно одно значение. Код до [`yield`](https://python-all.ru/2.7/reference/simple_stmts.html#yield) будет выполнен как метод [`__enter__()`](https://python-all.ru/2.7/reference/datamodel.html#object.__enter__), а сгенерированное значение станет возвращаемым значением метода, которое будет связано с переменной в конструкции [`as`](https://python-all.ru/2.7/reference/compound_stmts.html#as) оператора ‘[`with`](https://python-all.ru/2.7/reference/compound_stmts.html#with)’, если она присутствует. Код после [`yield`](https://python-all.ru/2.7/reference/simple_stmts.html#yield) будет выполнен в методе [`__exit__()`](https://python-all.ru/2.7/reference/datamodel.html#object.__exit__). Любое исключение, возникшее в блоке, будет возбуждено оператором [`yield`](https://python-all.ru/2.7/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/2.7/library/contextlib.html#module-contextlib) также содержит функцию `nested(mgr1, mgr2, ...)`, которая объединяет несколько контекстных менеджеров, чтобы не приходилось писать вложенные операторы '[`with`](https://python-all.ru/2.7/reference/compound_stmts.html#with)'. В этом примере один оператор '[`with`](https://python-all.ru/2.7/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/2.7/whatsnew/2.6.html) – Оператор «with»**
>
> PEP написан Гвидо ван Россумом и Ником Когланом; реализован Майком Бландом, Гвидо ван Россумом и Нилом Норвицем. В PEP показан код, генерируемый для оператора '[`with`](https://python-all.ru/2.7/reference/compound_stmts.html#with)', что может быть полезно для понимания того, как работает этот оператор.
>
> Документация для модуля [`contextlib`](https://python-all.ru/2.7/library/contextlib.html#module-contextlib).

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

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

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

Импортёры в стиле PEP 302 могут затем устанавливать `__package__` по мере необходимости. Модуль [`runpy`](https://python-all.ru/2.7/library/runpy.html#module-runpy), реализующий параметр [`-m`](https://python-all.ru/2.7/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/2.7/using/cmdline.html#envvar-PYTHONUSERBASE) задаёт корневой каталог, используемый всеми версиями Python, поддерживающими эту возможность. В Windows каталог для данных приложений можно изменить, установив переменную окружения `APPDATA`. Также можно изменить файл `site.py` для вашей установки Python.

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

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

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

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

Модуль [`multiprocessing`](https://python-all.ru/2.7/library/multiprocessing.html#module-multiprocessing) изначально был точной эмуляцией модуля [`threading`](https://python-all.ru/2.7/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
```

Для передачи результата вычисления факториала используется [`Queue`](https://python-all.ru/2.7/library/queue.html#Queue.Queue). Объект [`Queue`](https://python-all.ru/2.7/library/queue.html#Queue.Queue) хранится в глобальной переменной. Дочерний процесс будет использовать значение переменной на момент своего создания; поскольку это [`Queue`](https://python-all.ru/2.7/library/queue.html#Queue.Queue), родительский и дочерний процессы могут обмениваться данными через этот объект. (Если бы родитель изменил значение глобальной переменной, значение дочернего процесса не изменилось бы, и наоборот.)

Два других класса, `Pool` и `Manager`, предоставляют интерфейсы более высокого уровня. `Pool` создаёт фиксированное количество рабочих процессов, и запросы затем можно распределять между рабочими процессами с помощью вызова [`apply()`](https://python-all.ru/2.7/library/functions.html#apply) или `apply_async()` для добавления одного запроса и [`map()`](https://python-all.ru/2.7/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/2.7/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/2.7/library/multiprocessing.html#module-multiprocessing).
>
> **[**PEP 371**](https://python-all.ru/2.7/whatsnew/2.6.html) – Добавление пакета multiprocessing**
>
> PEP написан Джесси Ноллером и Ричардом Удкерком; реализован Ричардом Удкерком и Джесси Ноллером.

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

В Python 3.0 оператор *%* дополнен более мощным методом форматирования строк [`format()`](https://python-all.ru/2.7/library/functions.html#format). Поддержка метода [`str.format()`](https://python-all.ru/2.7/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/2.7/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__()` для управления тем, как они форматируются. Он принимает единственный аргумент – спецификатор формата:

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

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

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

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

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

Оператор `print` в Python 3.0 становится функцией [`print()`](https://python-all.ru/2.7/library/functions.html#print). Превращение [`print()`](https://python-all.ru/2.7/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/2.7/whatsnew/2.6.html) - Сделать print функцией**
>
> PEP написан Георгом Брандлом.

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

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

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

Автор, вероятно, пытается перехватить оба исключения [`TypeError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.TypeError) и [`ValueError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.ValueError), но этот код на самом деле делает кое-что другое: он перехватит [`TypeError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.TypeError) и свяжет полученный объект исключения с локальным именем `"ValueError"`. Исключение [`ValueError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.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/2.7/whatsnew/2.6.html) - Перехват исключений в Python 3000**
>
> PEP написан и реализован Коллином Уинтером.

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

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

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

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

Также существует импорт `__future__`, который приводит к тому, что все строковые литералы становятся строками Unicode. Это означает, что escape-последовательности `\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`](https://python-all.ru/2.7/c-api/string.html#c.PyStringObject) в Python 2.x, в `PyBytesObject`. Python 2.6 использует `#define` для поддержки использования имён `PyBytesObject()`, `PyBytes_Check()`, `PyBytes_FromStringAndSize()` и всех остальных функций и макросов, используемых со строками.

Экземпляры типа `bytes` неизменяемы, как и строки. Новый тип [`bytearray`](https://python-all.ru/2.7/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/2.7/c-api/bytearray.html#c.PyByteArray_FromObject), [`PyByteArray_FromStringAndSize()`](https://python-all.ru/2.7/c-api/bytearray.html#c.PyByteArray_FromStringAndSize) и различными другими.

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

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

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

Модуль [`io`](https://python-all.ru/2.7/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/2.7/glossary.html#term-universal-newlines). `TextIOBase` определяет метод [`readline()`](https://python-all.ru/2.7/library/readline.html#module-readline) и поддерживает итерацию по объектам.

  Существует две конкретные реализации. `TextIOWrapper` оборачивает буферизованный объект ввода-вывода, поддерживая все методы для текстового ввода-вывода и добавляя атрибут [`buffer`](https://python-all.ru/2.7/library/functions.html#buffer) для доступа к нижележащему объекту. [`StringIO`](https://python-all.ru/2.7/library/stringio.html#StringIO.StringIO) просто буферизует все в памяти, никогда ничего не записывая на диск.

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

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

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

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

Буферный протокол – это C-уровневый API, который позволяет типам Python обмениваться указателями на свои внутренние представления. Например, файл, отображенный в память, можно рассматривать как буфер символов, и это позволяет другому модулю, например [`re`](https://python-all.ru/2.7/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/2.7/c-api/buffer.html#c.PyObject_GetBuffer) задает ограничения на возвращаемую память. Вот несколько примеров:

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

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

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

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

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

Допустим, у вас есть некий класс, и вы хотите узнать, поддерживает ли он доступ в стиле словаря. Однако фраза «в стиле словаря» расплывчата. Вероятно, это означает, что доступ к элементам через `obj[1]` работает. Подразумевает ли это, что установка элементов через `obj[2] = value` работает? Или что объект будет иметь методы `keys()`, `values()` и `items()`? А как насчёт итеративных вариантов, таких как `iterkeys()`? [`copy()`](https://python-all.ru/2.7/library/copy.html#module-copy) и `update()`? Итерация по объекту с помощью [`iter()`](https://python-all.ru/2.7/library/functions.html#iter)?

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

Можно наследовать свои классы от конкретной 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/2.7/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/2.7/library/functions.html#oct) по-прежнему возвращает числа с ведущим нулём, а новая встроенная функция [`bin()`](https://python-all.ru/2.7/library/functions.html#bin) возвращает двоичное представление числа:

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

Встроенные функции [`int()`](https://python-all.ru/2.7/library/functions.html#int) и [`long()`](https://python-all.ru/2.7/library/functions.html#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/2.7/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/2.7/whatsnew/2.6.html) - Декораторы классов**
>
> PEP написан Коллином Уинтером.

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

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

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

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

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

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

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

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

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

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

Чтобы дополнить иерархию числовых типов, модуль [`fractions`](https://python-all.ru/2.7/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/2.7/library/fractions.html#module-fractions) основан на реализации Сьорда Мюллендера, которая долгое время находилась в каталоге Python `Demo/classes/`. Джеффри Яскин существенно обновил эту реализацию.

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

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

- Каталоги и zip-архивы, содержащие файл `__main__.py`, теперь можно выполнять напрямую, передавая их имя интерпретатору. Каталог или zip-архив автоматически вставляется как первая запись в sys.path. (Предложение и начальный патч от Энди Чу, впоследствии доработан Филиппом Дж. Иби и Ником Когланом; [bpo-1739468](https://python-all.ru/2.7/whatsnew/2.6.html).)
- Функция [`hasattr()`](https://python-all.ru/2.7/library/functions.html#hasattr) перехватывала и игнорировала все ошибки, полагая, что они означают, что метод [`__getattr__()`](https://python-all.ru/2.7/reference/datamodel.html#object.__getattr__) потерпел неудачу, и поэтому возвращаемое значение [`hasattr()`](https://python-all.ru/2.7/library/functions.html#hasattr) будет `False`. Однако эту логику не следует применять к [`KeyboardInterrupt`](https://python-all.ru/2.7/library/exceptions.html#exceptions.KeyboardInterrupt) и [`SystemExit`](https://python-all.ru/2.7/library/exceptions.html#exceptions.SystemExit); Python 2.6 больше не будет отбрасывать такие исключения, когда [`hasattr()`](https://python-all.ru/2.7/library/functions.html#hasattr) с ними сталкивается. (Исправлено Бенджамином Петерсоном; [bpo-2196](https://python-all.ru/2.7/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']
  ```

  (Автор: Александр Белопольский; [bpo-1686487](https://python-all.ru/2.7/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}
  ```

  Ранее это вызывало бы синтаксическую ошибку. (Автор: Амори Форжео д’Арк; [bpo-3473](https://python-all.ru/2.7/whatsnew/2.6.html).)
- Новая встроенная функция `next(iterator, [default])` возвращает следующий элемент из указанного итератора. Если передан аргумент *default*, он будет возвращён, если *iterator* исчерпан; в противном случае будет возбуждено исключение [`StopIteration`](https://python-all.ru/2.7/library/exceptions.html#exceptions.StopIteration). (Портировано в [bpo-2719](https://python-all.ru/2.7/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)`. Ранее поддержка была частичной, и некоторые крайние случаи не работали. (Реализовано Томасом Воутерсом.)
- Свойства теперь имеют три атрибута: `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/2.7/library/functions.html#float) теперь преобразует строку `nan` в значение NaN (не число) по стандарту IEEE 754, а `+inf` и `-inf` – в положительную или отрицательную бесконечность. Это работает на любой платформе с семантикой IEEE 754. (Автор: Кристиан Хаймс; [bpo-1635](https://python-all.ru/2.7/whatsnew/2.6.html).)

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

  Были добавлены функции преобразования чисел с плавающей запятой в шестнадцатеричные строки ([bpo-3008](https://python-all.ru/2.7/whatsnew/2.6.html)). Эти функции преобразуют числа с плавающей запятой в строковое представление и обратно, не внося ошибок округления, возникающих при преобразовании между десятичной и двоичной системами. Числа с плавающей запятой имеют метод [`hex()`](https://python-all.ru/2.7/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/2.7/library/functions.html#complex) теперь сохраняет знак нуля. (Исправлено Марком Т. Дикинсоном; [bpo-1507](https://python-all.ru/2.7/whatsnew/2.6.html).)
- Классы, наследующие метод [`__hash__()`](https://python-all.ru/2.7/reference/datamodel.html#object.__hash__) от родительского класса, могут установить `__hash__ = None`, чтобы указать, что класс не является хешируемым. Это заставит `hash(obj)` возбуждать [`TypeError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.TypeError), и класс не будет помечен как реализующий абстрактный базовый класс `Hashable`.

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

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

- Модуль [`warnings`](https://python-all.ru/2.7/library/warnings.html#module-warnings) переписан на C. Это позволяет вызывать предупреждения из парсера, а также может ускорить запуск интерпретатора. (Авторы: Neal Norwitz и Brett Cannon; [bpo-1631171](https://python-all.ru/2.7/whatsnew/2.6.html).)
- Объекты типов теперь имеют кеш методов, который сокращает работу по поиску правильной реализации метода для конкретного класса; после кеширования интерпретатору не нужно обходить базовые классы, чтобы определить, какой метод вызвать. Кеш очищается при изменении базового класса или самого класса, поэтому он должен оставаться корректным даже в условиях динамической природы Python. (Оригинальная оптимизация реализована Armin Rigo, обновлена для Python 2.6 Kevin Jacobs; [bpo-1700288](https://python-all.ru/2.7/whatsnew/2.6.html).)

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

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

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

Теперь можно запретить Python записывать файлы `.pyc` или `.pyo`, указав ключ [`-B`](https://python-all.ru/2.7/using/cmdline.html#id1) интерпретатору Python или установив переменную окружения [`PYTHONDONTWRITEBYTECODE`](https://python-all.ru/2.7/using/cmdline.html#envvar-PYTHONDONTWRITEBYTECODE) перед запуском интерпретатора. Эта настройка доступна программам Python как переменная `sys.dont_write_bytecode`, и код Python может изменить значение, чтобы изменить поведение интерпретатора. (Авторы: Neal Norwitz и Georg Brandl.)

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

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

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

- Модули [`asyncore`](https://python-all.ru/2.7/library/asyncore.html#module-asyncore) и [`asynchat`](https://python-all.ru/2.7/library/asynchat.html#module-asynchat) снова активно поддерживаются, и был применен ряд патчей и исправлений ошибок. (Поддерживаются Josiah Carlson; см. [bpo-1736190](https://python-all.ru/2.7/whatsnew/2.6.html) для одного из патчей.)
- У модуля [`bsddb`](https://python-all.ru/2.7/library/bsddb.html#module-bsddb) также появился новый сопровождающий – Jesús Cea Avion, и пакет теперь доступен как отдельный пакет. Веб-страница пакета: [www.jcea.es/programacion/pybsddb.htm](https://python-all.ru/2.7/whatsnew/2.6.html). Планируется удалить пакет из стандартной библиотеки в Python 3.0, поскольку темп его выпусков гораздо чаще, чем у Python.

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

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

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

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

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

  На платформах IEEE 754 модуль [`cmath`](https://python-all.ru/2.7/library/cmath.html#module-cmath) теперь обрабатывает специальные значения IEEE 754 и исключения с плавающей запятой в соответствии с приложением G стандарта C99.
- Новый тип данных в модуле [`collections`](https://python-all.ru/2.7/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/2.7/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`](https://python-all.ru/2.7/library/cookie.html#module-Cookie) теперь поддерживают атрибут `httponly`. В некоторых браузерах куки с установленным этим атрибутом не могут быть прочитаны или изменены через JavaScript. (Автор: Arvin Schnell; [bpo-1638033](https://python-all.ru/2.7/whatsnew/2.6.html).)
- Новый метод окна в модуле [`curses`](https://python-all.ru/2.7/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/2.7/library/curses.html#module-curses.textpad) теперь поддерживает редактирование как в режиме вставки, так и в режиме замены. Режим вставки включается передачей истинного значения параметру *insert\_mode* при создании экземпляра `Textbox`.
- Методы `strftime()` модуля [`datetime`](https://python-all.ru/2.7/library/datetime.html#module-datetime) теперь поддерживают код формата `%f`, который раскрывается в количество микросекунд в объекте, дополненное нулями слева до шести знаков. (Автор: Skip Montanaro; [bpo-1158](https://python-all.ru/2.7/whatsnew/2.6.html).)
- Модуль [`decimal`](https://python-all.ru/2.7/library/decimal.html#module-decimal) был обновлён до версии 1.66 [Общей спецификации десятичных чисел](https://python-all.ru/2.7/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/2.7/library/difflib.html#module-difflib) теперь возвращает именованные кортежи, представляющие совпадения, с атрибутами `a`, `b` и `size`. (Автор: Raymond Hettinger.)
- В конструктор класса [`ftplib.FTP`](https://python-all.ru/2.7/library/ftplib.html#ftplib.FTP), а также в метод `connect()` был добавлен необязательный параметр `timeout`, задающий тайм-аут в секундах. (Добавлено Facundo Batista.) Кроме того, методы `storbinary()` и `storlines()` класса `FTP` теперь принимают необязательный параметр *колбэк*, который будет вызываться с каждым блоком данных после его отправки. (Автор: Phil Schwartz; [bpo-1221598](https://python-all.ru/2.7/whatsnew/2.6.html).)
- Встроенная функция [`reduce()`](https://python-all.ru/2.7/library/functions.html#reduce) также доступна в модуле [`functools`](https://python-all.ru/2.7/library/functools.html#module-functools). В Python 3.0 встроенная функция была удалена, и [`reduce()`](https://python-all.ru/2.7/library/functions.html#reduce) доступна только из [`functools`](https://python-all.ru/2.7/library/functools.html#module-functools); в настоящее время планов по удалению встроенной функции в серии 2.x нет. (Патч от Christian Heimes; [bpo-1739906](https://python-all.ru/2.7/whatsnew/2.6.html).)
- Там, где возможно, модуль [`getpass`](https://python-all.ru/2.7/library/getpass.html#module-getpass) теперь использует `/dev/tty` для вывода приглашения и чтения пароля, возвращаясь к стандартному потоку ошибок и стандартному вводу. Если пароль может быть выведен на терминал, перед отображением приглашения выводится предупреждение. (Автор: Gregory P. Smith.)
- Функция [`glob.glob()`](https://python-all.ru/2.7/library/glob.html#glob.glob) теперь может возвращать имена файлов в Юникоде, если был указан путь в Юникоде и в каталоге есть файлы с такими именами. ([bpo-1001604](https://python-all.ru/2.7/whatsnew/2.6.html))
- Новая функция в модуле [`heapq`](https://python-all.ru/2.7/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/2.7/library/heapq.html#module-heapq) теперь реализовано с использованием только сравнения «меньше», а не «меньше или равно», как было раньше. Это приводит использование [`heapq`](https://python-all.ru/2.7/library/heapq.html#module-heapq) типа в соответствие с методом `list.sort()`. (Автор: Raymond Hettinger.)
- В конструкторы классов [`httplib.HTTPConnection`](https://python-all.ru/2.7/library/httplib.html#httplib.HTTPConnection) и `HTTPSConnection` был добавлен необязательный параметр `timeout`, задающий тайм-аут в секундах. (Добавлено Facundo Batista.)
- Большинство функций модуля [`inspect`](https://python-all.ru/2.7/library/inspect.html#module-inspect), таких как `getmoduleinfo()` и `getargs()`, теперь возвращают именованные кортежи. В дополнение к поведению кортежа элементы возвращаемого значения также могут быть доступны как атрибуты. (Автор: Raymond Hettinger.)

  Некоторые новые функции в модуле включают `isgenerator()`, `isgeneratorfunction()` и `isabstract()`.
- Модуль [`itertools`](https://python-all.ru/2.7/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* из элементов *итерируемого объекта*.

  ```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/2.7/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/2.7/library/logging.html#module-logging) и его подклассы `WatchedFileHandler`, `RotatingFileHandler`, и `TimedRotatingFileHandler` теперь имеют необязательный параметр *delay* в своих конструкторах. Если *delay* истинно, открытие файла журнала откладывается до первого вызова `emit()`. (Добавлено Винаем Саджипом.)

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

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

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

  (Добавлено Кристианом Хаймсом и Марком Дикинсоном.)
- Объекты [`mmap`](https://python-all.ru/2.7/library/mmap.html#mmap.mmap) теперь имеют метод `rfind()`, который ищет подстроку, начиная с конца строки и двигаясь назад. Метод `find()` также получил параметр *end*, задающий индекс, на котором следует остановить поиск. (Добавлено Джоном Лентоном.)
- Модуль [`operator`](https://python-all.ru/2.7/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/2.7/library/os.html#module-os) теперь обёртывает несколько новых системных вызовов. `fchmod(fd, mode)` и `fchown(fd, uid, gid)` изменяют режим и владельца открытого файла, а `lchmod(path, mode)` изменяет режим символической ссылки. (Добавлено Георгом Брандлом и Кристианом Хаймсом.)

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

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

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

  В Windows [`os.path.expandvars()`](https://python-all.ru/2.7/library/os.path.html#os.path.expandvars) теперь будет раскрывать переменные окружения, заданные в форме «%var%», а «~user» будет раскрываться в путь к домашнему каталогу пользователя. (Добавлено Джозайей Карлсоном; [bpo-957650](https://python-all.ru/2.7/whatsnew/2.6.html).)
- Отладчик Python, предоставляемый модулем [`pdb`](https://python-all.ru/2.7/library/pdb.html#module-pdb), получил новую команду: «run» перезапускает отлаживаемую программу Python и может опционально принимать новые аргументы командной строки для программы. (Добавлено Рокки Бернстайном; [bpo-1393667](https://python-all.ru/2.7/whatsnew/2.6.html).)
- Функция [`pdb.post_mortem()`](https://python-all.ru/2.7/library/pdb.html#pdb.post_mortem), используемая для начала отладки по traceback, теперь будет использовать traceback, возвращаемый [`sys.exc_info()`](https://python-all.ru/2.7/library/sys.html#sys.exc_info), если traceback не передан. (Добавлено Факундо Батистой; [bpo-1106316](https://python-all.ru/2.7/whatsnew/2.6.html).)
- Модуль [`pickletools`](https://python-all.ru/2.7/library/pickletools.html#module-pickletools) теперь имеет функцию `optimize()`, которая принимает строку, содержащую pickle, и удаляет некоторые неиспользуемые опкоды, возвращая более короткий pickle, содержащий ту же структуру данных. (Автор: Raymond Hettinger.)
- В модуль [`pkgutil`](https://python-all.ru/2.7/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; [bpo-2439](https://python-all.ru/2.7/whatsnew/2.6.html).)
- Объекты `Parser` модуля `pyexpat` теперь позволяют устанавливать свой атрибут `buffer_size` для изменения размера буфера, используемого для хранения символьных данных. (Автор: Achim Gaedke; [bpo-1137](https://python-all.ru/2.7/whatsnew/2.6.html).)
- Модуль [`Queue`](https://python-all.ru/2.7/library/queue.html#module-Queue) теперь предоставляет разновидности очередей, которые извлекают записи в разных порядках. Класс `PriorityQueue` хранит элементы очереди в куче и извлекает их в порядке приоритета, а `LifoQueue` извлекает первыми самые недавно добавленные записи, то есть ведёт себя как стек. (Автор: Raymond Hettinger.)
- Объекты `Random` модуля [`random`](https://python-all.ru/2.7/library/random.html#module-random) теперь можно сериализовать в 32-битной системе и десериализовать в 64-битной системе, и наоборот. К сожалению, это изменение также означает, что объекты `Random` Python 2.6 нельзя корректно десериализовать в более ранних версиях Python. (Автор: Shawn Ligocki; [bpo-1727780](https://python-all.ru/2.7/whatsnew/2.6.html).)

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

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

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

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

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

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

  (Автор: Adam Olsen; [bpo-1583](https://python-all.ru/2.7/whatsnew/2.6.html).)

  Функция `siginterrupt()` теперь доступна из кода Python и позволяет изменять, могут ли сигналы прерывать системные вызовы или нет. (Автор: Ralf Schmitt.)

  Функции `setitimer()` и `getitimer()` также были добавлены (там, где они доступны). `setitimer()` позволяет устанавливать интервальные таймеры, которые будут отправлять сигнал процессу по истечении заданного времени, измеряемого в реальном времени, процессорном времени процесса или совокупном времени процесса+системы. (Автор: Guilherme Polo; [bpo-2240](https://python-all.ru/2.7/whatsnew/2.6.html).)
- Модуль [`smtplib`](https://python-all.ru/2.7/library/smtplib.html#module-smtplib) теперь поддерживает SMTP через SSL благодаря добавлению класса `SMTP_SSL`. Этот класс поддерживает интерфейс, идентичный существующему классу `SMTP`. (Автор: Monty Taylor.) Оба конструктора классов также имеют необязательный параметр `timeout`, задающий тайм-аут для начальной попытки соединения, измеряемый в секундах. (Автор: Facundo Batista.)

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

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

  Новая функция `create_connection()` принимает адрес и подключается к нему, используя необязательное значение тайм-аута, возвращая подключённый объект сокета. Эта функция также определяет тип адреса и подключается к нему, используя IPv4 или IPv6 по ситуации. Изменение вашего кода для использования `create_connection()` вместо `socket(socket.AF_INET, ...)` может быть всем, что нужно, чтобы ваш код работал с IPv6.
- Базовые классы в модуле [`SocketServer`](https://python-all.ru/2.7/library/socketserver.html#module-SocketServer) теперь поддерживают вызов метода `handle_timeout()` после периода бездействия, заданного атрибутом `timeout` сервера. (Автор: Michael Pomraning.) Метод `serve_forever()` теперь принимает необязательный интервал опроса, измеряемый в секундах, контролирующий, как часто сервер будет проверять запрос на завершение. (Авторы: Pedro Werneck и Jeffrey Yasskin; [bpo-742598](https://python-all.ru/2.7/whatsnew/2.6.html), [bpo-1193577](https://python-all.ru/2.7/whatsnew/2.6.html).)
- Модуль [`sqlite3`](https://python-all.ru/2.7/library/sqlite3.html#module-sqlite3), сопровождаемый Gerhard Haering, обновлён с версии 2.3.2 в Python 2.5 до версии 2.4.1.
- Модуль [`struct`](https://python-all.ru/2.7/library/struct.html#module-struct) теперь поддерживает тип C99 `_Bool`, используя символ формата `'?'`. (Вклад David Remahl.)
- Объекты `Popen`, предоставляемые модулем [`subprocess`](https://python-all.ru/2.7/library/subprocess.html#module-subprocess), теперь имеют методы `terminate()`, `kill()` и `send_signal()`. В Windows `send_signal()` поддерживает только сигнал `SIGTERM`, и все эти методы являются псевдонимами для функции Win32 API `TerminateProcess()`. (Автор: Christian Heimes.)
- Новая переменная в модуле [`sys`](https://python-all.ru/2.7/library/sys.html#module-sys), `float_info`, представляет собой объект, содержащий информацию, полученную из файла `float.h` о поддержке чисел с плавающей запятой на платформе. Атрибуты этого объекта включают `mant_dig` (количество цифр в мантиссе), `epsilon` (наименьшая разница между 1.0 и следующим наибольшим представимым значением) и несколько других. (Автор: Christian Heimes; [bpo-1534](https://python-all.ru/2.7/whatsnew/2.6.html).)

  Ещё одна новая переменная, `dont_write_bytecode`, управляет тем, записывает ли Python какие-либо файлы `.pyc` или `.pyo` при импорте модуля. Если эта переменная истинна, скомпилированные файлы не записываются. Переменная изначально устанавливается при запуске путём передачи переключателя [`-B`](https://python-all.ru/2.7/using/cmdline.html#id1) интерпретатору Python или установкой переменной окружения [`PYTHONDONTWRITEBYTECODE`](https://python-all.ru/2.7/using/cmdline.html#envvar-PYTHONDONTWRITEBYTECODE) перед запуском интерпретатора. Код Python впоследствии может изменить значение этой переменной, чтобы управлять записью файлов байткода. (Авторы: Neal Norwitz и Georg Brandl.)

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

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

  Теперь можно определить текущие функции профилировщика и трассировщика, вызвав [`sys.getprofile()`](https://python-all.ru/2.7/library/sys.html#sys.getprofile) и [`sys.gettrace()`](https://python-all.ru/2.7/library/sys.html#sys.gettrace). (Автор: Georg Brandl; [bpo-1648](https://python-all.ru/2.7/whatsnew/2.6.html).)
- Модуль [`tarfile`](https://python-all.ru/2.7/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 поддерживает имена файлов в Unicode, по умолчанию используется UTF-8.)

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

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

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

  Классы `NamedTemporaryFile` и `SpooledTemporaryFile` оба работают как менеджеры контекста, поэтому можно написать `with tempfile.NamedTemporaryFile() as tmp: ...`. (Автор: Alexander Belopolsky; [bpo-2021](https://python-all.ru/2.7/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` и возвращает объект, который будет записывать все вызванные предупреждения ([bpo-3781](https://python-all.ru/2.7/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/2.7/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; [bpo-1581073](https://python-all.ru/2.7/whatsnew/2.6.html).)
- API модуля [`threading`](https://python-all.ru/2.7/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/2.7/library/threading.html#module-threading) получили свойство `ident`, которое возвращает идентификатор потока – ненулевое целое число. (Автор: Gregory P. Smith; [bpo-2871](https://python-all.ru/2.7/whatsnew/2.6.html).)
- Модуль [`timeit`](https://python-all.ru/2.7/library/timeit.html#module-timeit) теперь принимает как строки, так и вызываемые объекты для измеряемого оператора и для кода настройки. Были добавлены две вспомогательные функции для создания экземпляров `Timer`: `repeat(stmt, setup, time, repeat, number)` и `timeit(stmt, setup, time, number)` создают экземпляр и вызывают соответствующий метод. (Автор: Erik Demaine; [bpo-1533909](https://python-all.ru/2.7/whatsnew/2.6.html).)
- Модуль [`Tkinter`](https://python-all.ru/2.7/library/tkinter.html#module-Tkinter) теперь принимает списки и кортежи для параметров, разделяя элементы пробелами перед передачей результирующего значения в Tcl/Tk. (Автор: Guilherme Polo; [bpo-2906](https://python-all.ru/2.7/whatsnew/2.6.html).)
- Модуль [`turtle`](https://python-all.ru/2.7/library/turtle.html#module-turtle) для черепашьей графики был значительно улучшен Gregor Lingl. Новые возможности модуля включают:

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

  ([bpo-1513695](https://python-all.ru/2.7/whatsnew/2.6.html))
- Необязательный параметр `timeout` был добавлен в функцию [`urllib.urlopen()`](https://python-all.ru/2.7/library/urllib.html#urllib.urlopen), конструктор класса `urllib.ftpwrapper`, а также в функцию [`urllib2.urlopen()`](https://python-all.ru/2.7/library/urllib2.html#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/2.7/library/unicodedata.html#module-unicodedata), обновлена до версии 5.1.0. (Обновлено Martin von Loewis; [bpo-3811](https://python-all.ru/2.7/whatsnew/2.6.html).)
- Методы `formatwarning()` и `showwarning()` модуля [`warnings`](https://python-all.ru/2.7/library/warnings.html#module-warnings) получили необязательный аргумент *line*, который можно использовать для указания строки исходного кода. (Добавлено в рамках [bpo-1631171](https://python-all.ru/2.7/whatsnew/2.6.html), который переписал часть модуля [`warnings`](https://python-all.ru/2.7/library/warnings.html#module-warnings) на C.)

  Новая функция `catch_warnings()` – это контекстный менеджер, предназначенный для тестирования, который позволяет временно изменять фильтры предупреждений, а затем восстанавливать их исходные значения ([bpo-3781](https://python-all.ru/2.7/whatsnew/2.6.html)).
- Классы [`SimpleXMLRPCServer`](https://python-all.ru/2.7/library/simplexmlrpcserver.html#SimpleXMLRPCServer.SimpleXMLRPCServer) и [`DocXMLRPCServer`](https://python-all.ru/2.7/library/docxmlrpcserver.html#DocXMLRPCServer.DocXMLRPCServer) XML-RPC теперь можно настроить так, чтобы они не открывали и не привязывали свой сокет немедленно, передав `False` в качестве параметра *bind\_and\_activate* конструктора. Это можно использовать для изменения атрибута `allow_reuse_address` экземпляра перед вызовом методов `server_bind()` и `server_activate()`, чтобы открыть сокет и начать прослушивание соединений. (Предложено Питером Паренте; [bpo-1599845](https://python-all.ru/2.7/whatsnew/2.6.html).)

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

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

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

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

  (Предложено Аланом Макинтайром; [bpo-467924](https://python-all.ru/2.7/whatsnew/2.6.html).)

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

  Наконец, [`zipfile`](https://python-all.ru/2.7/library/zipfile.html#module-zipfile) теперь поддерживает использование имён файлов в Unicode для архивных файлов. (Предложено Алексеем Борзенковым; [bpo-1734346](https://python-all.ru/2.7/whatsnew/2.6.html).)

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

Модуль [`ast`](https://python-all.ru/2.7/library/ast.html#module-ast) предоставляет представление Python-кода в виде абстрактного синтаксического дерева, а Армин Ронахер предложил набор вспомогательных функций, выполняющих различные распространённые задачи. Они будут полезны для пакетов 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/2.7/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
```

Модуль также включает классы `NodeVisitor` и `NodeTransformer` для обхода и изменения AST, а также функции для распространённых преобразований, таких как изменение номеров строк.

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

Python 3.0 вносит много изменений в набор встроенных функций, и большинство из них нельзя ввести в серии Python 2.x, поскольку это нарушило бы совместимость. Модуль [`future_builtins`](https://python-all.ru/2.7/library/future_builtins.html#module-future_builtins) предоставляет версии этих встроенных функций, которые можно импортировать при написании кода, совместимого с Python 3.0.

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

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

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

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

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

### Модуль [`plistlib`](https://python-all.ru/2.7/library/plistlib.html#module-plistlib): анализатор списков свойств

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

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

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

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

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

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

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

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

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

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

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

  Список устаревших модулей: `audiodev`, `bgenlocations`, [`buildtools`](https://python-all.ru/2.7/library/undoc.html#module-buildtools), `bundlebuilder`, `Canvas`, [`compiler`](https://python-all.ru/2.7/library/compiler.html#module-compiler), [`dircache`](https://python-all.ru/2.7/library/dircache.html#module-dircache), [`dl`](https://python-all.ru/2.7/library/dl.html#module-dl), [`fpformat`](https://python-all.ru/2.7/library/fpformat.html#module-fpformat), [`gensuitemodule`](https://python-all.ru/2.7/library/gensuitemodule.html#module-gensuitemodule), `ihooks`, [`imageop`](https://python-all.ru/2.7/library/imageop.html#module-imageop), [`imgfile`](https://python-all.ru/2.7/library/imgfile.html#module-imgfile), `linuxaudiodev`, [`mhlib`](https://python-all.ru/2.7/library/mhlib.html#module-mhlib), [`mimetools`](https://python-all.ru/2.7/library/mimetools.html#module-mimetools), [`multifile`](https://python-all.ru/2.7/library/multifile.html#module-multifile), [`new`](https://python-all.ru/2.7/library/new.html#module-new), `pure`, [`statvfs`](https://python-all.ru/2.7/library/statvfs.html#module-statvfs), [`sunaudiodev`](https://python-all.ru/2.7/library/sunaudio.html#module-sunaudiodev), `test.testall` и `toaiff`.
- Модуль `gopherlib` удалён.
- Модули [`MimeWriter`](https://python-all.ru/2.7/library/mimewriter.html#module-MimeWriter) и [`mimify`](https://python-all.ru/2.7/library/mimify.html#module-mimify) объявлены устаревшими; вместо них используйте пакет [`email`](https://python-all.ru/2.7/library/email.html#module-email).
- Модуль [`md5`](https://python-all.ru/2.7/library/md5.html#module-md5) объявлен устаревшим; используйте вместо него модуль [`hashlib`](https://python-all.ru/2.7/library/hashlib.html#module-hashlib).
- Модуль [`posixfile`](https://python-all.ru/2.7/library/posixfile.html#module-posixfile) объявлен устаревшим; [`fcntl.lockf()`](https://python-all.ru/2.7/library/fcntl.html#fcntl.lockf) предоставляет более надёжные блокировки.
- Модуль [`popen2`](https://python-all.ru/2.7/library/popen2.html#module-popen2) объявлен устаревшим; используйте модуль [`subprocess`](https://python-all.ru/2.7/library/subprocess.html#module-subprocess).
- Модуль `rgbimg` удалён.
- Модуль [`sets`](https://python-all.ru/2.7/library/sets.html#module-sets) объявлен устаревшим; лучше использовать встроенные типы [`set`](https://python-all.ru/2.7/library/stdtypes.html#set) и [`frozenset`](https://python-all.ru/2.7/library/stdtypes.html#frozenset).
- Модуль [`sha`](https://python-all.ru/2.7/library/sha.html#module-sha) объявлен устаревшим; используйте вместо него модуль [`hashlib`](https://python-all.ru/2.7/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`](https://python-all.ru/2.7/library/bsddb.html#module-bsddb) для своих целей. (Предложено Данканом Грисби.)
- Новый интерфейс буфера, ранее описанный в [разделе PEP 3118](https://python-all.ru/2.7/whatsnew/2.6.html#pep-3118-revised-buffer-protocol), добавляет функции [`PyObject_GetBuffer()`](https://python-all.ru/2.7/c-api/buffer.html#c.PyObject_GetBuffer) и [`PyBuffer_Release()`](https://python-all.ru/2.7/c-api/buffer.html#c.PyBuffer_Release), а также несколько других.
- Использование Python библиотеки C stdio теперь потокобезопасно, или, по крайней мере, настолько потокобезопасно, насколько им является сама нижележащая библиотека. Долгое время существовала потенциальная ошибка, когда один поток закрывал файловый объект, в то время как другой поток читал из него или писал в него. В Python 2.6 файловые объекты имеют счетчик ссылок, управляемый функциями [`PyFile_IncUseCount()`](https://python-all.ru/2.7/c-api/file.html#c.PyFile_IncUseCount) и [`PyFile_DecUseCount()`](https://python-all.ru/2.7/c-api/file.html#c.PyFile_DecUseCount). Файловый объект нельзя закрыть, пока счетчик ссылок не равен нулю. [`PyFile_IncUseCount()`](https://python-all.ru/2.7/c-api/file.html#c.PyFile_IncUseCount) должна вызываться, пока GIL еще удерживается, перед выполнением операции ввода-вывода с использованием указателя `FILE *`, а [`PyFile_DecUseCount()`](https://python-all.ru/2.7/c-api/file.html#c.PyFile_DecUseCount) должна вызываться сразу после повторного захвата GIL. (Авторы: Антуан Питу и Грегори П. Смит.)
- Одновременный импорт модулей в двух разных потоках больше не приводит к взаимоблокировке; теперь вместо этого возбуждается [`ImportError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.ImportError). Новая функция API, [`PyImport_ImportModuleNoBlock()`](https://python-all.ru/2.7/c-api/import.html#c.PyImport_ImportModuleNoBlock), сначала ищет модуль в `sys.modules`, а затем пытается импортировать его после захвата блокировки импорта. Если блокировка импорта удерживается другим потоком, возбуждается [`ImportError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.ImportError). (Автор: Кристиан Хаймс.)
- Несколько функций возвращают информацию о поддержке чисел с плавающей запятой платформой. [`PyFloat_GetMax()`](https://python-all.ru/2.7/c-api/float.html#c.PyFloat_GetMax) возвращает максимальное представимое значение с плавающей запятой, а [`PyFloat_GetMin()`](https://python-all.ru/2.7/c-api/float.html#c.PyFloat_GetMin) возвращает минимальное положительное значение. [`PyFloat_GetInfo()`](https://python-all.ru/2.7/c-api/float.html#c.PyFloat_GetInfo) возвращает объект, содержащий дополнительную информацию из файла `float.h`, такую как `"mant_dig"` (количество цифр в мантиссе), `"epsilon"` (наименьшая разница между 1.0 и следующим большим представимым значением) и несколько других. (Вклад Кристиана Хаймса; [bpo-1534](https://python-all.ru/2.7/whatsnew/2.6.html).)
- C-функции и методы, использующие [`PyComplex_AsCComplex()`](https://python-all.ru/2.7/c-api/complex.html#c.PyComplex_AsCComplex), теперь принимают аргументы, у которых есть метод [`__complex__()`](https://python-all.ru/2.7/reference/datamodel.html#object.__complex__). В частности, функции в модуле [`cmath`](https://python-all.ru/2.7/library/cmath.html#module-cmath) теперь принимают объекты с этим методом. Это обратный порт изменения из Python 3.0. (Автор: Марк Дикинсон; [bpo-1675423](https://python-all.ru/2.7/whatsnew/2.6.html).)
- C API Python теперь включает две функции для сравнения строк без учета регистра: `PyOS_stricmp(char*, char*)` и `PyOS_strnicmp(char*, char*, Py_ssize_t)`. (Автор: Кристиан Хаймс; [bpo-1635](https://python-all.ru/2.7/whatsnew/2.6.html).)
- Многие C-расширения определяют собственные макросы для добавления целых чисел и строк в словарь модуля в функции `init*`. Python 2.6 наконец-то определяет стандартные макросы для добавления значений в модуль: [`PyModule_AddStringMacro`](https://python-all.ru/2.7/c-api/module.html#c.PyModule_AddStringMacro) и `PyModule_AddIntMacro()`. (Автор: Кристиан Хаймс.)
- Некоторые макросы были переименованы как в 3.0, так и в 2.6, чтобы было понятнее, что это макросы, а не функции. `Py_Size()` стал `Py_SIZE()`, `Py_Type()` стал `Py_TYPE()`, а `Py_Refcnt()` стал `Py_REFCNT()`. Макросы со смешанным регистром по-прежнему доступны в Python 2.6 для обратной совместимости. ([bpo-1629](https://python-all.ru/2.7/whatsnew/2.6.html))
- Distutils теперь размещает создаваемые C-расширения в другом каталоге при работе с отладочной версией Python. (Автор: Коллин Уинтер; [bpo-1530959](https://python-all.ru/2.7/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% быстрее обычных. (Автор: Christian Heimes при помощи Amaury Forgeot d’Arc и Martin von Loewis.)
- Модуль [`msvcrt`](https://python-all.ru/2.7/library/msvcrt.html#module-msvcrt) теперь поддерживает как обычную, так и широкосимвольную версии консольного API ввода-вывода. Функция `getwch()` считывает нажатие клавиши и возвращает значение Unicode, как и функция `getwche()`. Функция `putwch()` принимает символ Unicode и записывает его на консоль. (Автор: Кристиан Хаймс.)
- [`os.path.expandvars()`](https://python-all.ru/2.7/library/os.path.html#os.path.expandvars) теперь будет раскрывать переменные окружения в форме «%var%», а «~user» будет раскрываться в путь к домашнему каталогу пользователя. (Автор: Джозия Карлсон; [bpo-957650](https://python-all.ru/2.7/whatsnew/2.6.html).)
- Объекты сокетов модуля [`socket`](https://python-all.ru/2.7/library/socket.html#module-socket) теперь имеют метод `ioctl()`, который предоставляет ограниченный интерфейс к системному интерфейсу `WSAIoctl()`.
- В модуле [`_winreg`](https://python-all.ru/2.7/library/_winreg.html#module-_winreg) теперь есть функция `ExpandEnvironmentStrings()`, которая раскрывает ссылки на переменные окружения, такие как `%NAME%`, во входной строке. Объекты handle, предоставляемые этим модулем, теперь поддерживают протокол контекстного менеджера, поэтому их можно использовать в операторах [`with`](https://python-all.ru/2.7/reference/compound_stmts.html#with). (Автор: Кристиан Хаймс.)

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

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

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

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

Ряд старых модулей, специфичных для IRIX, устарели и будут удалены в Python 3.0: [`al`](https://python-all.ru/2.7/library/al.html#module-al) и [`AL`](https://python-all.ru/2.7/library/al.html#module-AL), [`cd`](https://python-all.ru/2.7/library/cd.html#module-cd), `cddb`, `cdplayer`, `CL` и `cl`, [`DEVICE`](https://python-all.ru/2.7/library/gl.html#module-DEVICE), `ERRNO`, `FILE`, [`FL`](https://python-all.ru/2.7/library/fl.html#module-FL) и [`fl`](https://python-all.ru/2.7/library/fl.html#module-fl), [`flp`](https://python-all.ru/2.7/library/fl.html#module-flp), [`fm`](https://python-all.ru/2.7/library/fm.html#module-fm), `GET`, `GLWS`, [`GL`](https://python-all.ru/2.7/library/gl.html#module-GL) и [`gl`](https://python-all.ru/2.7/library/gl.html#module-gl), `IN`, `IOCTL`, [`jpeg`](https://python-all.ru/2.7/library/jpeg.html#module-jpeg), `panelparser`, `readcd`, `SV` и `sv`, `torgb`, [`videoreader`](https://python-all.ru/2.7/library/undoc.html#module-videoreader) и `WAIT`.

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

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

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