5. Встроенные типы¶Built-in Types

5.1. Проверка истинности¶Truth Value Testing

Любой объект может быть проверен на истинность для использования в условии if или while, а также в качестве операнда булевых операций ниже. Следующие значения считаются ложными:

• None

• False

• ноль любого числового типа, например, 0, 0L, 0.0, 0j.

• любая пустая последовательность, например, '', (), [].

• любое пустое отображение, например, {}.

• экземпляры пользовательских классов, если класс определяет метод __nonzero__() или __len__(), и этот метод возвращает целый ноль или значение bool False. 1

Все остальные значения считаются истинными – поэтому объекты многих типов всегда истинны.

Операции и встроенные функции, возвращающие булев результат, всегда возвращают 0 или False для ложного и 1 или True для истинного, если не указано иное. (Важное исключение: булевы операции or и and всегда возвращают один из своих операндов.)

5.2. Булевы операции – and, or, not¶Boolean Operations – and, or, not

Это булевы операции в порядке возрастания приоритета:

Примечания:

1. Это оператор с сокращённым вычислением: второй аргумент вычисляется, только если первый ложен.

2. Это оператор с сокращённым вычислением: второй аргумент вычисляется, только если первый истинен.

3. not имеет более низкий приоритет, чем небулевы операторы, поэтому not a == b интерпретируется как not (a == b), а a == not b является синтаксической ошибкой.

5.3. Сравнения¶Comparisons

Операции сравнения поддерживаются всеми объектами. Все они имеют одинаковый приоритет (который выше, чем у логических операций). Сравнения можно произвольно объединять в цепочки; например, x < y <= z эквивалентно x < y and y <= z, за исключением того, что y вычисляется только один раз (но в обоих случаях z не вычисляется вообще, если x < y оказывается ложным).

В этой таблице приведены операции сравнения:

Примечания:

1. != можно также записать как <>, но это устаревшее использование, сохранённое только для обратной совместимости. В новом коде всегда следует использовать !=.

Объекты разных типов, за исключением разных числовых типов и разных строковых типов, никогда не сравниваются как равные; такие объекты упорядочиваются последовательно, но произвольно (таким образом, сортировка разнородного массива даёт согласованный результат). Кроме того, некоторые типы (например, файловые объекты) поддерживают лишь вырожденное понятие сравнения, при котором любые два объекта этого типа неравны. Опять же, такие объекты упорядочиваются произвольно, но последовательно. Операторы <, <=, > и >= вызовут исключение TypeError, если любой операнд является комплексным числом.

Неидентичные экземпляры класса обычно сравниваются как неравные, если только класс не определяет метод __eq__() или метод __cmp__().

Экземпляры класса нельзя упорядочить по отношению к другим экземплярам того же класса или объектам других типов, если только класс не определяет достаточное количество методов расширенного сравнения (__lt__(), __le__(), __gt__() и __ge__()) или метод __cmp__().

Ещё две операции с тем же синтаксическим приоритетом, in и not in, поддерживаются только типами последовательностей (см. ниже).

5.4. Числовые типы – int, float, long, complex¶Numeric Types – int, float, long, complex

Существует четыре различных числовых типа: обычные целые числа, длинные целые числа, числа с плавающей точкой и комплексные числа. Кроме того, логические значения являются подтипом обычных целых чисел. Обычные целые числа (также называемые целыми числами) реализованы с использованием long в C, что даёт им точность не менее 32 бит (sys.maxint всегда установлено в максимальное значение обычного целого для текущей платформы, минимальное значение – -sys.maxint - 1). Длинные целые числа имеют неограниченную точность. Числа с плавающей точкой обычно реализуются с помощью double в C; информация о точности и внутреннем представлении чисел с плавающей точкой для машины, на которой выполняется программа, доступна в sys.float_info. Комплексные числа имеют действительную и мнимую части, каждая из которых является числом с плавающей точкой. Чтобы извлечь эти части из комплексного числа z, используйте z.real и z.imag. (Стандартная библиотека включает дополнительные числовые типы: fractions, хранящие рациональные числа, и decimal, хранящие числа с плавающей точкой с настраиваемой точностью.)

Числа создаются с помощью числовых литералов или как результат встроенных функций и операторов. Обычные целочисленные литералы (включая двоичные, шестнадцатеричные и восьмеричные числа) дают обычные целые числа, если только обозначаемое ими значение не слишком велико для представления в виде обычного целого; в этом случае они дают длинное целое число. Целочисленные литералы с суффиксом 'L' или 'l' дают длинные целые числа ('L' предпочтительнее, потому что 1l слишком похоже на одиннадцать!). Числовые литералы, содержащие десятичную точку или знак экспоненты, дают числа с плавающей точкой. Добавление 'j' или 'J' к числовому литералу даёт мнимое число (комплексное число с нулевой действительной частью), которое можно добавить к целому числу или числу с плавающей точкой, чтобы получить комплексное число с действительной и мнимой частями.

Python полностью поддерживает смешанную арифметику: когда бинарный арифметический оператор имеет операнды разных числовых типов, операнд с более «узким» типом расширяется до типа другого операнда, при этом обычное целое у́же длинного целого, длинное целое у́же числа с плавающей точкой, а число с плавающей точкой у́же комплексного. Сравнения между числами смешанных типов используют то же правило. 2 Конструкторы int(), long(), float() и complex() можно использовать для получения чисел конкретного типа.

Все встроенные числовые типы поддерживают следующие операции. Смотрите Оператор возведения в степень и последующие разделы для получения информации о приоритетах операторов.

Примечания:

1. Для целочисленного деления (обычных или длинных целых) результатом является целое число. Результат всегда округляется в сторону минус бесконечности: 1/2 равно 0, (-1)/2 равно -1, 1/(-2) равно -1 и (-1)/(-2) равно 0. Обратите внимание, что результат будет длинным целым, если хотя бы один операнд является длинным целым, независимо от числового значения.

2. Преобразование из чисел с плавающей точкой с помощью int() или long() отбрасывает дробную часть в сторону нуля, как и родственная функция math.trunc(). Используйте функцию math.floor() для округления вниз и math.ceil() для округления вверх.

3. См. Встроенные функции для полного описания.

4. Устарело с версии 2.3: Оператор целочисленного деления, оператор взятия остатка и функция divmod() больше не определены для комплексных чисел. Вместо этого при необходимости преобразуйте в число с плавающей точкой с помощью функции abs().

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

6. float также принимает строки “nan” и “inf” с необязательным префиксом “+” или “-” для Not a Number (NaN) и положительной или отрицательной бесконечности.

   Новое в версии 2.6.

7. Python определяет pow(0, 0) и 0 ** 0 как 1, что общепринято для языков программирования.

Все типы numbers.Real (int, long и float) также включают следующие операции:

[sign] ['0x'] integer ['.' fraction] ['p' exponent]

>>> float.fromhex('0x3.a7p10')
3740.0

>>> float.hex(3740.0)
'0x1.d380000000000p+11'

5.5. Типы итераторов¶Iterator Types

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

Для поддержки итерации в объектах-контейнерах необходимо определить один метод:

container.__iter__()¶

Возвращает объект-итератор. Этот объект должен поддерживать протокол итератора, описанный ниже. Если контейнер поддерживает разные типы итерации, можно предоставить дополнительные методы для явного запроса итераторов для этих типов. (Примером объекта, поддерживающего несколько форм итерации, может служить древовидная структура, поддерживающая обход как в ширину, так и в глубину.) Этот метод соответствует слоту tp_iter структуры типа для объектов Python в API Python/C.

Сами объекты итераторов должны поддерживать следующие два метода, которые вместе образуют протокол итератора:

iterator.__iter__()¶

Возвращает сам объект-итератор. Это необходимо, чтобы контейнеры и итераторы можно было использовать с операторами for и in. Данный метод соответствует слоту tp_iter структуры типа для объектов Python в API Python/C.

iterator.next()¶

Возвращает следующий элемент из контейнера. Если больше элементов нет, возбуждает исключение StopIteration. Этот метод соответствует слоту tp_iternext структуры типа для объектов Python в API Python/C.

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

Протокол предполагает, что если метод next() итератора однажды возбудил StopIteration, то при последующих вызовах он будет продолжать возбуждать то же исключение. Реализации, нарушающие это правило, считаются некорректными. (Ограничение добавлено в Python 2.3; в Python 2.2 многие итераторы этому правилу не соответствовали.)

5.6. Типы последовательностей – str, unicode, list, tuple, bytearray, buffer, xrange¶Sequence Types – str, unicode, list, tuple, bytearray, buffer, xrange

Существует семь типов последовательностей: строки, строки Unicode, списки, кортежи, bytearrays, buffers и объекты xrange.

Для других контейнеров см. встроенные классы dict и set, а также модуль collections.

Строковые литералы записываются в одинарных или двойных кавычках: 'xyzzy', "frobozz". См. Строковые литералы для получения дополнительной информации о строковых литералах. Строки Unicode во многом похожи на строки, но в синтаксисе обозначаются предшествующим символом 'u': u'abc', u"def". В дополнение к описанной здесь функциональности существуют также строковые методы, описанные в разделе Строковые методы. Списки создаются с помощью квадратных скобок, элементы разделяются запятыми: [a, b, c]. Кортежи создаются оператором запятой (не в квадратных скобках), с enclosing parentheses или без, но пустой кортеж должен заключаться в скобки, например a, b, c или (). Кортеж из одного элемента должен иметь завершающую запятую, например (d,).

Объекты bytearray создаются с помощью встроенной функции bytearray().

Объекты buffer не поддерживаются напрямую синтаксисом Python, но могут быть созданы вызовом встроенной функции buffer(). Они не поддерживают конкатенацию или повторение.

Объекты типа xrange похожи на буферы тем, что для их создания нет специального синтаксиса, но они создаются с помощью функции xrange(). Они не поддерживают срезы, конкатенацию или повторение, и использование in, not in, min() или max() для них неэффективно.

Большинство типов последовательностей поддерживают следующие операции. Операции in и not in имеют тот же приоритет, что и операции сравнения. Операции + и * имеют тот же приоритет, что и соответствующие числовые операции. 3 Дополнительные методы предоставляются для Изменяемых типов последовательностей.

В этой таблице перечислены операции над последовательностями, отсортированные по возрастанию приоритета. В таблице s и t – последовательности одного типа; n, i и j – целые числа.

Типы последовательностей также поддерживают сравнение. В частности, кортежи и списки сравниваются лексикографически путём сравнения соответствующих элементов. Это означает, что для равенства каждый элемент должен быть равен, а обе последовательности должны быть одного типа и иметь одинаковую длину. (Подробнее см. Сравнения в справочнике по языку.)

Примечания:

1. Когда s является строкой или строкой Unicode, операции in и not in действуют как проверка на подстроку. В версиях Python до 2.3 x должна была быть строкой длины 1. В Python 2.3 и новее x может быть строкой любой длины.

2. Значения n меньше 0 трактуются как 0 (что даёт пустую последовательность того же типа, что и s). Обратите внимание: элементы последовательности s не копируются; на них ссылаются многократно. Это часто преследует начинающих программистов Python; рассмотрите:

   >>> lists = [[]] * 3
   >>> lists
   [[], [], []]
   >>> lists[0].append(3)
   >>> lists
   [[3], [3], [3]]
   

   Произошло следующее: [[]] – это список из одного элемента, содержащего пустой список, поэтому все три элемента [[]] * 3 являются ссылками на этот единственный пустой список. Изменение любого из элементов lists изменяет этот единственный список. Создать список из разных списков можно так:

   >>> lists = [[] for i in range(3)]
   >>> lists[0].append(3)
   >>> lists[1].append(5)
   >>> lists[2].append(7)
   >>> lists
   [[3], [5], [7]]
   

   Подробное объяснение доступно в разделе FAQ Как создать многомерный список?.

3. Если i или j отрицательно, индекс отсчитывается от конца последовательности s: подставляется len(s) + i или len(s) + j. Но обратите внимание, что -0 по-прежнему равно 0.

4. Срез s от i до j определяется как последовательность элементов с индексом k, для которых i <= k < j. Если i или j больше len(s), используйте len(s). Если i опущен или равен None, используйте 0. Если j опущен или равен None, используйте len(s). Если i больше или равно j, срез пуст.

5. The slice of s from i to j with step k is defined as the sequence of items with index x = i + n*k such that 0 <= n < (j-i)/k. In other words, the indices are i, i+k, i+2*k, i+3*k and so on, stopping when j is reached (but never including j). When k is positive, i and j are reduced to len(s) if they are greater. When k is negative, i and j are reduced to len(s) - 1 if they are greater. If i or j are omitted or None, they become “end” values (which end depends on the sign of k). Note, k cannot be zero. If k is None, it is treated like 1.

6. Особенность реализации CPython: Если s и t обе являются строками, некоторые реализации Python, такие как CPython, обычно могут выполнять оптимизацию на месте для присваиваний вида s = s + t или s += t. Когда это применимо, такая оптимизация значительно снижает вероятность квадратичного времени выполнения. Эта оптимизация зависит от версии и реализации. Для кода, чувствительного к производительности, предпочтительнее использовать метод str.join(), который гарантирует стабильную линейную производительность конкатенации во всех версиях и реализациях.

   Изменено в версии 2.4: Ранее конкатенация строк никогда не выполнялась на месте.

>>> print '%(language)s has %(number)03d quote types.' % \
...       {"language": "Python", "number": 2}
Python has 002 quote types.

5.7. Типы множеств – set, frozenset¶Set Types – set, frozenset

Объект set – это неупорядоченная коллекция уникальных хешируемых объектов. Обычно используется для проверки принадлежности, удаления дубликатов из последовательности и выполнения математических операций, таких как пересечение, объединение, разность и симметричная разность. (О других контейнерах см. встроенные классы dict, list и tuple, а также модуль collections.)

Как и другие коллекции, множества поддерживают x in set, len(set) и for x in set. Будучи неупорядоченной коллекцией, множество не запоминает положение элементов или порядок вставки. Поэтому множества не поддерживают индексацию, срезы и другое поведение, свойственное последовательностям.

В Python есть два встроенных типа множеств: set и frozenset. Тип set изменяемый – его содержимое можно менять с помощью методов вроде add() и remove(). Поскольку он изменяемый, у него нет хеш-значения, поэтому его нельзя использовать ни в качестве ключа словаря, ни как элемент другого множества. Тип frozenset неизменяемый и хешируемый – его содержимое нельзя изменить после создания; соответственно, его можно использовать как ключ словаря или как элемент другого множества.

Начиная с Python 2.7, непустые множества (не frozensets) можно создавать, помещая список элементов, разделенных запятыми, в фигурные скобки, например: {'jack', 'sjoerd'}, в дополнение к конструктору set.

Конструкторы обоих классов работают одинаково:

class set([iterable])¶

class frozenset([iterable])¶

Возвращает новый объект set или frozenset, элементы которого берутся из iterable. Элементы множества должны быть хэшируемыми. Чтобы представлять множества множеств, внутренние множества должны быть frozenset объектами. Если iterable не указан, возвращается новое пустое множество.

Экземпляры set и frozenset предоставляют следующие операции:

len(s)

Возвращает количество элементов в множестве s (мощность s).

x in s

Проверяет принадлежность x множеству s.

x not in s

Проверяет отсутствие x в множестве s.

isdisjoint(other)¶

Возвращает True, если у множества нет общих элементов с other. Множества не пересекаются тогда и только тогда, когда их пересечение – пустое множество.

Новое в версии 2.6.

issubset(other)¶

set <= other

Проверяет, принадлежит ли каждый элемент множества множеству other.

set < other

Проверяет, является ли множество строгим подмножеством other, то есть set <= other and set != other.

issuperset(other)¶

set >= other

Проверяет, принадлежит ли каждый элемент other множеству.

set > other

Проверяет, является ли множество строгим надмножеством other, то есть set >= other and set != other.

union(*others)¶

set | other | ...

Возвращает новое множество, содержащее элементы из исходного множества и всех остальных.

Изменено в версии 2.6: Принимает несколько входных итерабельных объектов.

intersection(*others)¶

set & other & ...

Возвращает новое множество, содержащее элементы, общие для исходного множества и всех остальных.

Изменено в версии 2.6: Принимает несколько входных итерабельных объектов.

difference(*others)¶

set - other - ...

Возвращает новое множество, содержащее элементы исходного множества, которых нет в других.

Изменено в версии 2.6: Принимает несколько входных итерабельных объектов.

symmetric_difference(other)¶

set ^ other

Возвращает новое множество, содержащее элементы, которые есть либо в исходном множестве, либо в other, но не в обоих.

copy()¶

Возвращает поверхностную копию множества.

Замечание: версии методов union(), intersection(), difference(), symmetric_difference(), issubset() и issuperset() без операторов принимают любой итерируемый объект в качестве аргумента. В отличие от них, их операторные аналоги требуют, чтобы аргументы были множествами. Это исключает подверженные ошибкам конструкции вроде set('abc') & 'cbs' в пользу более читаемой set('abc').intersection('cbs').

И set, и frozenset поддерживают сравнение множеств. Два множества равны тогда и только тогда, когда каждый элемент одного содержится в другом (каждое является подмножеством другого). Множество меньше другого тогда и только тогда, когда первое является собственным подмножеством второго (является подмножеством, но не равным). Множество больше другого тогда и только тогда, когда первое является собственным надмножеством второго (является надмножеством, но не равным).

Экземпляры set сравниваются с экземплярами frozenset на основе их элементов. Например, set('abc') == frozenset('abc') возвращает True, и то же самое делает set('abc') in set([frozenset('abc')]).

Сравнения на подмножество и равенство не обобщаются до функции полного упорядочения. Например, любые два непустых непересекающихся множества не равны и не являются подмножествами друг друга, поэтому все из следующих возвращают False: a<b, a==b или a>b. Соответственно, множества не реализуют метод __cmp__().

Поскольку множества определяют лишь частичное упорядочение (отношения подмножеств), результат метода list.sort() для списков множеств не определён.

Элементы множества, как и ключи словаря, должны быть хэшируемыми.

Бинарные операции, в которых смешиваются экземпляры set и frozenset, возвращают тип первого операнда. Например: frozenset('ab') | set('bc') возвращает экземпляр frozenset.

В следующей таблице перечислены операции, доступные для set, которые не применимы к неизменяемым экземплярам frozenset:

update(*others)¶

set |= other | ...

Обновляет множество, добавляя элементы из всех других.

Изменено в версии 2.6: Принимает несколько входных итерабельных объектов.

intersection_update(*others)¶

set &= other & ...

Обновляет множество, оставляя только те элементы, которые есть в нём и во всех других.

Изменено в версии 2.6: Принимает несколько входных итерабельных объектов.

difference_update(*others)¶

set -= other | ...

Обновляет множество, удаляя элементы, найденные в других.

Изменено в версии 2.6: Принимает несколько входных итерабельных объектов.

symmetric_difference_update(other)¶

set ^= other

Обновляет множество, оставляя только элементы, которые есть в одном из множеств, но не в обоих.

add(elem)¶

Добавляет элемент elem в множество.

remove(elem)¶

Удаляет элемент elem из множества. Вызывает KeyError, если elem отсутствует в множестве.

discard(elem)¶

Удаляет элемент elem из множества, если он присутствует.

pop()¶

Удаляет и возвращает произвольный элемент множества. Вызывает KeyError, если множество пусто.

clear()¶

Удаляет все элементы из множества.

Обратите внимание: не-операторные версии методов update(), intersection_update(), difference_update() и symmetric_difference_update() принимают любой итерируемый объект в качестве аргумента.

Примечание: аргумент elem для методов __contains__(), remove() и discard() может быть множеством. Для поддержки поиска эквивалентного замороженного множества создается временное множество из elem.

5.8. Типы отображений – dict¶Mapping Types – dict

Объект отображение сопоставляет хешируемые значения с произвольными объектами. Отображения – изменяемые объекты. В настоящее время существует только один стандартный тип отображения – словарь. (О других контейнерах см. встроенные классы list, set и tuple, а также модуль collections.)

Ключи словаря могут быть почти любыми значениями. Значения, которые не являются хэшируемыми, то есть содержат списки, словари или другие изменяемые типы (которые сравниваются по значению, а не по идентичности объекта), не могут использоваться в качестве ключей. Числовые типы, используемые в качестве ключей, подчиняются обычным правилам числового сравнения: если два числа равны (например, 1 и 1.0), то их можно взаимозаменяемо использовать для индексации одной и той же записи словаря. (Однако имейте в виду, что поскольку компьютеры хранят числа с плавающей запятой как приближенные значения, обычно неразумно использовать их в качестве ключей словаря.)

Словари можно создать, поместив разделённый запятыми список пар key: value в фигурные скобки, например: {'jack': 4098, 'sjoerd': 4127} или {4098: 'jack', 4127: 'sjoerd'}, либо с помощью конструктора dict.

class dict(**kwarg)¶

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

Возвращает новый словарь, инициализированный из необязательного позиционного аргумента и, возможно, пустого набора именованных аргументов.

Если позиционный аргумент не указан, создаётся пустой словарь. Если позиционный аргумент указан и является объектом отображения (mapping), создаётся словарь с теми же парами ключ-значение, что и у объекта отображения. В противном случае позиционный аргумент должен быть итерируемым объектом. Каждый элемент итерируемого объекта сам должен быть итерируемым объектом, содержащим ровно два объекта. Первый объект каждого элемента становится ключом в новом словаре, а второй – соответствующим значением. Если ключ встречается более одного раза, последнее значение для этого ключа становится соответствующим значением в новом словаре.

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

В качестве иллюстрации следующие примеры возвращают словарь, равный {"one": 1, "two": 2, "three": 3}:

>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> a == b == c == d == e
True

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

Новое в версии 2.2.

Изменено в версии 2.3: Добавлена поддержка создания словаря из именованных аргументов.

Вот операции, которые поддерживают словари (и, следовательно, должны поддерживать пользовательские типы отображений):

len(d)

Возвращает количество элементов в словаре d.

d[key]

Возвращает элемент d с ключом key. Возбуждает KeyError, если key отсутствует в отображении.

Если подкласс dict определяет метод __missing__(), а key отсутствует, операция d[key] вызывает этот метод с ключом key в качестве аргумента. Затем операция d[key] возвращает или возбуждает результат вызова __missing__(key). Никакие другие операции или методы не вызывают __missing__(). Если __missing__() не определён, возбуждается KeyError. __missing__() должен быть методом; он не может быть переменной экземпляра:

>>> class Counter(dict):
...     def __missing__(self, key):
...         return 0
>>> c = Counter()
>>> c['red']
0
>>> c['red'] += 1
>>> c['red']
1

В примере выше показана часть реализации collections.Counter. Для collections.defaultdict используется другой метод __missing__.

Новое в версии 2.5: Распознавание методов __missing__ подклассов dict.

d[key] = value

Устанавливает d[key] в значение value.

del d[key]

Удаляет d[key] из d. Вызывает KeyError, если key отсутствует в отображении.

key in d

Возвращает True, если d содержит ключ key, иначе False.

Новое в версии 2.2.

key not in d

Эквивалентно not key in d.

Новое в версии 2.2.

iter(d)

Возвращает итератор по ключам словаря. Это краткая форма записи для iterkeys().

clear()¶

Удаляет все элементы из словаря.

copy()¶

Возвращает поверхностную копию словаря.

fromkeys(seq[, value])¶

Создаёт новый словарь, ключи которого берутся из seq, а значения устанавливаются равными value.

fromkeys() – это метод класса, возвращающий новый словарь. value по умолчанию равен None.

Новое в версии 2.3.

get(key[, default])¶

Возвращает значение для key, если key присутствует в словаре, иначе default. Если default не указан, по умолчанию принимается None, поэтому этот метод никогда не вызывает исключение KeyError.

has_key(key)¶

Проверяет наличие key в словаре. has_key() устарело в пользу key in d.

items()¶

Возвращает копию списка пар (key, value) словаря.

Особенности реализации CPython: Ключи и значения перечисляются в произвольном порядке, который не является случайным, различается в разных реализациях Python и зависит от истории вставок и удалений в словаре.

Если items(), keys(), values(), iteritems(), iterkeys() и itervalues() вызываются без промежуточных изменений словаря, списки будут напрямую соответствовать друг другу. Это позволяет создавать пары (value, key) с помощью zip(): pairs = zip(d.values(), d.keys()). То же отношение справедливо для методов iterkeys() и itervalues(): pairs = zip(d.itervalues(), d.iterkeys()) предоставляет то же значение для pairs. Другой способ создать тот же список – pairs = [(v, k) for (k, v) in d.iteritems()].

iteritems()¶

Возвращает итератор по парам (key, value) словаря. См. примечание к dict.items().

Использование iteritems() при добавлении или удалении записей в словаре может вызвать RuntimeError или не позволить перебрать все записи.

Новое в версии 2.2.

iterkeys()¶

Возвращает итератор по ключам словаря. См. примечание к dict.items().

Использование iterkeys() при добавлении или удалении записей в словаре может вызвать RuntimeError или не позволить перебрать все записи.

Новое в версии 2.2.

itervalues()¶

Возвращает итератор по значениям словаря. См. примечание к dict.items().

Использование itervalues() при добавлении или удалении записей в словаре может вызвать RuntimeError или не позволить перебрать все записи.

Новое в версии 2.2.

keys()¶

Возвращает копию списка ключей словаря. См. примечание к dict.items().

pop(key[, default])¶

Если key присутствует в словаре, удаляет его и возвращает значение, иначе возвращает default. Если default не указан и key отсутствует в словаре, возбуждается KeyError.

Новое в версии 2.3.

popitem()¶

Удаляет и возвращает произвольную пару (key, value) из словаря.

popitem() полезен для разрушающего обхода словаря, как часто используется в алгоритмах над множествами. Если словарь пуст, вызов popitem() вызывает исключение KeyError.

setdefault(key[, default])¶

Если key есть в словаре, возвращает его значение. Если нет, вставляет key со значением default и возвращает default. default по умолчанию равен None.

update([other])¶

Обновляет словарь парами ключ/значение из other, перезаписывая существующие ключи. Возвращает None.

update() принимает либо другой объект словаря, либо итерируемый объект пар ключ/значение (в виде кортежей или других итерируемых объектов длиной два). Если указаны именованные аргументы, словарь затем обновляется этими парами ключ/значение: d.update(red=1, blue=2).

Изменено в версии 2.4: Разрешено передавать итерируемый объект пар ключ/значение, а также именованные аргументы.

values()¶

Возвращает копию списка значений словаря. См. примечание к dict.items().

viewitems()¶

Возвращает новое представление элементов словаря (пары (key, value)). См. ниже документацию объектов представления.

Новое в версии 2.7.

viewkeys()¶

Возвращает новое представление ключей словаря. См. ниже документацию объектов представления.

Новое в версии 2.7.

viewvalues()¶

Возвращает новое представление значений словаря. См. ниже документацию объектов представления.

Новое в версии 2.7.

Словари считаются равными тогда и только тогда, когда они содержат одни и те же пары (key, value).

>>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
>>> keys = dishes.viewkeys()
>>> values = dishes.viewvalues()

>>> # итерация
>>> n = 0
>>> for val in values:
...     n += val
>>> print(n)
504

>>> # ключи и значения перебираются в одном и том же порядке
>>> list(keys)
['eggs', 'bacon', 'sausage', 'spam']
>>> list(values)
[2, 1, 1, 500]

>>> # объекты представления динамичны и отражают изменения словаря
>>> del dishes['eggs']
>>> del dishes['sausage']
>>> list(keys)
['spam', 'bacon']

>>> # операции над множествами
>>> keys & {'eggs', 'bacon', 'salad'}
{'bacon'}

5.9. Файловые объекты¶File Objects

Файловые объекты реализованы с помощью пакета stdio языка C и могут быть созданы с помощью встроенной функции open(). Файловые объекты также возвращаются некоторыми другими встроенными функциями и методами, такими как os.popen() и os.fdopen(), а также методом makefile() объектов сокетов. Временные файлы можно создавать с помощью модуля tempfile, а высокоуровневые файловые операции, такие как копирование, перемещение и удаление файлов и каталогов, можно выполнять с помощью модуля shutil.

Когда файловая операция завершается ошибкой по причине, связанной с вводом-выводом, возбуждается исключение IOError. Сюда входят ситуации, когда операция не определена по какой-либо причине, например, seek() на устройстве tty или запись в файл, открытый для чтения.

Файлы имеют следующие методы:

file.close()¶

Закрывает файл. Закрытый файл нельзя больше читать или записывать. Любая операция, требующая, чтобы файл был открыт, возбудит ValueError после закрытия файла. Допускается вызов close() более одного раза.

Начиная с Python 2.5, можно избежать явного вызова этого метода, если использовать оператор with. Например, следующий код автоматически закроет f при выходе из блока with:

from __future__ import with_statement # Это не требуется в Python 2.6

with open("hello.txt") as f:
    for line in f:
        print line,

В более старых версиях Python для достижения того же эффекта приходилось делать так:

f = open("hello.txt")
try:
    for line in f:
        print line,
finally:
    f.close()

Примечание

Не все «файлоподобные» типы в Python поддерживают использование в качестве менеджера контекста для оператора with. Если ваш код предназначен для работы с любым файлоподобным объектом, можно использовать функцию contextlib.closing() вместо непосредственного использования объекта.

file.flush()¶

Сбрасывает внутренний буфер, как fflush() из stdio. На некоторых файлоподобных объектах это может быть пустой операцией.

Примечание

flush() не обязательно записывает данные файла на диск. Используйте flush() с последующим os.fsync(), чтобы гарантировать это поведение.

file.fileno()¶

Возвращает целочисленный «файловый дескриптор», используемый нижележащей реализацией для запроса операций ввода-вывода у операционной системы. Это может быть полезно для других низкоуровневых интерфейсов, использующих файловые дескрипторы, таких как модуль fcntl или os.read() и аналоги.

Примечание

Файлоподобные объекты, у которых нет реального файлового дескриптора, не должны предоставлять этот метод!

file.isatty()¶

Возвращает True, если файл подключён к tty-устройству (или подобному), иначе False.

Примечание

Если файлоподобный объект не связан с реальным файлом, этот метод не следует реализовывать.

file.next()¶

Файловый объект является собственным итератором; например, iter(f) возвращает f (если только f не закрыт). Когда файл используется как итератор, обычно в цикле for (например, for line in f: print line.strip()), многократно вызывается метод next(). Этот метод возвращает следующую строку ввода или возбуждает StopIteration при достижении EOF, если файл открыт для чтения (поведение не определено, если файл открыт для записи). Чтобы сделать цикл for наиболее эффективным способом перебора строк файла (очень распространённая операция), метод next() использует скрытый буфер упреждающего чтения. Из-за использования такого буфера комбинирование next() с другими методами файла (например, readline()) работает неправильно. Однако использование seek() для перемещения в абсолютную позицию сбрасывает буфер упреждающего чтения.

Новое в версии 2.3.

file.read([size])¶

Читает не более size байт из файла (меньше, если при чтении EOF встречен до получения size байт). Если аргумент size отрицателен или опущен, читаются все данные до EOF. Байты возвращаются в виде строкового объекта. Пустая строка возвращается, если EOF встречается сразу. (Для некоторых файлов, например tty, имеет смысл продолжать чтение после EOF.) Обратите внимание, что этот метод может вызывать нижележащую C-функцию fread() более одного раза, чтобы получить как можно ближе к size байт. Также заметьте, что в неблокирующем режиме может быть возвращено меньше данных, чем запрошено, даже если параметр size не был задан.

Примечание

Эта функция – просто обёртка для нижележащей C-функции fread() и будет вести себя так же в угловых случаях, например, кэшируется ли значение EOF.

file.readline([size])¶

Читает одну целую строку из файла. Завершающий символ новой строки сохраняется в строке (но может отсутствовать, если файл заканчивается неполной строкой). 6 Если аргумент size присутствует и неотрицателен, он указывает максимальное количество байт (включая завершающий перевод строки), и может быть возвращена неполная строка. Когда size не равен 0, пустая строка возвращается только, если EOF встречается сразу.

Примечание

В отличие от stdio метода fgets(), возвращаемая строка содержит нулевые символы ('\0'), если они встречались во входных данных.

file.readlines([sizehint])¶

Читает до EOF с помощью readline() и возвращает список, содержащий прочитанные таким образом строки. Если присутствует необязательный аргумент sizehint, то вместо чтения до EOF читаются целые строки общим объёмом приблизительно sizehint байт (возможно, с округлением до размера внутреннего буфера). Объекты, реализующие файлоподобный интерфейс, могут игнорировать sizehint, если его невозможно реализовать или невозможно реализовать эффективно.

file.xreadlines()¶

Этот метод возвращает то же самое, что и iter(f).

Новое в версии 2.1.

Устарело с версии 2.3: Используйте for line in file вместо.

file.seek(offset[, whence])¶

Устанавливает текущую позицию файла, как stdio метод fseek(). Аргумент whence необязателен и по умолчанию равен os.SEEK_SET или 0 (абсолютное позиционирование); другие значения: os.SEEK_CUR или 1 (позиционирование относительно текущей позиции) и os.SEEK_END или 2 (позиционирование относительно конца файла). Возвращаемого значения нет.

Например, f.seek(2, os.SEEK_CUR) продвигает позицию на два, а f.seek(-3, os.SEEK_END) устанавливает позицию на третью с конца.

Обратите внимание: если файл открыт для добавления (режим 'a' или 'a+'), любые операции seek() будут отменены при следующей записи. Если файл открыт только для записи в режиме добавления (режим 'a'), этот метод по сути ничего не делает, но он остаётся полезным для файлов, открытых в режиме добавления с возможностью чтения (режим 'a+'). Если файл открыт в текстовом режиме (без 'b'), допустимы только смещения, возвращаемые tell(). Использование других смещений приводит к неопределённому поведению.

Обратите внимание, что не все файловые объекты допускают перемещение (seekable).

Изменено в версии 2.6: Передача чисел с плавающей запятой в качестве смещения устарела.

file.tell()¶

Возвращает текущую позицию файла, как stdio метод ftell().

Примечание

В Windows tell() может возвращать недопустимые значения (после fgets()) при чтении файлов с переводами строк в стиле Unix. Используйте двоичный режим ('rb'), чтобы обойти эту проблему.

file.truncate([size])¶

Урезает размер файла. Если указан необязательный аргумент size, файл урезается (не более) до этого размера. По умолчанию размер равен текущей позиции. Текущая позиция файла не меняется. Обратите внимание: если указанный размер превышает текущий размер файла, результат зависит от платформы: возможны варианты, что файл останется без изменений, увеличится до указанного размера (как будто заполнен нулями) или увеличится до указанного размера с неопределённым новым содержимым. Доступность: Windows, многие варианты Unix.

file.write(str)¶

Записывает строку в файл. Возвращаемого значения нет. Из-за буферизации строка может фактически не появиться в файле до вызова метода flush() или close().

file.writelines(sequence)¶

Записывает последовательность строк в файл. Последовательность может быть любым итерируемым объектом, порождающим строки, обычно списком строк. Возвращаемого значения нет. (Название задумано так, чтобы соответствовать readlines(); writelines() не добавляет разделители строк.)

Файлы поддерживают протокол итератора. Каждая итерация возвращает тот же результат, что и readline(), и итерация завершается, когда метод readline() возвращает пустую строку.

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

file.closed¶

bool, указывающий текущее состояние файлового объекта. Это атрибут только для чтения; метод close() изменяет значение. Он может быть недоступен на всех файлоподобных объектах.

file.encoding¶

Кодировка, которую использует этот файл. Когда строки Unicode записываются в файл, они преобразуются в байтовые строки с использованием этой кодировки. Кроме того, когда файл подключён к терминалу, этот атрибут содержит кодировку, которую терминал, вероятно, использует (эта информация может быть неверной, если пользователь неправильно настроил терминал). Атрибут только для чтения и может отсутствовать на всех файлоподобных объектах. Он также может быть None, в этом случае файл использует системную кодировку по умолчанию для преобразования строк Unicode.

Новое в версии 2.3.

file.errors¶

Обработчик ошибок Unicode, используемый совместно с кодировкой.

Новое в версии 2.6.

file.mode¶

Режим ввода-вывода для файла. Если файл был создан с помощью встроенной функции open(), это будет значение параметра mode. Это атрибут только для чтения и может отсутствовать на всех файлоподобных объектах.

file.name¶

Если файловый объект был создан с помощью open() – имя файла. В противном случае – некоторая строка, указывающая источник файлового объекта, вида <...>. Это атрибут только для чтения и может отсутствовать на всех файлоподобных объектах.

file.newlines¶

Если Python был собран с поддержкой универсальных символов новой строки (по умолчанию), то существует этот атрибут только для чтения, и для файлов, открытых в режиме чтения с универсальными переводами строк, он отслеживает типы встреченных при чтении символов новой строки. Возможные значения: '\r', '\n', '\r\n', None (неизвестно, ещё не прочитано ни одной новой строки) или кортеж, содержащий все встреченные типы, чтобы указать, что использовались разные соглашения о переводах строк. Для файлов, не открытых в режиме чтения с универсальными переводами строк, значение этого атрибута будет None.

file.softspace¶

Логическое значение, указывающее, нужно ли печатать пробел перед другим значением при использовании оператора print. Классы, пытающиеся имитировать файловый объект, также должны иметь записываемый атрибут softspace, который следует инициализировать нулём. Для большинства классов, реализованных на Python, это будет автоматическим (может потребоваться осторожность для объектов, переопределяющих доступ к атрибутам); типы, реализованные на C, должны предоставлять записываемый атрибут softspace.

Примечание

Этот атрибут используется не для управления оператором print, а для того, чтобы реализация print могла отслеживать своё внутреннее состояние.

5.10. тип memoryview¶memoryview type

Объекты memoryview позволяют коду Python обращаться к внутренним данным объекта, поддерживающего буферный протокол, без копирования. Память обычно интерпретируется как простые байты.

class memoryview(obj)¶

Создаёт memoryview, ссылающийся на obj. obj должен поддерживать буферный протокол. Встроенные объекты, поддерживающие буферный протокол, включают str и bytearray (но не unicode).

memoryview имеет понятие элемента – атомарной единицы памяти, обрабатываемой исходным объектом obj. Для многих простых типов, таких как str и bytearray, элемент – это один байт, но другие сторонние типы могут предоставлять более крупные элементы.

len(view) возвращает общее количество элементов в memoryview, view. Атрибут itemsize выдаст количество байт в одном элементе.

memoryview поддерживает извлечение срезов для доступа к своим данным. Взятие одного индекса вернёт один элемент в виде объекта str. Полный срез приведёт к созданию подпредставления:

>>> v = memoryview('abcefg')
>>> v[1]
'b'
>>> v[-1]
'g'
>>> v[1:4]
<memory at 0x77ab28>
>>> v[1:4].tobytes()
'bce'

Если объект, над которым создано memoryview, допускает изменение своих данных, memoryview поддерживает присваивание срезу:

>>> data = bytearray('abcefg')
>>> v = memoryview(data)
>>> v.readonly
False
>>> v[0] = 'z'
>>> data
bytearray(b'zbcefg')
>>> v[1:4] = '123'
>>> data
bytearray(b'z123fg')
>>> v[2] = 'spam'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: cannot modify size of memoryview object

Обратите внимание, что размер объекта memoryview изменить нельзя.

memoryview имеет два метода:

tobytes()¶

Возвращает данные в буфере в виде байтовой строки (объект класса str).

>>> m = memoryview("abc")
>>> m.tobytes()
'abc'

tolist()¶

Возвращает данные из буфера в виде списка целых чисел.

>>> memoryview("abc").tolist()
[97, 98, 99]

Также доступно несколько атрибутов только для чтения:

format¶

Строка, содержащая формат (в стиле модуля struct) для каждого элемента представления. По умолчанию 'B' – простая байтовая строка.

itemsize¶

Размер каждого элемента memoryview в байтах.

shape¶

Кортеж целых чисел длиной ndim, задающий форму памяти как N-мерного массива.

ndim¶

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

strides¶

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

readonly¶

Логическое значение bool, указывающее, доступна ли память только для чтения.

5.11. Типы менеджеров контекста¶Context Manager Types

Оператор with языка Python поддерживает концепцию контекста выполнения, определяемого менеджером контекста. Это реализовано с помощью двух отдельных методов, которые позволяют пользовательским классам определять контекст выполнения, в который входят перед выполнением тела оператора и из которого выходят при завершении оператора.

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

contextmanager.__enter__()¶

Входит в контекст выполнения и возвращает либо этот объект, либо другой объект, связанный с контекстом выполнения. Значение, возвращаемое этим методом, связывается с идентификатором в предложении as оператора with, использующего данный контекстный менеджер.

Примером менеджера контекста, который возвращает сам себя, является файловый объект. Файловые объекты возвращают себя из __enter__(), чтобы open() можно было использовать как контекстное выражение в операторе with.

Примером контекстного менеджера, возвращающего связанный объект, является менеджер, возвращаемый decimal.localcontext(). Такие менеджеры устанавливают активный десятичный контекст в копию исходного десятичного контекста и затем возвращают эту копию. Это позволяет вносить изменения в текущий десятичный контекст в теле оператора with, не затрагивая код за пределами оператора with.

contextmanager.__exit__(exc_type, exc_val, exc_tb)¶

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

Возврат истинного значения из этого метода приведет к тому, что оператор with подавит исключение и продолжит выполнение с оператора, следующего сразу за оператором with. В противном случае исключение продолжит распространяться после завершения выполнения этого метода. Исключения, возникающие во время выполнения этого метода, заменят любое исключение, возникшее в теле оператора with.

Переданное исключение никогда не должно вызываться повторно явно; вместо этого данный метод должен возвращать ложное значение, указывающее, что метод завершился успешно и не хочет подавлять вызванное исключение. Это позволяет коду управления контекстом (например, contextlib.nested) легко определить, действительно ли метод __exit__() завершился неудачей.

Python определяет несколько контекстных менеджеров для поддержки простой синхронизации потоков, своевременного закрытия файлов или других объектов, а также более простого управления активным контекстом десятичной арифметики. Конкретные типы не рассматриваются особым образом, помимо реализации протокола управления контекстом. См. модуль contextlib для примеров.

Генераторы generators Python и декоратор contextlib.contextmanager decorator предоставляют удобный способ реализации этих протоколов. Если функция-генератор декорирована декоратором contextlib.contextmanager, она вернёт менеджер контекста, реализующий необходимые методы __enter__() и __exit__(), вместо итератора, создаваемого недекорированной функцией-генератором.

Обратите внимание, что в структуре типа для объектов Python в Python/C API нет специального слота для любого из этих методов. Типы расширений, желающие определить эти методы, должны предоставлять их как обычный метод, доступный из Python. По сравнению с накладными расходами на установку контекста выполнения, накладные расходы на один поиск в словаре класса пренебрежимо малы.

5.12. Другие встроенные типы¶Other Built-in Types

Интерпретатор поддерживает несколько других видов объектов. Большинство из них поддерживают только одну или две операции.

>>> class C:
...     def method(self):
...         pass
...
>>> c = C()
>>> c.method.whoami = 'my name is method'  # нельзя установить на методе
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'instancemethod' object has no attribute 'whoami'
>>> c.method.im_func.whoami = 'my name is method'
>>> c.method.whoami
'my name is method'

5.13. Специальные атрибуты¶Special Attributes

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

object.__dict__¶

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

object.__methods__¶

Устарело с версии 2.2: Используйте встроенную функцию dir() для получения списка атрибутов объекта. Этот атрибут больше не доступен.

object.__members__¶

Устарело с версии 2.2: Используйте встроенную функцию dir() для получения списка атрибутов объекта. Этот атрибут больше не доступен.

instance.__class__¶

Класс, которому принадлежит экземпляр класса.

class.__bases__¶

Кортеж базовых классов объекта класса.

definition.__name__¶

Имя класса, типа, функции, метода, дескриптора или экземпляра генератора.

Следующие атрибуты поддерживаются только классами нового стиля.

class.__mro__¶

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

class.mro()¶

Этот метод может быть переопределён метаклассом для настройки порядка разрешения методов для его экземпляров. Он вызывается при создании класса, и его результат сохраняется в __mro__.

class.__subclasses__()¶

Каждый класс нового стиля хранит список слабых ссылок на свои непосредственные подклассы. Этот метод возвращает список всех тех ссылок, которые ещё живы. Пример:

>>> int.__subclasses__()
[<type 'bool'>]

Сноски

1

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

2

Как следствие, список [1, 2] считается равным [1.0, 2.0], и аналогично для кортежей.

3

Они должны иметь, поскольку синтаксический анализатор не может определить тип операндов.

4(1,2,3,4)

Символы с учётом регистра – это те, у которых свойство общей категории является одним из «Lu» (буква, верхний регистр), «Ll» (буква, нижний регистр) или «Lt» (буква, заглавная).

5

Чтобы отформатировать только кортеж, следует предоставить одноэлементный кортеж, единственным элементом которого является форматируемый кортеж.

6

Преимущество сохранения символа новой строки в том, что возврат пустой строки является однозначным признаком конца файла (EOF). Также можно определить, заканчивается ли последняя строка файла символом новой строки или нет (да, такое бывает!), что может иметь значение, например, при создании точной копии файла во время построчного чтения.