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

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

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

• None

• False

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

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

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

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

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

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

Логические операции – and, or, not¶Boolean Operations – and, or, not

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

Примечания:

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

Сравнения¶Comparisons

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

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

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

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

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

Поведение операторов is и is not не может быть настроено; они также могут применяться к любым двум объектам и никогда не вызывают исключение.

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

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

Существует три различных числовых типа: целые числа, числа с плавающей запятой и комплексные числа. Кроме того, логические значения являются подтипом целых чисел. Целые числа имеют неограниченную точность. Числа с плавающей запятой реализованы с помощью double в C – все предположения об их точности теряют силу, если не известна машина, с которой ведётся работа. Комплексные числа имеют действительную и мнимую части, каждая из которых реализована с помощью double в C. Чтобы извлечь эти части из комплексного числа z, используются z.real и z.imag. (Стандартная библиотека включает дополнительные числовые типы: fractions для рациональных чисел и decimal для чисел с плавающей запятой с настраиваемой пользователем точностью.)

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

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

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

Примечания:

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

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

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

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

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

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

За дополнительными числовыми операциями обращайтесь к math и cmath модулям.

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

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

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

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

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

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

container.__iter__()¶

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

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

iterator.__iter__()¶

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

iterator.__next__()¶

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

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

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

Python генераторы предоставляют удобный способ реализовать протокол итератора. Если метод __iter__() объекта-контейнера реализован как генератор, он автоматически вернет объект-итератор (технически, объект-генератор), предоставляющий методы __iter__() и __next__().

Типы последовательностей – str, bytes, bytearray, list, tuple, range¶Sequence Types – str, bytes, bytearray, list, tuple, range

Существует шесть типов последовательностей: строки, последовательности байтов (объекты bytes), массивы байтов (объекты bytearray), списки, кортежи и объекты range. Для других контейнеров обратитесь ко встроенным классам dict и set, а также к модулю collections.

Строки содержат символы Unicode. Их литералы записываются в одинарных или двойных кавычках: 'xyzzy', "frobozz". Подробнее о строковых литералах см. String and Bytes literals. Помимо описанной здесь функциональности, существуют также строковые методы, описанные в разделе String Methods.

Объекты bytes и bytearray содержат отдельные байты – первый является неизменяемым, а второй – изменяемой последовательностью. Объекты bytes можно создать с помощью конструктора bytes(), а также из литералов, используя префикс b с обычным синтаксисом строк: b'xyzzy'. Для создания массивов байтов используется функция bytearray().

Списки создаются с помощью квадратных скобок, разделяя элементы запятыми: [a, b, c]. Кортежи создаются с помощью оператора запятой (не внутри квадратных скобок), с обрамляющими круглыми скобками или без них, но пустой кортеж должен иметь обрамляющие круглые скобки, например a, b, c или (). Кортеж из одного элемента должен иметь завершающую запятую, например (d,).

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

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

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

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

Примечания:

1. Если s является строковым объектом, операции in и not in работают как проверка на подстроку.

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

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

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

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

3. Если i или j отрицательно, индекс отсчитывается от конца строки: подставляется 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 никогда не включается). Если i или j больше len(s), используется len(s). Если i или j опущены или равны None, они становятся «конечными» значениями (какой именно конец – зависит от знака k). Обратите внимание: k не может быть нулём. Если k равно None, оно трактуется как 1.

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

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

a = "abc"
b = a.replace("a", "f")

a = b"abc"
b = a.replace(b"a", b"f")

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

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

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

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

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

class set([iterable])¶

class frozenset([iterable])¶

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

Instances of set and frozenset provide the following operations:

len(s)

Return the cardinality of set s.

x in s

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

x not in s

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

isdisjoint(other)¶

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

issubset(other)¶

set <= other

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

set < other

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

issuperset(other)¶

set >= other

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

set > other

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

union(other, ...)¶

set | other | ...

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

intersection(other, ...)¶

set & other & ...

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

difference(other, ...)¶

set - other - ...

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

symmetric_difference(other)¶

set ^ other

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

copy()¶

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

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

Both set and frozenset support set to set comparisons. Two sets are equal if and only if every element of each set is contained in the other (each is a subset of the other). A set is less than another set if and only if the first set is a proper subset of the second set (is a subset, but is not equal). A set is greater than another set if and only if the first set is a proper superset of the second set (is a superset, but is not equal).

Instances of set are compared to instances of frozenset based on their members. For example, set('abc') == frozenset('abc') returns True and so does set('abc') in set([frozenset('abc')]).

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

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

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

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

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

update(other, ...)¶

set |= other | ...

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

intersection_update(other, ...)¶

set &= other & ...

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

difference_update(other, ...)¶

set -= other | ...

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

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 временно изменяется во время поиска, а затем восстанавливается. Во время поиска множество elem не следует ни читать, ни изменять, поскольку оно не имеет осмысленного значения.

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

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

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

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

class dict([arg])¶

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

Если переданы именованные аргументы, сами ключевые слова с соответствующими значениями добавляются в словарь. Если ключ указан как в позиционном аргументе, так и в именованном, то в словаре сохраняется значение из именованного аргумента. Например, все следующие варианты возвращают словарь, равный {"one": 2, "two": 3}:

• dict(one=2, two=3)
• dict({'one': 2, 'two': 3})
• dict(zip(('one', 'two'), (2, 3)))
• dict([['two', 3], ['one', 2]])

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

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

len(d)

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

d[key]

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

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

d[key] = value

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

del d[key]

Remove d[key] from d. Raises a KeyError if key is not in the map.

key in d

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

key not in d

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

clear()¶

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

copy()¶

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

fromkeys(seq[, value])¶

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

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

get(key[, default])¶

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

items()¶

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

keys()¶

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

pop(key[, default])¶

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

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).

values()¶

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

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

>>> # итерация
>>> 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'}

Объекты файлов¶File Objects

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

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

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

file.close()¶

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

Можно избежать явного вызова этого метода, если использовать оператор 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()¶

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

file.fileno()¶

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

Примечание

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

file.isatty()¶

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

Примечание

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

file.__next__()¶

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

file.read([size])¶

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

file.readline([size])¶

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

Примечание

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

file.readlines([sizehint])¶

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

file.seek(offset[, whence])¶

Устанавливает текущую позицию в файле, подобно fseek из stdio. Аргумент 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).

file.tell()¶

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

Примечание

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

file.truncate([size])¶

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

file.write(str)¶

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

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

file.writelines(sequence)¶

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

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

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

file.closed¶

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

file.encoding¶

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

file.errors¶

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

file.mode¶

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

file.name¶

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

file.newlines¶

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

Типы memoryview¶memoryview Types

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

class memoryview(obj)¶

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

len(view) возвращает общее количество байтов в memoryview, view.

memoryview поддерживает срезы для доступа к своим данным. Обращение по одному индексу возвращает один байт. Полный срез приводит к созданию подвида:

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

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

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

Обратите внимание, что размер объекта memoryview не может быть изменён.

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

tobytes()¶

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

tolist()¶

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

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

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

format¶

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

itemsize¶

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

shape¶

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

ndim¶

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

strides¶

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

Типы контекстных менеджеров¶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 для примеров.

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

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

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

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

class C:
    def method(self):
        pass

c = C()
c.method.__func__.whoami = 'my name is c'

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

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

object.__dict__¶

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

instance.__class__¶

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

class.__bases__¶

Кортеж базовых классов объекта-класса. Если базовых классов нет, это будет пустой кортеж.

class.__name__¶

Имя класса или типа.

Сноски