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

Python 3.0¶

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

Python 3.0 - это масштабная переработка Python, которая нарушает совместимость с серией 2.x. Это означает, что для работы на Python 3.0 существующий код Python придется преобразовать. Однако не все изменения в версии 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: Заявление „с“¶

В предыдущей версии, 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-блока вызывается метод __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/

• 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¶

Новый пакет 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: завершающий текст, который будет выведен после вывода всех аргументов.

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

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

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

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

Автор, вероятно, пытается перехватить оба исключения 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: Литералы байтов¶

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# 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 и делайте это только там, где это абсолютно необходимо.

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

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 добавляет несколько абстрактных базовых классов для числовых типов, вдохновленных числовой башней Scheme. Эти классы были перенесены в версию 2.6 в виде модуля numbers.

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

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

Real далее происходит от Complex и добавляет операции, которые работают только с вещественными числами: floor(), trunc(), округление, взятие остатка mod 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}
  

  Раньше это было бы синтаксической ошибкой. (Внесено Amaury Forgeot d’Arc; bpo-3473).

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

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

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

  (При участии Раймонда Хеттингера)

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

• Свойства теперь имеют три атрибута, getter, setter и deleter, которые являются декораторами, предоставляющими полезные сокращения для добавления функции 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')  # Intersection between all inputs
  set(['2'])
  >>> s.difference('246', '789')
  set(['1', '0', '3', '5'])
  

  (При участии Раймонда Хеттингера.)

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

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

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

  >>> a = 3.75
  >>> a.hex()
  '0x1.e000000000000p+1'
  >>> float.fromhex('0x1.e000000000000p+1')
  3.75
  >>> b=1./3
  >>> b.hex()
  '0x1.5555555555555p-2'
  

• Числовая тонкость: при создании комплексного числа из двух плавающих чисел в системах, поддерживающих знаковые нули (-0 и +0), конструктор complex() теперь будет сохранять знак нуля. (Исправлено Марком Т. Дикинсоном; bpo-1507).

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

  Это следует делать, когда вы определили метод __cmp__() или __eq__(), который сравнивает объекты по их значению, а не по идентичности. Все объекты имеют метод хеширования по умолчанию, который использует id(obj) в качестве хеш-значения. Не существует аккуратного способа удалить метод __hash__(), унаследованный от родительского класса, поэтому присвоение None было реализовано как переопределение. На уровне языка C расширения могут устанавливать tp_hash в PyObject_HashNotImplemented(). (Исправлено Nick Coghlan и Amaury Forgeot d’Arc; 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». (Вклад внесли Александр Фиори и Nubis; 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 элементов. Добавление новых элементов в полный deque приводит к отбрасыванию старых элементов.

  >>> 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 теперь поддерживает редактирование в режиме вставки, а также в режиме перезаписи. Режим вставки включается путем задания значения true для параметра 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 теперь возвращает именованный кортеж с полями sign, digits и exponent.

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

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

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

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

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

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

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

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

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

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

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

• Большинство функций модуля 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 раз. При одном аргументе iterable возвращается 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]
  

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

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

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

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

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

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

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

  • fsum() складывает поток чисел из итерабельной таблицы, при этом старается избежать потери точности за счет использования частичных сумм. (При участии Jean Brouwers, Raymond Hettinger и Mark Dickinson; 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 и может принимать новые аргументы командной строки для программы. (Внесено Рокки Бернштейном; bpo-1393667).

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

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

• В модуль get_data() была добавлена функция pkgutil, которая возвращает содержимое файлов ресурсов, включенных в установленный пакет 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 как наиболее часто встречающееся значение в распределении. (Вклад внесли Wladmir van der Laan и Raymond Hettinger; bpo-1681432).

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

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

• Метод rlcompleter модуля Completer.complete() теперь будет игнорировать исключения, возникающие при оценке имени. (Исправлено Лоренцом Кваком; 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, который принимает объект callable. Этот вызываемый объект получает каждый путь к каталогу и список содержимого каталога, и возвращает список имен, которые будут проигнорированы, а не скопированы.

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

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

  (При участии Тарека Зиаде; bpo-2663).

• Интеграция обработки сигналов с циклами обработки событий GUI, подобными тем, что используются в Tkinter или GTk+, долгое время была проблемой; большинство программ в конечном итоге опрашивают, просыпаясь каждую долю секунды, чтобы проверить, произошли ли какие-либо события GUI. Модуль 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 (http://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, скомпилированные файлы не записываются. Изначально переменная устанавливается при запуске интерпретатора Python с помощью ключа -B или путем установки переменной окружения PYTHONDONTWRITEBYTECODE перед запуском интерпретатора. Впоследствии код Python может изменять значение этой переменной, чтобы контролировать запись или отсутствие записи файлов байткода. (При участии Нила Норвица и Георга Брандла).

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

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

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

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

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

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

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

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

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

• Класс 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 теперь принимает callables, а также строки для проверяемого оператора и кода установки. Добавлены две удобные функции для создания экземпляров Timer: repeat(stmt, setup, time, repeat, number) и timeit(stmt, setup, time, number) создают экземпляр и вызывают соответствующий метод. (Внесено Эриком Демейном; bpo-1533909).

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

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

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

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

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

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

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

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

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

  (bpo-1513695)

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

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

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

• База данных 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 теперь поддерживает использование имен файлов Unicode для архивных файлов. (Внесено Алексеем Борзенковым; bpo-1734346).

import ast

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

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

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

>>> import json
>>> data = {"spam": "foo", "parrot": 42}
>>> in_json = json.dumps(data) # 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-warning mode) В Python 3.0 будет реорганизована стандартная библиотека, из которой будут удалены многие устаревшие модули и переименованы другие. Python 2.6, работающий в режиме 3.0-warning, будет предупреждать об этих модулях при их импорте.

  Список устаревших модулей выглядит следующим образом: 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.

Изменения в API Build и C¶

Изменения в процессе сборки 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 может быть скомпилирован как 4-сторонняя универсальная сборка. Сценарий 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 для своих целей. (Внесено Дунканом Грисби.)

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

• Использование в Python библиотеки C stdio теперь потокобезопасно, или, по крайней мере, настолько потокобезопасно, насколько безопасна базовая библиотека. Давняя потенциальная ошибка возникала, если один поток закрывал файловый объект, в то время как другой поток читал из этого объекта или записывал в него. В версии 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).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

• Исключение модуля socket 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-warning) сравнения неравенств между двумя словарями или двумя объектами, которые не реализуют методы сравнения, сообщаются как предупреждения. dict1 == dict2 все еще работает, но dict1 < dict2 постепенно выводится из употребления.

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

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

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