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

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

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

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

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

Записи:

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=1, byteorder='big', *, 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'

Целое число представляется с использованием длины байт и по умолчанию равно 1. Значение OverflowError задается, если целое число не может быть представлено заданным количеством байт.

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

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

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

>>> (65).to_bytes()
b'A'

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

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

def to_bytes(n, length=1, byteorder='big', signed=False):
    if byteorder == 'little':
        order = range(length)
    elif byteorder == 'big':
        order = reversed(range(length))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    return bytes((n >> i*8) & 0xff for i in order)

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

Изменено в версии 3.11: Добавлены значения аргументов по умолчанию для length и byteorder.

classmethod int.from_bytes(bytes, byteorder='big', *, 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 определяет порядок байтов, используемый для представления целого числа, и по умолчанию равен "big". Если значение byteorder равно "big", то старший байт находится в начале массива байтов. Если значение byteorder равно "little", то старший байт находится в конце массива байтов. Чтобы запросить исходный порядок байтов в хост-системе, используйте sys.byteorder в качестве значения порядка байтов.

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

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

def from_bytes(bytes, byteorder='big', signed=False):
    if byteorder == 'little':
        little_ordered = list(bytes)
    elif byteorder == 'big':
        little_ordered = list(reversed(bytes))
    else:
        raise ValueError("byteorder must be either 'little' or 'big'")

    n = sum(b << i*8 for i, b in enumerate(little_ordered))
    if signed and little_ordered and (little_ordered[-1] & 0x80):
        n -= 1 << 8*len(little_ordered)

    return n

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

Изменено в версии 3.11: Добавлено значение аргумента по умолчанию для byteorder.

int.as_integer_ratio()¶

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

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

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

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

float.as_integer_ratio()¶

Возвращает пару целых чисел, отношение которых в точности равно исходному значению с плавающей точкой и положительным знаменателем. Умножает 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)¶

Метод класса, возвращающий значение с плавающей точкой, представленное шестнадцатеричной строкой 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, а шестнадцатеричные строки, созданные с помощью символа формата C %a или Java Double.toHexString, принимаются float.fromhex().

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

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

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

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

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

Для чисел 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

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

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

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

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

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

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

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

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

   Более подробное объяснение доступно в разделе Часто задаваемых вопросов Как создать многомерный список?.

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

Записи:

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 может быть либо последовательностью, контейнером, поддерживающим итерацию, либо объектом iterator. Если 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=str.lower). Ключ, соответствующий каждому элементу в списке, вычисляется один раз и затем используется для всего процесса сортировки. Значение по умолчанию None означает, что элементы списка сортируются напрямую, без вычисления отдельного значения ключа.

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

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

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

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

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

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

Кортежи¶

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

class tuple([iterable])¶

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

• Используя пару круглых скобок для обозначения пустого кортежа: ()

• Использование завершающей запятой для одноэлементного кортежа: a, или (a,)

• Элементы, разделяемые запятыми: a, b, c или (a, b, c)

• Используя встроенный tuple(): tuple() или tuple(iterable)

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

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

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

Диапазоны¶

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

class range(stop)¶

class range(start, stop[, step])

Аргументы конструктора range должны быть целыми числами (либо встроенными 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.

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

Допустимы диапазоны, содержащие абсолютные значения, превышающие 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, за исключением конкатенации и повторения (из-за того, что объекты range могут представлять только последовательности, которые следуют строгому шаблону, а повторение и конкатенация обычно нарушают этот шаблон).

start¶

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

stop¶

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

step¶

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

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

Объекты Range реализуют 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

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

Если sub пуст, возвращает количество пустых строк между символами, которое равно длине строки плюс один.

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

Возвращает строку, закодированную как bytes.

кодировка по умолчанию имеет значение 'utf-8'; возможные значения приведены в разделе Стандартные кодировки.

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

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

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

Изменено в версии 3.9: Значение аргумента errors теперь проверяется в Режим разработки на Python и в debug mode.

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

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

str.expandtabs(tabsize=8)¶

Возвращает копию строки, в которой все символы табуляции заменены одним или несколькими пробелами, в зависимости от текущего столбца и заданного размера табуляции. Позиции табуляции указаны в каждом символе tabsize (по умолчанию 8, что соответствует позициям табуляции в столбцах 0, 8, 16 и так далее). Чтобы расширить строку, текущему столбцу присваивается нулевое значение, и строка проверяется посимвольно. Если это символ табуляции (\t), в результат вставляется один или несколько пробелов, пока текущий столбец не будет равен следующей позиции табуляции. (Сам символ табуляции не копируется.) Если символ представляет собой новую строку (\n) или return (\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 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 как «Буква», т.е. те, которые имеют свойство общей категории «Lm», «Lt», «Lu», «Ll» или «Lo». Обратите внимание, что это отличается от свойства «Алфавитный», определенного в стандарте Unicode.

str.isascii()¶

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

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

str.isdecimal()¶

Возвращает True, если все символы в строке являются десятичными и есть хотя бы один символ, False в противном случае. Десятичные символы - это те, которые могут использоваться для формирования чисел по основанию 10, например, U+0660, арабско-ИНДИЙСКАЯ ЦИФРА НОЛЬ. Формально десятичный символ - это символ общей категории Unicode «Nd».

str.isdigit()¶

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

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 в противном случае. К числовым символам относятся цифровые символы и все символы, которые имеют свойство числового значения в Юникоде, например, U+2155, ОБЫЧНАЯ ДРОБЬ В ОДНУ ПЯТУЮ. Формально числовыми символами являются символы со значением свойства Numeric_Type=Цифра, Numeric_Type=Десятичный или Numeric_Type=Числовой.

str.isprintable()¶

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

str.isspace()¶

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

Символом является пробел, если в базе данных символов 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. Значение TypeError будет выведено, если в iterable есть какие-либо нестроковые значения, включая объекты bytes. Разделителем между элементами является строка, предоставляющая этот метод.

str.ljust(width[, fillchar])¶

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

str.lower()¶

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

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

str.lstrip([chars])¶

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

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

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

str.partition(sep)¶

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

str.removeprefix(prefix, /)¶

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

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

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

str.removesuffix(suffix, /)¶

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

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

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

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

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

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

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

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

str.upper()¶

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

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

str.zfill(width)¶

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

Например:

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

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

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

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

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

1. Символ '%', который отмечает начало указанного.

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

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

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

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

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

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

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

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

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

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

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

Существуют следующие типы преобразований:

Записи:

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

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

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

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

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

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

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

6. Смотрите PEP 237.

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

Объекты в байтах¶

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

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

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

В дополнение к литеральным формам объекты bytes могут быть созданы рядом других способов:

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

• Из повторяющегося набора целых чисел: bytes(range(20))

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

Также смотрите встроенную функцию bytes.

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

classmethod fromhex(string)¶

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

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

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

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

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)

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

Объекты Bytearray¶

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

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

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

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

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

• Из повторяющегося набора целых чисел: bytearray(range(20))

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

Поскольку объекты bytearray являются изменяемыми, они поддерживают операции последовательности mutable в дополнение к обычным операциям с байтами и 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 используется литеральный формат bytes (bytearray(b'...')), поскольку он часто более полезен, чем, например, bytearray([46, 46, 46]). Вы всегда можете преобразовать объект bytearray в список целых чисел, используя list(b).

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

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

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

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

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

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

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

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

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

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

Если sub пуст, возвращает количество пустых фрагментов между символами, которое равно длине объекта bytes плюс один.

Изменено в версии 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')¶

Возвращает байты, декодированные как str.

кодировка по умолчанию имеет значение 'utf-8'; возможные значения приведены в разделе Стандартные кодировки.

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

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

Примечание

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

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

Изменено в версии 3.9: Значение аргумента errors теперь проверяется в Режим разработки на Python и в debug mode.

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

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

Возвращает True, если двоичные данные заканчиваются указанным суффиксом, в противном случае возвращает False. суффикс также может быть набором суффиксов для поиска. С необязательным 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. Значение TypeError будет выдано, если в iterable есть какие-либо значения, которые не являются 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 элементов, содержащий часть перед разделителем, сам разделитель или его копию в bytearray и часть после разделителя. Если разделитель не найден, верните кортеж из 3 элементов, содержащий копию исходной последовательности, за которой следуют два пустых байта или объекта bytearray.

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

Разделитель для поиска может быть любым 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])¶

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

Примечание

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

bytes.ljust(width[, fillbyte])¶

bytearray.ljust(width[, fillbyte])¶

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

Примечание

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

bytes.lstrip([chars])¶

bytearray.lstrip([chars])¶

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

Возвращает копию объекта, выровненную по правому краю в последовательности длины ширины. Заполнение выполняется с использованием указанного fillbyte (по умолчанию используется ASCII-пробел). Для объектов bytes возвращается исходная последовательность, если ширина меньше или равна 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, то по умолчанию в аргументе chars удаляются пробелы 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']