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

5.4.1. Битовые операции над целыми числами¶Bit-string Operations on Integer Types

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

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

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

Примечания:

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

5.4.2. Дополнительные методы целочисленных типов¶Additional Methods on Integer Types

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

int.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)       # двоичное представление:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # удалить ведущие нули и знак минус
    return len(s)       # len('100101') --> 6

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

5.4.3. Дополнительные методы типа float¶Additional Methods on Float

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

float.as_integer_ratio()¶

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

float.is_integer()¶

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

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

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

float.hex()¶

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

classmethod float.fromhex(s)¶

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

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

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

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

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

Обратите внимание, что порядок записывается в десятичном виде, а не в шестнадцатеричном, и что он показывает степень двойки, на которую умножается коэффициент. Например, шестнадцатеричная строка 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.5.1. Типы генераторов¶Generator Types

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

5.6.1. Строковые методы¶String Methods

Строковые объекты поддерживают перечисленные ниже методы. Обратите внимание, что ни один из этих методов не принимает именованные аргументы.

Кроме того, строки Python поддерживают методы типов последовательностей, описанные в разделе Sequence Types – str, bytes, bytearray, list, tuple, range. Для вывода форматированных строк см. раздел String Formatting. Также см. модуль re для строковых функций, основанных на регулярных выражениях.

str.capitalize()¶

Возвращает копию строки, в которой первый символ переведён в верхний регистр, а остальные – в нижний.

str.center(width[, fillchar])¶

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

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

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

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

Возвращает закодированную версию строки в виде объекта bytes. Кодировка по умолчанию – текущая строковая кодировка по умолчанию. errors может быть указан для задания другой схемы обработки ошибок. Значение по умолчанию для errors – 'strict', что означает, что ошибки кодирования вызывают UnicodeError. Другие возможные значения: 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' и любое другое имя, зарегистрированное через codecs.register_error(); см. раздел Codec Base Classes. Список возможных кодировок см. в разделе Standard Encodings.

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

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

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

str.expandtabs([tabsize])¶

Возвращает копию строки, в которой все символы табуляции заменяются одним или несколькими пробелами в зависимости от текущей позиции столбца и заданного размера табуляции. Номер столбца сбрасывается в ноль после каждого перевода строки в строке. Если tabsize не указан, предполагается размер табуляции 8 символа. Этот метод не обрабатывает другие непечатаемые символы или escape-последовательности.

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

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

Примечание

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

>>> 'Py' in 'Python'
True

str.format(*args, **kwargs)¶

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

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

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

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

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

str.isalnum()¶

Возвращает true, если все символы в строке являются буквенно-цифровыми и есть хотя бы один символ, иначе false. Символ c является буквенно-цифровым, если один из следующих методов возвращает True: c.isalpha(), c.isdecimal(), c.isdigit() или c.isnumeric().

str.isalpha()¶

Возвращает true, если все символы в строке являются буквенными и есть хотя бы один символ, иначе false. Буквенные символы – это символы, определённые в базе данных символов Unicode как «Letter», т.е. те, у которых свойство общей категории является одним из «Lm», «Lt», «Lu», «Ll» или «Lo». Обратите внимание, что это отличается от свойства «Alphabetic», определённого в стандарте Unicode.

str.isdecimal()¶

Возвращает true, если все символы в строке являются десятичными цифрами и есть хотя бы один символ, и false в противном случае. Десятичными считаются символы из общей категории “Nd”. Эта категория включает цифровые символы, а также все символы, которые могут использоваться для записи десятичных чисел, например U+0660, ARABIC-INDIC DIGIT ZERO.

str.isdigit()¶

Возвращает true, если все символы в строке являются цифрами и есть хотя бы один символ, иначе false. Цифры включают десятичные символы и цифры, требующие специальной обработки, например совместимые надстрочные цифры. Формально цифрой является символ со значением свойства Numeric_Type=Digit или Numeric_Type=Decimal.

str.isidentifier()¶

Возвращает true, если строка является допустимым идентификатором в соответствии с определением языка, раздел Идентификаторы и ключевые слова.

str.islower()¶

Возвращает true, если все символы с учётом регистра в строке являются строчными и есть хотя бы один такой символ, и false в противном случае. Символами с учётом регистра считаются те, у которых свойство общей категории равно “Lu”, “Ll” или “Lt”, а строчными символами считаются те, у которых свойство общей категории “Ll”.

str.isnumeric()¶

Возвращает true, если все символы в строке являются числовыми символами и есть хотя бы один символ, иначе false. Числовые символы включают цифры и все символы, имеющие свойство числового значения Unicode, например U+2155, VULGAR FRACTION ONE FIFTH. Формально числовые символы – это символы со значением свойства Numeric_Type=Digit, Numeric_Type=Decimal или Numeric_Type=Numeric.

str.isprintable()¶

Возвращает true, если все символы строки являются печатаемыми или строка пуста, иначе false. Непечатаемые символы – это те, которые определены в базе данных Unicode как «Other» или «Separator», за исключением пробела ASCII (0x20), который считается печатаемым. (Обратите внимание, что печатаемые символы в данном контексте – это те, которые не должны экранироваться при вызове repr() для строки. Это не влияет на обработку строк, записываемых в sys.stdout или sys.stderr.)

str.isspace()¶

Возвращает true, если в строке есть только пробельные символы и есть хотя бы один символ, иначе false. Пробельные символы – это символы, определённые в базе данных символов Unicode как «Other» или «Separator», а также символы со свойством двунаправленности, являющимся одним из «WS», «B» или «S».

str.istitle()¶

Возвращает true, если строка является строкой в заглавном регистре (titlecased) и есть хотя бы один символ, например прописные символы могут следовать только за символами без регистра, а строчные – только за символами с регистром. Иначе возвращает false.

str.isupper()¶

Возвращает true, если все символы с учётом регистра в строке являются прописными и есть хотя бы один такой символ, и false в противном случае. Символами с учётом регистра считаются те, у которых свойство общей категории равно “Lu”, “Ll” или “Lt”, а прописными символами считаются те, у которых свойство общей категории “Lu”.

str.join(iterable)¶

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

str.ljust(width[, fillchar])¶

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

str.lower()¶

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

str.lstrip([chars])¶

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

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

static str.maketrans(x[, y[, z]])¶

Этот статический метод возвращает таблицу перевода, пригодную для использования в str.translate().

Если передан только один аргумент, это должен быть словарь, отображающий коды Unicode (целые числа) или символы (строки длины 1) в коды Unicode, строки (произвольной длины) или None. Ключи-символы при этом будут преобразованы в коды.

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

str.partition(sep)¶

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

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

str.rpartition(sep)¶

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

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

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

str.rstrip([chars])¶

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

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

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

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

Если указан 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 не задан и не равен true.

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

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

str.strip([chars])¶

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

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

str.swapcase()¶

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

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

str.translate(map)¶

Возвращает копию s, в которой все символы преобразованы с помощью map, который должен быть словарём, отображающим коды Unicode (целые числа) в коды Unicode, строки или None. Неотображённые символы остаются без изменений. Символы, отображённые на None, удаляются.

Для создания таблицы трансляции из символьных отображений в разных форматах можно использовать str.maketrans().

Примечание

Ещё более гибкий подход – создать собственный кодек отображения символов с помощью модуля codecs (см. encodings.cp1251 в качестве примера).

str.upper()¶

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

str.zfill(width)¶

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

5.6.2. Устаревшие операции форматирования строк¶Old String Formatting Operations

Строковые объекты имеют одну уникальную встроенную операцию: оператор % (modulo). Он также известен как оператор форматирования или интерполяции строк. При использовании format % values (где format – это строка), спецификации преобразования % в строке format заменяются на ноль или более элементов из values. Результат аналогичен использованию sprintf() в языке C.

Если format требует один аргумент, то values может быть одним объектом, не являющимся кортежем. [4] В противном случае 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. Точность определяет максимальное количество используемых символов.

7. См. PEP 237.

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

Изменено в версии 3.1: преобразования %f для чисел, абсолютное значение которых превышает 1e50, больше не заменяются преобразованиями %g.

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

5.6.3. Тип range¶Range Type

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

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

5.6.4. Изменяемые типы последовательностей¶Mutable Sequence Types

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

Обратите внимание: хотя списки допускают элементы любого типа, «элементы» объекта bytearray – это целые числа в диапазоне 0 <= x < 256.

Примечания:

1. t должен иметь ту же длину, что и заменяемый срез.

2. x может быть любым итерируемым объектом.

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

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

5. Необязательный аргумент i по умолчанию равен -1, поэтому по умолчанию удаляется и возвращается последний элемент.

6. The sort() and reverse() methods modify the sequence in place for economy of space when sorting or reversing a large sequence. To remind you that they operate by side effect, they don’t return the sorted or reversed sequence.

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

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

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

   Метод sort() гарантированно является устойчивым. Сортировка называется устойчивой, если она не меняет относительный порядок элементов, которые считаются равными – это полезно при сортировке в несколько проходов (например, сначала по отделу, затем по уровню зарплаты).

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

8. Метод sort() не поддерживается объектами bytearray.

5.6.5. Методы bytes и bytearray¶Bytes and Byte Array Methods

Объекты bytes и bytearray, будучи «строками байтов», имеют все методы, доступные для строк, за исключением encode(), format() и isidentifier(), которые не имеют смысла для этих типов. Для преобразования объектов в строки у них есть метод decode().

Если какому-либо из этих методов требуется интерпретировать байты как символы (например, методы is...()), предполагается набор символов ASCII.

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

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

bytes.decode([encoding[, errors]])¶

bytearray.decode([encoding[, errors]])¶

Возвращает строку, декодированную из заданных байтов. Кодировка по умолчанию – текущая стандартная строковая кодировка. errors может быть задан для использования другой схемы обработки ошибок. Значение по умолчанию для errors – 'strict', то есть ошибки кодирования вызывают UnicodeError. Другие возможные значения: 'ignore', 'replace' и любое другое имя, зарегистрированное через codecs.register_error(); см. раздел Codec Base Classes. Список возможных кодировок приведён в разделе Standard Encodings.

Типы bytes и bytearray имеют дополнительный метод класса:

classmethod bytes.fromhex(string)¶

classmethod bytearray.fromhex(string)¶

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

>>> bytes.fromhex('f0 f1f2  ')
b'\xf0\xf1\xf2'

Методы maketrans и translate отличаются семантикой от версий, доступных для строк:

bytes.translate(table[, delete])¶

bytearray.translate(table[, delete])¶

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

Для создания таблицы перевода можно использовать метод bytes.maketrans().

Установите аргумент table равным None для преобразований, которые только удаляют символы:

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

static bytes.maketrans(from, to)¶

static bytearray.maketrans(from, to)¶

Этот статический метод возвращает таблицу перевода, пригодную для использования в bytes.translate(), которая сопоставляет каждый символ из from с символом на той же позиции в to; from и to должны быть объектами bytes и иметь одинаковую длину.

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

5.8.1. Объекты представления словаря¶Dictionary view objects

Объекты, возвращаемые dict.keys(), dict.values() и dict.items(), являются представлениями. Они предоставляют динамическое представление содержимого словаря: при изменении словаря представление отражает эти изменения.

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

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

Представления ключей подобны множествам, поскольку их элементы уникальны и хешируемы. Если все значения хешируемы, так что пары (key, value) уникальны и хешируемы, то представление элементов также подобно множеству. (Представления значений не рассматриваются как подобные множествам, поскольку их элементы, как правило, не уникальны.) Для представлений, подобных множествам, доступны все операции, определённые для абстрактного базового класса collections.Set (например, ==, < или ^).

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

>>> 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'}
>>> keys ^ {'sausage', 'juice'}
{'juice', 'eggs', 'bacon', 'spam'}

5.11.1. Модули¶Modules

Единственная специальная операция над модулем – это доступ к атрибуту: 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'>.

5.11.2. Классы и экземпляры классов¶Classes and Class Instances

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

5.11.3. Функции¶Functions

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

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

Дополнительную информацию см. в разделе Определения функций.

5.11.4. Методы¶Methods

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

Если обратиться к методу (функции, определённой в пространстве имён класса) через экземпляр, получается специальный объект: объект связанного метода (также называемый методом экземпляра). При вызове он добавляет аргумент self в список аргументов. Связанные методы имеют два специальных атрибута только для чтения: m.__self__ – это объект, над которым выполняется метод, а m.__func__ – это функция, реализующая метод. Вызов m(arg-1, arg-2, ..., arg-n) полностью эквивалентен вызову m.__func__(m.__self__, arg-1, arg-2, ..., arg-n).

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

class C:
    def method(self):
        pass

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

Дополнительную информацию см. в разделе Стандартная иерархия типов.

5.11.5. Объекты кода¶Code Objects

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

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

Дополнительную информацию см. в разделе Стандартная иерархия типов.

5.11.6. Объекты типа¶Type Objects

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

Типы записываются так: <class 'int'>.

5.11.7. Объект None¶The Null Object

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

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

5.11.8. Объект Ellipsis¶The Ellipsis Object

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

Оно записывается как Ellipsis или ....

5.11.9. Булевы значения¶Boolean Values

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

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

5.11.10. Внутренние объекты¶Internal Objects

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