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

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

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

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

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

Проверка истинности значения

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

По умолчанию объект считается True, если его класс не определяет метод __bool__(), который возвращает False, или метод __len__(), который возвращает нулевым при вызове с объектом. [1] здесь большинство встроенных объектов считаются Falseи:

  • константы, определенные как false: None и False.
  • ноль любого числового типа: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
  • пустые последовательности и коллекции: '', (), [], {}, set(), range(0)

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

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

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

Операция Результат Примечание
x or y если x false, тогда y, иначе x (1)
x and y если x false, тогда x, иначе y (2)
not x если x false, v True, иначе False (3)

Примечания:

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

Сравнения

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

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

Операция Значение
< строго меньше, чем
<= меньше или равно
> строго больше, чем
>= больше или равно
== равно
!= не равно
is идентичность объекта
is not отрицание идентичности объекта

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

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

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

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

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

Числовые типы — int, float, complex

Существует три различных числовых типа: integers, floating point numbers и complex numbers. Кроме того, Boolean являются подтипом целых чисел. Целые числа имеют неограниченную точность. Числа с плавающей запятой обычно реализуются с использованием double в C; информация о точности и внутреннем представлении чисел с плавающей запятой для машины, на которой выполняется программа, доступна в sys.float_info. Комплексные числа имеют вещественную и мнимую часть, каждая из которых является числом с плавающей запятой. Чтобы извлечь эти детали из сложного числового z, используйте z.real и z.imag. (Стандартная библиотека включает дополнительные числовые типы fractions.Fraction, для обоснований и decimal.Decimal, для чисел с плавающей запятой с определяемой пользователем точностью.

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

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

Конструкторы int(), float() и complex() можно используемый для создания номеров определенного типа.

Все числовые типы (кроме сложных) поддерживают следующие операции (приоритеты операций см. Предшествование оператора):

Операция Результат Примечания Полная документация
x + y сумма x и y    
x - y разница x и y    
x * y учножение x и y    
x / y частное от x и y    
x // y целочисленное частное x и y (1)  
x % y оставшаяся часть x / y (2)  
-x измененный x    
+x x без изменений    
abs(x) абсолютное значение или величина x   abs()
int(x) x конвертируется в целое число (3)(6) int()
float(x) x преобразован в число с плавающей точкой (4)(6) float()
complex(re, im) комплексное число с действительной частью re, мнимая часть im. im по умолчанию ноль. (6) complex()
c.conjugate() сопряжение комплексного числа c    
divmod(x, y) пара (x // y, x % y) (2) divmod()
pow(x, y) х в степени у (5) pow()
x ** y х в степени у (5)  

Примечания:

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

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

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

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

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

  6. Числовые принятые опечатки включают цифры 0 в 9 или любой эквивалентный Юникод (вопросы код с собственностью Nd).

    Полный список точек http://www.unicode.org/Public/12.1.0/ucd/extracted/DerivedNumericType.txt со свойством код см. в разделе Nd.

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

Операция Результат
math.trunc(x) x усечено до Integral
round(x[, n]) x округляется до n цифр, округление половины до четной. Если n пропущено, значение по умолчанию равно 0.
math.floor(x) большее Integral <= x
math.ceil(x) меньшее Integral >= x

Дополнительные числовые операции см. в math и cmath модулях.

Побитовые операции с целочисленными типами

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

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

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

Операция Результат Примечания
x | y побитовое или x и y (4)
x ^ y побитовое исключающее или x и y (4)
x & y побитовое и x и y (4)
x << n сдвинуть x влево на n бит (1)(2)
x >> n сдвинуть x вправо на n бит (1)(3)
~x инверсия бит x  

Примечания:

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

Дополнительные методы для целочисленных типов

Тип 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.

int.to_bytes(length, byteorder, *, signed=False)

Возвращает массив байтов, представляющий целое число.

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() + 7) // 8, byteorder='little')
b'\xe8\x03'

Целое число представлено length байтами. Если целое число не может быть представлено с заданным числом байтов, возникает OverflowError.

Аргумент byteorder определяет порядок байтов, используемый для представления целого числа. Если byteorder "big", наиболее значимый байт находится в начале массива байтов. Если byteorder "little", наиболее значимый байт находится в конце массива байтов. Чтобы запросить собственный порядок байтов хост-системы, используйте sys.byteorder в качестве значение порядка байтов.

Аргумент signed определяет, является ли дополнение two используемый для представления целого числа. Если signed равно False и задано отрицательное целое число, то возникает OverflowError. По умолчанию для signed используется значение False.

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

classmethod int.from_bytes(bytes, byteorder, *, signed=False)

Возвращает целое число, представленное заданным массивом байт.

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680

Аргумент bytes должен быть либо байтоподобным объектом, либо итерабельным производящим байтами.

Аргумент byteorder определяет порядок байтов, используемый для представления целого числа. Если byteorder "big", наиболее значимый байт находится в начале массива байтов. Если byteorder "little", наиболее значимый байт находится в конце массива байтов. Чтобы запросить собственный порядок байтов хост-системы, используйте sys.byteorder в качестве значение порядка байтов.

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

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

int.as_integer_ratio()

Возвращает пару целых чисел, отношение которых точно равно исходному целому и с положительным знаменателем. Целочисленное отношение целых чисел (целые числа) всегда является целым числом как нумератором и 1 как знаменатель.

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

Дополнительные методы на Float

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

float.as_integer_ratio()

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

float.is_integer()

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

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

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

float.hex()

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

classmethod float.fromhex(s)

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

Обратите внимание, что 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 код, и шестнадцатеричные строки, произведенные форматом символ или Java’s Double.toHexString к %a, приняты 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'

Хеширование числовых типов

Для номеров x и y, возможно, различных типов, это требование hash(x) == hash(y) всякий раз, когда x == y (для получения более подробной информации см. документацию по методу __hash__()). Для простоты внедрения и эффективности через множество числовых типов (включая int, float, decimal.Decimal и fractions.Fraction) мешанина Python’s для числовых типов основана на единственной математической функции, это определено для любого рационального числа и следовательно относится ко всему сущности int и fractions.Fraction, и всему конечному сущности float и decimal.Decimal. По существу, эта функция задается уменьшением по модулю P для фиксированного простого P. значение P сделан доступным для Python как modulus атрибут sys.hash_info.

Детали реализации CPython: В настоящее время основной используемый P = 2**31 - 1 на машинах с 32-разрядной C-длиной и P = 2**61 - 1 на машинах с 64-разрядной C-длиной.

Вот правила в деталях:

  • Если x = m / n - неотрицательное рациональное число, и n не делимый P, определите hash(x) как m * invmod(n, P) % P, где invmod(n, P) дает инверсию модуля n P.
  • Если x = m / n является неотрицательным рациональным числом и n делится на P (но m нет), то n не имеет обратного по модулю P и правило выше не применяется; в этом случае определите hash(x) как константу значение sys.hash_info.inf.
  • Если x = m / n является отрицательным рациональным числом, определите hash(x) как -hash(-x). Если результирующий хэш -1, замените его на -2.
  • Конкретные значения sys.hash_info.inf, -sys.hash_info.inf и sys.hash_info.nan используемый как хеш значения для положительной бесконечности, отрицательной бесконечности или нанса (соответственно). (Все хэшируемые nans имеют одинаковый хеш значение.)
  • Для complex числа z хеш- значения действительной и мнимой частей объединяются вычислительными hash(z.real) + sys.hash_info.imag * hash(z.imag), уменьшенными по модулю 2**sys.hash_info.width так, что он лежит в range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1)). Опять же, если результат -1, он заменяется на -2.

Чтобы уточнить вышеприведенные правила, приведем пример Python код, эквивалентный встроенному хешу, для вычисления хеша рационального числа, float или complex:

import sys, math

def hash_fraction(m, n):
    """Вычислите хеш рационального числа m/n.

    Предполагает, что m и n являются целыми числами, с положительной n.
    Эквивалентно  hash(fractions.Fraction(m, n)).

    """
    P = sys.hash_info.modulus
    # Удалить общие факторы P. (Не нужно, если m и n уже взаимно просты.)
    while m % P == n % P == 0:
        m, n = m // P, n // P

    if n % P == 0:
        hash_value = sys.hash_info.inf
    else:
        # Малая теорема Ферма: pow(n, P-1, P) равна 1, поэтому pow(n, P-2, P) даёт
        # обратное значение n по модулю P.
        hash_value = (abs(m) % P) * pow(n, P - 2, P) % P
    if m < 0:
        hash_value = -hash_value
    if hash_value == -1:
        hash_value = -2
    return hash_value

def hash_float(x):
    """Вычислите хэш float x."""

    if math.isnan(x):
        return sys.hash_info.nan
    elif math.isinf(x):
        return sys.hash_info.inf if x > 0 else -sys.hash_info.inf
    else:
        return hash_fraction(*x.as_integer_ratio())

def hash_complex(z):
    """Вычислите хэш комплексного числа z."""

    hash_value = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)
    # сделать знаковое сокращение по модулю 2**sys.hash_info.width
    M = 2**(sys.hash_info.width - 1)
    hash_value = (hash_value & (M - 1)) - (hash_value & M)
    if hash_value == -1:
        hash_value = -2
    return hash_value

Типы итератора

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

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

container.__iter__()

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

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

iterator.__iter__()

Возвращает сам объект итератора. Это требуется, чтобы позволять обоим контейнерам и iterators быть используемый с for и in инструкции. Этот метод соответствует the:c:member:~PyTypeObject.tp_iter слоту структуры типа для Python объектов в API Python/C.

iterator.__next__()

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

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

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

Типы генератора

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

Типы последовательности — list, tuple, range

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

Общие операции с последовательностью

Операции в следующей таблице поддерживаются большинством типов последовательностей, как изменяемых, так и неизменяемых. Для упрощения правильной реализации этих операций на пользовательских типах последовательностей предоставляется collections.abc.Sequence ABC.

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

Операции in и not in имеют те же приоритеты, что и операции сравнения. Операции + (конкатенация) и * (повторение) имеют тот же приоритет, что и соответствующие числовые операции. [3]

Операция Результат Примечания
x in s True, если элемент s равный x, иначе False (1)
x not in s False, если элемент s равный x, иначе True (1)
s + t конкатенация s и t (6)(7)
s * n или n * s эквивалентно добавлению s в самого себя n раз (2)(7)
s[i] iй элемент s, начиная с 0 (3)
s[i:j] слайс s от i до j (3)(4)
s[i:j:k] слайс s от i до j с шагом k (3)(5)
len(s) длина s  
min(s) наименьший элемент s  
max(s) самый большой элемент s  
s.index(x[, i[, j]]) индекс первого вхождения x в s (или после индекса i и до индекса j) (8)
s.count(x) общее количество вхождений x в s  

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

Примечания:

  1. Хотя операции in и not in используемый только для простых испытаний на герметичность в общем случае, некоторые специализированные последовательности (такие как str, bytes и bytearray) также используют их для испытаний на подпоследовательность:

    >>> "gg" in "eggs"
    True
    
  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]]
    

    Дополнительные пояснения см. в Как создать многомерный список? ввода часто задаваемых вопросов.

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

    • связывая объекты str, вы можете построить список и использовать str.join() в конце или иначе написать io.StringIO сущность и восстановить его значение, когда полный
    • при конкатенации bytes объектов можно аналогичным образом использовать bytes.join() или io.BytesIO, либо выполнить контекстную конкатенацию с bytearray объектом. bytearray объекты являются изменяемыми и имеют эффективный механизм чрезмерного распределения
    • при конкатенации tuple объектов удлините list
    • для других типов изучите соответствующую документацию по классам
  7. Некоторые типы последовательностей (например, range) поддерживают только последовательности элементов, которые следуют определенным шаблонам и, следовательно, не поддерживают конкатенацию или повторение последовательностей.

  8. index вызывает ValueError, когда x не найден в s. Не все реализации поддерживают передачу дополнительных аргументов i и j. Эти аргументы позволяют эффективно искать подразделы последовательности. Передача дополнительных аргументов примерно эквивалентна использованию s[i:j].index(x), только без копирования каких-либо данных и с индексом возвращенный относительно начала последовательности, а не начала слайса.

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

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

Эта поддержка позволяет tuple неизменяемые последовательности, такие как сущности используемый, в качестве ключей dict и хранить в set и frozenset сущности.

Попытка хеширования неизменяемой последовательности, содержащей невидимые значения, приведет к TypeError.

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

Операции в следующей таблице определены для изменяемых типов последовательностей. Для упрощения правильной реализации этих операций на пользовательских типах последовательностей предоставляется collections.abc.MutableSequence ABC.

В таблице s сущность изменчивого типа последовательности, t - любой повторяемый объект, и x - произвольный объект, который встречает любой тип и ограничения значение, введенные s (например, bytearray только принимает целые числа, которые встречают ограничение 0 <= x <= 255 значение).

Операция Результат Примечания
s[i] = x i элемент s заменяется на x  
s[i:j] = t слайс s от i до j заменяется содержимым итерабельного t  
del s[i:j] то же как s[i:j] = []  
s[i:j:k] = t элементы s[i:j:k] заменены элементами t (1)
del s[i:j:k] удаляет элементы s[i:j:k] из списка  
s.append(x) добавляет x к концу последовательности (то же, что и s[len(s):len(s)] = [x])  
s.clear() удаляет все элементы из s (аналогично del s[:]) (5)
s.copy() создает поверхностую копию s (аналогично s[:]) (5)
s.extend(t) или s += t расширяет s с содержимым t (по большей части то же, что и s[len(s):len(s)] = t)  
s *= n обновление s с его содержимым, повторяющимся n раз (6)
s.insert(i, x) вставляет x в s по индексу i (аналогичному s[i:i] = [x])  
s.pop([i]) извлекает элемент в i, а также удаляет его из s (2)
s.remove(x) удалить первый элемент из s, где s[i] равно x (3)
s.reverse() переворачивает элементы s на месте (4)

Примечания:

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

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

  3. remove() вызывает ValueError, когда x не найден в s.

  4. Метод reverse() изменяет последовательность на место для экономии пространства при обращении большой последовательности. Чтобы напомнить пользователям, что он работает побочным эффектом, он не возвращает обратную последовательность.

  5. clear() и copy() включены для согласования с интерфейсами изменяемых контейнеров, которые не поддерживают операции разрезания (такие как dict и set). copy() не является частью collections.abc.MutableSequence ABC, но большинство конкретных изменяемых классов последовательностей обеспечивают его.

    Добавлено в версии 3.3: clear() и copy() методы.

  6. значение n - целое число или объект, реализующий __index__(). Нулевые и отрицательные значения n очищают последовательность. Элементы в последовательности не копируются; на них ссылаются несколько раз, как объясняется для s * n в разделе Общие операции с последовательностью.

Списки

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

class list([iterable])

Списки могут быть составлены несколькими способами:

  • Использование пары квадратных скобок для обозначения пустого списка: []
  • Использование квадратных скобок, разделяя элементы запятыми: [a], [a, b, c]
  • Использование list comprehension: [x for x in iterable]
  • Использование конструктора типов: list() or list(iterable)

Конструктор создает список, элементы которого совпадают и находятся в том же порядке, что и элементы iterable. iterable может быть последовательностью, контейнером, поддерживающим итерацию, или объектом-итератором. Если iterable уже является списком, создается и возвращенный копия, аналогичная iterable[:]. Например, list('abc') возвращает ['a', 'b', 'c'] и list( (1, 2, 3) ) возвращает [1, 2, 3]. Если аргумент не задан, конструктор создает новый пустой список [].

Много других операций также создают списки, включая встроенное sorted().

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

sort(*, key=None, reverse=False)

Этот метод сортирует список по месту, используя только < сравнения между элементами. Исключения не подавляются - если какие-либо операции сравнения завершатся неуспешно, вся операция сортировки завершится неуспешно (и список, скорее всего, останется в частично измененном состояние).

sort() принимает два аргумента, которые могут быть переданы только ключевой (только ключевые аргументы):

key задает функцию одного аргумента, используемый для извлечения ключа сравнения из каждого элемента списка (например, key=str.lower). Ключ, соответствующий каждому элементу списка, вычисляется один раз, а затем используемый для всего процесса сортировки. значение None по умолчанию означает, что элементы списка сортируются непосредственно без вычисления отдельного ключевого значение.

Утилита functools.cmp_to_key() доступна для преобразования функции cmp стиля 2.x в функцию key.

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

Этот метод изменяет последовательность на месте для экономии пространства при сортировке большой последовательности. Чтобы напомнить пользователям, что он работает по побочному эффекту, он не возвращает отсортированную последовательность (используйте sorted() для явного запроса нового отсортированного списка сущность).

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

Примеры сортировки и краткое учебное пособие по сортировке см. в разделе HOWTO по сортировке.

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

Кортежи

Кортежи являются неизменяемыми последовательностями, обычно используемый для хранения коллекций гетерогенных данных (таких как 2 кортежи, произведенные встроенным enumerate()). Кортежи также используемый для случаев, когда необходима неизменяемая последовательность однородных данных (например, разрешение хранения в set или dict сущность).

class tuple([iterable])

Кортежи могут быть построены несколькими способами:

  • Использование пары скобок для обозначения пустого кортежа: ()
  • Использование завершающей запятой для одиночного кортежа: a, или (a,)
  • Разделение элементов запятыми: a, b, c или (a, b, c)
  • Использование встроенного tuple(): tuple() или tuple(iterable)

Конструктор строит кортеж, элементы которого совпадают и находятся в том же порядке, что и элементы iterable. iterable может быть последовательностью, контейнером, поддерживающим итерацию, или объектом-итератором. Если iterable уже кортеж, он возвращенный неизменен. Например, tuple('abc') возвращает ('a', 'b', 'c') и tuple( [1, 2, 3] ) возвращает (1, 2, 3). Если аргумент не задан, конструктор создает новый пустой кортеж ().

Обратите внимание, что это на самом деле запятая, которая делает кортеж, а не круглые скобки. Скобки необязательны, за исключением пустого кортежа, или когда они необходимы, чтобы избежать синтаксической неоднозначности. Например, f(a, b, c) является вызовом функции с тремя аргументами, в то время как f((a, b, c)) является вызовом функции с 3-кортежем в качестве единственного аргумента.

Кортежи реализуют все операции общие последовательности.

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

Диапазоны

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

class range(stop)
class range(start, stop[, step])

Аргументы конструктора диапазона должны быть целыми числами (встроенными int или любым объектом, реализующим __index__ специальный метод). Если аргумент step опущен, по умолчанию он имеет значение 1. Если аргумент start опущен, по умолчанию он имеет значение 0. Если step равно нулю, ValueError поднимается.

Для положительного step содержание r диапазона определяется формулой r[i] = start +    step*i где i >= 0 и r[i] < stop. Для отрицательного step содержимое диапазона по-прежнему определяется формулой r[i] = start + step*i, но ограничения являются i >= 0 и r[i] > stop.

Объект диапазона будет пуст, если r[0] не соответствует ограничению значение. Диапазоны поддерживают отрицательные индексы, но они интерпретируются как индексирование от конца последовательности, определяемой положительными индексами.

Диапазоны, содержащие абсолютные значения, превышающие sys.maxsize, разрешены, но некоторые функции (например, len()) могут вызвать OverflowError.

Примеры диапазона:

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]
>>> list(range(0, 10, 3))
[0, 3, 6, 9]
>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> list(range(0))
[]
>>> list(range(1, 0))
[]

Диапазоны реализуют все общие операции последовательности, за исключением конкатенации и повторения (из-за того, что объекты диапазона могут представлять только последовательности, которые следуют строгому шаблону, и повторение и конкатенация обычно нарушают этот шаблон).

start

Значение параметра start (или 0, если параметр не был указан)

stop

Значение параметра stop

step

Значение параметра step (или 1, если параметр не был указан)

Преимущество типа range перед обычным list или tuple состоит в том, что объект range всегда будет занимать один и тот же (небольшой) объём памяти, независимо от размера представляемого им диапазона (так как он хранит только start, stop и step значения, вычисляя при необходимости отдельные элементы и поддиапазоны).

Объекты диапазона реализуют collections.abc.Sequence ABC и предоставляют такие функции, как тесты оболочки, поиск индекса элемента, нарезка и поддержка отрицательных индексов (см. Типы последовательности — list, tuple, range):

>>> r = range(0, 20, 2)
>>> r
range(0, 20, 2)
>>> 11 in r
False
>>> 10 in r
True
>>> r.index(10)
5
>>> r[5]
10
>>> r[:5]
range(0, 10, 2)
>>> r[-1]
18

Проверка объектов диапазона на равенство с == и != сравнивает их как последовательности. То есть два объекта диапазона считаются равными, если они представляют одну и ту же последовательность значения. (Обратите внимание, что два объекта диапазона, которые сравнивают равные, могут иметь различные start, stop и step атрибуты, например range(0) == range(2, 1, 3) или range(0, 3, 2) == range(0, 4, 2).)

Изменено в версии 3.2: Реализация ABC последовательности. Поддерживать нарезку и отрицательные индексы. Проверка int объектов на членство в постоянном времени вместо итерации всех элементов.

Изменено в версии 3.3: Определите «» = = «» и «»! = «» для сравнения объектов диапазона на основе определенной ими последовательности значения (вместо сравнения на основе идентификатора объекта).

Добавлено в версии 3.3: start, stop и step атрибуты.

См.также

  • В рецепт linspace показано, как реализовать ленивый вариант диапазона, подходящий для приложений с плавающей запятой.

Тип последовательности текста — str

Текстовые данные в Python обрабатываются str объектами или strings. Строки являются неизменяемыми последовательности точек код юникода. Строковые литералы пишутся различными способами:

  • Одниночная кавычки: 'allows embedded "double" quotes'
  • Двойные кавычки: "allows embedded 'single' quotes".
  • Тройные кавычки - '''Three single quotes''', """Three double quotes"""

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

Строковые литералы, являющиеся частью одного выражения и имеющие только пробелы между ними, будут неявно преобразованы в один строка литерал. То есть, ("spam " "eggs") == "spam eggs".

Дополнительные сведения о различных формах Строковые и байтовые литералы строка, включая поддерживаемые escape-последовательности, и префикс литерал («raw»), который отключает обработку большинства escape-последовательностей, см. в разделе r.

Строки также можно создавать из других объектов с помощью конструктора str.

Поскольку нет отдельного типа «символ», индексирование строка приводит к строки длины 1. То есть для непустого строка s, s[0] == s[0:1].

Также не существует изменяемого типа строка, но str.join() или io.StringIO можно используемый для эффективного конструирования строки из нескольких фрагментов.

Изменено в версии 3.3: Для обратной совместимости с серией Python 2 префикс u снова разрешен для строка литералов. Он не влияет на значение строка литералов и не может сочетаться с префиксом r.

class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')

Возвращает строковую версию object. Если object не указан, возвращает пустой строка. В противном случае поведение str() зависит от того, дано ли encoding или errors, следующим образом.

Если не дано ни encoding, ни errors, то str(object) возвращает object.__str__(), что является «неформальным» или красиво печатаемым строка представлением object. Для строка объектов это сам строка. Если у object нет метода __str__(), то str() возвращается к возвращаемому repr(object).

Если дан хотя бы один из encoding или errors, object должен быть байтоподобным объектом (например, bytes или bytearray). В этом случае, если object является объектом bytes (или bytearray), то str(bytes, encoding, errors) эквивалентно bytes.decode(encoding, errors). В противном случае объект байтов, лежащий в основе объекта буфера, получается перед вызовом bytes.decode(). Сведения об объектах буфера см. в разделах Тип двоичной последовательности — bytes, bytearray, memoryview и Протокол буфера.

Передача объекта bytes в str() без encoding или errors аргументов подпадает под первый случай возвращения неформального строка представительства (см. также вариант -b командной строки в Python). Например:

>>> str(b'Zoot!')
"b'Zoot!'"

Дополнительные сведения о классе str и его методах см. в разделе Тип последовательности текста — str и Методы строки ниже. Для вывода форматированных строки см. разделы Форматированные строковые литералы и Синтаксис format строки. Кроме того, см. раздел Службы по обработке текста.

Методы строки

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

Строки также поддерживают два стиля форматирования строки, один из которых обеспечивает большую степень гибкости и настройки (см. str.format(), Синтаксис format строки и Пользовательское форматирование строк), а другой основан на форматировании стиля C printf, который обрабатывает более узкий диапазон типов и несколько сложнее в использовании, но часто быстрее для тех случаев, когда он может работать (printf-стиль форматирования строк).

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

str.capitalize()

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

Изменено в версии 3.8: Первый символ теперь помещен в титлекейз, а не в верхний регистр. Это означает, что символы, такие как диграфы, будут иметь только первую букву, а не полную символ.

str.casefold()

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

Casefolding похож на строчный, но более агрессивный, потому что он предназначен для удаления всех различий в строка. Например, немецкая строчная буква 'ß' эквивалентна "ss". Поскольку он уже в нижнем регистре, lower() бы ничего не сделал для 'ß'; casefold() преобразует его в "ss".

Алгоритм формирования пакетов описан в разделе 3.13 стандарта Юникод.

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

str.center(width[, fillchar])

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

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

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

str.encode(encoding="utf-8", errors="strict")

Возвращает кодированный версию строка в виде байтового объекта. кодировка по умолчанию - 'utf-8'. errors задать другую схему обработки ошибок. Значением по умолчанию для errors является 'strict', что означает, что ошибки кодировка вызывают UnicodeError. Другие возможные значения: 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' и любое другое имя, зарегистрированное через codecs.register_error(), см. раздел Обработчики ошибок. Список возможных кодировок см. в разделе Стандартные кодировки.

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

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

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

str.expandtabs(tabsize=8)

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

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

Примечание

При форматировании числа (int, float, complex, decimal.Decimal и подклассы) с типом n (например, '{:n}'.format(1234)) функция временно устанавливает LC_CTYPE locale в LC_NUMERIC locale для декодирования decimal_point и thousands_sep полей localeconv(), если они не являются ASCII или длиннее 1 байта, а LC_NUMERIC locale отличается от LC_CTYPE locale. Это временное изменение влияет на другие потоки.

Изменено в версии 3.7: При форматировании числа с типом n функция в некоторых случаях временно устанавливает LC_CTYPE локаль в LC_NUMERIC локаль.

str.format_map(mapping)

Аналогично str.format(**mapping), за исключением того, что mapping используемый непосредственно и не копируется в dict. Это полезно, если, например, mapping является словарь подкласс:

>>> class Default(dict):
...     def __missing__(self, key):
...         return key
...
>>> '{name} was born in {country}'.format_map(Default(name='Guido'))
'Guido was born in country'

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

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 в противном случае. Буквенные символы - это символы, определенные в базе данных Юникод символ как «Letter», т.е. символы с общим свойством категории «Lm», «Lt», «Lu», «Ll» или «Lo». Обратите внимание, что это отличается от свойства «Alphabetic», определенного в стандарте юникод.

str.isascii()

Возвращает True, если строка пуст или все символы в строка являются ASCII, False в противном случае. Символы ASCII имеют код точки в диапазоне U+0000-U+007F.

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

str.isdecimal()

Возвращает True, если все символы в строка являются десятичными и имеется хотя бы один символ, False в противном случае. Десятичные символы - это символы, которые можно используемый для формирования чисел в базе 10, например U+0660, ARABIC-INDIC DIGIT ZERO. Формально десятичный символ - это символ в Юникод General Category «Nd».

str.isdigit()

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

str.isidentifier()

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

Вызовите keyword.iskeyword(), чтобы проверить, является ли строка s зарезервированным идентификатором, например def и class.

Пример::

>>> from keyword import iskeyword

>>> 'hello'.isidentifier(), iskeyword('hello')
True, False
>>> 'def'.isidentifier(), iskeyword('def')
True, True
str.islower()

Возвращает True, если все символы [4] в строка являются строчными и имеется по крайней мере один символ, False в противном случае.

str.isnumeric()

Возвращает True, если все символы в строка являются числовыми и имеется хотя бы один символ, False в противном случае. Числовые символы включают в себя цифровые символы, а также все символы, имеющие свойство Юникод numeric значение, например U+2155, VULGAR FRACTION ONE FIFTH. Формально числовые символы - это символы со свойством значение Numeric_Type=Digit, Numeric_Type=Decimal или Numeric_Type=Numeric.

str.isprintable()

Возвращает True, если все символы в строка доступны для печати или строка пуст, False в противном случае. Непечатаемые символы - это символы, определенные в базе данных Юникод символ как «Other» или «Separator», за исключением пространства ASCII (0x20), которое считается печатаемым. (Обратите внимание, что печатаемые символы в этом контекст - это символы, которые не следует удалять при вызове repr() на строка. Он не влияет на обработку строки, записанных в sys.stdout или sys.stderr.)

str.isspace()

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

символ whitespace, если в базе данных Юникод символ (см. unicodedata) его общая категория - Zs («Разделитьль, пробел»), или двунаправленный класс - это класс WS, B или S.

str.istitle()

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

str.isupper()

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

str.join(iterable)

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

str.ljust(width[, fillchar])

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

str.lower()

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

Алгоритм нижнего регистра используемый описан в разделе 3.13 стандарта Юникод.

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

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

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

str.partition(sep)

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

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 (по умолчанию используется ASCII-пространство). Исходное строка возвращенный, если width меньше или равно len(s).

str.rpartition(sep)

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

str.rsplit(sep=None, maxsplit=-1)

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

str.rstrip([chars])

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

>>> '   spacious   '.rstrip()
'   spacious'
>>> 'mississippi'.rstrip('ipz')
'mississ'
str.split(sep=None, maxsplit=-1)

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

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

Например:

>>> '1,2,3'.split(',')
['1', '2', '3']
>>> '1,2,3'.split(',', maxsplit=1)
['1', '2,3']
>>> '1,2,,3,'.split(',')
['1', '2', '', '3', '']

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

Например:

>>> '1 2 3'.split()
['1', '2', '3']
>>> '1 2 3'.split(maxsplit=1)
['1', '2 3']
>>> '   1   2   3   '.split()
['1', '2', '3']
str.splitlines([keepends])

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

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

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

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

Например:

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=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', '']
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'

Крайние ведущие и конечные chars аргументов значения удаляются из строка. Символы удаляются с ведущего конца до достижения строка символ, не содержащегося в множестве символов в chars. Аналогичное действие происходит на заднем конце. Например:

>>> comment_string = '#....... Section 3.2.1 Issue #32 .......'
>>> comment_string.strip('.#! ')
'Section 3.2.1 Issue #32'
str.swapcase()

Возвращает копию строка с прописными символами, преобразованными в строчные и наоборот. Обратите внимание, что s.swapcase().swapcase() == s не обязательно соответствует действительности.

str.title()

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

Например:

>>> 'Hello world'.title()
'Hello World'

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

>>> "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).capitalize(),
...                   s)
...
>>> titlecase("they're bill's friends.")
"They're Bill's Friends."
str.translate(table)

Возвращает копию строка, в которой каждый символ был сопоставлен через заданную таблицу преобразования. Таблица должна быть объектом, реализующим индексирование через __getitem__(), обычно отображение или последовательность. При индексировании по порядковому номеру юникода (целое число) объект таблицы может выполнить любое из следующих действий: возвращает порядковый номер юникода или строка, чтобы сопоставить символ с одним или несколькими другими символами; возвращает None, исключить символ из возвращает строка; или создать LookupError исключение, чтобы сопоставить символ самому себе.

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

См. также модуль codecs для более гибкого подхода к пользовательским сопоставлениям символ.

str.upper()

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

Алгоритм повышения частоты используемый описан в разделе 3.13 стандарта Юникод.

str.zfill(width)

Возвращает копию строка слева, заполненную '0' цифрами ASCII, чтобы создать строка длины width. Префикс ведущего знака ('+'/'-') обрабатывается путем вставки заполнения after символ знака, а не раньше. Исходное строка возвращенный, если width меньше или равно len(s).

Например:

>>> "42".zfill(5)
'00042'
>>> "-42".zfill(5)
'-0042'

printf-стиль форматирования строк

Примечание

Описанные здесь операции форматирования демонстрируют множество проблем, которые приводят к ряду распространенных ошибок (например, к неправильному отображению кортежей и словарей). Использование новые форматированные строковые литералы, интерфейса str.format() или строковый шаблон может помочь избежать этих ошибок. Каждая из этих альтернатив обеспечивает свои собственные компромиссы и преимущества простоты, гибкости и/или расширяемости.

Строковые объекты имеют одну уникальную встроенную операцию: оператор % (по модулю). Это также называется оператором строка formatting или interpolation. Данные format % values (где format - строка), конверсионные технические требования % в format заменены нолем или большим количеством элементов values. Эффект аналогичен использованию sprintf() на языке C.

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

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

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

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

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

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

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

Флаг Значение
'#' При преобразовании значения будет использоваться «альтернативная форма» (где определено ниже).
'0' Преобразование будет заполнено нулями для числовых значений.
'-' Преобразованное значение корректируется слева (переопределяет преобразование '0', если оба предоставлены).
' ' (пробел) Пробел должен быть оставлен перед положительным числом (или пустая строка), полученная в результате преобразования со знаком.
'+' Знаковый символ ('+' или '-') будет предшествовать преобразованию (переопределяет флаг «space»).

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

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

Преобразование Значение Примечания
'd' Десятичное целое число со знаком.  
'i' Десятичное целое число со знаком.  
'o' Знаковое восьмеричные значение. (1)
'u' Устаревший тип - он идентичен 'd'. (6)
'x' Шестнадцатеричный десятичный со знаком (нижний регистр). (2)
'X' Шестнадцатеричный десятичный со знаком (верхний регистр). (2)
'e' Экспоненциальный формат с плавающей запятой (нижний регистр). (3)
'E' Экспоненциальный формат с плавающей запятой (верхний регистр). (3)
'f' Десятичный формат с плавающей точкой. (3)
'F' Десятичный формат с плавающей точкой. (3)
'g' Формат с плавающей запятой. Используется строчный экспоненциальный формат, если экспонента меньше -4 или не меньше точности, в противном случае - десятичный формат. (4)
'G' Формат с плавающей запятой. Используется заглавный экспоненциальный формат, если экспонента меньше -4 или не меньше точности, в противном случае - десятичный формат. (4)
'c' Единичный символ (принимает целочисленный или одинарный символ строки).  
'r' Строка (преобразует любой Python объект с помощью repr()). (5)
's' Строка (преобразует любой Python объект с помощью str()). (5)
'a' Строка (преобразует любой Python объект с помощью ascii()). (5)
'%' Ни один аргумент не преобразуется, что приводит появление '%' символа в результате.  

Примечания:

  1. Альтернативная форма приводит к вставке ведущего восьмеричного спецификатора ('0o') перед первой цифрой.

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

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

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

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

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

  5. Если точность N, вывод усекается до N символов.

  6. См. PEP 237.

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

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

Тип двоичной последовательности — bytes, bytearray, memoryview

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

Модуль array поддерживает эффективное место хранения типов основных данных как 32-битные целые числа и двойная точность IEEE754, чисел с плавающей точкой значения.

Объекты байтов

Байтовые объекты являются неизменяемыми последовательностями одиночных байтов. Поскольку многие основные двоичные протоколы основаны на текстовом кодировка ASCII, байтовые объекты предлагают несколько методов, которые действительны только при работе с данными, совместимыми с ASCII, и тесно связаны с строка объектами различными другими способами.

class bytes([source[, encoding[, errors]]])

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

  • Одиночные кавычки: b'still allows embedded "double" quotes'
  • Двойные кавычки: b"still allows embedded 'single' quotes".
  • Тройные кавычки - b'''3 single quotes''', b"""3 double quotes"""

В байтах допускаются только символы ASCII (независимо от объявленного исходного код кодировка). Любой двоичный значения, превышающий 127, должен быть введен в литералы байтов с использованием соответствующей escape- последовательности.

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

В то время как байты литералов и представлений основаны на ASCII тексте, байты объекты на самом деле ведут себя как неизменяемые последовательности целых чисел, причем каждая значение в последовательности ограничена таким образом, что 0 <= x < 256 (попытки нарушить это ограничение вызовут ValueError). Это делается намеренно, чтобы подчеркнуть, что, хотя многие двоичные форматы включают элементы на основе ASCII и могут быть с пользой манипулированы с некоторыми текстовыми алгоритмами, это, как правило, не относится к произвольным двоичным данным (слепое применение алгоритмов обработки текста к двоичным форматам данных, которые не совместимы с ASCII, обычно приводит к повреждению данных).

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

  • Объект байтов с нулевым заполнением указанной длины: bytes(10)
  • из итерабля целых чисел: bytes(range(20))
  • копирование существующих двоичных данных через протокол буфера: bytes(obj)

Также см. встроенный байты.

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

classmethod fromhex(string)

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

>>> bytes.fromhex('2Ef0 F1f2  ')
b'.\xf0\xf1\xf2'

Изменено в версии 3.7: Теперь bytes.fromhex() пропускает все пробелы ASCII в строка, а не только пробелы.

Функция обратного преобразования существует для преобразования байтового объекта в его шестнадцатеричное представление.

hex([sep[, bytes_per_sep]])

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

>>> b'\xf0\xf1\xf2'.hex()
'f0f1f2'

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

>>> value = b'\xf0\xf1\xf2'
>>> value.hex('-')
'f0-f1-f2'
>>> value.hex('_', 2)
'f0_f1f2'
>>> b'UUDDLRLRAB'.hex(' ', -4)
'55554444 4c524c52 4142'

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

Изменено в версии 3.8: bytes.hex() теперь поддерживает дополнительные параметры sep и bytes_per_sep для вставки разделителей между байтами в шестнадцатеричный вывод.

Поскольку объекты bytes являются последовательностями целых чисел (сродни кортежу), для объекта bytes b b[0] будет целым числом, в то время как b[0:1] будет объектом bytes длиной 1. (Это контрастирует с текстовым строки, где и индексирование, и разрезание создают строка длиной 1)

Представление байтов объектов использует формат литерал (b'...'), поскольку он часто более полезен, чем, например, bytes([46, 46, 46]). Объект bytes всегда можно преобразовать в список целых чисел с помощью list(b).

Примечание

Для пользователей Python 2.x: в серии Python 2.x допускались разнообразные неявные преобразования между 8-битными строки (наиболее близкая вещь 2.x предлагает встроенному бинарному типу данных) и Юникод строки. Это был обходной путь обратной совместимости, чтобы учесть тот факт, что первоначально Python поддерживал только 8-битный текст, а текст в юникоде был более поздним дополнением. В Python 3.x эти неявные преобразования исчезли - преобразования между 8-битными двоичными данными и текстом юникода должны быть явными, а байты и строка объекты всегда будут сравнивать неравные.

Объекты bytearray

bytearray объекты являются изменяемым аналогом bytes объектов.

class bytearray([source[, encoding[, errors]]])

Отсутствует выделенный синтаксис литерал для объектов bytearray, вместо этого они всегда создаются путем вызова конструктора:

  • Создание пустую сущность: bytearray()
  • Создание заполненного нулем сущность с заданной длиной: bytearray(10)
  • Итератора целых чисел: bytearray(range(20))
  • Копирование существующих двоичных данных через буферный протокол: bytearray(b'Hi!')

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

Также см. встроенный bytearray.

Поскольку 2 шестнадцатеричные цифры точно соответствуют одному байту, шестнадцатеричные числа являются обычно используемый форматом для описания двоичных данных. Соответственно, тип bytearray имеет дополнительный метод класса для считывания данных в этом формате:

classmethod fromhex(string)

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

>>> bytearray.fromhex('2Ef0 F1f2  ')
bytearray(b'.\xf0\xf1\xf2')

Изменено в версии 3.7: Теперь bytearray.fromhex() пропускает все пробелы ASCII в строка, а не только пробелы.

Функция обратного преобразования существует для преобразования объекта bytearray в его шестнадцатеричное представление.

hex([sep[, bytes_per_sep]])

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

>>> bytearray(b'\xf0\xf1\xf2').hex()
'f0f1f2'

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

Изменено в версии 3.8: Подобно bytes.hex(), bytearray.hex() теперь поддерживает дополнительные параметры sep и bytes_per_sep для вставки разделителей между байтами в шестнадцатеричный вывод.

Поскольку объекты bytearray являются последовательностями целых чисел (сродни списку), для объекта bytearray b b[0] будет целым числом, в то время как b[0:1] будет объектом bytearray длиной 1. (Это контрастирует с текстовым строки, где и индексирование, и разрезание создают строка длиной 1)

Представление объектов bytearray использует байты формат (bytearray(b'...')) литерал, так как это часто более полезно, чем, например, bytearray([46, 46, 46]). Объект bytearray всегда можно преобразовать в список целых чисел с помощью list(b).

Байты и операции с массивом байтов

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

Примечание

Методы в байтах и объектах bytearray не принимают строки в качестве аргументов, так же как методы в строки не принимают байты в качестве аргументов. Например, надо писать:

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

и:

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

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

Примечание

Использование этих операций на основе ASCII для манипулирования двоичными данными, которые не хранятся в формате на основе ASCII, может привести к повреждению данных.

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

bytes.count(sub[, start[, end]])
bytearray.count(sub[, start[, end]])

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

Подпоследовательность для поиска может быть любой байтоподобным объектом или целым числом в диапазоне от 0 до 255.

Изменено в версии 3.3: Также примите целое число в диапазоне от 0 до 255 в качестве подпоследовательности.

bytes.decode(encoding="utf-8", errors="strict")
bytearray.decode(encoding="utf-8", errors="strict")

Возвращает строка, декодированный из заданных байтов. кодировка по умолчанию - 'utf-8'. errors задать другую схему обработки ошибок. Значением по умолчанию для errors является 'strict', что означает, что ошибки кодировка вызывают UnicodeError. Другими возможными значения являются 'ignore', 'replace' и любое другое имя, зарегистрированное через codecs.register_error(), см. раздел Обработчики ошибок. Список возможных кодировок см. в разделе Стандартные кодировки.

Примечание

Передача аргумента encoding в str позволяет декодировать любой байтоподобный объект напрямую, без необходимости создания временного объекта bytearray или объекта bytearray.

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

bytes.endswith(suffix[, start[, end]])
bytearray.endswith(suffix[, start[, end]])

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

Суффикс(ы) для поиска может быть любым байтоподобным объектом.

bytes.find(sub[, start[, end]])
bytearray.find(sub[, start[, end]])

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

Подпоследовательность для поиска может быть любой байтоподобный объект или целым числом в диапазоне от 0 до 255.

Примечание

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

>>> b'Py' in b'Python'
True

Изменено в версии 3.3: Также примите целое число в диапазоне от 0 до 255 в качестве подпоследовательности.

bytes.index(sub[, start[, end]])
bytearray.index(sub[, start[, end]])

Как и find(), но поднимайте ValueError, когда подпоследовательность не найдена.

Подпоследовательность для поиска может быть любым байтоподобным объектом или целым числом в диапазоне от 0 до 255.

Изменено в версии 3.3: Также примите целое число в диапазоне от 0 до 255 в качестве подпоследовательности.

bytes.join(iterable)
bytearray.join(iterable)

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

static bytes.maketrans(from, to)
static bytearray.maketrans(from, to)

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

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

bytes.partition(sep)
bytearray.partition(sep)

Разделить последовательность при первом вхождении sep и возвращает 3-кортеж, содержащий элемент перед сепаратором, сам сепаратор или его копию массива байт и элемент после сепаратора. Если разделитель не найден, возвращает 3-кортеж, содержащий копию исходной последовательности, за которым следуют два пустых байта или объекта bytearray.

Для поиска может использоваться любой байтоподобный объект.

bytes.replace(old, new[, count])
bytearray.replace(old, new[, count])

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

Подпоследовательность поиска и его замена может быть любой байтоподобный объект.

Примечание

Версия bytearray этого метода не работает на месте - он всегда производит новый объект, даже если изменений не было внесено.

bytes.rfind(sub[, start[, end]])
bytearray.rfind(sub[, start[, end]])

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

Подпоследовательность для поиска может быть любой байтоподобный объект или целым числом в диапазоне от 0 до 255.

Изменено в версии 3.3: Также примите целое число в диапазоне от 0 до 255 в качестве подпоследовательности.

bytes.rindex(sub[, start[, end]])
bytearray.rindex(sub[, start[, end]])

Как rfind() но поднимает ValueError, когда sub подпоследовательности не найден.

Подпоследовательность для поиска может быть любой байтоподобный объект или целым числом в диапазоне от 0 до 255.

Изменено в версии 3.3: Также примите целое число в диапазоне от 0 до 255 в качестве подпоследовательности.

bytes.rpartition(sep)
bytearray.rpartition(sep)

Разделить последовательность в последнем случае sep и возвращает 3-кортеж, содержащий элемент перед сепаратором, сам сепаратор или его копию массива байт и элемент после сепаратора. Если разделитель не найден, возвращает 3-кортеж, содержащий два пустых байта или объекты bytearray с последующей копией исходной последовательности.

Для поиска может использоваться любой байтоподобный объект.

bytes.startswith(prefix[, start[, end]])
bytearray.startswith(prefix[, start[, end]])

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

Префикс(ы) для поиска может быть любым байтоподобным объектом.

bytes.translate(table, /, delete=b'')
bytearray.translate(table, /, delete=b'')

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

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

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

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

Изменено в версии 3.6: delete теперь поддерживается в качестве аргумента ключевой.

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

bytes.center(width[, fillbyte])
bytearray.center(width[, fillbyte])

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

Примечание

Версия bytearray этого метода не работает на месте - он всегда производит новый объект, даже если изменений не было внесено.

bytes.ljust(width[, fillbyte])
bytearray.ljust(width[, fillbyte])

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

Примечание

Версия bytearray этого метода не работает на месте - он всегда производит новый объект, даже если изменений не было внесено.

bytes.lstrip([chars])
bytearray.lstrip([chars])

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

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

Двоичная последовательность байтов, значения для удаления, может быть любым байтоподобным объектом.

Примечание

Версия bytearray этого метода не работает на месте - он всегда производит новый объект, даже если изменений не было внесено.

bytes.rjust(width[, fillbyte])
bytearray.rjust(width[, fillbyte])

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

Примечание

Версия bytearray этого метода не работает на месте - он всегда производит новый объект, даже если изменений не было внесено.

bytes.rsplit(sep=None, maxsplit=-1)
bytearray.rsplit(sep=None, maxsplit=-1)

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

bytes.rstrip([chars])
bytearray.rstrip([chars])

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

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

Двоичная последовательность байтов, значения для удаления, может быть любой байтоподобный объект.

Примечание

Версия bytearray этого метода не работает на месте - он всегда производит новый объект, даже если изменений не было внесено.

bytes.split(sep=None, maxsplit=-1)
bytearray.split(sep=None, maxsplit=-1)

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

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

Например:

>>> b'1,2,3'.split(b',')
[b'1', b'2', b'3']
>>> b'1,2,3'.split(b',', maxsplit=1)
[b'1', b'2,3']
>>> b'1,2,,3,'.split(b',')
[b'1', b'2', b'', b'3', b'']

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

Например:

>>> b'1 2 3'.split()
[b'1', b'2', b'3']
>>> b'1 2 3'.split(maxsplit=1)
[b'1', b'2 3']
>>> b'   1   2   3   '.split()
[b'1', b'2', b'3']
bytes.strip([chars])
bytearray.strip([chars])

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

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

Двоичная последовательность байтов, значения для удаления, может быть любой байтоподобный объект.

Примечание

Версия bytearray этого метода не работает на месте - он всегда производит новый объект, даже если изменений не было внесено.

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

bytes.capitalize()
bytearray.capitalize()

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

Примечание

Версия bytearray этого метода не работает на месте - он всегда производит новый объект, даже если изменений не было внесено.

bytes.expandtabs(tabsize=8)
bytearray.expandtabs(tabsize=8)

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

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

Примечание

Версия bytearray этого метода не работает на месте - он всегда производит новый объект, даже если изменений не было внесено.

bytes.isalnum()
bytearray.isalnum()

Возвращает True, если все байты в последовательности являются алфавитными символами ASCII или десятичными цифрами ASCII и последовательность не пуста, False в противном случае. Буквенные символы ASCII - это байты, значения в b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' последовательности. Десятичные цифры ASCII - это байты, значения в b'0123456789' последовательности.

Например:

>>> b'ABCabc1'.isalnum()
True
>>> b'ABC abc1'.isalnum()
False
bytes.isalpha()
bytearray.isalpha()

Возвращает True, если все байты в последовательности являются буквами ASCII и последовательность не пуста, False в противном случае. Буквенные символы ASCII - это байты, значения в b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' последовательности.

Например:

>>> b'ABCabc'.isalpha()
True
>>> b'ABCabc1'.isalpha()
False
bytes.isascii()
bytearray.isascii()

Возвращает True, если последовательность пуста или все байты в последовательности являются ASCII, False в противном случае. Байты ASCII находятся в диапазоне 0-0x7F.

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

bytes.isdigit()
bytearray.isdigit()

Возвращает True, если все байты в последовательности являются десятичными цифрами ASCII и последовательность не пуста, False в противном случае. Десятичные цифры ASCII - это байты, значения в b'0123456789' последовательности.

Например:

>>> b'1234'.isdigit()
True
>>> b'1.23'.isdigit()
False
bytes.islower()
bytearray.islower()

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

Например:

>>> b'hello world'.islower()
True
>>> b'Hello world'.islower()
False

Строчные символы ASCII - это байты, значения в b'abcdefghijklmnopqrstuvwxyz' последовательности. Прописные символы ASCII - это байты, значения в b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' последовательности.

bytes.isspace()
bytearray.isspace()

Возвращает True, если все байты в последовательности являются пробелами ASCII и последовательность не пуста, False в противном случае. Пробелы ASCII - это байтовые значения в b' \t\n\r\x0b\f' последовательности (пробел, вкладка, новая строка, возвращает каретки, вертикальная вкладка, канал формы).

bytes.istitle()
bytearray.istitle()

Возвращает True, если последовательность является ASCII titlecase и последовательность не пуста, False в противном случае. Дополнительные сведения об определении «titlecase» см. в разделе bytes.title().

Например:

>>> b'Hello World'.istitle()
True
>>> b'Hello world'.istitle()
False
bytes.isupper()
bytearray.isupper()

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

Например:

>>> b'HELLO WORLD'.isupper()
True
>>> b'Hello world'.isupper()
False

Строчные символы ASCII - это байты, значения в b'abcdefghijklmnopqrstuvwxyz' последовательности. Прописные символы ASCII - это байты, значения в b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' последовательности.

bytes.lower()
bytearray.lower()

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

Например:

>>> b'Hello World'.lower()
b'hello world'

Строчные символы ASCII - это байты, значения в b'abcdefghijklmnopqrstuvwxyz' последовательности. Прописные символы ASCII - это байты, значения в b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' последовательности.

Примечание

Версия bytearray этого метода не работает на месте - он всегда производит новый объект, даже если изменений не было внесено.

bytes.splitlines(keepends=False)
bytearray.splitlines(keepends=False)
Возвращает список строк в двоичной последовательности с разрывом границ линий
ASCII. Этот метод использует :term:`универсальные новые строки <универсальный символ новой строки>`
подход к разделению строк. Разрывы
строк не включаются в результирующий список, если не задано значение *keepends*
и не задано значение true.

Например:

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

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

>>> b"".split(b'\n'), b"Two lines\n".split(b'\n')
([b''], [b'Two lines', b''])
>>> b"".splitlines(), b"One line\n".splitlines()
([], [b'One line'])
bytes.swapcase()
bytearray.swapcase()

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

Например:

>>> b'Hello World'.swapcase()
b'hELLO wORLD'

Строчные символы ASCII - это байты, значения в b'abcdefghijklmnopqrstuvwxyz' последовательности. Прописные символы ASCII - это байты, значения в b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' последовательности.

В отличие от str.swapcase(), это всегда случай, который bin.swapcase().swapcase() == bin для двоичных версий. Преобразования вариантов симметричны в ASCII, хотя это обычно не верно для произвольных точек код юникода.

Примечание

Версия bytearray этого метода не работает на месте - он всегда производит новый объект, даже если изменений не было внесено.

bytes.title()
bytearray.title()

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

Например:

>>> b'Hello world'.title()
b'Hello World'

Строчные символы ASCII - это байты, значения в b'abcdefghijklmnopqrstuvwxyz' последовательности. Прописные символы ASCII - это байты, значения в b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' последовательности. Все остальные байтовые значения не привязаны.

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

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

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

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

Примечание

Версия bytearray этого метода не работает на месте - он всегда производит новый объект, даже если изменений не было внесено.

bytes.upper()
bytearray.upper()

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

Например:

>>> b'Hello World'.upper()
b'HELLO WORLD'

Строчные символы ASCII - это байты, значения в b'abcdefghijklmnopqrstuvwxyz' последовательности. Прописные символы ASCII - это байты, значения в b'ABCDEFGHIJKLMNOPQRSTUVWXYZ' последовательности.

Примечание

Версия bytearray этого метода не работает на месте - он всегда производит новый объект, даже если изменений не было внесено.

bytes.zfill(width)
bytearray.zfill(ширина)

Возвращает копию последовательности, заполненную b'0' цифрами ASCII, чтобы сделать последовательность длиной width. Префикс ведущего знака (b'+'/ b'-') обрабатывается путем вставки заполнения after символ знака, а не раньше. Для bytes объектов исходная последовательность будет возвращенный, если width меньше или равна len(seq).

Например:

>>> b"42".zfill(5)
b'00042'
>>> b"-42".zfill(5)
b'-0042'

Примечание

Версия bytearray этого метода не работает на месте - он всегда производит новый объект, даже если изменений не было внесено.

printf-стиль форматирования байтов

Примечание

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

Байтовые объекты (bytes/bytearray) имеют одну уникальную встроенную операцию: оператор % (по модулю). Это также называется formatting байтов или оператором interpolation. Данные format % values (где format - объект байтов), конверсионные технические требования % в format заменены нолем или большим количеством элементов values. Эффект аналогичен использованию sprintf() на языке C.

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

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

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

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

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

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

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

Флаг Значение
'#' При преобразовании значение будет использоваться «альтернативная форма» (где определено ниже).
'0' Преобразование будет заполнено нулями для числовых значений.
'-' Преобразованный значение корректируется слева (переопределяет преобразование '0', если заданы оба значения).
' ' (пробел) пробел должен быть оставлен перед положительным числом (или пустой строкой), полученным путем преобразования со знаком.
'+' Знаковый символ ('+' или '-') будет предшествовать преобразованию (переопределяет флаг «пробел»).

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

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

Преобразование Значение Примечания
'd' Десятичное целое число со знаком.  
'i' Десятичное целое число со знаком.  
'o' Знаковое восьмеричные значение. (1)
'u' Устаревший тип - он идентичен 'd'. (8)
'x' Шестнадцатеричный со знаком (нижний регистр). (2)
'X' Шестнадцатеричный со знаком (верхний регистр). (2)
'e' Экспоненциальный формат с плавающей запятой (нижний регистр). (3)
'E' Экспоненциальный формат с плавающей запятой (верхний регистр). (3)
'f' Десятичный формат с плавающей запятой. (3)
'F' Десятичный формат с плавающей запятой. (3)
'g' Формат с плавающей запятой. Использует строчный кспоненциальный формат, если экспонента меньше 4 или не меньше точности, в противном случае - десятичный формат. (4)
'G' Формат с плавающей запятой. Использует экспоненциальный формат верхнего регистра, если экспонента меньше 4 или не меньше точности, в противном случае - десятичный формат. (4)
'c' Одиночный байт (принимает целочисленные или однобайтовые объекты).  
'b' Байты (любой объект, следующий за буферный протокол или имеющий __bytes__()). (5)
's' 's' - алиас для 'b' и должен использоваться только в для Python2/3 основанном коде. (6)
'a' Байты (преобразует любой Python объект с помощью repr(obj).encode('ascii','backslashreplace)). (5)
'r' 'r' - алиас для 'a' и должен только быть используем для Python2/3 основанном коде. (7)
'%'
Ни один аргумент не преобразуется, что приводит к
'%' символ в результате.
 

Примечания:

  1. Альтернативная форма приводит к вставке ведущего восьмеричного спецификатора ('0o') перед первой цифрой.

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

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

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

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

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

  5. Если точность N, вывод усекается до N символов.

  6. b'%s' устарел, но не будет удален во время серии 3.x.

  7. b'%r' устарел, но не будет удален во время серии 3.x.

  8. См. PEP 237.

Примечание

Версия bytearray этого метода не работает на месте - он всегда производит новый объект, даже если изменений не было внесено.

См.также

PEP 461 - добавление % форматирования к байтам и массиву байт

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

Представления памяти

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

class memoryview(obj)

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

У memoryview есть понятие element, которое представляет собой блок атомной памяти, обрабатываемый исходящим объектом obj. Для многих простых типов, таких как bytes и bytearray, элемент является одним байтом, но другие типы, такие как array.array, могут иметь большие элементы.

len(view) равно длине tolist. Если view.ndim = 0, длина равна 1. При view.ndim = 1 длина равна количеству элементов на виде. Для более высоких размеров длина равна длине вложенного представления вида в списке. В itemsize атрибут будет указано количество байтов в одном элементе.

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

>>> v = memoryview(b'abcefg')
>>> v[1]
98
>>> v[-1]
103
>>> v[1:4]
<memory at 0x7f3ddc9f4350>
>>> bytes(v[1:4])
b'bce'

Если format является одним из собственных спецификаторов формата из модуля struct, индексирование целым числом или кортежем целых чисел также поддерживается и возвращает один element с правильным типом. Одномерные memoryviews могут индексироваться целым числом или одноцелочисленным кортежем. Многомерные memoryviews могут индексироваться кортежами точно ndim целых чисел, где ndim - количество измерений. Нулевые размеры запоминающих устройств могут индексироваться пустым кортежем.

Вот пример с небайтовым форматом:

>>> import array
>>> a = array.array('l', [-11111111, 22222222, -33333333, 44444444])
>>> m = memoryview(a)
>>> m[0]
-11111111
>>> m[-1]
44444444
>>> m[::2].tolist()
[-11111111, -33333333]

Если базовый объект доступен для записи, запоминающее устройство поддерживает одномерное назначение срезов. Изменение размера недопустимо:

>>> data = bytearray(b'abcefg')
>>> v = memoryview(data)
>>> v.readonly
False
>>> v[0] = ord(b'z')
>>> data
bytearray(b'zbcefg')
>>> v[1:4] = b'123'
>>> data
bytearray(b'z123fg')
>>> v[2:3] = b'spam'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: memoryview assignment: lvalue and rvalue have different structures
>>> v[2:6] = b'spam'
>>> data
bytearray(b'z1spam')

Одномерные memoryviews хешируемых (только для чтения) типов с форматами «B», «b» или «c» также являются хешируемыми. Хэш определяется как hash(m) == hash(m.tobytes()):

>>> v = memoryview(b'abcefg')
>>> hash(v) == hash(b'abcefg')
True
>>> hash(v[2:4]) == hash(b'ce')
True
>>> hash(v[::-2]) == hash(b'abcefg'[::-2])
True

Изменено в версии 3.3: Теперь одномерные memoryviews можно разрезать. Одномерные memoryviews с форматами «B», «b» или «c» теперь являются хэшируемыми.

Изменено в версии 3.4: Теперь memoryview регистрируется автоматически в collections.abc.Sequence

Изменено в версии 3.5: memoryviews теперь могут индексироваться кортежем целых чисел.

memoryview имеет несколько методов:

__eq__(exporter)

Представление памяти и средство экспорта PEP 3118 равны, если их формы эквивалентны, и если все соответствующие значения равны, когда соответствующие коды формата операндов интерпретируются с использованием struct синтаксиса.

Для подмножества struct формата строки поддерживаемого в настоящее время tolist(), v и w равны, если v.tolist() == w.tolist():

>>> import array
>>> a = array.array('I', [1, 2, 3, 4, 5])
>>> b = array.array('d', [1.0, 2.0, 3.0, 4.0, 5.0])
>>> c = array.array('b', [5, 3, 1])
>>> x = memoryview(a)
>>> y = memoryview(b)
>>> x == a == y == b
True
>>> x.tolist() == a.tolist() == y.tolist() == b.tolist()
True
>>> z = y[::-2]
>>> z == c
True
>>> z.tolist() == c.tolist()
True

Если любой строка формата не поддерживается модулем struct, то объекты всегда будут сравниваться как неравные (даже если строки формата и содержимое буфера идентичны):

>>> from ctypes import BigEndianStructure, c_long
>>> class BEPoint(BigEndianStructure):
...     _fields_ = [("x", c_long), ("y", c_long)]
...
>>> point = BEPoint(100, 200)
>>> a = memoryview(point)
>>> b = memoryview(point)
>>> a == point
False
>>> a == b
False

Обратите внимание, что, как и в случае чисел с плавающей запятой, v is w не подразумевает v == w объектов memoryview.

Изменено в версии 3.3: Предыдущие версии сравнивали необработанную память без учета формата элемента и структуры логического массива.

tobytes(order=None)

Возвращает данные в буфере как bytestring. Это эквивалентно вызову конструктора bytes в представлении памяти.:

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

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

Добавлено в версии 3.8: order могут быть {„C“, „F“, „A“}. Когда order равно «C» или «F», данные исходного массива преобразуются в порядок C или Fortran. Для смежных представлений „A“ возвращает точную копию физической памяти. В частности, сохраняется имманентный порядок фортрана. Для несмежных представлений данные сначала преобразуются в C. order=None совпадает с order=“C“.

hex([sep[, bytes_per_sep]])

Возвращает объект строка, содержащий две шестнадцатеричные цифры для каждого байта в буфере.

>>> m = memoryview(b"abc")
>>> m.hex()
'616263'

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

Изменено в версии 3.8: Подобно bytes.hex(), memoryview.hex() теперь поддерживает дополнительные параметры sep и bytes_per_sep для вставки разделителей между байтами в шестнадцатеричный вывод.

tolist()

Возвращает данные в буфере в виде списка элементов.:

>>> memoryview(b'abc').tolist()
[97, 98, 99]
>>> import array
>>> a = array.array('d', [1.1, 2.2, 3.3])
>>> m = memoryview(a)
>>> m.tolist()
[1.1, 2.2, 3.3]

Изменено в версии 3.3: Теперь tolist() поддерживает все собственные форматы в символ синтаксисе модуля struct а также многомерные представления.

toreadonly()

Возвращает только для чтения версию объекта memoryview. Исходный объект memoryview не изменился.

>>> m = memoryview(bytearray(b'abc'))
>>> mm = m.toreadonly()
>>> mm.tolist()
[89, 98, 99]
>>> mm[0] = 42
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot modify read-only memory
>>> m[0] = 43
>>> mm.tolist()
[43, 98, 99]

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

release()

Освободить базовый буфер, отображаемый объектом memoryview. Многие объекты выполняют специальные действия, когда на них содержится представление (например, bytearray временно запрещает изменение размера); поэтому вызов release() удобен для скорейшего устранения этих ограничений (и освобождения любых висячих ресурсов).

После вызова этого метода любая дальнейшая операция над представлением вызывает ValueError (за исключением самого release(), который может вызываться несколько раз):

>>> m = memoryview(b'abc')
>>> m.release()
>>> m[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: operation forbidden on released memoryview object

Протокол управления контекст может быть используемый для аналогичного эффекта с помощью with инструкция:

>>> with memoryview(b'abc') as m:
...     m[0]
...
97
>>> m[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: operation forbidden on released memoryview object

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

cast(format[, shape])

Приведение вида памяти к новому формату или форме. По умолчанию shape имеет значение [byte_length//new_itemsize], что означает, что вид результата будет одномерным. возвращает значение является новым видом памяти, но сам буфер не копируется. Поддерживаемые приведения являются 1D - > C-смежный и C-смежными - > 1D.

Формат назначения ограничен собственным форматом одного элемента в struct синтаксисе. Один из форматов должен быть байтовым форматом («B», «b» или «c»). Длина байта результата должна совпадать с исходной длиной.

Приведение 1D/long к 1D/unsigned байтам:

>>> import array
>>> a = array.array('l', [1,2,3])
>>> x = memoryview(a)
>>> x.format
'l'
>>> x.itemsize
8
>>> len(x)
3
>>> x.nbytes
24
>>> y = x.cast('B')
>>> y.format
'B'
>>> y.itemsize
1
>>> len(y)
24
>>> y.nbytes
24

Приведение 1D/unsigned байтов к 1D/char:

>>> b = bytearray(b'zyz')
>>> x = memoryview(b)
>>> x[0] = b'a'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: memoryview: invalid value for format "B"
>>> y = x.cast('c')
>>> y[0] = b'a'
>>> b
bytearray(b'ayz')

Привести 1D/байты к 3D/инты к 1D/знаковым символам:

>>> import struct
>>> buf = struct.pack("i"*12, *list(range(12)))
>>> x = memoryview(buf)
>>> y = x.cast('i', shape=[2,2,3])
>>> y.tolist()
[[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]]
>>> y.format
'i'
>>> y.itemsize
4
>>> len(y)
2
>>> y.nbytes
48
>>> z = y.cast('b')
>>> z.format
'b'
>>> z.itemsize
1
>>> len(z)
48
>>> z.nbytes
48

От 1D/беззнаковый длинной до 2D/беззнаковый длинной:

>>> buf = struct.pack("L"*6, *list(range(6)))
>>> x = memoryview(buf)
>>> y = x.cast('L', shape=[2,3])
>>> len(y)
2
>>> y.nbytes
48
>>> y.tolist()
[[0, 1, 2], [3, 4, 5]]

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

Изменено в версии 3.5: Исходный формат больше не ограничен при передаче в байтовое представление.

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

obj

Базовый объект memoryview:

>>> b  = bytearray(b'xyz')
>>> m = memoryview(b)
>>> m.obj is b
True

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

nbytes

nbytes == product(shape) * itemsize == len(m.tobytes()). Это объем пространства в байтах, который массив будет использовать в непрерывном представлении. Это не обязательно равно len(m):

>>> import array
>>> a = array.array('i', [1,2,3,4,5])
>>> m = memoryview(a)
>>> len(m)
5
>>> m.nbytes
20
>>> y = m[::2]
>>> len(y)
3
>>> y.nbytes
12
>>> len(y.tobytes())
12

Многомерные множества:

>>> import struct
>>> buf = struct.pack("d"*12, *[1.5*x for x in range(12)])
>>> x = memoryview(buf)
>>> y = x.cast('d', shape=[3,4])
>>> y.tolist()
[[0.0, 1.5, 3.0, 4.5], [6.0, 7.5, 9.0, 10.5], [12.0, 13.5, 15.0, 16.5]]
>>> len(y)
3
>>> y.nbytes
96

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

readonly

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

format

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

Изменено в версии 3.3: Формат 'B' теперь обрабатывается в соответствии с синтаксисом модуля структуры. Это значит, что memoryview(b'abc')[0] == b'abc'[0] == 97.

itemsize

Размер каждого элемента запоминающего устройства в байтах:

>>> import array, struct
>>> m = memoryview(array.array('H', [32000, 32001, 32002]))
>>> m.itemsize
2
>>> m[0]
32000
>>> struct.calcsize('H') == m.itemsize
True
ndim

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

shape

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

Изменено в версии 3.3: Пустой кортеж вместо None при ndim = 0.

strides

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

Изменено в версии 3.3: Пустой кортеж вместо None при ndim = 0.

suboffsets

Используется внутри массивов в стиле PIL. Это значение носит только информационный характер.

c_contiguous

Логический объект, указывающий, является ли память C смежный.

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

f_contiguous

Bool указывает, является ли память смежный Fortran.

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

contiguous

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

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

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

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

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

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

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

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

class set([iterable])
class frozenset([iterable])

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

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

Возвращает новый множество с элементами из множества и всеми остальными.

intersection(*others)
set & other & ...

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

difference(*others)
set - other - ...

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

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')]) тоже.

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

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

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

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

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

update(*others)
set |= other | ...

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

intersection_update(*others)
set &= other & ...

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

difference_update(*others)
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() может быть множество. Для поддержки поиска эквивалентного фрозенсета из elem создается временный.

Типы сопоставления — dict

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

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

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

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

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

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

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

Для иллюстрации все следующие примеры возвращает словарь, равный {"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. В противном случае можно используемый любые допустимые ключи.

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

list(d)

Возвращает список всех ключей, используемый в d словаря.

len(d)

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

d[key]

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

Если подкласс словарь определяет метод, __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.

d[key] = value

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

del d[key]

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

key in d

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

key not in d

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

iter(d)

Возвращает итератор над ключами словаря. Это ярлык для iter(d.keys()).

clear()

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

copy()

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

classmethod fromkeys(iterable[, value])

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

fromkeys() - метод класса, возвращает новый словарь. Дефолты value к None. Все значения относятся только к одному сущность, поэтому value, как правило, не имеет смысла быть изменяемым объектом, таким как пустой список. Чтобы получить различные значения, используйте dict comprehension.

get(key[, default])

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

items()

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

keys()

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

pop(key[, default])

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

popitem()

Удаляет и возвращает пару (key, value) из словаря. Пары возвращенный в LIFO порядке.

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

Изменено в версии 3.7: Заказ LIFO теперь гарантирован. В предыдущих версиях popitem() бы возвращает произвольную пару ключ/значение.

reversed(d)

Возвращает обратный итератор над ключами словаря. Это ярлык для reversed(d.keys()).

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

setdefault(key[, default])

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

update([other])

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

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

values()

Возвращает новое представление значения словаря. Смотрите на:ref:документация объектов просмотра <dict-views>.

Сравнение равенства между одним dict.values() взглядом и другим всегда будет возвращает False. Это также применимо при сравнении dict.values() с самим собой:

>>> d = {'a': 1}
>>> d.values() == d.values()
False

Словари сравниваются одинаково тогда и только тогда, когда они имеют одинаковые пары (key, value) (независимо от порядка следования). Сравнение порядка („<“, „< =“, „> =“, „>“) вызывает TypeError. Словари сохраняют порядок вставки. Обратите внимание, что обновление ключа не влияет на заказ. Ключи, добавленные после удаления, вставляются в конце:

>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> d
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> list(d)
['one', 'two', 'three', 'four']
>>> list(d.values())
[1, 2, 3, 4]
>>> d["one"] = 42
>>> d
{'one': 42, 'two': 2, 'three': 3, 'four': 4}
>>> del d["two"]
>>> d["two"] = None
>>> d
{'one': 42, 'three': 3, 'four': 4, 'two': None}

Изменено в версии 3.7: Порядок словаря гарантированно соответствует порядку вставки. Это поведение было детализацией реализации CPython из 3.6.

Словари и словарные представления являются обратимыми.:

>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> d
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> list(reversed(d))
['four', 'three', 'two', 'one']
>>> list(reversed(d.values()))
[4, 3, 2, 1]
>>> list(reversed(d.items()))
[('four', 4), ('three', 3), ('two', 2), ('one', 1)]

Изменено в версии 3.8: Словари теперь обратимы.

См.также

types.MappingProxyType создания представления dict только для чтения можно используемый.

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

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

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

len(dictview)

Возвращает количество статей в словаре.

iter(dictview)

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

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

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

Изменено в версии 3.7: Порядок словаря гарантированно соответствует порядку вставки.

x in dictview

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

reversed(dictview)

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

Изменено в версии 3.8: Теперь представления словаря являются обратимыми.

Представления ключей подобны множествам, поскольку их записи уникальны и доступны для хэширования. Если все значения являются хешируемыми, так что (key, value) пары уникальны и хешируемы, то представление элементов также является настроенным. (Ракурсы значений не рассматриваются как настроенные, поскольку записи, как правило, не являются уникальными.) для множественных представлений доступны все операции, определенные для абстрактного базового класса collections.abc.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', 'sausage', 'bacon', 'spam']
>>> list(values)
[2, 1, 1, 500]

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

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

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

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 инструкция.

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

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

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

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

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

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

Модули

Единственной специальной операцией на модуле является атрибут доступ: m.name, где m является модулем и name обращается к имени, определенному в таблице символов m. Модуль атрибуты может быть назначен. (Обратите внимание, что import инструкция не является, строго говоря, операцией над объектом модуля; import foo не требует существования объекта модуля с именем foo, а требует (внешнего) definition для модуля с именем 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'>.

Классы и сущности классов

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

Функции

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

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

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

Методы

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

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

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

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

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

Кодовые объекты

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

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

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

Объекты type

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

Типы написаны так: <class 'int'>.

Объект Null

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

Пишется как None.

Объект многоточия

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

Пишется как Ellipsis или ....

Объект NotImplemented

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

Пишется как NotImplemented.

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

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

Они пишутся как False и True соответственно.

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

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

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

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

object.__dict__

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

instance.__class__

Класс, которому принадлежит сущность класса.

class.__bases__

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

definition.__name__

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

definition.__qualname__

Квалифицированное имя класса, функции, метода, дескриптор или генератор сущность.

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

class.__mro__

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

class.mro()

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

class.__subclasses__()

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

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

Сноски

[1]Дополнительную информацию об этих специальных методах можно найти в справочном руководстве Python (Основная настройка).
[2]Как следствие, список [1, 2] считается равным [1.0, 2.0], и аналогично для кортежей.
[3]Они должны иметь, так как парсер не может сказать тип операндов.
[4](1, 2, 3, 4) Кодированные символы - это символы с общим свойством категории «Lu» (буква, верхний регистр), «Ll» (буква, нижний регистр) или «Lt» (буква, верхний регистр).
[5](1, 2) Чтобы отформатировать только кортеж, необходимо предоставить одноэлементный кортеж, единственным элементом которого является отформатируемый кортеж.