Что нового в Python 2.6¶
- Автор:
А.М. Кучлинг (amk at amk.ca)
В этой статье рассказывается о новых возможностях Python 2.6, выпущенного 1 октября 2008 года. График выпуска описан в PEP 361.
Основной темой Python 2.6 является подготовка к переходу на Python 3.0, который является крупной переработкой языка. По возможности Python 2.6 включает в себя новые возможности и синтаксис из 3.0, сохраняя совместимость с существующим кодом за счет отсутствия удаления старых возможностей или синтаксиса. Когда это невозможно, Python 2.6 пытается сделать все возможное, добавляя функции совместимости в модуль future_builtins
и переключатель -3
, предупреждающий об использовании функций, которые станут неподдерживаемыми в 3.0.
В стандартную библиотеку было добавлено несколько значительных новых пакетов, таких как модули multiprocessing
и json
, но не так уж много новых возможностей, которые не были бы так или иначе связаны с Python 3.0.
В Python 2.6 также внесен ряд улучшений и исправлений по всему исходному коду. Поиск по журналам изменений показывает, что между Python 2.5 и 2.6 было применено 259 исправлений и исправлено 612 ошибок. Обе цифры, скорее всего, занижены.
Эта статья не претендует на полное описание новых возможностей, а представляет собой удобный обзор. За подробной информацией следует обращаться к документации по Python 2.6. Если вы хотите понять обоснование разработки и реализации, обратитесь к PEP для конкретной новой функции. По возможности, в разделе «Что нового в Python» даются ссылки на ошибки/патчи для каждого изменения.
Python 3.0¶
Цикл разработки версий Python 2.6 и 3.0 был синхронизирован, альфа- и бета-релизы обеих версий выходили в одни и те же дни. Разработка 3.0 повлияла на многие функции 2.6.
Python 3.0 - это масштабная переработка Python, которая нарушает совместимость с серией 2.x. Это означает, что существующий код Python придется немного преобразовать, чтобы он мог работать на Python 3.0. Однако не все изменения в 3.0 обязательно нарушают совместимость. В тех случаях, когда новые возможности не приведут к поломке существующего кода, они были перенесены в 2.6 и описаны в этом документе в соответствующем месте. К числу функций, перенесенных в 3.0, относятся:
Метод
__complex__()
для преобразования объектов в комплексное число.Альтернативный синтаксис для перехвата исключений:
except TypeError as exc
.Добавление
functools.reduce()
в качестве синонима встроенной функцииreduce()
.
В Python 3.0 добавлено несколько новых встроенных функций и изменена семантика некоторых существующих встроенных модулей. Новые функции 3.0, такие как bin()
, были просто добавлены в Python 2.6, но существующие встроенные функции не были изменены; вместо этого модуль future_builtins
имеет версии с новой семантикой 3.0. Код, написанный для совместимости с 3.0, может использовать from future_builtins import hex, map
по мере необходимости.
Новый переключатель командной строки, -3
, включает предупреждения о функциях, которые будут удалены в Python 3.0. Вы можете запустить код с этим переключателем, чтобы узнать, сколько работы потребуется для переноса кода в 3.0. Значение этого переключателя доступно для кода Python в виде булевой переменной sys.py3kwarning
, а для кода расширения C - в виде Py_Py3kWarningFlag
.
Изменения в процессе разработки¶
Во время разработки 2.6 процесс разработки Python претерпел два значительных изменения: мы перешли с трекера проблем SourceForge на адаптированную установку Roundup, а документация была переведена с LaTeX на reStructuredText.
Трекер новых выпусков: Раунд-ап¶
В течение долгого времени разработчиков Python все больше раздражал багтрекер SourceForge. Размещенное на хостинге SourceForge решение не позволяет многое настраивать, например, нельзя было настроить жизненный цикл проблем.
Поэтому инфраструктурный комитет Python Software Foundation опубликовал объявление о поиске трекеров проблем, попросив добровольцев создать различные продукты и импортировать некоторые ошибки и исправления с SourceForge. Было рассмотрено четыре различных трекера: Jira, Launchpad, Roundup и Trac. В итоге комитет остановился на Jira и Roundup как на двух кандидатах. Jira - это коммерческий продукт, который предлагает бесплатные хостинги для свободно распространяемых проектов; Roundup - это проект с открытым исходным кодом, который требует добровольцев для его администрирования и сервера для его размещения.
После публикации призыва к добровольцам новая установка Roundup была установлена на https://bugs.python.org. Одна установка Roundup может содержать несколько трекеров, и сейчас на этом сервере также размещены трекеры проблем для Jython и для веб-сайта Python. В будущем ему наверняка найдут и другое применение. По возможности, в этом выпуске «Что нового в Python» для каждого изменения дается ссылка на ошибку/патч.
Хостинг баг-трекера Python любезно предоставлен Upfront Systems из Стелленбоша, Южная Африка. Мартин фон Лёвис приложил много усилий для импорта существующих ошибок и патчей с SourceForge; его скрипты для этой операции импорта находятся на https://svn.python.org/view/tracker/importer/
и могут быть полезны другим проектам, желающим перейти с SourceForge на Roundup.
См.также
- https://bugs.python.org
Трекер ошибок Python.
- https://bugs.jython.org:
Трекер ошибок Jython.
- https://roundup.sourceforge.io/
Загрузка и документация по Roundup.
- https://svn.python.org/view/tracker/importer/
Скрипты преобразования Мартина фон Лёвиса.
Новый формат документации: reStructuredText с использованием Sphinx¶
Документация по Python была написана с использованием LaTeX с момента начала проекта примерно в 1989 году. В 1980-х и начале 1990-х годов большинство документации распечатывалось для последующего изучения, а не просматривалось онлайн. LaTeX широко использовался, потому что он обеспечивал привлекательный печатный результат, оставаясь при этом простым в написании после изучения основных правил разметки.
Сегодня LaTeX все еще используется для написания публикаций, предназначенных для печати, но ландшафт для инструментов программирования изменился. Мы больше не распечатываем пачки документации, вместо этого мы просматриваем ее в Интернете, и HTML стал самым важным форматом для поддержки. К сожалению, преобразование LaTeX в HTML довольно сложно, и Фред Л. Дрейк-младший, многолетний редактор документации Python, потратил много времени на поддержание процесса преобразования. Время от времени люди предлагали перевести документацию в SGML, а затем в XML, но качественное преобразование - это серьезная задача, и никто никогда не выделял время, необходимое для завершения работы.
Во время разработки 2.6 Георг Брандл приложил много усилий для создания новой цепочки инструментов для обработки документации. Получившийся пакет называется Sphinx и доступен по адресу https://www.sphinx-doc.org/.
Sphinx концентрируется на выводе HTML, создавая привлекательный и современный HTML; печатный вывод по-прежнему поддерживается через преобразование в LaTeX. Входной формат - reStructuredText, синтаксис разметки с поддержкой пользовательских расширений и директив, широко используемый в сообществе Python.
Sphinx - это отдельный пакет, который можно использовать для написания документов, и почти два десятка других проектов (listed on the Sphinx web site) приняли Sphinx в качестве инструмента для создания документации.
См.также
- Documenting Python
Описывает, как писать для Python документацию.
- Sphinx
Документация и код для инструментария Sphinx.
- Docutils
Основной парсер и набор инструментов для работы с reStructuredText.
PEP 343: Утверждение „с“¶
В предыдущей версии, Python 2.5, оператор „with
был добавлен как необязательная функция, которую можно было включить директивой from __future__ import with_statement
. В версии 2.6 это утверждение больше не нужно специально включать; это означает, что with
теперь всегда является ключевым словом. Остальная часть этого раздела является копией соответствующего раздела из документа «Что нового в Python 2.5»; если вы знакомы с оператором „with
из Python 2.5, то можете пропустить этот раздел.
Утверждение „with
“ уточняет код, который ранее использовал блоки try...finally
для обеспечения выполнения кода очистки. В этом разделе я расскажу об утверждении в том виде, в котором оно обычно используется. В следующем разделе я рассмотрю детали реализации и покажу, как писать объекты для использования этого оператора.
Оператор „with
“ представляет собой структуру потока управления, базовой структурой которой является:
with expression [as variable]:
with-block
Выражение оценивается, и в результате должен получиться объект, поддерживающий протокол управления контекстом (то есть имеющий методы __enter__()
и __exit__()
).
Функция __enter__()
объекта вызывается до выполнения with-block и поэтому может выполнять код установки. Он также может вернуть значение, связанное с именем переменной, если оно задано. (Обратите внимание, что переменная не присваивается результату выражения).
После завершения выполнения with-блока вызывается метод __exit__()
объекта, даже если блок вызвал исключение, и, следовательно, может быть запущен код очистки.
Некоторые стандартные объекты Python теперь поддерживают протокол управления контекстом и могут быть использованы с помощью оператора „with
“. Одним из примеров являются файловые объекты:
with open('/etc/passwd', 'r') as f:
for line in f:
print line
... more processing code ...
После выполнения этого оператора объект файла в f будет автоматически закрыт, даже если цикл for
вызвал исключение на полпути к блоку.
Примечание
В данном случае f - это тот же объект, созданный open()
, потому что __enter__()
возвращает self.
Блокировки и переменные условия модуля threading
также поддерживают оператор „with
:
lock = threading.Lock()
with lock:
# Critical section of code
...
Блокировка приобретается перед выполнением блока и всегда освобождается после его завершения.
Функция localcontext()
в модуле decimal
позволяет легко сохранять и восстанавливать текущий десятичный контекст, который включает в себя желаемую точность и характеристики округления для вычислений:
from decimal import Decimal, Context, localcontext
# Displays with default precision of 28 digits
v = Decimal('578')
print v.sqrt()
with localcontext(Context(prec=16)):
# All code in this block uses a precision of 16 digits.
# The original context is restored on exiting the block.
print v.sqrt()
Написание контекстных менеджеров¶
Под капотом оператор „with
довольно сложен. Большинство людей будут использовать „with
только в сочетании с существующими объектами, и им не нужно знать эти детали, поэтому вы можете пропустить остальную часть этого раздела, если хотите. Авторам новых объектов потребуется разобраться в деталях базовой реализации, и им следует продолжить чтение.
Высокоуровневое объяснение протокола управления контекстом таково:
Выражение оценивается, и в результате должен появиться объект, называемый «менеджером контекста». Менеджер контекста должен иметь методы
__enter__()
и__exit__()
.Вызывается метод
__enter__()
менеджера контекста. Возвращенное значение присваивается VAR. Если отсутствует предложениеas VAR
, значение просто отбрасывается.Выполняется код в BLOCK.
Если BLOCK поднимает исключение, вызывается метод
__exit__()
контекстного менеджера с тремя аргументами - деталями исключения (type, value, traceback
, те же значения, возвращаемыеsys.exc_info()
, которые также могут бытьNone
, если исключение не произошло). Возвращаемое значение метода контролирует, будет ли исключение повторно поднято: любое ложное значение повторно поднимает исключение, аTrue
приведет к его подавлению. Подавлять исключение нужно очень редко, потому что в этом случае автор кода, содержащего оператор „with
, никогда не поймет, что что-то пошло не так.Если BLOCK не вызвал исключения, метод
__exit__()
по-прежнему вызывается, но type, value и traceback становятсяNone
.
Давайте подумаем на примере. Я не буду приводить подробный код, а лишь набросаю методы, необходимые для базы данных, поддерживающей транзакции.
(Для людей, незнакомых с терминологией баз данных: набор изменений в базе данных объединяется в транзакцию. Транзакции могут быть либо зафиксированы, что означает запись всех изменений в базу данных, либо откачены, что означает отмену всех изменений и сохранение базы данных без изменений. Более подробную информацию можно найти в любом учебнике по базам данных).
Предположим, что есть объект, представляющий соединение с базой данных. Наша цель - позволить пользователю написать код, подобный этому:
db_connection = DatabaseConnection()
with db_connection as cursor:
cursor.execute('insert into ...')
cursor.execute('delete from ...')
# ... more operations ...
Транзакция должна быть зафиксирована, если код в блоке работает безупречно, или откачена, если возникло исключение. Вот базовый интерфейс для DatabaseConnection
, который я предполагаю:
class DatabaseConnection:
# Database interface
def cursor(self):
"Returns a cursor object and starts a new transaction"
def commit(self):
"Commits current transaction"
def rollback(self):
"Rolls back current transaction"
Метод __enter__()
довольно прост, нужно только начать новую транзакцию. Для данного приложения результирующий объект курсора будет полезным результатом, поэтому метод вернет его. Затем пользователь может добавить as cursor
к своему оператору „with
, чтобы привязать курсор к имени переменной.
class DatabaseConnection:
...
def __enter__(self):
# Code to start a new transaction
cursor = self.cursor()
return cursor
Метод __exit__()
является самым сложным, потому что именно в нем выполняется большая часть работы. Метод должен проверить, не произошло ли исключение. Если исключения не было, транзакция фиксируется. Если исключение имело место, транзакция откатывается.
В приведенном ниже коде выполнение просто отвалится в конец функции, вернув значение по умолчанию None
. None
равно false, поэтому исключение будет вызвано автоматически. При желании вы можете быть более явными и добавить оператор return
в отмеченное место.
class DatabaseConnection:
...
def __exit__(self, type, value, tb):
if tb is None:
# No exception, so commit
self.commit()
else:
# Exception occurred, so rollback.
self.rollback()
# return False
Модуль contextlib¶
Модуль contextlib
предоставляет несколько функций и декоратор, которые полезны при написании объектов для использования с оператором „with
“.
Декоратор называется contextmanager()
и позволяет написать одну функцию-генератор вместо того, чтобы определять новый класс. Генератор должен выдавать ровно одно значение. Код до yield
будет выполнен как метод __enter__()
, а полученное значение будет возвращенным значением метода, которое будет привязано к переменной в предложении as
оператора „with
, если таковое имеется. Код после yield
будет выполнен в методе __exit__()
. Любое исключение, возникшее в блоке, будет вызвано оператором yield
.
Используя этот декоратор, наш пример с базой данных из предыдущего раздела можно записать так:
from contextlib import contextmanager
@contextmanager
def db_transaction(connection):
cursor = connection.cursor()
try:
yield cursor
except:
connection.rollback()
raise
else:
connection.commit()
db = DatabaseConnection()
with db_transaction(db) as cursor:
...
В модуле contextlib
также есть функция nested(mgr1, mgr2, ...)
, которая объединяет несколько менеджеров контекста, что избавляет вас от необходимости писать вложенные операторы „with
. В этом примере один оператор „with
одновременно запускает транзакцию базы данных и получает блокировку потока:
lock = threading.Lock()
with nested (db_transaction(db), lock) as (cursor, locked):
...
Наконец, функция closing()
возвращает свой аргумент, чтобы его можно было привязать к переменной, и вызывает метод .close()
аргумента в конце блока.
import urllib, sys
from contextlib import closing
with closing(urllib.urlopen('http://www.yahoo.com')) as f:
for line in f:
sys.stdout.write(line)
См.также
- PEP 343 - Утверждение «с»
PEP, написанный Гвидо ван Россумом и Ником Когланом; реализованный Майком Бландом, Гвидо ван Россумом и Нилом Норвицем. PEP показывает код, генерируемый для оператора „
with
“, что может быть полезно для изучения работы этого оператора.
Документация для модуля contextlib
.
PEP 366: Явный относительный импорт из главного модуля¶
Переключатель -m
в Python позволяет запускать модуль как скрипт. Когда вы запускали модуль, который находился внутри пакета, относительный импорт работал некорректно.
Исправление для Python 2.6 добавляет атрибут __package__
к модулям. Когда этот атрибут присутствует, относительный импорт будет относиться к значению этого атрибута, а не к атрибуту __name__
.
Импортеры в стиле PEP 302 могут устанавливать __package__
по мере необходимости. Модуль runpy
, реализующий переключатель -m
, теперь делает это, так что относительный импорт теперь будет корректно работать в скриптах, запускаемых изнутри пакета.
PEP 370: Однопользовательский site-packages
Каталог¶
Когда вы запускаете Python, путь поиска модулей sys.path
обычно включает каталог, путь к которому заканчивается на "site-packages"
. Этот каталог предназначен для хранения локально установленных пакетов, доступных всем пользователям, использующим машину или установку на конкретном сайте.
В Python 2.6 введена конвенция для пользовательских каталогов сайтов. Каталог зависит от платформы:
Unix и Mac OS X:
~/.local/
Windows:
%APPDATA%/Python
Внутри этого каталога будут подкаталоги, зависящие от версии, например lib/python2.6/site-packages
на Unix/Mac OS и Python26/site-packages
на Windows.
Если вам не нравится каталог по умолчанию, его можно переопределить с помощью переменной окружения. PYTHONUSERBASE
задает корневой каталог, используемый для всех версий Python, поддерживающих эту функцию. В Windows каталог для данных, специфичных для приложения, можно изменить, установив переменную окружения APPDATA
. Вы также можете изменить файл site.py
для вашей установки Python.
Эту функцию можно полностью отключить, запустив Python с параметром -s
или установив переменную окружения PYTHONNOUSERSITE
.
См.также
- PEP 370 - На одного пользователя
site-packages
Каталог PEP написан и реализован Кристианом Хаймсом.
PEP 371: The multiprocessing
Пакет¶
Новый пакет multiprocessing
позволяет программам Python создавать новые процессы, которые будут выполнять вычисления и возвращать результат родительскому процессу. Родительский и дочерний процессы могут взаимодействовать с помощью очередей и труб, синхронизировать свои операции с помощью блокировок и семафоров, а также совместно использовать простые массивы данных.
Модуль multiprocessing
начинался как точная эмуляция модуля threading
с использованием процессов вместо потоков. Эта цель была отброшена на пути к Python 2.6, но общий подход модуля все еще схож. Основополагающим классом является Process
, которому передается вызываемый объект и набор аргументов. Метод start()
устанавливает выполнение вызываемого объекта в подпроцессе, после чего можно вызвать метод is_alive()
, чтобы проверить, запущен ли еще подпроцесс, и метод join()
, чтобы дождаться завершения процесса.
Вот простой пример, в котором подпроцесс вычисляет факториал. Функция, выполняющая вычисления, написана странным образом, так что она занимает значительно больше времени, если входной аргумент кратен 4.
import time
from multiprocessing import Process, Queue
def factorial(queue, N):
"Compute a factorial."
# If N is a multiple of 4, this function will take much longer.
if (N % 4) == 0:
time.sleep(.05 * N/4)
# Calculate the result
fact = 1L
for i in range(1, N+1):
fact = fact * i
# Put the result on the queue
queue.put(fact)
if __name__ == '__main__':
queue = Queue()
N = 5
p = Process(target=factorial, args=(queue, N))
p.start()
p.join()
result = queue.get()
print 'Factorial', N, '=', result
Объект Queue
используется для передачи результата факториала. Объект Queue
хранится в глобальной переменной. В дочернем процессе будет использоваться значение переменной, которое было в момент создания дочернего процесса; поскольку это Queue
, родитель и ребенок могут использовать этот объект для связи. (Если родитель изменит значение глобальной переменной, значение дочернего объекта не изменится, и наоборот).
Два других класса, Pool
и Manager
, предоставляют интерфейсы более высокого уровня. Pool
создает фиксированное количество рабочих процессов, а запросы можно распределять между ними, вызывая apply()
или apply_async()
для добавления одного запроса и map()
или map_async()
для добавления нескольких запросов. Следующий код использует Pool
для распределения запросов между 5 рабочими процессами и получения списка результатов:
from multiprocessing import Pool
def factorial(N, dictionary):
"Compute a factorial."
...
p = Pool(5)
result = p.map(factorial, range(1, 1000, 10))
for v in result:
print v
Это дает следующий результат:
1
39916800
51090942171709440000
8222838654177922817725562880000000
33452526613163807108170062053440751665152000000000
...
Другой высокоуровневый интерфейс, класс Manager
, создает отдельный серверный процесс, который может хранить основные копии структур данных Python. Другие процессы могут обращаться к этим структурам данных и изменять их с помощью прокси-объектов. В следующем примере создается общий словарь путем вызова метода dict()
; рабочие процессы затем вставляют значения в словарь. (Блокировка не выполняется автоматически, что в данном примере не имеет значения. Методы Manager
также включают Lock()
, RLock()
и Semaphore()
для создания общих блокировок.)
import time
from multiprocessing import Pool, Manager
def factorial(N, dictionary):
"Compute a factorial."
# Calculate the result
fact = 1L
for i in range(1, N+1):
fact = fact * i
# Store result in dictionary
dictionary[N] = fact
if __name__ == '__main__':
p = Pool(5)
mgr = Manager()
d = mgr.dict() # Create shared dictionary
# Run tasks using the pool
for N in range(1, 1000, 10):
p.apply_async(factorial, (N, d))
# Mark pool as closed -- no more tasks can be added.
p.close()
# Wait for tasks to exit
p.join()
# Output results
for k, v in sorted(d.items()):
print k, v
Это приведет к выводу:
1 1
11 39916800
21 51090942171709440000
31 8222838654177922817725562880000000
41 33452526613163807108170062053440751665152000000000
51 15511187532873822802242430164693032110632597200169861120000...
См.также
Документация для модуля multiprocessing
.
- PEP 371 - Добавление пакета многопроцессорной обработки
PEP написан Джесси Ноллером и Ричардом Оудкерком; реализован Ричардом Оудкерком и Джесси Ноллером.
PEP 3101: Расширенное форматирование строк¶
В Python 3.0 оператор %
дополнен более мощным методом форматирования строк, format()
. Поддержка метода str.format()
была перенесена в Python 2.6.
В 2.6 для 8-битных и Unicode-строк есть метод .format()
, который рассматривает строку как шаблон и принимает аргументы для форматирования. Шаблон форматирования использует фигурные скобки ({
, }
) в качестве специальных символов:
>>> # Substitute positional argument 0 into the string.
>>> "User ID: {0}".format("root")
'User ID: root'
>>> # Use the named keyword arguments
>>> "User ID: {uid} Last seen: {last_login}".format(
... uid="root",
... last_login = "5 Mar 2008 07:20")
'User ID: root Last seen: 5 Mar 2008 07:20'
Фигурные скобки можно снять, удвоив их:
>>> "Empty dict: {{}}".format()
"Empty dict: {}"
Имена полей могут быть целыми числами, обозначающими позиционные аргументы, такие как {0}
, {1}
и т. д., или именами аргументов ключевых слов. Вы также можете задать составные имена полей, которые считывают атрибуты или обращаются к ключам словаря:
>>> import sys
>>> print 'Platform: {0.platform}\nPython version: {0.version}'.format(sys)
Platform: darwin
Python version: 2.6a1+ (trunk:61261M, Mar 5 2008, 20:29:41)
[GCC 4.0.1 (Apple Computer, Inc. build 5367)]'
>>> import mimetypes
>>> 'Content-type: {0[.mp4]}'.format(mimetypes.types_map)
'Content-type: video/mp4'
Обратите внимание, что при использовании обозначений в словарном стиле, например [.mp4]
, не нужно ставить кавычки вокруг строки; она будет искать значение, используя .mp4
в качестве ключа. Строки, начинающиеся с цифры, будут преобразованы в целое число. Внутри строки формата нельзя писать более сложные выражения.
До сих пор мы показывали, как указать, какое поле подставлять в результирующую строку. Точное форматирование также можно контролировать, добавляя двоеточие, за которым следует спецификатор формата. Например:
>>> # Field 0: left justify, pad to 15 characters
>>> # Field 1: right justify, pad to 6 characters
>>> fmt = '{0:15} ${1:>6}'
>>> fmt.format('Registration', 35)
'Registration $ 35'
>>> fmt.format('Tutorial', 50)
'Tutorial $ 50'
>>> fmt.format('Banquet', 125)
'Banquet $ 125'
Спецификаторы формата могут ссылаться на другие поля с помощью вложенности:
>>> fmt = '{0:{1}}'
>>> width = 15
>>> fmt.format('Invoice #1234', width)
'Invoice #1234 '
>>> width = 35
>>> fmt.format('Invoice #1234', width)
'Invoice #1234 '
Можно задать выравнивание поля по ширине:
Персонаж |
Эффект |
---|---|
< (по умолчанию) |
Выравнивание по левому краю |
> |
Выравнивание по правому краю |
^ |
Центр |
= |
(Только для цифровых типов) Запятая после знака. |
Спецификаторы формата могут также включать тип представления, который управляет тем, как отформатировано значение. Например, числа с плавающей точкой могут быть представлены в виде общего числа или в экспоненциальной нотации:
>>> '{0:g}'.format(3.75)
'3.75'
>>> '{0:e}'.format(3.75)
'3.750000e+00'
Доступны различные типы представления. Обратитесь к документации по версии 2.6, чтобы узнать, что такое complete list; вот пример:
|
Двоичный. Выводит число по основанию 2. |
|
Символ. Преобразует целое число в соответствующий символ Unicode перед печатью. |
|
Десятичное целое число. Выводит число по основанию 10. |
|
Октальный формат. Выводит число по основанию 8. |
|
Шестнадцатеричный формат. Выводит число по основанию 16, используя строчные буквы для цифр больше 9. |
|
Выражение в виде экспоненты. Выводит число в научной нотации, используя букву „e“ для обозначения экспоненты. |
|
Общий формат. Выводит число в виде числа с фиксированной точкой, если только число не слишком велико, в этом случае оно переключается на нотацию с экспонентой „e“. |
|
Число. Это то же самое, что и „g“ (для плавающих чисел) или „d“ (для целых чисел), за исключением того, что для вставки соответствующих символов-разделителей чисел используется текущая настройка локали. |
|
Процент. Умножает число на 100 и отображает его в фиксированном формате («f»), за которым следует знак процента. |
Классы и типы могут определить метод __format__()
для управления их форматированием. Он принимает единственный аргумент - спецификатор формата:
def __format__(self, format_spec):
if isinstance(format_spec, unicode):
return unicode(str(self))
else:
return str(self)
Существует также встроенный модуль format()
, который форматирует одно значение. Он вызывает метод __format__()
типа с указанным спецификатором:
>>> format(75.6564, '.2f')
'75.66'
См.также
- Синтаксис строки форматирования
Справочная документация по полям формата.
- PEP 3101 - Расширенное форматирование строк
PEP, написанный Талином. Реализован Эриком Смитом.
PEP 3105: print
Как функция¶
Оператор print
становится функцией print()
в Python 3.0. Если сделать print()
функцией, то можно заменить функцию, выполнив def print(...)
или импортировав новую функцию из другого места.
В Python 2.6 есть импорт __future__
, который удаляет print
из синтаксиса языка, позволяя вам использовать функциональную форму вместо этого. Например:
>>> from __future__ import print_function
>>> print('# of entries', len(dictionary), file=sys.stderr)
Сигнатура новой функции выглядит так:
def print(*args, sep=' ', end='\n', file=None)
Параметры следующие:
args: позиционные аргументы, значения которых будут выведены.
sep: разделитель, который будет выведен между аргументами.
end: завершающий текст, который будет выведен после вывода всех аргументов.
file: объект файла, в который будет отправлен вывод.
См.также
- PEP 3105 - Сделайте печать функцией
PEP написан Георгом Брандлом.
PEP 3110: Изменения в обработке исключений¶
Одна из ошибок, которую иногда допускают программисты на Python, - это написание следующего кода:
try:
...
except TypeError, ValueError: # Wrong!
...
Автор, вероятно, пытается перехватить оба исключения TypeError
и ValueError
, но на самом деле этот код делает нечто другое: он перехватит TypeError
и привяжет полученный объект исключения к локальному имени "ValueError"
. Исключение ValueError
не будет поймано вообще. Правильный код задает кортеж исключений:
try:
...
except (TypeError, ValueError):
...
Эта ошибка возникает потому, что использование запятой здесь неоднозначно: указывает ли она на два разных узла в дереве разбора или на один узел, который является кортежем?
Python 3.0 делает это однозначно, заменяя запятую на слово «как». Чтобы поймать исключение и сохранить объект исключения в переменной exc
, вы должны написать:
try:
...
except TypeError as exc:
...
Python 3.0 поддерживает только использование «as», и поэтому первый пример интерпретируется как перехват двух разных исключений. Python 2.6 поддерживает и запятую, и «as», поэтому существующий код будет продолжать работать. Поэтому мы рекомендуем использовать «as» при написании нового кода на Python, который будет выполняться только в версии 2.6.
См.также
- PEP 3110 - Ловля исключений в Python 3000
PEP написан и реализован Коллином Винтером.
PEP 3112: Литералы байтов¶
Python 3.0 принимает Unicode в качестве основного строкового типа языка и обозначает 8-битные литералы по-разному: либо как b'string'
, либо с помощью конструктора bytes
. Для будущей совместимости Python 2.6 добавляет bytes
в качестве синонима для типа str
, а также поддерживает нотацию b''
.
Тип str
в 2.6 отличается от типа bytes
в 3.0 различными способами; прежде всего, полностью отличается конструктор. В 3.0 bytes([65, 66, 67])
имеет длину 3 элемента и содержит байты, представляющие ABC
; в 2.6 bytes([65, 66, 67])
возвращает 12-байтовую строку, представляющую str()
списка.
Основное использование bytes
в 2.6 будет заключаться в написании тестов объектного типа, таких как isinstance(x, bytes)
. Это поможет конвертеру 2to3, который не может определить, в каком коде 2.x строки должны содержать символы или 8-битные байты; теперь вы можете использовать bytes
или str
, чтобы точно выразить свое намерение, и полученный код будет корректен и в Python 3.0.
Существует также импорт __future__
, который заставляет все строковые литералы становиться строками Юникода. Это означает, что для включения символов Юникода можно использовать управляющие последовательности \u
:
from __future__ import unicode_literals
s = ('\u751f\u3080\u304e\u3000\u751f\u3054'
'\u3081\u3000\u751f\u305f\u307e\u3054')
print len(s) # 12 Unicode characters
На уровне языка Си в Python 3.0 существующий 8-битный тип строки, называемый в Python 2.x PyStringObject
, будет переименован в PyBytesObject
. Python 2.6 использует #define
для поддержки использования имен PyBytesObject()
, PyBytes_Check()
, PyBytes_FromStringAndSize()
и всех других функций и макросов, используемых со строками.
Экземпляры типа bytes
неизменяемы, как и строки. Новый тип bytearray
хранит изменяемую последовательность байтов:
>>> bytearray([65, 66, 67])
bytearray(b'ABC')
>>> b = bytearray(u'\u21ef\u3244', 'utf-8')
>>> b
bytearray(b'\xe2\x87\xaf\xe3\x89\x84')
>>> b[0] = '\xe3'
>>> b
bytearray(b'\xe3\x87\xaf\xe3\x89\x84')
>>> unicode(str(b), 'utf-8')
u'\u31ef \u3244'
Байтовые массивы поддерживают большинство методов строковых типов, таких как startswith()
/endswith()
, find()
/rfind()
, и некоторые методы списков, такие как append()
, pop()
и reverse()
.
>>> b = bytearray('ABC')
>>> b.append('d')
>>> b.append(ord('e'))
>>> b
bytearray(b'ABCde')
Существует также соответствующий API на языке C, с функциями PyByteArray_FromObject()
, PyByteArray_FromStringAndSize()
и различными другими.
См.также
- PEP 3112 - Литералы байтов в Python 3000
PEP написан Джейсоном Орендорффом; бэкпортирован в 2.6 Кристианом Хаймсом.
PEP 3116: Новая библиотека ввода/вывода¶
Встроенные файловые объекты Python поддерживают ряд методов, но файлоподобные объекты не обязательно поддерживают все из них. Объекты, имитирующие файлы, обычно поддерживают read()
и write()
, но могут не поддерживать, например, readline()
. В Python 3.0 появилась многоуровневая библиотека ввода-вывода в модуле io
, которая отделяет функции буферизации и работы с текстом от основных операций чтения и записи.
Существует три уровня абстрактных базовых классов, предоставляемых модулем io
:
RawIOBase
определяет необработанные операции ввода-вывода:read()
,readinto()
,write()
,seek()
,tell()
,truncate()
иclose()
. Большинство методов этого класса часто отображаются на один системный вызов. Также существуют методыreadable()
,writable()
иseekable()
для определения того, какие операции разрешены данному объекту.В Python 3.0 есть конкретные реализации этого класса для файлов и сокетов, но Python 2.6 не реструктурировал свои объекты файлов и сокетов подобным образом.
BufferedIOBase
- это абстрактный базовый класс, который буферизирует данные в памяти, чтобы уменьшить количество используемых системных вызовов и сделать обработку ввода-вывода более эффективной. Он поддерживает все методыRawIOBase
и добавляет атрибутraw
, содержащий базовый необработанный объект.Существует пять конкретных классов, реализующих этот ABC.
BufferedWriter
иBufferedReader
предназначены для объектов, которые поддерживают использование только для записи или только для чтения и имеют методseek()
для произвольного доступа. ОбъектыBufferedRandom
поддерживают доступ на чтение и запись к одному и тому же базовому потоку, аBufferedRWPair
предназначен для таких объектов, как TTY, у которых есть операции чтения и записи, действующие на несвязанные потоки данных. КлассBytesIO
поддерживает чтение, запись и поиск по буферу в памяти.TextIOBase
: Предоставляет функции для чтения и записи строк (помните, что в Python 3.0 строки будут в Unicode), а также поддерживает universal newlines.TextIOBase
определяет методreadline()
и поддерживает итерацию объектов.Существует две конкретные реализации.
TextIOWrapper
оборачивает объект буферизованного ввода-вывода, поддерживая все методы для текстового ввода-вывода и добавляя атрибутbuffer
для доступа к базовому объекту.StringIO
просто буферизирует все в памяти, никогда не записывая ничего на диск.(В Python 2.6 модуль
io.StringIO
реализован на чистом Python, поэтому он довольно медленный. Поэтому пока вам следует придерживаться существующего модуляStringIO
илиcStringIO
. В какой-то момент модульio
в Python 3.0 будет переписан на C для повышения скорости, и, возможно, реализация на C будет перенесена в релизы 2.x).
В Python 2.6 базовые реализации не были реструктурированы для построения поверх классов модуля io
. Модуль предоставляется для того, чтобы облегчить написание кода, совместимого с версией 3.0, и избавить разработчиков от необходимости писать собственные реализации буферизации и ввода-вывода текста.
См.также
- PEP 3116 - Новый ввод/вывод
PEP написан Даниэлем Штутцбахом, Майком Вердоне и Гвидо ван Россумом. Код от Гвидо ван Россума, Георга Брандла, Вальтера Доервальда, Джереми Хилтона, Мартина фон Лёвиса, Тони Лоундса и других.
PEP 3118: Пересмотренный протокол буферов¶
Буферный протокол - это API на уровне C, позволяющий типам Python обмениваться указателями на свои внутренние представления. Например, файл, отображаемый в памяти, можно рассматривать как буфер символов, что позволяет другому модулю, например re
, рассматривать файлы, отображаемые в памяти, как строку символов для поиска.
Основными пользователями буферного протокола являются пакеты для обработки чисел, такие как NumPy, которые раскрывают внутреннее представление массивов, чтобы пользователи могли записывать данные непосредственно в массив, а не через более медленный API. Этот PEP обновляет буферный протокол с учетом опыта разработки NumPy, добавляя ряд новых возможностей, таких как указание формы массива или блокировка области памяти.
Наиболее важной новой функцией C API является PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags)
, которая принимает объект и набор флагов и заполняет структуру Py_buffer
информацией о представлении памяти объекта. Объекты могут использовать эту операцию для фиксации памяти на месте, в то время как внешний пользователь может изменять ее содержимое, поэтому существует соответствующая PyBuffer_Release(Py_buffer *view)
, указывающая, что внешний пользователь закончил.
Аргумент flags в PyObject_GetBuffer()
задает ограничения на возвращаемую память. Некоторые примеры:
PyBUF_WRITABLE
указывает, что память должна быть доступна для записи.PyBUF_LOCK
запрашивает блокировку памяти только для чтения или эксклюзивную блокировку.PyBUF_C_CONTIGUOUS
иPyBUF_F_CONTIGUOUS
запрашивает компоновку массива на языке C (последняя размерность изменяется быстрее всего) или Fortran (первая размерность изменяется быстрее всего).
Два новых кода аргументов PyArg_ParseTuple()
, s*
и z*
возвращают заблокированные объекты буфера для параметра.
См.также
- PEP 3118 - Пересмотр протокола буферизации
PEP написан Трэвисом Олифантом и Карлом Бэнксом; реализован Трэвисом Олифантом.
PEP 3119: Абстрактные базовые классы¶
Некоторые объектно-ориентированные языки, такие как Java, поддерживают интерфейсы, объявляя, что класс имеет определенный набор методов или поддерживает определенный протокол доступа. Абстрактные базовые классы (или ABC) - это эквивалентная возможность для Python. Поддержка ABC состоит из модуля abc
, содержащего метакласс ABCMeta
, специальной обработки этого метакласса встроенными модулями isinstance()
и issubclass()
, а также коллекции базовых ABC, которые, по мнению разработчиков Python, будут широко полезны. В будущих версиях Python, возможно, будут добавлены новые ABC.
Допустим, у вас есть определенный класс, и вы хотите узнать, поддерживает ли он доступ в стиле словаря. Фраза «в стиле словаря», однако, расплывчата. Вероятно, она означает, что доступ к элементам с obj[1]
работает. Означает ли она, что установка элементов с obj[2] = value
работает? Или что у объекта будут методы keys()
, values()
и items()
? А как насчет итеративных вариантов, таких как iterkeys()
? copy()
и update()
? Итерация над объектом с помощью iter()
?
Модуль Python 2.6 collections
включает в себя несколько различных азбук, которые представляют эти различия. Iterable
означает, что класс определяет __iter__()
, а Container
означает, что класс определяет __contains__()
метод и поэтому поддерживает x in y
выражения. Базовый интерфейс словаря, включающий получение элементов, установку элементов и keys()
, values()
и items()
, определяется MutableMapping
. ABC.
Вы можете создавать свои собственные классы на основе определенного ABC, чтобы указать, что они поддерживают интерфейс этого ABC:
import collections
class Storage(collections.MutableMapping):
...
В качестве альтернативы можно написать класс, не производя его от нужного ABC, и вместо этого зарегистрировать класс, вызвав метод register()
ABC:
import collections
class Storage:
...
collections.MutableMapping.register(Storage)
Для классов, которые вы пишете сами, производные от ABC, вероятно, более понятны. Метод register()
полезен, когда вы написали новый ABC, который может описывать существующий тип или класс, или если вы хотите объявить, что какой-то сторонний класс реализует ABC. Например, если вы определили PrintableType
ABC, то можно сделать следующее:
# Register Python's types
PrintableType.register(int)
PrintableType.register(float)
PrintableType.register(str)
Классы должны подчиняться семантике, указанной в ABC, но Python не может проверить это; автор класса должен понять требования ABC и реализовать код соответствующим образом.
Чтобы проверить, поддерживает ли объект определенный интерфейс, теперь можно написать:
def func(d):
if not isinstance(d, collections.MutableMapping):
raise ValueError("Mapping object expected, not %r" % d)
Не думайте, что теперь вы должны начать писать множество проверок, как в примере выше. В Python сильна традиция duck-typing, когда явная проверка типов никогда не выполняется, а код просто вызывает методы объекта, полагаясь на то, что эти методы будут там, и поднимая исключение, если их там нет. Будьте благоразумны в проверке ABC и делайте это только там, где это абсолютно необходимо.
Вы можете написать свой собственный ABC, используя abc.ABCMeta
в качестве метакласса в определении класса:
from abc import ABCMeta, abstractmethod
class Drawable():
__metaclass__ = ABCMeta
@abstractmethod
def draw(self, x, y, scale=1.0):
pass
def draw_doubled(self, x, y):
self.draw(x, y, scale=2.0)
class Square(Drawable):
def draw(self, x, y, scale):
...
В примере Drawable
В приведенном выше ABC метод draw_doubled()
отображает объект в два раза большего размера и может быть реализован в терминах других методов, описанных в Drawable
. Поэтому классам, реализующим этот ABC, не нужно предоставлять собственную реализацию draw_doubled()
, хотя они могут это сделать. Однако реализация draw()
необходима; ABC не может предоставить полезную общую реализацию.
Вы можете применить декоратор @abstractmethod
к таким методам, как draw()
, которые должны быть реализованы; тогда Python вызовет исключение для классов, не определивших метод. Обратите внимание, что исключение будет вызвано только тогда, когда вы попытаетесь создать экземпляр подкласса, в котором отсутствует метод:
>>> class Circle(Drawable):
... pass
...
>>> c = Circle()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class Circle with abstract methods draw
>>>
Атрибуты абстрактных данных могут быть объявлены с помощью декоратора @abstractproperty
:
from abc import abstractproperty
...
@abstractproperty
def readonly(self):
return self._x
После этого подклассы должны определить свойство readonly()
.
См.также
- PEP 3119 - Представляем абстрактные базовые классы
PEP, написанный Гвидо ван Россумом и Талином. Реализован Гвидо ван Россумом. Бэкпортирован в 2.6 Бенджамином Арангуреном при участии Алекса Мартелли.
PEP 3127: Поддержка целочисленных литералов и синтаксис¶
В Python 3.0 изменен синтаксис для восьмеричных (base-8) целых литералов: вместо ведущего нуля им присваивается префикс «0o» или «0O», а также добавлена поддержка двоичных (base-2) целых литералов, обозначаемых префиксом «0b» или «0B».
Python 2.6 не отказался от поддержки ведущего 0, обозначающего восьмеричное число, но добавил поддержку «0o» и «0b»:
>>> 0o21, 2*8 + 1
(17, 17)
>>> 0b101111
47
Встроенный модуль oct()
по-прежнему возвращает числа с ведущим нулем, а новый встроенный модуль bin()
возвращает двоичное представление числа:
>>> oct(42)
'052'
>>> future_builtins.oct(42)
'0o52'
>>> bin(173)
'0b10101101'
Встроенные модули int()
и long()
теперь будут принимать префиксы «0o» и «0b», когда запрашивается base-8 или base-2, или когда аргумент base равен нулю (сигнализируя, что используемое основание должно быть определено из строки):
>>> int ('0o52', 0)
42
>>> int('1101', 2)
13
>>> int('0b1101', 2)
13
>>> int('0b1101', 0)
13
См.также
- PEP 3127 - Поддержка и синтаксис целочисленных литералов
PEP, написанный Патриком Мопином; бэкпортирован в 2.6 Эриком Смитом.
PEP 3129: Декораторы классов¶
Декораторы были расширены от функций до классов. Теперь можно писать:
@foo
@bar
class A:
pass
Это эквивалентно:
class A:
pass
A = foo(bar(A))
См.также
- PEP 3129 - Декораторы классов
PEP написан Коллином Уинтером.
PEP 3141: Иерархия типов для чисел¶
В Python 3.0 добавлено несколько абстрактных базовых классов для числовых типов, вдохновленных числовой башней Scheme. Эти классы были перенесены в 2.6 в виде модуля numbers
.
Самым общим ABC является Number
. Она не определяет никаких операций и существует только для того, чтобы можно было проверить, является ли объект числом, выполнив isinstance(obj, Number)
.
Complex
является подклассом Number
. С комплексными числами можно выполнять основные операции сложения, вычитания, умножения, деления и экспоненции, а также извлекать действительную и мнимую части и получать сопряженное число. Встроенный в Python тип complex является реализацией Complex
.
Real
далее происходит от Complex
и добавляет операции, которые работают только с вещественными числами: floor()
, trunc()
, округление, взятие остатка mod N, поэтажное деление и сравнение.
Числа Rational
происходят от Real
, обладают свойствами numerator
и denominator
и могут быть преобразованы к плавающим числам. В Python 2.6 добавлен простой класс рациональных чисел Fraction
в модуле fractions
. (Он называется Fraction
вместо Rational
, чтобы избежать столкновения имен с numbers.Rational
).
Числа Integral
происходят от Rational
, их можно сдвигать влево и вправо с помощью <<
и >>
, объединять с помощью побитовых операций &
и |
, использовать в качестве индексов массивов и границ фрагментов.
В Python 3.0 PEP немного переопределяет существующие встроенные модули round()
, math.floor()
, math.ceil()
и добавляет новый, math.trunc()
, который был перенесен в Python 2.6. math.trunc()
округляет в сторону нуля, возвращая ближайший Integral
, который находится между аргументом функции и нулем.
Модуль fractions
Модуль¶
Модуль fractions
Модуль
Модуль Fraction
Модуль
>>> from fractions import Fraction
>>> a = Fraction(2, 3)
>>> b = Fraction(2, 5)
>>> float(a), float(b)
(0.66666666666666663, 0.40000000000000002)
>>> a+b
Fraction(16, 15)
>>> a/b
Fraction(5, 3)
Модуль as_integer_ratio()
Модуль
>>> (2.5) .as_integer_ratio()
(5, 2)
>>> (3.1415) .as_integer_ratio()
(7074029114692207L, 2251799813685248L)
>>> (1./3) .as_integer_ratio()
(6004799503160661L, 18014398509481984L)
Обратите внимание, что значения, которые можно аппроксимировать только числами с плавающей точкой, например 1,/3, не упрощаются до аппроксимируемого числа; дробь пытается соответствовать значению с плавающей точкой точно.
Модуль fractions
Модуль
Другие языковые изменения¶
Некоторые более мелкие изменения, внесенные в ядро языка Python:
Каталоги и zip-архивы, содержащие
__main__.py
файл, теперь можно выполнять напрямую, передавая их имя интерпретатору. Каталог или zip-архив автоматически вставляется в качестве первой записи в sys.path. (Предложение и первоначальный патч Энди Чу, впоследствии исправленный Филлипом Дж. Эби и Ником Когланом; bpo-1739468).Функция
hasattr()
ловила и игнорировала все ошибки, полагая, что они означают, что метод__getattr__()
каким-то образом не сработал, и поэтому возвращаемое значениеhasattr()
будетFalse
. Однако эту логику не следует применять кKeyboardInterrupt
иSystemExit
; Python 2.6 больше не будет отбрасывать такие исключения, когдаhasattr()
встречает их. (Исправлено Бенджамином Петерсоном; bpo-2196).При вызове функции, использующей синтаксис
**
для указания аргументов в виде ключевых слов, больше не требуется использовать словарь Python; теперь подойдет любое отображение:>>> def f(**kw): ... print sorted(kw) ... >>> ud=UserDict.UserDict() >>> ud['a'] = 1 >>> ud['b'] = 'string' >>> f(**ud) ['a', 'b']
(Внесено Александром Белопольским; bpo-1686487)
Также стало законным предоставлять аргументы ключевых слов после аргумента
*args
в вызове функции.>>> def f(*args, **kw): ... print args, kw ... >>> f(1,2,3, *(4,5,6), keyword=13) (1, 2, 3, 4, 5, 6) {'keyword': 13}
Раньше это было бы синтаксической ошибкой. (Внесено Amaury Forgeot d’Arc; bpo-3473).
Новый встроенный модуль
next(iterator, [default])
возвращает следующий элемент из указанного итератора. Если указан аргумент default, то он будет возвращен, если iterator был исчерпан; в противном случае будет вызвано исключениеStopIteration
. (Перенесено в bpo-2719).Кортежи теперь имеют методы
index()
иcount()
, соответствующие методамindex()
иcount()
типа list:>>> t = (0,1,2,3,4,0,1,2) >>> t.index(3) 3 >>> t.count(0) 2
(Предоставлено Раймондом Хеттингером)
Встроенные типы теперь имеют улучшенную поддержку расширенного синтаксиса нарезки, принимая различные комбинации
(start, stop, step)
. Ранее поддержка была частичной, и некоторые угловые случаи не работали. (Реализовано Томасом Воутерсом).У свойств теперь есть три атрибута,
getter
,setter
иdeleter
, которые представляют собой декораторы, обеспечивающие удобное сокращение для добавления функции getter, setter или deleter к существующему свойству. Вы можете использовать их следующим образом:class C(object): @property def x(self): return self._x @x.setter def x(self, value): self._x = value @x.deleter def x(self): del self._x class D(C): @C.x.getter def x(self): return self._x * 2 @x.setter def x(self, value): self._x = value / 2
Некоторые методы встроенных типов множеств теперь принимают несколько итераций:
intersection()
,intersection_update()
,union()
,update()
,difference()
иdifference_update()
.>>> s=set('1234567890') >>> s.intersection('abc123', 'cdf246') # Intersection between all inputs set(['2']) >>> s.difference('246', '789') set(['1', '0', '3', '5'])
(Предоставлено Раймондом Хеттингером.)
Добавлено множество функций для работы с плавающей точкой. Функция
float()
теперь превращает строкуnan
в значение IEEE 754 Not A Number, а+inf
и-inf
- в положительную или отрицательную бесконечность. Это работает на любой платформе с семантикой IEEE 754. (Вклад Кристиана Хаймса; bpo-1635).Другие функции модуля
math
,isinf()
иisnan()
, возвращают true, если их аргумент с плавающей точкой бесконечен или не является числом. (bpo-1640)Добавлены функции преобразования чисел с плавающей точкой в шестнадцатеричные строки (bpo-3008). Эти функции преобразуют плавающие числа в строковое представление и обратно, не допуская ошибок округления при преобразовании десятичных чисел в двоичные. У плавающих чисел есть метод
hex()
, который возвращает строковое представление, а методfloat.fromhex()
преобразует строку обратно в число:>>> a = 3.75 >>> a.hex() '0x1.e000000000000p+1' >>> float.fromhex('0x1.e000000000000p+1') 3.75 >>> b=1./3 >>> b.hex() '0x1.5555555555555p-2'
Числовая тонкость: при создании комплексного числа из двух float в системах, поддерживающих знаковые нули (-0 и +0), конструктор
complex()
теперь сохраняет знак нуля. (Исправлено Марком Т. Дикинсоном; bpo-1507).Классы, наследующие метод
__hash__()
от родительского класса, могут установить__hash__ = None
, чтобы указать, что класс не является хэшируемым. В результатеhash(obj)
подниметTypeError
, и класс не будет указан как реализующийHashable
. ABC.Это нужно делать, если вы определили метод
__cmp__()
или__eq__()
, который сравнивает объекты по их значению, а не по идентичности. Все объекты имеют хэш-метод по умолчанию, который используетid(obj)
в качестве хэш-значения. Не существует аккуратного способа удалить метод__hash__()
, унаследованный от родительского класса, поэтому присвоениеNone
было реализовано в виде переопределения. На уровне C расширения могут устанавливатьtp_hash
вPyObject_HashNotImplemented()
. (Исправлено Ником Когланом и Амори Форжо д’Арк; bpo-2235).Исключение
GeneratorExit
теперь подклассифицируетBaseException
, а неException
. Это означает, что обработчик исключений, выполняющийexcept Exception:
, не перехватит случайноGeneratorExit
. (Внесено Чадом Остином; bpo-1537).Объекты-генераторы теперь имеют атрибут
gi_code
, который ссылается на объект исходного кода, поддерживающий генератор. (Внесено Коллином Винтером; bpo-1473257).Встроенная функция
compile()
теперь принимает аргументы в виде ключевых слов, а также позиционные параметры. (Внесено Томасом Воутерсом; bpo-1444529).Конструктор
complex()
теперь принимает строки, содержащие комплексные числа в круглых скобках, что означает, чтоcomplex(repr(cplx))
теперь будет округлять значения. Например,complex('(3+4j)')
теперь возвращает значение (3+4j). (bpo-1491866)Метод string
translate()
теперь принимает в качестве параметра таблицы трансляцииNone
, которая рассматривается как преобразование тождества. Это упрощает выполнение операций, в которых удаляются только символы. (Внесено Бенгтом Рихтером и реализовано Раймондом Хеттингером; bpo-1193128).Встроенная функция
dir()
теперь проверяет наличие метода__dir__()
у получаемых объектов. Этот метод должен возвращать список строк, содержащих имена допустимых атрибутов объекта, и позволяет объекту управлять значением, которое выдаетdir()
. Объекты, у которых есть методы__getattr__()
или__getattribute__()
, могут использовать этот метод для объявления псевдоатрибутов, которые они будут соблюдать. (bpo-1591665)У объектов метода экземпляра появились новые атрибуты для объекта и функции, входящих в метод; новым синонимом для
im_self
стал__self__
, аim_func
также доступен как__func__
. Старые имена все еще поддерживаются в Python 2.6, но в 3.0 их уже нет.Непонятное изменение: когда вы используете функцию
locals()
внутри оператораclass
, результирующий словарь больше не возвращает свободные переменные. (Свободные переменные в данном случае - это переменные, на которые ссылается операторclass
и которые не являются атрибутами класса).
Оптимизации¶
Модуль
warnings
был переписан на C. Это позволяет вызывать предупреждения из парсера, а также может ускорить запуск интерпретатора. (Внесено Нилом Норвицем и Бреттом Кэнноном; bpo-1631171).Объекты типов теперь имеют кэш методов, что позволяет сократить трудозатраты на поиск правильной реализации метода для конкретного класса; после создания кэша интерпретатору не нужно обходить базовые классы, чтобы найти нужный метод для вызова. Кэш очищается при изменении базового класса или самого класса, поэтому кэш должен оставаться корректным даже в условиях динамичности Python. (Оригинальная оптимизация реализована Армином Риго, обновлена для Python 2.6 Кевином Джейкобсом; bpo-1700288).
По умолчанию это изменение применяется только к типам, входящим в состав ядра Python. Модули расширений могут быть несовместимы с этим кэшем, поэтому они должны явно добавить
Py_TPFLAGS_HAVE_VERSION_TAG
к полюtp_flags
модуля, чтобы включить кэш методов. (Чтобы быть совместимым с кэшем методов, код модуля расширения не должен напрямую обращаться и изменять членtp_dict
ни одного из реализуемых им типов. Большинство модулей этого не делают, но интерпретатор Python не может этого определить. См. bpo-1878 для некоторого обсуждения).Вызовы функций, использующих аргументы в виде ключевых слов, значительно ускоряются за счет быстрого сравнения указателей, что обычно экономит время полного сравнения строк. (Внесено Раймондом Хеттингером, после первоначальной реализации Антуаном Питру; bpo-1819).
Все функции в модуле
struct
были переписаны на C благодаря работе на спринте Need For Speed. (Внесено Раймондом Хеттингером).Некоторые стандартные встроенные типы теперь задают бит в своих объектах типа. Это ускоряет проверку того, является ли объект подклассом одного из этих типов. (Внесено Нилом Норвицем).
Строки Unicode теперь используют более быстрый код для определения пробельных символов и переносов строк; это ускоряет метод
split()
примерно на 25 %, аsplitlines()
- на 35 %. (Вклад Антуана Питру.) Использование памяти уменьшено за счет использования pymalloc для данных строки Unicode.Оператор
with
теперь сохраняет метод__exit__()
в стеке, что дает небольшое ускорение. (Реализовано Джеффри Ясскином).Чтобы сократить потребление памяти, сборщик мусора теперь очищает внутренние списки свободных объектов при сборке объектов самого высокого поколения. Это позволяет быстрее возвращать память операционной системе.
Изменения в работе переводчика¶
Два параметра командной строки были зарезервированы для использования в других реализациях Python. Переключатель -J
был зарезервирован для использования в Jython для специфических для Jython опций, таких как переключатели, передаваемые базовой JVM. Переключатель -X
был зарезервирован для опций, специфичных для конкретной реализации Python, таких как CPython, Jython или IronPython. Если одна из этих опций используется в Python 2.6, интерпретатор сообщит, что в настоящее время эта опция не используется.
Теперь можно запретить Python записывать файлы .pyc
или .pyo
, установив переключатель -B
в интерпретаторе Python или задав переменную окружения PYTHONDONTWRITEBYTECODE
перед запуском интерпретатора. Эта настройка доступна программам Python в виде переменной sys.dont_write_bytecode
, и код Python может изменять ее значение, чтобы модифицировать поведение интерпретатора. (При участии Нила Норвица и Георга Брандла).
Кодировку, используемую для стандартного ввода, вывода и стандартной ошибки, можно задать, установив переменную окружения PYTHONIOENCODING
перед запуском интерпретатора. Значение должно представлять собой строку в виде <encoding>
или <encoding>:<errorhandler>
. Часть encoding указывает имя кодировки, например, utf-8
или latin-1
; необязательная часть errorhandler указывает, что делать с символами, которые не могут быть обработаны кодировкой, и должна быть одной из «error», «ignore» или «replace». (Внесено Мартином фон Лёвисом).
Новые и улучшенные модули¶
Как и в каждом выпуске, стандартная библиотека Python получила ряд улучшений и исправлений ошибок. Здесь представлен неполный список наиболее заметных изменений, отсортированный в алфавитном порядке по имени модуля. За более полным списком изменений обратитесь к файлу Misc/NEWS
в дереве исходных текстов или просмотрите журналы Subversion, чтобы узнать все подробности.
Модули
asyncore
иasynchat
снова активно поддерживаются, и в них было внесено несколько исправлений и ошибок. (Поддерживается Джосайей Карлсоном; один патч см. в bpo-1736190).У модуля
bsddb
также появился новый сопровождающий, Хесус Сеа Авион, а сам пакет теперь доступен в виде отдельного пакета. Веб-страница пакета находится по адресу www.jcea.es/programacion/pybsddb.htm. Планируется удалить пакет из стандартной библиотеки в Python 3.0, так как темпы его выпуска гораздо выше, чем у Python.Модуль
bsddb.dbshelve
теперь использует самый высокий из доступных протоколов травления, вместо того чтобы ограничиваться протоколом 1. (Внесено В. Барнсом).Модуль
cgi
теперь будет считывать переменные из строки запроса HTTP POST. Это позволяет использовать действия формы с URL, содержащими такие строки запроса, как «/cgi-bin/add.py?category=1». (Вклад Александра Фиори и Nubis; bpo-1817).Функции
parse_qs()
иparse_qsl()
были перенесены из модуляcgi
в модульurlparse
. Версии, все еще доступные в модулеcgi
, будут вызывать сообщенияPendingDeprecationWarning
в версии 2.6 (bpo-600362).Модуль
cmath
подвергся обширной переработке, в которой приняли участие Марк Дикинсон и Кристиан Хаймс. Было добавлено пять новых функций:polar()
преобразует комплексное число в полярную форму, возвращая модуль и аргумент комплексного числа.rect()
делает обратное, превращая пару модуль-аргумент обратно в соответствующее комплексное число.phase()
возвращает аргумент (также называемый углом) комплексного числа.isnan()
возвращает True, если действительная или мнимая часть его аргумента равна NaN.isinf()
возвращает True, если действительная или мнимая часть его аргумента бесконечна.
Изменения также улучшили числовую надежность модуля
cmath
. Для всех функций действительная и мнимая части результатов по возможности точны до нескольких единиц наименьшей точности (ulps). Подробности см. в bpo-1381. Также были исправлены разрезы ветвей дляasinh()
,atanh()
иatan()
.Тесты для модуля были значительно расширены; почти 2000 новых тестовых примеров отрабатывают алгебраические функции.
На платформах IEEE 754 модуль
cmath
теперь обрабатывает специальные значения IEEE 754 и исключения с плавающей точкой в соответствии с приложением „G“ стандарта C99.Новый тип данных в модуле
collections
:namedtuple(typename, fieldnames)
- это фабричная функция, создающая подклассы стандартного кортежа, поля которого доступны как по имени, так и по индексу. Например:>>> var_type = collections.namedtuple('variable', ... 'id name type size') >>> # Names are separated by spaces or commas. >>> # 'id, name, type, size' would also work. >>> var_type._fields ('id', 'name', 'type', 'size') >>> var = var_type(1, 'frequency', 'int', 4) >>> print var[0], var.id # Equivalent 1 1 >>> print var[2], var.type # Equivalent int int >>> var._asdict() {'size': 4, 'type': 'int', 'id': 1, 'name': 'frequency'} >>> v2 = var._replace(name='amplitude') >>> v2 variable(id=1, name='amplitude', type='int', size=4)
Несколько мест в стандартной библиотеке, которые возвращали кортежи, были изменены, чтобы возвращать экземпляры
namedtuple()
. Например, методDecimal.as_tuple()
теперь возвращает именованный кортеж с полямиsign
,digits
иexponent
.(Предоставлено Раймондом Хеттингером.)
Еще одно изменение в модуле
collections
- типdeque
теперь поддерживает необязательный параметр maxlen; если он указан, размер deque будет ограничен не более чем maxlen элементов. Добавление новых элементов в заполненный deque приводит к отбрасыванию старых элементов.>>> from collections import deque >>> dq=deque(maxlen=3) >>> dq deque([], maxlen=3) >>> dq.append(1); dq.append(2); dq.append(3) >>> dq deque([1, 2, 3], maxlen=3) >>> dq.append(4) >>> dq deque([2, 3, 4], maxlen=3)
(Предоставлено Раймондом Хеттингером.)
Объекты
Cookie
модуляMorsel
теперь поддерживают атрибутhttponly
. В некоторых браузерах файлы cookie с этим атрибутом не могут быть доступны или управляться кодом JavaScript. (Внесено Арвином Шнеллом; bpo-1638033).Новый метод окна в модуле
curses
,chgat()
, изменяет атрибуты отображения для определенного количества символов в одной строке. (Внесено Фабианом Кройцем.)# Boldface text starting at y=0,x=21 # and affecting the rest of the line. stdscr.chgat(0, 21, curses.A_BOLD)
Класс
Textbox
в модулеcurses.textpad
теперь поддерживает редактирование в режиме вставки, а также в режиме перезаписи. Режим вставки включается путем задания значения true для параметра insert_mode при создании экземпляраTextbox
.Методы
datetime
модуляstrftime()
теперь поддерживают код формата%f
, который расширяется до количества микросекунд в объекте, с нулевым добавлением слева до шести мест. (Внесено Скипом Монтанаро; bpo-1158).Модуль
decimal
был обновлен до версии 1.66 the General Decimal Specification. Среди новых возможностей - методы для некоторых базовых математических функций, таких какexp()
иlog10()
:>>> Decimal(1).exp() Decimal("2.718281828459045235360287471") >>> Decimal("2.7182818").ln() Decimal("0.9999999895305022877376682436") >>> Decimal(1000).log10() Decimal("3")
Метод
as_tuple()
объектовDecimal
теперь возвращает именованный кортеж с полямиsign
,digits
иexponent
.(Реализовано Факундо Батистой и Марком Дикинсоном. Поддержка именованных кортежей добавлена Раймондом Хеттингером).
Класс
difflib
модуляSequenceMatcher
теперь возвращает именованные кортежи, представляющие совпадения, с атрибутамиa
,b
иsize
. (Вклад Раймонда Хеттингера.)В конструктор класса
ftplib.FTP
и методconnect()
был добавлен необязательный параметрtimeout
, задающий таймаут, измеряемый в секундах. (Добавлено Факундо Батистой.) Кроме того, методыstorbinary()
иstorlines()
классаFTP
теперь принимают необязательный параметр callback, который будет вызываться с каждым блоком данных после их отправки. (Внесено Филом Шварцем; bpo-1221598).Встроенная функция
reduce()
также доступна в модулеfunctools
. В Python 3.0 встроенная функция была отменена, иreduce()
доступна только изfunctools
; в настоящее время не планируется отменять встроенную функцию в серии 2.x. (Исправлено Кристианом Хаймсом; bpo-1739906).Когда это возможно, модуль
getpass
теперь будет использовать/dev/tty
для печати сообщения подсказки и чтения пароля, возвращаясь к стандартной ошибке и стандартному вводу. Если пароль может быть передан эхом на терминал, то перед выводом подсказки будет напечатано предупреждение. (Внесено Грегори П. Смитом).Функция
glob.glob()
теперь может возвращать имена файлов в Юникоде, если использовался путь в Юникоде и в каталоге встречаются имена файлов в Юникоде. (bpo-1001604)Новая функция в модуле
heapq
,merge(iter1, iter2, ...)
, принимает любое количество итераторов, возвращающих данные в отсортированном порядке, и возвращает новый генератор, который возвращает содержимое всех итераторов, также в отсортированном порядке. Например:>>> list(heapq.merge([1, 3, 5, 9], [2, 8, 16])) [1, 2, 3, 5, 8, 9, 16]
Еще одна новая функция,
heappushpop(heap, item)
, помещает item в heap, затем выгружает и возвращает наименьший элемент. Это более эффективно, чем вызовheappush()
, а затемheappop()
.Метод
heapq
теперь использует только сравнение «меньше-меньше» вместо сравнения «меньше-меньше или равно», которое использовалось ранее. Благодаря этому использование типа вheapq
совпадает с методомlist.sort()
. (Внесено Раймондом Хеттингером).В конструкторы классов
httplib.HTTPConnection
иHTTPSConnection
добавлен необязательный параметрtimeout
, задающий таймаут, измеряемый в секундах. (Добавлено Факундо Батистой).Большинство функций модуля
inspect
, такие какgetmoduleinfo()
иgetargs()
, теперь возвращают именованные кортежи. Помимо того, что элементы возвращаемого значения ведут себя как кортежи, к ним можно обращаться как к атрибутам. (Внесено Раймондом Хеттингером).Среди новых функций модуля -
isgenerator()
,isgeneratorfunction()
иisabstract()
.Модуль
itertools
получил несколько новых функций.izip_longest(iter1, iter2, ...[, fillvalue])
создает кортежи из каждого элемента; если некоторые итерабели короче других, то недостающие значения устанавливаются в fillvalue. Например:>>> tuple(itertools.izip_longest([1,2,3], [1,2,3,4,5])) ((1, 1), (2, 2), (3, 3), (None, 4), (None, 5))
product(iter1, iter2, ..., [repeat=N])
возвращает декартово произведение заданных итераций - набор кортежей, содержащих все возможные комбинации элементов, возвращаемых из каждой итерации.>>> list(itertools.product([1,2,3], [4,5,6])) [(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6)]
Необязательный ключевой аргумент repeat используется для получения произведения итерабельной переменной или набора итерабельных переменных на самих себя, повторенного N раз. При использовании одного аргумента iterable возвращается N кортежей:
>>> list(itertools.product([1,2], repeat=3)) [(1, 1, 1), (1, 1, 2), (1, 2, 1), (1, 2, 2), (2, 1, 1), (2, 1, 2), (2, 2, 1), (2, 2, 2)]
При использовании двух итераций возвращается 2N кортежей.
>>> list(itertools.product([1,2], [3,4], repeat=2)) [(1, 3, 1, 3), (1, 3, 1, 4), (1, 3, 2, 3), (1, 3, 2, 4), (1, 4, 1, 3), (1, 4, 1, 4), (1, 4, 2, 3), (1, 4, 2, 4), (2, 3, 1, 3), (2, 3, 1, 4), (2, 3, 2, 3), (2, 3, 2, 4), (2, 4, 1, 3), (2, 4, 1, 4), (2, 4, 2, 3), (2, 4, 2, 4)]
combinations(iterable, r)
возвращает подпоследовательности длины r из элементов iterable.>>> list(itertools.combinations('123', 2)) [('1', '2'), ('1', '3'), ('2', '3')] >>> list(itertools.combinations('123', 3)) [('1', '2', '3')] >>> list(itertools.combinations('1234', 3)) [('1', '2', '3'), ('1', '2', '4'), ('1', '3', '4'), ('2', '3', '4')]
permutations(iter[, r])
возвращает все перестановки длины r элементов итерабельной системы. Если r не задано, то по умолчанию возвращается число элементов, порожденных итерабельной системой.>>> list(itertools.permutations([1,2,3,4], 2)) [(1, 2), (1, 3), (1, 4), (2, 1), (2, 3), (2, 4), (3, 1), (3, 2), (3, 4), (4, 1), (4, 2), (4, 3)]
itertools.chain(*iterables)
- это существующая вitertools
функция, которая получила новый конструктор в Python 2.6.itertools.chain.from_iterable(iterable)
принимает одну итерируемую переменную, которая должна возвращать другие итерируемые переменные.chain()
возвращает все элементы первой итерируемой таблицы, затем все элементы второй и т. д.>>> list(itertools.chain.from_iterable([[1,2,3], [4,5,6]])) [1, 2, 3, 4, 5, 6]
(Все материалы предоставлены Раймондом Хеттингером).
Класс
logging
модуляFileHandler
и его подклассыWatchedFileHandler
,RotatingFileHandler
иTimedRotatingFileHandler
теперь имеют необязательный параметр delay в своих конструкторах. Если delay равен true, открытие файла журнала откладывается до первого вызоваemit()
. (Внесено Винаем Саджипом).TimedRotatingFileHandler
также имеет параметр конструктора utc. Если аргумент равен true, то при определении момента наступления полуночи и при генерации имен файлов будет использоваться время UTC; в противном случае будет использоваться местное время.В модуль
math
было добавлено несколько новых функций:isinf()
иisnan()
определяют, является ли данный float (положительной или отрицательной) бесконечностью или NaN (Not a Number), соответственно.copysign()
копирует бит знака числа IEEE 754, возвращая абсолютное значение x в сочетании с битом знака y. Например,math.copysign(1, -0.0)
возвращает -1,0. (Предоставлено Кристианом Хаймсом).factorial()
вычисляет факториал числа. (Внесено Раймондом Хеттингером; bpo-2138).fsum()
складывает поток чисел из итерируемой таблицы, стараясь избежать потери точности при использовании частичных сумм. (Вклад внесли Жан Бруверс, Раймонд Хеттингер и Марк Дикинсон; bpo-2819).acosh()
,asinh()
иatanh()
вычисляют обратные гиперболические функции.log1p()
возвращает натуральный логарифм от 1+x (основание e).trunc()
округляет число в сторону нуля, возвращая ближайшуюIntegral
, которая находится между аргументом функции и нулем. Добавлена как часть бэкпорта PEP 3141’s type hierarchy for numbers.
Модуль
math
был улучшен, чтобы обеспечить более последовательное поведение на разных платформах, особенно в отношении обработки исключений с плавающей точкой и специальных значений IEEE 754.По возможности модуль следует рекомендациям стандарта C99 относительно специальных значений 754. Например,
sqrt(-1.)
теперь должен выдаватьValueError
почти на всех платформах, аsqrt(float('NaN'))
должен возвращать NaN на всех платформах IEEE 754. Там, где приложение „F“ стандарта C99 рекомендует сигнализировать «деление на ноль» или «недействительно», Python будет выдаватьValueError
. Если приложение „F“ стандарта C99 рекомендует сигнализировать о «переполнении», Python выдаст сообщениеOverflowError
. (См. bpo-711019 и bpo-1640).(При участии Кристиана Хаймса и Марка Дикинсона).
У объектов
mmap
теперь есть методrfind()
, который ищет подстроку, начиная с конца строки и в обратном направлении. Методfind()
также получил параметр end, указывающий индекс, на котором следует прекратить поиск. (Внесено Джоном Лентоном.)Модуль
operator
получил функциюmethodcaller()
, которая принимает имя и необязательный набор аргументов, возвращая вызываемую функцию, которая будет вызывать именованную функцию на любых переданных ей аргументах. Например:>>> # Equivalent to lambda s: s.replace('old', 'new') >>> replacer = operator.methodcaller('replace', 'old', 'new') >>> replacer('old wine in old bottles') 'new wine in new bottles'
(Внесено Георгом Брандлом по предложению Григория Петросяна).
Функция
attrgetter()
теперь принимает точечные имена и выполняет соответствующий поиск атрибутов:>>> inst_name = operator.attrgetter( ... '__class__.__name__') >>> inst_name('') 'str' >>> inst_name(help) '_Helper'
(Внесено Георгом Брандлом по предложению Барри Варшава).
Модуль
os
теперь включает в себя несколько новых системных вызовов.fchmod(fd, mode)
иfchown(fd, uid, gid)
изменяют режим и право собственности на открытый файл, аlchmod(path, mode)
изменяет режим симлинка. (Вклад внесли Георг Брандл и Кристиан Хаймс).chflags()
иlchflags()
являются обертками для соответствующих системных вызовов (если они доступны), изменяющих флаги, установленные для файла. Константы для значений флагов определяются в модулеstat
; некоторые возможные значения включаютUF_IMMUTABLE
, сигнализирующий о том, что файл не может быть изменен, иUF_APPEND
, указывающий, что данные могут быть только добавлены в файл. (Внесено М. Левинсоном.)os.closerange(low, high)
эффективно закрывает все файловые дескрипторы от low до high, игнорируя любые ошибки и не включая сам high. Эта функция теперь используется модулемsubprocess
для ускорения запуска процессов. (Внесено Георгом Брандлом; bpo-1663329).Метод
os.environ
объектаclear()
теперь будет удалять переменные окружения с помощьюos.unsetenv()
в дополнение к очистке ключей объекта. (Внесено Мартином Хорчицкой; bpo-1181).У функции
os.walk()
теперь есть параметрfollowlinks
. Если установить значение True, она будет следовать по симлинкам, указывающим на каталоги, и посещать содержимое каталога. Для обратной совместимости значение параметра по умолчанию равно false. Обратите внимание, что функция может впасть в бесконечную рекурсию, если есть симлинк, указывающий на родительский каталог. (bpo-1273829)В модуле
os.path
функцияsplitext()
была изменена таким образом, чтобы она не разделялась на символы ведущей точки. Это дает лучшие результаты при работе с точечными файлами Unix. Например,os.path.splitext('.ipython')
теперь возвращает('.ipython', '')
вместо('', '.ipython')
. (bpo-1115886)Новая функция,
os.path.relpath(path, start='.')
, возвращает относительный путь от путиstart
, если он указан, или от текущего рабочего каталога к месту назначенияpath
. (Внесено Ричардом Барраном; bpo-1339796).В Windows
os.path.expandvars()
теперь будет расширять переменные окружения, заданные в виде «%var%», а «~user» будет расширен до пути к домашнему каталогу пользователя. (Внесено Джосайей Карлсоном; bpo-957650).В отладчике Python, предоставляемом модулем
pdb
, появилась новая команда: «run» перезапускает отлаживаемую программу на Python и может опционально принимать новые аргументы командной строки для программы. (Внесено Роки Бернштейном; bpo-1393667).Функция
pdb.post_mortem()
, используемая для начала отладки трассировки, теперь будет использовать трассировку, возвращаемуюsys.exc_info()
, если трассировка не указана. (Внесено Факундо Батистой; bpo-1106316).В модуле
pickletools
теперь есть функцияoptimize()
, которая принимает строку, содержащую pickle, и удаляет некоторые неиспользуемые опкоды, возвращая более короткий pickle, содержащий ту же структуру данных. (Внесено Раймондом Хеттингером).В модуль
pkgutil
была добавлена функцияget_data()
, которая возвращает содержимое файлов ресурсов, входящих в установленный пакет Python. Например:>>> import pkgutil >>> print pkgutil.get_data('test', 'exception_hierarchy.txt') BaseException +-- SystemExit +-- KeyboardInterrupt +-- GeneratorExit +-- Exception +-- StopIteration +-- StandardError ...
(Предоставлено Полом Муром; bpo-2439).
Объекты
pyexpat
модуляParser
теперь позволяют устанавливать атрибутbuffer_size
для изменения размера буфера, используемого для хранения символьных данных. (Внесено Ахимом Гаэдке; bpo-1137).Модуль
Queue
теперь предоставляет варианты очередей, которые извлекают записи в разном порядке. КлассPriorityQueue
хранит элементы очереди в куче и извлекает их в порядке приоритета, аLifoQueue
извлекает сначала самые последние добавленные записи, то есть ведет себя как стек. (Предоставлено Раймондом Хеттингером.)Объекты
random
модуляRandom
теперь могут быть распакованы на 32-битной системе и распакованы на 64-битной системе, и наоборот. К сожалению, это изменение также означает, что объектыRandom
модуля Python 2.6 не могут быть корректно распакованы на более ранних версиях Python. (Внесено Шоном Лигоцки; bpo-1727780).Новая функция
triangular(low, high, mode)
возвращает случайные числа, соответствующие треугольному распределению. Возвращаемые значения находятся между low и high, не включая само high, и с mode как наиболее часто встречающееся значение в распределении. (Вклад Владмира ван дер Лаана и Раймонда Хеттингера; bpo-1681432).Длительный поиск регулярных выражений, выполняемый модулем
re
, будет проверять наличие доставляемых сигналов, так что теперь трудоемкие поиски можно прервать. (Вклад Джоша Хойта и Ральфа Шмитта; bpo-846388).Модуль регулярных выражений реализуется путем компиляции байткода для крошечной виртуальной машины, специфичной для regex. Недоверенный код может напрямую создавать вредоносные строки байткода и вызывать сбои, поэтому в Python 2.6 включен верификатор для байткода regex. (Прислано Гвидо ван Россумом из работы в Google App Engine; bpo-3487).
Метод
rlcompleter
модуляCompleter.complete()
теперь будет игнорировать исключения, возникающие при вычислении имени. (Исправлено Лоренцем Кваком; bpo-2250).Экземпляры
sched
модуляscheduler
теперь имеют атрибутqueue
, доступный только для чтения, который возвращает содержимое очереди планировщика, представленное в виде списка именованных кортежей с полями(time, priority, action, argument)
. (Внесено Раймондом Хеттингером; bpo-1861).Модуль
select
теперь содержит функции-обертки для системных вызовов Linuxepoll()
и BSDkqueue()
. Методmodify()
был добавлен к существующим объектамpoll
;pollobj.modify(fd, eventmask)
принимает дескриптор файла или объект файла и маску события, изменяя записанную маску события для этого файла. (Внесено Кристианом Хаймсом; bpo-1657).Функция
shutil.copytree()
теперь имеет необязательный аргумент ignore, который принимает объект callable. Этот вызываемый объект получает каждый путь к каталогу и список его содержимого, а также возвращает список имен, которые будут проигнорированы, а не скопированы.Модуль
shutil
также предоставляет функциюignore_patterns()
для использования с этим новым параметром.ignore_patterns()
принимает произвольное количество шаблонов в стиле glob и возвращает вызываемую функцию, которая будет игнорировать любые файлы и каталоги, соответствующие любому из этих шаблонов. В следующем примере копируется дерево каталогов, но пропускаются каталоги.svn
и файлы резервного копирования Emacs, имена которых заканчиваются на „~“:shutil.copytree('Doc/library', '/tmp/library', ignore=shutil.ignore_patterns('*~', '.svn'))
(Предоставлено Тареком Зиаде; bpo-2663)
Интеграция обработки сигналов с циклами обработки событий GUI, подобными тем, что используются в Tkinter или GTk+, долгое время была проблемой; большинство программ в конечном итоге опрашивают, просыпаясь каждую долю секунды, чтобы проверить, произошли ли какие-либо события GUI. Модуль
signal
теперь может сделать это более эффективным. Вызовsignal.set_wakeup_fd(fd)
задает дескриптор файла, который будет использоваться; когда поступает сигнал, в этот дескриптор записывается байт. Для установки дескриптора существует также функцияPySignal_SetWakeupFd()
на уровне языка Си.Циклы событий будут использовать это, открывая трубу для создания двух дескрипторов, одного для чтения и одного для записи. Дескриптор для записи будет передан в
set_wakeup_fd()
, а дескриптор для чтения будет добавлен в список дескрипторов, отслеживаемых циклом событий черезselect()
илиpoll()
. При получении сигнала будет записан байт, и основной цикл событий будет разбужен, что избавит вас от необходимости опрашивать.(Предоставлено Адамом Олсеном; bpo-1583).
Функция
siginterrupt()
теперь доступна из кода Python и позволяет изменять, могут ли сигналы прерывать системные вызовы или нет. (Внесено Ральфом Шмиттом.)Также были добавлены функции
setitimer()
иgetitimer()
(там, где они доступны).setitimer()
позволяет установить интервальные таймеры, которые вызовут подачу сигнала процессу через заданное время, измеряемое в настенных часах, потребляемом времени процесса или комбинированном времени процесса+системы. (Внесено Гильерме Поло; bpo-2240).Модуль
smtplib
теперь поддерживает SMTP через SSL благодаря добавлению классаSMTP_SSL
. Этот класс поддерживает интерфейс, идентичный существующему классуSMTP
. (Внесено Монти Тейлором.) Оба конструктора класса также имеют необязательный параметрtimeout
, который задает таймаут для первой попытки соединения, измеряемый в секундах. (Внесено Факундо Батистой.)В модуль также была добавлена реализация протокола LMTP (RFC 2033). LMTP используется вместо SMTP при передаче электронной почты между агентами, которые не управляют почтовой очередью. (LMTP реализован Лейфом Хедстромом; bpo-957003).
SMTP.starttls()
теперь соответствует RFC 3207 и забывает любые знания, полученные от сервера, которые не были получены в ходе самих переговоров TLS. (Исправление внесено Биллом Феннером; bpo-829951).Модуль
socket
теперь поддерживает TIPC (https://tipc.sourceforge.net/), высокопроизводительный протокол, не основанный на IP, предназначенный для использования в кластерных средах. Адреса TIPC представляют собой 4- или 5-кортежи. (Внесено Альберто Бертогли; bpo-1646).Новая функция
create_connection()
принимает адрес и соединяется с ним, используя необязательное значение таймаута, возвращая объект подключенного сокета. Эта функция также ищет тип адреса и соединяется с ним, используя IPv4 или IPv6 в зависимости от ситуации. Изменение кода для использованияcreate_connection()
вместоsocket(socket.AF_INET, ...)
может быть все, что требуется, чтобы ваш код работал с IPv6.Базовые классы модуля
SocketServer
теперь поддерживают вызов методаhandle_timeout()
после периода бездействия, заданного атрибутомtimeout
сервера. (Вклад Майкла Помранинга.) Методserve_forever()
теперь принимает необязательный интервал опроса, измеряемый в секундах, определяющий, как часто сервер будет проверять запрос на выключение. (Вклад Педро Вернека и Джеффри Ясскина; bpo-742598, bpo-1193577).Модуль
sqlite3
, поддерживаемый Герхардом Херингом, был обновлен с версии 2.3.2 в Python 2.5 до версии 2.4.1.Модуль
struct
теперь поддерживает тип C99 _Bool, используя символ формата'?'
. (Внесено Дэвидом Ремалем.)У объектов
Popen
, предоставляемых модулемsubprocess
, теперь есть методыterminate()
,kill()
иsend_signal()
. В Windowssend_signal()
поддерживает только сигналSIGTERM
, а все эти методы являются псевдонимами для функции Win32 APITerminateProcess()
. (Внесено Кристианом Хаймсом.)Новая переменная в модуле
sys
,float_info
, представляет собой объект, содержащий информацию, полученную из файлаfloat.h
, о поддержке плавающей точки в платформе. Атрибуты этого объекта включаютmant_dig
(количество цифр в мантиссе),epsilon
(наименьшая разница между 1.0 и следующим наибольшим значением, которое можно представить) и некоторые другие. (Внесено Кристианом Хаймсом; bpo-1534).Еще одна новая переменная,
dont_write_bytecode
, управляет тем, пишет ли Python какие-либо файлы.pyc
или.pyo
при импорте модуля. Если эта переменная равна true, скомпилированные файлы не записываются. Изначально переменная устанавливается при запуске интерпретатора Python с помощью ключа-B
или путем установки переменной окруженияPYTHONDONTWRITEBYTECODE
перед запуском интерпретатора. В дальнейшем код Python может изменять значение этой переменной, чтобы контролировать запись или не запись файлов байткода. (При участии Нила Норвица и Георга Брандла).Информация об аргументах командной строки, переданных интерпретатору Python, доступна через чтение атрибутов именованного кортежа, доступного как
sys.flags
. Например, атрибутverbose
истинен, если Python выполнялся в режиме verbose,debug
истинен в режиме отладки и т. д. Все эти атрибуты доступны только для чтения. (Внесено Кристианом Хаймсом.)Новая функция
getsizeof()
принимает объект Python и возвращает объем памяти, используемый объектом, измеряемый в байтах. Встроенные объекты возвращают корректные результаты; сторонние расширения могут этого не делать, но могут определить метод__sizeof__()
для возврата размера объекта. (Внесено Робертом Шуппенисом; bpo-2898).Теперь можно определить текущие функции профилировщика и трассировщика, вызвав
sys.getprofile()
иsys.gettrace()
. (Внесено Георгом Брандлом; bpo-1648).Модуль
tarfile
теперь поддерживает tar-файлы POSIX.1-2001 (pax) в дополнение к уже поддерживаемым форматам POSIX.1-1988 (ustar) и GNU tar. По умолчанию используется формат GNU tar; укажите параметрformat
, чтобы открыть файл в другом формате:tar = tarfile.open("output.tar", "w", format=tarfile.PAX_FORMAT)
Новые параметры
encoding
иerrors
задают кодировку и схему обработки ошибок при преобразовании символов.'strict'
,'ignore'
и'replace'
- это три стандартных способа обработки ошибок в Python;'utf-8'
- это специальное значение, которое заменяет ошибочные символы их представлением в UTF-8. (Преобразование символов происходит потому, что формат PAX поддерживает имена файлов в кодировке Юникод, а по умолчанию используется кодировка UTF-8).Метод
TarFile.add()
теперь принимает аргументexclude
, представляющий собой функцию, которая может использоваться для исключения определенных имен файлов из архива. Функция должна принимать имя файла и возвращать true, если файл должен быть исключен, или false, если он должен быть заархивирован. Функция применяется как к имени, изначально переданному вadd()
, так и к именам файлов в рекурсивно добавленных каталогах.(Все изменения внесены Ларсом Густебелем).
В конструктор класса
telnetlib.Telnet
добавлен необязательный параметрtimeout
, задающий таймаут, измеряемый в секундах. (Добавлено Факундо Батистой).Класс
tempfile.NamedTemporaryFile
обычно удаляет созданный им временный файл при закрытии файла. Теперь это поведение можно изменить, передав в конструкторdelete=False
. (Внесено Дэмиеном Миллером; bpo-1537850).Новый класс,
SpooledTemporaryFile
, ведет себя как временный файл, но хранит свои данные в памяти до тех пор, пока не будет превышен максимальный размер. По достижении этого предела содержимое будет записано во временный файл на диске. (Внесено Дастином Дж. Митчеллом).Классы
NamedTemporaryFile
иSpooledTemporaryFile
работают как менеджеры контекста, поэтому вы можете написатьwith tempfile.NamedTemporaryFile() as tmp: ...
. (Внесено Александром Белопольским; bpo-2021).В модуле
test.test_support
появилось несколько контекстных менеджеров, полезных для написания тестов.EnvironmentVarGuard()
- это контекстный менеджер, который временно изменяет переменные окружения и автоматически восстанавливает их прежние значения.Другой менеджер контекста,
TransientResource
, может окружать обращения к ресурсам, которые могут быть или не быть доступными; он будет перехватывать и игнорировать указанный список исключений. Например, сетевой тест может игнорировать определенные сбои при подключении к внешнему веб-сайту:with test_support.TransientResource(IOError, errno=errno.ETIMEDOUT): f = urllib.urlopen('https://sf.net') ...
Наконец,
check_warnings()
сбрасывает фильтры предупреждений модуляwarning
и возвращает объект, в котором будут записаны все сработавшие предупреждения (bpo-3781):with test_support.check_warnings() as wrec: warnings.simplefilter("always") # ... code that triggers a warning ... assert str(wrec.message) == "function is outdated" assert len(wrec.warnings) == 1, "Multiple warnings raised"
(Предоставлено Бреттом Кэнноном.)
Модуль
textwrap
теперь может сохранять существующие пробельные символы в начале и конце вновь создаваемых строк, указав в качестве аргументаdrop_whitespace=False
:>>> S = """This sentence has a bunch of ... extra whitespace.""" >>> print textwrap.fill(S, width=15) This sentence has a bunch of extra whitespace. >>> print textwrap.fill(S, drop_whitespace=False, width=15) This sentence has a bunch of extra whitespace. >>>
(Предоставлено Дуэйном Бейли; bpo-1581073).
API модуля
threading
был изменен для использования свойствdaemon
вместо методовsetDaemon()
иisDaemon()
, а некоторые методы были переименованы для использования подчеркивания вместо верблюжьего регистра; например, методactiveCount()
был переименован вactive_count()
. Версии модуля 2.6 и 3.0 поддерживают те же свойства и переименованные методы, но не удаляют старые методы. Дата отказа от старых API в Python 3.x не установлена; старые API не будут удалены ни в одной из версий 2.x. (Этим занимаются несколько человек, в первую очередь Бенджамин Петерсон).Объекты
threading
модуляThread
получили свойствоident
, которое возвращает идентификатор потока - целое число без нуля. (Внесено Грегори П. Смитом; bpo-2871).Модуль
timeit
теперь принимает вызовы, а также строки для оператора, который проверяется по времени, и для кода установки. Добавлены две удобные функции для создания экземпляровTimer
:repeat(stmt, setup, time, repeat, number)
иtimeit(stmt, setup, time, number)
создают экземпляр и вызывают соответствующий метод. (Внесено Эриком Демейном; bpo-1533909).Модуль
Tkinter
теперь принимает списки и кортежи для опций, разделяя элементы пробелами перед передачей результирующего значения в Tcl/Tk. (Внесено Гильерме Поло; bpo-2906).Модуль
turtle
для черепашьей графики был значительно улучшен Грегором Линглом. Новые возможности модуля включают:Улучшена анимация движения и вращения черепахи.
Управление движением черепахи с помощью новых методов
delay()
,tracer()
иspeed()
.Возможность задавать новые формы для черепахи и определять новую систему координат.
У черепах теперь есть метод
undo()
, который позволяет откатывать действия назад.Простая поддержка реакции на события ввода, такие как активность мыши и клавиатуры, что позволяет писать простые игры.
Файл
turtle.cfg
можно использовать для настройки начального вида экрана черепахи.Документация модуля может быть заменена новой документацией, переведенной на другой язык.
В функцию
urllib.urlopen
и конструктор классаurllib.ftpwrapper
, а также в функциюurllib2.urlopen
был добавлен необязательный параметрtimeout
. Параметр задает таймаут, измеряемый в секундах. Например:>>> u = urllib2.urlopen("http://slow.example.com", timeout=3) Traceback (most recent call last): ... urllib2.URLError: <urlopen error timed out> >>>
(Добавлено Факундо Батистой.)
База данных Unicode, предоставляемая модулем
unicodedata
, была обновлена до версии 5.1.0. (Обновлено Мартином фон Лёвисом; bpo-3811).В модулях
warnings
formatwarning()
иshowwarning()
появился необязательный аргумент line, который можно использовать для указания строки исходного кода. (Добавлено как часть bpo-1631171, который переимитировал часть модуляwarnings
в код на языке C).Новая функция
catch_warnings()
- это менеджер контекста, предназначенный для тестирования, который позволяет временно изменять фильтры предупреждений, а затем восстанавливать их исходные значения (bpo-3781).Классы XML-RPC
SimpleXMLRPCServer
иDocXMLRPCServer
теперь можно предотвратить немедленное открытие и привязку к сокету, передавFalse
в качестве параметра конструктора bind_and_activate. Это можно использовать для изменения атрибутаallow_reuse_address
экземпляра перед вызовом методовserver_bind()
иserver_activate()
, чтобы открыть сокет и начать прослушивать соединения. (Внесено Питером Паренте; bpo-1599845).У
SimpleXMLRPCServer
также есть атрибут_send_traceback_header
; если он равен true, исключение и отслеживание в формате возвращаются в виде HTTP-заголовков «X-Exception» и «X-Traceback». Эта функция предназначена только для отладки и не должна использоваться на рабочих серверах, поскольку трассировка может раскрыть пароли или другую конфиденциальную информацию. (Внесено Аланом Макинтайром в рамках его проекта для Google Summer of Code 2007).Модуль
xmlrpclib
больше не преобразует автоматически экземплярыdatetime.date
иdatetime.time
в типxmlrpclib.DateTime
; семантика преобразования не всегда была корректной для всех приложений. Код, использующийxmlrpclib
, должен преобразовывать экземплярыdate
иtime
. (bpo-1330538) Код также может работать с датами до 1900 года (вклад Ральфа Шмитта; bpo-2014) и 64-битными целыми числами, представленными с помощью<i8>
в ответах XML-RPC (вклад Рику Линдблада; bpo-2985).Класс
zipfile
модуляZipFile
теперь имеет методыextract()
иextractall()
, которые распаковывают один файл или все файлы в архиве в текущий каталог или в указанный каталог:z = zipfile.ZipFile('python-251.zip') # Unpack a single file, writing it relative # to the /tmp directory. z.extract('Python/sysmodule.c', '/tmp') # Unpack all the files in the archive. z.extractall()
(Предоставлено Аланом Макинтайром; bpo-467924).
Методы
open()
,read()
иextract()
теперь могут принимать либо имя файла, либо объектZipInfo
. Это полезно, когда архив случайно содержит дублирующееся имя файла. (Внесено Грэмом Хорлером; bpo-1775025).Наконец,
zipfile
теперь поддерживает использование имен файлов Unicode для архивных файлов. (Внесено Алексеем Борзенковым; bpo-1734346).
Модуль ast
¶
Модуль ast
обеспечивает представление кода Python в виде абстрактного синтаксического дерева, а Армин Ронахер предоставил набор вспомогательных функций, которые выполняют множество общих задач. Они будут полезны для пакетов шаблонизации HTML, анализаторов кода и подобных инструментов, обрабатывающих Python-код.
Функция parse()
принимает выражение и возвращает AST. Функция dump()
выводит представление дерева, подходящее для отладки:
import ast
t = ast.parse("""
d = {}
for i in 'abcdefghijklm':
d[i + i] = ord(i) - ord('a') + 1
print d
""")
print ast.dump(t)
В результате получается глубоко вложенное дерево:
Module(body=[
Assign(targets=[
Name(id='d', ctx=Store())
], value=Dict(keys=[], values=[]))
For(target=Name(id='i', ctx=Store()),
iter=Str(s='abcdefghijklm'), body=[
Assign(targets=[
Subscript(value=
Name(id='d', ctx=Load()),
slice=
Index(value=
BinOp(left=Name(id='i', ctx=Load()), op=Add(),
right=Name(id='i', ctx=Load()))), ctx=Store())
], value=
BinOp(left=
BinOp(left=
Call(func=
Name(id='ord', ctx=Load()), args=[
Name(id='i', ctx=Load())
], keywords=[], starargs=None, kwargs=None),
op=Sub(), right=Call(func=
Name(id='ord', ctx=Load()), args=[
Str(s='a')
], keywords=[], starargs=None, kwargs=None)),
op=Add(), right=Num(n=1)))
], orelse=[])
Print(dest=None, values=[
Name(id='d', ctx=Load())
], nl=True)
])
Метод literal_eval()
принимает строку или AST, представляющую литеральное выражение, анализирует и оценивает его, а затем возвращает полученное значение. Литеральное выражение - это выражение Python, содержащее только строки, числа, словари и т. д., но не содержащее операторов или вызовов функций. Если вам нужно оценить выражение, но вы не можете принять риск безопасности, связанный с использованием вызова eval()
, literal_eval()
безопасно справится с этой задачей:
>>> literal = '("a", "b", {2:4, 3:8, 1:2})'
>>> print ast.literal_eval(literal)
('a', 'b', {1: 2, 2: 4, 3: 8})
>>> print ast.literal_eval('"a" + "b"')
Traceback (most recent call last):
...
ValueError: malformed string
Модуль также включает классы NodeVisitor
и NodeTransformer
для обхода и модификации AST, а также функции для общих преобразований, таких как изменение номеров строк.
Модуль future_builtins
¶
Python 3.0 вносит множество изменений в репертуар встроенных функций, и большинство из них не могут быть введены в серию Python 2.x, поскольку нарушают совместимость. Модуль future_builtins
предоставляет версии этих встроенных функций, которые можно импортировать при написании кода, совместимого с 3.0.
В настоящее время этот модуль включает в себя следующие функции:
ascii(obj)
: эквивалентноrepr()
. В Python 3.0repr()
возвращает строку Unicode, аascii()
- чистую байт-строку ASCII.filter(predicate, iterable)
,map(func, iterable1, ...)
: версии 3.0 возвращают итераторы, в отличие от встроенных модулей 2.x, которые возвращают списки.hex(value)
,oct(value)
: вместо вызова методов__hex__()
или__oct__()
эти версии будут вызывать метод__index__()
и преобразовывать результат в шестнадцатеричную или восьмеричную систему счисления.oct()
будет использовать новую нотацию0o
для своего результата.
Модуль json
: Объектная нотация JavaScript¶
Новый модуль json
поддерживает кодирование и декодирование типов Python в JSON (Javascript Object Notation). JSON - это легкий формат обмена данными, часто используемый в веб-приложениях. Более подробную информацию о JSON можно найти на сайте http://www.json.org.
json
поставляется с поддержкой декодирования и кодирования большинства встроенных типов Python. Следующий пример кодирует и декодирует словарь:
>>> import json
>>> data = {"spam": "foo", "parrot": 42}
>>> in_json = json.dumps(data) # Encode the data
>>> in_json
'{"parrot": 42, "spam": "foo"}'
>>> json.loads(in_json) # Decode into a Python object
{"spam": "foo", "parrot": 42}
Также можно написать свои собственные декодеры и кодеры для поддержки большего количества типов. Также поддерживается красивая печать строк JSON.
json
(первоначальное название simplejson) был написан Бобом Ипполито.
Модуль plistlib
: Парсер списков свойств¶
Формат .plist
широко используется в Mac OS X для хранения основных типов данных (чисел, строк, списков и словарей) путем их сериализации в формат на основе XML. Он напоминает сериализацию типов данных в XML-RPC.
Несмотря на то, что формат в основном используется в Mac OS X, в нем нет ничего специфичного для Mac, а реализация на Python работает на любой платформе, которую поддерживает Python, поэтому модуль plistlib
был перенесен в стандартную библиотеку.
Использовать модуль очень просто:
import sys
import plistlib
import datetime
# Create data structure
data_struct = dict(lastAccessed=datetime.datetime.now(),
version=1,
categories=('Personal','Shared','Private'))
# Create string containing XML.
plist_str = plistlib.writePlistToString(data_struct)
new_struct = plistlib.readPlistFromString(plist_str)
print data_struct
print new_struct
# Write data structure to a file and read it back.
plistlib.writePlist(data_struct, '/tmp/customizations.plist')
new_struct = plistlib.readPlist('/tmp/customizations.plist')
# read/writePlist accepts file-like objects as well as paths.
plistlib.writePlist(data_struct, sys.stdout)
Усовершенствования ctypes¶
Томас Хеллер продолжал поддерживать и улучшать модуль ctypes
.
ctypes
теперь поддерживает тип данных c_bool
, который представляет тип C99 bool
. (Внесено Дэвидом Ремалем; bpo-1649190).
В типах строк, буферов и массивов ctypes
улучшена поддержка расширенного синтаксиса нарезки, в котором используются различные комбинации (start, stop, step)
. (Реализовано Томасом Воутерсом).
Все типы данных ctypes
теперь поддерживают методы from_buffer()
и from_buffer_copy()
, которые создают экземпляр ctypes на основе предоставленного объекта буфера. from_buffer_copy()
копирует содержимое объекта, а from_buffer()
будет использовать ту же область памяти.
Новое соглашение о вызовах предписывает ctypes
очищать переменные errno
или Win32 LastError в начале каждого обернутого вызова. (Реализовано Томасом Хеллером; bpo-1798).
Теперь вы можете получить переменную Unix errno
после вызова функции. При создании обернутой функции вы можете передать use_errno=True
в качестве параметра ключевого слова в функцию DLL()
, а затем вызвать методы уровня модуля set_errno()
и get_errno()
для установки и получения значения ошибки.
Переменная Win32 LastError аналогичным образом поддерживается функциями DLL()
, OleDLL()
и WinDLL()
. Вы передаете use_last_error=True
в качестве параметра ключевого слова, а затем вызываете методы уровня модуля set_last_error()
и get_last_error()
.
Функция byref()
, используемая для получения указателя на экземпляр ctypes, теперь имеет необязательный параметр offset, представляющий собой количество байт, которое будет добавлено к возвращаемому указателю.
Улучшенная поддержка SSL¶
Билл Янссен внес значительные улучшения в поддержку Secure Sockets Layer в Python 2.6, добавив новый модуль ssl
, который построен на базе библиотеки OpenSSL. Этот новый модуль предоставляет больше контроля над протоколом, используемыми сертификатами X.509, а также улучшает поддержку написания SSL-серверов (в отличие от клиентов) на Python. Существующая поддержка SSL в модуле socket
не была удалена и продолжает работать, хотя она будет удалена в Python 3.0.
Чтобы использовать новый модуль, необходимо сначала создать TCP-соединение обычным способом, а затем передать его функции ssl.wrap_socket()
. Можно указать, требуется ли сертификат, и получить информацию о сертификате, вызвав метод getpeercert()
.
См.также
Документация для модуля ssl
.
Амортизация и удаление¶
Строковые исключения были удалены. Попытка их использования вызывает ошибку
TypeError
.Изменения в интерфейсе
Exception
, продиктованные PEP 352, продолжаются. В версии 2.6 атрибутmessage
будет упразднен в пользу атрибутаargs
.(Режим 3.0-warning) В Python 3.0 будет проведена реорганизация стандартной библиотеки, в результате которой многие устаревшие модули будут удалены, а другие переименованы. Python 2.6, работающий в режиме 3.0-warning, будет предупреждать об этих модулях при их импорте.
Список устаревших модулей выглядит следующим образом:
audiodev
,bgenlocations
,buildtools
,bundlebuilder
,Canvas
,compiler
,dircache
,dl
,fpformat
,gensuitemodule
,ihooks
,imageop
,imgfile
,linuxaudiodev
,mhlib
,mimetools
,multifile
,new
,pure
,statvfs
,sunaudiodev
,test.testall
, иtoaiff
.Модуль
gopherlib
был удален.Модуль
MimeWriter
и модульmimify
были устаревшими; вместо них используйте пакетemail
.Модуль
md5
был устаревшим; вместо него используйте модульhashlib
.Модуль
posixfile
был устаревшим;fcntl.lockf()
обеспечивает лучшую блокировку.Модуль
popen2
был устаревшим; используйте модульsubprocess
.Модуль
rgbimg
был удален.Модуль
sets
был устаревшим; лучше использовать встроенные типыset
иfrozenset
.Модуль
sha
был устаревшим; вместо него используйте модульhashlib
.
Изменения в сборке и C API¶
Изменения в процессе сборки Python и в C API включают:
Теперь Python должен компилироваться компиляторами C89 (спустя 19 лет!). Это означает, что дерево исходных текстов Python отказалось от собственных реализаций
memmove()
иstrerror()
, которые находятся в стандартной библиотеке C89.Python 2.6 может быть собран с помощью Microsoft Visual Studio 2008 (версия 9.0), и это новый компилятор по умолчанию. Файлы сборки находятся в каталоге
PCbuild
. (Реализовано Кристианом Хаймсом).В Mac OS X Python 2.6 может быть скомпилирован как 4-сторонняя универсальная сборка. Скрипт configure может принимать переключатель
--with-universal-archs=[32-bit|64-bit|all]
, управляющий тем, будут ли двоичные файлы собраны для 32-битных архитектур (x86, PowerPC), 64-битных (x86-64 и PPC-64) или для обеих. (Внесено Рональдом Оуссореном.)Новая функция, добавленная в Python 2.6.6,
PySys_SetArgvEx()
, устанавливает значениеsys.argv
и может по желанию обновитьsys.path
, чтобы включить каталог, содержащий скрипт, названныйsys.argv[0]
, в зависимости от значения параметра updatepath.Эта функция была добавлена, чтобы закрыть брешь в безопасности для приложений, в которых используется Python. Старая функция,
PySys_SetArgv()
, всегда обновлялаsys.path
, а иногда добавляла текущий каталог. Это означало, что если вы запускали приложение, внедряющее Python, в директории, контролируемой кем-то другим, злоумышленники могли поместить в эту директорию троянский модуль (например, файл с именемos.py
), который ваше приложение затем импортировало бы и запускало.Если вы работаете с приложением на C/C++, в которое встроен Python, проверьте, вызываете ли вы
PySys_SetArgv()
, и тщательно подумайте, не следует ли использоватьPySys_SetArgvEx()
с updatepath, установленным в false. Обратите внимание, что использование этой функции нарушает совместимость с Python версий 2.6.5 и более ранних; если вам нужно продолжать работать с более ранними версиями, вы можете оставить вызовPySys_SetArgv()
в покое и вызватьPyRun_SimpleString("sys.path.pop(0)\n")
после этого, чтобы отбросить первый компонентsys.path
.О проблеме безопасности сообщалось в CVE-2008-5983; она обсуждалась в gh-50003 и была исправлена Антуаном Питру.
Модуль BerkeleyDB теперь имеет объект C API, доступный как
bsddb.db.api
. Этот объект может быть использован другими расширениями C, которые хотят использовать модульbsddb
для своих целей. (Внесено Дунканом Грисби).Новый интерфейс буфера, ранее описанный в the PEP 3118 section, добавляет
PyObject_GetBuffer()
иPyBuffer_Release()
, а также несколько других функций.Использование в Python библиотеки C stdio теперь потокобезопасно, или, по крайней мере, настолько, насколько потокобезопасна базовая библиотека. Давно существовавшая потенциальная ошибка возникала, если один поток закрывал файловый объект, в то время как другой поток читал из этого объекта или записывал в него. В 2.6 файловые объекты имеют счетчик ссылок, которым управляют функции
PyFile_IncUseCount()
иPyFile_DecUseCount()
. Файловые объекты не могут быть закрыты, если счетчик ссылок не равен нулю. ФункциюPyFile_IncUseCount()
следует вызывать, пока GIL еще удерживается, перед выполнением операции ввода-вывода с использованием указателяFILE *
, аPyFile_DecUseCount()
следует вызывать сразу после повторного получения GIL. (При участии Антуана Питру и Грегори П. Смита).Импорт модулей одновременно в двух разных потоках больше не приводит к дедлоку; теперь он вызывает ошибку
ImportError
. Новая функция API,PyImport_ImportModuleNoBlock()
, сначала ищет модуль вsys.modules
, а затем пытается импортировать его после получения блокировки импорта. Если блокировка импорта находится в другом потоке, возникает ошибкаImportError
. (Внесено Кристианом Хаймсом.)Несколько функций возвращают информацию о поддержке платформы с плавающей точкой.
PyFloat_GetMax()
возвращает максимальное представимое значение с плавающей точкой, аPyFloat_GetMin()
- минимальное положительное значение.PyFloat_GetInfo()
возвращает объект, содержащий дополнительную информацию из файлаfloat.h
, такую как"mant_dig"
(количество цифр в мантиссе),"epsilon"
(наименьшая разница между 1.0 и следующим наибольшим представимым значением) и некоторые другие. (Внесено Кристианом Хаймсом; bpo-1534).Функции и методы языка C, использующие
PyComplex_AsCComplex()
, теперь будут принимать аргументы, имеющие метод__complex__()
. В частности, функции в модулеcmath
теперь будут принимать объекты с этим методом. Это обратный перенос изменения, внесенного в Python 3.0. (Внесено Марком Дикинсоном; bpo-1675423).API Python на языке C теперь включает две функции для сравнения строк без учета регистра,
PyOS_stricmp(char*, char*)
иPyOS_strnicmp(char*, char*, Py_ssize_t)
. (Вклад Кристиана Хаймса; bpo-1635).Многие расширения языка C определяют свой собственный маленький макрос для добавления целых чисел и строк в словарь модуля в функции
init*
. В Python 2.6 наконец-то определены стандартные макросы для добавления значений в модуль,PyModule_AddStringMacro
иPyModule_AddIntMacro()
. (Внесено Кристианом Хаймсом.)Некоторые макросы были переименованы как в 3.0, так и в 2.6, чтобы было понятнее, что это макросы, а не функции.
Py_Size()
сталPy_SIZE()
,Py_Type()
сталPy_TYPE()
, аPy_Refcnt()
сталPy_REFCNT()
. Макросы в смешанном регистре по-прежнему доступны в Python 2.6 для обратной совместимости. (bpo-1629)Distutils теперь помещает создаваемые им расширения C в другой каталог при запуске на отладочной версии Python. (Внесено Коллином Винтером; bpo-1530959).
Некоторые базовые типы данных, такие как целые числа и строки, содержат внутренние свободные списки объектов, которые могут быть использованы повторно. Структуры данных для этих свободных списков теперь следуют соглашению об именовании: переменная всегда называется
free_list
, счетчик всегда называетсяnumfree
, и всегда определен макросPy<typename>_MAXFREELIST
.Новая цель Makefile, «make patchcheck», подготавливает дерево исходных текстов Python к созданию патча: она исправляет пробелы во всех измененных файлах
.py
, проверяет, была ли изменена документация, и сообщает, были ли обновлены файлыMisc/ACKS
иMisc/NEWS
. (Внесено Бреттом Кэнноном.)Еще одна новая цель, «make profile-opt», компилирует двоичный файл Python, используя оптимизацию GCC с учетом профилирования. Она компилирует Python с включенным профилированием, запускает набор тестов для получения набора результатов профилирования, а затем компилирует, используя эти результаты для оптимизации. (Внесено Грегори П. Смитом).
Изменения для конкретного порта: Windows¶
Поддержка Windows 95, 98, ME и NT4 была прекращена. Для Python 2.6 требуется как минимум Windows 2000 SP4.
Новым компилятором по умолчанию в Windows является Visual Studio 2008 (версия 9.0). Директории сборки для Visual Studio 2003 (версия 7.1) и 2005 (версия 8.0) были перемещены в каталог PC/. Новый каталог
PCbuild
поддерживает кросс-компиляцию для X64, отладочные сборки и Profile Guided Optimization (PGO). Сборки PGO примерно на 10% быстрее обычных сборок. (Внесено Кристианом Хаймсом при содействии Амори Форжо д’Арк и Мартина фон Лёвиса).Модуль
msvcrt
теперь поддерживает как обычный, так и широкосимвольный варианты API ввода/вывода консоли. Функцияgetwch()
считывает нажатие клавиши и возвращает значение Unicode, как и функцияgetwche()
. Функцияputwch()
принимает символ Unicode и записывает его в консоль. (Внесено Кристианом Хаймсом.)os.path.expandvars()
теперь будет расширять переменные окружения в виде «%var%», а «~user» будет расширяться в путь к домашнему каталогу пользователя. (Внесено Джосайей Карлсоном; bpo-957650).Объекты сокетов модуля
socket
теперь имеют методioctl()
, который предоставляет ограниченный интерфейс к системному интерфейсуWSAIoctl()
.Модуль
_winreg
теперь имеет функциюExpandEnvironmentStrings()
, которая расширяет ссылки на переменные окружения, такие как%NAME%
во входной строке. Объекты handle, предоставляемые этим модулем, теперь поддерживают протокол контекста, поэтому их можно использовать в операторахwith
. (Внесено Кристианом Хаймсом.)_winreg
также имеет лучшую поддержку x64-систем, раскрывая функцииDisableReflectionKey()
,EnableReflectionKey()
иQueryReflectionKey()
, которые включают и выключают отражение реестра для 32-битных процессов, работающих на 64-битных системах. (bpo-1753245)Объект
msilib
модуляRecord
обзавелся методамиGetInteger()
иGetString()
, которые возвращают значения полей в виде целого числа или строки. (Вклад Флориса Бруйнооге; bpo-2125).
Изменения для конкретного порта: Mac OS X¶
При компиляции фреймворковой сборки Python теперь можно указать имя фреймворка, который будет использоваться, указав опцию
--with-framework-name=
в сценарии configure.Модуль
macfs
был удален. Это, в свою очередь, потребовало удаления функцииmacostools.touched()
, поскольку она зависела от модуляmacfs
. (bpo-1490190)Многие другие модули Mac OS были устаревшими и будут удалены в Python 3. 0:
_builtinSuites
,aepack
,aetools
,aetypes
,applesingle
,appletrawmain
,appletrunner
,argvemulator
,Audio_mac
,autoGIL
,Carbon
,cfmfile
,CodeWarrior
,ColorPicker
,EasyDialogs
,Explorer
,Finder
,FrameWork
,findertools
,ic
,icglue
,icopen
,macerrors
,MacOS
,macfs
,macostools
,macresource
,MiniAEFrame
,Nav
,Netscape
,OSATerminology
,pimp
,PixMapWrapper
,StdSuites
,SystemEvents
,Terminal
, иterminalcommand
.
Изменения для конкретного порта: IRIX¶
Ряд старых модулей, специфичных для IRIX, были устаревшими и будут удалены в Python 3. 0: al
и AL
, cd
, cddb
, cdplayer
, CL
и cl
, DEVICE
, ERRNO
, FILE
, FL
и fl
, flp
, fm
, GET
, GLWS
, GL
и gl
, IN
, IOCTL
, jpeg
, panelparser
, readcd
, SV
и sv
, torgb
, videoreader
и WAIT
.
Переход на Python 2.6¶
В этом разделе перечислены ранее описанные изменения и другие исправления, которые могут потребовать внесения изменений в ваш код:
Классы, которые не должны быть хэшируемыми, должны устанавливать
__hash__ = None
в своих определениях, чтобы указать на этот факт.Строковые исключения были удалены. Попытка их использования вызывает ошибку
TypeError
.Метод
__init__()
изcollections.deque
теперь очищает все существующее содержимое deque перед добавлением элементов из итерируемой таблицы. Это изменение приводит поведение в соответствие сlist.__init__()
.Ранее
object.__init__()
принимал произвольные аргументы и аргументы ключевых слов, игнорируя их. В Python 2.6 это больше не допускается и приведет к появлениюTypeError
. Это повлияет на методы__init__()
, которые в итоге вызывают соответствующий метод наobject
(возможно, с помощьюsuper()
). Обсуждение см. в разделе bpo-1683368.Конструктор
Decimal
теперь принимает ведущие и завершающие пробельные символы при передаче строки. Ранее это приводило к возникновению исключенияInvalidOperation
. С другой стороны, методcreate_decimal()
объектовContext
теперь явно запрещает лишние пробельные символы, вызывая исключениеConversionSyntax
.Из-за ошибки в реализации, если вы передавали путь к файлу встроенной функции
__import__()
, она действительно импортировала указанный файл. Однако этого не должно было произойти, и теперь реализация явно проверяет этот случай и вызывает ошибкуImportError
.C API: функции
PyImport_Import()
иPyImport_ImportModule()
теперь по умолчанию используют абсолютный импорт, а не относительный. Это повлияет на расширения C, которые импортируют другие модули.C API: расширенные типы данных, которые не должны быть хэшируемыми, должны определять свой слот
tp_hash
вPyObject_HashNotImplemented()
.Модуль-исключение
socket
модуляsocket.error
теперь наследуется отIOError
. Ранее оно не было подклассомStandardError
, но теперь является таковым черезIOError
. (Реализовано Грегори П. Смитом; bpo-1706815).Модуль
xmlrpclib
больше не преобразует автоматически экземплярыdatetime.date
иdatetime.time
в типxmlrpclib.DateTime
; семантика преобразования не всегда была корректной для всех приложений. Код, использующийxmlrpclib
, должен преобразовывать экземплярыdate
иtime
. (bpo-1330538)(3.0-warning mode) Класс
Exception
теперь предупреждает при обращении к нему с использованием срезов или индексного доступа; отказ от использованияException
, ведущего себя как кортеж.(3.0-warning mode) неравнозначные сравнения между двумя словарями или двумя объектами, в которых не реализованы методы сравнения, выдаются как предупреждения.
dict1 == dict2
по-прежнему работает, ноdict1 < dict2
постепенно выводится из употребления.Сравнения между ячейками, которые являются деталью реализации правил скопинга Python, также вызывают предупреждения, поскольку такие сравнения полностью запрещены в версии 3.0.
Для приложений, в которых используется Python:
Функция
PySys_SetArgvEx()
была добавлена в Python 2.6.6, что позволило приложениям закрыть брешь в безопасности, когда использовалась существующая функцияPySys_SetArgv()
. Проверьте, вызываете ли вы функциюPySys_SetArgv()
, и тщательно подумайте, не следует ли приложению использоватьPySys_SetArgvEx()
с updatepath, установленным на false.
Благодарности¶
Автор хотел бы поблагодарить следующих людей за предложения, исправления и помощь в работе над различными черновиками этой статьи: Georg Brandl, Steve Brown, Nick Coghlan, Ralph Corderoy, Jim Jewett, Kent Johnson, Chris Lambacher, Martin Michlmayr, Antoine Pitrou, Brian Warner.