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

Автор:А.М. Кухлинг (amk на 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» содержит ссылку на элемент ошибки/исправления для каждого изменения.

Питон 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, а затем изучите PEPS с более высокими номерами, которые предлагают определённые функции.

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

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

Новый трекер проблем: сводка новостей

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

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

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

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

См.также

bugs
Трекер ошибок Python.
jbugs
Трекер ошибок Jython.
roundup
Сводка новостей и документация.
svn
Сценарии преобразования Мартина фон Лёвиса.

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

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

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

В цикле разработки версии 2.6 Георг Брандл приложил немало усилий для создания новой цепочки инструментов для обработки документации. Полученный пакет называется Sphinx и доступен по адресу.

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

Sphinx — это отдельный пакет, который можно использовать для написания, и почти два десятка других проектов (перечислены на веб-сайте Sphinx) используют Sphinx в качестве средства документирования.

См.также

Документирование Python
Рассказывает, как писать документацию для Python.
Sphinx
Документация и код для набора инструментов Sphinx.
Docutils
Базовый парсер reStructuredText и множество инструментов.

PEP 343: Оператор with

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

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

Оператор «with» представляет собой структуру потока управления, основная структура которой такова:

with expression [as variable]:
    with-block

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

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

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

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

with open('/etc/passwd', 'r') as f:
    for line in f:
        print line
        ... больше кода обработки ...

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

Примечание

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

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

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

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

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

from decimal import Decimal, Context, localcontext

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

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

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

Под капотом оператор «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 ...')
    # ... больше операций ...

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

class DatabaseConnection:
    # Интерфейс базы данных
    def cursor(self):
        "Возвращает объект курсора и запускает новую транзакцию"
    def commit(self):
        "Фиксирует текущую транзакцию"
    def rollback(self):
        "Откатывает текущую транзакцию"

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

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

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

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

class DatabaseConnection:
    ...
    def __exit__(self, type, value, tb):
        if tb is None:
            # Не исключение, так что фиксируем
            self.commit()
        else:
            # Произошло исключение, поэтому откат.
            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('https://digitology.tech')) as f:
    for line in f:
        sys.stdout.write(line)

См.также

PEP 343 — Оператор with
PEP, написанный Гвидо ван Россумом и Nick Coghlan; реализованный Майком Блэндом Гвидо ван Россумом и Нил Норвиц. PEP показывает код, сгенерированный для a Оператор «with», который может быть полезен при изучении того, как оператор работает.

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

PEP 366: явный относительный импорт из основного модуля

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

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

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

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

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

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

  • Unix и Mac OS X: ~/.local/
  • Окна: %APPDATA%/Python

В этом каталоге будут подкаталоги для версий, такие как lib/python2.6/site-packages в Unix/Mac OS и Python26/site- packages в Windows.

Если вам не нравится каталог по умолчанию, его можно переопределить с помощью переменной среды. PYTHONUSERBASE задаёт корневой каталог, используемый для всех версий Python, поддерживающих эту функцию. В Windows каталог для данных приложения можно изменить, задав переменную среды APPDATA. Вы также можете изменить файл site.py для вашей установки Python.

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

См.также

PEP 370 — каталог site-packages для каждого пользователя
PEP написан и реализован Кристианом Хеймсом.

PEP 371: пакет multiprocessing

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

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

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

import time
from multiprocessing import Process, Queue


def factorial(queue, N):
    "Вычислить факториал."
    # Если N кратно 4, функция займет гораздо больше времени.
    if (N % 4) == 0:
        time.sleep(.05 * N/4)

    # Рассчитать результат
    fact = 1L
    for i in range(1, N+1):
        fact = fact * i

    # Ставим результат в очередь
    queue.put(fact)

if __name__ == '__main__':
    queue = Queue()

    N = 5

    p = Process(target=factorial, args=(queue, N))
    p.start()
    p.join()

    result = queue.get()
    print 'Factorial', N, '=', result

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

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

from multiprocessing import Pool

def factorial(N, dictionary):
    "Вычислить факториал."
    ...
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):
    "Вычислить факториал."
    # Рассчитать результат
    fact = 1L
    for i in range(1, N+1):
        fact = fact * i

    # Сохранить результат в словаре
    dictionary[N] = fact

if __name__ == '__main__':
    p = Pool(5)
    mgr = Manager()
    d = mgr.dict()         # Создать общий словарь

    # Запуск задач с использованием пула
    for N in range(1, 1000, 10):
        p.apply_async(factorial, (N, d))

    # Пометить пул как закрытый — больше нельзя добавлять задачи.
    p.close()

    # Дождаться завершения задач
    p.join()

    # Выходные результаты
    for k, v in sorted(d.items()):
        print k, v

Это произведёт вывод:

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

См.также

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

PEP 371 — Добавлен пакет многопроцессорности
PEP, написанный Джесси Ноллером и Ричардом Оудкерком; реализован Ричардом Оудкерком и Джесси Ноллером.

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

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

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

>>> # Подставить позиционный аргумент 0 в строку.
>>> "User ID: {0}".format("root")
'User ID: root'
>>> # Использовать именованные ключевые аргументы
>>> "User ID: {uid}   Last seen: {last_login}".format(
...    uid="root",
...    last_login = "5 Mar 2008 07:20")
'User ID: root   Last seen: 5 Mar 2008 07:20'

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

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

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

>>> import sys
>>> print 'Platform: {0.platform}\nPython version: {0.version}'.format(sys)
Platform: darwin
Python version: 2.6a1+ (trunk:61261M, Mar  5 2008, 20:29:41)
[GCC 4.0.1 (Apple Computer, Inc. build 5367)]'

>>> import mimetypes
>>> 'Content-type: {0[.mp4]}'.format(mimetypes.types_map)
'Content-type: video/mp4'

Обратите внимание, что при использовании нотации в стиле словаря, такой как [.mp4], вам не нужно заключать строку в кавычки; он будет искать значение, используя .mp4 в качестве ключа. Строки, начинающиеся с числа, будут преобразованы в целое число. Вы не можете писать более сложные выражения внутри строки формата.

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

>>> # Поле 0: выравнивание по левому краю, отступ до 15 символов
>>> # Поле 1: выравнивание по правому краю, отступ до 6 символов
>>> fmt = '{0:15} ${1:>6}'
>>> fmt.format('Registration', 35)
'Registration    $    35'
>>> fmt.format('Tutorial', 50)
'Tutorial        $    50'
>>> fmt.format('Banquet', 125)
'Banquet         $   125'

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

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

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

Символ Эффект
< (по умолчанию) Выровнять по левому краю
> Выровнять по правому краю
^ Центр
= (Только для числовых типов) Смещение после знака.

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

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

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

b Бинарный. Выводит число по основанию 2.
c Символ. Преобразует целое число в соответствующий символ Юникода перед печатью.
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 — Сделать print функцией
PEP, написанный Георгом Брандлом.

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

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

try:
    ...
except TypeError, ValueError:  # Неправильно!
    ...

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

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

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

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

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

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

См.также

PEP 3110 — Перехват исключений в Python 3000
PEP написан и реализован Коллином Винтером.

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

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

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

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

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

from __future__ import unicode_literals

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

print len(s)               # 12 символов Юникода

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

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

>>> bytearray([65, 66, 67])
bytearray(b'ABC')
>>> b = bytearray(u'\u21ef\u3244', 'utf-8')
>>> b
bytearray(b'\xe2\x87\xaf\xe3\x89\x84')
>>> b[0] = '\xe3'
>>> b
bytearray(b'\xe3\x87\xaf\xe3\x89\x84')
>>> unicode(str(b), 'utf-8')
u'\u31ef \u3244'

Массивы байтов поддерживают большинство методов строковых типов, например, startswith()/endswith(), find()/rfind(), и некоторые методы списков, такие как append(), pop() и reverse().

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

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

См.также

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

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

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

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

См.также

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

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

import collections

class Storage(collections.MutableMapping):
    ...

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

import collections

class Storage:
    ...

collections.MutableMapping.register(Storage)

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

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

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

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

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

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

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

from abc import ABCMeta, abstractmethod

class Drawable():
    __metaclass__ = ABCMeta

    @abstractmethod
    def draw(self, x, y, scale=1.0):
        pass

    def draw_doubled(self, x, y):
        self.draw(x, y, scale=2.0)


class Square(Drawable):
    def draw(self, x, y, scale):
        ...

В 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, написанный Гвидо ван Россумом и Talin. Реализован Гвидо ван Россумом. Обратно перенесено на версию 2.6 Бенджамином Арангуреном и Алексом Мартелли.

PEP 3127: поддержка целочисленного литерала и синтаксис

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

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

См.также

PEP 3127 — поддержка целочисленного литерала и синтаксис
PEP, написанный Патриком Мопеном; бэкпортирован на 2.6 by Эрик Смит.

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.

Real является производным от Complex и добавляет операции, которые работают только с действительными числами: floor(), trunc(), округление, получение остатка по модулю N, деление на пол и сравнения.

Числа Rational происходят от Real, имеют свойства numerator и denominator и могут быть преобразованы в числа с плавающей запятой. Python 2.6 добавляет простой класс рациональных чисел Fraction в модуль fractions. (Он называется Fraction вместо Rational, чтобы избежать конфликта имён с numbers.Rational.)

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

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

См.также

PEP 3141 — Иерархия типов для чисел
PEP, написанный Джеффри Яскиным.

Числовая башня Scheme из руководства Guile.

Числовые типы данных Scheme из спецификации схемы R5RS.

Модуль fractions

Для заполнения иерархии числовых типов модуль fractions предоставляет класс рациональных чисел. Рациональные числа хранят свои значения в виде числителя и знаменателя, образующих дробь, и могут точно представлять такие числа, как 2/3, которые числа с плавающей запятой могут только приближать.

Конструктор Fraction принимает два значения Integral, которые будут числителем и знаменателем результирующей дроби.

>>> from fractions import Fraction
>>> a = Fraction(2, 3)
>>> b = Fraction(2, 5)
>>> float(a), float(b)
(0.66666666666666663, 0.40000000000000002)
>>> a+b
Fraction(16, 15)
>>> a/b
Fraction(5, 3)

Для преобразования чисел с плавающей запятой в рациональные числа тип float теперь имеет метод 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 основан на реализации Sjoerd Mullender, которая долгое время находилась в каталоге Python Demo/classes/. Реализация была существенно обновлена Джеффри Яскиным.

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

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

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

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

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

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

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

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

    >>> def f(*args, **kw):
    ...     print args, kw
    ...
    >>> f(1,2,3, *(4,5,6), keyword=13)
    (1, 2, 3, 4, 5, 6) {'keyword': 13}
    

    Раньше это было бы синтаксической ошибкой. (Предоставлено Амори Форжо д’Арк; bpo-3473.)

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

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

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

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

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

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

    class C(object):
        @property
        def x(self):
            return self._x
    
        @x.setter
        def x(self, value):
            self._x = value
    
        @x.deleter
        def x(self):
            del self._x
    
    class D(C):
        @C.x.getter
        def x(self):
            return self._x * 2
    
        @x.setter
        def x(self, value):
            self._x = value / 2
    
  • Некоторые методы встроенных типов наборов теперь принимают несколько итераций: intersection(), intersection_update(), union(), update(), difference() и difference_update().

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

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

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

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

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

    >>> a = 3.75
    >>> a.hex()
    '0x1.e000000000000p+1'
    >>> float.fromhex('0x1.e000000000000p+1')
    3.75
    >>> b=1./3
    >>> b.hex()
    '0x1.5555555555555p-2'
    
  • Числовая тонкость: при создании комплексного числа из двух чисел с плавающей запятой в системах, поддерживающих нули со знаком (-0 и +0), конструктор complex() теперь будет сохранять знак нуля. (Исправлено Марком Т. Дикинсоном; bpo-1507.)

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

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

  • Строковый метод 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. (Предоставлено Рэймондом Хеттингером.)

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

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

  • Оператор 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 указывает, что делать с символами, которые не могут быть обработаны кодировкой, и должна быть одной из «ошибка», «игнорировать» или «заменить». (Предоставлено Мартином фон Лёвисом)

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

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

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

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

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

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

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

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

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

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

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

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

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

    >>> var_type = collections.namedtuple('variable',
    ...             'id name type size')
    >>> # Имена разделяются пробелами или запятыми.
    >>> # 'id, name, type, size' would also work.
    >>> var_type._fields
    ('id', 'name', 'type', 'size')
    
    >>> var = var_type(1, 'frequency', 'int', 4)
    >>> print var[0], var.id    # Эквивалент
    1 1
    >>> print var[2], var.type  # Эквивалент
    int int
    >>> var._asdict()
    {'size': 4, 'type': 'int', 'id': 1, 'name': 'frequency'}
    >>> v2 = var._replace(name='amplitude')
    >>> v2
    variable(id=1, name='amplitude', type='int', size=4)
    

    Несколько мест в стандартной библиотеке, которые возвращали кортежи, были изменены, чтобы возвращать экземпляры namedtuple. Например, метод Decimal.as_tuple() теперь возвращает именованный кортеж с полями sign, digits и exponent.

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

  • Ещё одно изменение в модуле collections заключается в том, что тип deque теперь поддерживает необязательный параметр maxlen; если указано, размер очереди будет ограничен не более чем maxlen элементов. Добавление дополнительных элементов в полную очередь приводит к отбрасыванию старых элементов.

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

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

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

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

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

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

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

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

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

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

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

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

  • Необязательный параметр timeout, определяющий время ожидания в секундах, был добавлен в конструктор класса ftplib.FTP, а также в метод connect(). (Добавлено Факундо Батиста.) Кроме того, 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, указывающий время ожидания в секундах. (Добавлено Факундо Батиста.)

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

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

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

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

    >>> tuple(itertools.izip_longest([1,2,3], [1,2,3,4,5]))
    ((1, 1), (2, 2), (3, 3), (None, 4), (None, 5))
    

    product(iter1, iter2, ..., [repeat=N]) возвращает декартово произведение предоставленных итераций, множество кортежей, содержащих все возможные комбинации элементов, возвращаемых из каждой итерации.

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

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

    >>> list(itertools.product([1,2], repeat=3))
    [(1, 1, 1), (1, 1, 2), (1, 2, 1), (1, 2, 2),
     (2, 1, 1), (2, 1, 2), (2, 2, 1), (2, 2, 2)]
    

    С двумя итерируемыми объектами возвращаются кортежи 2N.

    >>> list(itertools.product([1,2], [3,4], repeat=2))
    [(1, 3, 1, 3), (1, 3, 1, 4), (1, 3, 2, 3), (1, 3, 2, 4),
     (1, 4, 1, 3), (1, 4, 1, 4), (1, 4, 2, 3), (1, 4, 2, 4),
     (2, 3, 1, 3), (2, 3, 1, 4), (2, 3, 2, 3), (2, 3, 2, 4),
     (2, 4, 1, 3), (2, 4, 1, 4), (2, 4, 2, 3), (2, 4, 2, 4)]
    

    combinations(iterable, r) возвращает подпоследовательности длиной r из элементов iterable.

    >>> list(itertools.combinations('123', 2))
    [('1', '2'), ('1', '3'), ('2', '3')]
    >>> list(itertools.combinations('123', 3))
    [('1', '2', '3')]
    >>> list(itertools.combinations('1234', 3))
    [('1', '2', '3'), ('1', '2', '4'),
     ('1', '3', '4'), ('2', '3', '4')]
    

    permutations(iter[, r]) возвращает все перестановки длины r элементов итерации. Если r не указан, по умолчанию будет использоваться количество элементов, созданных итерируемым объектом.

    >>> list(itertools.permutations([1,2,3,4], 2))
    [(1, 2), (1, 3), (1, 4),
     (2, 1), (2, 3), (2, 4),
     (3, 1), (3, 2), (3, 4),
     (4, 1), (4, 2), (4, 3)]
    

    itertools.chain(*iterables) — это существующая функция в itertools, получившая новый конструктор в Python 2.6. itertools.chain.from_iterable(iterable) принимает одну итерацию, которая должна возвращать другие итерации. Затем chain() вернёт все элементы первой итерации, затем все элементы второй и так далее.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    (Предоставлено Георгом Брандлом по предложению Барри Варшавы.)

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

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

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

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

  • Функция os.walk() теперь имеет параметр followlinks. Если установлено значение Истина, он будет следовать символическим ссылкам, указывающим на каталоги, и посещать содержимое каталога. Для обратной совместимости значение параметра по умолчанию равно ложь. Обратите внимание, что функция может попасть в бесконечную рекурсию, если есть символическая ссылка, указывающая на родительский каталог. (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(), которая принимает содержащую пикл строку и удаляет некоторые неиспользуемые коды операций, возвращая более короткий пикл, содержащий ту же структуру данных. (Предоставлено Рэймондом Хеттингером.)

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

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

    (Предоставлено Полом Муром; bpo-2439.)

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

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

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

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

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

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

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

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

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

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

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

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

    (Предоставлено Тареком Зиаде; bpo-2663.)

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

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

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

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

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

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

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

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

  • Модуль socket теперь поддерживает TIPC (сайт), высокопроизводительный протокол, не основанный на 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 при импорте модуля. Если у переменной истинное значение , скомпилированные файлы не записываются. Первоначально переменная устанавливается при запуске путём предоставления переключателя -B интерпретатору Python или путём установки переменной среды PYTHONDONTWRITEBYTECODE перед запуском интерпретатора. Код Python может впоследствии изменить значение этой переменной, чтобы контролировать, записываются ли файлы байт-кода или нет. (Предоставили Нил Норвиц и Георг Брандл.)

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

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

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

  • Модуль tarfile теперь поддерживает tar-файлы POSIX.1-2001 (pax) в дополнение к уже поддерживаемым форматам tar POSIX.1-1988 (ustar) и GNU. Формат по умолчанию — 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 — функцию, которую можно использовать для исключения определенных имён файлов из архива. Функция должна принимать имя файла и возвращать истина, если файл следует исключить, или ложь, если его следует заархивировать. Функция применяется как к имени, изначально переданному в 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://digitology.tech/')
        ...
    

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

    with test_support.check_warnings() as wrec:
        warnings.simplefilter("always")
        # ... код, вызывающий предупреждение ...
        assert str(wrec.message) == "function is outdated"
        assert len(wrec.warnings) == 1, "Multiple warnings raised"
    

    (Предоставлено Бреттом Кэнноном)

  • Модуль textwrap теперь может сохранять существующие пробелы в начале и конце вновь созданных строк, указав drop_whitespace=False в качестве аргумента:

    >>> S = """This  sentence  has a bunch   of
    ...   extra   whitespace."""
    >>> print textwrap.fill(S, width=15)
    This  sentence
    has a bunch
    of    extra
    whitespace.
    >>> print textwrap.fill(S, drop_whitespace=False, width=15)
    This  sentence
      has a bunch
       of    extra
       whitespace.
    >>>
    

    (Предоставлено Дуэйном Бейли; bpo-1581073.)

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

    Объекты Thread модуля threading получили свойство 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)

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

    >>> u = urllib2.urlopen("https://digitology.tech",
                            timeout=3)
    Traceback (most recent call last):
      ...
    urllib2.URLError: <urlopen error timed out>
    >>>
    

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

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

  • formatwarning() и showwarning() модуля warnings получили необязательный аргумент 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; если истина, исключение и отформатированная трассировка возвращаются в виде заголовков HTTP «X-Exception» и «X-Traceback». Данная функция предназначена только для целей отладки и не должна использоваться на рабочих серверах, поскольку обратная трассировка может раскрыть пароли или другую конфиденциальную информацию. (Предоставлено Аланом Макинтайром в рамках его проекта для Google Summer of Code 2007)

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

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

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

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

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

    Наконец, zipfile теперь поддерживает использование имён файлов Юникод для архивных файлов. (Предоставлено Алексеем Борзенковым; 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() вернёт строку Юникод, а 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). JSON — это облегченный формат обмена, часто используемый в веб-приложениях. Дополнительные сведения о JSON см. на странице.

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

>>> import json
>>> data = {"spam": "foo", "parrot": 42}
>>> in_json = json.dumps(data) # Кодировать данные
>>> in_json
'{"parrot": 42, "spam": "foo"}'
>>> json.loads(in_json) # Декодировать в объект Python
{"spam": "foo", "parrot": 42}

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

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

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

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

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

Пользоваться модулем просто:

import sys
import plistlib
import datetime

# Создать структуру данных
data_struct = dict(lastAccessed=datetime.datetime.now(),
                   version=1,
                   categories=('Personal','Shared','Private'))

# Создать строку, содержащую XML.
plist_str = plistlib.writePlistToString(data_struct)
new_struct = plistlib.readPlistFromString(plist_str)
print data_struct
print new_struct

# Записать структуру данных в файл и прочитайть её обратно.
plistlib.writePlist(data_struct, '/tmp/customizations.plist')
new_struct = plistlib.readPlist('/tmp/customizations.plist')

# read/writePlist принимает файловые объекты, а также пути.
plistlib.writePlist(data_struct, sys.stdout)

Усовершенствования 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

Билл Янссен значительно улучшил поддержку 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) Python 3.0 будет включать реорганизованную стандартную библиотеку, в которой будут удалены многие устаревшие модули и переименованы другие. Python 2.6, работающий в режиме предупреждения 3.0, будет предупреждать об данных модулях при их импорте.

    Список устаревших модулей: audiodev, bgenlocations, buildtools, bundlebuilder, Canvas, compiler, dircache, dl, fpformat, gensuitemodule, ihooks, imageop, imgfile, linuxaudiodev, mhlib, mimetools, multifile, new, pure, statvfs, sunaudiodev, test.testall, and 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) или для обеих. (Предоставлено Рональдом Оссореном.)

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

  • Новый интерфейс буфера, ранее описанный в раздел PEP 3118, добавляет 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.)

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

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

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

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

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

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

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

Изменения, относящиеся к порту: 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, отладочные сборки и оптимизацию под управлением профиля (PGO). Сборки PGO примерно на 10% быстрее, чем обычные сборки. (Предоставлено Кристианом Хаймесом с помощью Амори Форжо д«Арк и Мартина фон Лёвиса)

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

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

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

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

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

  • Объект Record модуля msilib получил методы 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, and terminalcommand.

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

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

Портирование на Python 2.6

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

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

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

  • Метод __init__() collections.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) Класс Exception теперь выдает предупреждение при доступе с использованием доступа к срезам или индексам; наличие Exception ведёт себя так, как будто кортеж прекращает свое существование.

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

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

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

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