Что нового в Python 2.4¶What’s New in Python 2.4

PEP 218: Встроенные объекты множеств¶PEP 218: Built-In Set Objects

Python 2.3 представил модуль sets. Теперь в ядро Python добавлены реализации наборов данных на C в виде двух новых встроенных типов, set(iterable) и frozenset(iterable). Они обеспечивают высокоскоростные операции для проверки членства, удаления дубликатов из последовательностей, и для математических операций, таких как объединение, пересечение, разность и симметрическая разность.

>>> a = set('abracadabra')              # Сформировать множество из строки
>>> 'z' in a                            # быстрая проверка принадлежности
False
>>> a                                   # уникальные буквы в a
set(['a', 'r', 'b', 'c', 'd'])
>>> ''.join(a)                          # Преобразовать обратно в строку
'arbcd'

>>> b = set('alacazam')                 # Сформировать второе множество
>>> a - b                               # буквы, которые есть в a, но нет в b
set(['r', 'd', 'b'])
>>> a | b                               # Буквы из a или b
set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])
>>> a & b                               # буквы, которые есть и в a, и в b
set(['a', 'c'])
>>> a ^ b                               # буквы, которые есть в a или в b, но не в обоих
set(['r', 'd', 'b', 'm', 'z', 'l'])

>>> a.add('z')                          # Добавить новый элемент
>>> a.update('wxy')                     # Добавить несколько новых элементов
>>> a
set(['a', 'c', 'b', 'd', 'r', 'w', 'y', 'x', 'z'])
>>> a.remove('x')                       # извлечь один элемент
>>> a
set(['a', 'c', 'b', 'd', 'r', 'w', 'y', 'z'])

Тип frozenset() – это неизменяемая версия set(). Поскольку он неизменяем и хешируем, его можно использовать в качестве ключа словаря или элемента другого множества.

Модуль sets остаётся в стандартной библиотеке и может быть полезен, если вы пожелаете создать подклассы Set или ImmutableSet. В настоящее время нет планов объявлять модуль устаревшим.

PEP 237: Унификация длинных целых и целых чисел¶PEP 237: Unifying Long Integers and Integers

Долгий процесс перехода по этому PEP, начатый в Python 2.2, делает ещё один шаг вперёд в Python 2.4. В 2.3 некоторые целочисленные операции, которые вели бы себя по-разному после унификации int/long, вызывали предупреждения FutureWarning и возвращали значения, ограниченные 32 или 64 битами (в зависимости от платформы). В 2.4 эти выражения больше не выдают предупреждение, а вместо этого возвращают другой результат, обычно длинное целое.

Проблемные выражения – это в основном сдвиги влево и длинные шестнадцатеричные и восьмеричные константы. Например, 2 << 32 в 2.3 вызывает предупреждение, вычисляясь в 0 на 32-битных платформах. В Python 2.4 это выражение теперь возвращает правильный ответ: 8589934592.

PEP 289: Выражения-генераторы¶PEP 289: Generator Expressions

Функция итераторов, введённая в Python 2.2, и модуль itertools облегчают написание программ, которые проходят по большим наборам данных без необходимости держать весь набор данных в памяти одновременно. Списковые включения не очень вписываются в эту картину, поскольку они создают объект списка Python, содержащий все элементы. Это неизбежно загружает все объекты в память, что может быть проблемой, если набор данных очень большой. При попытке написать программу в функциональном стиле естественно написать что-то вроде:

links = [link for link in get_all_links() if not link.followed]
for link in links:
    ...

вместо

for link in get_all_links():
    if link.followed:
        continue
    ...

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

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

links = (link for link in get_all_links() if not link.followed)
for link in links:
    ...

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

print sum(obj.count for obj in list_all_objects())

Выражения-генераторы отличаются от списковых включений в различных мелочах. Наиболее заметно, что переменная цикла (obj в примере выше) недоступна за пределами выражения-генератора. Списковые включения оставляют переменную присвоенной её последнему значению; будущие версии Python изменят это, сделав списковые включения соответствующими выражениям-генераторам в этом отношении.

PEP 292: Более простые подстановки в строках¶PEP 292: Simpler String Substitutions

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

Обычный способ подстановки переменных по имени – оператор %:

>>> '%(page)i: %(title)s' % {'page':2, 'title': 'The Best of Times'}
'2: The Best of Times'

При написании шаблонной строки легко забыть i или s после закрывающей скобки. Это не большая проблема, если шаблон находится в модуле Python, потому что вы запускаете код, получаете «Unsupported format character» ValueError и исправляете проблему. Однако представьте приложение вроде Mailman, где шаблонные строки или переводы редактируются пользователями, которые не знакомы с языком Python. Синтаксис строки формата сложно объяснить таким пользователям, и если они допустят ошибку, сложно дать полезную обратную связь.

PEP 292 добавляет класс Template в модуль string, который использует $ для обозначения подстановки:

>>> import string
>>> t = string.Template('$page: $title')
>>> t.substitute({'page':2, 'title': 'The Best of Times'})
'2: The Best of Times'

Если ключ отсутствует в словаре, метод substitute() вызовет исключение KeyError. Также есть метод safe_substitute(), который игнорирует отсутствующие ключи:

>>> t = string.Template('$page: $title')
>>> t.safe_substitute({'page':3})
'3: $title'

PEP 318: Декораторы функций и методов¶PEP 318: Decorators for Functions and Methods

Python 2.2 расширил объектную модель Python, добавив статические методы и методы класса, но не расширил синтаксис Python, чтобы предоставить новый способ определения статических методов или методов класса. Вместо этого нужно было написать инструкцию def обычным способом и передать полученный метод функции staticmethod() или classmethod(), которая оборачивала функцию как метод нового типа. Код выглядел так:

class C:
   def meth (cls):
       ...

   meth = classmethod(meth)   # перепривязать имя к обёрнутому методу класса

Если метод был очень длинным, было легко пропустить или забыть вызов classmethod() после тела функции.

Всегда предполагалось добавить синтаксис, чтобы сделать такие определения более читаемыми, но на момент выхода 2.2 хороший синтаксис не был очевиден. Сегодня хороший синтаксис всё ещё не очевиден, но пользователи просят более простого доступа к этой возможности; был добавлен новый синтаксический элемент для удовлетворения этой потребности.

Новая возможность называется «декораторы функций». Название происходит от идеи, что classmethod(), staticmethod() и им подобные сохраняют дополнительную информацию в объекте функции; они декорируют функции дополнительными деталями.

Обозначение заимствовано из Java и использует символ '@' как индикатор. С использованием нового синтаксиса приведённый выше пример был бы записан так:

class C:

   @classmethod
   def meth (cls):
       ...

@classmethod – это сокращённая запись для присваивания meth=classmethod(meth). В более общем случае, если есть следующее:

@A
@B
@C
def f ():
    ...

Это эквивалентно следующему коду без декораторов:

def f(): ...
f = A(B(C(f)))

Декораторы должны находиться на строке перед определением функции, по одному декоратору на строку, и не могут быть на той же строке, что и инструкция def, то есть @A def f(): ... недопустимо. Можно декорировать только определения функций, либо на уровне модуля, либо внутри класса; нельзя декорировать определения классов.

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

>>> def deco(func):
...    func.attr = 'decorated'
...    return func
...
>>> @deco
... def f(): pass
...
>>> f
<function f at 0x402ef0d4>
>>> f.attr
'decorated'
>>>

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

def require_int (func):
    def wrapper (arg):
        assert isinstance(arg, int)
        return func(arg)

    return wrapper

@require_int
def p1 (arg):
    print arg

@require_int
def p2(arg):
    print arg*2

Пример в PEP 318 содержит более продвинутую версию этой идеи, которая позволяет как указать требуемый тип, так и проверить возвращаемый тип.

Функции-декораторы могут принимать аргументы. Если аргументы переданы, ваша функция-декоратор вызывается только с этими аргументами и должна вернуть новую функцию-декоратор; эта функция должна принимать одну функцию и возвращать функцию, как описано ранее. Другими словами, @A @B @C(args) превращается в:

def f(): ...
_deco = C(args)
f = A(B(_deco(f)))

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

Небольшое связанное изменение делает атрибут func_name функций доступным для записи. Этот атрибут используется для отображения имён функций в трассировках, поэтому декораторы должны изменять имя любой новой функции, которая создаётся и возвращается.

PEP 322: Обратная итерация¶PEP 322: Reverse Iteration

Новая встроенная функция reversed(seq) принимает последовательность и возвращает итератор, который перебирает элементы последовательности в обратном порядке.

>>> for i in reversed(xrange(1,4)):
...    print i
...
3
2
1

По сравнению с расширенной срезкой, например range(1,4)[::-1], reversed() легче читается, работает быстрее и использует значительно меньше памяти.

Обратите внимание, что reversed() принимает только последовательности, а не произвольные итераторы. Если нужно обратить итератор, сначала преобразуйте его в список с помощью list().

>>> input = open('/etc/passwd', 'r')
>>> for line in reversed(list(input)):
...   print line
...
root:*:0:0:System Administrator:/var/root:/bin/tcsh
  ...

PEP 324: Новый модуль подпроцесс¶PEP 324: New subprocess Module

Стандартная библиотека предоставляет несколько способов выполнения подпроцесса, предлагая разные возможности и разный уровень сложности. os.system(command) прост в использовании, но медленный (он запускает процесс оболочки, который выполняет команду) и опасен (нужно быть осторожным с экранированием метасимволов оболочки). Модуль popen2 предлагает классы, которые могут захватывать стандартный вывод и стандартную ошибку подпроцесса, но названия сбивают с толку. Модуль subprocess исправляет это, предоставляя единый интерфейс, который содержит все необходимые возможности.

Вместо набора классов popen2, subprocess содержит единственный класс subprocess.Popen, конструктор которого поддерживает множество различных именованных аргументов.

class Popen(args, bufsize=0, executable=None,
            stdin=None, stdout=None, stderr=None,
            preexec_fn=None, close_fds=False, shell=False,
            cwd=None, env=None, universal_newlines=False,
            startupinfo=None, creationflags=0):

args обычно представляет собой последовательность строк, которые будут аргументами программы, выполняемой как подпроцесс. (Если аргумент shell равен true, args может быть строкой, которая затем передаётся оболочке для интерпретации, как и в os.system().)

stdin, stdout и stderr определяют, какими будут потоки ввода, вывода и ошибок подпроцесса. Можно передать файловый объект или файловый дескриптор, либо использовать константу subprocess.PIPE для создания канала между подпроцессом и родительским процессом.

Конструктор имеет ряд удобных опций:

• close_fds требует, чтобы все файловые дескрипторы были закрыты перед запуском подпроцесса.

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

• env – это словарь, задающий переменные окружения.

• preexec_fn – это функция, которая вызывается перед запуском дочернего процесса.

• universal_newlines открывает ввод и вывод дочернего процесса с использованием механизма универсальных символов новой строки Python.

После создания экземпляра Popen можно вызвать его метод wait() для ожидания завершения подпроцесса, poll() для проверки, завершился ли он без ожидания, или communicate(data) для отправки строки data на стандартный ввод подпроцесса. communicate(data) затем читает любые данные, отправленные подпроцессом на стандартный вывод или стандартную ошибку, и возвращает кортеж (stdout_data, stderr_data).

call() – это сокращение, которое передаёт свои аргументы конструктору Popen, ожидает завершения команды и возвращает код состояния подпроцесса. Он может служить более безопасным аналогом os.system():

sts = subprocess.call(['dpkg', '-i', '/tmp/new-package.deb'])
if sts == 0:
    # Успех
    ...
else:
    # dpkg вернул ошибку
    ...

Команда вызывается без использования оболочки. Если действительно нужно использовать оболочку, можно добавить shell=True в качестве именованного аргумента и передать строку вместо последовательности:

sts = subprocess.call('dpkg -i /tmp/new-package.deb', shell=True)

В PEP приведены различные примеры кода на shell и Python и показано, как их можно перевести в код Python, использующий subprocess. Настоятельно рекомендуется прочитать этот раздел PEP.

PEP 327: Decimal Data Type¶

Python всегда поддерживал числа с плавающей точкой (FP) как тип данных, основанный на базовом типе C double. Однако, хотя большинство языков программирования предоставляют тип с плавающей точкой, многие люди (даже программисты) не знают, что числа с плавающей точкой не могут точно представлять некоторые десятичные дроби. Новый тип Decimal может точно представлять эти дроби с заданной пользователем точностью.

>>> 1.1
1.1000000000000001

>>> import decimal
>>> decimal.Decimal(1972)
Decimal("1972")
>>> decimal.Decimal("1.1")
Decimal("1.1")

>>> decimal.Decimal((1, (1, 4, 7, 5), -2))
Decimal("-14.75")

>>> f = 1.1
>>> decimal.Decimal(str(f))
Decimal("1.1")
>>> decimal.Decimal('%.12f' % f)
Decimal("1.100000000000")

>>> a = decimal.Decimal('35.72')
>>> b = decimal.Decimal('1.73')
>>> a+b
Decimal("37.45")
>>> a-b
Decimal("33.99")
>>> a*b
Decimal("61.7956")
>>> a/b
Decimal("20.64739884393063583815028902")
>>> a ** 2
Decimal("1275.9184")
>>> a**b
Traceback (most recent call last):
  ...
decimal.InvalidOperation: x ** (non-integer)

>>> a + 4
Decimal("39.72")
>>> a + 4.5
Traceback (most recent call last):
  ...
TypeError: You can interact Decimal only with int, long or Decimal data types.
>>>

>>> import math, cmath
>>> d = decimal.Decimal('123456789012.345')
>>> math.sqrt(d)
351364.18288201344
>>> cmath.sqrt(-d)
351364.18288201344j

>>> d.sqrt()
Decimal("351364.1828820134592177245001")

>>> decimal.getcontext().prec
28
>>> decimal.Decimal(1) / decimal.Decimal(7)
Decimal("0.1428571428571428571428571429")
>>> decimal.getcontext().prec = 9
>>> decimal.Decimal(1) / decimal.Decimal(7)
Decimal("0.142857143")

>>> decimal.Decimal(1) / decimal.Decimal(0)
Traceback (most recent call last):
  ...
decimal.DivisionByZero: x / 0
>>> decimal.getcontext().traps[decimal.DivisionByZero] = False
>>> decimal.Decimal(1) / decimal.Decimal(0)
Decimal("Infinity")
>>>

PEP 328: Многострочные импорты¶PEP 328: Multi-line Imports

Одно из изменений языка – небольшое синтаксическое усовершенствование, направленное на упрощение импорта нескольких имён из модуля. В инструкции from module import names имена представляют собой последовательность имён, разделённых запятыми. Если последовательность очень длинная, можно либо написать несколько инструкций импорта из одного модуля, либо использовать обратную косую черту для переноса строк, например:

from SimpleXMLRPCServer import SimpleXMLRPCServer,\
            SimpleXMLRPCRequestHandler,\
            CGIXMLRPCRequestHandler,\
            resolve_dotted_attribute

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

from SimpleXMLRPCServer import (SimpleXMLRPCServer,
                                SimpleXMLRPCRequestHandler,
                                CGIXMLRPCRequestHandler,
                                resolve_dotted_attribute)

PEP также предлагает, чтобы все инструкции import были абсолютными импортами, с ведущим символом . для указания относительного импорта. Эта часть PEP не была реализована в Python 2.4, но была завершена в Python 2.5.

PEP 331: Преобразования чисел с плавающей запятой/строк, не зависящие от локали¶PEP 331: Locale-Independent Float/String Conversions

Модуль locale позволяет программам на Python выбирать различные преобразования и соглашения отображения, локализованные для определённой страны или языка. Однако модуль старался не изменять числовую локаль, поскольку различные функции в реализации Python требовали, чтобы числовая локаль оставалась установленной на локаль 'C'. Часто это было связано с использованием C-функции atof().

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

Решение, описанное в PEP, заключается в добавлении в Python API трёх новых функций, которые выполняют преобразования только в ASCII, игнорируя настройки локали:

• PyOS_ascii_strtod(str, ptr) и PyOS_ascii_atof(str, ptr) обе преобразуют строку в C double.

• PyOS_ascii_formatd(buffer, buf_len, format, d) преобразует double в строку ASCII.

Код этих функций взят из библиотеки GLib (https://developer-old.gnome.org/glib/2.26/), разработчики которой любезно перелицензировали соответствующие функции и передали их Python Software Foundation. Модуль locale теперь может изменять числовую локаль, что позволяет расширениям, таким как GTK+, давать правильные результаты.

Другие изменения языка¶Other Language Changes

Ниже перечислены все изменения, которые Python 2.4 вносит в ядро языка Python.

• Добавлены декораторы для функций и методов (PEP 318).

• Добавлены встроенные типы set() и frozenset() (PEP 218). Среди других новых встроенных функций – функция reversed(seq) (PEP 322).

• Добавлены генераторные выражения (PEP 289).

• Некоторые числовые выражения больше не возвращают значения, ограниченные 32 или 64 битами (PEP 237).

• Теперь можно заключать список имён в операторе from module import names в круглые скобки (PEP 328).

• Метод dict.update() теперь принимает те же формы аргументов, что и конструктор dict. Сюда входят любое отображение, любой итерируемый объект с парами ключ/значение и именованные аргументы. (Предложено Raymond Hettinger.)

• Строковые методы ljust(), rjust() и center() теперь принимают необязательный аргумент для указания символа заполнения, отличного от пробела. (Предложено Raymond Hettinger.)

• Строки также обзавелись методом rsplit(), который работает как метод split(), но разбивает строку с конца. (Предложено Sean Reifschneider.)

  >>> 'www.python.org'.split('.', 1)
  ['www', 'python.org']
  'www.python.org'.rsplit('.', 1)
  ['www.python', 'org']
  

• Три именованных параметра – cmp, key и reverse – были добавлены к методу sort() списков. Эти параметры упрощают некоторые распространённые случаи использования sort(). Все эти параметры являются необязательными.

  Для параметра cmp значением должна быть функция сравнения, которая принимает два параметра и возвращает -1, 0 или +1 в зависимости от результата сравнения. Затем эта функция будет использоваться для сортировки списка. Ранее это был единственный параметр, который можно было передать в sort().

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

  >>> L = ['A', 'b', 'c', 'D']
  >>> L.sort()                 # сортировка с учётом регистра
  >>> L
  ['A', 'D', 'b', 'c']
  >>> # использование параметра 'key' для сортировки списка
  >>> L.sort(key=lambda x: x.lower())
  >>> L
  ['A', 'b', 'c', 'D']
  >>> # старый способ
  >>> L.sort(cmp=lambda x,y: cmp(x.lower(), y.lower()))
  >>> L
  ['A', 'b', 'c', 'D']
  

  Последний пример, использующий параметр cmp, – это старый способ выполнения сортировки без учёта регистра. Он работает, но медленнее, чем использование параметра key. Использование key вызывает метод lower() один раз для каждого элемента списка, в то время как использование cmp вызывает его дважды для каждого сравнения, поэтому использование key экономит вызовы метода lower().

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

  >>> L.sort(key=str.lower)
  >>> L
  ['A', 'b', 'c', 'D']
  

  Наконец, параметр reverse принимает логическое значение. Если значение истинно, список будет отсортирован в обратном порядке. Вместо L.sort(); L.reverse() теперь можно написать L.sort(reverse=True).

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

  (Все изменения в sort() предложены Raymond Hettinger.)

• Появилась новая встроенная функция sorted(iterable), которая работает как метод list.sort(), изменяющий объект на месте, но может использоваться в выражениях. Отличия:

• входными данными может быть любой итерируемый объект;

• сортируется новосозданная копия, оригинал остаётся нетронутым; и

• выражение возвращает новую отсортированную копию

  >>> L = [9,7,8,3,2,4,1,6,5]
  >>> [10+i for i in sorted(L)]       # можно использовать в списковом включении
  [11, 12, 13, 14, 15, 16, 17, 18, 19]
  >>> L                               # оригинал остаётся неизменным
  [9,7,8,3,2,4,1,6,5]
  >>> sorted('Monty Python')          # любой итерируемый объект может быть входным
  [' ', 'M', 'P', 'h', 'n', 'n', 'o', 'o', 't', 't', 'y', 'y']
  
  >>> # вывести содержимое словаря, отсортированное по ключам
  >>> colormap = dict(red=1, blue=2, green=3, black=4, yellow=5)
  >>> for k, v in sorted(colormap.iteritems()):
  ...     print k, v
  ...
  black 4
  blue 2
  green 3
  red 1
  yellow 5
  

  (Предложено Raymond Hettinger.)

• Целочисленные операции больше не вызывают OverflowWarning. Предупреждение OverflowWarning исчезнет в Python 2.5.

• Интерпретатор получил новый флаг -m, который принимает имя, ищет соответствующий модуль в sys.path и запускает модуль как сценарий. Например, теперь можно запустить профилировщик Python с помощью python -m profile. (Предложено Nick Coghlan.)

• Функции eval(expr, globals, locals) и execfile(filename, globals, locals), а также оператор exec теперь принимают любой тип отображения для параметра locals. Ранее это должен был быть обычный словарь Python. (Предложено Raymond Hettinger.)

• Встроенная функция zip() и itertools.izip() теперь возвращают пустой список, если вызваны без аргументов. Ранее они вызывали исключение TypeError. Это делает их более подходящими для использования со списками аргументов переменной длины:

  >>> def transpose(array):
  ...    return zip(*array)
  ...
  >>> transpose([(1,2,3), (4,5,6)])
  [(1, 4), (2, 5), (3, 6)]
  >>> transpose([])
  []
  

  (Предложено Raymond Hettinger.)

• Сбой при импорте модуля больше не оставляет частично инициализированный объект модуля в sys.modules. Оставленный неполный объект модуля мог ввести в заблуждение последующие импорты того же модуля, заставляя их считаться успешными, что приводило к запутанным ошибкам. (Исправлено Tim Peters.)

• None теперь является константой; код, который присваивает новое значение имени None, теперь вызывает синтаксическую ошибку. (Автор: Raymond Hettinger.)

Новые, улучшенные и устаревшие модули¶New, Improved, and Deprecated Modules

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

• Функция loop() модуля asyncore теперь имеет параметр count, который позволяет выполнить ограниченное количество проходов по циклу опроса. По умолчанию цикл по-прежнему выполняется бесконечно.

• Модуль base64 теперь имеет более полную поддержку RFC 3548 для кодирования и декодирования Base64, Base32 и Base16, включая опциональное преобразование регистра и опциональные альтернативные алфавиты. (Автор: Barry Warsaw.)

• Модуль bisect теперь имеет базовую реализацию на C для улучшения производительности. (Автор: Dmitry Vasiliev.)

• Коллекции восточноазиатских кодеков CJKCodecs, поддерживаемые Hye-Shik Chang, были интегрированы в версию 2.4. Новые кодировки:

• Китай (КНР): gb2312, gbk, gb18030, big5hkscs, hz

• Китай (Тайвань): big5, cp950

• Японский: cp932, euc-jis-2004, euc-jp, euc-jisx0213, iso-2022-jp,

  iso-2022-jp-1, iso-2022-jp-2, iso-2022-jp-3, iso-2022-jp-ext, iso-2022-jp-2004, shift-jis, shift-jisx0213, shift-jis-2004

• Корейский: cp949, euc-kr, johab, iso-2022-kr

• Были добавлены некоторые другие новые кодировки: HP Roman8, ISO_8859-11, ISO_8859-16, PCTP-154 и TIS-620.

• Кодеки UTF-8 и UTF-16 теперь лучше справляются с получением частичных входных данных. Раньше класс StreamReader пытался прочитать больше данных, что делало невозможным возобновление декодирования из потока. Теперь метод read() будет возвращать столько данных, сколько возможно, и последующие вызовы продолжат декодирование с того места, где остановились предыдущие. (Реализовано Walter Dörwald.)

• Появился новый модуль collections для различных специализированных типов коллекций. В настоящее время он содержит только один тип – deque, двустороннюю очередь, которая поддерживает эффективное добавление и удаление элементов с любого конца:

  >>> from collections import deque
  >>> d = deque('ghi')        # создать новый deque с тремя элементами
  >>> d.append('j')           # добавить новый элемент справа
  >>> d.appendleft('f')       # добавить новый элемент слева
  >>> d                       # показать представление deque
  deque(['f', 'g', 'h', 'i', 'j'])
  >>> d.pop()                 # вернуть и удалить правый элемент
  'j'
  >>> d.popleft()             # вернуть и удалить левый элемент
  'f'
  >>> list(d)                 # вывести содержимое deque
  ['g', 'h', 'i']
  >>> 'h' in d                # поиск в deque
  True
  

  Некоторые модули, такие как Queue и threading, теперь используют collections.deque для повышения производительности. (Автор: Raymond Hettinger.)

• Классы ConfigParser были немного улучшены. Метод read() теперь возвращает список файлов, которые были успешно разобраны, а метод set() вызывает исключение TypeError, если ему передан аргумент value, не являющийся строкой. (Авторы: John Belmonte и David Goodger.)

• Модуль curses теперь поддерживает расширение ncurses use_default_colors(). На платформах, где терминал поддерживает прозрачность, это позволяет использовать прозрачный фон. (Автор: Jörg Lehmann.)

• Модуль difflib теперь включает класс HtmlDiff, который создаёт HTML-таблицу с построчным сравнением двух версий текста. (Автор: Dan Gass.)

• Пакет email был обновлён до версии 3.0, в которой удалены различные устаревшие API и прекращена поддержка версий Python ниже 2.3. Версия 3.0 пакета использует новый инкрементальный парсер MIME-сообщений, доступный в модуле email.FeedParser. Новый парсер не требует чтения всего сообщения в память и не вызывает исключений, если сообщение имеет некорректный формат; вместо этого он записывает любые проблемы в атрибут defect сообщения. (Разработан Anthony Baxter, Barry Warsaw, Thomas Wouters и другими.)

• Модуль heapq был переписан на C. Десятикратное повышение скорости делает модуль пригодным для обработки больших объёмов данных. Кроме того, в модуле появились две новые функции nlargest() и nsmallest(), которые используют кучи для поиска N наибольших или наименьших значений в наборе данных без затрат на полную сортировку. (Автор: Raymond Hettinger.)

• Модуль httplib теперь содержит константы для кодов состояния HTTP, определённых в различных RFC, связанных с HTTP. Константы имеют имена, такие как OK, CREATED, CONTINUE и MOVED_PERMANENTLY; для получения полного списка используйте pydoc. (Автор: Andrew Eland.)

• Модуль imaplib теперь поддерживает команду IMAP THREAD (поток) (автор: Yves Dionne) и новые методы deleteacl() и myrights() (автор: Arnaud Mazin).

• В модуле itertools появилась функция groupby(iterable[, *func*]). Итерируемый объект – это то, что можно перебирать для получения потока элементов, а необязательный параметр func – функция, которая принимает элемент и возвращает значение ключа; если он опущен, ключом служит сам элемент. groupby() затем группирует элементы в подпоследовательности с совпадающими значениями ключа и возвращает серию кортежей из двух элементов, содержащих значение ключа и итератор по подпоследовательности.

  Вот пример для наглядности. Функция key просто возвращает, является ли число чётным или нечётным, так что результат groupby() – это последовательные группы нечётных или чётных чисел.

  >>> import itertools
  >>> L = [2, 4, 6, 7, 8, 9, 11, 12, 14]
  >>> for key_val, it in itertools.groupby(L, lambda x: x % 2):
  ...    print key_val, list(it)
  ...
  0 [2, 4, 6]
  1 [7]
  0 [8]
  1 [9, 11]
  0 [12, 14]
  >>>
  

  groupby() обычно используется с отсортированными входными данными. Логика groupby() похожа на фильтр Unix uniq, что удобно для удаления, подсчёта или идентификации дублирующихся элементов:

  >>> word = 'abracadabra'
  >>> letters = sorted(word)   # преобразовать строку в отсортированный список букв
  >>> letters
  ['a', 'a', 'a', 'a', 'a', 'b', 'b', 'c', 'd', 'r', 'r']
  >>> for k, g in itertools.groupby(letters):
  ...    print k, list(g)
  ...
  a ['a', 'a', 'a', 'a', 'a']
  b ['b', 'b']
  c ['c']
  d ['d']
  r ['r', 'r']
  >>> # вывести уникальные буквы
  >>> [k for k, g in groupby(letters)]
  ['a', 'b', 'c', 'd', 'r']
  >>> # подсчитать количество вхождений букв
  >>> [(k, len(list(g))) for k, g in groupby(letters)]
  [('a', 5), ('b', 2), ('c', 1), ('d', 1), ('r', 2)]
  

  (Добавлено Hye-Shik Chang.)

• В модуле itertools также появилась функция tee(iterator, N), которая возвращает N независимых итераторов, копирующих iterator. Если N опущено, по умолчанию используется 2.

  >>> L = [1,2,3]
  >>> i1, i2 = itertools.tee(L)
  >>> i1,i2
  (<itertools.tee object at 0x402c2080>, <itertools.tee object at 0x402c2090>)
  >>> list(i1)               # исчерпать первый итератор
  [1, 2, 3]
  >>> list(i2)               # исчерпать второй итератор
  [1, 2, 3]
  

  Обратите внимание, что tee() вынужден хранить копии значений, возвращаемых итератором; в худшем случае может потребоваться сохранить их все. Поэтому его следует использовать с осторожностью, если ведущий итератор может сильно опережать ведомый в длинной последовательности входных данных. Если разрыв велик, лучше использовать list(). Когда итераторы движутся почти синхронно, tee() идеален. Возможные применения включают итераторы для закладок, оконного просмотра или опережающего чтения. (Добавлено Raymond Hettinger.)

• В модуль locale было добавлено несколько функций, например, bind_textdomain_codeset() для указания конкретной кодировки и семейство функций l*gettext(), возвращающих сообщения в выбранной кодировке. (Добавлено Gustavo Niemeyer.)

• В функцию basicConfig() пакета logging были добавлены некоторые именованные аргументы для упрощения настройки логирования. По умолчанию сообщения выводятся в стандартный поток ошибок, но можно указать различные именованные аргументы, чтобы вести журнал в определённый файл, изменить формат логирования или установить уровень журналирования. Например:

  import logging
  logging.basicConfig(filename='/var/log/application.log',
      level=0,  # записать все сообщения в лог
      format='%(levelname):%(process):%(thread):%(message)')
  

  Другие дополнения пакета logging включают удобный метод log(level, msg), а также класс TimedRotatingFileHandler, который циклически перезаписывает файлы журнала через заданный интервал времени. В модуле уже был RotatingFileHandler, который перезаписывал журналы по достижении файлом определённого размера. Оба класса наследуются от нового класса BaseRotatingHandler, который можно использовать для реализации других обработчиков ротации.

  (Изменения внесены Vinay Sajip.)

• Модуль marshal теперь использует интернированные строки при распаковке структуры данных. Это может уменьшить размер некоторых строк pickle, но основной эффект – значительное уменьшение размера файлов .pyc. (Добавлено Martin von Löwis.)

• Класс NNTP модуля nntplib получил методы description() и descriptions() для получения описаний новостных групп для одной группы или для диапазона групп. (Добавлено Jürgen A. Erhard.)

• В модуль operator были добавлены две новые функции: attrgetter(attr) и itemgetter(index). Обе функции возвращают вызываемые объекты, которые принимают один аргумент и возвращают соответствующий атрибут или элемент; эти вызываемые объекты отлично подходят для извлечения данных при использовании с map() или sorted(). Например:

  >>> L = [('c', 2), ('d', 1), ('a', 4), ('b', 3)]
  >>> map(operator.itemgetter(0), L)
  ['c', 'd', 'a', 'b']
  >>> map(operator.itemgetter(1), L)
  [2, 1, 4, 3]
  >>> sorted(L, key=operator.itemgetter(1)) # отсортировать список по второму элементу кортежа
  [('d', 1), ('c', 2), ('b', 3), ('a', 4)]
  

  (Добавлено Raymond Hettinger.)

• Модуль optparse был обновлён различными способами. Теперь он пропускает свои сообщения через gettext.gettext(), что позволяет интернационализировать справочные сообщения и сообщения об ошибках Optik. В справочные сообщения для параметров теперь можно включать строку '%default', которая будет заменена на значение параметра по умолчанию. (Добавлено Greg Ward.)

• Долгосрочный план – объявить модуль rfc822 устаревшим в одном из будущих релизов Python в пользу пакета email. С этой целью функция email.Utils.formatdate была изменена, чтобы её можно было использовать как замену для rfc822.formatdate(). Возможно, вам стоит писать новый код для обработки электронной почты с учётом этого. (Изменения внесены Anthony Baxter.)

• В модуль os была добавлена новая функция urandom(n), возвращающая строку, содержащую n байт случайных данных. Эта функция предоставляет доступ к платформозависимым источникам случайности, таким как /dev/urandom в Linux или Windows CryptoAPI. (Добавлено Trevor Perrin.)

• Ещё одна новая функция: os.path.lexists(path) возвращает true, если файл, указанный в path, существует, независимо от того, является ли он символической ссылкой. Это отличается от существующей функции os.path.exists(path), которая возвращает false, если path является симлинком, указывающим на несуществующий целевой объект. (Добавлено Beni Cherniavsky.)

• В модуль posix, лежащий в основе модуля os, добавлена новая функция getsid(). (Добавлено J. Raynor.)

• Модуль poplib теперь поддерживает POP через SSL. (Добавлено Hector Urtubia.)

• Модуль profile теперь может профилировать функции-расширения на C. (Добавлено Nick Bastin.)

• В модуле random появился новый метод getrandbits(N), который возвращает длинное целое длиной в N бит. Существующий метод randrange() теперь использует getrandbits() где это уместно, что делает генерацию произвольно больших случайных чисел более эффективной. (Добавлено Raymond Hettinger.)

• Язык регулярных выражений, принимаемый модулем re, был расширен простыми условными выражениями, записываемыми как (?(group)A|B). group – это либо числовой идентификатор группы, либо имя группы, определенное с помощью (?P<group>...) ранее в выражении. Если указанная группа совпала, шаблон регулярного выражения A будет проверяться на строке; если группа не совпала, вместо него будет использоваться шаблон B. (Добавлено Gustavo Niemeyer.)

• Модуль re больше не является рекурсивным, благодаря огромной работе Gustavo Niemeyer. В рекурсивном движке регулярных выражений некоторые шаблоны приводят к потреблению большого объёма памяти в стеке C, и можно было переполнить стек. Например, если сопоставить 30000-байтовую строку из символов a с выражением (a|b)+, расходуется один кадр стека на символ. Python 2.3 пытался проверять переполнение стека и возбуждать исключение RuntimeError, но некоторые шаблоны могли обойти проверку, и при невезении Python мог упасть с segfault. Движок регулярных выражений Python 2.4 может сопоставлять этот шаблон без проблем.

• Модуль signal теперь выполняет более строгую проверку ошибок в параметрах функции signal.signal(). Например, нельзя установить обработчик на сигнал SIGKILL; предыдущие версии Python молча принимали это, но 2.4 возбудит исключение RuntimeError.

• В модуль socket добавлены две новые функции. socketpair() возвращает пару соединённых сокетов, а getservbyport(port) ищет имя службы для заданного номера порта. (Добавлено Dave Cole и Barry Warsaw.)

• Функция sys.exitfunc() объявлена устаревшей. Код должен использовать существующий модуль atexit, который правильно обрабатывает вызов нескольких функций завершения. В конечном итоге sys.exitfunc() станет чисто внутренним интерфейсом, доступным только через atexit.

• Модуль tarfile теперь по умолчанию создаёт tar-файлы в формате GNU. (Добавлено Lars Gustäbel.)

• Модуль threading теперь имеет элегантно простой способ поддержки потоково-локальных данных. Модуль содержит класс local, значения атрибутов которого являются локальными для разных потоков.

  import threading
  
  data = threading.local()
  data.number = 42
  data.url = ('www.python.org', 80)
  

  Другие потоки могут присваивать и получать свои собственные значения для атрибутов number и url. Можно создать подкласс local для инициализации атрибутов или добавления методов. (Добавлено Jim Fulton.)

• Модуль timeit теперь автоматически отключает периодическую сборку мусора во время цикла замеров. Это изменение делает последовательные замеры времени более сопоставимыми. (Добавлено Raymond Hettinger.)

• Модуль weakref теперь поддерживает более широкий спектр объектов, включая функции Python, экземпляры классов, множества, frozenset, deque, массивы, файлы, сокеты и объекты шаблонов регулярных выражений. (Добавлено Raymond Hettinger.)

• Модуль xmlrpclib теперь поддерживает расширение multi-call для передачи нескольких XML-RPC-вызовов в одной HTTP-операции. (Автор: Брайан Куинлан.)

• Модули mpz, rotor и xreadlines были удалены.

def f (x, y):
    """>>> f(2,2)
4
>>> f(3,2)
6
    """
    return x*y

finder = doctest.DocTestFinder()

# получить список экземпляров DocTest
tests = finder.find(f)

runner = doctest.DocTestRunner()
for t in tests:
    tried, failed = runner.run(t)

runner.summarize(verbose=1)

1 items passed all tests:
   2 tests in f
2 tests in 1 items.
2 passed and 0 failed.
Test passed.

def o (n):
    """>>> o(1)
<__main__.C instance at 0x...>
>>>
"""

def p (n):
    """>>> p(1)
<BLANKLINE>
>>>
"""

def g (n):
    """>>> g(4)
здесь
есть
a
длинный
>>>"""
    L = 'here is a rather lengthy list of words'.split()
    for word in L[:n]:
        print word

**********************************************************************
File "t.py", line 15, in g
Failed example:
    g(4)
Differences (unified diff with -expected +actual):
    @@ -2,3 +2,3 @@
     is
     a
    -lengthy
    +rather
**********************************************************************

Изменения в сборке и C API¶Build and C API Changes

Некоторые из изменений в процессе сборки Python и в C API:

• Были добавлены три новых удобных макроса для распространённых возвращаемых значений функций расширений: Py_RETURN_NONE, Py_RETURN_TRUE и Py_RETURN_FALSE. (Автор: Бретт Кэннон.)

• Ещё один новый макрос Py_CLEAR уменьшает счётчик ссылок объекта obj и устанавливает obj в нулевой указатель. (Автор: Джим Фултон.)

• Новая функция PyTuple_Pack(N, obj1, obj2, ..., objN) создаёт кортежи из списка аргументов переменной длины объектов Python. (Автор: Реймонд Хеттингер.)

• Новая функция PyDict_Contains(d, k) реализует быстрый поиск в словаре без маскировки исключений, возникших в процессе поиска. (Автор: Реймонд Хеттингер.)

• Макрос Py_IS_NAN(X) возвращает 1, если его аргумент типа float или double X является NaN. (Автор: Тим Питерс.)

• C-код может избежать ненужной блокировки, используя новую функцию PyEval_ThreadsInitialized(), чтобы узнать, выполнялись ли какие-либо операции с потоками. Если эта функция возвращает false, никакие операции блокировки не требуются. (Автор: Ник Коглан.)

• Новая функция PyArg_VaParseTupleAndKeywords() аналогична PyArg_ParseTupleAndKeywords(), но принимает va_list вместо количества аргументов. (Автор: Грег Чепмен.)

• Новый флаг метода METH_COEXIST позволяет функции, определённой в слотах, сосуществовать с PyCFunction, имеющим то же имя. Это может вдвое сократить время доступа к такому методу, как set.__contains__(). (Автор: Реймонд Хеттингер.)

• Python теперь может быть собран с дополнительным профилированием самого интерпретатора, предназначенным для помощи разработчикам ядра Python. Указание --enable-profiling сценарию configure позволит вам профилировать интерпретатор с помощью gprof, а указание ключа --with-tsc включает профилирование с использованием регистра счётчика временных меток Pentium. Обратите внимание, что ключ --with-tsc назван немного неправильно, поскольку функция профилирования также работает на платформе PowerPC, хотя эта архитектура процессора не называет этот регистр «регистром TSC». (Автор: Джереми Хилтон.)

• Тип tracebackobject был переименован в PyTracebackObject.

Переход на Python 2.4¶Porting to Python 2.4

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

• Сдвиги влево и шестнадцатеричные/восьмеричные константы, которые слишком велики, больше не вызывают FutureWarning и не возвращают значение, ограниченное 32 или 64 битами; вместо этого они возвращают длинное целое число.

• Целочисленные операции больше не будут вызывать OverflowWarning. Предупреждение OverflowWarning исчезнет в Python 2.5.

• Встроенная функция zip() и itertools.izip() теперь возвращают пустой список вместо возбуждения исключения TypeError, если вызваны без аргументов.

• Сравнение экземпляров date и datetime, предоставляемых модулем datetime, больше не допускается. Два экземпляра разных классов теперь всегда будут неравными, а операции относительного сравнения (<, >) будут возбуждать TypeError.

• dircache.listdir() теперь передаёт исключения вызывающему коду вместо возврата пустых списков.

• LexicalHandler.startDTD() раньше получал публичные и системные идентификаторы в неправильном порядке. Это исправлено; приложения, полагающиеся на неправильный порядок, необходимо исправить.

• fcntl.ioctl() теперь выдаёт предупреждение, если аргумент mutate опущен и это имеет значение.

• Модуль tarfile теперь по умолчанию создаёт tar-файлы в формате GNU.

• Ошибка при импорте модуля больше не оставляет частично инициализированный объект модуля в sys.modules.

• None теперь является константой; код, присваивающий новое значение имени None, теперь вызывает синтаксическую ошибку.

• Функция signals.signal() теперь возбуждает исключение RuntimeError для некоторых недопустимых значений; ранее эти ошибки проходили незамеченными. Например, больше нельзя установить обработчик на сигнал SIGKILL.

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

Автор хотел бы поблагодарить следующих людей за предложения, исправления и помощь в работе над различными черновиками этой статьи: Koray Can, Hye-Shik Chang, Michael Dyck, Raymond Hettinger, Brian Hurt, Hamish Lawson, Fredrik Lundh, Sean Reifschneider, Sadruddin Rejeb.