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

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

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

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

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

Примечания:

1. Отрицательные отсчеты сдвига недопустимы и приводят к появлению сообщения ValueError.

2. Сдвиг влево на n бит эквивалентен умножению на pow(2, n).

3. Сдвиг вправо на n бит эквивалентен полу делению на pow(2, n).

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

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

Тип int реализует numbers.Integral abstract base class. Кроме того, он предоставляет еще несколько методов:

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)       # binary representation:  bin(-37) --> '-0b100101'
    s = s.lstrip('-0b') # remove leading zeros and minus sign
    return len(s)       # len('100101') --> 6

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

int.bit_count()¶

Возвращает количество единиц в двоичном представлении абсолютного значения целого числа. Это значение также известно как количество населения. Пример:

>>> n = 19
>>> bin(n)
'0b10011'
>>> n.bit_count()
3
>>> (-n).bit_count()
3

Эквивалент:

def bit_count(self):
    return bin(self).count("1")

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

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 определяет, используется ли для представления целого числа дополнение двойки. Если 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 должен быть либо bytes-like object, либо итерацией, производящей байты.

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

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

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

int.as_integer_ratio()¶

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

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

Дополнительные методы на поплавке¶

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

float.as_integer_ratio()¶

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

float.is_integer()¶

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

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

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

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, а шестнадцатеричные строки, создаваемые символом формата %a в C или Double.toHexString в Java, принимаются 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 для числовых типов основан на одной математической функции, которая определена для любого рационального числа и, следовательно, применима ко всем экземплярам int и fractions.Fraction, а также ко всем конечным экземплярам float и decimal.Decimal. По сути, эта функция задается уменьшением по модулю P для фиксированного простого числа P. Значение P доступно в Python как атрибут modulus в sys.hash_info.

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

• Если 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 используются в качестве хэш-значений для положительной бесконечности или отрицательной бесконечности (соответственно).

• Для числа 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):
    """Compute the hash of a rational number m / n.

    Assumes m and n are integers, with n positive.
    Equivalent to hash(fractions.Fraction(m, n)).

    """
    P = sys.hash_info.modulus
    # Remove common factors of P.  (Unnecessary if m and n already coprime.)
    while m % P == n % P == 0:
        m, n = m // P, n // P

    if n % P == 0:
        hash_value = sys.hash_info.inf
    else:
        # Fermat's Little Theorem: pow(n, P-1, P) is 1, so
        # pow(n, P-2, P) gives the inverse of n modulo 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):
    """Compute the hash of a float x."""

    if math.isnan(x):
        return object.__hash__(x)
    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):
    """Compute the hash of a complex number z."""

    hash_value = hash_float(z.real) + sys.hash_info.imag * hash_float(z.imag)
    # do a signed reduction modulo 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

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

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

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

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

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

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

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

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

Примечания:

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

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

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

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

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

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

   • если конкатенировать объекты 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.

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

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

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

Примечания:

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]

• Использование понимания списка: [x for x in iterable]

• Использование конструктора типов: list() или list(iterable).

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

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

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

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

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

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

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

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

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

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

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

Примеры сортировки и краткое руководство по сортировке см. в разделе Сортировка КАК.

CPython implementation detail: Пока список сортируется, эффект от попыток изменить или даже просмотреть список не определен. Реализация Python на языке C делает список пустым на все время сортировки и выдает сообщение 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)) - это вызов функции с кортежем в качестве единственного аргумента.

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

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

Диапазоны¶

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

class range(stop)¶

class range(start, stop[, step])

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

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

Для отрицательного шага содержимое диапазона по-прежнему определяется формулой 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))
[]

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

start¶

Значение параметра start (или 0, если параметр не был предоставлен)

stop¶

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

step¶

Значение параметра step (или 1, если параметр не был предоставлен)

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

Объекты диапазона реализуют ABC collections.abc.Sequence и предоставляют такие возможности, как тесты на вложенность, поиск индекса элемента, нарезка и поддержка отрицательных индексов (см. Типы последовательностей — 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)).

Строковые методы¶

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

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

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

str.capitalize()¶

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

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

str.casefold()¶

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

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

Алгоритм сложения регистров описан в разделе 3.13 стандарта Unicode.

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

str.center(width[, fillchar])¶

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

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

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

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

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

По умолчанию аргумент errors не проверяется для лучшей производительности, а используется только при первой ошибке кодирования. Включите Python Development Mode или используйте debug build для проверки errors.

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

Изменено в версии 3.9: Теперь ошибки проверяются в режиме разработки и в debug mode.

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

Возвращает True, если строка заканчивается указанным суффиксом, в противном случае возвращает 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'

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

Примечание

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

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

str.format_map(mapping)¶

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

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

str.isascii()¶

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

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

str.isdecimal()¶

Возвращает True, если все символы в строке десятичные и есть хотя бы один символ, False в противном случае. Десятичные символы - это символы, которые могут использоваться для формирования чисел по основанию 10, например, U+0660, ARABIC-INDIC DIGIT ZERO. Формально десятичный символ - это символ общей категории Юникода «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 в противном случае. К числовым символам относятся символы цифр и все символы, имеющие свойство числового значения Unicode, например, U+2155, VULGAR FRACTION ONE FIFTH. Формально числовые символы - это символы со свойством Numeric_Type=Digit, Numeric_Type=Decimal или Numeric_Type=Numeric.

str.isprintable()¶

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

str.isspace()¶

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

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

str.istitle()¶

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

str.isupper()¶

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

>>> 'BANANA'.isupper()
True
>>> 'banana'.isupper()
False
>>> 'baNana'.isupper()
False
>>> ' '.isupper()
False

str.join(iterable)¶

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

str.ljust(width[, fillchar])¶

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

str.lower()¶

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

Используемый алгоритм строчных букв описан в разделе 3.13 стандарта Unicode.

str.lstrip([chars])¶

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

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

См. str.removeprefix() для метода, который удаляет одну строку префикса, а не весь набор символов. Например:

>>> 'Arthur: three!'.lstrip('Arthur: ')
'ee!'
>>> 'Arthur: three!'.removeprefix('Arthur: ')
'three!'

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

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

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

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

str.partition(sep)¶

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

str.removeprefix(prefix, /)¶

Если строка начинается со строки префикс, возвращается string[len(prefix):]. В противном случае возвращается копия исходной строки:

>>> 'TestHook'.removeprefix('Test')
'Hook'
>>> 'BaseTestCase'.removeprefix('Test')
'BaseTestCase'

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

str.removesuffix(suffix, /)¶

Если строка заканчивается строкой suffix и этот suffix не пуст, возвращается string[:-len(suffix)]. В противном случае возвращается копия исходной строки:

>>> 'MiscTests'.removesuffix('Tests')
'Misc'
>>> 'TmpDirMixin'.removesuffix('Tests')
'TmpDirMixin'

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

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

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

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

Возвращает наивысший индекс строки, в которой найдена подстрока sub, такая, что sub содержится в пределах s[start:end]. Необязательные аргументы start и end интерпретируются как в нотации slice. При неудаче возвращается -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 разбиений, причем самые правые. Если sep не задан или None, то в качестве разделителя используется любая пробельная строка. За исключением разбиения справа, rsplit() ведет себя как split(), что подробно описано ниже.

str.rstrip([chars])¶

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

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

См. str.removesuffix() для метода, который удаляет одну суффиксную строку, а не весь набор символов. Например:

>>> 'Monty Python'.rstrip(' Python')
'M'
>>> 'Monty Python'.removesuffix(' Python')
'Monty'

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=False)¶

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

Этот метод расщепляет по следующим границам строк. В частности, эти границы являются супермножеством universal newlines.

Представительство	Описание
\n	Подача линии
\r	Возврат каретки
\r\n	Возврат каретки + перевод строки
\v или \x0b	Табуляция строк
\f или \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, если строка начинается с префикса, иначе возвращает False. Префикс также может быть кортежем префиксов для поиска. С необязательным start, проверить строку, начинающуюся с этой позиции. С необязательным end - остановить сравнение строки на этой позиции.

str.strip([chars])¶

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

Функция string.capwords() не имеет этой проблемы, поскольку она разделяет слова только на пробелы.

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

>>> 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__(), обычно mapping или sequence. При индексации по порядковому номеру Unicode (целому числу) объект таблицы может выполнить одно из следующих действий: вернуть порядковый номер Unicode или строку, чтобы сопоставить символ с одним или несколькими другими символами; вернуть None, чтобы удалить символ из возвращаемой строки; или вызвать исключение LookupError, чтобы сопоставить символ с самим собой.

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

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

str.upper()¶

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

Используемый алгоритм прописных букв описан в разделе 3.13 стандарта Unicode.

str.zfill(width)¶

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

Например:

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

Форматирование строк в стиле printf¶

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

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

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

1. Символ '%', который отмечает начало спецификатора.

2. Ключ сопоставления (необязательный), состоящий из последовательности символов в скобках (например, (somename)).

3. Флаги преобразования (необязательные), которые влияют на результат некоторых типов преобразования.

4. Минимальная ширина поля (необязательно). Если указано '*' (звездочка), то фактическая ширина считывается из следующего элемента кортежа в values, а объект для преобразования идет после минимальной ширины поля и необязательной точности.

5. Точность (необязательно), задается в виде '.' (точка), за которой следует точность. Если указано '*' (звездочка), то фактическая точность считывается из следующего элемента кортежа в values, а значение для преобразования идет после точности.

6. Модификатор длины (необязательно).

7. Тип преобразования.

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

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

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

Символами флага конвертации являются:

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

Типы конвертации следующие:

Примечания:

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

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

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

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

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

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

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

6. См. PEP 237.

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

Байты Объекты¶

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

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

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

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

• Объект с нулевым заполнением байтов заданной длины: bytes(10)

• Из итерации целых чисел: bytes(range(20))

• Копирование существующих двоичных данных по буферному протоколу: bytes(obj)

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

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

classmethod fromhex(string)¶

Этот метод класса bytes возвращает объект 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 для вставки разделителей между байтами в шестнадцатеричный вывод.

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

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

Объекты байтовых массивов¶

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

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

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

• Создание пустого экземпляра: bytearray()

• Создание экземпляра с нулевым заполнением заданной длины: bytearray(10)

• Из итерации целых чисел: bytearray(range(20))

• Копирование существующих двоичных данных по буферному протоколу: bytearray(b'Hi!')

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

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

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

classmethod fromhex(string)¶

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

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

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

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

hex([sep[, bytes_per_sep]])¶

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

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

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

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

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

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

Операции с байтами и массивами байтов¶

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

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

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

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

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

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

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

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

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

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

bytes.removeprefix(prefix, /)¶

bytearray.removeprefix(prefix, /)¶

Если двоичные данные начинаются со строки prefix, верните bytes[len(prefix):]. В противном случае возвращается копия исходных двоичных данных:

>>> b'TestHook'.removeprefix(b'Test')
b'Hook'
>>> b'BaseTestCase'.removeprefix(b'Test')
b'BaseTestCase'

Префикс* может быть любым bytes-like object.

Примечание

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

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

bytes.removesuffix(suffix, /)¶

bytearray.removesuffix(suffix, /)¶

Если двоичные данные заканчиваются строкой suffix и этот suffix не пуст, возвращается bytes[:-len(suffix)]. В противном случае возвращается копия исходных двоичных данных:

>>> b'MiscTests'.removesuffix(b'Tests')
b'Misc'
>>> b'TmpDirMixin'.removesuffix(b'Tests')
b'TmpDirMixin'

Суффикс * может быть любым bytes-like object.

Примечание

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

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

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(), см. раздел Обработчики ошибок. Список возможных кодировок приведен в разделе Стандартные кодировки.

По умолчанию аргумент errors не проверяется для лучшей производительности, а используется только при первой ошибке декодирования. Включите Python Development Mode или используйте debug build для проверки errors.

Примечание

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

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

Изменено в версии 3.9: Теперь ошибки проверяются в режиме разработки и в debug mode.

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

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

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

Суффикс(ы) для поиска может быть любым bytes-like object.

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

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

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

Последовательность для поиска может быть любой bytes-like object или целым числом в диапазоне от 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, если подпоследовательность не найдена.

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

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

bytes.join(iterable)¶

bytearray.join(iterable)¶

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

static bytes.maketrans(from, to)¶

static bytearray.maketrans(from, to)¶

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

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

bytes.partition(sep)¶

bytearray.partition(sep)¶

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

Разделителем для поиска может быть любой bytes-like object.

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

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

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

Искомая подпоследовательность и ее замена могут быть любыми bytes-like object.

Примечание

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

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

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

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

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

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

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

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

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

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

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

bytes.rpartition(sep)¶

bytearray.rpartition(sep)¶

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

Разделителем для поиска может быть любой bytes-like object.

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

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

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

Префикс(ы) для поиска может быть любым bytes-like object.

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

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

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

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

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

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

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

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

bytes.center(width[, fillbyte])¶

bytearray.center(width[, fillbyte])¶

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

Примечание

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

bytes.ljust(width[, fillbyte])¶

bytearray.ljust(width[, fillbyte])¶

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

Примечание

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

bytes.lstrip([chars])¶

bytearray.lstrip([chars])¶

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

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

Двоичная последовательность значений байтов для удаления может быть любой bytes-like object. См. removeprefix() для метода, который удаляет одну префиксную строку, а не весь набор символов. Например:

>>> b'Arthur: three!'.lstrip(b'Arthur: ')
b'ee!'
>>> b'Arthur: three!'.removeprefix(b'Arthur: ')
b'three!'

Примечание

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

bytes.rjust(width[, fillbyte])¶

bytearray.rjust(width[, fillbyte])¶

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

Примечание

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

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

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

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

bytes.rstrip([chars])¶

bytearray.rstrip([chars])¶

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

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

Двоичная последовательность значений байтов для удаления может быть любой bytes-like object. См. removesuffix() для метода, который удаляет одну суффиксную строку, а не весь набор символов. Например:

>>> b'Monty Python'.rstrip(b' Python')
b'M'
>>> b'Monty Python'.removesuffix(b' Python')
b'Monty'

Примечание

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

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 может быть любым bytes-like object.

Например:

>>> 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. Если аргумент chars опущен или None, то по умолчанию удаляются пробельные символы ASCII. Аргумент chars не является префиксом или суффиксом; скорее, удаляются все комбинации его значений:

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

Двоичная последовательность значений байтов для удаления может быть любой bytes-like object.

Примечание

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

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

bytes.capitalize()¶

bytearray.capitalize()¶

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

Примечание

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

bytes.expandtabs(tabsize=8)¶

bytearray.expandtabs(tabsize=8)¶

Возвращает копию последовательности, в которой все символы табуляции ASCII заменены одним или несколькими пробелами ASCII, в зависимости от текущего столбца и заданного размера табуляции. Позиции табуляции встречаются через каждые tabsize байт (по умолчанию 8, что дает позиции табуляции в столбцах 0, 8, 16 и так далее). Чтобы расширить последовательность, текущий столбец устанавливается равным нулю, и последовательность просматривается побайтно. Если байт является символом табуляции ASCII (b'\t'), то в результат вставляется один или несколько символов пробела до тех пор, пока текущий столбец не будет равен следующей позиции табуляции. (Сам символ табуляции не копируется). Если текущий байт является новой строкой ASCII (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'

Примечание

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

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 в противном случае. Более подробно об определении «заглавной буквы» смотрите 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'.

Примечание

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

bytes.splitlines(keepends=False)¶

bytearray.splitlines(keepends=False)¶

Возвращает список строк в двоичной последовательности, разбивая их на границы ASCII строк. Этот метод использует подход universal newlines для разбиения строк. Разрывы строк не включаются в результирующий список, если только 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, хотя это не совсем верно для произвольных кодовых точек Unicode.

Примечание

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

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

Примечание

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