Что нового в 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 теперь всегда является ключевым словом. Остальная часть раздела представляет собой копию соответствующего раздела из документа «Что нового в Python 2.5»; если вы знакомы с оператором ‘with‘ из Python 2.5, этот раздел можно пропустить.

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

Оператор ‘with‘ – это управляющая конструкция, имеющая следующую базовую структуру:

with expression [as variable]:
    with-block

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

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

После завершения выполнения блока 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

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

Два других класса, 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 становится функцией print() в Python 3.0. Превращение 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 в Python 2.6 будет заключаться в написании проверок типа объекта, таких как isinstance(x, bytes). Это поможет конвертеру 2to3, который не может определить, предполагается ли в коде 2.x, что строки содержат символы или 8-битные байты; теперь можно использовать либо bytes, либо str, чтобы точно выразить своё намерение, и полученный код также будет корректен в Python 3.0.

Существует также импорт __future__, который приводит к тому, что все строковые литералы становятся строками Unicode. Это означает, что управляющие последовательности \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. Этот модуль предоставляется, чтобы упростить написание кода, совместимого с Python 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.

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

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

Можно наследовать свои классы от конкретной 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. Эти классы были перенесены в Python 2.6 как модуль numbers.

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

Complex является подклассом Number. Комплексные числа поддерживают основные операции сложения, вычитания, умножения, деления и возведения в степень, а также позволяют получить действительную и мнимую части и сопряжённое число. Встроенный комплексный тип 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. (Предложение и начальный патч от Энди Чу (Andy Chu), затем доработано Филлипом Дж. Иби (Phillip J. Eby) и Ником Когланом (Nick Coghlan); issue 1739468.)

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

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

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

  (Автор: Александр Белопольский (Alexander Belopolsky); issue 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}
  

  Раньше это приводило бы к синтаксической ошибке. (Автор: Амори Форжо д’Арк (Amaury Forgeot d’Arc); issue 3473.)

• Новая встроенная функция next(iterator, [default]) возвращает следующий элемент из указанного итератора. Если передан аргумент default, он будет возвращён, когда iterator исчерпан; в противном случае будет возбуждено исключение StopIteration. (Перенесено в issue 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). Раньше поддержка была частичной, и некоторые граничные случаи не работали. (Реализовано Томасом Воутерсом (Thomas Wouters).)

• Свойства теперь имеют три атрибута: 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 в значение IEEE 754 Not A Number, а +inf и -inf – в положительную или отрицательную бесконечность. Это работает на любой платформе с семантикой IEEE 754. (Предложено Кристианом Хаймсом; issue 1635.)

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

  Были добавлены функции преобразования чисел с плавающей запятой в шестнадцатеричные строки (issue 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() теперь сохраняет знак нуля. (Исправлено Марком Т. Дикинсоном; issue 1507.)

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

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

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

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

• Встроенная функция compile() теперь принимает именованные аргументы, а также позиционные параметры. (Предложено Томасом Воутерсом; issue 1444529.)

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

• Метод строки translate() теперь принимает None в качестве параметра таблицы перевода, который рассматривается как тождественное преобразование. Это упрощает выполнение операций, которые только удаляют символы. (Предложено Бенгтом Рихтером и реализовано Рэймондом Хеттингером; issue 1193128.)

• Встроенная функция dir() теперь проверяет наличие метода __dir__() у получаемых объектов. Этот метод должен возвращать список строк, содержащих имена допустимых атрибутов объекта, и позволяет объекту контролировать значение, которое возвращает dir(). Объекты, имеющие методы __getattr__() или __getattribute__(), могут использовать это для рекламирования псевдоатрибутов, которые они будут поддерживать. (issue 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 снова активно поддерживаются, и было применено несколько патчей и исправлений ошибок. (Поддерживается Джозией Карлсоном; см. issue 1736190 для одного патча.)

• Модуль bsddb также получил нового сопровождающего, Хесуса Сеа Авиона, и теперь пакет доступен как автономный. Веб-страница пакета: www.jcea.es/programacion/pybsddb.htm. Планируется удалить пакет из стандартной библиотеки в Python 3.0, поскольку частота его выпусков намного выше, чем у Python.

  Модуль bsddb.dbshelve теперь использует самый высокий доступный протокол сериализации вместо того, чтобы ограничиваться протоколом 1. (Предложено У. Барнсом.)

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

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

• Модуль cmath подвергся значительной доработке, предложенной Марком Дикинсоном и Кристианом Хаймсом. Было добавлено пять новых функций:

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

  Ревизии также улучшили числовую надёжность модуля cmath. Для всех функций вещественная и мнимая части результатов точны до нескольких единиц последнего разряда (ulps), когда это возможно. Подробности см. в issue 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; issue 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; issue 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; issue 1221598.)

• Встроенная функция reduce() также доступна в модуле functools. В Python 3.0 эта встроенная функция была удалена, и reduce() доступна только из functools; в настоящее время планов удалять её из серии 2.x нет. (Исправление: Christian Heimes; issue 1739906.)

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

• Функция glob.glob() теперь может возвращать имена файлов в Unicode, если использовался путь в Unicode и в каталоге есть соответствующие имена в Unicode. (issue 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 из элементов iterable.

  >>> 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 равен true, открытие файла журнала откладывается до первого вызова emit(). (Автор: Vinay Sajip.)

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

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

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

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

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

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

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

• Модуль 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) изменяет режим символической ссылки. (Авторы: Georg Brandl и Christian Heimes.)

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

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

• Метод clear() объекта os.environ теперь будет не только очищать ключи объекта, но и сбрасывать переменные окружения с помощью os.unsetenv(). (Автор: Martin Horcicka; issue 1181.)

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

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

  Новая функция os.path.relpath(path, start='.') возвращает относительный путь от пути start (если он указан) или от текущего рабочего каталога к целевому пути path. (Автор: Richard Barran; issue 1339796.)

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

• Отладчик Python, предоставляемый модулем pdb, получил новую команду: «run» перезапускает отлаживаемую программу Python и может опционально принимать новые аргументы командной строки для программы. (Автор: Rocky Bernstein; issue 1393667.)

• Функция pdb.post_mortem(), используемая для начала отладки по трассировке, теперь будет использовать трассировку, возвращаемую sys.exc_info(), если трассировка не указана. (Автор: Facundo Batista; issue 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; issue 2439.)

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

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

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

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

• Длительные поиски по регулярному выражению, выполняемые модулем re будут проверять доставку сигналов, поэтому продолжительные поиски теперь можно прерывать. (Предложено Джошем Хойтом и Ральфом Шмиттом; issue 846388.)

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

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

• В модуле sched экземпляры scheduler теперь имеют доступный только для чтения атрибут queue, который возвращает содержимое очереди планировщика, представленное в виде списка именованных кортежей с полями (time, priority, action, argument). (Предложено Раймондом Хеттингером; issue 1861.)

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

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

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

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

  (Предложено Тареком Зиаде; issue 2663.)

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

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

  (Предложено Адамом Олсеном; issue 1583.)

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

  Функции setitimer() и getitimer() также были добавлены (там, где они доступны). setitimer() позволяет устанавливать интервальные таймеры, которые вызовут отправку сигнала процессу по истечении заданного времени, измеряемого в реальном времени, затраченном процессорном времени или суммарном времени процесса и системы. (Предложено Гильерме Поло; issue 2240.)

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

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

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

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

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

• Базовые классы модуля SocketServer теперь поддерживают вызов метода handle_timeout() после периода бездействия, заданного атрибутом сервера timeout. (Предложено Майклом Помранингом.) Метод serve_forever() теперь принимает необязательный интервал опроса, измеряемый в секундах, определяющий, как часто сервер будет проверять запрос на завершение работы. (Предложено Педро Вернеком и Джеффри Яскиным; issue 742598, issue 1193577.)

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

• Модуль struct теперь поддерживает тип C99 _Bool, с использованием символа формата '?'. (Предложено Дэвидом Ремалем.)

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

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

  Another new variable, dont_write_bytecode, controls whether Python writes any .pyc or .pyo files on importing a module. If this variable is true, the compiled files are not written. The variable is initially set on start-up by supplying the -B switch to the Python interpreter, or by setting the PYTHONDONTWRITEBYTECODE environment variable before running the interpreter. Python code can subsequently change the value of this variable to control whether bytecode files are written or not. (Contributed by Neal Norwitz and Georg Brandl.)

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

  Новая функция getsizeof() принимает объект Python и возвращает объём памяти, используемый объектом, измеряемый в байтах. Встроенные объекты возвращают корректные результаты; сторонние расширения могут этого не делать, но могут определить метод __sizeof__() для возврата размера объекта. (Предложено Робертом Шуппенисом; issue 2898.)

  Теперь можно определить текущие функции профилировщика и трассировщика, вызвав sys.getprofile() и sys.gettrace(). (Предложено Георгом Брандлем; issue 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 поддерживает имена файлов в Юникоде, по умолчанию используется кодировка UTF-8.)

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

  (Все изменения выполнены Lars Gustäbel.)

• Необязательный параметр timeout был добавлен в конструктор класса telnetlib.Telnet, задающий тайм-аут в секундах. (Добавлено Факундо Батистой.)

• Класс tempfile.NamedTemporaryFile обычно удаляет созданный временный файл при закрытии. Теперь это поведение можно изменить, передав delete=False конструктору. (Предложено Дэмиеном Миллером; issue 1537850.)

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

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

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

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

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

  Наконец, check_warnings() сбрасывает фильтры предупреждений модуля warning и возвращает объект, который будет записывать все возникающие предупреждения (issue 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; issue 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; issue 2871.)

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

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

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

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

  (issue 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 Löwis; issue 3811.)

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

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

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

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

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

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

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

  (Автор: Alan McIntyre; issue 467924.)

  Методы open(), read() и extract() теперь могут принимать как имя файла, так и объект ZipInfo. Это полезно, если архив случайно содержит дублирующееся имя файла. (Автор: Graham Horler; issue 1775025.)

  Наконец, zipfile теперь поддерживает имена файлов в Unicode для архивов. (Автор: Alexey Borzenkov; issue 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.

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

• Модуль 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 и следующим большим представимым значением) и несколько других. (Предложено Кристианом Хаймсом; issue 1534.)

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

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

• Многие расширения на C определяют собственные небольшие макросы для добавления целых чисел и строк в словарь модуля в функции init*. Python 2.6 наконец определяет стандартные макросы для добавления значений в модуль: PyModule_AddStringMacro и PyModule_AddIntMacro(). (Предложено Кристианом Хаймсом.)

• Некоторые макросы были переименованы как в Python 3.0, так и в 2.6, чтобы яснее показать, что это макросы, а не функции. Py_Size() стал Py_SIZE(), Py_Type() стал Py_TYPE(), а Py_Refcnt() стал Py_REFCNT(). Макросы со смешанным регистром по-прежнему доступны в Python 2.6 для обратной совместимости. (issue 1629)

• Distutils теперь помещает расширения на C, которые он собирает, в другой каталог при работе с отладочной версией Python. (Предложено Коллином Уинтером; issue 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()). См. обсуждение в issue 1683368.

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

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

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

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

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

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

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

• (Режим предупреждений для версии 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.