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

Автор:

А.М. Кучлинг (amk at amk.ca)

В этой статье рассказывается о новых возможностях Python 2.6, выпущенного 1 октября 2008 года. График выпуска описан в PEP 361.

Основной темой Python 2.6 является подготовка к переходу на Python 3.0, который является крупной переработкой языка. По возможности Python 2.6 включает в себя новые возможности и синтаксис из 3.0, сохраняя совместимость с существующим кодом за счет отсутствия удаления старых возможностей или синтаксиса. Когда это невозможно, Python 2.6 пытается сделать все возможное, добавляя функции совместимости в модуль future_builtins и переключатель -3, предупреждающий об использовании функций, которые станут неподдерживаемыми в 3.0.

В стандартную библиотеку было добавлено несколько значительных новых пакетов, таких как модули multiprocessing и json, но не так уж много новых возможностей, которые не были бы так или иначе связаны с Python 3.0.

В Python 2.6 также внесен ряд улучшений и исправлений по всему исходному коду. Поиск по журналам изменений показывает, что между Python 2.5 и 2.6 было применено 259 исправлений и исправлено 612 ошибок. Обе цифры, скорее всего, занижены.

Эта статья не претендует на полное описание новых возможностей, а представляет собой удобный обзор. За подробной информацией следует обращаться к документации по Python 2.6. Если вы хотите понять обоснование разработки и реализации, обратитесь к PEP для конкретной новой функции. По возможности, в разделе «Что нового в Python» даются ссылки на ошибки/патчи для каждого изменения.

Python 3.0

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

Python 3.0 - это масштабная переработка Python, которая нарушает совместимость с серией 2.x. Это означает, что существующий код Python придется немного преобразовать, чтобы он мог работать на Python 3.0. Однако не все изменения в 3.0 обязательно нарушают совместимость. В тех случаях, когда новые возможности не приведут к поломке существующего кода, они были перенесены в 2.6 и описаны в этом документе в соответствующем месте. К числу функций, перенесенных в 3.0, относятся:

• Метод __complex__() для преобразования объектов в комплексное число.

• Альтернативный синтаксис для перехвата исключений: 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.

См.также

Серия 3xxx PEP, содержащая предложения по Python 3.0. PEP 3000 описывает процесс разработки Python 3.0. Начните с PEP 3100, в котором описываются общие цели Python 3.0, а затем изучите PEP с более высокими номерами, в которых предлагаются конкретные функции.

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

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

Трекер новых выпусков: Раунд-ап

В течение долгого времени разработчиков Python все больше раздражал багтрекер SourceForge. Размещенное на хостинге SourceForge решение не позволяет многое настраивать, например, нельзя было настроить жизненный цикл проблем.

Поэтому инфраструктурный комитет Python Software Foundation опубликовал объявление о поиске трекеров проблем, попросив добровольцев создать различные продукты и импортировать некоторые ошибки и исправления с SourceForge. Было рассмотрено четыре различных трекера: Jira, Launchpad, Roundup и Trac. В итоге комитет остановился на Jira и Roundup как на двух кандидатах. Jira - это коммерческий продукт, который предлагает бесплатные хостинги для свободно распространяемых проектов; Roundup - это проект с открытым исходным кодом, который требует добровольцев для его администрирования и сервера для его размещения.

После публикации призыва к добровольцам новая установка Roundup была установлена на https://bugs.python.org. Одна установка Roundup может содержать несколько трекеров, и сейчас на этом сервере также размещены трекеры проблем для Jython и для веб-сайта Python. В будущем ему наверняка найдут и другое применение. По возможности, в этом выпуске «Что нового в Python» для каждого изменения дается ссылка на ошибку/патч.

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

См.также

https://bugs.python.org

Трекер ошибок Python.

https://bugs.jython.org:

Трекер ошибок Jython.

https://roundup.sourceforge.io/

Загрузка и документация по Roundup.

https://svn.python.org/view/tracker/importer/

Скрипты преобразования Мартина фон Лёвиса.

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

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

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

Во время разработки 2.6 Георг Брандл приложил много усилий для создания новой цепочки инструментов для обработки документации. Получившийся пакет называется Sphinx и доступен по адресу https://www.sphinx-doc.org/.

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

Sphinx - это отдельный пакет, который можно использовать для написания документов, и почти два десятка других проектов (listed on the Sphinx web site) приняли Sphinx в качестве инструмента для создания документации.

См.также

Documenting Python

Описывает, как писать для Python документацию.

Sphinx

Документация и код для инструментария Sphinx.

Docutils

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

Примечание

В данном случае f - это тот же объект, созданный open(), потому что __enter__() возвращает self.

Блокировки и переменные условия модуля 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()

Написание контекстных менеджеров

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

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

• Выражение оценивается, и в результате должен появиться объект, называемый «менеджером контекста». Менеджер контекста должен иметь методы __enter__() и __exit__().

• Вызывается метод __enter__() менеджера контекста. Возвращенное значение присваивается VAR. Если отсутствует предложение as VAR, значение просто отбрасывается.

• Выполняется код в BLOCK.

• Если BLOCK поднимает исключение, вызывается метод __exit__() контекстного менеджера с тремя аргументами - деталями исключения (type, value, traceback, те же значения, возвращаемые sys.exc_info(), которые также могут быть None, если исключение не произошло). Возвращаемое значение метода контролирует, будет ли исключение повторно поднято: любое ложное значение повторно поднимает исключение, а True приведет к его подавлению. Подавлять исключение нужно очень редко, потому что в этом случае автор кода, содержащего оператор „with, никогда не поймет, что что-то пошло не так.

• Если BLOCK не вызвал исключения, метод __exit__() по-прежнему вызывается, но type, value и traceback становятся None.

Давайте подумаем на примере. Я не буду приводить подробный код, а лишь набросаю методы, необходимые для базы данных, поддерживающей транзакции.

(Для людей, незнакомых с терминологией баз данных: набор изменений в базе данных объединяется в транзакцию. Транзакции могут быть либо зафиксированы, что означает запись всех изменений в базу данных, либо откачены, что означает отмену всех изменений и сохранение базы данных без изменений. Более подробную информацию можно найти в любом учебнике по базам данных).

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

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

Транзакция должна быть зафиксирована, если код в блоке работает безупречно, или откачена, если возникло исключение. Вот базовый интерфейс для DatabaseConnection, который я предполагаю:

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"

Метод __enter__() довольно прост, нужно только начать новую транзакцию. Для данного приложения результирующий объект курсора будет полезным результатом, поэтому метод вернет его. Затем пользователь может добавить as cursor к своему оператору „with, чтобы привязать курсор к имени переменной.

class DatabaseConnection:
    ...
    def __enter__(self):
        # Code to start a new transaction
        cursor = self.cursor()
        return cursor

Метод __exit__() является самым сложным, потому что именно в нем выполняется большая часть работы. Метод должен проверить, не произошло ли исключение. Если исключения не было, транзакция фиксируется. Если исключение имело место, транзакция откатывается.

В приведенном ниже коде выполнение просто отвалится в конец функции, вернув значение по умолчанию None. None равно false, поэтому исключение будет вызвано автоматически. При желании вы можете быть более явными и добавить оператор return в отмеченное место.

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

Модуль contextlib

Модуль contextlib предоставляет несколько функций и декоратор, которые полезны при написании объектов для использования с оператором „with“.

Декоратор называется contextmanager() и позволяет написать одну функцию-генератор вместо того, чтобы определять новый класс. Генератор должен выдавать ровно одно значение. Код до yield будет выполнен как метод __enter__(), а полученное значение будет возвращенным значением метода, которое будет привязано к переменной в предложении as оператора „with, если таковое имеется. Код после yield будет выполнен в методе __exit__(). Любое исключение, возникшее в блоке, будет вызвано оператором yield.

Используя этот декоратор, наш пример с базой данных из предыдущего раздела можно записать так:

from contextlib import contextmanager

@contextmanager
def db_transaction(connection):
    cursor = connection.cursor()
    try:
        yield cursor
    except:
        connection.rollback()
        raise
    else:
        connection.commit()

db = DatabaseConnection()
with db_transaction(db) as cursor:
    ...

В модуле contextlib также есть функция nested(mgr1, mgr2, ...), которая объединяет несколько менеджеров контекста, что избавляет вас от необходимости писать вложенные операторы „with. В этом примере один оператор „with одновременно запускает транзакцию базы данных и получает блокировку потока:

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

Наконец, функция closing() возвращает свой аргумент, чтобы его можно было привязать к переменной, и вызывает метод .close() аргумента в конце блока.

import urllib, sys
from contextlib import closing

with closing(urllib.urlopen('http://www.yahoo.com')) as f:
    for line in f:
        sys.stdout.write(line)

См.также

PEP 343 - Утверждение «с»

PEP, написанный Гвидо ван Россумом и Ником Когланом; реализованный Майком Бландом, Гвидо ван Россумом и Нилом Норвицем. PEP показывает код, генерируемый для оператора „with“, что может быть полезно для изучения работы этого оператора.

Документация для модуля contextlib.

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 370 - На одного пользователя site-packages Каталог

PEP написан и реализован Кристианом Хаймсом.

PEP 371: The 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...

См.также

Документация для модуля multiprocessing.

PEP 371 - Добавление пакета многопроцессорной обработки

PEP написан Джесси Ноллером и Ричардом Оудкерком; реализован Ричардом Оудкерком и Джесси Ноллером.

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

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

В 2.6 для 8-битных и Unicode-строк есть метод .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; вот пример:

b	Двоичный. Выводит число по основанию 2.
c	Символ. Преобразует целое число в соответствующий символ Unicode перед печатью.
d	Десятичное целое число. Выводит число по основанию 10.
o	Октальный формат. Выводит число по основанию 8.
x	Шестнадцатеричный формат. Выводит число по основанию 16, используя строчные буквы для цифр больше 9.
e	Выражение в виде экспоненты. Выводит число в научной нотации, используя букву „e“ для обозначения экспоненты.
g	Общий формат. Выводит число в виде числа с фиксированной точкой, если только число не слишком велико, в этом случае оно переключается на нотацию с экспонентой „e“.
n	Число. Это то же самое, что и „g“ (для плавающих чисел) или „d“ (для целых чисел), за исключением того, что для вставки соответствующих символов-разделителей чисел используется текущая настройка локали.
%	Процент. Умножает число на 100 и отображает его в фиксированном формате («f»), за которым следует знак процента.

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

PEP, написанный Талином. Реализован Эриком Смитом.

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 3105 - Сделайте печать функцией

PEP написан Георгом Брандлом.

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

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

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

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

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

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

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

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

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

См.также

PEP 3110 - Ловля исключений в Python 3000

PEP написан и реализован Коллином Винтером.

PEP 3112: Литералы байтов

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

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

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

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

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

См.также

PEP 3112 - Литералы байтов в Python 3000

PEP написан Джейсоном Орендорффом; бэкпортирован в 2.6 Кристианом Хаймсом.

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: Предоставляет функции для чтения и записи строк (помните, что в Python 3.0 строки будут в Unicode), а также поддерживает 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 3116 - Новый ввод/вывод

PEP написан Даниэлем Штутцбахом, Майком Вердоне и Гвидо ван Россумом. Код от Гвидо ван Россума, Георга Брандла, Вальтера Доервальда, Джереми Хилтона, Мартина фон Лёвиса, Тони Лоундса и других.

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 запрашивает компоновку массива на языке C (последняя размерность изменяется быстрее всего) или Fortran (первая размерность изменяется быстрее всего).

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

См.также

PEP 3118 - Пересмотр протокола буферизации

PEP написан Трэвисом Олифантом и Карлом Бэнксом; реализован Трэвисом Олифантом.

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 включает в себя несколько различных азбук, которые представляют эти различия. Iterable означает, что класс определяет __iter__(), а Container означает, что класс определяет __contains__() метод и поэтому поддерживает x in y выражения. Базовый интерфейс словаря, включающий получение элементов, установку элементов и keys(), values() и items(), определяется MutableMapping. ABC.

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

import collections

class Storage(collections.MutableMapping):
    ...

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

import collections

class Storage:
    ...

collections.MutableMapping.register(Storage)

Для классов, которые вы пишете сами, производные от ABC, вероятно, более понятны. Метод register() полезен, когда вы написали новый ABC, который может описывать существующий тип или класс, или если вы хотите объявить, что какой-то сторонний класс реализует ABC. Например, если вы определили 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 сильна традиция duck-typing, когда явная проверка типов никогда не выполняется, а код просто вызывает методы объекта, полагаясь на то, что эти методы будут там, и поднимая исключение, если их там нет. Будьте благоразумны в проверке 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):
        ...

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

PEP, написанный Гвидо ван Россумом и Талином. Реализован Гвидо ван Россумом. Бэкпортирован в 2.6 Бенджамином Арангуреном при участии Алекса Мартелли.

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 3127 - Поддержка и синтаксис целочисленных литералов

PEP, написанный Патриком Мопином; бэкпортирован в 2.6 Эриком Смитом.

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

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

@foo
@bar
class A:
  pass

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

class A:
  pass

A = foo(bar(A))

См.также

PEP 3129 - Декораторы классов

PEP написан Коллином Уинтером.

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

В Python 3.0 добавлено несколько абстрактных базовых классов для числовых типов, вдохновленных числовой башней Scheme. Эти классы были перенесены в 2.6 в виде модуля numbers.

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

Complex является подклассом Number. С комплексными числами можно выполнять основные операции сложения, вычитания, умножения, деления и экспоненции, а также извлекать действительную и мнимую части и получать сопряженное число. Встроенный в Python тип complex является реализацией 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, который находится между аргументом функции и нулем.

См.также

[…] […]

[…] […]

Scheme’s numerical tower, из руководства по Guile.

[…]

Модуль fractions Модуль

Модуль fractions Модуль

Модуль Fraction Модуль

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

Модуль as_integer_ratio() Модуль

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

Обратите внимание, что значения, которые можно аппроксимировать только числами с плавающей точкой, например 1,/3, не упрощаются до аппроксимируемого числа; дробь пытается соответствовать значению с плавающей точкой точно.

Модуль fractions Модуль

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

Некоторые более мелкие изменения, внесенные в ядро языка 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'
  

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

Оптимизации

• Модуль warnings был переписан на C. Это позволяет вызывать предупреждения из парсера, а также может ускорить запуск интерпретатора. (Внесено Нилом Норвицем и Бреттом Кэнноном; bpo-1631171).

• Объекты типов теперь имеют кэш методов, что позволяет сократить трудозатраты на поиск правильной реализации метода для конкретного класса; после создания кэша интерпретатору не нужно обходить базовые классы, чтобы найти нужный метод для вызова. Кэш очищается при изменении базового класса или самого класса, поэтому кэш должен оставаться корректным даже в условиях динамичности Python. (Оригинальная оптимизация реализована Армином Риго, обновлена для Python 2.6 Кевином Джейкобсом; bpo-1700288).

  По умолчанию это изменение применяется только к типам, входящим в состав ядра Python. Модули расширений могут быть несовместимы с этим кэшем, поэтому они должны явно добавить Py_TPFLAGS_HAVE_VERSION_TAG к полю tp_flags модуля, чтобы включить кэш методов. (Чтобы быть совместимым с кэшем методов, код модуля расширения не должен напрямую обращаться и изменять член tp_dict ни одного из реализуемых им типов. Большинство модулей этого не делают, но интерпретатор Python не может этого определить. См. bpo-1878 для некоторого обсуждения).

• Вызовы функций, использующих аргументы в виде ключевых слов, значительно ускоряются за счет быстрого сравнения указателей, что обычно экономит время полного сравнения строк. (Внесено Раймондом Хеттингером, после первоначальной реализации Антуаном Питру; bpo-1819).

• Все функции в модуле struct были переписаны на C благодаря работе на спринте Need For Speed. (Внесено Раймондом Хеттингером).

• Некоторые стандартные встроенные типы теперь задают бит в своих объектах типа. Это ускоряет проверку того, является ли объект подклассом одного из этих типов. (Внесено Нилом Норвицем).

• Строки Unicode теперь используют более быстрый код для определения пробельных символов и переносов строк; это ускоряет метод split() примерно на 25 %, а splitlines() - на 35 %. (Вклад Антуана Питру.) Использование памяти уменьшено за счет использования pymalloc для данных строки Unicode.

• Оператор with теперь сохраняет метод __exit__() в стеке, что дает небольшое ускорение. (Реализовано Джеффри Ясскином).

• Чтобы сократить потребление памяти, сборщик мусора теперь очищает внутренние списки свободных объектов при сборке объектов самого высокого поколения. Это позволяет быстрее возвращать память операционной системе.

Изменения в работе переводчика

Два параметра командной строки были зарезервированы для использования в других реализациях Python. Переключатель -J был зарезервирован для использования в Jython для специфических для Jython опций, таких как переключатели, передаваемые базовой JVM. Переключатель -X был зарезервирован для опций, специфичных для конкретной реализации Python, таких как CPython, Jython или IronPython. Если одна из этих опций используется в Python 2.6, интерпретатор сообщит, что в настоящее время эта опция не используется.

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

Кодировку, используемую для стандартного ввода, вывода и стандартной ошибки, можно задать, установив переменную окружения PYTHONIOENCODING перед запуском интерпретатора. Значение должно представлять собой строку в виде <encoding> или <encoding>:<errorhandler>. Часть encoding указывает имя кодировки, например, utf-8 или latin-1; необязательная часть errorhandler указывает, что делать с символами, которые не могут быть обработаны кодировкой, и должна быть одной из «error», «ignore» или «replace». (Внесено Мартином фон Лёвисом).

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

Как и в каждом выпуске, стандартная библиотека 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. (Вклад Раймонда Хеттингера.)

• В конструктор класса ftplib.FTP и метод connect() был добавлен необязательный параметр timeout, задающий таймаут, измеряемый в секундах. (Добавлено Факундо Батистой.) Кроме того, методы storbinary() и storlines() класса FTP теперь принимают необязательный параметр callback, который будет вызываться с каждым блоком данных после их отправки. (Внесено Филом Шварцем; 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), помещает item в heap, затем выгружает и возвращает наименьший элемент. Это более эффективно, чем вызов 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 раз. При использовании одного аргумента 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() складывает поток чисел из итерируемой таблицы, стараясь избежать потери точности при использовании частичных сумм. (Вклад внесли Жан Бруверс, Раймонд Хеттингер и Марк Дикинсон; 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, содержащий ту же структуру данных. (Внесено Раймондом Хеттингером).

• В модуль 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).

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

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

  Новая функция 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 поддерживает имена файлов в кодировке Юникод, а по умолчанию используется кодировка 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 для черепашьей графики был значительно улучшен Грегором Линглом. Новые возможности модуля включают:

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

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

Модуль ast

Модуль ast обеспечивает представление кода Python в виде абстрактного синтаксического дерева, а Армин Ронахер предоставил набор вспомогательных функций, которые выполняют множество общих задач. Они будут полезны для пакетов шаблонизации HTML, анализаторов кода и подобных инструментов, обрабатывающих Python-код.

Функция parse() принимает выражение и возвращает AST. Функция dump() выводит представление дерева, подходящее для отладки:

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_eval() принимает строку или AST, представляющую литеральное выражение, анализирует и оценивает его, а затем возвращает полученное значение. Литеральное выражение - это выражение Python, содержащее только строки, числа, словари и т. д., но не содержащее операторов или вызовов функций. Если вам нужно оценить выражение, но вы не можете принять риск безопасности, связанный с использованием вызова eval(), literal_eval() безопасно справится с этой задачей:

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

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

Модуль future_builtins

Python 3.0 вносит множество изменений в репертуар встроенных функций, и большинство из них не могут быть введены в серию Python 2.x, поскольку нарушают совместимость. Модуль future_builtins предоставляет версии этих встроенных функций, которые можно импортировать при написании кода, совместимого с 3.0.

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

• ascii(obj): эквивалентно repr(). В Python 3.0 repr() возвращает строку Unicode, а ascii() - чистую байт-строку ASCII.

• filter(predicate, iterable), map(func, iterable1, ...): версии 3.0 возвращают итераторы, в отличие от встроенных модулей 2.x, которые возвращают списки.

• hex(value), oct(value): вместо вызова методов __hex__() или __oct__() эти версии будут вызывать метод __index__() и преобразовывать результат в шестнадцатеричную или восьмеричную систему счисления. oct() будет использовать новую нотацию 0o для своего результата.

Модуль json: Объектная нотация JavaScript

Новый модуль json поддерживает кодирование и декодирование типов Python в JSON (Javascript Object Notation). JSON - это легкий формат обмена данными, часто используемый в веб-приложениях. Более подробную информацию о JSON можно найти на сайте http://www.json.org.

json поставляется с поддержкой декодирования и кодирования большинства встроенных типов Python. Следующий пример кодирует и декодирует словарь:

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

Также можно написать свои собственные декодеры и кодеры для поддержки большего количества типов. Также поддерживается красивая печать строк JSON.

json (первоначальное название simplejson) был написан Бобом Ипполито.

Модуль plistlib: Парсер списков свойств

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

Несмотря на то, что формат в основном используется в Mac OS X, в нем нет ничего специфичного для Mac, а реализация на Python работает на любой платформе, которую поддерживает Python, поэтому модуль plistlib был перенесен в стандартную библиотеку.

Использовать модуль очень просто:

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)

Усовершенствования ctypes

Томас Хеллер продолжал поддерживать и улучшать модуль ctypes.

ctypes теперь поддерживает тип данных c_bool, который представляет тип C99 bool. (Внесено Дэвидом Ремалем; bpo-1649190).

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

Все типы данных ctypes теперь поддерживают методы from_buffer() и from_buffer_copy(), которые создают экземпляр ctypes на основе предоставленного объекта буфера. from_buffer_copy() копирует содержимое объекта, а from_buffer() будет использовать ту же область памяти.

Новое соглашение о вызовах предписывает ctypes очищать переменные errno или Win32 LastError в начале каждого обернутого вызова. (Реализовано Томасом Хеллером; bpo-1798).

Теперь вы можете получить переменную Unix errno после вызова функции. При создании обернутой функции вы можете передать use_errno=True в качестве параметра ключевого слова в функцию DLL(), а затем вызвать методы уровня модуля set_errno() и get_errno() для установки и получения значения ошибки.

Переменная Win32 LastError аналогичным образом поддерживается функциями DLL(), OleDLL() и WinDLL(). Вы передаете use_last_error=True в качестве параметра ключевого слова, а затем вызываете методы уровня модуля set_last_error() и get_last_error().

Функция byref(), используемая для получения указателя на экземпляр ctypes, теперь имеет необязательный параметр offset, представляющий собой количество байт, которое будет добавлено к возвращаемому указателю.

Улучшенная поддержка SSL

Билл Янссен внес значительные улучшения в поддержку Secure Sockets Layer в Python 2.6, добавив новый модуль ssl, который построен на базе библиотеки OpenSSL. Этот новый модуль предоставляет больше контроля над протоколом, используемыми сертификатами X.509, а также улучшает поддержку написания SSL-серверов (в отличие от клиентов) на Python. Существующая поддержка SSL в модуле socket не была удалена и продолжает работать, хотя она будет удалена в Python 3.0.

Чтобы использовать новый модуль, необходимо сначала создать TCP-соединение обычным способом, а затем передать его функции ssl.wrap_socket(). Можно указать, требуется ли сертификат, и получить информацию о сертификате, вызвав метод getpeercert().

См.также

Документация для модуля ssl.

Амортизация и удаление

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

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

• (Режим 3.0-warning) В 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.

Изменения в сборке и 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 может быть скомпилирован как 4-сторонняя универсальная сборка. Скрипт 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 теперь имеет объект 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).

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

Изменения для конкретного порта: Windows

• Поддержка Windows 95, 98, ME и NT4 была прекращена. Для Python 2.6 требуется как минимум Windows 2000 SP4.

• Новым компилятором по умолчанию в Windows является Visual Studio 2008 (версия 9.0). Директории сборки для Visual Studio 2003 (версия 7.1) и 2005 (версия 8.0) были перемещены в каталог PC/. Новый каталог PCbuild поддерживает кросс-компиляцию для X64, отладочные сборки и Profile Guided Optimization (PGO). Сборки PGO примерно на 10% быстрее обычных сборок. (Внесено Кристианом Хаймсом при содействии Амори Форжо д’Арк и Мартина фон Лёвиса).

• Модуль msvcrt теперь поддерживает как обычный, так и широкосимвольный варианты API ввода/вывода консоли. Функция getwch() считывает нажатие клавиши и возвращает значение Unicode, как и функция getwche(). Функция putwch() принимает символ Unicode и записывает его в консоль. (Внесено Кристианом Хаймсом.)

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

• Объекты сокетов модуля socket теперь имеют метод ioctl(), который предоставляет ограниченный интерфейс к системному интерфейсу WSAIoctl().

• Модуль _winreg теперь имеет функцию ExpandEnvironmentStrings(), которая расширяет ссылки на переменные окружения, такие как %NAME% во входной строке. Объекты handle, предоставляемые этим модулем, теперь поддерживают протокол контекста, поэтому их можно использовать в операторах with. (Внесено Кристианом Хаймсом.)

  _winreg также имеет лучшую поддержку x64-систем, раскрывая функции DisableReflectionKey(), EnableReflectionKey() и QueryReflectionKey(), которые включают и выключают отражение реестра для 32-битных процессов, работающих на 64-битных системах. (bpo-1753245)

• Объект msilib модуля Record обзавелся методами GetInteger() и GetString(), которые возвращают значения полей в виде целого числа или строки. (Вклад Флориса Бруйнооге; bpo-2125).

Изменения для конкретного порта: Mac OS X

• При компиляции фреймворковой сборки Python теперь можно указать имя фреймворка, который будет использоваться, указав опцию --with-framework-name= в сценарии configure.

• Модуль macfs был удален. Это, в свою очередь, потребовало удаления функции macostools.touched(), поскольку она зависела от модуля macfs. (bpo-1490190)

• Многие другие модули Mac OS были устаревшими и будут удалены в Python 3. 0: _builtinSuites, aepack, aetools, aetypes, applesingle, appletrawmain, appletrunner, argvemulator, Audio_mac, autoGIL, Carbon, cfmfile, CodeWarrior, ColorPicker, EasyDialogs, Explorer, Finder, FrameWork, findertools, ic, icglue, icopen, macerrors, MacOS, macfs, macostools, macresource, MiniAEFrame, Nav, Netscape, OSATerminology, pimp, PixMapWrapper, StdSuites, SystemEvents, Terminal, и terminalcommand.

Изменения для конкретного порта: IRIX

Ряд старых модулей, специфичных для IRIX, были устаревшими и будут удалены в Python 3. 0: al и AL, cd, cddb, cdplayer, CL и cl, DEVICE, ERRNO, FILE, FL и fl, flp, fm, GET, GLWS, GL и gl, IN, IOCTL, jpeg, panelparser, readcd, SV и sv, torgb, videoreader и WAIT.

Переход на Python 2.6

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

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

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

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

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

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

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

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

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

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

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

• (3.0-warning mode) Класс Exception теперь предупреждает при обращении к нему с использованием срезов или индексного доступа; отказ от использования Exception, ведущего себя как кортеж.

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

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

Для приложений, в которых используется Python:

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

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

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