Встроенные типы

В следующих разделах описаны стандартные типы, встроенные в интерпретатор.

Основные встроенные типы — это числовые, последовательности, отображения, файлы, классы, экземпляры и исключения.

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

1. Проверка истинности

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

• None
• False
• ноль любого числового типа, например, 0, 0L, 0.0, 0j.
• любая пустая последовательность, например, '', (), [].
• любое пустое отображение, например, {}.
• экземпляры классов, определённых пользователем, если класс определяет метод __nonzero__() или __len__(), когда этот метод возвращает целое число ноль или значение bool False. 1

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

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

2. Логические операции — and, or, not

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

Примечания:

1. Это оператор короткого замыкания, поэтому он оценивает второй аргумент только если первый ложный.
2. Это оператор короткого замыкания, поэтому он оценивает второй аргумент только если первый истинный.
3. not имеет более низкий приоритет, чем нелогические операторы, поэтому not a == b интерпретируется как not (a == b), а a == not b — синтаксическая ошибка.

3. Сравнения

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

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

Примечания:

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

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

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

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

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

4. Числовые типы — 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» с необязательным префиксом «+» или «-» для нечислового значения (NaN) и положительной или отрицательной бесконечности.

   Введено в версии 2.6.

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

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

4.1. Побитовые операции над целыми типами

Побитовые операции имеют смысл только для целых чисел. Отрицательные числа рассматриваются как их значение в обратном дополнении 2 (предполагается достаточное количество бит, чтобы при операции не произошло переполнения).

Приоритеты бинарных побитовых операций ниже, чем у числовых операций, и выше, чем у сравнений; унарная операция ~ имеет такой же приоритет, как и другие унарные числовые операции (+ и -).

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

Примечания:

1. Отрицательные значения сдвига недопустимы и приводят к ошибке ValueError.
2. Сдвиг влево на n бит эквивалентен умножению на pow(2, n). Возвращается длинное целое число, если результат выходит за пределы диапазона обычных целых чисел.
3. Сдвиг вправо на n бит эквивалентен делению на pow(2, n).

4.2. Дополнительные методы целых типов

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

int.bit_length()

long.bit_length()

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

>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6

Точнее, если x не равно нулю, тогда x.bit_length() — единственное положительное целое число k такое, что 2**(k-1) <= abs(x) < 2**k. Аналогично, когда abs(x) достаточно мало, чтобы логарифм был правильно округлен, тогда k = 1 + int(log(abs(x), 2)). Если x равно нулю, то x.bit_length() возвращает 0.

Эквивалентно:

def bit_length(self):
    s = bin(self)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6

Введено в версии 2.7.

4.3. Дополнительные методы чисел с плавающей точкой

Тип float реализует numbers.Real абстрактный базовый класс. Тип float также имеет следующие дополнительные методы.

float.as_integer_ratio()

Возвращает пару целых чисел, отношение которых точно равно исходному числу с плавающей точкой, и знаменатель положительный. Возбуждает OverflowError для бесконечностей и ValueError для NaN.

Введено в версии 2.6.

float.is_integer()

Возвращает True если экземпляр float является конечным с целочисленным значением, и False в противном случае:

>>> (-2.0).is_integer()
True
>>> (3.2).is_integer()
False

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

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

float.hex()

Возвращает представление числа с плавающей точкой в виде шестнадцатеричной строки. Для конечных чисел с плавающей точкой это представление всегда включает ведущий 0x и заключительный p и показатель степени.

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

float.fromhex(s)

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

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

Обратите внимание, что float.hex() — это метод экземпляра, а float.fromhex() — это метод класса.

Шестнадцатеричная строка имеет вид:

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

где необязательный sign может быть либо + или -, integer и fraction — это строки шестнадцатеричных цифр, а exponent — это целое десятичное число с необязательным ведущим знаком. Регистр не имеет значения, и должно быть по крайней мере одна шестнадцатеричная цифра в целой или дробной части. Этот синтаксис аналогичен синтаксису, указанному в разделе 6.4.4.2 стандарта C99, а также синтаксису, используемому в Java 1.5 и более поздних версиях. В частности, вывод float.hex() можно использовать в качестве шестнадцатеричной константы с плавающей точкой в коде C или Java, а шестнадцатеричные строки, созданные символом формата C %a или символом формата Java Double.toHexString, принимаются float.fromhex().

Обратите внимание, что показатель степени записывается в десятичной, а не шестнадцатеричной системе, и что он задаёт степень 2, на которую следует умножить коэффициент. Например, шестнадцатеричная строка 0x3.a7p10 представляет число с плавающей точкой (3 + 10./16 + 7./16**2) * 2.0**10, или 3740.0:

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

Применение обратного преобразования к 3740.0 даёт другую шестнадцатеричную строку, представляющую то же самое число:

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

5. Типы итераторов

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.1. Типы генераторов

Генераторы Python предоставляют удобный способ реализации протокола итератора. Если метод __iter__() контейнерного объекта реализован как генератор, он автоматически вернёт объект итератора (технически, объект генератора), предоставляющий методы __iter__() и next(). Более подробную информацию о генераторах можно найти в документации по выражению yield.

6. Типы последовательностей — str, unicode, list, tuple, bytearray, buffer, xrange

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

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

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

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

Объекты буфера напрямую не поддерживаются синтаксисом 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. Срез s с i по j с шагом k определяется как последовательность элементов с индексом x = i + n*k таким образом, что 0 <= n < (j-i)/k. Другими словами, индексы являются i, i+k, i+2*k, i+3*k и так далее, останавливаясь, когда достигается j (но никогда не включая j). Когда k положительный, i и j уменьшаются до len(s) если они больше. Когда k отрицательный, i и j уменьшаются до len(s) - 1 если они больше. Если i или j опущены или None, они становятся значениями «конец» (который зависит от знака k). Обратите внимание, что k не может быть нулём. Если k None, он обрабатывается как 1.

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

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

6.1. Методы строк

Ниже приведены методы строк, которые поддерживаются как строками 8-битного типа, так и объектами Unicode. Некоторые из них также доступны для объектов bytearray.

Кроме того, строки Python поддерживают методы типа последовательности, описанные в разделе Типы последовательностей — str, unicode, list, tuple, bytearray, buffer, xrange. Для вывода форматированных строк используйте шаблоны строк или оператор %, описанный в разделе Операции форматирования строк. Также см. модуль re для функций строк, основанных на регулярных выражениях.

str.capitalize()

Возвращает копию строки с заглавной первой буквой и остальными строчными.

Для 8-битных строк этот метод зависит от локали.

str.center(width[, fillchar])

Возвращает отцентрованную строку длины width. Выравнивание выполняется с использованием указанного fillchar (по умолчанию — пробел).

Изменено в версии 2.4: Добавлена поддержка аргумента fillchar.

str.count(sub[, start[, end]])

Возвращает количество неперекрывающихся вхождений подстроки sub в диапазоне [start, end]. Дополнительные аргументы start и end интерпретируются как в записи срезов.

str.decode([encoding[, errors]])

Декодирует строку с использованием кодека, зарегистрированного для encoding. encoding по умолчанию — кодировка строк по умолчанию. errors можно задать для установки другого способа обработки ошибок. По умолчанию это 'strict', что означает, что ошибки кодирования вызывают UnicodeError. Другие возможные значения — 'ignore', 'replace' и любое другое имя, зарегистрированное через codecs.register_error(), см. раздел Базовые классы кодеков.

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

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

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

str.encode([encoding[, errors]])

Возвращает закодированную версию строки. Кодировка по умолчанию — текущая кодировка строк по умолчанию. errors можно задать для установки другого способа обработки ошибок. По умолчанию errors — 'strict', что означает, что ошибки кодирования вызывают UnicodeError. Другие возможные значения — 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' и любое другое имя, зарегистрированное через codecs.register_error(), см. раздел Базовые классы кодеков. Список возможных кодировок см. в разделе Стандартные кодировки.

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

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

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

str.endswith(suffix[, start[, end]])

Возвращает True если строка заканчивается указанным suffix, иначе возвращает False. suffix также может быть кортежем из суффиксов для проверки. С опциональным start, проверка начинается с этой позиции. С опциональным end, сравнение останавливается на этой позиции.

Изменено в версии 2.5: Принимает кортежи как suffix.

str.expandtabs([tabsize])

Возвращает копию строки, где все символы табуляции заменены одним или несколькими пробелами, в зависимости от текущей колонки и заданного размера табуляции. Позиции табуляции происходят через каждые tabsize символов (по умолчанию 8, что даёт позиции табуляции в столбцах 0, 8, 16 и так далее). Для расширения строки текущая колонка устанавливается в ноль, и строка анализируется символ за символом. Если символ является символом табуляции (\t), в результат вставляется один или несколько пробелов, пока текущая колонка не станет равной следующей позиции табуляции. (Сам символ табуляции не копируется.) Если символ является символом новой строки (\n) или возврата каретки (\r), он копируется, а текущая колонка сбрасывается в ноль. Любой другой символ копируется без изменений, и текущая колонка увеличивается на единицу независимо от того, как символ отображается при печати.

>>> '01\t012\t0123\t01234'.expandtabs()
'01      012     0123    01234'
>>> '01\t012\t0123\t01234'.expandtabs(4)
'01  012 0123    01234'

str.find(sub[, start[, end]])

Возвращает самый низкий индекс в строке, где подстрока sub найдена внутри среза s[start:end]. Необязательные аргументы start и end интерпретируются так же, как и в операторах среза. Возвращает -1 если sub не найдена.

Примечание

Метод find() следует использовать только если вам нужно знать позицию sub. Чтобы проверить, является ли sub подстрокой или нет, используйте оператор in:

>>> 'Py' in 'Python'
True

str.format(*args, **kwargs)

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

>>> "The sum of 1 + 2 is {0}".format(1+2)
'The sum of 1 + 2 is 3'

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

Этот метод форматирования строк является новым стандартом в Python 3 и должен предпочтительно использоваться в новом коде вместо метода % форматирования, описанного в Операции форматирования строк.

Введено в версии 2.6.

str.index(sub[, start[, end]])

Как find(), но вызывает ValueError, когда подстрока не найдена.

str.isalnum()

Возвращает True, если все символы в строке являются буквенно-цифровыми и есть хотя бы один символ, иначе False.

Для 8-битных строк этот метод зависит от локали.

str.isalpha()

Возвращает True, если все символы в строке являются буквенными и есть хотя бы один символ, иначе False.

Для 8-битных строк этот метод зависит от локали.

str.isdigit()

Возвращает True, если все символы в строке являются цифрами и есть хотя бы один символ, иначе False.

Для 8-битных строк этот метод зависит от локали.

str.islower()

Возвращает True, если все символы с регистром 4 в строке являются строчными и есть хотя бы один такой символ, иначе False.

Для 8-битных строк этот метод зависит от локали.

str.isspace()

Возвращает True, если в строке содержатся только пробельные символы и есть хотя бы один символ, иначе False.

Для 8-битных строк этот метод зависит от локали.

str.istitle()

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

Для 8-битных строк этот метод зависит от локали.

str.isupper()

Возвращает True, если все символы с регистром 4 в строке являются заглавными и есть хотя бы один такой символ, иначе False.

Для 8-битных строк этот метод зависит от локали.

str.join(iterable)

Возвращает строку, которая является конкатенацией строк в iterable. Если в iterable есть какой-либо объект Unicode, возвращается Unicode. Будет вызвана ошибка TypeError, если в iterable есть какие-либо значения, которые не являются строками или объектами Unicode. Разделитель между элементами — это строка, которая предоставляет этот метод.

str.ljust(width[, fillchar])

Возвращает строку, выровненную влево в строке длиной width. Заполнение выполняется с использованием указанного fillchar (по умолчанию пробел). Исходная строка возвращается, если width меньше или равно len(s).

Изменено в версии 2.4: Поддержка аргумента fillchar.

str.lower()

Возвращает копию строки со всеми символами с регистром 4, преобразованными в нижний регистр.

Для 8-битных строк этот метод зависит от локали.

str.lstrip([chars])

Возвращает копию строки с удаленными начальными символами. Аргумент chars — это строка, определяющая набор символов, которые нужно удалить. Если он опущен или None, аргумент chars по умолчанию удаляет пробелы. Аргумент chars не является префиксом; вместо этого удаляются все комбинации его значений:

>>> '   spacious   '.lstrip()
'spacious   '
>>> 'www.example.com'.lstrip('cmowz.')
'example.com'

Изменено в версии 2.2.2: Поддержка аргумента chars.

str.partition(sep)

Разделяет строку на первой встреченной sep и возвращает кортеж из 3 элементов: часть перед разделителем, сам разделитель и часть после разделителя. Если разделитель не найден, возвращает кортеж из 3 элементов: сама строка, две пустые строки.

Введено в версии 2.5.

str.replace(old, new[, count])

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

str.rfind(sub[, start[, end]])

Возвращает самый высокий индекс в строке, где подстрока sub найдена, такая, что sub содержится внутри s[start:end]. Необязательные аргументы start и end интерпретируются так же, как и в операторах среза. Возвращает -1 при неудаче.

str.rindex(sub[, start[, end]])

Как rfind(), но вызывает ValueError, если подстрока sub не найдена.

str.rjust(width[, fillchar])

Возвращает строку, выровненную вправо в строке длиной width. Заполнение выполняется с использованием указанного fillchar (по умолчанию пробел). Исходная строка возвращается, если width меньше или равно len(s).

Изменено в версии 2.4: Поддержка аргумента fillchar.

str.rpartition(sep)

Разделяет строку на последнем вхождении sep и возвращает кортеж из 3 элементов: часть перед разделителем, сам разделитель и часть после разделителя. Если разделитель не найден, возвращает кортеж из 3 элементов: две пустые строки, затем сама строка.

Введено в версии 2.5.

str.rsplit([sep[, maxsplit]])

Возвращает список слов в строке, используя sep в качестве разделителя строки. Если maxsplit задан, выполняется не более maxsplit разделений, начиная с правого. Если sep не указан или None, любая строка пробелов является разделителем. Кроме разделения справа, rsplit() ведет себя как split(), которое подробно описано ниже.

Введено в версии 2.4.

str.rstrip([chars])

Возвращает копию строки с удаленными конечными символами. Аргумент chars — это строка, определяющая набор символов, которые нужно удалить. Если он опущен или None, аргумент chars по умолчанию удаляет пробелы. Аргумент chars не является суффиксом; вместо этого удаляются все комбинации его значений:

>>> '   spacious   '.rstrip()
'   spacious'
>>> 'mississippi'.rstrip('ipz')
'mississ'

Изменено в версии 2.2.2: Поддержка аргумента chars.

str.split([sep[, maxsplit]])

Возвращает список слов в строке, используя sep в качестве разделителя. Если задано maxsplit, выполняется не более maxsplit разбиений (следовательно, список будет содержать не более maxsplit+1 элементов). Если maxsplit не указано или -1, ограничений на количество разбиений нет (производится все возможные разбиения).

Если sep задан, последовательные разделители не объединяются и считаются разделителями пустых строк (например, '1,,2'.split(',') возвращает ['1', '', '2']). Аргумент sep может состоять из нескольких символов (например, '1<>2<>3'.split('<>') возвращает ['1', '2', '3']). Разбиение пустой строки с заданным разделителем возвращает [''].

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

Например, ' 1  2   3  '.split() возвращает ['1', '2', '3'], а '  1  2   3  '.split(None, 1) возвращает ['1', '2   3  '].

str.splitlines([keepends])

Возвращает список строк в строке, разделяя их по границам строк. Этот метод использует подход универсальных разделителей строк для разделения строк. Разделители строк не включаются в результирующий список, если не задан и не является истинным аргумент keepends.

Python распознает "\r", "\n", и "\r\n" как границы строк для строк из 8 бит.

Например:

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

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

>>> "".splitlines()
[]
>>> "One line\n".splitlines()
['One line']

Для сравнения, split('\n') даёт:

>>> ''.split('\n')
['']
>>> 'Two lines\n'.split('\n')
['Two lines', '']

unicode.splitlines([keepends])

Возвращает список строк в строке, как и str.splitlines(). Однако метод Unicode разделяет по следующим границам строк, которые являются супермножеством универсальных разделителей строк, распознаваемых для строк из 8 бит.

Представление	Описание
\n	Перевод строки
\r	Возврат каретки
\r\n	Возврат каретки + перевод строки
\v или \x0b	Табуляция
\f или \x0c	Форматирование страницы
\x1c	Разделитель файлов
\x1d	Разделитель групп
\x1e	Разделитель записей
\x85	Следующая строка (управляющий символ C1)
\u2028	Разделитель строк
\u2029	Разделитель абзацев

Изменено в версии 2.7: \v и \f добавлены в список границ строк.

str.startswith(prefix[, start[, end]])

Возвращает True если строка начинается с prefix, в противном случае возвращает False. prefix также может быть кортежем префиксов, которые нужно искать. С необязательным start, проверка начинается с этой позиции. С необязательным end, сравнение прекращается на этой позиции.

Изменено в версии 2.5: Принимает кортежи как prefix.

str.strip([chars])

Возвращает копию строки, из которой удалены начальные и конечные символы. Аргумент chars — строка, определяющая множество символов, которые нужно удалить. Если опущен или None, аргумент chars по умолчанию удаляет пробелы. Аргумент chars не является префиксом или суффиксом; вместо этого удаляются все комбинации его значений:

>>> '   spacious   '.strip()
'spacious'
>>> 'www.example.com'.strip('cmowz.')
'example'

Изменено в версии 2.2.2: Поддержка аргумента chars.

str.swapcase()

Возвращает копию строки, в которой заглавные буквы преобразованы в строчные, а строчные — в заглавные.

Для строк из 8 бит этот метод зависит от локали.

str.title()

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

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

>>> "they're bill's friends from the UK".title()
"They'Re Bill'S Friends From The Uk"

Обходной путь для апострофов может быть построен с использованием регулярных выражений:

>>> import re
>>> def titlecase(s):
...     return re.sub(r"[A-Za-z]+('[A-Za-z]+)?",
...                   lambda mo: mo.group(0)[0].upper() +
...                              mo.group(0)[1:].lower(),
...                   s)
...
>>> titlecase("they're bill's friends.")
"They're Bill's Friends."

Для строк из 8 бит этот метод зависит от локали.

str.translate(table[, deletechars])

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

Вы можете использовать вспомогательную функцию maketrans() в модуле string для создания таблицы преобразований. Для объектов типа строка, установите аргумент table в None для преобразований, которые только удаляют символы:

>>> 'read this short text'.translate(None, 'aeiou')
'rd ths shrt txt'

Добавлена в версии 2.6: Поддержка аргумента table типа None.

Для объектов Unicode, метод translate() не принимает необязательный аргумент deletechars. Вместо этого он возвращает копию s, где все символы были отображены через заданную таблицу преобразований, которая должна быть отображением кодов Unicode на коды Unicode, строки Unicode или None. Неотображенные символы остаются без изменений. Символы, отображенные на None удаляются. Обратите внимание, что более гибкий подход заключается в создании настраиваемого кодека преобразования символов с использованием модуля codecs (см. encodings.cp1251 для примера).

str.upper()

Возвращает копию строки со всеми символами, допускающими изменение регистра, 4 преобразованными в верхний регистр. Обратите внимание, что s.upper().isupper() может быть False если s содержит символы без изменения регистра или если категория Unicode результирующего символа(ов) не «Lu» (Буква, заглавная), а, например, «Lt» (Буква, строчная).

Для строк из 8 бит этот метод зависит от локали.

str.zfill(width)

Возвращает числовую строку, дополненную слева нулями до длины width. Знаковый префикс обрабатывается правильно. Исходная строка возвращается, если width меньше или равно len(s).

Добавлена в версии 2.2.2.

Следующие методы присутствуют только в объектах unicode:

unicode.isnumeric()

Возвращает True если в строке S только числовые символы, False иначе. Числовые символы включают символы цифр и все символы, имеющие свойство числового значения Unicode, например U+2155, VULGAR FRACTION ONE FIFTH.

unicode.isdecimal()

Возвращает True если в строке S только десятичные символы, False иначе. Десятичные символы включают символы цифр и все символы, которые могут использоваться для образования десятичных чисел, например U+0660, ARABIC-INDIC DIGIT ZERO.

6.2. Операции форматирования строк

Объекты строк и Unicode имеют одну уникальную встроенную операцию: оператор % (modulo). Он также известен как оператор форматирования или интерполяции строк. Учитывая format % values (где format — строка или объект Unicode), спецификации преобразования % в format заменяются нулем или более элементами values. Эффект аналогичен использованию sprintf() в языке C. Если format — это объект Unicode или любой из преобразуемых объектов с использованием оператора %s является объектом Unicode, результат также будет объектом Unicode.

Если format требует одного аргумента, values может быть одним объектом, не являющимся кортежем. 5 В противном случае values должен быть кортежем с точным числом элементов, указанных в строке форматирования, или одним объектом-отображением (например, словарем).

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

1. Символ '%', обозначающий начало спецификатора.
2. Ключ сопоставления (необязательный), состоящий из последовательности символов в скобках (например, (somename)).
3. Флаги преобразования (необязательные), которые влияют на результат некоторых типов преобразования.
4. Минимальная ширина поля (необязательная). Если указано как '*' (звездочка), фактическая ширина считывается из следующего элемента кортежа в values, а объект для преобразования следует за минимальной шириной поля и необязательной точностью.
5. Точность (необязательная), заданная как '.' (точка) и последующая точность. Если указано как '*' (звездочка), фактическая ширина считывается из следующего элемента кортежа в values, а значение для преобразования следует за точностью.
6. Модификатор длины (необязательный).
7. Тип преобразования.

Когда правым аргументом является словарь (или другой тип отображения), форматы в строке должны содержать ключ сопоставления в этом словаре, вставленный непосредственно после символа '%'. Ключ сопоставления выбирает значение, которое должно быть отформатировано из отображения. Например:

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

В этом случае в формате не должно быть спецификаторов *, так как они требуют последовательного списка параметров.

Символы флагов преобразования:

Модификатор длины (h, l, или L) может быть присутствовать, но игнорируется, поскольку он не нужен в Python — например, %ld идентично %d.

Типы преобразования:

Примечания:

1. Альтернативная форма вставляет ведущий ноль ('0') между левой обрезкой и форматированием числа, если ведущий символ результата не является нулём.
2. Альтернативная форма вставляет ведущие '0x' или '0X' (в зависимости от того, использовался ли формат 'x' или 'X') перед первой цифрой.

3. Альтернативная форма всегда включает десятичную точку в результате, даже если за ней нет цифр.

   Точность определяет количество цифр после десятичной точки и по умолчанию равна 6.

4. Альтернативная форма всегда включает десятичную точку, и хвостовые нули не удаляются, как это происходило бы в противном случае.

   Точность определяет количество значащих цифр до и после десятичной точки и по умолчанию равна 6.

5. Преобразование %r было добавлено в Python 2.0.

   Точность определяет максимальное количество используемых символов.

6. Если предоставленный объект или формат — строка unicode, результирующая строка также будет unicode.

   Точность определяет максимальное количество используемых символов.

7. См. PEP 237.

Поскольку строки Python имеют явную длину, преобразования %s не предполагают, что '\0' является концом строки.

Дополнительные операции со строками определены в стандартных модулях string и re.

6.3. Тип XRange

Тип xrange — это неизменяемая последовательность, часто используемая для циклов. Преимущество типа xrange заключается в том, что объект xrange всегда занимает одинаковый объем памяти, независимо от размера представляемого им диапазона. Нет никаких заметных преимуществ в производительности.

Объекты XRange имеют очень ограниченный функционал: они поддерживают только индексацию, итерацию и функцию len().

6.4. Изменяемые типы последовательностей

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

Примечания:

1. t должен иметь такую же длину, как и срез, который он заменяет.
2. Реализация Python на C исторически принимала несколько параметров и неявно объединяла их в кортеж; это больше не работает в Python 2.0. Использование этой неверной функции устарело начиная с Python 1.4.
3. t может быть любым итерируемым объектом.

4. Вызывает ValueError, когда x не найден в s. Когда в качестве второго или третьего параметра к методу index() передаётся отрицательный индекс, к длине списка добавляется значение, как и для индексов срезов. Если он всё ещё отрицательный, он усекается до нуля, как и для индексов срезов.

   Изменено в версии 2.3: Ранее, index() не имел аргументов для указания начальной и конечной позиций.

5. Когда в качестве первого параметра к методу insert() передаётся отрицательный индекс, к длине списка добавляется значение, как и для индексов срезов. Если он всё ещё отрицательный, он усекается до нуля, как и для индексов срезов.

   Изменено в версии 2.3: Ранее все отрицательные индексы обрезались до нуля.

6. Необязательный аргумент метода pop() i по умолчанию равен -1, так что по умолчанию удаляется и возвращается последний элемент.
7. Методы sort() и reverse() изменяют список на месте для экономии места при сортировке или обратном порядке большого списка. Чтобы напомнить, что они работают с побочным эффектом, они не возвращают отсортированный или обратный список.

8. Метод sort() принимает необязательные аргументы для управления сравнениями.

   cmp указывает пользовательскую функцию сравнения двух аргументов (элементов списка), которая должна возвращать отрицательное, нулевое или положительное число в зависимости от того, считается ли первый аргумент меньше, равен или больше второго аргумента: cmp=lambda x,y: cmp(x.lower(), y.lower()). Значение по умолчанию — None.

   key указывает функцию с одним аргументом, которая используется для извлечения ключа сравнения из каждого элемента списка: key=str.lower. Значение по умолчанию — None.

   reverse — логическое значение. Если установлено в True, элементы списка сортируются так, как если бы каждое сравнение было обращено.

   В общем случае процессы преобразования key и reverse значительно быстрее, чем указание эквивалентной функции cmp. Это связано с тем, что cmp вызывается несколько раз для каждого элемента списка, в то время как key и reverse касаются каждого элемента только один раз. Используйте functools.cmp_to_key() для преобразования функции cmp старого стиля в функцию key.

   Изменено в версии 2.3: Добавлена поддержка None как эквивалента пропуска cmp.

   Изменено в версии 2.4: Добавлена поддержка key и reverse.

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

10. Подробность реализации CPython: В то время как список сортируется, воздействие попытки изменить или даже проверить список не определено. Реализация C в Python 2.3 и более поздних версий делает список пустым на всё время и вызывает ValueError, если может определить, что список был изменён во время сортировки.

11. Значение n — это целое число или объект, реализующий __index__(). Нулевые и отрицательные значения n очищают последовательность. Элементы в последовательности не копируются; они ссылаются несколько раз, как объяснено для s * n в разделе Типы последовательностей — str, unicode, list, tuple, bytearray, buffer, xrange.

7. Типы множеств — set, frozenset

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

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

В настоящее время существует два встроенных типа множеств, 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() может быть множеством. Для поддержки поиска эквивалентного frozenset создается временное множество из elem.

8. Типы отображений — dict

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

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

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

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

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

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

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

Для иллюстрации, следующие примеры все возвращают словарь, равный {"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. Разный __missing__ метод используется в collections.defaultdict.

Введено в версии 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()

Возвращает копию списка пар «ключ-значение» словаря.

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

Если items(), keys(), values(), iteritems(), iterkeys() и itervalues() вызываются без промежуточных изменений в словаре, списки будут напрямую соответствовать. Это позволяет создавать пары «ключ-значение» с помощью 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()

Возвращает итератор по парам «ключ-значение» словаря. См. примечание к 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])

Если ключ есть в словаре, вернуть его значение. Если нет, вставить ключ со значением по умолчанию и вернуть по умолчанию. Значение по умолчанию по умолчанию равно None.

update([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) пары.

8.1. Объекты вида словаря

Объекты, возвращаемые dict.viewkeys(), dict.viewvalues() и dict.viewitems(), являются объектами вида. Они предоставляют динамический вид на записи словаря, что означает, что при изменении словаря вид отражает эти изменения.

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

len(dictview)

Вернуть число записей в словаре.

iter(dictview)

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

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

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

x in dictview

Вернуть True если x есть в ключах, значениях или элементах базового словаря (в последнем случае x должен быть кортежем (key, value)).

Взгляды на ключи похожи на множества, так как их записи уникальны и хешируемы. Если все значения хешируемы, так что пары «ключ-значение» уникальны и хешируемы, то вид элементов также похож на множество. (Виды значений не считаются множествами, так как записи обычно не уникальны.) Тогда доступны следующие операции над множествами («other» относится либо к другому виду, либо к множеству):

dictview & other

Вернуть пересечение dictview и другого объекта как новое множество.

dictview | other

Вернуть объединение dictview и другого объекта как новое множество.

dictview - other

Вернуть разность dictview и другого объекта (все элементы в dictview, которые не находятся в other) как новое множество.

dictview ^ other

Вернуть симметрическую разность (все элементы, которые находятся либо в dictview, либо в other, но не в обоих) dictview и другого объекта как новое множество.

Пример использования вида словаря:

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

>>> # iteration
>>> n = 0
>>> for val in values:
...     n += val
>>> print(n)
504

>>> # keys and values are iterated over in the same order
>>> list(keys)
['eggs', 'bacon', 'sausage', 'spam']
>>> list(values)
[2, 1, 1, 500]

>>> # view objects are dynamic and reflect dict changes
>>> del dishes['eggs']
>>> del dishes['sausage']
>>> list(keys)
['spam', 'bacon']

>>> # set operations
>>> keys & {'eggs', 'bacon', 'salad'}
{'bacon'}

9. Объекты файлов

Объекты файлов реализованы с использованием пакета C stdio и могут быть созданы с помощью встроенной функции 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 # This isn't required in 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()

Очистить внутренний буфер, как stdio’s fflush(). В некоторых объектах, подобных файлам, это может быть пустая операция.

Примечание

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, когда достигается конец файла при чтении (поведение не определено, когда файл открыт для записи). Чтобы сделать цикл for наиболее эффективным способом циклического перебора строк файла (очень распространённая операция), метод next() использует скрытый буфер предварительного чтения. Вследствие использования буфера предварительного чтения сочетание next() с другими методами файла (например, readline()) работает некорректно. Однако использование seek() для перемещения файла в абсолютную позицию очистит буфер предварительного чтения.

Введено в версии 2.3.

file.read([size])

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

Примечание

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

file.readline([size])

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

Примечание

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

file.readlines([sizehint])

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

file.xreadlines()

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

Введено в версии 2.1.

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

file.seek(offset[, whence])

Установить текущую позицию файла, как stdio’s 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(), являются допустимыми. Использование других смещений приводит к неопределённому поведению.

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

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

file.tell()

Возвратить текущую позицию файла, как stdio’s 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

Булево значение, указывающее текущее состояние объекта файла. Это атрибут только для чтения; метод 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 отслеживать своё внутреннее состояние.

10. Тип memoryview

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

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

11. Типы менеджеров контекста

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

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

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 для примеров.

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

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

12. Другие встроенные типы

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

12.1. Модули

Единственной специальной операцией над модулем является доступ к атрибутам: m.name, где m — модуль, а name обращается к имени, определённому в таблице символов m. Атрибуты модулей можно присваивать. (Обратите внимание, что оператор import строго говоря, не является операцией над объектом модуля; import foo не требует существования объекта модуля с именем foo, а требует (внешнего) определения модуля с именем foo где-то.)

Специальным атрибутом каждого модуля является __dict__. Это словарь, содержащий таблицу символов модуля. Изменение этого словаря фактически изменяет таблицу символов модуля, но непосредственное присваивание атрибуту __dict__ невозможно (вы можете написать m.__dict__['a'] = 1, что определяет m.a как 1, но вы не можете написать m.__dict__ = {}). Изменение __dict__ напрямую не рекомендуется.

Встроенные в интерпретатор модули пишутся так: <module 'sys' (built-in)>. Если они загружаются из файла, они записываются как <module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>.

12.2. Классы и экземпляры классов

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

12.3. Функции

Объекты функций создаются определениями функций. Единственной операцией над объектом функции является вызов: func(argument-list).

На самом деле существует два типа объектов функций: встроенные функции и функции, определённые пользователем. Оба поддерживают одинаковую операцию (вызов функции), но реализация отличается, следовательно, разные типы объектов.

См. Определения функций для получения дополнительной информации.

12.4. Методы

Методы — это функции, которые вызываются с использованием нотации атрибутов. Есть два типа: встроенные методы (например, append() для списков) и методы экземпляров классов. Встроенные методы описываются вместе с типами, которые их поддерживают.

Реализация добавляет два специальных атрибута только для чтения к методам экземпляров классов: m.im_self — объект, над которым выполняется метод, и m.im_func — функция, реализующая метод. Вызов m(arg-1, arg-2, ..., arg-n) полностью эквивалентен вызову m.im_func(m.im_self, arg-1, arg-2, ..., arg-n).

Методы экземпляров класса могут быть связанными или несвязанными, в зависимости от того, был ли метод вызван через экземпляр или класс соответственно. Когда метод несвязан, его атрибут im_self будет None, и при вызове необходимо явно передать объект self в качестве первого аргумента. В этом случае self должен быть экземпляром класса несвязанного метода (или подклассом этого класса), в противном случае возникает TypeError.

Как и объекты функций, объекты методов поддерживают получение произвольных атрибутов. Однако, так как атрибуты методов фактически хранятся в базовом объекте функции (meth.im_func), установление атрибутов методов для связанных или несвязанных методов запрещено. Попытка установить атрибут в методе приводит к возникновению AttributeError. Для установки атрибута метода вам необходимо явно установить его в базовом объекте функции:

>>> class C:
...     def method(self):
...         pass
...
>>> c = C()
>>> c.method.whoami = 'my name is method'  # can't set on the 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'

См. Стандартная иерархия типов для получения дополнительной информации.

12.5. Объекты кода

Объекты кода используются реализацией для представления «псевдоскомпилированного» исполняемого кода Python, такого как тело функции. Они отличаются от объектов функций тем, что не содержат ссылки на свою глобальную среду выполнения. Объекты кода возвращаются встроенной функцией compile() и могут быть извлечены из объектов функций через их атрибут func_code. См. также модуль code.

Объект кода можно выполнить или оценить, передав его (вместо строки исходного кода) в оператор exec или встроенную функцию eval().

См. Стандартная иерархия типов для получения дополнительной информации.

12.6. Объекты типов

Объекты типов представляют различные типы объектов. Тип объекта обращается к встроенной функции type(). Нет специальных операций над типами. Стандартный модуль types определяет имена всех стандартных встроенных типов.

Типы записываются следующим образом: <type 'int'>.

12.7. Нулевой объект

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

Он записывается как None.

12.8. Объект эллипса

Этот объект используется расширенной нотацией срезов (см. Срезы). Он не поддерживает никаких специальных операций. Существует ровно один объект эллипса, с именем Ellipsis (встроенное имя).

Он записывается как Ellipsis. В подписях он также может быть записан как ..., например, seq[...].

12.9. Объект NotImplemented

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

Он записывается как NotImplemented.

12.10. Булевы значения

Булевы значения — это два константных объекта False и True. Они используются для представления логических значений (хотя и другие значения могут также считаться ложными или истинными). В числовых контекстах (например, когда они используются в качестве аргумента арифметического оператора) они ведут себя как целые числа 0 и 1 соответственно. Встроенная функция bool() может быть использована для преобразования любого значения в булево значение, если значение может быть интерпретировано как логическое значение (см. раздел Проверка истинности выше).

Они записываются как False и True соответственно.

12.11. Внутренние объекты

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

13. Специальные атрибуты

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

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