Что нового в 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 3.0 существующий код Python придется преобразовать. Однако не все изменения в версии 3.0 обязательно нарушают совместимость. В тех случаях, когда новые возможности не приведут к поломке существующего кода, они были перенесены в версию 2.6 и описаны в этом документе в соответствующем месте. Некоторые из функций, перенесенных в 3.0, следующие:
Метод
__complex__()
для преобразования объектов в комплексное число.Альтернативный синтаксис для перехвата исключений:
except TypeError as exc
.Добавление
functools.reduce()
в качестве синонима встроенной функцииreduce()
.
Python 3.0 добавляет несколько новых встроенных функций и изменяет семантику некоторых существующих встроенных функций. Функции, новые в 3.0, такие как bin()
, были просто добавлены в Python 2.6, но существующие встроенные функции не были изменены; вместо этого модуль future_builtins
имеет версии с новой семантикой 3.0. Код, написанный для совместимости с 3.0, может выполнять from future_builtins import hex, map
при необходимости.
Новый переключатель командной строки -3
включает предупреждения о функциях, которые будут удалены в Python 3.0. Вы можете запустить код с этим переключателем, чтобы узнать, сколько работы потребуется для переноса кода в версию 3.0. Значение этого переключателя доступно для кода Python в виде булевой переменной sys.py3kwarning
, а для кода расширения C в виде Py_Py3kWarningFlag
.
Изменения в процессе разработки¶
Во время разработки 2.6 процесс разработки Python претерпел два значительных изменения: мы перешли с трекера проблем SourceForge на специализированную установку Roundup, а документация была переведена с LaTeX на reStructuredText.
Трекер новых выпусков: Раунд-ап¶
В течение долгого времени разработчиков 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 и доступен по адресу http://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()
, потому что file.__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__()
, а полученное значение будет возвращаемым значением метода, которое будет привязано к переменной в предложении with
оператора as
, если таковая имеется. Код после 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: Пакет 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-битных и юникодных строк есть метод .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 делает это однозначным, заменяя запятую словом «as». Чтобы поймать исключение и сохранить объект исключения в переменной 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''
.
Тип 2.6 str
отличается от типа 3.0 bytes
различными способами; самое главное, конструктор полностью отличается. В 3.0 bytes([65, 66, 67])
имеет длину 3 элемента и содержит байты, представляющие ABC
; в 2.6 bytes([65, 66, 67])
возвращает 12-байтовую строку, представляющую str()
списка.
Основное использование bytes
в 2.6 будет заключаться в написании тестов объектного типа, таких как isinstance(x, bytes)
. Это поможет конвертеру 2to3, который не может определить, что в коде 2.x строки должны содержать символы или 8-битные байты; теперь вы можете использовать bytes
или str
для точного представления вашего намерения, и полученный код будет корректен и в Python 3.0.
Существует также импорт __future__
, который заставляет все строковые литералы становиться строками Юникода. Это означает, что управляющие последовательности \u
можно использовать для включения символов Юникода:
from __future__ import unicode_literals
s = ('\u751f\u3080\u304e\u3000\u751f\u3054'
'\u3081\u3000\u751f\u305f\u307e\u3054')
print len(s) # 12 Unicode characters
На уровне языка Си, Python 3.0 переименует существующий 8-битный строковый тип, называемый PyStringObject
в Python 2.x, в PyBytesObject
. Python 2.6 использует #define
для поддержки использования имен PyBytesObject()
, PyBytes_Check()
, PyBytes_FromStringAndSize()
и всех других функций и макросов, используемых со строками.
Экземпляры типа bytes
неизменяемы, как и строки. Новый тип bytearray
хранит изменяемую последовательность байтов:
>>> bytearray([65, 66, 67])
bytearray(b'ABC')
>>> b = bytearray(u'\u21ef\u3244', 'utf-8')
>>> b
bytearray(b'\xe2\x87\xaf\xe3\x89\x84')
>>> b[0] = '\xe3'
>>> b
bytearray(b'\xe3\x87\xaf\xe3\x89\x84')
>>> unicode(str(b), 'utf-8')
u'\u31ef \u3244'
Байтовые массивы поддерживают большинство методов строковых типов, таких как startswith()
/endswith()
, find()
/rfind()
, и некоторые методы списков, такие как append()
, pop()
и reverse()
.
>>> b = bytearray('ABC')
>>> b.append('d')
>>> b.append(ord('e'))
>>> b
bytearray(b'ABCde')
Существует также соответствующий C API, с PyByteArray_FromObject()
, PyByteArray_FromStringAndSize()
и различными другими функциями.
См.также
- PEP 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
: Предоставляет функции для чтения и записи строк (помните, что строки будут Unicode в Python 3.0), а также поддерживает universal newlines.TextIOBase
определяет методreadline()
и поддерживает итерацию объектов.Существует две конкретные реализации.
TextIOWrapper
оборачивает объект буферизованного ввода-вывода, поддерживая все методы для текстового ввода-вывода и добавляя атрибутbuffer
для доступа к базовому объекту.StringIO
просто буферизирует все в памяти, никогда ничего не записывая на диск.(В Python 2.6 модуль
io.StringIO
реализован на чистом Python, поэтому он довольно медленный. Поэтому пока вам следует придерживаться существующего модуляStringIO
илиcStringIO
. В какой-то момент модульio
в Python 3.0 будет переписан на C для повышения скорости, и, возможно, реализация на C будет перенесена в релизы 2.x).
В Python 2.6 базовые реализации не были реструктурированы для построения поверх классов модуля io
. Модуль предоставляется для того, чтобы облегчить написание кода, совместимого с версией 3.0, и избавить разработчиков от необходимости писать собственные реализации буферизации и ввода-вывода текста.
См.также
- PEP 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
запрашивает компоновку массива на языке Си (последняя размерность меняется быстрее всего) или Фортран (первая размерность меняется быстрее всего).
Два новых кода аргументов для PyArg_ParseTuple()
, s*
и z*
, возвращают заблокированные объекты буфера для параметра.
См.также
- PEP 3118 - Пересмотр протокола буферизации
PEP написан Тревисом Олифантом и Карлом Бэнксом; реализован Тревисом Олифантом.
PEP 3119: Абстрактные базовые классы¶
Некоторые объектно-ориентированные языки, такие как Java, поддерживают интерфейсы, объявляя, что класс имеет определенный набор методов или поддерживает определенный протокол доступа. Абстрактные базовые классы (или ABC) являются эквивалентной функцией для Python. Поддержка ABC состоит из модуля abc
, содержащего метакласс ABCMeta
, специальной обработки этого метакласса встроенными модулями isinstance()
и issubclass()
, а также коллекции базовых ABC, которые, по мнению разработчиков Python, будут широко полезны. В будущих версиях Python, вероятно, будут добавлены новые ABC.
Допустим, у вас есть определенный класс, и вы хотите узнать, поддерживает ли он доступ в стиле словаря. Фраза «в стиле словаря», однако, расплывчата. Вероятно, она означает, что доступ к элементам с помощью obj[1]
работает. Означает ли это, что установка элементов с помощью obj[2] = value
работает? Или что объект будет иметь методы keys()
, values()
и items()
? Как насчет итеративных вариантов, таких как iterkeys()
? copy()
и update()
? Итерация над объектом с помощью iter()
?
Модуль Python 2.6 collections
включает несколько различных ABC, которые представляют эти различия. Iterable
указывает, что класс определяет __iter__()
, а Container
означает, что класс определяет метод __contains__()
и поэтому поддерживает выражения x in y
. Основной интерфейс словаря, включающий получение элементов, установку элементов и keys()
, values()
и items()
, определяется MutableMapping
ABC.
Вы можете создавать собственные классы на основе определенного ABC, чтобы указать, что они поддерживают интерфейс этого ABC:
import collections
class Storage(collections.MutableMapping):
...
В качестве альтернативы можно написать класс, не производя его от нужного ABC, и вместо этого зарегистрировать класс, вызвав метод ABC register()
:
import collections
class Storage:
...
collections.MutableMapping.register(Storage)
Для классов, которые вы пишете сами, производные от ABC, вероятно, более понятны. Метод register()
полезен, когда вы написали новый ABC, который может описывать существующий тип или класс, или если вы хотите объявить, что какой-то сторонний класс реализует ABC. Например, если вы определили ABC PrintableType
, то можно сделать следующее:
# Register Python's types
PrintableType.register(int)
PrintableType.register(float)
PrintableType.register(str)
Классы должны подчиняться семантике, указанной в ABC, но Python не может проверить это; автор класса должен понять требования ABC и реализовать код соответствующим образом.
Чтобы проверить, поддерживает ли объект определенный интерфейс, теперь можно написать:
def func(d):
if not isinstance(d, collections.MutableMapping):
raise ValueError("Mapping object expected, not %r" % d)
Не думайте, что теперь вы должны начать писать множество проверок, как в приведенном выше примере. В Python сильна традиция «утиной типизации», когда явная проверка типов никогда не выполняется, а код просто вызывает методы объекта, полагаясь на то, что эти методы там есть, и вызывая исключение, если их там нет. Будьте благоразумны в проверке ABC и делайте это только там, где это абсолютно необходимо.
Вы можете написать свой собственный ABC, используя abc.ABCMeta
в качестве метакласса в определении класса:
from abc import ABCMeta, abstractmethod
class Drawable():
__metaclass__ = ABCMeta
@abstractmethod
def draw(self, x, y, scale=1.0):
pass
def draw_doubled(self, x, y):
self.draw(x, y, scale=2.0)
class Square(Drawable):
def draw(self, x, y, scale):
...
В приведенной выше ABC Drawable
метод draw_doubled()
отображает объект в два раза больше его размера и может быть реализован в терминах других методов, описанных в Drawable
. Поэтому классам, реализующим этот ABC, не нужно предоставлять собственную реализацию draw_doubled()
, хотя они могут это сделать. Однако реализация draw()
необходима; ABC не может предоставить полезную общую реализацию.
Вы можете применить декоратор @abstractmethod
к таким методам, как draw()
, которые должны быть реализованы; тогда Python выдаст исключение для классов, не определивших этот метод. Обратите внимание, что исключение будет вызвано только тогда, когда вы действительно попытаетесь создать экземпляр подкласса, в котором отсутствует метод:
>>> class Circle(Drawable):
... pass
...
>>> c = Circle()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class Circle with abstract methods draw
>>>
Абстрактные атрибуты данных могут быть объявлены с помощью декоратора @abstractproperty
:
from abc import abstractproperty
...
@abstractproperty
def readonly(self):
return self._x
Затем подклассы должны определить свойство readonly()
.
См.также
- PEP 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
.
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
, находящееся между аргументом функции и нулем.
См.также
- PEP 3141 - Иерархия типов для чисел
PEP, автор Джеффри Ясскин.
Scheme’s numerical tower, из руководства по Guile.
Scheme’s number datatypes из спецификации схемы R5RS.
Модуль fractions
¶
Чтобы заполнить иерархию числовых типов, модуль fractions
предоставляет класс рациональных чисел. Рациональные числа хранят свои значения в виде числителя и знаменателя, образующих дробь, и могут точно представлять такие числа, как 2/3
, которые числа с плавающей точкой могут только приближенно представлять.
Конструктор Fraction
принимает два значения Integral
, которые будут числителем и знаменателем полученной дроби.
>>> from fractions import Fraction
>>> a = Fraction(2, 3)
>>> b = Fraction(2, 5)
>>> float(a), float(b)
(0.66666666666666663, 0.40000000000000002)
>>> a+b
Fraction(16, 15)
>>> a/b
Fraction(5, 3)
Для преобразования чисел с плавающей точкой в рациональные, тип float теперь имеет метод as_integer_ratio()
, который возвращает числитель и знаменатель для дроби, которая оценивается в одно и то же значение с плавающей точкой:
>>> (2.5) .as_integer_ratio()
(5, 2)
>>> (3.1415) .as_integer_ratio()
(7074029114692207L, 2251799813685248L)
>>> (1./3) .as_integer_ratio()
(6004799503160661L, 18014398509481984L)
Обратите внимание, что значения, которые могут быть аппроксимированы только числами с плавающей точкой, например 1,/3, не упрощаются до аппроксимируемого числа; дробь пытается соответствовать значению с плавающей точкой точно.
Модуль fractions
основан на реализации Sjoerd Mullender, которая долгое время находилась в каталоге Python Demo/classes/
. Эта реализация была значительно обновлена Джеффри Ясскином.
Другие языковые изменения¶
Некоторые более мелкие изменения, внесенные в основной язык Python, следующие:
Каталоги и zip-архивы, содержащие файл
__main__.py
, теперь можно выполнять напрямую, передавая их имя интерпретатору. Каталог или zip-архив автоматически вставляется в качестве первой записи в sys.path. (Предложение и первоначальный патч Энди Чу, впоследствии исправленный Филлипом Дж. Эби и Ником Когланом; bpo-1739468).Функция
hasattr()
ловила и игнорировала все ошибки, полагая, что они означают, что метод__getattr__()
каким-то образом не работает, и поэтому возвращаемое значениеhasattr()
будетFalse
. Однако эту логику не следует применять кKeyboardInterrupt
иSystemExit
; Python 2.6 больше не будет отбрасывать такие исключения, когдаhasattr()
встречает их. (Исправлено Бенджамином Петерсоном; bpo-2196).При вызове функции, использующей синтаксис
**
для предоставления аргументов в виде ключевых слов, больше не требуется использовать словарь Python; теперь будет работать любое отображение:>>> def f(**kw): ... print sorted(kw) ... >>> ud=UserDict.UserDict() >>> ud['a'] = 1 >>> ud['b'] = 'string' >>> f(**ud) ['a', 'b']
(Внесено Александром Белопольским; bpo-1686487).
Также стало законным предоставлять аргументы ключевых слов после аргумента
*args
в вызове функции.>>> def f(*args, **kw): ... print args, kw ... >>> f(1,2,3, *(4,5,6), keyword=13) (1, 2, 3, 4, 5, 6) {'keyword': 13}
Раньше это было бы синтаксической ошибкой. (Внесено Amaury Forgeot d’Arc; bpo-3473).
Новый встроенный модуль
next(iterator, [default])
возвращает следующий элемент из указанного итератора. Если указан аргумент default, то он будет возвращен, если iterator был исчерпан; в противном случае будет вызвано исключениеStopIteration
. (Перенесено в bpo-2719).Кортежи теперь имеют методы
index()
иcount()
, соответствующие методамindex()
иcount()
типа list:>>> t = (0,1,2,3,4,0,1,2) >>> t.index(3) 3 >>> t.count(0) 2
(При участии Раймонда Хеттингера)
Встроенные типы теперь имеют улучшенную поддержку расширенного синтаксиса нарезки, принимая различные комбинации
(start, stop, step)
. Ранее поддержка была частичной, и некоторые угловые случаи не работали. (Реализовано Томасом Воутерсом.)Свойства теперь имеют три атрибута,
getter
,setter
иdeleter
, которые являются декораторами, предоставляющими полезные сокращения для добавления функции getter, setter или deleter к существующему свойству. Вы можете использовать их следующим образом:class C(object): @property def x(self): return self._x @x.setter def x(self, value): self._x = value @x.deleter def x(self): del self._x class D(C): @C.x.getter def x(self): return self._x * 2 @x.setter def x(self, value): self._x = value / 2
Некоторые методы встроенных типов множеств теперь принимают несколько итераций:
intersection()
,intersection_update()
,union()
,update()
,difference()
иdifference_update()
.>>> s=set('1234567890') >>> s.intersection('abc123', 'cdf246') # Intersection between all inputs set(['2']) >>> s.difference('246', '789') set(['1', '0', '3', '5'])
(При участии Раймонда Хеттингера.)
Добавлено множество функций с плавающей запятой. Функция
float()
теперь превращает строкуnan
в значение IEEE 754 Not A Number, а+inf
и-inf
- в положительную или отрицательную бесконечность. Это работает на любой платформе с семантикой IEEE 754. (Внесено Кристианом Хаймсом; bpo-1635).Другие функции модуля
math
,isinf()
иisnan()
, возвращают true, если их аргумент с плавающей точкой бесконечен или не является числом. (bpo-1640)Добавлены функции преобразования для преобразования чисел с плавающей точкой в шестнадцатеричные строки (bpo-3008). Эти функции преобразуют числа с плавающей точкой в строковое представление и обратно, не внося ошибок округления при преобразовании десятичных чисел в двоичные. У плавающих чисел есть метод
hex()
, который возвращает строковое представление, а методfloat.fromhex()
преобразует строку обратно в число:>>> a = 3.75 >>> a.hex() '0x1.e000000000000p+1' >>> float.fromhex('0x1.e000000000000p+1') 3.75 >>> b=1./3 >>> b.hex() '0x1.5555555555555p-2'
Числовая тонкость: при создании комплексного числа из двух плавающих чисел в системах, поддерживающих знаковые нули (-0 и +0), конструктор
complex()
теперь будет сохранять знак нуля. (Исправлено Марком Т. Дикинсоном; bpo-1507).Классы, наследующие метод
__hash__()
от родительского класса, могут установить__hash__ = None
, чтобы указать, что класс не является хэшируемым. Это заставитhash(obj)
вызыватьTypeError
, и класс не будет указан как реализующийHashable
ABC.Это следует делать, когда вы определили метод
__cmp__()
или__eq__()
, который сравнивает объекты по их значению, а не по идентичности. Все объекты имеют метод хеширования по умолчанию, который используетid(obj)
в качестве хеш-значения. Не существует аккуратного способа удалить метод__hash__()
, унаследованный от родительского класса, поэтому присвоениеNone
было реализовано как переопределение. На уровне языка C расширения могут устанавливатьtp_hash
вPyObject_HashNotImplemented()
. (Исправлено Nick Coghlan и Amaury Forgeot d’Arc; bpo-2235).Исключение
GeneratorExit
теперь подклассыBaseException
вместоException
. Это означает, что обработчик исключений, выполняющийexcept Exception:
, не будет случайно ловитьGeneratorExit
. (Внесено Чадом Остином; bpo-1537).Объекты генераторов теперь имеют атрибут
gi_code
, который ссылается на исходный объект кода, поддерживающий генератор. (Внесено Коллином Уинтером; bpo-1473257).Встроенная функция
compile()
теперь принимает аргументы в виде ключевых слов, а также позиционные параметры. (Внесено Томасом Воутерсом; bpo-1444529).Конструктор
complex()
теперь принимает строки, содержащие комплексные числа в круглых скобках, что означает, чтоcomplex(repr(cplx))
теперь будет округлять значения. Например,complex('(3+4j)')
теперь возвращает значение (3+4j). (bpo-1491866)Метод string
translate()
теперь принимаетNone
в качестве параметра таблицы трансляции, которая рассматривается как преобразование тождества. Это облегчает выполнение операций, в которых удаляются только символы. (Внесено Бенгтом Рихтером и реализовано Раймондом Хеттингером; bpo-1193128).Встроенная функция
dir()
теперь проверяет наличие метода__dir__()
на объектах, которые она получает. Этот метод должен возвращать список строк, содержащих имена допустимых атрибутов объекта, и позволяет объекту контролировать значение, которое выдаетdir()
. Объекты, имеющие методы__getattr__()
или__getattribute__()
, могут использовать этот метод для объявления псевдоатрибутов, которые они будут соблюдать. (bpo-1591665)Объекты метода экземпляра имеют новые атрибуты для объекта и функции, составляющей метод; новым синонимом для
im_self
является__self__
, аim_func
также доступен как__func__
. Старые имена все еще поддерживаются в Python 2.6, но в версии 3.0 они исчезли.Непонятное изменение: когда вы используете функцию
locals()
внутри оператораclass
, полученный словарь больше не возвращает свободные переменные. (Свободные переменные, в данном случае, это переменные, на которые ссылается операторclass
и которые не являются атрибутами класса).
Оптимизации¶
Модуль
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
. (Внесено Раймондом Хеттингером.)В конструктор класса
timeout
, а также в методftplib.FTP
был добавлен необязательный параметрconnect()
, задающий тайм-аут, измеряемый в секундах. (Добавлено Facundo Batista.) Кроме того, методыFTP
классаstorbinary()
иstorlines()
теперь принимают необязательный параметр callback, который будет вызываться с каждым блоком данных после их отправки. (Внесено Филом Шварцем; bpo-1221598).Встроенная функция
reduce()
также доступна в модулеfunctools
. В Python 3.0 встроенная функция была отменена, иreduce()
доступна только изfunctools
; в настоящее время не планируется отменять встроенную функцию в серии 2.x. (Исправлено Кристианом Хаймсом; bpo-1739906).Когда это возможно, модуль
getpass
теперь будет использовать/dev/tty
для печати сообщения подсказки и чтения пароля, возвращаясь к стандартной ошибке и стандартному вводу. Если пароль может быть передан на терминал, то перед выводом подсказки печатается предупреждение. (Внесено Грегори П. Смитом.)Функция
glob.glob()
теперь может возвращать имена файлов Unicode, если был использован путь Unicode и имена файлов Unicode найдены в каталоге. (bpo-1001604)Новая функция в модуле
heapq
,merge(iter1, iter2, ...)
, принимает любое количество итераторов, возвращающих данные в отсортированном порядке, и возвращает новый генератор, который возвращает содержимое всех итераторов, также в отсортированном порядке. Например:>>> list(heapq.merge([1, 3, 5, 9], [2, 8, 16])) [1, 2, 3, 5, 8, 9, 16]
Другая новая функция,
heappushpop(heap, item)
, помещает item на heap, затем выскакивает и возвращает наименьший элемент. Это более эффективно, чем вызовheappush()
и затемheappop()
.heapq
теперь используется только сравнение «меньше-чем», вместо сравнения «меньше-чем-или-равно», которое использовалось ранее. Это делает использование типаheapq
в методе совпадающим с методомlist.sort()
. (Внесено Раймондом Хеттингером.)В конструкторы классов
timeout
иhttplib.HTTPConnection
добавлен необязательный параметрHTTPSConnection
, задающий тайм-аут, измеряемый в секундах. (Добавлено Факундо Батиста.)Большинство функций модуля
inspect
, таких какgetmoduleinfo()
иgetargs()
, теперь возвращают именованные кортежи. Помимо того, что элементы возвращаемого значения ведут себя как кортежи, к ним можно обращаться как к атрибутам. (Внесено Раймондом Хеттингером.)Некоторые новые функции в модуле включают
isgenerator()
,isgeneratorfunction()
иisabstract()
.Модуль
itertools
получил несколько новых функций.izip_longest(iter1, iter2, ...[, fillvalue])
составляет кортежи из каждого элемента; если некоторые итерации короче других, недостающие значения устанавливаются в fillvalue. Например:>>> tuple(itertools.izip_longest([1,2,3], [1,2,3,4,5])) ((1, 1), (2, 2), (3, 3), (None, 4), (None, 5))
product(iter1, iter2, ..., [repeat=N])
возвращает декартово произведение заданных итераций, набор кортежей, содержащих все возможные комбинации элементов, возвращаемых каждой итерацией.>>> list(itertools.product([1,2,3], [4,5,6])) [(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6)]
Необязательный аргумент с ключевым словом repeat используется для получения произведения итерируемого или набора итерируемых с самим собой, повторяемого N раз. При одном аргументе iterable возвращается N кортежей:
>>> list(itertools.product([1,2], repeat=3)) [(1, 1, 1), (1, 1, 2), (1, 2, 1), (1, 2, 2), (2, 1, 1), (2, 1, 2), (2, 2, 1), (2, 2, 2)]
При двух итерациях возвращается 2N кортежей.
>>> list(itertools.product([1,2], [3,4], repeat=2)) [(1, 3, 1, 3), (1, 3, 1, 4), (1, 3, 2, 3), (1, 3, 2, 4), (1, 4, 1, 3), (1, 4, 1, 4), (1, 4, 2, 3), (1, 4, 2, 4), (2, 3, 1, 3), (2, 3, 1, 4), (2, 3, 2, 3), (2, 3, 2, 4), (2, 4, 1, 3), (2, 4, 1, 4), (2, 4, 2, 3), (2, 4, 2, 4)]
combinations(iterable, r)
возвращает подпоследовательности длины r из элементов iterable.>>> list(itertools.combinations('123', 2)) [('1', '2'), ('1', '3'), ('2', '3')] >>> list(itertools.combinations('123', 3)) [('1', '2', '3')] >>> list(itertools.combinations('1234', 3)) [('1', '2', '3'), ('1', '2', '4'), ('1', '3', '4'), ('2', '3', '4')]
permutations(iter[, r])
возвращает все перестановки длины r элементов итерабельной таблицы. Если r не указано, то по умолчанию возвращается количество элементов, созданных итерабельной системой.>>> list(itertools.permutations([1,2,3,4], 2)) [(1, 2), (1, 3), (1, 4), (2, 1), (2, 3), (2, 4), (3, 1), (3, 2), (3, 4), (4, 1), (4, 2), (4, 3)]
itertools.chain(*iterables)
- это существующая функция вitertools
, которая получила новый конструктор в Python 2.6.itertools.chain.from_iterable(iterable)
принимает одну итерабельную таблицу, которая должна возвращать другие итерабели.chain()
будет возвращать все элементы первой итеративной таблицы, затем все элементы второй и т.д.>>> list(itertools.chain.from_iterable([[1,2,3], [4,5,6]])) [1, 2, 3, 4, 5, 6]
(Все материалы предоставлены Раймондом Хеттингером).
Класс
logging
модуляFileHandler
и его подклассыWatchedFileHandler
,RotatingFileHandler
иTimedRotatingFileHandler
теперь имеют необязательный параметр delay в своих конструкторах. Если delay равен true, открытие файла журнала откладывается до первого вызоваemit()
. (Внесено Винаем Саджипом.)TimedRotatingFileHandler
также имеет параметр конструктора utc. Если аргумент равен true, то при определении момента наступления полуночи и при генерации имен файлов будет использоваться время UTC; в противном случае будет использоваться местное время.В модуль
math
было добавлено несколько новых функций:isinf()
иisnan()
определяют, является ли данное число float (положительной или отрицательной) бесконечностью или NaN (Not a Number), соответственно.copysign()
копирует бит знака числа IEEE 754, возвращая абсолютное значение x в сочетании с битом знака y. Например,math.copysign(1, -0.0)
возвращает -1.0. (Внесено Кристианом Хаймсом.)factorial()
вычисляет факториал числа. (Внесено Раймондом Хеттингером; bpo-2138).fsum()
складывает поток чисел из итерабельной таблицы, при этом старается избежать потери точности за счет использования частичных сумм. (При участии Jean Brouwers, Raymond Hettinger и Mark Dickinson; bpo-2819).acosh()
,asinh()
иatanh()
вычисляют обратные гиперболические функции.log1p()
возвращает натуральный логарифм 1+x (основание e).trunc()
округляет число в сторону нуля, возвращая ближайшееIntegral
, находящееся между аргументом функции и нулем. Добавлена как часть бэкпорта PEP 3141’s type hierarchy for numbers.
Модуль
math
был улучшен для обеспечения более последовательного поведения на разных платформах, особенно в отношении обработки исключений с плавающей точкой и специальных значений IEEE 754.По возможности, модуль следует рекомендациям стандарта C99 относительно специальных значений 754. Например,
sqrt(-1.)
теперь должно выдаватьValueError
почти на всех платформах, аsqrt(float('NaN'))
должно возвращать NaN на всех платформах IEEE 754. Там, где Приложение „F“ стандарта C99 рекомендует сигнализировать «деление на ноль» или «недействительно», Python будет выдаватьValueError
. Если приложение „F“ стандарта C99 рекомендует сигнализировать о «переполнении», Python выдаст сообщениеOverflowError
. (См. bpo-711019 и bpo-1640).(При участии Кристиана Хаймса и Марка Дикинсона).
Объекты
mmap
теперь имеют методrfind()
, который ищет подстроку, начиная с конца строки и в обратном направлении. У методаfind()
также появился параметр end, задающий индекс, на котором следует прекратить поиск. (Внесено Джоном Лентоном.)Модуль
operator
получил функциюmethodcaller()
, которая принимает имя и необязательный набор аргументов, возвращая вызываемую функцию, которая будет вызывать именованную функцию на любых переданных ей аргументах. Например:>>> # Equivalent to lambda s: s.replace('old', 'new') >>> replacer = operator.methodcaller('replace', 'old', 'new') >>> replacer('old wine in old bottles') 'new wine in new bottles'
(Внесено Георгом Брандлом по предложению Григория Петросяна).
Функция
attrgetter()
теперь принимает точечные имена и выполняет соответствующий поиск атрибутов:>>> inst_name = operator.attrgetter( ... '__class__.__name__') >>> inst_name('') 'str' >>> inst_name(help) '_Helper'
(Внесено Георгом Брандлом по предложению Барри Варшава).
Модуль
os
теперь содержит несколько новых системных вызовов.fchmod(fd, mode)
иfchown(fd, uid, gid)
изменяют режим и владельца открытого файла, аlchmod(path, mode)
изменяет режим симлинка. (Вклад внесли Георг Брандл и Кристиан Хаймс.)chflags()
иlchflags()
являются обертками для соответствующих системных вызовов (если они доступны), изменяющих флаги, установленные на файле. Константы для значений флагов определяются в модулеstat
; некоторые возможные значения включаютUF_IMMUTABLE
для сигнализации того, что файл не может быть изменен, иUF_APPEND
для указания того, что данные могут быть только добавлены в файл. (Внесено М. Левинсоном.)os.closerange(low, high)
эффективно закрывает все файловые дескрипторы от low до high, игнорируя любые ошибки и не включая сам high. Эта функция теперь используется модулемsubprocess
для ускорения запуска процессов. (Внесено Георгом Брандлом; bpo-1663329).Метод
os.environ
объектаclear()
теперь будет удалять переменные окружения с помощьюos.unsetenv()
в дополнение к очистке ключей объекта. (Внесено Мартином Хорчицкой; bpo-1181).Функция
os.walk()
теперь имеет параметрfollowlinks
. Если параметр равен True, то функция будет следовать по симлинкам, указывающим на каталоги, и посещать содержимое каталога. Для обратной совместимости значение параметра по умолчанию равно false. Обратите внимание, что функция может впасть в бесконечную рекурсию, если есть симлинк, указывающий на родительский каталог. (bpo-1273829)В модуле
os.path
функцияsplitext()
была изменена таким образом, чтобы она не разделялась на символы точки. Это дает лучшие результаты при работе с точечными файлами Unix. Например,os.path.splitext('.ipython')
теперь возвращает('.ipython', '')
вместо('', '.ipython')
. (bpo-1115886)Новая функция,
os.path.relpath(path, start='.')
, возвращает относительный путь от путиstart
, если он указан, или от текущего рабочего каталога к месту назначенияpath
. (Внесено Ричардом Барраном; bpo-1339796).В Windows,
os.path.expandvars()
теперь будет расширять переменные окружения, заданные в форме «%var%», а «~user» будет расширяться в путь к домашнему каталогу пользователя. (Внесено Джосайей Карлсоном; bpo-957650).Отладчик Python, предоставляемый модулем
pdb
, обзавелся новой командой: «run» перезапускает отлаживаемую программу Python и может принимать новые аргументы командной строки для программы. (Внесено Рокки Бернштейном; bpo-1393667).Функция
pdb.post_mortem()
, используемая для начала отладки трассировки, теперь будет использовать трассировку, возвращаемуюsys.exc_info()
, если трассировка не указана. (Внесено Факундо Батистой; bpo-1106316).Модуль
pickletools
теперь имеет функциюoptimize()
, которая принимает строку, содержащую pickle, и удаляет некоторые неиспользуемые опкоды, возвращая более короткий pickle, содержащий ту же структуру данных. (Внесено Раймондом Хеттингером.)В модуль
get_data()
была добавлена функцияpkgutil
, которая возвращает содержимое файлов ресурсов, включенных в установленный пакет Python. Например:>>> import pkgutil >>> print pkgutil.get_data('test', 'exception_hierarchy.txt') BaseException +-- SystemExit +-- KeyboardInterrupt +-- GeneratorExit +-- Exception +-- StopIteration +-- StandardError ...
(Внесено Полом Муром; bpo-2439).
Объекты
pyexpat
модуляParser
теперь позволяют устанавливать атрибутbuffer_size
для изменения размера буфера, используемого для хранения символьных данных. (Внесено Ахимом Гаэдке; bpo-1137).Модуль
Queue
теперь предоставляет варианты очередей, которые извлекают записи в различном порядке. КлассPriorityQueue
хранит элементы очереди в куче и извлекает их в порядке приоритета, аLifoQueue
извлекает сначала последние добавленные записи, то есть ведет себя как стек. (Внесено Раймондом Хеттингером.)Объекты
random
модуляRandom
теперь могут быть распикированы на 32-битной системе и распикированы на 64-битной системе, и наоборот. К сожалению, это изменение также означает, что объектыRandom
модуля Python 2.6 не могут быть корректно распакованы на более ранних версиях Python. (Внесено Шоном Лигоцки; bpo-1727780).Новая функция
triangular(low, high, mode)
возвращает случайные числа, соответствующие треугольному распределению. Возвращаемые значения находятся между low и high, не включая само high, и с mode как наиболее часто встречающееся значение в распределении. (Вклад внесли Wladmir van der Laan и Raymond Hettinger; bpo-1681432).Длительный поиск по регулярным выражениям, выполняемый модулем
re
, будет проверять наличие подаваемых сигналов, поэтому трудоемкий поиск теперь может быть прерван. (Вклад внесли Джош Хойт и Ральф Шмитт; bpo-846388).Модуль регулярных выражений реализован путем компиляции байткодов для крошечной виртуальной машины, специфичной для regex. Недоверенный код может напрямую создавать вредоносные строки байткода и вызывать сбои, поэтому в Python 2.6 включен верификатор для байткода regex. (Внесено Гвидо ван Россумом из работы в Google App Engine; bpo-3487).
Метод
rlcompleter
модуляCompleter.complete()
теперь будет игнорировать исключения, возникающие при оценке имени. (Исправлено Лоренцом Кваком; bpo-2250).Экземпляры
sched
модуляscheduler
теперь имеют атрибутqueue
только для чтения, который возвращает содержимое очереди планировщика, представленное в виде списка именованных кортежей с полями(time, priority, action, argument)
. (Внесено Раймондом Хеттингером; bpo-1861).Модуль
select
теперь имеет функции-обертки для системных вызовов 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)
устанавливает дескриптор файла, который будет использоваться; при получении сигнала байт записывается в этот дескриптор. Существует также функция уровня C,PySignal_SetWakeupFd()
, для установки дескриптора.Циклы событий будут использовать это, открывая трубу для создания двух дескрипторов, одного для чтения и одного для записи. Дескриптор для записи будет передан в
set_wakeup_fd()
, а дескриптор для чтения будет добавлен в список дескрипторов, отслеживаемых циклом событий черезselect()
илиpoll()
. При получении сигнала будет записан байт, и основной цикл событий будет разбужен, что позволит избежать необходимости опроса.(Внесено Адамом Олсеном; bpo-1583).
Функция
siginterrupt()
теперь доступна из кода Python и позволяет изменять, могут ли сигналы прерывать системные вызовы или нет. (Внесено Ральфом Шмиттом.)Также были добавлены функции
setitimer()
иgetitimer()
(там, где они доступны).setitimer()
позволяет установить интервальные таймеры, которые вызовут подачу сигнала процессу через заданное время, измеряемое в настенных часах, потребляемом времени процесса или комбинированном времени процесса+системы. (Внесено Гильерме Поло; bpo-2240).Модуль
smtplib
теперь поддерживает SMTP через SSL благодаря добавлению классаSMTP_SSL
. Этот класс поддерживает интерфейс, идентичный существующему классуSMTP
. (Внесено Монти Тейлором.) Оба конструктора класса также имеют необязательный параметрtimeout
, который определяет таймаут для начальной попытки соединения, измеряемый в секундах. (Внесено Факундо Батистой.)В модуль также была добавлена реализация протокола LMTP (RFC 2033). LMTP используется вместо SMTP при передаче электронной почты между агентами, которые не управляют почтовой очередью. (LMTP реализован Лейфом Хедстромом; bpo-957003).
SMTP.starttls()
теперь соответствует RFC 3207 и забывает любые знания, полученные от сервера, не полученные в ходе переговоров TLS. (Исправление внесено Биллом Феннером; bpo-829951).Модуль
socket
теперь поддерживает TIPC (http://tipc.sourceforge.net/), высокопроизводительный протокол, не основанный на IP, разработанный для использования в кластерных средах. Адреса TIPC представляют собой 4- или 5-кортежи. (Внесено Альберто Бертогли; bpo-1646).Новая функция
create_connection()
принимает адрес и соединяется с ним, используя необязательное значение таймаута, возвращая объект подключенного сокета. Эта функция также проверяет тип адреса и соединяется с ним, используя IPv4 или IPv6 в зависимости от ситуации. Изменение кода для использованияcreate_connection()
вместоsocket(socket.AF_INET, ...)
может быть достаточно для того, чтобы ваш код работал с IPv6.Базовые классы модуля
SocketServer
теперь поддерживают вызов методаhandle_timeout()
после периода бездействия, заданного атрибутомtimeout
сервера. (Внесено Майклом Помранингом.) Методserve_forever()
теперь принимает необязательный интервал опроса, измеряемый в секундах, определяющий, как часто сервер будет проверять наличие запроса на выключение. (При участии Педро Вернека и Джеффри Ясскина; bpo-742598, bpo-1193577).Модуль
sqlite3
, поддерживаемый Герхардом Херингом, был обновлен с версии 2.3.2 в Python 2.5 до версии 2.4.1.Модуль
struct
теперь поддерживает тип C99 _Bool, используя символ формата'?'
. (Внесено Дэвидом Ремалем.)Объекты
Popen
, предоставляемые модулемsubprocess
, теперь имеют методыterminate()
,kill()
иsend_signal()
. В Windows модульsend_signal()
поддерживает только сигналSIGTERM
, и все эти методы являются псевдонимами функции Win32 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
истинен в режиме debugging и т.д. Все эти атрибуты доступны только для чтения. (Внесено Кристианом Хаймсом.)Новая функция
getsizeof()
принимает объект Python и возвращает объем памяти, используемый объектом, измеряемый в байтах. Встроенные объекты возвращают корректные результаты; сторонние расширения могут этого не делать, но могут определить метод__sizeof__()
для возврата размера объекта. (Внесено Робертом Шуппенисом; bpo-2898).Теперь можно определить текущие функции профилировщика и трассировщика, вызвав
sys.getprofile()
иsys.gettrace()
. (Внесено Георгом Брандлом; bpo-1648).Модуль
tarfile
теперь поддерживает tar-файлы формата POSIX.1-2001 (pax) в дополнение к уже поддерживаемым форматам POSIX.1-1988 (ustar) и GNU tar. По умолчанию используется формат GNU tar; для открытия файла в другом формате укажите параметрformat
:tar = tarfile.open("output.tar", "w", format=tarfile.PAX_FORMAT)
Новые параметры
encoding
иerrors
задают кодировку и схему обработки ошибок при преобразовании символов.'strict'
,'ignore'
и'replace'
- это три стандартных способа обработки ошибок в Python;'utf-8'
- это специальное значение, которое заменяет плохие символы их представлением в формате UTF-8. (Преобразование символов происходит потому, что формат PAX поддерживает имена файлов Unicode и по умолчанию использует кодировку UTF-8).Метод
TarFile.add()
теперь принимает аргументexclude
, представляющий собой функцию, которую можно использовать для исключения определенных имен файлов из архива. Функция должна принимать имя файла и возвращать true, если файл должен быть исключен, или false, если он должен быть заархивирован. Функция применяется как к имени, изначально переданному вadd()
, так и к именам файлов в рекурсивно добавляемых каталогах.(Все изменения внесены Ларсом Густебелем).
В конструктор класса
timeout
добавлен необязательный параметрtelnetlib.Telnet
, задающий тайм-аут, измеряемый в секундах. (Добавлено Факундо Батиста.)Класс
tempfile.NamedTemporaryFile
обычно удаляет созданный им временный файл при закрытии файла. Теперь это поведение можно изменить, передав конструктору значениеdelete=False
. (Внесено Дэмиеном Миллером; bpo-1537850).Новый класс,
SpooledTemporaryFile
, ведет себя как временный файл, но хранит свои данные в памяти до тех пор, пока не будет превышен максимальный размер. По достижении этого предела содержимое будет записано во временный файл на диске. (Внесено Дастином Дж. Митчеллом.)Классы
NamedTemporaryFile
иSpooledTemporaryFile
работают как менеджеры контекста, поэтому вы можете писатьwith tempfile.NamedTemporaryFile() as tmp: ...
. (Внесено Александром Белопольским; bpo-2021).Модуль
test.test_support
получил ряд контекстных менеджеров, полезных для написания тестов.EnvironmentVarGuard()
- это контекстный менеджер, который временно изменяет переменные окружения и автоматически восстанавливает их старые значения.Другой менеджер контекста,
TransientResource
, может окружать вызовы к ресурсам, которые могут быть или не быть доступными; он будет перехватывать и игнорировать заданный список исключений. Например, сетевой тест может игнорировать определенные сбои при подключении к внешнему веб-сайту:with test_support.TransientResource(IOError, errno=errno.ETIMEDOUT): f = urllib.urlopen('https://sf.net') ...
Наконец,
check_warnings()
сбрасывает фильтры предупреждений модуляwarning
и возвращает объект, в котором будут записаны все сработавшие предупреждающие сообщения (bpo-3781):with test_support.check_warnings() as wrec: warnings.simplefilter("always") # ... code that triggers a warning ... assert str(wrec.message) == "function is outdated" assert len(wrec.warnings) == 1, "Multiple warnings raised"
(При участии Бретта Кэннона.)
Модуль
textwrap
теперь может сохранять существующие пробельные символы в начале и конце вновь создаваемых строк, указываяdrop_whitespace=False
в качестве аргумента:>>> S = """This sentence has a bunch of ... extra whitespace.""" >>> print textwrap.fill(S, width=15) This sentence has a bunch of extra whitespace. >>> print textwrap.fill(S, drop_whitespace=False, width=15) This sentence has a bunch of extra whitespace. >>>
(Внесено Дуэйном Бейли; bpo-1581073).
API модуля
threading
изменен для использования свойств типаdaemon
вместо методовsetDaemon()
иisDaemon()
, а некоторые методы переименованы для использования подчеркиваний вместо символов верблюжьего регистра; например, методactiveCount()
переименован вactive_count()
. Версии модуля 2.6 и 3.0 поддерживают те же свойства и переименованные методы, но не удаляют старые методы. Дата отказа от старых API в Python 3.x не установлена; старые API не будут удалены ни в одной версии 2.x. (Этим занимаются несколько человек, в первую очередь Бенджамин Петерсон).Объекты
threading
модуляThread
получили свойствоident
, которое возвращает идентификатор потока, целое ненулевое число. (Внесено Грегори П. Смитом; bpo-2871).Модуль
timeit
теперь принимает callables, а также строки для проверяемого оператора и кода установки. Добавлены две удобные функции для создания экземпляровTimer
:repeat(stmt, setup, time, repeat, number)
иtimeit(stmt, setup, time, number)
создают экземпляр и вызывают соответствующий метод. (Внесено Эриком Демейном; bpo-1533909).Модуль
Tkinter
теперь принимает списки и кортежи для опций, разделяя элементы пробелами перед передачей полученного значения в Tcl/Tk. (Внесено Гильерме Поло; bpo-2906).Модуль
turtle
для черепашьей графики был значительно улучшен Грегором Линглом. Новые возможности модуля включают:Улучшенная анимация движения и вращения черепахи.
Управление движением черепахи с помощью новых методов
delay()
,tracer()
иspeed()
.Возможность задавать новые формы для черепахи и определять новую систему координат.
Черепахи теперь имеют метод
undo()
, который может откатывать действия.Простая поддержка реакции на события ввода, такие как активность мыши и клавиатуры, что делает возможным написание простых игр.
Файл
turtle.cfg
можно использовать для настройки начального вида экрана черепахи.Докстринги модуля могут быть заменены новыми докстрингами, переведенными на другой язык.
В функцию
timeout
и конструктор классаurllib.urlopen()
, а также в функциюurllib.ftpwrapper
был добавлен необязательный параметрurllib2.urlopen()
. Параметр задает тайм-аут, измеряемый в секундах. Например:>>> u = urllib2.urlopen("http://slow.example.com", timeout=3) Traceback (most recent call last): ... urllib2.URLError: <urlopen error timed out> >>>
(Добавлено Факундо Батиста.)
База данных Unicode, предоставляемая модулем
unicodedata
, была обновлена до версии 5.1.0. (Обновлено Мартином фон Лёвисом; bpo-3811).В модулях
warnings
formatwarning()
иshowwarning()
появился необязательный аргумент line, который можно использовать для ввода строки исходного кода. (Добавлено как часть модуля bpo-1631171, который повторно реализовал часть модуляwarnings
в коде C).Новая функция
catch_warnings()
- это менеджер контекста, предназначенный для тестирования, который позволяет временно изменить фильтры предупреждений, а затем восстановить их исходные значения (bpo-3781).Классы XML-RPC
SimpleXMLRPCServer
иDocXMLRPCServer
теперь можно предотвратить немедленное открытие и привязку к сокету, передавFalse
в качестве параметра конструктора bind_and_activate. Это можно использовать для изменения атрибута экземпляраallow_reuse_address
перед вызовом методовserver_bind()
иserver_activate()
для открытия сокета и начала прослушивания соединений. (Внесено Питером Паренте; bpo-1599845).SimpleXMLRPCServer
также имеет атрибут_send_traceback_header
; если он равен true, исключение и отформатированный обратный след возвращаются в виде HTTP-заголовков «X-Exception» и «X-Traceback». Эта функция предназначена только для отладки и не должна использоваться на рабочих серверах, поскольку отслеживание может раскрыть пароли или другую конфиденциальную информацию. (Внесено Аланом Макинтайром как часть его проекта для Google Summer of Code 2007).Модуль
xmlrpclib
больше не преобразует автоматическиdatetime.date
иdatetime.time
к типуxmlrpclib.DateTime
; семантика преобразования не всегда была корректной для всех приложений. Код, использующийxmlrpclib
, должен преобразовывать экземплярыdate
иtime
. (bpo-1330538) Код также может обрабатывать даты до 1900 года (вклад Ральфа Шмитта; bpo-2014) и 64-битные целые числа, представленные с помощью<i8>
в ответах XML-RPC (вклад Рику Линдблада; bpo-2985).Класс
zipfile
модуляZipFile
теперь имеет методыextract()
иextractall()
, которые распаковывают один файл или все файлы в архиве в текущий каталог или в указанный каталог:z = zipfile.ZipFile('python-251.zip') # Unpack a single file, writing it relative # to the /tmp directory. z.extract('Python/sysmodule.c', '/tmp') # Unpack all the files in the archive. z.extractall()
(Внесено Аланом Макинтайром; bpo-467924).
Методы
open()
,read()
иextract()
теперь могут принимать либо имя файла, либо объектZipInfo
. Это полезно, когда архив случайно содержит дублированное имя файла. (Внесено Грэмом Хорлером; bpo-1775025).Наконец,
zipfile
теперь поддерживает использование имен файлов Unicode для архивных файлов. (Внесено Алексеем Борзенковым; bpo-1734346).
Модуль 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 mode) В Python 3.0 будет реорганизована стандартная библиотека, из которой будут удалены многие устаревшие модули и переименованы другие. Python 2.6, работающий в режиме 3.0-warning, будет предупреждать об этих модулях при их импорте.
Список устаревших модулей выглядит следующим образом:
audiodev
,bgenlocations
,buildtools
,bundlebuilder
,Canvas
,compiler
,dircache
,dl
,fpformat
,gensuitemodule
,ihooks
,imageop
,imgfile
,linuxaudiodev
,mhlib
,mimetools
,multifile
,new
,pure
,statvfs
,sunaudiodev
,test.testall
иtoaiff
.Модуль
gopherlib
был удален.Модуль
MimeWriter
и модульmimify
были устаревшими; вместо них используйте пакетemail
.Модуль
md5
был устаревшим; вместо него используйте модульhashlib
.Модуль
posixfile
был устаревшим;fcntl.lockf()
обеспечивает лучшую блокировку.Модуль
popen2
был устаревшим; используйте модульsubprocess
.Модуль
rgbimg
был удален.Модуль
sets
был устаревшим; лучше использовать встроенные типыset
иfrozenset
.Модуль
sha
был устаревшим; вместо него используйте модульhashlib
.
Изменения в API Build и C¶
Изменения в процессе сборки Python и в C API включают:
Python теперь должен компилироваться компиляторами C89 (спустя 19 лет!). Это означает, что дерево исходников Python отказалось от собственных реализаций
memmove()
иstrerror()
, которые находятся в стандартной библиотеке C89.Python 2.6 может быть собран с помощью Microsoft Visual Studio 2008 (версия 9.0), и это новый компилятор по умолчанию. Файлы сборки смотрите в каталоге
PCbuild
. (Реализовано Кристианом Хаймсом.)На Mac OS X Python 2.6 может быть скомпилирован как 4-сторонняя универсальная сборка. Сценарий configure может принимать переключатель
--with-universal-archs=[32-bit|64-bit|all]
, управляющий тем, собираются ли двоичные файлы для 32-битных архитектур (x86, PowerPC), 64-битных (x86-64 и PPC-64) или для обеих. (Внесено Рональдом Оусореном.)Модуль BerkeleyDB теперь имеет объект C API, доступный как
bsddb.db.api
. Этот объект может быть использован другими расширениями C, которые хотят использовать модульbsddb
для своих целей. (Внесено Дунканом Грисби.)Новый интерфейс буфера, ранее описанный в the PEP 3118 section, добавляет
PyObject_GetBuffer()
иPyBuffer_Release()
, а также несколько других функций.Использование в Python библиотеки C stdio теперь потокобезопасно, или, по крайней мере, настолько потокобезопасно, насколько безопасна базовая библиотека. Давняя потенциальная ошибка возникала, если один поток закрывал файловый объект, в то время как другой поток читал из этого объекта или записывал в него. В версии 2.6 файловые объекты имеют счетчик ссылок, которым управляют функции
PyFile_IncUseCount()
иPyFile_DecUseCount()
. Файловые объекты не могут быть закрыты, если счетчик ссылок не равен нулю.PyFile_IncUseCount()
следует вызывать, пока GIL еще удерживается, перед выполнением операции ввода-вывода с использованием указателяFILE *
, аPyFile_DecUseCount()
следует вызывать сразу после повторного получения GIL. (При участии Антуана Питру и Грегори П. Смита).Импортирование модулей одновременно в двух разных потоках больше не приводит к тупиковым ситуациям; теперь при этом будет возникать ошибка
ImportError
. Новая функция API,PyImport_ImportModuleNoBlock()
, сначала ищет модуль вsys.modules
, а затем пытается импортировать его после получения блокировки импорта. Если блокировка импорта принадлежит другому потоку, будет выдано предупреждениеImportError
. (Внесено Кристианом Хаймсом.)Несколько функций возвращают информацию о поддержке платформы с плавающей точкой.
PyFloat_GetMax()
возвращает максимальное представимое значение с плавающей точкой, аPyFloat_GetMin()
- минимальное положительное значение.PyFloat_GetInfo()
возвращает объект, содержащий дополнительную информацию из файлаfloat.h
, такую как"mant_dig"
(количество цифр в мантиссе),"epsilon"
(наименьшая разница между 1.0 и следующим наибольшим представимым значением) и некоторые другие. (Внесено Кристианом Хаймсом; bpo-1534).Функции и методы языка Си, использующие
PyComplex_AsCComplex()
, теперь будут принимать аргументы, имеющие метод__complex__()
. В частности, функции в модулеcmath
теперь будут принимать объекты с этим методом. Это обратный перенос изменения, внесенного в Python 3.0. (Внесено Марком Дикинсоном; bpo-1675423).API Python на языке C теперь включает две функции для сравнения строк без учета регистра,
PyOS_stricmp(char*, char*)
иPyOS_strnicmp(char*, char*, Py_ssize_t)
. (Вклад Кристиана Хаймса; bpo-1635).Многие расширения языка C определяют свой собственный маленький макрос для добавления целых чисел и строк в словарь модуля в функции
init*
. В Python 2.6 наконец-то определены стандартные макросы для добавления значений в модуль,PyModule_AddStringMacro
иPyModule_AddIntMacro()
. (При участии Кристиана Хаймса.)Некоторые макросы были переименованы в 3.0 и 2.6, чтобы было понятнее, что это макросы, а не функции.
Py_Size()
сталPy_SIZE()
,Py_Type()
сталPy_TYPE()
, аPy_Refcnt()
сталPy_REFCNT()
. Макросы со смешанным регистром по-прежнему доступны в Python 2.6 для обратной совместимости. (bpo-1629)Distutils теперь помещает создаваемые расширения C в другой каталог при запуске на отладочной версии Python. (Внесено Коллином Уинтером; bpo-1530959).
Некоторые базовые типы данных, такие как целые числа и строки, поддерживают внутренние свободные списки объектов, которые могут быть использованы повторно. Структуры данных для этих свободных списков теперь следуют соглашению об именовании: переменная всегда называется
free_list
, счетчик всегда называетсяnumfree
, и всегда определен макросPy<typename>_MAXFREELIST
.Новая цель Makefile, «make patchcheck», подготавливает дерево исходников Python к созданию патча: она исправляет пробелы во всех измененных файлах
.py
, проверяет, была ли изменена документация, и сообщает, были ли обновлены файлыMisc/ACKS
иMisc/NEWS
. (Внесено Бреттом Кэнноном.)Еще одна новая цель, «make profile-opt», компилирует двоичный файл Python, используя оптимизацию GCC с учетом профиля. Она компилирует Python с включенным профилированием, запускает набор тестов для получения набора результатов профилирования, а затем компилирует, используя эти результаты для оптимизации. (Внесено Грегори П. Смитом.)
Изменения, специфичные для порта: 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, которые импортируют другие модули.API C: типы данных расширения, которые не должны быть хэшируемыми, должны определять свой слот
tp_hash
наPyObject_HashNotImplemented()
.Исключение модуля
socket
socket.error
теперь наследуется отIOError
. Ранее оно не было подклассомStandardError
, но теперь является, черезIOError
. (Реализовано Грегори П. Смитом; bpo-1706815).Модуль
xmlrpclib
больше не преобразует автоматическиdatetime.date
иdatetime.time
к типуxmlrpclib.DateTime
; семантика преобразования не всегда была корректной для всех приложений. Код, использующийxmlrpclib
, должен преобразовывать экземплярыdate
иtime
. (bpo-1330538)(3.0 - режим предупреждения) Класс
Exception
теперь предупреждает при обращении к нему с использованием срезов или индексного доступа; от использования классаException
, ведущего себя как кортеж, постепенно отказываются.(режим 3.0-warning) сравнения неравенств между двумя словарями или двумя объектами, которые не реализуют методы сравнения, сообщаются как предупреждения.
dict1 == dict2
все еще работает, ноdict1 < dict2
постепенно выводится из употребления.Сравнения между ячейками, которые являются деталью реализации правил скопирования Python, также вызывают предупреждения, поскольку такие сравнения полностью запрещены в версии 3.0.
Благодарности¶
Автор хотел бы поблагодарить следующих людей за предложения, исправления и помощь в работе над различными черновиками этой статьи: Georg Brandl, Steve Brown, Nick Coghlan, Ralph Corderoy, Jim Jewett, Kent Johnson, Chris Lambacher, Martin Michlmayr, Antoine Pitrou, Brian Warner.