Что нового в 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.

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

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

PEP 343: Утверждение «with»¶

Предыдущая версия, 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-block и, следовательно, может запускать установочный код. Он также может возвращать значение, привязанное к имени переменной, если оно задано. (Внимательно обратите внимание, что переменной не присваивается результат выражения.)

После завершения выполнения with-block вызывается метод объекта __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:
    # Critical section of code
    ...

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

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

from decimal import Decimal, Context, localcontext

# Displays with default precision of 28 digits
v = Decimal('578')
print v.sqrt()

with localcontext(Context(prec=16)):
    # All code in this block uses a precision of 16 digits.
    # The original context is restored on exiting the block.
    print v.sqrt()

db_connection = DatabaseConnection()
with db_connection as cursor:
    cursor.execute('insert into ...')
    cursor.execute('delete from ...')
    # ... more operations ...

class DatabaseConnection:
    # Database interface
    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):
        # Code to start a new transaction
        cursor = self.cursor()
        return cursor

class DatabaseConnection:
    ...
    def __exit__(self, type, value, tb):
        if tb is None:
            # No exception, so commit
            self.commit()
        else:
            # Exception occurred, so rollback.
            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: Явный относительный импорт из основного Модуля¶

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

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

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

PEP 370: Каталог для каждого пользователя site-packages¶

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

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

• Unix и Mac OS X: ~/.local/

• Окна: %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¶

Новый пакет 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."
    # If N is a multiple of 4, this function will take much longer.
    if (N % 4) == 0:
        time.sleep(.05 * N/4)

    # Calculate the result
    fact = 1L
    for i in range(1, N+1):
        fact = fact * i

    # Put the result on the queue
    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."
    # Calculate the result
    fact = 1L
    for i in range(1, N+1):
        fact = fact * i

    # Store result in dictionary
    dictionary[N] = fact

if __name__ == '__main__':
    p = Pool(5)
    mgr = Manager()
    d = mgr.dict()         # Create shared dictionary

    # Run tasks using the pool
    for N in range(1, 1000, 10):
        p.apply_async(factorial, (N, d))

    # Mark pool as closed -- no more tasks can be added.
    p.close()

    # Wait for tasks to exit
    p.join()

    # Output results
    for k, v in sorted(d.items()):
        print k, v

Это приведет к получению результата:

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

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

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

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

>>> # Substitute positional argument 0 into the string.
>>> "User ID: {0}".format("root")
'User ID: root'
>>> # Use the named keyword arguments
>>> "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 в качестве ключа. Строки, начинающиеся с числа, будут преобразованы в целое число. Вы не можете написать более сложные выражения внутри форматной строки.

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

>>> # Field 0: left justify, pad to 15 characters
>>> # Field 1: right justify, pad to 6 characters
>>> 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'

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

Классы и типы могут определять метод __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 Как функция¶

Оператор 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: конечный текст, который будет напечатан после того, как будут выведены все аргументы.

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

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

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

try:
    ...
except TypeError, ValueError:  # Wrong!
    ...

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

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

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

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

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

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

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

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

Тип 2.6 str отличается от типа 3.0 bytes различными способами; наиболее заметно, что конструктор полностью отличается. В версии 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__, который преобразует все строковые литералы в строки Юникода. Это означает, что для включения символов Юникода можно использовать управляющие последовательности \u:

from __future__ import unicode_literals

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

print len(s)               # 12 Unicode characters

На уровне 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: Новая библиотека ввода-вывода¶

Встроенные файловые объекты 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 объекты file и socket не были реструктурированы таким образом.

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

  Существует пять конкретных классов, реализующих эту азбуку. BufferedWriter и BufferedReader предназначены для объектов, которые поддерживают использование только для записи или только для чтения и имеют seek() метод произвольного доступа. BufferedRandom объекты поддерживают доступ для чтения и записи к одному и тому же базовому потоку, а BufferedRWPair - для таких объектов, как TTYs, которые выполняют операции как чтения, так и записи, воздействуя на несвязанные потоки данных. Класс BytesIO поддерживает чтение, запись и поиск по буферу в памяти.

• TextIOBase: Предоставляет функции для чтения и записи строк (помните, что в Python 3.0 строки будут иметь кодировку Unicode) и поддерживает universal newlines. TextIOBase определяет метод readline() и поддерживает итерацию по объектам.

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

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

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

PEP 3118: Пересмотренный протокол буферизации¶

Протокол buffer - это API уровня C, который позволяет типам Python обмениваться указателями в своих внутренних представлениях. Например, файл, отображенный в памяти, можно рассматривать как буфер символов, и это позволяет другому модулю, такому как re, обрабатывать файлы, отображенные в памяти, как строку символов для поиска.

Основными пользователями протокола buffer являются пакеты числовой обработки, такие как NumPy, которые предоставляют внутреннее представление массивов, чтобы вызывающие пользователи могли записывать данные непосредственно в массив, а не использовать более медленный API. Этот PEP обновляет протокол buffer в свете опыта разработки 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: Абстрактные базовые классы¶

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

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

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

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

import collections

class Storage(collections.MutableMapping):
    ...

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

import collections

class Storage:
    ...

collections.MutableMapping.register(Storage)

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

# Register Python's types
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.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):
        ...

В Drawable ABC, приведенном выше, метод 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: Поддержка целочисленных литералов и синтаксис¶

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

В Python 2.6 не отменена поддержка начального 0, обозначающего восьмеричное число, но добавлена поддержка «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», когда запрашивается значение base-8 или base-2, или когда аргумент base равен нулю (сигнализируя о том, что используемая база должна определяться из строка):

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

PEP 3129: Классные декораторы¶

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

@foo
@bar
class A:
  pass

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

class A:
  pass

A = foo(bar(A))

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

В Python 3.0 добавлено несколько абстрактных базовых классов для числовых типов, вдохновленных numeric tower от Scheme. Эти классы были перенесены в версию 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)

Другие языковые изменения¶

Вот некоторые небольшие изменения, внесенные в основной язык 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, он будет возвращен, если итератор исчерпан; в противном случае будет вызвано исключение StopIteration. (Бэкпортирован в bpo-2719.)

• У кортежей теперь есть методы index() и count(), соответствующие методам типа list 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
  

• Несколько методов встроенных типов set теперь принимают несколько итераций: intersection(), intersection_update(), union(), update(), difference() и difference_update().

  >>> s=set('1234567890')
  >>> s.intersection('abc123', 'cdf246')  # Intersection between all inputs
  set(['2'])
  >>> s.difference('246', '789')
  set(['1', '0', '3', '5'])
  

  (Автор - Раймонд Хеттингер.)

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

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

  Были добавлены функции преобразования чисел с плавающей запятой в шестнадцатеричные строки (bpo-3008). Эти функции преобразуют числа с плавающей запятой в строковое представление и обратно без ошибок округления при преобразовании из десятичного в двоичный формат. У Floats есть метод 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 ABC.

  Это следует делать, когда вы определили метод __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() теперь принимает аргументы из ключевых слов, а также позиционные параметры. (Автор Томас Ваутерс; bpo-1444529.)

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

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

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

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

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

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

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

• Модули asyncore и asynchat снова активно поддерживаются, и был добавлен ряд исправлений. (Поддерживается Джосайей Карлсоном; об одном исправлении смотрите в bpo-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». (Авторы - Александр Фиори и Нубис; bpo-1817.)

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

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

  • 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')
  >>> # Names are separated by spaces or commas.
  >>> # 'id, name, type, size' would also work.
  >>> var_type._fields
  ('id', 'name', 'type', 'size')
  
  >>> var = var_type(1, 'frequency', 'int', 4)
  >>> print var[0], var.id    # Equivalent
  1 1
  >>> print var[2], var.type  # Equivalent
  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.

  (Автор - Раймонд Хеттингер.)

• Еще одно изменение в модуле collections заключается в том, что тип deque теперь поддерживает необязательный параметр maxlen; если он указан, размер deque будет ограничен не более чем 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)
  

  (Автор - Раймонд Хеттингер.)

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

• Новый оконный метод в модуле curses, chgat(), изменяет атрибуты отображения для определенного количества символов в одной строке. (Автор - Фабиан Крейц).

  # Boldface text starting at y=0,x=21
  # and affecting the rest of the line.
  stdscr.chgat(0, 21, curses.A_BOLD)
  

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

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

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

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

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

  (Реализовано Факундо Батистой и Марком Дикинсоном. Поддержка именованных кортежей добавлена Раймондом Хеттингером.)

• Класс difflib модуля SequenceMatcher теперь возвращает именованные кортежи, представляющие совпадения, с атрибутами a, b, и size. (Автор - Раймонд Хеттингер.)

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

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

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

• Функция 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), помещает элемент в кучу, затем извлекает и возвращает наименьший элемент. Это более эффективно, чем вызывать heappush(), а затем heappop().

  heapq теперь реализован для использования только сравнения «меньше, чем», вместо сравнения «меньше, чем» или «равно», которое использовалось ранее. Таким образом, использование типа heapq соответствует методу list.sort(). (Автор - Раймонд Хеттингер.)

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

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

  Некоторые новые функции в модуле включают в себя 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 элементов iterable. Если значение r не указано, то по умолчанию будет использоваться количество элементов, создаваемых iterable.

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

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

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

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

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

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

  • 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’s type hierarchy for numbers.

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

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

  (Авторы: Кристиан Хеймс и Марк Дикинсон.)

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

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

  >>> # Equivalent to 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.)

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

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

• В модуле os.path функция splitext() была изменена таким образом, чтобы она не разделялась на начальные символы точки. Это дает лучшие результаты при работе с точечными файлами Unix. Например, 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 и при необходимости может принимать новые аргументы командной строки для программы. (Автор: Rocky Bernstein; bpo-1393667.)

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

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

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

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

  (Автор: Пол Мур; bpo-2439.)

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

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

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

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

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

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

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

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

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

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

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

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

  (Автор: Тарек Зиаде; bpo-2663.)

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

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

  (Автор: Адам Олсен; bpo-1583.)

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

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

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

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

  SMTP.starttls() теперь соответствует требованиям RFC 3207 и забывает все данные, полученные с сервера, кроме данных, полученных в результате согласования TLS. (Исправление внесено Биллом Феннером; bpo-829951.)

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

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

• Базовые классы в модуле SocketServer теперь поддерживают вызов метода handle_timeout() после периода бездействия, указанного в атрибуте сервера timeout. (Автор - Майкл Помрейнинг). Метод serve_forever() теперь использует необязательный интервал опроса, измеряемый в секундах, определяя, как часто сервер будет проверять наличие запроса на завершение работы. (Авторы: Педро Вернек и Джеффри Ясскин; bpo-742598, bpo-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 и следующим по величине представимым значением) и несколько других. (Автор: Кристиан Хеймс; bpo-1534.)

  Другая новая переменная, dont_write_bytecode, определяет, записывает ли Python какие-либо файлы .pyc или .pyo при импорте модуля. Если значение этой переменной равно true, скомпилированные файлы не записываются. Переменная изначально устанавливается при запуске путем установки параметра -B в интерпретаторе Python или путем установки переменной окружения PYTHONDONTWRITEBYTECODE перед запуском интерпретатора. Код на Python может впоследствии изменять значение этой переменной, чтобы контролировать, записываются ли файлы с байт-кодом или нет. (Авторы - Нил Норвиц и Георг Брандл.)

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

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

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

• Модуль tarfile теперь поддерживает файлы POSIX.1-2001 (pax) tar в дополнение к форматам 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(), так и к именам файлов в рекурсивно добавляемых каталогах.

  (Все изменения внесены Ларсом Густабелем).

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

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

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

  Классы NamedTemporaryFile и SpooledTemporaryFile работают как контекстные менеджеры, поэтому вы можете написать with tempfile.NamedTemporaryFile() as tmp: .... (Автор - Александр Белопольский; 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")
      # ... code that triggers a warning ...
      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.
  >>>
  

  (Автор: Дуэйн Бейли; bpo-1581073.)

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

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

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

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

• Грегор Лингл значительно усовершенствовал модуль turtle для turtle graphics. В модуле добавлены следующие новые функции:

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

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

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

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

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

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

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

  (bpo-1513695)

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

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

  (Добавлено Факундо Батистой.)

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

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

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

• Классам XML-RPC SimpleXMLRPCServer и DocXMLRPCServer теперь можно запретить немедленное открытие и привязку к их сокету, передав 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')
  
  # Unpack a single file, writing it relative
  # to the /tmp directory.
  z.extract('Python/sysmodule.c', '/tmp')
  
  # Unpack all the files in the archive.
  z.extractall()
  

  (Автор: Алан Макинтайр; bpo-467924.)

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

  Наконец, zipfile теперь поддерживает использование имен файлов в Юникоде для архивированных файлов. (Автор: Алексей Борзенков; 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) # Encode the data
>>> in_json
'{"parrot": 42, "spam": "foo"}'
>>> json.loads(in_json) # Decode into a Python object
{"spam": "foo", "parrot": 42}

import sys
import plistlib
import datetime

# Create data structure
data_struct = dict(lastAccessed=datetime.datetime.now(),
                   version=1,
                   categories=('Personal','Shared','Private'))

# Create string containing XML.
plist_str = plistlib.writePlistToString(data_struct)
new_struct = plistlib.readPlistFromString(plist_str)
print data_struct
print new_struct

# Write data structure to a file and read it back.
plistlib.writePlist(data_struct, '/tmp/customizations.plist')
new_struct = plistlib.readPlist('/tmp/customizations.plist')

# read/writePlist accepts file-like objects as well as paths.
plistlib.writePlist(data_struct, sys.stdout)

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

• Строковые исключения были удалены. При попытке их использования возникает ошибка 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¶

Изменения в процессе сборки 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) или для обеих. (Автор: Рональд Оуссорен.)

• Новая функция, добавленная в Python 2.6.6, PySys_SetArgvEx(), устанавливает значение sys.argv и может дополнительно обновлять sys.path, чтобы включить каталог, содержащий скрипт с именем sys.argv[0] в зависимости от значения параметра updatepath.

  Эта функция была добавлена, чтобы закрыть брешь в безопасности приложений, использующих Python. Старая функция, PySys_SetArgv(), всегда обновляла sys.path, а иногда добавляла текущий каталог. Это означало, что если вы запустите приложение, использующее Python, в каталоге, контролируемом кем-то другим, злоумышленники могут поместить в этот каталог троянский модуль (скажем, файл с именем os.py), который ваше приложение затем импортирует и запустит.

  Если вы поддерживаете приложение на C/C++, в которое встроен Python, проверьте, вызываете ли вы PySys_SetArgv() и тщательно подумайте, должно ли приложение использовать PySys_SetArgvEx() с updatepath, установленным в значение false. Обратите внимание, что использование этой функции нарушит совместимость с версиями Python 2.6.5 и более ранними версиями; если вам нужно продолжить работу с более ранними версиями, вы можете оставить вызов PySys_SetArgv() в покое и вызвать PyRun_SimpleString("sys.path.pop(0)\n") после этого, чтобы отменить первый sys.path компонент.

  Проблема безопасности, о которой сообщалось как о CVE-2008-5983; обсуждалась в gh-50003 и была исправлена Антуаном Питру.

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

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

• Использование библиотеки 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.)

• Функции и методы языка Си, использующие 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 наконец-то определены стандартные макросы для добавления значений в модуль:c:macro: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. (Автор: Collin Winter; 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¶

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

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

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

• Метод __init__() из collections.deque теперь очищает все существующее содержимое deque перед добавлением элементов из iterable. Это изменение приводит поведение в соответствие с 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 следующим образом:c:func:PyObject_HashNotImplemented.

• Исключение socket moduleexception socket.error теперь наследуется от 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 постепенно отменяется.

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

Для приложений, использующих Python:

• В Python 2.6.6 была добавлена функция PySys_SetArgvEx(), позволяющая приложениям закрывать брешь в системе безопасности при использовании существующей функции PySys_SetArgv(). Проверьте, вызываете ли вы:c:func:!PySys_SetArgv и тщательно обдумайте, должно ли приложение использовать PySys_SetArgvEx() с параметром updatepath, равным false.

Признание¶

Автор хотел бы поблагодарить следующих людей за предложения, исправления и помощь в работе над различными вариантами этой статьи: Георга Брандла, Стива Брауна, Ника Коглана, Ральфа Кордероя, Джима Джуэтта, Кента Джонсона, Криса Ламбахера, Мартина Миклмайра, Антуана Питру, Брайана Уорнера.