Вбудовані типи

У наступних розділах описуються стандартні типи, вбудовані в інтерпретатор.

Основними вбудованими типами є числа, послідовності, відображення, класи, екземпляри та винятки.

Деякі класи колекцій є змінними. Методи, які додають, віднімають або переставляють свої члени на місці, і не повертають конкретний елемент, ніколи не повертають сам екземпляр колекції, але Жодного.

Деякі операції підтримуються кількома типами об’єктів; зокрема, практично всі об’єкти можна порівняти на рівність, перевірити на значення істинності та перетворити на рядок (за допомогою функції repr() або трохи іншої функції str()). Остання функція неявно використовується, коли об’єкт записується функцією print().

Перевірка правдивості

Будь-який об’єкт можна перевірити на значення істинності, для використання в умовах if або while або як операнд логічних операцій, наведених нижче.

By default, an object is considered true unless its class defines either a __bool__() method that returns False or a __len__() method that returns zero, when called with the object. [1] Here are most of the built-in objects considered false:

• constants defined to be false: None and False

• нуль будь-якого числового типу: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)

• порожні послідовності та колекції: '', (), [], {}, set(), range(0)

Операції та вбудовані функції, які мають логічний результат, завжди повертають 0 або False для false і 1 або True для true, якщо не вказано інше. (Важливий виняток: логічні операції «або» та «і» завжди повертають один із своїх операндів.)

Логічні операції — and, or, not

Це логічні операції, упорядковані за зростанням пріоритету:

Операція	Результат	Примітки
x або y	if x is true, then x, else y	(1)
x і y	якщо x false, тоді x, інакше y	(2)
не x	якщо x false, тоді True, інакше False	(3)

Примітки:

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

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

3. not має нижчий пріоритет, ніж не-булеві оператори, тому not a == b інтерпретується як not (a == b), а a == not b є синтаксичною помилкою.

Порівняння

У Python є вісім операцій порівняння. Усі вони мають однаковий пріоритет (вищий, ніж у логічних операцій). Порівняння можна зв’язувати довільно; наприклад, x < y <= z еквівалентно x < y і y <= z, за винятком того, що y обчислюється лише один раз (але в обох випадках z не обчислюється в все, коли x < y виявляється хибним).

Ця таблиця підсумовує операції порівняння:

Операція	Значення
<	строго менше ніж
<=	менше або дорівнює
>	строго більше ніж
>=	більше або дорівнює
==	рівні
!=	не рівні
є	ідентичність об’єкта
не	заперечена ідентичність об’єкта

Об’єкти різних типів, за винятком різних числових типів, ніколи не порівнюються. Оператор == завжди визначений, але для деяких типів об’єктів (наприклад, об’єктів класу) еквівалентний is. Оператори <, <=, > і >= визначені лише там, де вони мають сенс; наприклад, вони викликають виняток TypeError, коли один із аргументів є комплексним числом.

Неідентичні екземпляри класу зазвичай порівнюються як нерівні, якщо клас не визначає метод __eq__().

Екземпляри класу не можуть бути впорядковані відносно інших екземплярів того самого класу або інших типів об’єктів, якщо клас не визначає достатньо методів __lt__(), __le__() , __gt__() і __ge__() (загалом, __lt__() і __eq__() достатньо, якщо ви хочете звичайні значення операторів порівняння).

Поведінку операторів is і is not не можна налаштувати; також вони можуть бути застосовані до будь-яких двох об’єктів і ніколи не викликають винятків.

Two more operations with the same syntactic priority, in and not in, are supported by types that are iterable or implement the __contains__() method.

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

There are three distinct numeric types: integers, floating point numbers, and complex numbers. In addition, Booleans are a subtype of integers. Integers have unlimited precision. Floating point numbers are usually implemented using double in C; information about the precision and internal representation of floating point numbers for the machine on which your program is running is available in sys.float_info. Complex numbers have a real and imaginary part, which are each a floating point number. To extract these parts from a complex number z, use z.real and z.imag. (The standard library includes the additional numeric types fractions.Fraction, for rationals, and decimal.Decimal, for floating-point numbers with user-definable precision.)

Numbers are created by numeric literals or as the result of built-in functions and operators. Unadorned integer literals (including hex, octal and binary numbers) yield integers. Numeric literals containing a decimal point or an exponent sign yield floating point numbers. Appending 'j' or 'J' to a numeric literal yields an imaginary number (a complex number with a zero real part) which you can add to an integer or float to get a complex number with real and imaginary parts.

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

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

Усі числові типи (крім комплексних) підтримують наступні операції (пріоритети операцій див. Пріоритет оператора):

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

Примітки:

1. Also referred to as integer division. For operands of type int, the result has type int. For operands of type float, the result has type float. In general, the result is a whole integer, though the result’s type is not necessarily int. The result is always rounded towards minus infinity: 1//2 is 0, (-1)//2 is -1, 1//(-2) is -1, and (-1)//(-2) is 0.

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

3. Conversion from float to int truncates, discarding the fractional part. See functions math.floor() and math.ceil() for alternative conversions.

4. float також приймає рядки «nan» і «inf» з необов’язковим префіксом «+» або «-» для Not a Number (NaN) і додатною або від’ємною нескінченністю.

5. Python визначає pow(0, 0) і 0 ** 0 як 1, як це прийнято для мов програмування.

6. Прийнятні числові літерали включають цифри від 0 до 9 або будь-який еквівалент Unicode (кодові точки з властивістю Nd).

   See https://www.unicode.org/Public/14.0.0/ucd/extracted/DerivedNumericType.txt for a complete list of code points with the Nd property.

Усі типи numbers.Real (int і float) також містять такі операції:

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

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

Побітові операції над цілими типами

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

Пріоритети двійкових порозрядних операцій нижчі, ніж числових операцій, і вищі, ніж порівняння; унарна операція ~ має той самий пріоритет, що й інші унарні числові операції (+ і -).

У цій таблиці наведено порозрядні операції, відсортовані за зростанням пріоритету:

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

Примітки:

1. Підрахунок від’ємного зсуву є незаконним і викликає ValueError.

2. Зсув вліво на n бітів еквівалентний множенню на pow(2, n).

3. Зсув праворуч на n бітів еквівалентний діленню підлоги за допомогою pow(2, n).

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

Додаткові методи для цілих типів

Тип int реалізує numbers.Integral 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'

The integer is represented using length bytes, and defaults to 1. An OverflowError is raised if the integer is not representable with the given number of bytes.

The byteorder argument determines the byte order used to represent the integer, and defaults to "big". If byteorder is "big", the most significant byte is at the beginning of the byte array. If byteorder is "little", the most significant byte is at the end of the byte array.

Аргумент signed визначає, чи використовується доповнення до двох для представлення цілого числа. Якщо signed має значення False і вказано від’ємне ціле число, виникає OverflowError. Значенням за замовчуванням для signed є False.

The default values can be used to conveniently turn an integer into a single byte object:

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

However, when using the default arguments, don’t try to convert a value greater than 255 or you’ll get an 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: Added default argument values for length and 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, або ітерованим, що створює байти.

The byteorder argument determines the byte order used to represent the integer, and defaults to "big". If byteorder is "big", the most significant byte is at the beginning of the byte array. If byteorder is "little", the most significant byte is at the end of the byte array. To request the native byte order of the host system, use sys.byteorder as the byte order value.

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

Дорівнює:

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: Added default argument value for byteorder.

int.as_integer_ratio()

Return a pair of integers whose ratio is exactly equal to the original integer and with a positive denominator. The integer ratio of integers (whole numbers) is always the integer as the numerator and 1 as the denominator.

Нове в версії 3.8.

Додаткові методи для Float

Тип float реалізує numbers.Real abstract base class. float також має такі додаткові методи.

float.as_integer_ratio()

Return a pair of integers whose ratio is exactly equal to the original float and with a positive denominator. Raises OverflowError on infinities and a ValueError on 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]

де необов’язковий знак може мати + або -, ціле число і дріб є рядками шістнадцяткових цифр, а експонента є десятковим цілим числом з необов’язковим переднім знаком. Регістр не є значущим, і в цілому чи дробі має бути принаймні одна шістнадцяткова цифра. Цей синтаксис подібний до синтаксису, зазначеного в розділі 6.4.4.2 стандарту C99, а також до синтаксису, який використовується в Java 1.5 і далі. Зокрема, вихід float.hex() можна використовувати як шістнадцятковий літерал із плаваючою комою в коді C або Java, а також шістнадцяткові рядки, створені символом формату C %a або 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'

Хешування числових типів

For numbers x and y, possibly of different types, it’s a requirement that hash(x) == hash(y) whenever x == y (see the __hash__() method documentation for more details). For ease of implementation and efficiency across a variety of numeric types (including int, float, decimal.Decimal and fractions.Fraction) Python’s hash for numeric types is based on a single mathematical function that’s defined for any rational number, and hence applies to all instances of int and fractions.Fraction, and all finite instances of float and decimal.Decimal. Essentially, this function is given by reduction modulo P for a fixed prime P. The value of P is made available to Python as the modulus attribute of sys.hash_info.

Деталі реалізації CPython: В даний час простим числом, яке використовується, є P = 2**31 - 1 на машинах з 32-розрядним C long і P = 2**61 - 1 на машинах з 64-бітним C long.

Ось правила в деталях:

• Якщо x = m / n є невід’ємним раціональним числом, а n не ділиться на P, визначте hash(x) як m * invmod(n, P ) % P``, де invmod(n, P) дає обернене n за модулем P.

• Якщо x = m / n є невід’ємним раціональним числом, а n ділиться на P (але m не ділиться на 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 так, щоб він знаходився в діапазоні (-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

Типи ітераторів

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

Потрібно визначити один метод для об’єктів-контейнерів, щоб забезпечити підтримку iterable:

container.__iter__()

Повертає об’єкт iterator. Об’єкт повинен підтримувати описаний нижче протокол ітератора. Якщо контейнер підтримує різні типи ітерацій, можна надати додаткові методи для спеціального запиту ітераторів для цих типів ітерацій. (Прикладом об’єкта, що підтримує кілька форм ітерації, може бути деревоподібна структура, яка підтримує обхід як у ширину, так і в глибину.) Цей метод відповідає слоту tp_iter структури типу для об’єктів Python в API Python/C.

Самі об’єкти ітератора повинні підтримувати наступні два методи, які разом утворюють iterator protocol:

iterator.__iter__()

Повертає сам об’єкт iterator. Це потрібно, щоб дозволити використовувати як контейнери, так і ітератори з операторами for і in. Цей метод відповідає слоту tp_iter структури типу для об’єктів Python в API Python/C.

iterator.__next__()

Повертає наступний елемент із iterator. Якщо більше елементів немає, підніміть виняток StopIteration. Цей метод відповідає слоту tp_iternext структури типу для об’єктів Python в API Python/C.

Python визначає декілька об’єктів-ітераторів для підтримки ітерації загальних і конкретних типів послідовностей, словників та інших більш спеціалізованих форм. Конкретні типи не важливі за межами їхньої реалізації протоколу ітератора.

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

Типи генераторів

Python’s generators provide a convenient way to implement the iterator protocol. If a container object’s __iter__() method is implemented as a generator, it will automatically return an iterator object (technically, a generator object) supplying the __iter__() and __next__() methods. More information about generators can be found in the documentation for the yield expression.

Типи послідовностей — list, tuple, range

Існує три основні типи послідовностей: списки, кортежі та об’єкти діапазону. Додаткові типи послідовностей, призначені для обробки бінарних даних і текстових рядків, описані у спеціальних розділах.

Загальні операції послідовності

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

У цій таблиці наведено послідовність операцій, відсортованих за зростанням пріоритету. У таблиці s і t — послідовності одного типу, n, i, j і k — цілі числа, а x — довільний об’єкт, який відповідає будь-яким обмеженням щодо типу та значення накладений s.

Операції in і not in мають ті самі пріоритети, що й операції порівняння. Операції + (конкатенація) і * (повторення) мають той самий пріоритет, що й відповідні числові операції. [3]

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

Послідовності одного типу також підтримують порівняння. Зокрема, кортежі та списки порівнюються лексикографічно шляхом порівняння відповідних елементів. Це означає, що для порівняння однаково кожен елемент повинен порівнюватись рівно, а дві послідовності мають бути одного типу та мати однакову довжину. (Для отримання повної інформації див. Порівняння у мовній довідці.)

Прямі та зворотні ітератори над змінними послідовностями отримують доступ до значень за допомогою індексу. Цей індекс буде продовжувати рух вперед (або назад), навіть якщо базова послідовність змінена. Ітератор завершується лише тоді, коли зустрічається 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 = [[] for i in range(3)]
   >>> lists[0].append(3)
   >>> lists[1].append(5)
   >>> lists[2].append(7)
   >>> lists
   [[3], [5], [7]]
   

   Подальші пояснення доступні в розділі поширених запитань Як створити багатовимірний список?.

3. Якщо i або j є від’ємними, індекс відноситься до кінця послідовності s: замінюється len(s) + i або len(s) + j. Але зауважте, що -0 все одно 0.

4. Зріз s від i до j визначається як послідовність елементів з індексом k, така що i <= k < j. Якщо i або j більше ніж len(s), використовуйте len(s). Якщо i пропущено або None, використовуйте 0. Якщо j пропущено або None, використовуйте len(s). Якщо i більше або дорівнює j, фрагмент порожній.

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

6. Конкатенація незмінних послідовностей завжди призводить до нового об’єкта. Це означає, що створення послідовності шляхом повторної конкатенації матиме квадратичну вартість виконання в загальній довжині послідовності. Щоб отримати лінійну вартість роботи, ви повинні перейти до однієї з наведених нижче альтернатив:

   • якщо конкатенувати об’єкти str, ви можете створити список і використовувати str.join() наприкінці або записати в екземпляр io.StringIO і отримати його значення після завершення

   • якщо конкатенація об’єктів bytes, ви можете так само використовувати bytes.join() або io.BytesIO, або ви можете виконати конкатенацію на місці з об’єктом bytearray. Об’єкти bytearray є змінними та мають ефективний механізм загального розподілу

   • якщо конкатенація об’єктів tuple, замість цього розширте list

   • для інших типів дослідіть відповідну документацію класу

7. Деякі типи послідовностей (наприклад, range) підтримують лише послідовності елементів, які відповідають певним шаблонам, і, отже, не підтримують конкатенацію або повторення послідовності.

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

Незмінні типи послідовностей

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

Ця підтримка дозволяє використовувати незмінні послідовності, такі як екземпляри tuple, як ключі dict і зберігати їх у екземплярах set і frozenset.

Спроба хешувати незмінну послідовність, яка містить нехешовані значення, призведе до TypeError.

Змінні типи послідовностей

Операції в наведеній нижче таблиці визначено для змінних типів послідовностей. collections.abc.MutableSequence ABC надається, щоб спростити правильну реалізацію цих операцій у настроюваних типах послідовностей.

У таблиці s є екземпляром змінного типу послідовності, t є будь-яким ітерованим об’єктом, а x є довільним об’єктом, який відповідає будь-яким обмеженням типу та значення, накладеним s (наприклад, bytearray приймає лише цілі числа, які відповідають обмеженню значення 0 <= x <= 255).

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

Примітки:

1. t must have the same length as the slice it is replacing.

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() приймає два аргументи, які можуть бути передані лише ключовим словом (аргументи лише для ключових слів):

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

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

reverse — це логічне значення. Якщо встановлено значення True, елементи списку сортуються так, ніби кожне порівняння було зворотним.

Цей метод змінює наявну послідовність для економії простору під час сортування великої послідовності. Щоб нагадати користувачам, що він працює за побічним ефектом, він не повертає відсортовану послідовність (використовуйте sorted(), щоб явно запитати новий екземпляр відсортованого списку).

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

Приклади сортування та короткий посібник із сортування див. Sorting HOW TO.

Деталі реалізації CPython: Поки список сортується, ефект від спроби змінити або навіть перевірити список не визначено. Реалізація 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))» — це виклик функції з 3-кортежем як єдиним аргумент.

Кортежі реалізують усі загальні операції послідовності.

Для різнорідних колекцій даних, де доступ за іменем є зрозумілішим, ніж доступ за індексом, collections.namedtuple() може бути більш відповідним вибором, ніж простий об’єкт кортежу.

діапазони

Тип range представляє незмінну послідовність чисел і зазвичай використовується для повторення певної кількості разів у циклах for.

class range(stop)

class range(start, stop[, step])

Аргументи конструктора діапазону мають бути цілими числами (або вбудованим int, або будь-яким об’єктом, який реалізує спеціальний метод __index__()). Якщо аргумент step опущено, за умовчанням він дорівнює 1. Якщо аргумент початок опущено, за умовчанням він дорівнює 0. Якщо крок дорівнює нулю, виникає 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))
[]

Діапазони реалізують усі загальні операції послідовності, окрім конкатенації та повторення (через те, що об’єкти діапазону можуть представляти лише послідовності, які дотримуються строгого шаблону, а повторення та конкатенація зазвичай порушують цей шаблон).

start

Значення параметра start (або 0, якщо параметр не було надано)

stop

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

step

Значення параметра step (або 1, якщо параметр не було надано)

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

Об’єкти діапазону реалізують collections.abc.Sequence ABC і надають такі функції, як тести на обмеження, пошук індексу елемента, нарізка та підтримка негативних індексів (див. Типи послідовностей — list, tuple, range):

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

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

Змінено в версії 3.2: Реалізуйте послідовність ABC. Підтримка нарізки та негативних індексів. Перевіряйте об’єкти int на приналежність у постійному часі замість повторення всіх елементів.

Змінено в версії 3.3: Визначте «==» і «!=», щоб порівнювати об’єкти діапазону на основі послідовності значень, які вони визначають (замість порівняння на основі ідентичності об’єкта).

Added the start, stop and step attributes.

Дивись також

• The linspace recipe shows how to implement a lazy version of range suitable for floating point applications.

Тип текстової послідовності — str

Текстові дані в Python обробляються за допомогою об’єктів str або strings. Рядки є незмінними послідовностями кодових точок Unicode. Рядкові літерали записуються різними способами:

• Одинарні лапки: 'дозволяє вбудовані "подвійні" лапки'

• Подвійні лапки: "дозволяє вбудовані 'одинарні' лапки"

• Потрійні лапки: ''Три одинарні лапки'''', """Три подвійні лапки"""

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

Рядкові літерали, які є частиною одного виразу і мають лише пробіли між собою, будуть неявно перетворені в один рядковий літерал. Тобто ("спам " "яйця") == "спам яйця".

See Рядкові та байтові літерали for more about the various forms of string literal, including supported escape sequences, and the r («raw») prefix that disables most escape sequence processing.

Рядки також можна створювати з інших об’єктів за допомогою конструктора str.

Оскільки окремого типу «символів» немає, індексування рядка створює рядки довжиною 1. Тобто для непорожнього рядка s s[0] == s[0:1].

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

Змінено в версії 3.3: Для зворотної сумісності з серією Python 2 префікс u знову дозволений у рядкових літералах. Він не впливає на значення рядкових літералів і не може поєднуватися з префіксом r.

class str(object='')

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

Повертає string версію об’єкта. Якщо object не надано, повертає порожній рядок. В іншому випадку поведінка str() залежить від того, чи вказано кодування чи помилки, як показано нижче.

If neither encoding nor errors is given, str(object) returns type(object).__str__(object), which is the «informal» or nicely printable string representation of object. For string objects, this is the string itself. If object does not have a __str__() method, then str() falls back to returning repr(object).

Якщо вказано принаймні одну з кодування або помилок, об’єкт має бути bytes-like object (наприклад, bytes або bytearray). У цьому випадку, якщо object є об’єктом bytes (або bytearray), тоді str(bytes, encoding, errors) еквівалентно bytes.decode (кодування, помилки). В іншому випадку об’єкт bytes, що лежить в основі об’єкта буфера, отримується перед викликом bytes.decode(). Перегляньте Типи бінарних послідовностей — bytes, bytearray, memoryview і Буферний протокол для отримання інформації про буферні об’єкти.

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

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

Додаткову інформацію про клас str і його методи див. у розділі Тип текстової послідовності — str і Рядкові методи нижче. Щоб вивести форматовані рядки, перегляньте розділи f-strings і Синтаксис рядка формату. Крім того, перегляньте розділ Послуги обробки тексту.

Рядкові методи

Рядки реалізують усі загальні операції послідовності разом із додатковими методами, описаними нижче.

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

Розділ Послуги обробки тексту стандартної бібліотеки охоплює низку інших модулів, які надають різноманітні утиліти, пов’язані з текстом (зокрема підтримку регулярних виразів у модулі re).

str.capitalize()

Повертає копію рядка з великим першим символом, а решта малими.

Змінено в версії 3.8: Перший символ тепер вводиться в заголовок, а не у верхній регістр. Це означає, що такі символи, як диграфи, матимуть велику першу літеру, а не повний символ.

str.casefold()

Повертає згорнуту копію рядка. Для зіставлення без регістру можна використовувати рядки з регістром.

Згортання регістру подібне до нижнього регістру, але більш агресивне, оскільки воно призначене для видалення всіх відмінностей регістру в рядку. Наприклад, німецька мала літера 'ß' еквівалентна "ss". Оскільки це вже малий регістр, lower() нічого не зробить для 'ß'; casefold() перетворює його на "ss".

The casefolding algorithm is described in section 3.13 of the Unicode Standard.

Нове в версії 3.3.

str.center(width[, fillchar])

Повернення з центром у рядку довжиною width. Заповнення виконується за допомогою вказаного fillchar (за замовчуванням це пробіл ASCII). Оригінальний рядок повертається, якщо width менше або дорівнює len(s).

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

Повертає кількість неперекриваючих входжень підрядка sub у діапазоні [початок, кінець]. Необов’язкові аргументи початок і кінець інтерпретуються як у нотації фрагментів.

If sub is empty, returns the number of empty strings between characters which is the length of the string plus one.

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

Return the string encoded to bytes.

encoding defaults to 'utf-8'; see Стандартні кодування for possible values.

errors controls how encoding errors are handled. If 'strict' (the default), a UnicodeError exception is raised. Other possible values are 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' and any other name registered via codecs.register_error(). See Обробники помилок for details.

For performance reasons, the value of errors is not checked for validity unless an encoding error actually occurs, Режим розробки Python is enabled or a debug build is used.

Змінено в версії 3.1: Додано підтримку аргументів ключових слів.

Змінено в версії 3.9: The value of the errors argument is now checked in Режим розробки Python and in debug mode.

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

Повертає True, якщо рядок закінчується вказаним суфіксом, інакше повертає False. suffix також може бути кортежем суфіксів для пошуку. З необов’язковим початком тестування починається з цієї позиції. З необов’язковим 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]. Необов’язкові аргументи початок і кінець інтерпретуються як у нотації фрагментів. Повертає -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()

Return True if all characters in the string are alphabetic and there is at least one character, False otherwise. Alphabetic characters are those characters defined in the Unicode character database as «Letter», i.e., those with general category property being one of «Lm», «Lt», «Lu», «Ll», or «Lo». Note that this is different from the «Alphabetic» property defined in the Unicode Standard.

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=Digit або Numeric_Type=Decimal.

str.isidentifier()

Повертає True, якщо рядок є дійсним ідентифікатором відповідно до визначення мови, розділ Ідентифікатори та ключові слова.

Call keyword.iskeyword() to test whether string s is a reserved identifier, such as def and 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, ВУЛЬГАРНА ФРАКЦІЯ ОДНА П’ЯТА. Формально цифровими символами є символи зі значенням властивості Numeric_Type=Digit, Numeric_Type=Decimal або Numeric_Type=Numeric.

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

Повертає рядок, вирівняний за лівим краєм, у рядку довжини width. Заповнення виконується за допомогою вказаного fillchar (за замовчуванням це пробіл ASCII). Оригінальний рядок повертається, якщо width менше або дорівнює len(s).

str.lower()

Повертає копію рядка з усіма регістровими символами [4], перетвореними на нижній регістр.

The lowercasing algorithm used is described in section 3.13 of the Unicode Standard.

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

Якщо є лише один аргумент, це має бути словник, який відображає порядкові номери Unicode (цілі числа) або символи (рядки довжиною 1) на порядкові номери Unicode, рядки (довільної довжини) або None. Потім символьні ключі будуть перетворені на порядкові.

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

str.partition(sep)

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

str.removeprefix(prefix, /)

Якщо рядок починається з рядка 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])

Return a copy of the string with all occurrences of substring old replaced by new. If the optional argument count is given, only the first count occurrences are replaced.

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

Повертає найвищий індекс у рядку, де знайдено підрядок sub, так що sub міститься в s[start:end]. Необов’язкові аргументи початок і кінець інтерпретуються як у нотації фрагментів. Повернути -1 у разі помилки.

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

Подібно до rfind(), але викликає ValueError, коли підрядок sub не знайдено.

str.rjust(width[, fillchar])

Повертає рядок, вирівняний по правому краю, у рядку довжини width. Заповнення виконується за допомогою вказаного fillchar (за замовчуванням це пробіл ASCII). Оригінальний рядок повертається, якщо width менше або дорівнює len(s).

str.rpartition(sep)

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

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

Повертає список слів у рядку, використовуючи sep як роздільник. Якщо задано maxsplit, виконується щонайбільше maxsplit розбиття, найправіші. Якщо 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, тоді немає обмеження на кількість розділень (виконуються всі можливі розділення).

If sep is given, consecutive delimiters are not grouped together and are deemed to delimit empty strings (for example, '1,,2'.split(',') returns ['1', '', '2']). The sep argument may consist of multiple characters (for example, '1<>2<>3'.split('<>') returns ['1', '2', '3']). Splitting an empty string with a specified separator returns [''].

Наприклад:

>>> '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 не задано і не відповідає дійсності.

Цей метод розбивається на наступні межі рядків. Зокрема, межі є надмножиною 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. префікс також може бути кортежем префіксів для пошуку. З необов’язковим початком, тестовий рядок починається з цієї позиції. З необов’язковим 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)

Return a copy of the string in which each character has been mapped through the given translation table. The table must be an object that implements indexing via __getitem__(), typically a mapping or sequence. When indexed by a Unicode ordinal (an integer), the table object can do any of the following: return a Unicode ordinal or a string, to map the character to one or more other characters; return None, to delete the character from the return string; or raise a LookupError exception, to map the character to itself.

Ви можете використовувати str.maketrans(), щоб створити карту перекладу з відображень символів у різні формати.

Перегляньте також модуль codecs для більш гнучкого підходу до нестандартних відображень символів.

str.upper()

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

The uppercasing algorithm used is described in section 3.13 of the Unicode Standard.

str.zfill(width)

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

Наприклад:

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

Форматування рядків у стилі printf

Примітка

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

String objects have one unique built-in operation: the % operator (modulo). This is also known as the string formatting or interpolation operator. Given format % values (where format is a string), % conversion specifications in format are replaced with zero or more elements of values. The effect is similar to using the sprintf() in the C language.

Якщо для format потрібен один аргумент, values може бути одним некортежним об’єктом. [5] В іншому випадку values має бути кортежем із точною кількістю елементів, визначених рядком формату, або одним об’єктом відображення (наприклад, словником).

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

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

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

3. Прапорці перетворення (опціонально), які впливають на результат деяких типів перетворення.

4. Мінімальна ширина поля (опціонально). Якщо вказано як '*' (зірочка), фактична ширина зчитується з наступного елемента кортежу в значеннях, а об’єкт для перетворення йде після мінімальної ширини поля та необов’язкової точності.

5. Точність (необов’язкова), подається як '.' (крапка), за якою йде точність. Якщо вказано як '*' (зірочка), фактична точність зчитується з наступного елемента кортежу в значеннях, а значення для перетворення йде після точності.

6. Модифікатор довжини (необов’язково).

7. Тип перетворення.

Якщо правильний аргумент є словником (або іншим типом відображення), то формати в рядку мають містити ключ відображення в дужках у цьому словнику, вставлений одразу після символу '%'. Ключ відображення вибирає значення, яке потрібно відформатувати, із відображення. Наприклад:

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

У цьому випадку у форматі не може бути специфікаторів * (оскільки вони вимагають послідовного списку параметрів).

Символи прапора перетворення:

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

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

Типи перетворення:

Перетворення	Значення	Примітки
'd''	Ціле десяткове число зі знаком.
'я''	Ціле десяткове число зі знаком.
'o'	Вісімкове значення зі знаком.	(1)
'u''	Застарілий тип – він ідентичний 'd'.	(6)
'x''	Шістнадцяткове число зі знаком (нижній регістр).	(2)
'X''	Шістнадцяткове число зі знаком (верхній регістр).	(2)
'e''	Floating point exponential format (lowercase).	(3)
'E'	Floating point exponential format (uppercase).	(3)
'f''	Floating point decimal format.	(3)
'F''	Floating point decimal format.	(3)
'g''	Floating point format. Uses lowercase exponential format if exponent is less than -4 or not less than precision, decimal format otherwise.	(4)
'G''	Floating point format. Uses uppercase exponential format if exponent is less than -4 or not less than precision, decimal format otherwise.	(4)
'c''	Один символ (приймає рядок цілих чи односимвольних символів).
'r''	Рядок (перетворює будь-який об’єкт Python за допомогою repr()).	(5)
's''	Рядок (перетворює будь-який об’єкт Python за допомогою str()).	(5)
'a'	Рядок (перетворює будь-який об’єкт Python за допомогою ascii()).	(5)
'%'	Жоден аргумент не перетворюється, результатом є символ '%' в результаті.

Примітки:

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

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

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

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

4. Альтернативна форма призводить до того, що результат завжди містить десяткову кому, а кінцеві нулі не видаляються, як це було б інакше.

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

5. Якщо точність N, вивід скорочується до N символів.

6. Дивіться PEP 237.

Оскільки рядки Python мають явну довжину, перетворення %s не припускають, що '\0 є кінцем рядка.

Змінено в версії 3.1: Перетворення %f для чисел, абсолютне значення яких перевищує 1e50, більше не замінюються перетвореннями %g.

Типи бінарних послідовностей — bytes, bytearray, memoryview

Основними вбудованими типами для обробки двійкових даних є bytes і bytearray. Вони підтримуються memoryview, який використовує протокол буфера для доступу до пам’яті інших бінарних об’єктів без необхідності створення копії.

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

Об’єкти Bytes

Об’єкти Bytes — це незмінні послідовності окремих байтів. Оскільки багато основних двійкових протоколів базуються на текстовому кодуванні ASCII, об’єкти bytes пропонують кілька методів, які дійсні лише під час роботи з даними, сумісними з ASCII, і тісно пов’язані з рядковими об’єктами різними способами.

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

По-перше, синтаксис байтових літералів здебільшого такий самий, як і для рядкових літералів, за винятком того, що додано префікс b:

• Одинарні лапки: b'все ще дозволяє вбудовані "подвійні" лапки

• Подвійні лапки: b"все ще дозволяє вбудовані 'одинарні' лапки

• Потрійні лапки: b''''3 одинарні лапки'''', b"""3 подвійні лапки"""

У байтових літералах дозволені лише символи ASCII (незалежно від оголошеного кодування вихідного коду). Будь-які двійкові значення понад 127 потрібно вводити в байтові літерали за допомогою відповідної керуючої послідовності.

Як і рядкові літерали, літерали bytes також можуть використовувати префікс r, щоб вимкнути обробку керуючих послідовностей. Перегляньте Рядкові та байтові літерали, щоб дізнатися більше про різні форми літералів байтів, включаючи підтримувані керуючі послідовності.

У той час як байтові літерали та представлення базуються на тексті ASCII, об’єкти байтів фактично поводяться як незмінні послідовності цілих чисел, де кожне значення в послідовності обмежено таким чином, що 0 <= x < 256 (спроби порушити це обмеження викличуть ValueError). Це зроблено навмисно, щоб підкреслити, що хоча багато двійкових форматів включають елементи на основі ASCII і ними можна корисно маніпулювати за допомогою деяких текстово-орієнтованих алгоритмів, це зазвичай не стосується довільних двійкових даних (сліпе застосування алгоритмів обробки тексту до двійкових форматів даних, які не Сумісність із ASCII зазвичай призводить до пошкодження даних).

Окрім літеральних форм, об’єкти bytes можна створювати кількома іншими способами:

• Об’єкт із заповненими нулем байтами вказаної довжини: 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'

If you want to make the hex string easier to read, you can specify a single character separator sep parameter to include in the output. By default, this separator will be included between each byte. A second optional bytes_per_sep parameter controls the spacing. Positive values calculate the separator position from the right, negative values from the left.

>>> 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]» буде байтом об’єкт довжини 1. (Це контрастує з текстовими рядками, де як індексування, так і нарізка створять рядок довжиною 1)

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

Об’єкти байтового масиву

Об’єкти bytearray є змінними аналогами об’єктів bytes.

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

Для об’єктів bytearray немає виділеного синтаксису літералів, натомість вони завжди створюються шляхом виклику конструктора:

• Створення порожнього екземпляра: bytearray()

• Створення екземпляра із заповненням нуля із заданою довжиною: bytearray(10)

• З ітерації цілих чисел: bytearray(range(20))

• Копіювання наявних двійкових даних за допомогою буферного протоколу: bytearray(b'Hi!')

Оскільки об’єкти bytearray є змінними, вони підтримують операції послідовності mutable на додаток до звичайних операцій з байтами та байтовими масивами, описаних у Операції з байтами та масивом байтів.

Також перегляньте вбудований bytearray.

Оскільки 2 шістнадцяткові цифри точно відповідають одному байту, шістнадцяткові числа є широко використовуваним форматом для опису двійкових даних. Відповідно, тип bytearray має додатковий метод класу для читання даних у цьому форматі:

classmethod fromhex(string)

Цей метод класу bytearray повертає об’єкт 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 для вставки роздільників між байтами в шістнадцятковому виведенні.

Оскільки об’єкти bytearray — це послідовності цілих чисел (схожі на список), для об’єкта bytearray b «b[0]» буде цілим числом, а «b[0:1]» буде масивом bytearray об’єкт довжини 1. (Це контрастує з текстовими рядками, де як індексування, так і нарізка створять рядок довжиною 1)

У представленні об’єктів bytearray використовується формат літералу bytes (bytearray(b'...')), оскільки він часто корисніший, ніж, наприклад, bytearray([46, 46, 46]). Ви завжди можете перетворити об’єкт bytearray на список цілих чисел за допомогою list(b).

Операції з байтами та масивом байтів

Як об’єкти bytes, так і bytearray підтримують операції послідовності common. Вони взаємодіють не тільки з операндами того самого типу, але й з будь-яким bytes-like object. Завдяки цій гнучкості їх можна вільно змішувати під час операцій, не викликаючи помилок. Однак тип результату може залежати від порядку операндів.

Примітка

Методи для об’єктів bytes і bytearray не приймають рядки як аргументи, так само як методи для рядків не приймають байти як аргументи. Наприклад, ви повинні написати:

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

і:

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

Деякі операції з байтами та масивами байтів передбачають використання двійкових форматів, сумісних із ASCII, і тому їх слід уникати під час роботи з довільними двійковими даними. Ці обмеження описані нижче.

Примітка

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

Наступні методи для об’єктів bytes і bytearray можна використовувати з довільними двійковими даними.

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

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

Повертає кількість неперекриваючих входжень підпослідовності sub у діапазоні [початок, кінець]. Необов’язкові аргументи початок і кінець інтерпретуються як у нотації фрагментів.

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

If sub is empty, returns the number of empty slices between characters which is the length of the bytes object plus one.

Змінено в версії 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.

Примітка

Версія bytearray цього методу не працює на місці – вона завжди створює новий об’єкт, навіть якщо не було зроблено жодних змін.

Нове в версії 3.9.

bytes.removesuffix(suffix, /)

bytearray.removesuffix(suffix, /)

Якщо двійкові дані закінчуються рядком суфікса і цей суфікс не порожній, поверніть bytes[:-len(suffix)]. В іншому випадку поверніть копію вихідних двійкових даних:

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

Суфіксом може бути будь-який bytes-like object.

Примітка

Версія bytearray цього методу не працює на місці – вона завжди створює новий об’єкт, навіть якщо не було зроблено жодних змін.

Нове в версії 3.9.

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

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

Return the bytes decoded to a str.

encoding defaults to 'utf-8'; see Стандартні кодування for possible values.

errors controls how decoding errors are handled. If 'strict' (the default), a UnicodeError exception is raised. Other possible values are 'ignore', 'replace', and any other name registered via codecs.register_error(). See Обробники помилок for details.

For performance reasons, the value of errors is not checked for validity unless a decoding error actually occurs, Режим розробки Python is enabled or a debug build is used.

Примітка

Passing the encoding argument to str allows decoding any bytes-like object directly, without needing to make a temporary bytes or bytearray object.

Змінено в версії 3.1: Додано підтримку аргументів ключових слів.

Змінено в версії 3.9: The value of the errors argument is now checked in Режим розробки Python and in debug mode.

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

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

Повертає True, якщо двійкові дані закінчуються вказаним суфіксом, інакше повертає False. suffix також може бути кортежем суфіксів для пошуку. З необов’язковим початком тестування починається з цієї позиції. З необов’язковим end, припинити порівняння на цій позиції.

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

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

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

Повертає найнижчий індекс у даних, де знайдено підпослідовність sub, так що sub міститься в сегменті s[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-подібними об’єктами, включаючи об’єкти str. Роздільником між елементами є вміст об’єкта bytes або bytearray, що забезпечує цей метод.

static bytes.maketrans(from, to)

static bytearray.maketrans(from, to)

Цей статичний метод повертає таблицю перекладу, придатну для bytes.translate(), яка відобразить кожен символ у from на символ у тій же позиції в to; from і to мають бути байтоподібними об’єктами і мати однакову довжину.

Нове в версії 3.1.

bytes.partition(sep)

bytearray.partition(sep)

Розділіть послідовність при першому входженні sep і поверніть 3-кортеж, що містить частину перед роздільником, сам роздільник або його копію байтового масиву та частину після роздільника. Якщо роздільник не знайдено, поверніть 3-кортеж, що містить копію вихідної послідовності, за якою слідують два порожні байти або об’єкти bytearray.

Роздільником для пошуку може бути будь-який bytes-like object.

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

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

Повертає копію послідовності з заміною всіх входжень підпослідовності old на new. Якщо вказано необов’язковий аргумент count, заміняються лише перші випадки count.

Підпослідовністю для пошуку та її заміною може бути будь-який bytes-like object.

Примітка

Версія bytearray цього методу не працює на місці – вона завжди створює новий об’єкт, навіть якщо не було зроблено жодних змін.

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

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

Повертає найвищий індекс у послідовності, де знайдено підпослідовність sub, так що sub міститься в s[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-кортеж, що містить частину перед роздільником, сам роздільник або його копію байтового масиву та частину після роздільника. Якщо роздільник не знайдено, поверніть 3-кортеж, що містить два порожні об’єкти байтів або масиву байтів, а потім копію вихідної послідовності.

Роздільником для пошуку може бути будь-який bytes-like object.

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

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

Повертає True, якщо двійкові дані починаються з указаного префікса, інакше повертає False. префікс також може бути кортежем префіксів для пошуку. З необов’язковим початком тестування починається з цієї позиції. З необов’язковим 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-сумісних двійкових форматів, але все одно їх можна використовувати з довільними двійковими даними шляхом передачі відповідних аргументів. Зауважте, що всі методи bytearray у цьому розділі не працюють на місці, а створюють нові об’єкти.

bytes.center(width[, fillbyte])

bytearray.center(width[, fillbyte])

Повертає копію об’єкта з центром у послідовності довжиною шириною. Доповнення виконується за допомогою вказаного fillbyte (за замовчуванням це пробіл ASCII). Для об’єктів bytes оригінальна послідовність повертається, якщо width менше або дорівнює len(s).

Примітка

Версія bytearray цього методу не працює на місці – вона завжди створює новий об’єкт, навіть якщо не було зроблено жодних змін.

bytes.ljust(width[, fillbyte])

bytearray.ljust(width[, fillbyte])

Повертає копію об’єкта, вирівняну за лівим краєм у послідовності довжини ширина. Доповнення виконується за допомогою вказаного fillbyte (за замовчуванням це пробіл ASCII). Для об’єктів bytes вихідна послідовність повертається, якщо width менше або дорівнює len(s).

Примітка

Версія bytearray цього методу не працює на місці – вона завжди створює новий об’єкт, навіть якщо не було зроблено жодних змін.

bytes.lstrip([chars])

bytearray.lstrip([chars])

Повертає копію послідовності з видаленими вказаними початковими байтами. Аргумент chars є двійковою послідовністю, яка визначає набір значень байтів, які потрібно видалити. Назва вказує на те, що цей метод зазвичай використовується з символами ASCII. Якщо пропущено або None, аргумент chars за умовчанням видаляє пробіли ASCII. Аргумент chars не є префіксом; навпаки, усі комбінації його значень видаляються:

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

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

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

Примітка

Версія bytearray цього методу не працює на місці – вона завжди створює новий об’єкт, навіть якщо не було зроблено жодних змін.

bytes.rjust(width[, fillbyte])

bytearray.rjust(width[, fillbyte])

Повертає копію об’єкта, вирівняну по правому краю в послідовності довжина ширина. Доповнення виконується за допомогою вказаного fillbyte (за замовчуванням це пробіл ASCII). Для об’єктів bytes оригінальна послідовність повертається, якщо width менше або дорівнює len(s).

Примітка

Версія bytearray цього методу не працює на місці – вона завжди створює новий об’єкт, навіть якщо не було зроблено жодних змін.

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. Якщо пропущено або 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'

Примітка

Версія bytearray цього методу не працює на місці – вона завжди створює новий об’єкт, навіть якщо не було зроблено жодних змін.

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

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

Розділіть бінарну послідовність на підпослідовності одного типу, використовуючи sep як рядок-роздільник. Якщо задано maxsplit і воно є невід’ємним, виконується щонайбільше розділень maxsplit (отже, список матиме щонайбільше елементів maxsplit+1). Якщо maxsplit не вказано або дорівнює -1, тоді немає обмежень на кількість розбивок (виконуються всі можливі розбиття).

If sep is given, consecutive delimiters are not grouped together and are deemed to delimit empty subsequences (for example, b'1,,2'.split(b',') returns [b'1', b'', b'2']). The sep argument may consist of a multibyte sequence (for example, b'1<>2<>3'.split(b'<>') returns [b'1', b'2', b'3']). Splitting an empty sequence with a specified separator returns [b''] or [bytearray(b'')] depending on the type of object being split. The sep argument may be any 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. Якщо пропущено або None, аргумент chars за замовчуванням видаляє пробіли ASCII. Аргумент chars не є префіксом або суфіксом; навпаки, усі комбінації його значень видаляються:

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

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

Примітка

Версія bytearray цього методу не працює на місці – вона завжди створює новий об’єкт, навіть якщо не було зроблено жодних змін.

Наступні методи для об’єктів bytes і bytearray передбачають використання двійкових форматів, сумісних із ASCII, і їх не слід застосовувати до довільних двійкових даних. Зауважте, що всі методи bytearray у цьому розділі не працюють на місці, а створюють нові об’єкти.

bytes.capitalize()

bytearray.capitalize()

Повертає копію послідовності з кожним байтом, інтерпретованим як символ ASCII, і перший байт у великому регістрі, а решта – у нижньому. Байтові значення, відмінні від ASCII, передаються без змін.

Примітка

Версія bytearray цього методу не працює на місці – вона завжди створює новий об’єкт, навіть якщо не було зроблено жодних змін.

bytes.expandtabs(tabsize=8)

bytearray.expandtabs(tabsize=8)

Повертає копію послідовності, де всі символи табуляції ASCII замінено одним або декількома пробілами ASCII, залежно від поточного стовпця та заданого розміру табуляції. Позиції табуляції відбуваються кожні байти табуляції (за замовчуванням — 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'

Примітка

Версія bytearray цього методу не працює на місці – вона завжди створює новий об’єкт, навіть якщо не було зроблено жодних змін.

bytes.isalnum()

bytearray.isalnum()

Повертає True, якщо всі байти в послідовності є алфавітними символами ASCII або десятковими цифрами ASCII і послідовність не є порожньою, False інакше. Алфавітні символи ASCII – це значення байтів у послідовності b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ. Десяткові цифри ASCII – це значення байтів у послідовності b'0123456789.

Наприклад:

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

bytes.isalpha()

bytearray.isalpha()

Повертає True, якщо всі байти в послідовності є алфавітними символами ASCII і послідовність не є пустою, False інакше. Алфавітні символи ASCII – це значення байтів у послідовності b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.

Наприклад:

>>> b'ABCabc'.isalpha()
True
>>> b'ABCabc1'.isalpha()
False

bytes.isascii()

bytearray.isascii()

Повертає True, якщо послідовність порожня або всі байти в послідовності ASCII, False інакше. Байти ASCII знаходяться в діапазоні 0-0x7F.

Нове в версії 3.7.

bytes.isdigit()

bytearray.isdigit()

Повертає True, якщо всі байти в послідовності є десятковими цифрами ASCII і послідовність не порожня, False інакше. Десяткові цифри ASCII – це значення байтів у послідовності b'0123456789.

Наприклад:

>>> b'1234'.isdigit()
True
>>> b'1.23'.isdigit()
False

bytes.islower()

bytearray.islower()

Повертає True, якщо в послідовності є принаймні один символ нижнього регістру ASCII і немає символів ASCII у верхньому регістрі, інакше False.

Наприклад:

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

Символи ASCII у нижньому регістрі – це значення байтів у послідовності b'abcdefghijklmnopqrstuvwxyz. Символи ASCII у верхньому регістрі – це значення байтів у послідовності b'ABCDEFGHIJKLMNOPQRSTUVWXYZ.

bytes.isspace()

bytearray.isspace()

Повертає True, якщо всі байти в послідовності є пробілами ASCII і послідовність не порожня, False інакше. Пробільні символи ASCII – це значення байтів у послідовності b' \t\n\r\x0b\f'' (пробіл, табуляція, новий рядок, повернення каретки, вертикальна табуляція, передача форми).

bytes.istitle()

bytearray.istitle()

Повертає True, якщо послідовність має регістр заголовків ASCII і послідовність не є порожньою, 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.

Примітка

Версія bytearray цього методу не працює на місці – вона завжди створює новий об’єкт, навіть якщо не було зроблено жодних змін.

bytes.splitlines(keepends=False)

bytearray.splitlines(keepends=False)

Повертає список рядків у двійковій послідовності, розриваючи межі рядків ASCII. Цей метод використовує підхід universal newlines до розділення рядків. Розриви рядків не включаються до результуючого списку, якщо не задано keepends і воно є істинним.

Наприклад:

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

Unlike str.swapcase(), it is always the case that bin.swapcase().swapcase() == bin for the binary versions. Case conversions are symmetrical in ASCII, even though that is not generally true for arbitrary Unicode code points.

Примітка

Версія bytearray цього методу не працює на місці – вона завжди створює новий об’єкт, навіть якщо не було зроблено жодних змін.

bytes.title()

bytearray.title()

Повертає версію двійкової послідовності в заголовку, де слова починаються з символу ASCII у верхньому регістрі, а решта символів – у нижньому регістрі. Значення байтів без регістру залишаються незмінними.

Наприклад:

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

Символи ASCII у нижньому регістрі – це значення байтів у послідовності b'abcdefghijklmnopqrstuvwxyz. Символи ASCII у верхньому регістрі – це значення байтів у послідовності b'ABCDEFGHIJKLMNOPQRSTUVWXYZ. Усі інші значення байтів без регістру.

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

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

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

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

Примітка

Версія bytearray цього методу не працює на місці – вона завжди створює новий об’єкт, навіть якщо не було зроблено жодних змін.

bytes.upper()

bytearray.upper()

Повертає копію послідовності з усіма символами нижнього регістру ASCII, перетвореними на їхні відповідні відповідники у верхньому регістрі.

Наприклад:

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

Символи ASCII у нижньому регістрі – це значення байтів у послідовності b'abcdefghijklmnopqrstuvwxyz. Символи ASCII у верхньому регістрі – це значення байтів у послідовності b'ABCDEFGHIJKLMNOPQRSTUVWXYZ.

Примітка

Версія bytearray цього методу не працює на місці – вона завжди створює новий об’єкт, навіть якщо не було зроблено жодних змін.

bytes.zfill(width)

bytearray.zfill(width)

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

Наприклад:

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

Примітка

Версія bytearray цього методу не працює на місці – вона завжди створює новий об’єкт, навіть якщо не було зроблено жодних змін.

Форматування байтів у стилі printf

Примітка

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

Об’єкти Bytes (bytes/bytearray) мають одну унікальну вбудовану операцію: оператор % (за модулем). Це також відоме як оператор форматування або інтерполяції байтів. Враховуючи формат % значень (де format є об’єктом байтів), % специфікації перетворення у format замінюються нулем або більше елементами значень. Ефект подібний до використання sprintf() у мові C.

Якщо для format потрібен один аргумент, values може бути одним некортежним об’єктом. [5] В іншому випадку values має бути кортежем із точною кількістю елементів, указаною об’єктом format bytes, або одним об’єктом відображення (наприклад, словником).

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

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

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

3. Прапорці перетворення (опціонально), які впливають на результат деяких типів перетворення.

4. Мінімальна ширина поля (опціонально). Якщо вказано як '*' (зірочка), фактична ширина зчитується з наступного елемента кортежу в значеннях, а об’єкт для перетворення йде після мінімальної ширини поля та необов’язкової точності.

5. Точність (необов’язкова), подається як '.' (крапка), за якою йде точність. Якщо вказано як '*' (зірочка), фактична точність зчитується з наступного елемента кортежу в значеннях, а значення для перетворення йде після точності.

6. Модифікатор довжини (необов’язково).

7. Тип перетворення.

Коли правильний аргумент є словником (або іншим типом відображення), тоді формати в об’єкті bytes мають містити ключ відображення в дужках у цьому словнику, вставлений відразу після символу '%'. Ключ відображення вибирає значення, яке потрібно відформатувати, із відображення. Наприклад:

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

У цьому випадку у форматі не може бути специфікаторів * (оскільки вони вимагають послідовного списку параметрів).

Символи прапора перетворення:

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

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

Типи перетворення:

Перетворення	Значення	Примітки
'd''	Ціле десяткове число зі знаком.
'я''	Ціле десяткове число зі знаком.
'o'	Вісімкове значення зі знаком.	(1)
'u''	Застарілий тип – він ідентичний 'd'.	(8)
'x''	Шістнадцяткове число зі знаком (нижній регістр).	(2)
'X''	Шістнадцяткове число зі знаком (верхній регістр).	(2)
'e''	Floating point exponential format (lowercase).	(3)
'E'	Floating point exponential format (uppercase).	(3)
'f''	Floating point decimal format.	(3)
'F''	Floating point decimal format.	(3)
'g''	Floating point format. Uses lowercase exponential format if exponent is less than -4 or not less than precision, decimal format otherwise.	(4)
'G''	Floating point format. Uses uppercase exponential format if exponent is less than -4 or not less than precision, decimal format otherwise.	(4)
'c''	Однобайтовий (приймає цілі чи однобайтові об’єкти).
'b''	Bytes (any object that follows the buffer protocol or has __bytes__()).	(5)
's''	's'' є псевдонімом для 'b'' і має використовуватися лише для базового коду Python2/3.	(6)
'a'	Байти (перетворює будь-який об’єкт Python за допомогою repr(obj).encode('ascii', 'backslashreplace')).	(5)
'r''	'r' є псевдонімом для 'a' і має використовуватися лише для базових кодів Python2/3.	(7)
'%'	Жоден аргумент не перетворюється, результатом є символ '%' в результаті.

Примітки:

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

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

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

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

4. Альтернативна форма призводить до того, що результат завжди містить десяткову кому, а кінцеві нулі не видаляються, як це було б інакше.

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

5. Якщо точність N, вивід скорочується до N символів.

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

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

8. Дивіться PEP 237.

Примітка

Версія bytearray цього методу не працює на місці – вона завжди створює новий об’єкт, навіть якщо не було зроблено жодних змін.

Дивись також

PEP 461 - Додано форматування % до байтів і масиву байтів

Нове в версії 3.5.

Перегляди пам’яті

Об’єкти memoryview дозволяють коду Python отримувати доступ до внутрішніх даних об’єкта, який підтримує протокол буфера без копіювання.

class memoryview(object)

Створіть memoryview, який посилається на об’єкт. об’єкт має підтримувати протокол буфера. Вбудовані об’єкти, які підтримують протокол буфера, включають bytes і bytearray.

memoryview має поняття елемента, який є атомарною одиницею пам’яті, яка обробляється вихідним об’єктом. Для багатьох простих типів, таких як bytes і bytearray, елемент є одним байтом, але інші типи, такі як array.array, можуть мати більші елементи.

len(view) is equal to the length of tolist. If view.ndim = 0, the length is 1. If view.ndim = 1, the length is equal to the number of elements in the view. For higher dimensions, the length is equal to the length of the nested list representation of the view. The itemsize attribute will give you the number of bytes in a single element.

memoryview підтримує нарізку та індексування для показу своїх даних. Одновимірне нарізання призведе до підвиду:

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

Якщо format є одним із власних специфікаторів формату з модуля struct, індексація за допомогою цілого числа або кортежу цілих чисел також підтримується та повертає один елемент із правильним типом . Одновимірні представлення пам’яті можна індексувати за допомогою цілого або одноцілого кортежу. Багатовимірні представлення пам’яті можна індексувати за допомогою кортежів з точно ndim цілих чисел, де ndim є кількістю вимірів. Нульвимірні представлення пам’яті можна індексувати за допомогою порожнього кортежу.

Ось приклад небайтового формату:

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

Якщо основний об’єкт доступний для запису, memoryview підтримує одновимірне призначення фрагментів. Зміна розміру заборонена:

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

One-dimensional memoryviews of hashable (read-only) types with formats „B“, „b“ or „c“ are also hashable. The hash is defined as hash(m) == hash(m.tobytes()):

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

Змінено в версії 3.3: One-dimensional memoryviews can now be sliced. One-dimensional memoryviews with formats „B“, „b“ or „c“ are now hashable.

Змінено в версії 3.4: memoryview тепер автоматично реєструється в collections.abc.Sequence

Змінено в версії 3.5: memoryviews тепер можна індексувати кортежем цілих чисел.

memoryview має кілька методів:

__eq__(exporter)

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

Для підмножини рядків формату struct, які зараз підтримуються tolist(), v і w рівні, якщо v.tolist() == w.tolist():

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

Якщо будь-який рядок формату не підтримується модулем struct, тоді об’єкти завжди порівнюватимуться як нерівні (навіть якщо рядки формату та вміст буфера ідентичні):

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

Note that, as with floating point numbers, v is w does not imply v == w for memoryview objects.

Змінено в версії 3.3: Попередні версії порівнювали необроблену пам’ять без урахування формату елемента та логічної структури масиву.

tobytes(order='C')

Повертає дані в буфері як байтовий рядок. Це еквівалентно виклику конструктора bytes у memoryview.

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

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

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

hex([sep[, bytes_per_sep]])

Повертає рядковий об’єкт, що містить дві шістнадцяткові цифри для кожного байта в буфері.

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

Нове в версії 3.5.

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

tolist()

Повертає дані в буфері як список елементів.

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

Змінено в версії 3.3: tolist() тепер підтримує всі односимвольні рідні формати в синтаксисі модуля struct, а також багатовимірні представлення.

toreadonly()

Повертає версію об’єкта memoryview лише для читання. Оригінальний об’єкт memoryview не змінено.

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

Нове в версії 3.8.

release()

Вивільніть базовий буфер, відкритий об’єктом memoryview. Багато об’єктів виконують спеціальні дії, коли їх переглядають (наприклад, bytearray тимчасово забороняє зміну розміру); отже, виклик release() є зручним, щоб усунути ці обмеження (і звільнити будь-які завислі ресурси) якомога швидше.

After this method has been called, any further operation on the view raises a ValueError (except release() itself which can be called multiple times):

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

Протокол керування контекстом може бути використаний для подібного ефекту, використовуючи оператор with:

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

Нове в версії 3.2.

cast(format[, shape])

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

The destination format is restricted to a single element native format in struct syntax. One of the formats must be a byte format („B“, „b“ or „c“). The byte length of the result must be the same as the original length. Note that all byte lengths may depend on the operating system.

Перетворення 1D/long на 1D/беззнакові байти:

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

Перетворення 1D/беззнакових байтів у 1D/char:

>>> b = bytearray(b'zyz')
>>> x = memoryview(b)
>>> x[0] = b'a'
Traceback (most recent call last):
  ...
TypeError: memoryview: invalid type for format 'B'
>>> y = x.cast('c')
>>> y[0] = b'a'
>>> b
bytearray(b'ayz')

Перетворити 1D/байти на 3D/ints на 1D/signed char:

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

Перетворення 1D/unsigned long на 2D/unsigned long

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

Нове в версії 3.3.

Змінено в версії 3.5: Вихідний формат більше не обмежений під час трансляції до байтового перегляду.

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

obj

Основний об’єкт memoryview:

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

Нове в версії 3.3.

nbytes

nbytes == product(shape) * itemsize == len(m.tobytes()). Це обсяг простору в байтах, який буде використовуватися масивом у безперервному представленні. Воно не обов’язково дорівнює len(m):

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

Багатовимірні масиви:

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

Нове в версії 3.3.

readonly

Bool, що вказує, чи є пам’ять лише для читання.

format

Рядок, що містить формат (у стилі модуля struct) для кожного елемента в поданні. Огляд пам’яті можна створити з експортерів із довільними рядками формату, але деякі методи (наприклад, tolist()) обмежені рідними одноелементними форматами.

Змінено в версії 3.3: формат 'B' тепер обробляється відповідно до синтаксису модуля struct. Це означає, що memoryview(b'abc')[0] == b'abc'[0] == 97.

itemsize

Розмір у байтах кожного елемента memoryview:

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

ndim

Ціле число, що вказує, скільки вимірів багатовимірного масиву представляє пам’ять.

shape

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

Змінено в версії 3.3: Порожній кортеж замість None, коли ndim = 0.

strides

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

Змінено в версії 3.3: Порожній кортеж замість None, коли ndim = 0.

suboffsets

Використовується внутрішньо для масивів у стилі PIL. Значення лише інформаційне.

c_contiguous

Логічне значення, яке вказує, чи є пам’ять C-contiguous.

Нове в версії 3.3.

f_contiguous

Логічне значення, що вказує, чи є пам’ять Fortran contiguous.

Нове в версії 3.3.

contiguous

Bool, що вказує, чи є пам’ять contiguous.

Нове в версії 3.3.

Типи наборів — set, frozenset

Об’єкт set — це невпорядкована колекція окремих об’єктів hashable. Загальне використання включає тестування членства, видалення дублікатів із послідовності та обчислення математичних операцій, таких як перетин, об’єднання, різниця та симетрична різниця. (Для інших контейнерів перегляньте вбудовані класи dict, list і tuple, а також модуль collections.)

Як і інші колекції, набори підтримують x in set, len(set) і for x in set. Будучи невпорядкованою колекцією, набори не записують положення елемента або порядок вставки. Відповідно, набори не підтримують індексування, нарізку чи іншу поведінку, подібну до послідовності.

Наразі існує два вбудовані типи наборів: set і frozenset. Тип set є змінним — вміст можна змінити за допомогою таких методів, як add() і remove(). Оскільки він є змінним, він не має хеш-значення і не може використовуватися ні як ключ словника, ні як елемент іншого набору. Тип frozenset є незмінним і hashable — його вміст не можна змінити після створення; тому його можна використовувати як ключ до словника або як елемент іншого набору.

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

Конструктори для обох класів працюють однаково:

class set([iterable])

class frozenset([iterable])

Повертає новий набір або заморожений об’єкт, елементи якого взяті з iterable. Елементи набору мають бути hashable. Щоб представити набори наборів, внутрішні набори мають бути об’єктами frozenset. Якщо iterable не вказано, повертається новий порожній набір.

Набори можна створювати кількома способами:

• Використовуйте список елементів, розділених комами, у фігурних дужках: {'jack', 'sjoerd'}

• Використовуйте розуміння набору: {c для c в 'abracadabra' якщо c не в 'abc'}

• Використовуйте конструктор типу: set(), set('foobar'), set(['a', 'b', 'foo'])

Екземпляри set і frozenset забезпечують такі операції:

len(s)

Повертає кількість елементів у наборі s (мощність s).

x in s

Перевірте x на членство в s.

x not in s

Перевірте x на неналежність до s.

isdisjoint(other)

Повертає True, якщо набір не має спільних елементів з other. Множини непересічні тоді і тільки тоді, коли їх перетин є порожньою множиною.

issubset(other)

set <= other

Перевірте, чи кожен елемент у наборі знаходиться в other.

set < other

Перевірте, чи набір є правильною підмножиною other, тобто set <= other і set != other.

issuperset(other)

set >= other

Перевірте, чи всі елементи в other є в наборі.

set > other

Перевірте, чи є набір правильною надмножиною other, тобто set >= other і set != other.

union(*others)

set | other | ...

Повернути новий набір з елементами з набору та всі інші.

intersection(*others)

set & other & ...

Повертає новий набір із елементами, спільними для набору та всіх інших.

difference(*others)

set - other - ...

Повертає новий набір з елементами в наборі, яких немає в інших.

symmetric_difference(other)

set ^ other

Повертає новий набір з елементами або в наборі, або в іншому, але не в обох.

copy()

Поверніть мілку копію набору.

Зауважте, версії без операторів union(), intersection(), difference(), symmetric_difference(), issubset() і issuperset() методи приймуть будь-яку ітерацію як аргумент. На відміну від цього, їхні аналоги на основі операторів вимагають, щоб їхні аргументи були наборами. Це виключає такі схильні до помилок конструкції, як set('abc') & 'cbs' на користь більш читабельного set('abc').intersection('cbs').

І set, і frozenset підтримують набір для встановлення порівнянь. Дві множини рівні тоді і тільки тоді, коли кожен елемент кожної множини міститься в іншій (кожен є підмножиною іншого). Набір менший за інший набір тоді і тільки тоді, коли перший набір є належним підмножиною другого набору (є підмножиною, але не дорівнює). Набір більший за інший набір тоді і тільки тоді, коли перший набір є належним надмножиною другого набору (є надмножиною, але не є рівним).

Примірники set порівнюються з примірниками frozenset на основі їхніх членів. Наприклад, set('abc') == frozenset('abc') повертає True, а також set('abc') у set([frozenset('abc')]).

Порівняння підмножини та рівності не узагальнюють до загальної функції впорядкування. Наприклад, будь-які дві непорожні непересічні множини не рівні і не є підмножинами одна одної, тому всі з наступного повертають False: a <b, a==b, or a> b.

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

Елементи набору, як і ключі словника, мають бути hashable.

Бінарні операції, які поєднують екземпляри set із frozenset, повертають тип першого операнда. Наприклад: frozenset('ab') | set('bc') повертає екземпляр frozenset.

У наступній таблиці наведено операції, доступні для set, які не застосовуються до незмінних екземплярів frozenset:

update(*others)

set |= other | ...

Оновіть набір, додавши елементи з усіх інших.

intersection_update(*others)

set &= other & ...

Оновіть набір, зберігаючи лише елементи, знайдені в ньому, і всі інші.

difference_update(*others)

set -= other | ...

Оновіть набір, видаляючи елементи, знайдені в інших.

symmetric_difference_update(other)

set ^= other

Оновіть набір, зберігаючи лише елементи, знайдені в будь-якому наборі, але не в обох.

add(elem)

Додайте елемент elem до набору.

remove(elem)

Видалити елемент elem із набору. Викликає KeyError, якщо elem не міститься в наборі.

discard(elem)

Видалити елемент elem із набору, якщо він присутній.

pop()

Вилучити та повернути довільний елемент із набору. Викликає KeyError, якщо набір порожній.

clear()

Видаліть усі елементи з набору.

Зауважте, що безоператорні версії методів update(), intersection_update(), difference_update() і symmetric_difference_update() прийматимуть будь-яку ітерацію як аргумент.

Note, the elem argument to the __contains__(), remove(), and discard() methods may be a set. To support searching for an equivalent frozenset, a temporary one is created from elem.

Типи зіставлення — dict

Об’єкт mapping відображає значення hashable на довільні об’єкти. Відображення є змінними об’єктами. Зараз існує лише один стандартний тип відображення, dictionary. (Для інших контейнерів перегляньте вбудовані класи list, set і tuple, а також модуль collections.)

A dictionary’s keys are almost arbitrary values. Values that are not hashable, that is, values containing lists, dictionaries or other mutable types (that are compared by value rather than by object identity) may not be used as keys. Values that compare equal (such as 1, 1.0, and True) can be used interchangeably to index the same dictionary entry.

class dict(**kwargs)

class dict(mapping, **kwargs)

class dict(iterable, **kwargs)

Повертає новий словник, ініціалізований необов’язковим позиційним аргументом і, можливо, порожнім набором ключових аргументів.

Словники можна створювати кількома способами:

• Використовуйте розділений комами список пар ключ: значення у дужках: {'jack': 4098, 'sjoerd': 4127} або {4098: 'jack', 4127: 'sjoerd' }

• Використовуйте розуміння диктового слова: {}, {x: x ** 2 для x в діапазоні (10)}

• Використовуйте конструктор типу: dict(), dict([('foo', 100), ('bar', 200)]), dict(foo=100, bar=200)

Якщо позиційний аргумент не задано, створюється порожній словник. Якщо вказано позиційний аргумент і він є об’єктом відображення, словник створюється з тими самими парами ключ-значення, що й об’єкт відображення. В іншому випадку позиційний аргумент має бути об’єктом iterable. Кожен елемент у ітераторі повинен сам бути ітератором із рівно двома об’єктами. Перший об’єкт кожного елемента стає ключем у новому словнику, а другий об’єкт – відповідним значенням. Якщо ключ зустрічається більше одного разу, останнє значення цього ключа стає відповідним значенням у новому словнику.

Якщо надано аргументи ключового слова, аргументи ключового слова та їхні значення додаються до словника, створеного з позиційного аргументу. Якщо ключ, який додається, уже присутній, значення з аргументу ключового слова замінює значення з позиційного аргументу.

Для ілюстрації, усі наступні приклади повертають словник, що дорівнює {"one": 1, "two": 2, "three": 3}:

>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> f = dict({'one': 1, 'three': 3}, two=2)
>>> a == b == c == d == e == f
True

Надання аргументів ключових слів, як у першому прикладі, працює лише для ключів, які є дійсними ідентифікаторами Python. В іншому випадку можна використовувати будь-які дійсні ключі.

Це операції, які підтримують словники (і, отже, також повинні підтримуватися спеціальні типи зіставлення):

list(d)

Повернути список усіх ключів, які використовуються у словнику d.

len(d)

Повернути кількість елементів у словнику d.

d[key]

Поверніть елемент d за допомогою ключа key. Викликає KeyError, якщо key немає на карті.

Якщо підклас dict визначає метод __missing__() і key відсутній, операція d[key] викликає цей метод із ключем key як аргументом. Потім операція d[key] повертає або викликає все, що повертається або викликається викликом __missing__(key). Жодні інші операції чи методи не викликають __missing__(). Якщо __missing__() не визначено, виникає KeyError. __missing__() має бути методом; це не може бути змінна екземпляра:

>>> class Counter(dict):
...     def __missing__(self, key):
...         return 0
>>> c = Counter()
>>> c['red']
0
>>> c['red'] += 1
>>> c['red']
1

Наведений вище приклад показує частину реалізації collections.Counter. Інший метод __missing__ використовується collections.defaultdict.

d[key] = value

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

del d[key]

Видаліть d[key] з d. Викликає KeyError, якщо key немає на карті.

key in d

Повертає True, якщо d має ключ key, інакше False.

key not in d

Еквівалент не вводити d.

iter(d)

Повертає ітератор над ключами словника. Це ярлик для iter(d.keys()).

clear()

Видаліть усі елементи зі словника.

copy()

Поверніть мілку копію словника.

classmethod fromkeys(iterable[, value])

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

fromkeys() — це метод класу, який повертає новий словник. value за замовчуванням None. Усі значення стосуються лише одного екземпляра, тому загалом не має сенсу, щоб value було змінним об’єктом, таким як порожній список. Щоб отримати різні значення, замість цього використовуйте dict comprehension.

get(key[, default])

Повертає значення для key, якщо key є в словнику, інакше за замовчуванням. Якщо default не вказано, за замовчуванням буде None, тому цей метод ніколи не викликає KeyError.

items()

Повертає нове подання елементів словника (пари «(ключ, значення)»). Перегляньте документацію об’єктів перегляду.

keys()

Повернути новий вигляд ключів словника. Перегляньте документацію об’єктів перегляду.

pop(key[, default])

Якщо key є у словнику, видаліть його та поверніть його значення, інакше поверніть default. Якщо default не вказано, а key немає в словнику, виникає KeyError.

popitem()

Видалити та повернути пару (ключ, значення) зі словника. Пари повертаються в порядку LIFO.

popitem() корисний для деструктивного повторення словника, як це часто використовується в набір алгоритмів. Якщо словник порожній, виклик popitem() викликає KeyError.

Змінено в версії 3.7: Замовлення LIFO тепер гарантовано. У попередніх версіях popitem() повертав довільну пару ключ/значення.

reversed(d)

Повертає зворотний ітератор над ключами словника. Це ярлик для reversed(d.keys()).

Нове в версії 3.8.

setdefault(key[, default])

Якщо key є в словнику, поверніть його значення. Якщо ні, вставте ключ зі значенням default і поверніть default. default за замовчуванням None.

update([other])

Оновіть словник парами ключ/значення з other, перезаписавши існуючі ключі. Повернути Жодного.

update() приймає або інший об’єкт словника, або ітерацію пар ключ/значення (як кортежі чи інші ітерації довжиною два). Якщо вказано аргументи ключового слова, словник оновлюється такими парами ключ/значення: d.update(red=1, blue=2).

values()

Повернути нове подання значень словника. Перегляньте документацію об’єктів перегляду.

Порівняння рівності між одним переглядом dict.values() та іншим завжди повертатиме False. Це також стосується порівняння dict.values() із собою:

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

d | other

Створіть новий словник із об’єднаними ключами та значеннями d та other, які мають бути словниками. Значення other мають пріоритет, коли d та other мають спільні ключі.

Нове в версії 3.9.

d |= other

Оновіть словник d ключами та значеннями з other, які можуть бути mapping або iterable пар ключ/значення. Значення other мають пріоритет, коли d та other мають спільні ключі.

Нове в версії 3.9.

Словники порівнюються рівними тоді і тільки тоді, коли вони мають однакові пари (ключ, значення) (незалежно від порядку). Порівняння порядку (“ <“, „<=“, „> =“, „>“) викликає TypeError.

Словники зберігають порядок вставки. Зауважте, що оновлення ключа не впливає на порядок. Ключі, додані після видалення, вставляються в кінці.

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

Змінено в версії 3.7: Порядок словника гарантовано буде порядком вставки. Така поведінка була деталлю реалізації CPython від 3.6.

Словники та перегляди словників є оборотними.

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

Змінено в версії 3.8: Словники тепер оборотні.

Дивись також

types.MappingProxyType можна використовувати для створення перегляду dict лише для читання.

Об’єкти перегляду словника

Об’єкти, які повертаються dict.keys(), dict.values() і dict.items(), є об’єктами перегляду. Вони забезпечують динамічний перегляд статей словника, що означає, що коли словник змінюється, перегляд відображає ці зміни.

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

len(dictview)

Повернути кількість статей у словнику.

iter(dictview)

Повертає ітератор над ключами, значеннями або елементами (представленими у вигляді кортежів (ключ, значення)) у словнику.

Ключі та значення повторюються в порядку вставки. Це дозволяє створювати пари (значення, ключ) за допомогою zip(): pairs = zip(d.values(), d.keys()). Інший спосіб створити той самий список: pairs = [(v, k) for (k, v) in d.items()].

Ітерація подання під час додавання чи видалення записів у словнику може викликати RuntimeError або не вдається виконати ітерацію по всіх записах.

Змінено в версії 3.7: Порядок словника гарантовано буде порядком вставки.

x in dictview

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

reversed(dictview)

Повертає зворотний ітератор над ключами, значеннями або елементами словника. Подання буде повторено в порядку, зворотному до вставки.

Змінено в версії 3.8: Перегляди словника тепер оборотні.

dictview.mapping

Повертає types.MappingProxyType, який обгортає вихідний словник, на який посилається перегляд.

Нове в версії 3.10.

Keys views are set-like since their entries are unique and hashable. If all values are hashable, so that (key, value) pairs are unique and hashable, then the items view is also set-like. (Values views are not treated as set-like since the entries are generally not unique.) For set-like views, all of the operations defined for the abstract base class collections.abc.Set are available (for example, ==, <, or ^).

Приклад використання перегляду словника:

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

>>> # iteration
>>> n = 0
>>> for val in values:
...     n += val
>>> print(n)
504

>>> # keys and values are iterated over in the same order (insertion order)
>>> list(keys)
['eggs', 'sausage', 'bacon', 'spam']
>>> list(values)
[2, 1, 1, 500]

>>> # view objects are dynamic and reflect dict changes
>>> del dishes['eggs']
>>> del dishes['sausage']
>>> list(keys)
['bacon', 'spam']

>>> # set operations
>>> keys & {'eggs', 'bacon', 'salad'}
{'bacon'}
>>> keys ^ {'sausage', 'juice'} == {'juice', 'sausage', 'bacon', 'spam'}
True
>>> keys | ['juice', 'juice', 'juice'] == {'bacon', 'spam', 'juice'}
True

>>> # get back a read-only proxy for the original dictionary
>>> values.mapping
mappingproxy({'bacon': 1, 'spam': 500})
>>> values.mapping['spam']
500

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

Оператор Python with підтримує концепцію контексту виконання, визначеного менеджером контексту. Це реалізовано за допомогою пари методів, які дозволяють визначеним користувачем класам визначати контекст виконання, який вводиться перед виконанням тіла оператора та виходить, коли оператор закінчується:

contextmanager.__enter__()

Введіть контекст середовища виконання та поверніть або цей об’єкт, або інший об’єкт, пов’язаний із контекстом середовища виконання. Значення, яке повертає цей метод, прив’язується до ідентифікатора в пункті as операторів with за допомогою цього менеджера контексту.

Прикладом контекстного менеджера, який повертає сам себе, є file object. Файлові об’єкти повертаються з __enter__(), щоб дозволити використовувати open() як вираз контексту в операторі with.

Прикладом менеджера контексту, який повертає пов’язаний об’єкт, є той, який повертає decimal.localcontext(). Ці менеджери встановлюють активний десятковий контекст на копію вихідного десяткового контексту, а потім повертають копію. Це дозволяє вносити зміни до поточного десяткового контексту в тілі оператора with, не впливаючи на код поза оператором with.

contextmanager.__exit__(exc_type, exc_val, exc_tb)

Вийдіть із контексту виконання та поверніть логічний прапор, який вказує, чи має бути придушено будь-який виняток, який стався. Якщо виняток стався під час виконання тіла оператора with, аргументи містять тип винятку, значення та інформацію про відстеження. В іншому випадку всі три аргументи є Жодним.

Повернення цього методу справжнього значення призведе до того, що оператор with придушить виняток і продовжить виконання з оператором, який слідує безпосередньо за оператором with. В іншому випадку виняткова ситуація продовжує поширюватися після завершення виконання цього методу. Винятки, які виникають під час виконання цього методу, замінять будь-які винятки, які виникли в тілі оператора with.

The exception passed in should never be reraised explicitly - instead, this method should return a false value to indicate that the method completed successfully and does not want to suppress the raised exception. This allows context management code to easily detect whether or not an __exit__() method has actually failed.

Python визначає декілька контекстних менеджерів для підтримки легкої синхронізації потоків, швидкого закриття файлів чи інших об’єктів і простішого маніпулювання активним десятковим арифметичним контекстом. Конкретні типи не розглядаються спеціально за межами їх реалізації в протоколі керування контекстом. Перегляньте модуль contextlib для деяких прикладів.

generators Python і декоратор contextlib.contextmanager забезпечують зручний спосіб реалізації цих протоколів. Якщо функція-генератор прикрашена декоратором contextlib.contextmanager, вона повертатиме менеджер контексту, який реалізує необхідні методи __enter__() і __exit__(), а не ітератор, створений недекорованою функцією генератора.

Зауважте, що немає спеціального слота для жодного з цих методів у структурі типу для об’єктів Python в API Python/C. Типи розширень, які хочуть визначити ці методи, повинні надати їх як звичайний доступний метод Python. Порівняно з накладними витратами на налаштування контексту виконання, накладні витрати на пошук словника одного класу є незначними.

Типи анотацій типу — Загальний псевдонім, Об’єднання

Основними вбудованими типами для анотацій типу є Generic Alias і Union.

Загальний тип псевдоніма

Об’єкти GenericAlias зазвичай створюються індексом класу. Найчастіше вони використовуються з контейнерними класами, такими як list або dict. Наприклад, list[int] є об’єктом GenericAlias, створеним шляхом підписання класу list з аргументом int. Об’єкти GenericAlias призначені насамперед для використання з анотаціями типу.

Примітка

Як правило, індекс класу можливий, лише якщо клас реалізує спеціальний метод __class_getitem__().

Об’єкт GenericAlias діє як проксі для generic type, реалізуючи параметризовані генерики.

Для класу-контейнера аргумент(и), що надаються підписці класу, може вказувати тип(и) елементів, які містить об’єкт. Наприклад, set[bytes] можна використовувати в анотаціях типу для позначення set, у якому всі елементи мають тип bytes.

Для класу, який визначає __class_getitem__(), але не є контейнером, аргумент(и), що надаються до підписки класу, часто вказуватиме тип(и) повернення одного або кількох методів, визначених для об’єкта . Наприклад, регулярні вирази можна використовувати як для типу даних str, так і для типу даних bytes:

• Якщо x = re.search('foo', 'foo'), x буде об’єктом re.Match, де повертаються значення x.group(0 ) і x[0] будуть мати тип str. Ми можемо представити цей тип об’єктів в анотаціях типу за допомогою GenericAlias re.Match[str].

• Якщо y = re.search(b'bar', b'bar') (зверніть увагу на b для bytes), y також буде екземпляром re.Match, але повертані значення y.group(0) і y[0] будуть мати тип bytes. В анотаціях типів ми б представили цю різноманітність об’єктів re.Match за допомогою re.Match[bytes].

Об’єкти GenericAlias є екземплярами класу types.GenericAlias, який також можна використовувати для безпосереднього створення об’єктів GenericAlias.

T[X, Y, ...]

Створює Generic Alias, що представляє тип T, параметризований типами X, Y тощо залежно від T, що використовується. Наприклад, функція, яка очікує list, що містить елементи float:

def average(values: list[float]) -> float:
    return sum(values) / len(values)

Інший приклад для об’єктів mapping з використанням dict, який є загальним типом, який очікує двох параметрів типу, що представляють тип ключа та тип значення. У цьому прикладі функція очікує dict з ключами типу str і значеннями типу int:

def send_post_request(url: str, body: dict[str, int]) -> None:
    ...

Вбудовані функції isinstance() і issubclass() не приймають типи GenericAlias для свого другого аргументу:

>>> isinstance([1, 2], list[str])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: isinstance() argument 2 cannot be a parameterized generic

Середовище виконання Python не вимагає анотацій типу. Це поширюється на загальні типи та їхні параметри типу. Під час створення об’єкта-контейнера з GenericAlias елементи в контейнері не перевіряються на їх тип. Наприклад, наступний код не рекомендується, але працюватиме без помилок:

>>> t = list[str]
>>> t([1, 2, 3])
[1, 2, 3]

Крім того, параметризовані генерики стирають параметри типу під час створення об’єкта:

>>> t = list[str]
>>> type(t)
<class 'types.GenericAlias'>

>>> l = t()
>>> type(l)
<class 'list'>

Виклик repr() або str() у загальному показує параметризований тип:

>>> repr(list[int])
'list[int]'

>>> str(list[int])
'list[int]'

Метод __getitem__() загальних контейнерів викличе виняток, щоб заборонити такі помилки, як dict[str][str]:

>>> dict[str][str]
Traceback (most recent call last):
  ...
TypeError: dict[str] is not a generic class

Однак такі вирази дійсні, коли використовуються змінні типу. Індекс має містити стільки елементів, скільки елементів змінних типу в об’єкті GenericAlias __args__.

>>> from typing import TypeVar
>>> Y = TypeVar('Y')
>>> dict[str, Y][int]
dict[str, int]

Стандартні загальні класи

Наступні стандартні бібліотечні класи підтримують параметризовані генерики. Цей список не є вичерпним.

• tuple

• list

• dict

• set

• frozenset

• type

• collections.deque

• collections.defaultdict

• collections.OrderedDict

• collections.Counter

• collections.ChainMap

• collections.abc.Awaitable

• collections.abc.Coroutine

• collections.abc.AsyncIterable

• collections.abc.AsyncIterator

• collections.abc.AsyncGenerator

• collections.abc.Iterable

• collections.abc.Iterator

• collections.abc.Generator

• collections.abc.Reversible

• collections.abc.Container

• collections.abc.Collection

• collections.abc.Callable

• collections.abc.Set

• collections.abc.MutableSet

• collections.abc.Mapping

• collections.abc.MutableMapping

• collections.abc.Sequence

• collections.abc.MutableSequence

• collections.abc.ByteString

• collections.abc.MappingView

• collections.abc.KeysView

• collections.abc.ItemsView

• collections.abc.ValuesView

• contextlib.AbstractContextManager

• contextlib.AbstractAsyncContextManager

• dataclasses.Field

• functools.cached_property

• functools.partialmethod

• os.PathLike

• queue.LifoQueue

• queue.Queue

• queue.PriorityQueue

• queue.SimpleQueue

• re.Патерн

• re.Match

• полиця.BsdDbShelf

• полиця.DbfilenameShelf

• полиця.Полиця

• types.MappingProxyType

• weakref.WeakKeyDictionary

• weakref.WeakMethod

• weakref.WeakSet

• weakref.WeakValueDictionary

Спеціальні атрибути об’єктів GenericAlias

Усі параметризовані генерики реалізують спеціальні атрибути лише для читання.

genericalias.__origin__

Цей атрибут вказує на непараметризований загальний клас:

>>> list[int].__origin__
<class 'list'>

genericalias.__args__

Цей атрибут є tuple (можливо, довжиною 1) загальних типів, переданих до оригінального __class_getitem__() загального класу:

>>> dict[str, list[int]].__args__
(<class 'str'>, list[int])

genericalias.__parameters__

Цей атрибут є ліниво обчисленим кортежем (можливо, порожнім) унікальних змінних типу, знайдених у __args__:

>>> from typing import TypeVar

>>> T = TypeVar('T')
>>> list[T].__parameters__
(~T,)

Примітка

Об’єкт GenericAlias з параметрами typing.ParamSpec може не мати правильних __parameters__ після заміни, тому що typing.ParamSpec призначений насамперед для статичної перевірки типу.

genericalias.__unpacked__

A boolean that is true if the alias has been unpacked using the * operator (see TypeVarTuple).

Нове в версії 3.11.

Дивись також

PEP 484 - підказки типу

Представляємо структуру Python для анотацій типів.

PEP 585 - Універсальні підказки типів у стандартних колекціях

Представляємо можливість нативної параметризації класів стандартної бібліотеки, якщо вони реалізують спеціальний метод класу __class_getitem__().

Узагальнення, визначені користувачем узагальнення і typing.Generic

Документація про те, як реалізувати загальні класи, які можна параметризувати під час виконання та розуміти статичними засобами перевірки типів.

Нове в версії 3.9.

Тип союзу

Об’єкт об’єднання містить значення операції | (порозрядної або) на кількох об’єктах типу. Ці типи призначені насамперед для анотацій типу. Вираз типу об’єднання забезпечує чіткіший синтаксис підказки типу порівняно з typing.Union.

X | Y | ...

Визначає об’єкт об’єднання, який містить типи X, Y і так далі. X | Y означає X або Y. Це еквівалентно typing.Union[X, Y]. Наприклад, наступна функція очікує аргумент типу int або float:

def square(number: int | float) -> int | float:
    return number ** 2

Примітка

The | operand cannot be used at runtime to define unions where one or more members is a forward reference. For example, int | "Foo", where "Foo" is a reference to a class not yet defined, will fail at runtime. For unions which include forward references, present the whole expression as a string, e.g. "int | Foo".

union_object == other

Об’єкти об’єднання можна перевірити на рівність з іншими об’єктами об’єднання. Подробиці:

• Союзи союзів сплощені:

  (int | str) | float == int | str | float
  

• Зайві типи видаляються:

  int | str | int == int | str
  

• Під час порівняння об’єднань порядок ігнорується:

  int | str == str | int
  

• Він сумісний з typing.Union:

  int | str == typing.Union[int, str]
  

• Необов’язкові типи можуть бути написані як об’єднання з None:

  str | None == typing.Optional[str]
  

isinstance(obj, union_object)

issubclass(obj, union_object)

Виклики isinstance() і issubclass() також підтримуються з об’єктом об’єднання:

>>> isinstance("", int | str)
True

However, parameterized generics in union objects cannot be checked:

>>> isinstance(1, int | list[int])  # short-circuit evaluation
True
>>> isinstance([1], int | list[int])
Traceback (most recent call last):
  ...
TypeError: isinstance() argument 2 cannot be a parameterized generic

Доступ до відкритого користувачем типу для об’єкта union можна отримати з types.UnionType і використовувати для перевірки isinstance(). Об’єкт не може бути створений із типу:

>>> import types
>>> isinstance(int | str, types.UnionType)
True
>>> types.UnionType()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot create 'types.UnionType' instances

Примітка

The __or__() method for type objects was added to support the syntax X | Y. If a metaclass implements __or__(), the Union may override it:

>>> class M(type):
...     def __or__(self, other):
...         return "Hello"
...
>>> class C(metaclass=M):
...     pass
...
>>> C | int
'Hello'
>>> int | C
int | C

Дивись також

PEP 604 – PEP пропонує X | Синтаксис Y і тип Union.

Нове в версії 3.10.

Інші вбудовані типи

Інтерпретатор підтримує кілька інших видів об’єктів. Більшість із них підтримує лише одну або дві операції.

Модулі

Єдиною спеціальною операцією над модулем є доступ до атрибутів: m.name, де m — це модуль, а name отримує доступ до імені, визначеного в таблиці символів m. Модулю можна призначити атрибути. (Зауважте, що оператор import не є, строго кажучи, операцією над об’єктом модуля; import foo не вимагає існування об’єкта модуля з назвою foo, скоріше для цього потрібен (зовнішній) визначення для модуля з назвою foo десь.)

Спеціальним атрибутом кожного модуля є __dict__. Це словник, що містить таблицю символів модуля. Зміна цього словника фактично змінить таблицю символів модуля, але пряме призначення атрибуту __dict__ неможливо (ви можете написати m.__dict__['a'] = 1, що визначає m.a буде 1, але ви не можете написати m.__dict__ = {}). Не рекомендується безпосередньо змінювати __dict__.

Модулі, вбудовані в інтерпретатор, записуються так: <module 'sys' (built-in)>. Якщо завантажуються з файлу, вони записуються як <module 'os' from '/usr/local/lib/pythonX.Y/os.pyc'>.

Класи та екземпляри класів

Перегляньте Об’єкти, значення та типи і Визначення класів для них.

Функції

Функціональні об’єкти створюються визначеннями функцій. Єдина операція над об’єктом-функцією – це викликати його: func(список-аргументів).

Насправді існує два види функціональних об’єктів: вбудовані функції та функції, визначені користувачем. Обидва підтримують однакову операцію (виклик функції), але реалізація різна, отже, різні типи об’єктів.

Перегляньте Визначення функцій для отримання додаткової інформації.

методи

Methods are functions that are called using the attribute notation. There are two flavors: built-in methods (such as append() on lists) and class instance method. Built-in methods are described with the types that support them.

If you access a method (a function defined in a class namespace) through an instance, you get a special object: a bound method (also called instance method) object. When called, it will add the self argument to the argument list. Bound methods have two special read-only attributes: m.__self__ is the object on which the method operates, and m.__func__ is the function implementing the method. Calling m(arg-1, arg-2, ..., arg-n) is completely equivalent to calling m.__func__(m.__self__, arg-1, arg-2, ..., arg-n).

Like function objects, bound method objects support getting arbitrary attributes. However, since method attributes are actually stored on the underlying function object (method.__func__), setting method attributes on bound methods is disallowed. Attempting to set an attribute on a method results in an AttributeError being raised. In order to set a method attribute, you need to explicitly set it on the underlying function object:

>>> class C:
...     def method(self):
...         pass
...
>>> c = C()
>>> c.method.whoami = 'my name is method'  # can't set on the method
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'method' object has no attribute 'whoami'
>>> c.method.__func__.whoami = 'my name is method'
>>> c.method.whoami
'my name is method'

See Методи екземплярів for more information.

Об’єкти коду

Code objects are used by the implementation to represent «pseudo-compiled» executable Python code such as a function body. They differ from function objects because they don’t contain a reference to their global execution environment. Code objects are returned by the built-in compile() function and can be extracted from function objects through their __code__ attribute. See also the code module.

Accessing __code__ raises an auditing event object.__getattr__ with arguments obj and "__code__".

Об’єкт коду можна виконати або оцінити, передавши його (замість вихідного рядка) у вбудовані функції exec() або eval().

Перегляньте Стандартна ієрархія типів для отримання додаткової інформації.

Об’єкти типу

Об’єкти типу представляють різні типи об’єктів. Доступ до типу об’єкта здійснюється за допомогою вбудованої функції type(). Над типами немає спеціальних операцій. Стандартний модуль types визначає імена для всіх стандартних вбудованих типів.

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

Нульовий об’єкт

Цей об’єкт повертають функції, які явно не повертають значення. Він не підтримує ніяких спеціальних операцій. Існує рівно один нульовий об’єкт із назвою None (вбудована назва). type(None)() створює той самий синглтон.

Він записується як None.

Об’єкт «Еліпсис».

Цей об’єкт зазвичай використовується для нарізки (див. Нарізки). Він не підтримує ніяких спеціальних операцій. Існує рівно один об’єкт з крапкою, який називається Ellipsis (вбудована назва). type(Ellipsis)() виробляє Ellipsis синглтон.

Він записується як Еліпсис або ....

Об’єкт NotImplemented

This object is returned from comparisons and binary operations when they are asked to operate on types they don’t support. See Порівняння for more information. There is exactly one NotImplemented object. type(NotImplemented)() produces the singleton instance.

It is written as NotImplemented.

Boolean Values

Boolean values are the two constant objects False and True. They are used to represent truth values (although other values can also be considered false or true). In numeric contexts (for example when used as the argument to an arithmetic operator), they behave like the integers 0 and 1, respectively. The built-in function bool() can be used to convert any value to a Boolean, if the value can be interpreted as a truth value (see section Перевірка правдивості above).

They are written as False and True, respectively.

Внутрішні об’єкти

See Стандартна ієрархія типів for this information. It describes stack frame objects, traceback objects, and slice objects.

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

Реалізація додає кілька спеціальних атрибутів лише для читання до кількох типів об’єктів, де вони актуальні. Деякі з них не повідомляються вбудованою функцією dir().

object.__dict__

Словник або інший об’єкт відображення, який використовується для зберігання атрибутів об’єкта (для запису).

instance.__class__

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

class.__bases__

Кортеж базових класів об’єкта класу.

definition.__name__

Ім’я класу, функції, методу, дескриптора або екземпляра генератора.

definition.__qualname__

qualified name класу, функції, методу, дескриптора або екземпляра генератора.

Нове в версії 3.3.

class.__mro__

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

class.mro()

Цей метод може бути перевизначений метакласом, щоб налаштувати порядок вирішення методів для його екземплярів. Він викликається під час створення екземпляра класу, а його результат зберігається в __mro__.

class.__subclasses__()

Кожен клас зберігає список слабких посилань на його безпосередні підкласи. Цей метод повертає список усіх посилань, які ще живі. Список у порядку визначення. Приклад:

>>> int.__subclasses__()
[<class 'bool'>, <enum 'IntEnum'>, <flag 'IntFlag'>, <class 're._constants._NamedIntConstant'>]

Integer string conversion length limitation

CPython has a global limit for converting between int and str to mitigate denial of service attacks. This limit only applies to decimal or other non-power-of-two number bases. Hexadecimal, octal, and binary conversions are unlimited. The limit can be configured.

The int type in CPython is an arbitrary length number stored in binary form (commonly known as a «bignum»). There exists no algorithm that can convert a string to a binary integer or a binary integer to a string in linear time, unless the base is a power of 2. Even the best known algorithms for base 10 have sub-quadratic complexity. Converting a large value such as int('1' * 500_000) can take over a second on a fast CPU.

Limiting conversion size offers a practical way to avoid CVE-2020-10735.

The limit is applied to the number of digit characters in the input or output string when a non-linear conversion algorithm would be involved. Underscores and the sign are not counted towards the limit.

When an operation would exceed the limit, a ValueError is raised:

>>> import sys
>>> sys.set_int_max_str_digits(4300)  # Illustrative, this is the default.
>>> _ = int('2' * 5432)
Traceback (most recent call last):
...
ValueError: Exceeds the limit (4300 digits) for integer string conversion: value has 5432 digits; use sys.set_int_max_str_digits() to increase the limit
>>> i = int('2' * 4300)
>>> len(str(i))
4300
>>> i_squared = i*i
>>> len(str(i_squared))
Traceback (most recent call last):
...
ValueError: Exceeds the limit (4300 digits) for integer string conversion; use sys.set_int_max_str_digits() to increase the limit
>>> len(hex(i_squared))
7144
>>> assert int(hex(i_squared), base=16) == i*i  # Hexadecimal is unlimited.

The default limit is 4300 digits as provided in sys.int_info.default_max_str_digits. The lowest limit that can be configured is 640 digits as provided in sys.int_info.str_digits_check_threshold.

Verification:

>>> import sys
>>> assert sys.int_info.default_max_str_digits == 4300, sys.int_info
>>> assert sys.int_info.str_digits_check_threshold == 640, sys.int_info
>>> msg = int('578966293710682886880994035146873798396722250538762761564'
...           '9252925514383915483333812743580549779436104706260696366600'
...           '571186405732').to_bytes(53, 'big')
...

Нове в версії 3.11.

Affected APIs

The limitation only applies to potentially slow conversions between int and str or bytes:

• int(string) with default base 10.

• int(string, base) for all bases that are not a power of 2.

• str(integer).

• repr(integer).

• any other string conversion to base 10, for example f"{integer}", "{}".format(integer), or b"%d" % integer.

The limitations do not apply to functions with a linear algorithm:

• int(string, base) with base 2, 4, 8, 16, or 32.

• int.from_bytes() and int.to_bytes().

• hex(), oct(), bin().

• Міні-мова специфікації формату for hex, octal, and binary numbers.

• str to float.

• str to decimal.Decimal.

Configuring the limit

Before Python starts up you can use an environment variable or an interpreter command line flag to configure the limit:

• PYTHONINTMAXSTRDIGITS, e.g. PYTHONINTMAXSTRDIGITS=640 python3 to set the limit to 640 or PYTHONINTMAXSTRDIGITS=0 python3 to disable the limitation.

• -X int_max_str_digits, e.g. python3 -X int_max_str_digits=640

• sys.flags.int_max_str_digits contains the value of PYTHONINTMAXSTRDIGITS or -X int_max_str_digits. If both the env var and the -X option are set, the -X option takes precedence. A value of -1 indicates that both were unset, thus a value of sys.int_info.default_max_str_digits was used during initialization.

From code, you can inspect the current limit and set a new one using these sys APIs:

• sys.get_int_max_str_digits() and sys.set_int_max_str_digits() are a getter and setter for the interpreter-wide limit. Subinterpreters have their own limit.

Information about the default and minimum can be found in sys.int_info:

• sys.int_info.default_max_str_digits is the compiled-in default limit.

• sys.int_info.str_digits_check_threshold is the lowest accepted value for the limit (other than 0 which disables it).

Нове в версії 3.11.

Застереження

Setting a low limit can lead to problems. While rare, code exists that contains integer constants in decimal in their source that exceed the minimum threshold. A consequence of setting the limit is that Python source code containing decimal integer literals longer than the limit will encounter an error during parsing, usually at startup time or import time or even at installation time - anytime an up to date .pyc does not already exist for the code. A workaround for source that contains such large constants is to convert them to 0x hexadecimal form as it has no limit.

Test your application thoroughly if you use a low limit. Ensure your tests run with the limit set early via the environment or flag so that it applies during startup and even during any installation step that may invoke Python to precompile .py sources to .pyc files.

Recommended configuration

The default sys.int_info.default_max_str_digits is expected to be reasonable for most applications. If your application requires a different limit, set it from your main entry point using Python version agnostic code as these APIs were added in security patch releases in versions before 3.11.

Приклад:

>>> import sys
>>> if hasattr(sys, "set_int_max_str_digits"):
...     upper_bound = 68000
...     lower_bound = 4004
...     current_limit = sys.get_int_max_str_digits()
...     if current_limit == 0 or current_limit > upper_bound:
...         sys.set_int_max_str_digits(upper_bound)
...     elif current_limit < lower_bound:
...         sys.set_int_max_str_digits(lower_bound)

If you need to disable it entirely, set it to 0.

Виноски

[1]

Додаткову інформацію про ці спеціальні методи можна знайти в довідковому посібнику Python (Базове налаштування).

[2]

Як наслідок, список [1, 2] вважається рівним [1.0, 2.0], і аналогічно для кортежів.

[3]

Мабуть, оскільки аналізатор не може визначити тип операндів.

[4] (1,2,3,4)

Регістр символів — це символи загальної категорії, які мають одну з таких властивостей: «Lu» (літера, верхній регістр), «Ll» (літера, нижній регістр) або «Lt» (літера, регістр заголовка).

[5] (1,2)

Щоб відформатувати лише кортеж, ви повинні надати одиночний кортеж, єдиним елементом якого є кортеж, який потрібно відформатувати.