Что нового в Python 2.6¶What’s New in Python 2.6

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__() для преобразования объектов в комплексное число.

• Альтернативный синтаксис для перехвата исключений: except TypeError as exc.

• Добавление functools.reduce() как синонима для встроенной функции reduce().

Python 3.0 добавляет несколько новых встроенных функций и изменяет семантику некоторых существующих. Функции, новые в 3.0, такие как bin(), были просто добавлены в Python 2.6, но существующие встроенные функции не были изменены; вместо этого модуль future_builtins содержит версии с новой семантикой 3.0. Код, написанный для совместимости с 3.0, может при необходимости делать from future_builtins import hex, map.

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

Изменения в процессе разработки¶Changes to the Development Process

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

PEP 343: Оператор ‘with’¶PEP 343: The ‘with’ statement

Предыдущая версия, Python 2.5, добавила оператор ‘with’ как опциональную возможность, включаемую директивой from __future__ import with_statement. В версии 2.6 оператор больше не требует специального включения; это означает, что with теперь всегда является ключевым словом. Остальная часть этого раздела является копией соответствующего раздела из документа «What’s New in Python 2.5»; если вы знакомы с оператором ‘with’ из Python 2.5, можете пропустить этот раздел.

Оператор ‘with’ делает код понятнее, который ранее использовал блоки try...finally для гарантии выполнения кода очистки. В этом разделе я расскажу об операторе в его обычном использовании. В следующем разделе я рассмотрю детали реализации и покажу, как писать объекты для использования с этим оператором.

Оператор ‘with’ – это управляющая структура, базовая структура которой:

with expression [as variable]:
    with-block

Выражение вычисляется, и в результате должен получиться объект, поддерживающий протокол управления контекстом (то есть имеющий методы __enter__() и __exit__()).

Метод __enter__() объекта вызывается перед выполнением блока with и поэтому может выполнять код настройки. Он также может возвращать значение, которое связывается с именем переменная, если оно указано. (Обратите внимание, что переменная не присваивается результат выражения.)

После завершения выполнения блока with вызывается метод __exit__() объекта, даже если блок вызвал исключение, и поэтому он может выполнить код очистки.

Некоторые стандартные объекты Python теперь поддерживают протокол управления контекстом и могут использоваться с оператором ‘with’. Файловые объекты – один из примеров:

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

После выполнения этого оператора файловый объект f будет автоматически закрыт, даже если цикл for вызвал исключение в середине блока.

Блокировки и переменные условия модуля threading также поддерживают оператор ‘with’:

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

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

Функция localcontext() в модуле decimal упрощает сохранение и восстановление текущего десятичного контекста, который инкапсулирует желаемые характеристики точности и округления для вычислений:

from decimal import Decimal, Context, localcontext

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

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

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

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"

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

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

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:
    ...

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

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 366: Явные относительные импорты из главного модуля ¶PEP 366: Explicit Relative Imports From a Main Module

Параметр командной строки -m Python позволяет запускать модуль как скрипт. Когда вы запускали модуль, находящийся внутри пакета, относительные импорты работали некорректно.

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

Импортёры в стиле PEP 302 могут затем устанавливать __package__ по мере необходимости. Модуль runpy, реализующий параметр -m, теперь делает это, так что относительные импорты теперь будут корректно работать в скриптах, запускаемых изнутри пакета.

PEP 370: Персональный каталог site-packages¶PEP 370: Per-user site-packages Directory

При запуске 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 задаёт корневой каталог, используемый всеми версиями Python, поддерживающими эту возможность. В Windows каталог для данных приложений можно изменить, установив переменную окружения APPDATA. Также можно изменить файл site.py для вашей установки Python.

Эту возможность можно полностью отключить, запустив Python с параметром -s или установив переменную окружения PYTHONNOUSERSITE.

PEP 371: multiprocessing Пакет¶PEP 371: The multiprocessing Package

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

Модуль multiprocessing изначально был точной эмуляцией модуля threading, использующей процессы вместо потоков. Эта цель была отброшена на пути к Python 2.6, но общий подход модуля остаётся похожим. Основным классом является Process, которому передаётся вызываемый объект и набор аргументов. Метод start() запускает вызываемый объект в подпроцессе, после чего можно вызвать метод is_alive(), чтобы проверить, работает ли подпроцесс, и метод join(), чтобы дождаться завершения процесса.

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

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. Объект Queue хранится в глобальной переменной. Дочерний процесс будет использовать значение переменной на момент своего создания; поскольку это Queue, родительский и дочерний процессы могут обмениваться данными через этот объект. (Если бы родитель изменил значение глобальной переменной, значение дочернего процесса не изменилось бы, и наоборот.)

Два других класса, Pool и Manager, предоставляют интерфейсы более высокого уровня. Pool создаёт фиксированное количество рабочих процессов, и запросы затем можно распределять между рабочими процессами с помощью вызова apply() или apply_async() для добавления одного запроса и map() или map_async() для добавления нескольких запросов. В следующем коде используется Pool для распределения запросов по 5 рабочим процессам и получения списка результатов:

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

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

1
39916800
51090942171709440000
8222838654177922817725562880000000
33452526613163807108170062053440751665152000000000
...

Другой интерфейс высокого уровня, класс Manager, создаёт отдельный серверный процесс, который может хранить главные копии структур данных Python. Другие процессы затем могут получать доступ и изменять эти структуры данных с помощью прокси-объектов. В следующем примере создаётся общий словарь вызовом метода dict(); рабочие процессы затем вставляют значения в словарь. (Блокировка не выполняется автоматически, что в данном примере не имеет значения. Методы Manager также включают Lock(), RLock(), и Semaphore() для создания общих блокировок.)

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

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

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

PEP 3101: Расширенное форматирование строк¶PEP 3101: Advanced String Formatting

В Python 3.0 оператор % дополнен более мощным методом форматирования строк format(). Поддержка метода str.format() была перенесена в Python 2.6.

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

>>> # Подставить позиционный аргумент 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'

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

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

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

>>> 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. Строки, начинающиеся с цифры, будут преобразованы в целое число. В строке формата нельзя писать более сложные выражения.

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

>>> # Поле 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'

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

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

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

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

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

Доступны различные типы представления. Обратитесь к документации Python 2.6 за полным списком; вот пример:

Классы и типы могут определять метод __format__() для управления тем, как они форматируются. Он принимает единственный аргумент – спецификатор формата:

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

Также существует встроенная функция format(), которая форматирует одно значение. Она вызывает метод __format__() типа с переданным спецификатором:

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

PEP 3105: print как функция¶PEP 3105: print As a Function

Оператор print в Python 3.0 становится функцией print(). Превращение print() в функцию позволяет заменить эту функцию, написав def print(...) или импортировав новую функцию откуда-то ещё.

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

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

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

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

Параметры:

• args: позиционные аргументы, значения которых будут выведены.

• sep: разделитель, который будет выводиться между аргументами.

• end: завершающий текст, который будет выведен после того, как все аргументы будут выведены.

• file: файловый объект, в который будет отправлен вывод.

PEP 3110: Изменения в обработке исключений¶PEP 3110: Exception-Handling Changes

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

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

Автор, вероятно, пытается перехватить оба исключения TypeError и ValueError, но этот код на самом деле делает кое-что другое: он перехватит TypeError и свяжет полученный объект исключения с локальным именем "ValueError". Исключение ValueError не будет перехвачено вообще. Правильный код задает кортеж исключений:

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

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

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

try:
    ...
except TypeError as exc:
    ...

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

PEP 3112: Байтовые литералы¶PEP 3112: Byte Literals

Python 3.0 принимает Unicode в качестве основного строкового типа языка и обозначает 8-битные литералы иначе: либо как b'string', либо с помощью конструктора bytes. Для обратной совместимости Python 2.6 добавляет bytes как синоним типа str, а также поддерживает нотацию b''.

Тип str в 2.6 отличается от типа bytes в 3.0 по ряду причин; наиболее заметно, что конструктор совершенно разный. В 3.0 bytes([65, 66, 67]) имеет длину 3 элемента и содержит байты, представляющие ABC; в 2.6 bytes([65, 66, 67]) возвращает 12-байтовую строку, представляющую str() списка.

Основное применение bytes в 2.6 будет заключаться в написании тестов типа объекта, таких как isinstance(x, bytes). Это поможет конвертеру 2to3, который не может определить, предназначены ли строки в коде 2.x для содержания символов или 8-битных байтов; теперь можно использовать bytes или str для точного выражения намерения, и результирующий код также будет корректным в Python 3.0.

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

from __future__ import unicode_literals

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

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

На уровне C Python 3.0 переименует существующий 8-битный строковый тип, называемый PyStringObject в Python 2.x, в PyBytesObject. Python 2.6 использует #define для поддержки использования имён PyBytesObject(), PyBytes_Check(), PyBytes_FromStringAndSize() и всех остальных функций и макросов, используемых со строками.

Экземпляры типа bytes неизменяемы, как и строки. Новый тип bytearray хранит изменяемую последовательность байтов:

>>> 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().

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

Существует также соответствующий C API с функциями PyByteArray_FromObject(), PyByteArray_FromStringAndSize() и различными другими.

PEP 3116: Новая библиотека ввода-вывода¶PEP 3116: New I/O Library

Встроенные файловые объекты Python поддерживают ряд методов, но файлоподобные объекты не обязательно поддерживают их все. Объекты, имитирующие файлы, обычно поддерживают read() и write(), но они могут не поддерживать readline(), например. Python 3.0 вводит многоуровневую библиотеку ввода-вывода в модуле io, которая отделяет буферизацию и обработку текста от основных операций чтения и записи.

Модуль 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) и поддерживает универсальные символы новой строки. TextIOBase определяет метод readline() и поддерживает итерацию по объектам.

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

  (В Python 2.6 io.StringIO реализован на чистом Python, поэтому он довольно медленный. Поэтому пока лучше придерживаться существующего модуля StringIO или cStringIO. В какой-то момент модуль io Python 3.0 будет переписан на C для ускорения, и, возможно, реализация на C будет портирована на версии 2.x.)

В Python 2.6 базовые реализации не были перестроены поверх классов модуля io. Модуль предоставляется для упрощения написания кода, совместимого с будущими версиями (3.0), и для избавления разработчиков от необходимости писать собственные реализации буферизации и текстового ввода-вывода.

PEP 3118: Пересмотренный буферный протокол¶PEP 3118: Revised Buffer Protocol

Буферный протокол – это C-уровневый API, который позволяет типам Python обмениваться указателями на свои внутренние представления. Например, файл, отображенный в память, можно рассматривать как буфер символов, и это позволяет другому модулю, например 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() задает ограничения на возвращаемую память. Вот несколько примеров:

• PyBUF_WRITABLE указывает, что память должна быть доступна для записи.

• PyBUF_LOCK запрашивает блокировку только для чтения или исключительную блокировку памяти.

• PyBUF_C_CONTIGUOUS и PyBUF_F_CONTIGUOUS запрашивают C-непрерывный (последнее измерение изменяется быстрее всего) или Fortran-непрерывный (первое измерение изменяется быстрее всего) макет массива.

Два новых кода аргументов для PyArg_ParseTuple(), s* и z*, возвращают заблокированные буферные объекты для параметра.

PEP 3119: Абстрактные базовые классы¶PEP 3119: Abstract Base Classes

Некоторые объектно-ориентированные языки, такие как Java, поддерживают интерфейсы, объявляя, что класс имеет определенный набор методов или поддерживает определенный протокол доступа. Абстрактные базовые классы (ABC) – это аналогичная возможность для Python. Поддержка ABC состоит из модуля abc, содержащего метакласс ABCMeta, специальной обработки этого метакласса встроенными функциями isinstance() и issubclass(), а также набора базовых ABC, которые, по мнению разработчиков Python, будут широко полезны. Будущие версии Python, вероятно, добавят больше ABC.

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

Модуль collections в Python 2.6 включает несколько различных ABC, которые представляют эти различия. Iterable указывает, что класс определяет __iter__(), а Container означает, что класс определяет метод __contains__() и, следовательно, поддерживает выражения x in y. Базовый интерфейс словаря (получение элементов, установка элементов, и keys(), values() и items()) определяется MutableMapping ABC.

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

import collections

class Storage(collections.MutableMapping):
    ...

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

import collections

class Storage:
    ...

collections.MutableMapping.register(Storage)

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

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

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

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

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

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

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

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 будет возбуждать исключение для классов, не определяющих этот метод. Обратите внимание: исключение возбуждается только при попытке создать экземпляр подкласса, в котором отсутствует метод:

>>> 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:

from abc import abstractproperty
...

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

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

PEP 3127: Поддержка и синтаксис целочисленных литералов¶PEP 3127: Integer Literal Support and Syntax

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

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

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

Встроенная функция oct() по-прежнему возвращает числа с ведущим нулём, а новая встроенная функция bin() возвращает двоичное представление числа:

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

Встроенные функции int() и long() теперь принимают префиксы «0o» и «0b» при запросе основания 8 или 2, а также когда аргумент base равен нулю (что указывает на то, что используемое основание должно быть определено из строки):

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

PEP 3129: Декораторы классов¶PEP 3129: Class Decorators

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

@foo
@bar
class A:
  pass

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

class A:
  pass

A = foo(bar(A))

PEP 3141: Иерархия типов для чисел¶PEP 3141: A Type Hierarchy for Numbers

Python 3.0 добавляет несколько абстрактных базовых классов для числовых типов, вдохновлённых числовой башней Scheme. Эти классы были портированы в 2.6 как модуль 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. (Он называется Fraction вместо Rational, чтобы избежать конфликта имён с numbers.Rational.)

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

В Python 3.0 PEP слегка переопределяет существующие встроенные функции round(), math.floor(), math.ceil() и добавляет новую – math.trunc(), которая была портирована в Python 2.6. math.trunc() округляет к нулю, возвращая ближайшее Integral, которое находится между аргументом функции и нулём.

>>> 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)

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

Прочие изменения языка ¶Other Language Changes

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

• Каталоги и zip-архивы, содержащие файл __main__.py, теперь можно выполнять напрямую, передавая их имя интерпретатору. Каталог или zip-архив автоматически вставляется как первая запись в sys.path. (Предложение и начальный патч от Энди Чу, впоследствии доработан Филиппом Дж. Иби и Ником Когланом; bpo-1739468.)

• Функция hasattr() перехватывала и игнорировала все ошибки, полагая, что они означают, что метод __getattr__() потерпел неудачу, и поэтому возвращаемое значение hasattr() будет False. Однако эту логику не следует применять к KeyboardInterrupt и SystemExit; Python 2.6 больше не будет отбрасывать такие исключения, когда hasattr() с ними сталкивается. (Исправлено Бенджамином Петерсоном; bpo-2196.)

• При вызове функции с использованием синтаксиса ** для передачи именованных аргументов больше не требуется использовать словарь Python; теперь подойдёт любое отображение:

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

  (Автор: Александр Белопольский; bpo-1686487.)

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

  >>> 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.)

• Новая встроенная функция next(iterator, [default]) возвращает следующий элемент из указанного итератора. Если передан аргумент default, он будет возвращён, если iterator исчерпан; в противном случае будет возбуждено исключение StopIteration. (Портировано в bpo-2719.)

• Кортежи теперь имеют методы index() и count(), соответствующие методам списков index() и count():

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

  (Автор: Рэймонд Хеттингер)

• Встроенные типы теперь имеют улучшенную поддержку расширенного синтаксиса срезов, принимая различные комбинации (start, stop, step). Ранее поддержка была частичной, и некоторые крайние случаи не работали. (Реализовано Томасом Воутерсом.)

• Свойства теперь имеют три атрибута: getter, setter и deleter, которые являются декораторами, предоставляющими удобные сокращения для добавления функции получения, установки или удаления к существующему свойству. Используются они так:

  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().

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

  (Автор: Raymond Hettinger.)

• Было добавлено много функций для чисел с плавающей запятой. Функция float() теперь преобразует строку nan в значение NaN (не число) по стандарту IEEE 754, а +inf и -inf – в положительную или отрицательную бесконечность. Это работает на любой платформе с семантикой IEEE 754. (Автор: Кристиан Хаймс; bpo-1635.)

  Другие функции модуля math, isinf() и isnan(), возвращают true, если их аргумент с плавающей запятой является бесконечностью или NaN. (bpo-1640)

  Были добавлены функции преобразования чисел с плавающей запятой в шестнадцатеричные строки (bpo-3008). Эти функции преобразуют числа с плавающей запятой в строковое представление и обратно, не внося ошибок округления, возникающих при преобразовании между десятичной и двоичной системами. Числа с плавающей запятой имеют метод hex(), возвращающий строковое представление, а метод float.fromhex() преобразует строку обратно в число:

  >>> 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() теперь сохраняет знак нуля. (Исправлено Марком Т. Дикинсоном; bpo-1507.)

• Классы, наследующие метод __hash__() от родительского класса, могут установить __hash__ = None, чтобы указать, что класс не является хешируемым. Это заставит hash(obj) возбуждать TypeError, и класс не будет помечен как реализующий абстрактный базовый класс Hashable.

  Это следует делать, когда вы определили метод __cmp__() или __eq__(), который сравнивает объекты по значению, а не по идентичности. Все объекты имеют метод хеширования по умолчанию, использующий id(obj) в качестве хеш-значения. Нет аккуратного способа удалить метод __hash__(), унаследованный от родительского класса, поэтому присваивание None было реализовано как переопределение. На уровне C расширения могут установить tp_hash в PyObject_HashNotImplemented(). (Исправлено Ником Когланом и Амори Форжео д’Арк; bpo-2235.)

• Исключение GeneratorExit теперь является подклассом BaseException вместо Exception. Это означает, что обработчик исключений, выполняющий except Exception:, не будет случайно перехватывать GeneratorExit. (Автор: Чад Остин; bpo-1537.)

• Объекты-генераторы теперь имеют атрибут gi_code, который ссылается на исходный объект кода, лежащий в основе генератора. (Автор: Коллин Уинтер; bpo-1473257.)

• Встроенная функция compile() теперь принимает как именованные, так и позиционные аргументы. (Автор: Thomas Wouters; bpo-1444529.)

• Конструктор complex() теперь принимает строки, содержащие комплексные числа в скобках, то есть complex(repr(cplx)) теперь будет сохранять значения при преобразовании. Например, complex('(3+4j)') теперь возвращает значение (3+4j). (bpo-1491866)

• Строковый метод translate() теперь принимает None в качестве параметра таблицы перевода, который рассматривается как тождественное преобразование. Это упрощает выполнение операций, которые только удаляют символы. (Автор: Bengt Richter, реализация: Raymond Hettinger; bpo-1193128.)

• Встроенная функция dir() теперь проверяет наличие метода __dir__() у получаемых объектов. Этот метод должен возвращать список строк с именами допустимых атрибутов объекта и позволяет объекту управлять значением, которое возвращает dir(). Объекты, у которых есть методы __getattr__() или __getattribute__(), могут использовать это для объявления псевдоатрибутов, которые они будут поддерживать. (bpo-1591665)

• Объекты методов экземпляров имеют новые атрибуты для объекта и функции, составляющих метод; новый синоним для im_self – это __self__, и im_func также доступен как __func__. Старые имена по-прежнему поддерживаются в Python 2.6, но отсутствуют в 3.0.

• Малоизвестное изменение: при использовании функции locals() внутри инструкции class результирующий словарь больше не возвращает свободные переменные. (В данном случае свободные переменные – это переменные, на которые ссылается инструкция class, но которые не являются атрибутами класса.)

Новые и улучшенные модули¶New and Improved Modules

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

• Модули asyncore и asynchat снова активно поддерживаются, и был применен ряд патчей и исправлений ошибок. (Поддерживаются Josiah Carlson; см. bpo-1736190 для одного из патчей.)

• У модуля bsddb также появился новый сопровождающий – Jesús Cea Avion, и пакет теперь доступен как отдельный пакет. Веб-страница пакета: www.jcea.es/programacion/pybsddb.htm. Планируется удалить пакет из стандартной библиотеки в Python 3.0, поскольку темп его выпусков гораздо чаще, чем у Python.

  Модуль bsddb.dbshelve теперь использует самый высокий доступный протокол сериализации вместо ограничения протоколом 1. (Автор: W. Barnes.)

• Модуль cgi теперь будет читать переменные из строки запроса HTTP POST. Это позволяет использовать действия форм с URL, содержащими строки запроса, например “/cgi-bin/add.py?category=1”. (Авторы: Alexandre Fiori и Nubis; bpo-1817.)

  Функции parse_qs() и parse_qsl() перемещены из модуля cgi в модуль urlparse. Версии, все еще доступные в модуле cgi, будут вызывать сообщения PendingDeprecationWarning в версии 2.6 (bpo-600362).

• Модуль cmath подвергся значительной доработке, авторы – Mark Dickinson и Christian Heimes. Было добавлено пять новых функций:

  • polar() преобразует комплексное число в полярную форму, возвращая модуль и аргумент комплексного числа.

  • rect() делает обратное, преобразуя пару (модуль, аргумент) обратно в соответствующее комплексное число.

  • phase() возвращает аргумент (также называемый углом) комплексного числа.

  • isnan() возвращает True, если либо действительная, либо мнимая часть его аргумента является NaN.

  • isinf() возвращает True, если вещественная или мнимая часть его аргумента бесконечна.

  Правки также повысили численную надёжность модуля cmath. Для всех функций вещественная и мнимая части результатов, где только возможно, точны в пределах нескольких единиц наименьшей точности (ulps). Подробности – на bpo-1381. Также исправлены разрезы ветвей для asinh(), atanh() и atan().

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

  На платформах IEEE 754 модуль cmath теперь обрабатывает специальные значения IEEE 754 и исключения с плавающей запятой в соответствии с приложением G стандарта C99.

• Новый тип данных в модуле collections: namedtuple(typename, fieldnames) – это фабричная функция, создающая подклассы стандартного кортежа, поля которых доступны по имени, а также по индексу. Например:

  >>> 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: тип deque теперь поддерживает необязательный параметр maxlen; если он указан, размер дека будет ограничен не более чем maxlen элементами. Добавление новых элементов в заполненный дек приводит к отбрасыванию старых.

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

  (Автор: Raymond Hettinger.)

• Объекты Morsel модуля Cookie теперь поддерживают атрибут httponly. В некоторых браузерах куки с установленным этим атрибутом не могут быть прочитаны или изменены через JavaScript. (Автор: Arvin Schnell; bpo-1638033.)

• Новый метод окна в модуле curses, chgat(), изменяет атрибуты отображения для заданного количества символов на одной строке. (Автор: Fabian Kreutz.)

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

  Класс Textbox в модуле curses.textpad теперь поддерживает редактирование как в режиме вставки, так и в режиме замены. Режим вставки включается передачей истинного значения параметру insert_mode при создании экземпляра Textbox.

• Методы strftime() модуля datetime теперь поддерживают код формата %f, который раскрывается в количество микросекунд в объекте, дополненное нулями слева до шести знаков. (Автор: Skip Montanaro; bpo-1158.)

• Модуль decimal был обновлён до версии 1.66 Общей спецификации десятичных чисел. Новые возможности включают некоторые методы для базовых математических функций, таких как exp() и log10():

  >>> 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 теперь возвращает именованные кортежи, представляющие совпадения, с атрибутами a, b и size. (Автор: Raymond Hettinger.)

• В конструктор класса ftplib.FTP, а также в метод connect() был добавлен необязательный параметр timeout, задающий тайм-аут в секундах. (Добавлено Facundo Batista.) Кроме того, методы storbinary() и storlines() класса FTP теперь принимают необязательный параметр колбэк, который будет вызываться с каждым блоком данных после его отправки. (Автор: Phil Schwartz; bpo-1221598.)

• Встроенная функция reduce() также доступна в модуле functools. В Python 3.0 встроенная функция была удалена, и reduce() доступна только из functools; в настоящее время планов по удалению встроенной функции в серии 2.x нет. (Патч от Christian Heimes; bpo-1739906.)

• Там, где возможно, модуль getpass теперь использует /dev/tty для вывода приглашения и чтения пароля, возвращаясь к стандартному потоку ошибок и стандартному вводу. Если пароль может быть выведен на терминал, перед отображением приглашения выводится предупреждение. (Автор: Gregory P. Smith.)

• Функция glob.glob() теперь может возвращать имена файлов в Юникоде, если был указан путь в Юникоде и в каталоге есть файлы с такими именами. (bpo-1001604)

• Новая функция в модуле heapq, merge(iter1, iter2, ...), принимает произвольное количество итерируемых объектов, возвращающих данные в отсортированном порядке, и возвращает новый генератор, который выдает содержимое всех итераторов, также в отсортированном порядке. Например:

  >>> 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 теперь реализовано с использованием только сравнения «меньше», а не «меньше или равно», как было раньше. Это приводит использование heapq типа в соответствие с методом list.sort(). (Автор: Raymond Hettinger.)

• В конструкторы классов httplib.HTTPConnection и HTTPSConnection был добавлен необязательный параметр timeout, задающий тайм-аут в секундах. (Добавлено Facundo Batista.)

• Большинство функций модуля inspect, таких как getmoduleinfo() и getargs(), теперь возвращают именованные кортежи. В дополнение к поведению кортежа элементы возвращаемого значения также могут быть доступны как атрибуты. (Автор: Raymond Hettinger.)

  Некоторые новые функции в модуле включают isgenerator(), isgeneratorfunction() и isabstract().

• Модуль itertools получил несколько новых функций.

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

  >>> 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]) возвращает декартово произведение переданных итерируемых объектов – набор кортежей, содержащих все возможные комбинации элементов, возвращённых из каждого итерируемого объекта.

  >>> 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 элементов:

  >>> 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 элементов.

  >>> 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 из элементов итерируемого объекта.

  >>> 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 не указан, по умолчанию берётся количество элементов, возвращаемых итерируемым объектом.

  >>> 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, получившая новый конструктор в Python 2.6. itertools.chain.from_iterable(iterable) принимает единственный итерируемый объект, который должен возвращать другие итерируемые объекты. Затем chain() возвращает все элементы первого итерируемого объекта, затем все элементы второго и так далее.

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

  (Всё добавлено Рэймондом Хеттингером.)

• Класс FileHandler модуля logging и его подклассы WatchedFileHandler, RotatingFileHandler, и TimedRotatingFileHandler теперь имеют необязательный параметр delay в своих конструкторах. Если delay истинно, открытие файла журнала откладывается до первого вызова emit(). (Добавлено Винаем Саджипом.)

  TimedRotatingFileHandler также имеет параметр конструктора utc. Если аргумент истинен, время UTC будет использоваться для определения момента полуночи и генерации имён файлов; в противном случае будет использоваться местное время.

• В модуль math было добавлено несколько новых функций:

  • isinf() и isnan() определяют, является ли заданное число с плавающей запятой бесконечностью (положительной или отрицательной) или NaN (Not a Number), соответственно.

  • copysign() копирует знаковый бит числа IEEE 754, возвращая абсолютное значение x, объединённое со знаковым битом y. Например, math.copysign(1, -0.0) возвращает -1.0. (Добавлено Кристианом Хаймсом.)

  • factorial() вычисляет факториал числа. (Добавлено Рэймондом Хеттингером; bpo-2138.)

  • fsum() суммирует поток чисел из итерируемого объекта, стараясь избежать потери точности за счёт использования частичных сумм. (Добавлено Жаном Брауэрсом, Рэймондом Хеттингером и Марком Дикинсоном; bpo-2819.)

  • acosh(), asinh() и atanh() вычисляют обратные гиперболические функции.

  • log1p() возвращает натуральный логарифм от 1+x (по основанию e).

  • trunc() округляет число в сторону нуля, возвращая ближайшее Integral, которое находится между аргументом функции и нулём. Добавлено в рамках обратного портирования иерархии типов чисел из PEP 3141.

• Модуль math был улучшен для более согласованного поведения на разных платформах, особенно в отношении обработки исключений с плавающей запятой и специальных значений IEEE 754.

  По возможности модуль следует рекомендациям стандарта C99 относительно специальных значений 754. Например, sqrt(-1.) теперь должно давать ValueError почти на всех платформах, в то время как sqrt(float('NaN')) должно возвращать NaN на всех платформах, поддерживающих IEEE 754. Там, где приложение F стандарта C99 рекомендует сигнализировать «деление на ноль» или «недопустимая операция», Python возбуждает ValueError. Там, где приложение F рекомендует сигнализировать «переполнение», Python возбуждает OverflowError. (См. bpo-711019 и bpo-1640.)

  (Добавлено Кристианом Хаймсом и Марком Дикинсоном.)

• Объекты mmap теперь имеют метод rfind(), который ищет подстроку, начиная с конца строки и двигаясь назад. Метод find() также получил параметр end, задающий индекс, на котором следует остановить поиск. (Добавлено Джоном Лентоном.)

• Модуль operator получил функцию methodcaller(), которая принимает имя и необязательный набор аргументов, возвращая вызываемый объект, который будет вызывать именованную функцию с любыми переданными аргументами. Например:

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

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

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

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

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

• Модуль os теперь обёртывает несколько новых системных вызовов. fchmod(fd, mode) и fchown(fd, uid, gid) изменяют режим и владельца открытого файла, а lchmod(path, mode) изменяет режим символической ссылки. (Добавлено Георгом Брандлом и Кристианом Хаймсом.)

  chflags() и lchflags() являются обёртками для соответствующих системных вызовов (где они доступны), изменяющими флаги, установленные для файла. Константы значений флагов определены в модуле stat; некоторые возможные значения включают UF_IMMUTABLE (файл нельзя изменять) и UF_APPEND (данные можно только добавлять в файл). (Добавлено М. Левинсоном.)

  os.closerange(low, high) эффективно закрывает все файловые дескрипторы от low до high, игнорируя любые ошибки и не включая сам high. Эта функция теперь используется модулем subprocess для ускорения запуска процессов. (Добавлено Георгом Брандлом; bpo-1663329.)

• Метод clear() объекта os.environ теперь будет сбрасывать переменные окружения с помощью os.unsetenv() в дополнение к очистке ключей объекта. (Добавлено Мартином Хорчичкой; bpo-1181.)

• Функция os.walk() теперь имеет параметр followlinks. Если ему присвоено True, она будет переходить по символьным ссылкам, указывающим на каталоги, и обходить содержимое каталога. Для обратной совместимости значение параметра по умолчанию – false. Обратите внимание, что функция может попасть в бесконечную рекурсию, если есть символьная ссылка, указывающая на родительский каталог. (bpo-1273829)

• В модуле os.path функция splitext() была изменена: теперь она не разбивает строку по начальным точкам. Это даёт лучшие результаты при работе с «точечными» файлами Unix (dot-files). Например, os.path.splitext('.ipython') теперь возвращает ('.ipython', '') вместо ('', '.ipython'). (bpo-1115886)

  Новая функция os.path.relpath(path, start='.') возвращает относительный путь от пути start, если он указан, или от текущей рабочей директории до целевого пути path. (Добавлено Ричардом Барраном; bpo-1339796.)

  В Windows os.path.expandvars() теперь будет раскрывать переменные окружения, заданные в форме «%var%», а «~user» будет раскрываться в путь к домашнему каталогу пользователя. (Добавлено Джозайей Карлсоном; bpo-957650.)

• Отладчик Python, предоставляемый модулем pdb, получил новую команду: «run» перезапускает отлаживаемую программу Python и может опционально принимать новые аргументы командной строки для программы. (Добавлено Рокки Бернстайном; bpo-1393667.)

• Функция pdb.post_mortem(), используемая для начала отладки по traceback, теперь будет использовать traceback, возвращаемый sys.exc_info(), если traceback не передан. (Добавлено Факундо Батистой; bpo-1106316.)

• Модуль pickletools теперь имеет функцию optimize(), которая принимает строку, содержащую pickle, и удаляет некоторые неиспользуемые опкоды, возвращая более короткий pickle, содержащий ту же структуру данных. (Автор: Raymond Hettinger.)

• В модуль pkgutil была добавлена функция get_data(), которая возвращает содержимое файлов ресурсов, включённых в установленный пакет Python. Например:

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

  (Автор: Paul Moore; bpo-2439.)

• Объекты Parser модуля pyexpat теперь позволяют устанавливать свой атрибут buffer_size для изменения размера буфера, используемого для хранения символьных данных. (Автор: Achim Gaedke; bpo-1137.)

• Модуль Queue теперь предоставляет разновидности очередей, которые извлекают записи в разных порядках. Класс PriorityQueue хранит элементы очереди в куче и извлекает их в порядке приоритета, а LifoQueue извлекает первыми самые недавно добавленные записи, то есть ведёт себя как стек. (Автор: Raymond Hettinger.)

• Объекты Random модуля random теперь можно сериализовать в 32-битной системе и десериализовать в 64-битной системе, и наоборот. К сожалению, это изменение также означает, что объекты Random Python 2.6 нельзя корректно десериализовать в более ранних версиях Python. (Автор: Shawn Ligocki; bpo-1727780.)

  Новая функция triangular(low, high, mode) возвращает случайные числа, подчиняющиеся треугольному распределению. Возвращаемые значения находятся между low и high, не включая high, и с mode в качестве наиболее часто встречающегося значения в распределении. (Авторы: Wladmir van der Laan и Raymond Hettinger; bpo-1681432.)

• Длительные поиски по регулярным выражениям, выполняемые модулем re, будут проверять доставку сигналов, поэтому длительные поиски теперь можно прерывать. (Авторы: Josh Hoyt и Ralf Schmitt; bpo-846388.)

  Модуль регулярных выражений реализован путём компиляции байткода для крошечной виртуальной машины, специфичной для regex. Недоверенный код может напрямую создавать вредоносные строки байткода и вызывать сбои, поэтому Python 2.6 включает верификатор для байткода regex. (Автор: Guido van Rossum на основе работы для Google App Engine; bpo-3487.)

• Метод Completer.complete() модуля rlcompleter теперь будет игнорировать исключения, возникающие при вычислении имени. (Исправлено Lorenz Quack; bpo-2250.)

• Экземпляры scheduler модуля sched теперь имеют атрибут queue только для чтения, который возвращает содержимое очереди планировщика, представленное в виде списка именованных кортежей с полями (time, priority, action, argument). (Автор: Raymond Hettinger; bpo-1861.)

• Модуль select теперь имеет функции-обёртки для системных вызовов Linux epoll() и BSD kqueue(). Метод modify() был добавлен к существующим объектам poll; pollobj.modify(fd, eventmask) принимает файловый дескриптор или файловый объект и маску событий, изменяя записанную маску событий для этого файла. (Автор: Christian Heimes; bpo-1657.)

• Функция shutil.copytree() теперь имеет необязательный аргумент ignore, который принимает вызываемый объект. Этот вызываемый объект будет получать каждый путь к каталогу и список содержимого каталога, и возвращать список имён, которые будут проигнорированы, а не скопированы.

  Модуль shutil также предоставляет функцию ignore_patterns() для использования с этим новым параметром. ignore_patterns() принимает произвольное количество шаблонов в стиле glob и возвращает вызываемый объект, который будет игнорировать любые файлы и каталоги, соответствующие любому из этих шаблонов. В следующем примере копируется дерево каталогов, но пропускаются как каталоги .svn, так и резервные файлы Emacs, у которых имена заканчиваются на '~':

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

  (Автор: Tarek Ziadé; bpo-2663.)

• Интеграция обработки сигналов с циклами событий GUI, такими как используемые в Tkinter или GTk+, долгое время была проблемой; большинство программ прибегают к опросу (polling), просыпаясь каждую долю секунды, чтобы проверить, не произошли ли какие-либо события GUI. Теперь модуль signal может сделать это более эффективно. Вызов signal.set_wakeup_fd(fd) устанавливает файловый дескриптор для использования; при получении сигнала в этот файловый дескриптор записывается байт. Также существует функция на уровне C, PySignal_SetWakeupFd(), для установки дескриптора.

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

  (Автор: Adam Olsen; bpo-1583.)

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

  Функции setitimer() и getitimer() также были добавлены (там, где они доступны). setitimer() позволяет устанавливать интервальные таймеры, которые будут отправлять сигнал процессу по истечении заданного времени, измеряемого в реальном времени, процессорном времени процесса или совокупном времени процесса+системы. (Автор: Guilherme Polo; bpo-2240.)

• Модуль smtplib теперь поддерживает SMTP через SSL благодаря добавлению класса SMTP_SSL. Этот класс поддерживает интерфейс, идентичный существующему классу SMTP. (Автор: Monty Taylor.) Оба конструктора классов также имеют необязательный параметр timeout, задающий тайм-аут для начальной попытки соединения, измеряемый в секундах. (Автор: Facundo Batista.)

  В модуль также была добавлена реализация протокола LMTP (RFC 2033). LMTP используется вместо SMTP при передаче электронной почты между агентами, которые не управляют почтовой очередью. (LMTP реализован Leif Hedstrom; bpo-957003.)

  SMTP.starttls() теперь соответствует RFC 3207 и забывает любые знания, полученные от сервера, не полученные в результате самого согласования TLS. (Патч предоставлен Bill Fenner; bpo-829951.)

• Модуль socket теперь поддерживает TIPC (http://tipc.sourceforge.net), высокопроизводительный протокол, не основанный на IP, предназначенный для использования в кластерных средах. Адреса TIPC – это 4- или 5-кортежи. (Вклад Alberto Bertogli; bpo-1646.)

  Новая функция create_connection() принимает адрес и подключается к нему, используя необязательное значение тайм-аута, возвращая подключённый объект сокета. Эта функция также определяет тип адреса и подключается к нему, используя IPv4 или IPv6 по ситуации. Изменение вашего кода для использования create_connection() вместо socket(socket.AF_INET, ...) может быть всем, что нужно, чтобы ваш код работал с IPv6.

• Базовые классы в модуле SocketServer теперь поддерживают вызов метода handle_timeout() после периода бездействия, заданного атрибутом timeout сервера. (Автор: Michael Pomraning.) Метод serve_forever() теперь принимает необязательный интервал опроса, измеряемый в секундах, контролирующий, как часто сервер будет проверять запрос на завершение. (Авторы: Pedro Werneck и Jeffrey Yasskin; bpo-742598, bpo-1193577.)

• Модуль sqlite3, сопровождаемый Gerhard Haering, обновлён с версии 2.3.2 в Python 2.5 до версии 2.4.1.

• Модуль struct теперь поддерживает тип C99 _Bool, используя символ формата '?'. (Вклад David Remahl.)

• Объекты Popen, предоставляемые модулем subprocess, теперь имеют методы terminate(), kill() и send_signal(). В Windows send_signal() поддерживает только сигнал SIGTERM, и все эти методы являются псевдонимами для функции Win32 API TerminateProcess(). (Автор: Christian Heimes.)

• Новая переменная в модуле sys, float_info, представляет собой объект, содержащий информацию, полученную из файла float.h о поддержке чисел с плавающей запятой на платформе. Атрибуты этого объекта включают mant_dig (количество цифр в мантиссе), epsilon (наименьшая разница между 1.0 и следующим наибольшим представимым значением) и несколько других. (Автор: Christian Heimes; bpo-1534.)

  Ещё одна новая переменная, dont_write_bytecode, управляет тем, записывает ли Python какие-либо файлы .pyc или .pyo при импорте модуля. Если эта переменная истинна, скомпилированные файлы не записываются. Переменная изначально устанавливается при запуске путём передачи переключателя -B интерпретатору Python или установкой переменной окружения PYTHONDONTWRITEBYTECODE перед запуском интерпретатора. Код Python впоследствии может изменить значение этой переменной, чтобы управлять записью файлов байткода. (Авторы: Neal Norwitz и Georg Brandl.)

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

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

  Теперь можно определить текущие функции профилировщика и трассировщика, вызвав sys.getprofile() и sys.gettrace(). (Автор: Georg Brandl; bpo-1648.)

• Модуль tarfile теперь поддерживает tar-файлы POSIX.1-2001 (pax) в дополнение к уже поддерживаемым форматам POSIX.1-1988 (ustar) и GNU tar. Формат по умолчанию – GNU tar; укажите параметр format, чтобы открыть файл в другом формате:

  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 добавлен необязательный параметр timeout, задающий тайм-аут в секундах. (Добавлено Facundo Batista.)

• Класс tempfile.NamedTemporaryFile обычно удаляет созданный временный файл при его закрытии. Теперь это поведение можно изменить, передав delete=False конструктору. (Автор: Damien Miller; bpo-1537850.)

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

  Классы NamedTemporaryFile и SpooledTemporaryFile оба работают как менеджеры контекста, поэтому можно написать with tempfile.NamedTemporaryFile() as tmp: .... (Автор: Alexander Belopolsky; bpo-2021.)

• Модуль test.test_support получил ряд менеджеров контекста, полезных для написания тестов. EnvironmentVarGuard() – это менеджер контекста, который временно изменяет переменные окружения и автоматически восстанавливает их старые значения.

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

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

  Наконец, check_warnings() сбрасывает фильтры предупреждений модуля warning и возвращает объект, который будет записывать все вызванные предупреждения (bpo-3781):

  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 теперь может сохранять существующие пробельные символы в начале и конце вновь создаваемых строк, указывая drop_whitespace=False в качестве аргумента:

  >>> 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.)

• API модуля threading изменяется, чтобы использовать свойства, такие как daemon, вместо методов setDaemon() и isDaemon(), а некоторые методы были переименованы для использования подчёркиваний вместо верблюжьего регистра; например, метод activeCount() переименован в active_count(). Версии модуля 2.6 и 3.0 поддерживают одинаковые свойства и переименованные методы, но не удаляйте старые методы. Дата устаревания старых API в Python 3.x не установлена; старые API не будут удалены ни в одной версии 2.x. (Выполнено несколькими людьми, в первую очередь Бенджамином Петерсоном.)

  Объекты Thread модуля threading получили свойство ident, которое возвращает идентификатор потока – ненулевое целое число. (Автор: Gregory P. Smith; bpo-2871.)

• Модуль timeit теперь принимает как строки, так и вызываемые объекты для измеряемого оператора и для кода настройки. Были добавлены две вспомогательные функции для создания экземпляров Timer: repeat(stmt, setup, time, repeat, number) и timeit(stmt, setup, time, number) создают экземпляр и вызывают соответствующий метод. (Автор: Erik Demaine; bpo-1533909.)

• Модуль Tkinter теперь принимает списки и кортежи для параметров, разделяя элементы пробелами перед передачей результирующего значения в Tcl/Tk. (Автор: Guilherme Polo; bpo-2906.)

• Модуль turtle для черепашьей графики был значительно улучшен Gregor Lingl. Новые возможности модуля включают:

  • Улучшенная анимация движения и поворота черепахи.

  • Управление движением черепахи с помощью новых методов delay(), tracer() и speed().

  • Возможность задавать новые формы для черепахи и определять новую систему координат.

  • У черепах теперь есть метод undo(), который может откатывать действия.

  • Простая поддержка реакции на события ввода, такие как активность мыши и клавиатуры, что позволяет писать простые игры.

  • Файл turtle.cfg можно использовать для настройки начального вида экрана черепахи.

  • Докстринги модуля могут быть заменены новыми докстрингами, переведёнными на другой язык.

  (bpo-1513695)

• Необязательный параметр timeout был добавлен в функцию urllib.urlopen(), конструктор класса urllib.ftpwrapper, а также в функцию urllib2.urlopen(). Параметр задаёт тайм-аут в секундах. Например:

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

  (Добавлено Facundo Batista.)

• База данных Unicode, предоставляемая модулем unicodedata, обновлена до версии 5.1.0. (Обновлено Martin von Loewis; bpo-3811.)

• Методы formatwarning() и showwarning() модуля warnings получили необязательный аргумент line, который можно использовать для указания строки исходного кода. (Добавлено в рамках bpo-1631171, который переписал часть модуля warnings на C.)

  Новая функция catch_warnings() – это контекстный менеджер, предназначенный для тестирования, который позволяет временно изменять фильтры предупреждений, а затем восстанавливать их исходные значения (bpo-3781).

• Классы SimpleXMLRPCServer и DocXMLRPCServer XML-RPC теперь можно настроить так, чтобы они не открывали и не привязывали свой сокет немедленно, передав False в качестве параметра bind_and_activate конструктора. Это можно использовать для изменения атрибута allow_reuse_address экземпляра перед вызовом методов server_bind() и server_activate(), чтобы открыть сокет и начать прослушивание соединений. (Предложено Питером Паренте; bpo-1599845.)

  SimpleXMLRPCServer также имеет атрибут _send_traceback_header; если он равен true, исключение и форматированная трассировка возвращаются в виде HTTP-заголовков «X-Exception» и «X-Traceback». Эта функция предназначена только для отладки и не должна использоваться на производственных серверах, поскольку трассировки могут раскрыть пароли или другую конфиденциальную информацию. (Предложено Аланом Макинтайром в рамках его проекта для Google Summer of Code 2007.)

• Модуль xmlrpclib больше не преобразует автоматически datetime.date и datetime.time в тип xmlrpclib.DateTime; семантика преобразования не обязательно была корректной для всех приложений. Код, использующий xmlrpclib, должен преобразовывать экземпляры date и time. (bpo-1330538) Код также может обрабатывать даты до 1900 года (предложено Ральфом Шмиттом; bpo-2014) и 64-битные целые числа, представленные с помощью <i8> в ответах XML-RPC (предложено Рику Линдбладом; bpo-2985).

• Класс ZipFile модуля zipfile теперь имеет методы extract() и extractall(), которые распаковывают один файл или все файлы из архива в текущий каталог или в указанный каталог:

  z = zipfile.ZipFile('python-251.zip')
  
  # Распаковать один файл, записывая его относительно
  # в каталог /tmp.
  z.extract('Python/sysmodule.c', '/tmp')
  
  # Распаковать все файлы из архива.
  z.extractall()
  

  (Предложено Аланом Макинтайром; bpo-467924.)

  Методы open(), read() и extract() теперь могут принимать либо имя файла, либо объект ZipInfo. Это полезно, когда архив случайно содержит дублированное имя файла. (Предложено Грэмом Хорлером; bpo-1775025.)

  Наконец, zipfile теперь поддерживает использование имён файлов в Unicode для архивных файлов. (Предложено Алексеем Борзенковым; bpo-1734346.)

import ast

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

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 = '("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

>>> 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}

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)

Устаревания и удаления¶Deprecations and Removals

• Строковые исключения были удалены. Попытка их использования возбуждает TypeError.

• Изменения интерфейса Exception, продиктованные PEP 352, продолжают вноситься. В версии 2.6 атрибут message объявлен устаревшим в пользу атрибута args.

• (Режим предупреждений о 3.0) В Python 3.0 будет реорганизована стандартная библиотека: многие устаревшие модули будут удалены, а другие переименованы. Python 2.6, запущенный в режиме предупреждений о 3.0, будет выдавать предупреждения об этих модулях при их импорте.

  Список устаревших модулей: audiodev, bgenlocations, buildtools, bundlebuilder, Canvas, compiler, dircache, dl, fpformat, gensuitemodule, ihooks, imageop, imgfile, linuxaudiodev, mhlib, mimetools, multifile, new, pure, statvfs, sunaudiodev, test.testall и toaiff.

• Модуль gopherlib удалён.

• Модули MimeWriter и mimify объявлены устаревшими; вместо них используйте пакет email.

• Модуль md5 объявлен устаревшим; используйте вместо него модуль hashlib.

• Модуль posixfile объявлен устаревшим; fcntl.lockf() предоставляет более надёжные блокировки.

• Модуль popen2 объявлен устаревшим; используйте модуль subprocess.

• Модуль rgbimg удалён.

• Модуль sets объявлен устаревшим; лучше использовать встроенные типы set и frozenset.

• Модуль sha объявлен устаревшим; используйте вместо него модуль hashlib.

Изменения в сборке и C API¶Build and C API Changes

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

• Теперь Python должен компилироваться компиляторами C89 (спустя 19 лет!). Это означает, что в исходном коде Python удалены собственные реализации memmove() и strerror(), которые входят в стандартную библиотеку C89.

• Python 2.6 можно собрать с помощью Microsoft Visual Studio 2008 (версия 9.0), и это новый компилятор по умолчанию. Смотрите каталог PCbuild для файлов сборки. (Реализовано Кристианом Хаймсом.)

• На Mac OS X Python 2.6 может быть скомпилирован как универсальная сборка для четырёх архитектур. Скрипт configure может принимать ключ --with-universal-archs=[32-bit|64-bit|all], определяющий, будут ли двоичные файлы собраны для 32-битных архитектур (x86, PowerPC), 64-битных (x86-64 и PPC-64) или для обеих. (Предложено Рональдом Уссореном.)

• Модуль BerkeleyDB теперь имеет объект C API, доступный как bsddb.db.api. Этот объект может использоваться другими расширениями C, которые хотят использовать модуль bsddb для своих целей. (Предложено Данканом Грисби.)

• Новый интерфейс буфера, ранее описанный в разделе PEP 3118, добавляет функции PyObject_GetBuffer() и PyBuffer_Release(), а также несколько других.

• Использование Python библиотеки C stdio теперь потокобезопасно, или, по крайней мере, настолько потокобезопасно, насколько им является сама нижележащая библиотека. Долгое время существовала потенциальная ошибка, когда один поток закрывал файловый объект, в то время как другой поток читал из него или писал в него. В Python 2.6 файловые объекты имеют счетчик ссылок, управляемый функциями PyFile_IncUseCount() и PyFile_DecUseCount(). Файловый объект нельзя закрыть, пока счетчик ссылок не равен нулю. PyFile_IncUseCount() должна вызываться, пока GIL еще удерживается, перед выполнением операции ввода-вывода с использованием указателя FILE *, а PyFile_DecUseCount() должна вызываться сразу после повторного захвата GIL. (Авторы: Антуан Питу и Грегори П. Смит.)

• Одновременный импорт модулей в двух разных потоках больше не приводит к взаимоблокировке; теперь вместо этого возбуждается ImportError. Новая функция API, PyImport_ImportModuleNoBlock(), сначала ищет модуль в sys.modules, а затем пытается импортировать его после захвата блокировки импорта. Если блокировка импорта удерживается другим потоком, возбуждается ImportError. (Автор: Кристиан Хаймс.)

• Несколько функций возвращают информацию о поддержке чисел с плавающей запятой платформой. PyFloat_GetMax() возвращает максимальное представимое значение с плавающей запятой, а PyFloat_GetMin() возвращает минимальное положительное значение. PyFloat_GetInfo() возвращает объект, содержащий дополнительную информацию из файла float.h, такую как "mant_dig" (количество цифр в мантиссе), "epsilon" (наименьшая разница между 1.0 и следующим большим представимым значением) и несколько других. (Вклад Кристиана Хаймса; bpo-1534.)

• C-функции и методы, использующие PyComplex_AsCComplex(), теперь принимают аргументы, у которых есть метод __complex__(). В частности, функции в модуле cmath теперь принимают объекты с этим методом. Это обратный порт изменения из Python 3.0. (Автор: Марк Дикинсон; bpo-1675423.)

• C API Python теперь включает две функции для сравнения строк без учета регистра: PyOS_stricmp(char*, char*) и PyOS_strnicmp(char*, char*, Py_ssize_t). (Автор: Кристиан Хаймс; bpo-1635.)

• Многие C-расширения определяют собственные макросы для добавления целых чисел и строк в словарь модуля в функции init*. Python 2.6 наконец-то определяет стандартные макросы для добавления значений в модуль: 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)

• Distutils теперь размещает создаваемые C-расширения в другом каталоге при работе с отладочной версией Python. (Автор: Коллин Уинтер; bpo-1530959.)

• Некоторые базовые типы данных, такие как целые числа и строки, ведут внутренние списки свободных объектов, которые можно повторно использовать. Структуры данных для этих списков теперь следуют соглашению об именовании: переменная всегда называется free_list, счетчик всегда называется numfree, и всегда определяется макрос Py<typename>_MAXFREELIST.

• Новая цель Makefile, «make patchcheck», подготавливает дерево исходных текстов Python для создания патча: она исправляет завершающие пробелы во всех измененных файлах .py, проверяет, была ли изменена документация, и сообщает, были ли обновлены файлы Misc/ACKS и Misc/NEWS. (Автор: Бретт Кэннон.)

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

Перенос на Python 2.6¶Porting to Python 2.6

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

• Классы, которые не должны быть хешируемыми, должны установить __hash__ = None в своих определениях, чтобы указать на это.

• Строковые исключения были удалены. Попытка их использования возбуждает TypeError.

• Метод __init__() объекта collections.deque теперь очищает существующее содержимое deque перед добавлением элементов из итерируемого объекта. Это изменение приводит поведение в соответствие с list.__init__().

• object.__init__() ранее принимал произвольные позиционные и именованные аргументы, игнорируя их. В Python 2.6 это больше не допускается и приведет к TypeError. Это затронет методы __init__(), которые в итоге вызывают соответствующий метод на object (возможно, через использование super()). См. обсуждение в bpo-1683368.

• Конструктор Decimal теперь допускает начальные и конечные пробелы при передаче строки. Ранее он вызывал исключение InvalidOperation. С другой стороны, метод create_decimal() объектов Context теперь явно запрещает лишние пробелы, вызывая исключение ConversionSyntax.

• Из-за случайности реализации, если передать путь к файлу встроенной функции __import__(), она фактически импортировала указанный файл. Однако это никогда не должно было работать, и теперь реализация явно проверяет этот случай и вызывает ImportError.

• C API: функции PyImport_Import() и PyImport_ImportModule() теперь по умолчанию используют абсолютный импорт, а не относительный. Это повлияет на расширения на C, которые импортируют другие модули.

• C API: типы данных расширений, которые не должны быть хэшируемыми, должны определить свой слот tp_hash как PyObject_HashNotImplemented().

• Исключение socket.error модуля socket теперь наследуется от IOError. Ранее оно не было подклассом StandardError, но теперь стало, через IOError. (Реализовано Грегори П. Смитом; bpo-1706815.)

• Модуль xmlrpclib больше не преобразует автоматически datetime.date и datetime.time в тип xmlrpclib.DateTime; семантика преобразования не обязательно была корректна для всех приложений. Код, использующий xmlrpclib, должен преобразовывать экземпляры date и time. (bpo-1330538)

• (режим предупреждения 3.0) Класс Exception теперь выдаёт предупреждение при доступе через срез или по индексу; возможность Exception вести себя как кортеж постепенно упраздняется.

• (режим предупреждения 3.0) Сравнения на неравенство между двумя словарями или двумя объектами, которые не реализуют методы сравнения, сообщаются как предупреждения. dict1 == dict2 всё ещё работает, но dict1 < dict2 постепенно упраздняется.

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

Благодарности¶Acknowledgements

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