Wbudowane typy¶

The following sections describe the standard types that are built into the interpreter.

The principal built-in types are numerics, sequences, mappings, classes, instances and exceptions.

Some collection classes are mutable. The methods that add, subtract, or rearrange their members in place, and don’t return a specific item, never return the collection instance itself but None.

Some operations are supported by several object types; in particular, practically all objects can be compared for equality, tested for truth value, and converted to a string (with the repr() function or the slightly different str() function). The latter function is implicitly used when an object is written by the print() function.

Truth Value Testing¶

Any object can be tested for truth value, for use in an if or while condition or as operand of the Boolean operations below.

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
zero of any numeric type: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
empty sequences and collections: '', (), [], {}, set(), range(0)

Operations and built-in functions that have a Boolean result always return 0 or False for false and 1 or True for true, unless otherwise stated. (Important exception: the Boolean operations or and and always return one of their operands.)

Boolean Operations — `and`, `or`, `not`¶

These are the Boolean operations, ordered by ascending priority:

Operation	Result	Notatki
`x or y`	if x is true, then x, else y	(1)
`x and y`	if x is false, then x, else y	(2)
`not x`	if x is false, then `True`, else `False`	(3)

Uwagi:

This is a short-circuit operator, so it only evaluates the second argument if the first one is false.
This is a short-circuit operator, so it only evaluates the second argument if the first one is true.
not has a lower priority than non-Boolean operators, so not a == b is interpreted as not (a == b), and a == not b is a syntax error.

Comparisons¶

There are eight comparison operations in Python. They all have the same priority (which is higher than that of the Boolean operations). Comparisons can be chained arbitrarily; for example, x < y <= z is equivalent to x < y and y <= z, except that y is evaluated only once (but in both cases z is not evaluated at all when x < y is found to be false).

This table summarizes the comparison operations:

Operation	Znaczenie
`<`	strictly less than
`<=`	less than or equal
`>`	strictly greater than
`>=`	greater than or equal
`==`	equal
`!=`	not equal
`is`	object identity
`is not`	negated object identity

Objects of different types, except different numeric types, never compare equal. The == operator is always defined but for some object types (for example, class objects) is equivalent to is. The <, <=, > and >= operators are only defined where they make sense; for example, they raise a TypeError exception when one of the arguments is a complex number.

Non-identical instances of a class normally compare as non-equal unless the class defines the __eq__() method.

Instances of a class cannot be ordered with respect to other instances of the same class, or other types of object, unless the class defines enough of the methods __lt__(), __le__(), __gt__(), and __ge__() (in general, __lt__() and __eq__() are sufficient, if you want the conventional meanings of the comparison operators).

The behavior of the is and is not operators cannot be customized; also they can be applied to any two objects and never raise an exception.

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

Numeric Types — `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 fully supports mixed arithmetic: when a binary arithmetic operator has operands of different numeric types, the operand with the „narrower” type is widened to that of the other, where integer is narrower than floating point, which is narrower than complex. A comparison between numbers of different types behaves as though the exact values of those numbers were being compared. [2]

The constructors int(), float(), and complex() can be used to produce numbers of a specific type.

All numeric types (except complex) support the following operations (for priorities of the operations, see Operator precedence):

Operation	Result	Notatki	Full documentation
`x + y`	sum of x and y
`x - y`	difference of x and y
`x * y`	product of x and y
`x / y`	quotient of x and y
`x // y`	floored quotient of x and y	(1)(2)
`x % y`	remainder of `x / y`	(2)
`-x`	x negated
`+x`	x unchanged
`abs(x)`	absolute value or magnitude of x		`abs()`
`int(x)`	x converted to integer	(3)(6)	`int()`
`float(x)`	x converted to floating point	(4)(6)	`float()`
`complex(re, im)`	a complex number with real part re, imaginary part im. im defaults to zero.	(6)	`complex()`
`c.conjugate()`	conjugate of the complex number c
`divmod(x, y)`	the pair `(x // y, x % y)`	(2)	`divmod()`
`pow(x, y)`	x to the power y	(5)	`pow()`
`x ** y`	x to the power y	(5)

Uwagi:

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.
Not for complex numbers. Instead convert to floats using abs() if appropriate.
Conversion from float to int truncates, discarding the fractional part. See functions math.floor() and math.ceil() for alternative conversions.
float also accepts the strings „nan” and „inf” with an optional prefix „+” or „-” for Not a Number (NaN) and positive or negative infinity.
Python defines pow(0, 0) and 0 ** 0 to be 1, as is common for programming languages.
The numeric literals accepted include the digits 0 to 9 or any Unicode equivalent (code points with the Nd property).

See the Unicode Standard for a complete list of code points with the Nd property.

All numbers.Real types (int and float) also include the following operations:

Operation	Result
`math.trunc(x)`	x truncated to `Integral`
`round(x[, n])`	x rounded to n digits, rounding half to even. If n is omitted, it defaults to 0.
`math.floor(x)`	the greatest `Integral` <= x
`math.ceil(x)`	the least `Integral` >= x

For additional numeric operations see the math and cmath modules.

Bitwise Operations on Integer Types¶

Bitwise operations only make sense for integers. The result of bitwise operations is calculated as though carried out in two’s complement with an infinite number of sign bits.

The priorities of the binary bitwise operations are all lower than the numeric operations and higher than the comparisons; the unary operation ~ has the same priority as the other unary numeric operations (+ and -).

This table lists the bitwise operations sorted in ascending priority:

Operation	Result	Notatki
`x \| y`	bitwise or of x and y	(4)
`x ^ y`	bitwise exclusive or of x and y	(4)
`x & y`	bitwise and of x and y	(4)
`x << n`	x shifted left by n bits	(1)(2)
`x >> n`	x shifted right by n bits	(1)(3)
`~x`	the bits of x inverted

Uwagi:

Negative shift counts are illegal and cause a ValueError to be raised.
A left shift by n bits is equivalent to multiplication by pow(2, n).
A right shift by n bits is equivalent to floor division by pow(2, n).
Performing these calculations with at least one extra sign extension bit in a finite two’s complement representation (a working bit-width of 1 + max(x.bit_length(), y.bit_length()) or more) is sufficient to get the same result as if there were an infinite number of sign bits.

Additional Methods on Integer Types¶

The int type implements the numbers.Integral abstract base class. In addition, it provides a few more methods:

int.bit_length()¶

Return the number of bits necessary to represent an integer in binary, excluding the sign and leading zeros:

>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6

More precisely, if x is nonzero, then x.bit_length() is the unique positive integer k such that 2**(k-1) <= abs(x) < 2**k. Equivalently, when abs(x) is small enough to have a correctly rounded logarithm, then k = 1 + int(log(abs(x), 2)). If x is zero, then x.bit_length() returns 0.

Odpowiednik:

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

Dodane w wersji 3.1.

int.bit_count()¶

Return the number of ones in the binary representation of the absolute value of the integer. This is also known as the population count. Example:

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

Odpowiednik:

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

Dodane w wersji 3.10.

int.to_bytes(length=1, byteorder='big', *, signed=False)¶

Return an array of bytes representing an integer.

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

The signed argument determines whether two’s complement is used to represent the integer. If signed is False and a negative integer is given, an OverflowError is raised. The default value for signed is 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.

Odpowiednik:

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)

Dodane w wersji 3.2.

Zmienione w wersji 3.11: Added default argument values for length and byteorder.

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

Return the integer represented by the given array of bytes.

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

The argument bytes must either be a bytes-like object or an iterable producing 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. To request the native byte order of the host system, use sys.byteorder as the byte order value.

The signed argument indicates whether two’s complement is used to represent the integer.

Odpowiednik:

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

Dodane w wersji 3.2.

Zmienione w wersji 3.11: Added default argument value for byteorder.

int.as_integer_ratio()¶: Return a pair of integers whose ratio is equal to the original integer and has a positive denominator. The integer ratio of integers (whole numbers) is always the integer as the numerator and 1 as the denominator.

Dodane w wersji 3.8.

int.is_integer()¶: Returns True. Exists for duck type compatibility with float.is_integer().

Dodane w wersji 3.12.

Additional Methods on Float¶

The float type implements the numbers.Real abstract base class. float also has the following additional methods.

float.as_integer_ratio()¶: Return a pair of integers whose ratio is exactly equal to the original float. The ratio is in lowest terms and has a positive denominator. Raises OverflowError on infinities and a ValueError on NaNs.

float.is_integer()¶

Return True if the float instance is finite with integral value, and False otherwise:

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

Two methods support conversion to and from hexadecimal strings. Since Python’s floats are stored internally as binary numbers, converting a float to or from a decimal string usually involves a small rounding error. In contrast, hexadecimal strings allow exact representation and specification of floating-point numbers. This can be useful when debugging, and in numerical work.

float.hex()¶: Return a representation of a floating-point number as a hexadecimal string. For finite floating-point numbers, this representation will always include a leading 0x and a trailing p and exponent.

classmethod float.fromhex(s)¶: Class method to return the float represented by a hexadecimal string s. The string s may have leading and trailing whitespace.

Note that float.hex() is an instance method, while float.fromhex() is a class method.

A hexadecimal string takes the form:

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

where the optional sign may by either + or -, integer and fraction are strings of hexadecimal digits, and exponent is a decimal integer with an optional leading sign. Case is not significant, and there must be at least one hexadecimal digit in either the integer or the fraction. This syntax is similar to the syntax specified in section 6.4.4.2 of the C99 standard, and also to the syntax used in Java 1.5 onwards. In particular, the output of float.hex() is usable as a hexadecimal floating-point literal in C or Java code, and hexadecimal strings produced by C’s %a format character or Java’s Double.toHexString are accepted by float.fromhex().

Note that the exponent is written in decimal rather than hexadecimal, and that it gives the power of 2 by which to multiply the coefficient. For example, the hexadecimal string 0x3.a7p10 represents the floating-point number (3 + 10./16 + 7./16**2) * 2.0**10, or 3740.0:

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

Applying the reverse conversion to 3740.0 gives a different hexadecimal string representing the same number:

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

Hashing of numeric types¶

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.

Szczegół implementacyjny CPythona: Currently, the prime used is P = 2**31 - 1 on machines with 32-bit C longs and P = 2**61 - 1 on machines with 64-bit C longs.

Here are the rules in detail:

If x = m / n is a nonnegative rational number and n is not divisible by P, define hash(x) as m * invmod(n, P) % P, where invmod(n, P) gives the inverse of n modulo P.
If x = m / n is a nonnegative rational number and n is divisible by P (but m is not) then n has no inverse modulo P and the rule above doesn’t apply; in this case define hash(x) to be the constant value sys.hash_info.inf.
If x = m / n is a negative rational number define hash(x) as -hash(-x). If the resulting hash is -1, replace it with -2.
The particular values sys.hash_info.inf and -sys.hash_info.inf are used as hash values for positive infinity or negative infinity (respectively).
For a complex number z, the hash values of the real and imaginary parts are combined by computing hash(z.real) + sys.hash_info.imag * hash(z.imag), reduced modulo 2**sys.hash_info.width so that it lies in range(-2**(sys.hash_info.width - 1), 2**(sys.hash_info.width - 1)). Again, if the result is -1, it’s replaced with -2.

To clarify the above rules, here’s some example Python code, equivalent to the built-in hash, for computing the hash of a rational number, float, or 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

Boolean Type - `bool`¶

Booleans represent truth values. The bool type has exactly two constant instances: True and False.

The built-in function bool() converts any value to a boolean, if the value can be interpreted as a truth value (see section Truth Value Testing above).

For logical operations, use the boolean operators and, or and not. When applying the bitwise operators &, |, ^ to two booleans, they return a bool equivalent to the logical operations „and”, „or”, „xor”. However, the logical operators and, or and != should be preferred over &, | and ^.

Niezalecane od wersji 3.12: The use of the bitwise inversion operator ~ is deprecated and will raise an error in Python 3.16.

bool is a subclass of int (see Numeric Types — int, float, complex). In many numeric contexts, False and True behave like the integers 0 and 1, respectively. However, relying on this is discouraged; explicitly convert using int() instead.

Iterator Types¶

Python supports a concept of iteration over containers. This is implemented using two distinct methods; these are used to allow user-defined classes to support iteration. Sequences, described below in more detail, always support the iteration methods.

One method needs to be defined for container objects to provide iterable support:

container.__iter__()¶: Return an iterator object. The object is required to support the iterator protocol described below. If a container supports different types of iteration, additional methods can be provided to specifically request iterators for those iteration types. (An example of an object supporting multiple forms of iteration would be a tree structure which supports both breadth-first and depth-first traversal.) This method corresponds to the tp_iter slot of the type structure for Python objects in the Python/C API.

The iterator objects themselves are required to support the following two methods, which together form the iterator protocol:

iterator.__iter__()¶: Return the iterator object itself. This is required to allow both containers and iterators to be used with the for and in statements. This method corresponds to the tp_iter slot of the type structure for Python objects in the Python/C API.

iterator.__next__()¶: Return the next item from the iterator. If there are no further items, raise the StopIteration exception. This method corresponds to the tp_iternext slot of the type structure for Python objects in the Python/C API.

Python defines several iterator objects to support iteration over general and specific sequence types, dictionaries, and other more specialized forms. The specific types are not important beyond their implementation of the iterator protocol.

Once an iterator’s __next__() method raises StopIteration, it must continue to do so on subsequent calls. Implementations that do not obey this property are deemed broken.

Generator Types¶

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.

Sequence Types — `list`, `tuple`, `range`¶

There are three basic sequence types: lists, tuples, and range objects. Additional sequence types tailored for processing of binary data and text strings are described in dedicated sections.

Common Sequence Operations¶

The operations in the following table are supported by most sequence types, both mutable and immutable. The collections.abc.Sequence ABC is provided to make it easier to correctly implement these operations on custom sequence types.

This table lists the sequence operations sorted in ascending priority. In the table, s and t are sequences of the same type, n, i, j and k are integers and x is an arbitrary object that meets any type and value restrictions imposed by s.

The in and not in operations have the same priorities as the comparison operations. The + (concatenation) and * (repetition) operations have the same priority as the corresponding numeric operations. [3]

Operation	Result	Notatki
`x in s`	`True`, якщо елемент s дорівнює x, інакше `False`	(1)
`x not in s`	`False`, якщо елемент s дорівнює x, інакше `True`	(1)
`s + t`	конкатенація s і t	(6)(7)
`s * n` or `n * s`	еквівалентно додаванню s до самого себе n разів	(2)(7)
`s[i]`	iий елемент з s, джерело 0	(3)(8)
`s[i:j]`	фрагмент s від i до j	(3)(4)
`s[i:j:k]`	фрагмент s від i до j з кроком k	(3)(5)
`len(s)`	довжина s
`min(s)`	найменший елемент s
`max(s)`	найбільший предмет s

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

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

Uwagi:

У той час як операції in і not in використовуються лише для простого тестування локалізації в загальному випадку, деякі спеціалізовані послідовності (такі як str, bytes і bytearray) також використовуйте їх для тестування підпослідовності:
```
>>> "gg" in "eggs"
True
```
Значення 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]]
```
Подальші пояснення доступні в розділі поширених запитань Jak stworzyć listę wielowymiarową?.
Якщо i або j є від’ємними, індекс відноситься до кінця послідовності s: замінюється len(s) + i або len(s) + j. Але зауважте, що -0 все одно 0.
Зріз s від i до j визначається як послідовність елементів з індексом k, така що i <= k < j. Якщо i або j більше ніж len(s), використовуйте len(s). Якщо i пропущено або None, використовуйте 0. Якщо j пропущено або None, використовуйте len(s). Якщо i більше або дорівнює j, фрагмент порожній.
Зріз 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.
Конкатенація незмінних послідовностей завжди призводить до нового об’єкта. Це означає, що створення послідовності шляхом повторної конкатенації матиме квадратичну вартість виконання в загальній довжині послідовності. Щоб отримати лінійну вартість роботи, ви повинні перейти до однієї з наведених нижче альтернатив:
- якщо конкатенувати об’єкти str, ви можете створити список і використовувати str.join() наприкінці або записати в екземпляр io.StringIO і отримати його значення після завершення
- якщо конкатенація об’єктів bytes, ви можете так само використовувати bytes.join() або io.BytesIO, або ви можете виконати конкатенацію на місці з об’єктом bytearray. Об’єкти bytearray є змінними та мають ефективний механізм загального розподілу
- якщо конкатенація об’єктів tuple, замість цього розширте list
- для інших типів дослідіть відповідну документацію класу
Деякі типи послідовностей (наприклад, range) підтримують лише послідовності елементів, які відповідають певним шаблонам, і, отже, не підтримують конкатенацію або повторення послідовності.
Uma IndexError é levantada se i estiver fora do intervalo da sequência.

Sequence Methods

Sequence types also support the following methods:

sequence.count(value, /)¶: Return the total number of occurrences of value in sequence.

sequence.index(value[, start[, stop])¶

Return the index of the first occurrence of value in sequence.

Raises ValueError if value is not found in sequence.

The start or stop arguments allow for efficient searching of subsections of the sequence, beginning at start and ending at stop. This is roughly equivalent to start + sequence[start:stop].index(value), only without copying any data.

Ostrzeżenie

Not all sequence types support passing the start and stop arguments.

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

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

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

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

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

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

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

Operation	Result	Notatki
`s[i] = x`	пункт i з s замінено на x
`del s[i]`	remove o item i de s
`s[i:j] = t`	фрагмент s від i до j замінюється вмістом ітерованого t
`del s[i:j]`	removes the elements of `s[i:j]` from the list (same as `s[i:j] = []`)
`s[i:j:k] = t`	елементи `s[i:j:k]` замінюються на елементи t	(1)
`del s[i:j:k]`	видаляє елементи `s[i:j:k]` зі списку
`s += t`	розширює s вмістом t (здебільшого те саме, що `s[len(s):len(s)] = t`)
`s *= n`	оновлює s з повторенням його вмісту n разів	(2)

Uwagi:

Если k не равно 1 , t должно иметь ту же длину, что и заменяемый фрагмент.
Значення n є цілим числом або об’єктом, що реалізує __index__(). Нульові та негативні значення n очищають послідовність. Елементи послідовності не копіюються; на них посилаються кілька разів, як пояснюється для s * n у Common Sequence Operations.

Mutable Sequence Methods

Mutable sequence types also support the following methods:

sequence.append(value, /)¶: Append value to the end of the sequence This is equivalent to writing seq[len(seq):len(seq)] = [value].

sequence.clear()¶: Dodane w wersji 3.3.

Remove all items from sequence. This is equivalent to writing del sequence[:].

sequence.copy()¶: Dodane w wersji 3.3.

Create a shallow copy of sequence. This is equivalent to writing sequence[:].

Podpowiedź

The copy() method is not part of the MutableSequence ABC, but most concrete mutable sequence types provide it.

sequence.extend(iterable, /)¶: Extend sequence with the contents of iterable. For the most part, this is the same as writing seq[len(seq):len(seq)] = iterable.

sequence.insert(index, value, /)¶: Insert value into sequence at the given index. This is equivalent to writing sequence[index:index] = [value].

sequence.pop(index=-1, /)¶: Retrieve the item at index and also removes it from sequence. By default, the last item in sequence is removed and returned.

sequence.remove(value, /)¶

Remove the first item from sequence where sequence[i] == value.

Raises ValueError if value is not found in sequence.

sequence.reverse()¶: Reverse the items of sequence in place. This method maintains economy of space when reversing a large sequence. To remind users that it operates by side-effect, it returns None.

Listy¶

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

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 jest wartością logiczną. Jeśli jest ustawiona na True, elementy listy są sortowane tak, jakby każde porównanie było odwrócone.

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

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

Przykłady sortowania i krótki samouczek sortowania można znaleźć na stronie Sorting Techniques.

Поки список сортується, ефект від спроби змінити або навіть перевірити список не визначено. Реалізація Python на C робить список порожнім протягом певного часу та викликає ValueError, якщо він може виявити, що список було змінено під час сортування.

Tuples¶

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

class tuple(iterable=(), /)¶

Krotki mogą być konstruowane na kilka sposobów:

Przy użyciu pary nawiasów, by oznaczyć pustą krotkę: ()
Przy użyciu przecinka, by oznaczyć jednoelementową krotkę: a, lub (a,)
Розділення елементів комами: a, b, c або (a, b, c)
Przy użyciu wbudowanej funkcji tuple(): tuple() lub 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=1, /)

Аргументи конструктора діапазону мають бути цілими числами (або вбудованим 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 і надають такі функції, як тести на обмеження, пошук індексу елемента, нарізка та підтримка негативних індексів (див. Sequence Types — 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).)

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

Zmienione w wersji 3.3: Визначте „==” і „!=”, щоб порівнювати об’єкти діапазону на основі послідовності значень, які вони визначають (замість порівняння на основі ідентичності об’єкта).

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

Zobacz także

Рецепт линспейса <https://code.activestate.com/recipes/579000-equally-spaced-numbers-linspace/>`_ показывает, как реализовать ленивую версию диапазона, подходящую для приложений с плавающей запятой.

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

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

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

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

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

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

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

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

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

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

class str(*, encoding='utf-8', errors='strict')¶

class str(object)

class str(object, encoding, errors='strict')

class str(object, *, errors)

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

Если не указано ни кодирование, ни ошибки, str(объект) возвращает type(объект).__str__(объект) , который является «неформальным» или удобным для печати строковым представлением object. Для строковых объектов это сама строка. Если объект не имеет __str__() метод, тогда str() возвращается к возврату :func:`repr(object) `.

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

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

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

Додаткову інформацію про клас str і його методи див. у розділі Тип текстової послідовності — str і Metody ciągów нижче. Щоб вивести форматовані рядки, перегляньте розділи f-strings і Синтаксис рядка формату. Крім того, перегляньте розділ Usługi przetwarzania tekstu.

Metody ciągów¶

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

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

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

str.capitalize()¶: Повертає копію рядка з великим першим символом, а решта малими.

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

str.casefold()¶

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

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

The casefolding algorithm is described in section 3.13 «Default Case Folding» of the Unicode Standard.

Dodane w wersji 3.3.

str.center(width, fillchar=' ', /)¶

Retorna um texto centralizado em uma string de comprimento width. Preenchimento é feito usando o parâmetro fillchar especificado (padrão é o caractere de espaço ASCII). A string original é retornada se width é menor ou igual que len(s). Por exemplo:

>>> 'Python'.center(10)
'  Python  '
>>> 'Python'.center(10, '-')
'--Python--'
>>> 'Python'.center(4)
'Python'

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

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

Se sub estiver vazio, retorna o número de strings vazias entre os caracteres, que é o comprimento da string mais um. Por exemplo:

>>> 'spam, spam, spam'.count('spam')
3
>>> 'spam, spam, spam'.count('spam', 5)
2
>>> 'spam, spam, spam'.count('spam', 5, 10)
1
>>> 'spam, spam, spam'.count('eggs')
0
>>> 'spam, spam, spam'.count('')
17

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

Вернуть строку, закодированную в байты .

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

errors управляет обработкой ошибок кодирования. Если 'строгий' (по умолчанию), а UnicodeError возникает исключение. Другие возможные значения: 'игнорировать' , 'заменить' , 'xmlcharrefreplace' , 'обратная косая черта' и любое другое имя, зарегистрированное через codecs.register_error() . Видеть обработчики ошибок для получения подробной информации.

Por motivos de desempenho, o valor de errors não é verificado quanto à validade, a menos que um erro de codificação realmente ocorra, Python Development Mode esteja ativado ou uma construção de depuração seja usada. Por exemplo:

>>> encoded_str_to_bytes = 'Python'.encode()
>>> type(encoded_str_to_bytes)
<class 'bytes'>
>>> encoded_str_to_bytes
b'Python'

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

Zmienione w wersji 3.9: Значение аргумента errors теперь проверяется. Python Development Mode и в :ref:`режиме отладки `.

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

Retorna True se a string terminar com o suffix especificado, caso contrário retorna False. suffix também pode ser uma tupla de sufixos para procurar. Com o parâmetro opcional start, começamos a testar a partir daquela posição. Com o parâmetro opcional end, devemos parar de comparar na posição especificada. Usar start e end equivale a str[start:end].endswith(suffix). Por exemplo:

>>> 'Python'.endswith('on')
True
>>> 'a tuple of suffixes'.endswith(('at', 'in'))
False
>>> 'a tuple of suffixes'.endswith(('at', 'es'))
True
>>> 'Python is amazing'.endswith('is', 0, 9)
True

Veja também startswith() e removesuffix().

str.expandtabs(tabsize=8)¶

Retorna uma cópia da string onde todos os caracteres de tabulação são substituídos por um ou mais espaços, dependendo da coluna atual e do tamanho fornecido para a tabulação. Posições de tabulação ocorrem a cada tabsize caracteres (o padrão é 8, dada as posições de tabulação nas colunas 0, 8, 16 e assim por diante). Para expandir a string, a coluna atual é definida como zero e a string é examinada caractere por caractere. Se o caractere é uma tabulação (\t), um ou mais caracteres de espaço são inseridos no resultado até que a coluna atual seja igual a próxima posição de tabulação. (O caractere de tabulação em si não é copiado.) Se o caractere é um caractere de nova linha (\n) ou de retorno (\r), ele é copiado e a coluna atual é redefinida para zero. Qualquer outro caractere é copiado sem ser modificado e a coluna atual é incrementada em uma unidade independentemente de como o caractere é representado quando é impresso. Por exemplo:

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

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

Return the lowest index in the string where substring sub is found within the slice s[start:end]. Optional arguments start and end are interpreted as in slice notation. Return -1 if sub is not found. For example:

>>> 'spam, spam, spam'.find('sp')
0
>>> 'spam, spam, spam'.find('sp', 5)
6

Strings literais formatadas (f-strings)¶

Dodane w wersji 3.6.

Zmienione w wersji 3.7: await e async for podem ser usados em expressões dentro de f-strings.

Zmienione w wersji 3.8: Adicionado o operador de depuração (=)

Zmienione w wersji 3.12: Muitas restrições a expressões dentro de f-strings foram removidas. Notavelmente, strings aninhadas, comentários e contrabarras agora são permitidos.

Uma f-string (formalmente uma literal de string formatada) é uma literal de string prefixada com f ou F. Esse tipo de literal de string permite incorporar expressões Python arbitrárias dentro de campos de substituição, delimitados por chaves ({}). Essas expressões são avaliadas em tempo de execução, de forma semelhante a str.format(), e convertidas em objetos str regulares. Por exemplo:

>>> who = 'Ninguém'
>>> nationality = 'Espanhola'
>>> f'{who.title()} está à espera da Inquisição {nationality}!'
'Ninguém está à espera da Inquisição Espanhola!'

Também é possível usar uma f-string de várias linhas:

>>> f'''Esta é uma string
... em duas linhas'''
'Esta é uma string\nem duas linhas'

Uma única chave de abertura, '{', marca um campo de substituição que pode conter qualquer expressão Python:

>>> nationality = 'Espanhola'
>>> f'A Inquisição {nationality}!'
'A Inquisição Espanhola!'

Para incluir um literal { ou }, use chaves duplas:

>>> x = 42
>>> f'{{x}} is {x}'
'{x} is 42'

Funções também podem ser usadas, como especificadores de formato:

>>> from math import sqrt
>>> f'√2 \N{ALMOST EQUAL TO} {sqrt(2):.5f}'
'√2 ≈ 1.41421'

Qualquer expressão que não seja string é convertida usando str(), por padrão:

>>> from fractions import Fraction
>>> f'{Fraction(1, 3)}'
'1/3'

Para usar uma conversão explícita, use o operador ! (ponto de exclamação), seguido por qualquer um dos formatos válidos, que são:

Перетворення	Znaczenie
`!a`	`ascii()`
`!r`	`repr()`
`!s`	`str()`

Na przykład:

>>> from fractions import Fraction
>>> f'{Fraction(1, 3)!s}'
'1/3'
>>> f'{Fraction(1, 3)!r}'
'Fraction(1, 3)'
>>> question = '¿Dónde está el Presidente?'
>>> print(f'{question!a}')
'\xbfD\xf3nde est\xe1 el Presidente?'

Durante a depuração, pode ser útil visualizar tanto a expressão quanto seu valor, usando o sinal de igual (=) após a expressão. Isso preserva os espaços entre chaves e pode ser usado com um conversor. Por padrão, o operador de depuração usa a conversão repr() (!r). Por exemplo:

>>> from fractions import Fraction
>>> calculation = Fraction(1, 3)
>>> f'{calculation=}'
'calculation=Fraction(1, 3)'
>>> f'{calculation = }'
'calculation = Fraction(1, 3)'
>>> f'{calculation = !s}'
'calculation = 1/3'

Após a avaliação da saída, ela pode ser formatada usando um especificador de formato seguido de dois pontos (':'). Após a avaliação da expressão e sua possível conversão para uma string, o método __format__() do resultado é chamado com o especificador de formato, ou a string vazia, caso nenhum especificador de formato seja fornecido. O resultado formatado é então usado como o valor final para o campo de substituição. Por exemplo:

>>> from fractions import Fraction
>>> f'{Fraction(1, 7):.6f}'
'0.142857'
>>> f'{Fraction(1, 7):_^+10}'
'___+1/7___'

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

Informacja

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

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

>>> print('%s has %d quote types.' % ('Python', 2))
Python has 2 quote types.

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

A conversion specifier contains two or more characters and has the following components, which must occur in this order:

The '%' character, which marks the start of the specifier.
Ключ відображення (необов’язковий), що складається з послідовності символів у дужках (наприклад, (якесь ім’я)).
Conversion flags (optional), which affect the result of some conversion types.
Мінімальна ширина поля (опціонально). Якщо вказано як '*' (зірочка), фактична ширина зчитується з наступного елемента кортежу в значеннях, а об’єкт для перетворення йде після мінімальної ширини поля та необов’язкової точності.
Точність (необов’язкова), подається як '.' (крапка), за якою йде точність. Якщо вказано як '*' (зірочка), фактична точність зчитується з наступного елемента кортежу в значеннях, а значення для перетворення йде після точності.
Length modifier (optional).
Conversion type.

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

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

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

The conversion flag characters are:

Flag	Znaczenie
`'#'`	Перетворення значень використовуватиме „альтернативну форму” (де визначено нижче).
`'0'`	The conversion will be zero padded for numeric values.
`'-'`	Перетворене значення коригується зліва (перевизначає перетворення `'0'`, якщо подано обидва значення).
`' '`	(пробіл) Пробіл слід залишити перед додатним числом (або порожнім рядком), утвореним перетворенням зі знаком.
`'+'`	Символ знака (`'+'` або `'-'`) передуватиме перетворенню (перевизначає позначку „пробіл”).

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

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

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

Uwagi:

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

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

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

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

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

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

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

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

Bytes Objects¶

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

class bytes(source=b'')¶

class bytes(source, encoding, errors='strict')

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

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

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

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

У той час як байтові літерали та представлення базуються на тексті 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'

Zmienione w wersji 3.7: bytes.fromhex() тепер пропускає всі пробіли ASCII у рядку, а не лише пробіли.

Існує функція зворотного перетворення для перетворення об’єкта байтів у його шістнадцяткове представлення.

hex(*, bytes_per_sep=1)¶

hex(sep, bytes_per_sep=1)

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

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

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

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

Dodane w wersji 3.5.

Zmienione w wersji 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).

Bayt dizisi Nesneleri¶

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

class bytearray(source=b'')¶

class bytearray(source, encoding, errors='strict')

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

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

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

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

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

classmethod fromhex(string, /)¶

Цей метод класу bytearray повертає об’єкт bytearray, декодуючи заданий рядковий об’єкт. Рядок має містити дві шістнадцяткові цифри на байт, при цьому пробіли ASCII ігноруються.

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

Zmienione w wersji 3.7: bytearray.fromhex() тепер пропускає всі пробіли ASCII у рядку, а не лише пробіли.

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

hex(*, bytes_per_sep=1)¶

hex(sep, bytes_per_sep=1)

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

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

Dodane w wersji 3.5.

Zmienione w wersji 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).

Baytlar ve Bayt dizisi İşlemleri¶

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

Informacja

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

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

dan:

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

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

Informacja

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

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

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

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

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

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

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

Zmienione w wersji 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.

Informacja

Versi bytearray dari metode ini tidak beroperasi di tempatnya - selalu menghasilkan objek baru, bahkan jika tidak ada perubahan yang dilakukan.

Dodane w wersji 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.

Informacja

Versi bytearray dari metode ini tidak beroperasi di tempatnya - selalu menghasilkan objek baru, bahkan jika tidak ada perubahan yang dilakukan.

Dodane w wersji 3.9.

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

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

Вернуть декодированные байты в str .

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

errors управляет обработкой ошибок декодирования. Если 'строгий' (по умолчанию), а UnicodeError возникает исключение. Другие возможные значения: 'игнорировать' , 'заменить' и любое другое имя, зарегистрированное через codecs.register_error() . Видеть обработчики ошибок для получения подробной информации.

По соображениям производительности значение errors не проверяется на достоверность, если только не возникает ошибка декодирования. Python Development Mode включен или имеется :ref:`отладочная сборка ` используется.

Informacja

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

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

Zmienione w wersji 3.9: Значение аргумента errors теперь проверяется. Python Development Mode и в :ref:`режиме отладки `.

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.

Informacja

Метод find() слід використовувати, лише якщо вам потрібно знати позицію sub. Щоб перевірити, чи є sub підрядком, скористайтеся оператором in:

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

Zmienione w wersji 3.3: Також прийняти ціле число в діапазоні від 0 до 255 як підпослідовність.

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

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

Як find(), але викликає ValueError, коли підпослідовність не знайдено.

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

Zmienione w wersji 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 мають бути байтоподібними об’єктами і мати однакову довжину.

Dodane w wersji 3.1.

bytes.partition(sep, /)¶

bytearray.partition(sep, /)¶

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

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

bytes.replace(old, new, count=-1, /)¶

bytearray.replace(old, new, count=-1, /)¶

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

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

Informacja

Versi bytearray dari metode ini tidak beroperasi di tempatnya - selalu menghasilkan objek baru, bahkan jika tidak ada perubahan yang dilakukan.

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

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

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

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

Zmienione w wersji 3.3: Також прийняти ціле число в діапазоні від 0 до 255 як підпослідовність.

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

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

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

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

Zmienione w wersji 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'

Zmienione w wersji 3.6: delete тепер підтримується як аргумент ключового слова.

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

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

Informacja

Versi bytearray dari metode ini tidak beroperasi di tempatnya - selalu menghasilkan objek baru, bahkan jika tidak ada perubahan yang dilakukan.

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

Informacja

Versi bytearray dari metode ini tidak beroperasi di tempatnya - selalu menghasilkan objek baru, bahkan jika tidak ada perubahan yang dilakukan.

bytes.lstrip(bytes=None, /)¶

bytearray.lstrip(bytes=None, /)¶

Return a copy of the sequence with specified leading bytes removed. The bytes argument is a binary sequence specifying the set of byte values to be removed. If omitted or None, the bytes argument defaults to removing ASCII whitespace. The bytes argument is not a prefix; rather, all combinations of its values are stripped:

>>> 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!'

Informacja

Versi bytearray dari metode ini tidak beroperasi di tempatnya - selalu menghasilkan objek baru, bahkan jika tidak ada perubahan yang dilakukan.

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

Informacja

Versi bytearray dari metode ini tidak beroperasi di tempatnya - selalu menghasilkan objek baru, bahkan jika tidak ada perubahan yang dilakukan.

bytes.rsplit(sep=None, maxsplit=-1)¶
bytearray.rsplit(sep=None, maxsplit=-1)¶: Розділіть бінарну послідовність на підпослідовності одного типу, використовуючи sep як рядок-роздільник. Якщо задано maxsplit, виконується щонайбільше maxsplit розбиття, найправіші. Якщо sep не вказано або None, будь-яка підпослідовність, що складається виключно з пробілів ASCII, є роздільником. За винятком розділення справа, rsplit() поводиться як split(), що детально описано нижче.

bytes.rstrip(bytes=None, /)¶

bytearray.rstrip(bytes=None, /)¶

Return a copy of the sequence with specified trailing bytes removed. The bytes argument is a binary sequence specifying the set of byte values to be removed. If omitted or None, the bytes argument defaults to removing ASCII whitespace. The bytes argument is not a suffix; rather, all combinations of its values are stripped:

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

Informacja

Versi bytearray dari metode ini tidak beroperasi di tempatnya - selalu menghasilkan objek baru, bahkan jika tidak ada perubahan yang dilakukan.

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

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

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

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

Dla przykładu:

>>> 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'']
>>> b'1<>2<>3<4'.split(b'<>')
[b'1', b'2', b'3<4']

Якщо sep не вказано або має значення None, застосовується інший алгоритм поділу: цикли послідовних пробілів ASCII розглядаються як один роздільник, і результат не міститиме порожніх рядків на початку або в кінці, якщо послідовність має пробіли на початку або в кінці. Отже, розділення порожньої послідовності або послідовності, що складається виключно з пробілів ASCII без указаного роздільника, повертає [].

Dla przykładu:

>>> 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(bytes=None, /)¶

bytearray.strip(bytes=None, /)¶

Return a copy of the sequence with specified leading and trailing bytes removed. The bytes argument is a binary sequence specifying the set of byte values to be removed. If omitted or None, the bytes argument defaults to removing ASCII whitespace. The bytes argument is not a prefix or suffix; rather, all combinations of its values are stripped:

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

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

Informacja

Versi bytearray dari metode ini tidak beroperasi di tempatnya - selalu menghasilkan objek baru, bahkan jika tidak ada perubahan yang dilakukan.

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

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

Informacja

Versi bytearray dari metode ini tidak beroperasi di tempatnya - selalu menghasilkan objek baru, bahkan jika tidak ada perubahan yang dilakukan.

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'

Informacja

Versi bytearray dari metode ini tidak beroperasi di tempatnya - selalu menghasilkan objek baru, bahkan jika tidak ada perubahan yang dilakukan.

bytes.isalnum()¶

bytearray.isalnum()¶

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

Dla przykładu:

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

bytes.isalpha()¶

bytearray.isalpha()¶

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

Dla przykładu:

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

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

Dodane w wersji 3.7.

bytes.isdigit()¶

bytearray.isdigit()¶

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

Dla przykładu:

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

bytes.islower()¶

bytearray.islower()¶

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

Dla przykładu:

>>> 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(), щоб дізнатися більше про визначення „заголовка”.

Dla przykładu:

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

bytes.isupper()¶

bytearray.isupper()¶

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

Dla przykładu:

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

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

bytes.lower()¶

bytearray.lower()¶

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

Dla przykładu:

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

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

Informacja

Versi bytearray dari metode ini tidak beroperasi di tempatnya - selalu menghasilkan objek baru, bahkan jika tidak ada perubahan yang dilakukan.

bytes.splitlines(keepends=False)¶

bytearray.splitlines(keepends=False)¶

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

Dla przykładu:

>>> 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, перетвореними на їхні відповідні відповідники у верхньому регістрі та навпаки.

Dla przykładu:

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

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

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

Informacja

Versi bytearray dari metode ini tidak beroperasi di tempatnya - selalu menghasilkan objek baru, bahkan jika tidak ada perubahan yang dilakukan.

bytes.title()¶

bytearray.title()¶

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

Dla przykładu:

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

Informacja

Versi bytearray dari metode ini tidak beroperasi di tempatnya - selalu menghasilkan objek baru, bahkan jika tidak ada perubahan yang dilakukan.

bytes.upper()¶

bytearray.upper()¶

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

Dla przykładu:

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

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

Informacja

Versi bytearray dari metode ini tidak beroperasi di tempatnya - selalu menghasilkan objek baru, bahkan jika tidak ada perubahan yang dilakukan.

bytes.zfill(width, /)¶

bytearray.zfill(width, /)¶

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

Dla przykładu:

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

Informacja

Versi bytearray dari metode ini tidak beroperasi di tempatnya - selalu menghasilkan objek baru, bahkan jika tidak ada perubahan yang dilakukan.

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

Informacja

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

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

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

A conversion specifier contains two or more characters and has the following components, which must occur in this order:

The '%' character, which marks the start of the specifier.
Ключ відображення (необов’язковий), що складається з послідовності символів у дужках (наприклад, (якесь ім’я)).
Conversion flags (optional), which affect the result of some conversion types.
Мінімальна ширина поля (опціонально). Якщо вказано як '*' (зірочка), фактична ширина зчитується з наступного елемента кортежу в значеннях, а об’єкт для перетворення йде після мінімальної ширини поля та необов’язкової точності.
Точність (необов’язкова), подається як '.' (крапка), за якою йде точність. Якщо вказано як '*' (зірочка), фактична точність зчитується з наступного елемента кортежу в значеннях, а значення для перетворення йде після точності.
Length modifier (optional).
Conversion type.

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

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

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

The conversion flag characters are:

Flag	Znaczenie
`'#'`	Перетворення значень використовуватиме „альтернативну форму” (де визначено нижче).
`'0'`	The conversion will be zero padded for numeric values.
`'-'`	Перетворене значення коригується зліва (перевизначає перетворення `'0'`, якщо подано обидва значення).
`' '`	(пробіл) Пробіл слід залишити перед додатним числом (або порожнім рядком), утвореним перетворенням зі знаком.
`'+'`	Символ знака (`'+'` або `'-'`) передуватиме перетворенню (перевизначає позначку „пробіл”).

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

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

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

Uwagi:

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

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

Точність визначає кількість значущих цифр до та після десяткової коми та за умовчанням дорівнює 6.
Якщо точність N, вивід скорочується до N символів.
b'%s є застарілим, але не буде видалено протягом серії 3.x.
b'%r'' є застарілим, але не буде видалено протягом серії 3.x.
Zob. PEP 237.

Informacja

Versi bytearray dari metode ini tidak beroperasi di tempatnya - selalu menghasilkan objek baru, bahkan jika tidak ada perubahan yang dilakukan.

Zobacz także

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

Dodane w wersji 3.5.

Bellek Görünümleri¶

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

class memoryview(object)¶

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

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

лен(просмотр) равна длине tolist , который представляет собой вложенный список представления. Если view.ndim = 1 , это равно количеству элементов в представлении.

Zmienione w wersji 3.12: Если view.ndim == 0 , лен(просмотр) теперь поднимает TypeError вместо возврата 1.

The itemsize Атрибут даст вам количество байтов в одном элементе.

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

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

Якщо format є одним із власних специфікаторів формату з модуля struct, індексація за допомогою цілого числа або кортежу цілих чисел також підтримується та повертає один елемент із правильним типом . Одновимірні представлення пам’яті можна індексувати за допомогою цілого або одноцілого кортежу. Багатовимірні представлення пам’яті можна індексувати за допомогою кортежів з точно 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')

Одномерные представления памяти типов hashable (только для чтения) с форматами «B», «b» или «c» также являются хэшируемыми. Хэш определяется как хэш(m) == хэш(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

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

Zmienione w wersji 3.4: memoryview тепер автоматично реєструється в collections.abc.Sequence

Zmienione w wersji 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

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

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

tobytes(order='C')¶

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

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

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

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

hex(*, bytes_per_sep=1)¶

hex(sep, bytes_per_sep=1)

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

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

Dodane w wersji 3.5.

Zmienione w wersji 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]

Zmienione w wersji 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]

Dodane w wersji 3.8.

release()¶

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

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

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

Dodane w wersji 3.2.

cast(format, /)¶

cast(format, shape, /)

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

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

Перетворення 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]]

Dodane w wersji 3.3.

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

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

obj¶

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

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

Dodane w wersji 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

Çok-boyutlu diziler:

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

Dodane w wersji 3.3.

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

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

Zmienione w wersji 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-вимірного масиву.

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

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

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

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

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

Dodane w wersji 3.3.

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

Dodane w wersji 3.3.

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

Dodane w wersji 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()¶: Tüm öğeleri kümeden çıkarın.

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

Обратите внимание, что аргумент elem для __contains__() , удалить() , и выбросить() методы могут быть набором. Для поддержки поиска эквивалентного замороженного набора из elem создается временный набор.

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

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

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

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)

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

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

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

Dicionários são iguais se e somente se eles os mesmos pares (key, value) (independente de ordem). Comparações de ordem («<», «<=», «>=», «>») levantam TypeError. Para ilustrar a criação e igualdade de dicionários, os exemplos a seguir retornam um dicionário igual a {"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. В іншому випадку можна використовувати будь-які дійсні ключі.

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

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

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

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

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=None, /)¶

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

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

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

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

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

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

popitem()¶

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

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

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

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

Dodane w wersji 3.8.

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

update(**kwargs)¶

update(mapping, /, **kwargs)

update(iterable, /, **kwargs)

Update the dictionary with the key/value pairs from mapping or iterable and kwargs, overwriting existing keys. Return None.

update() принимает либо другой объект с методом keys() (в этом случае __getitem__() вызывается с каждым ключом, возвращаемым из метода), либо итерацию ключа/значения пары (как кортежи или другие итерации длины два). Если указаны аргументы ключевого слова, словарь затем обновляется этими парами ключ/значение: 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 мають спільні ключі.

Dodane w wersji 3.9.

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

Dodane w wersji 3.9.

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

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

Zmienione w wersji 3.8: Словники тепер оборотні.

Zobacz także

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 або не вдається виконати ітерацію по всіх записах.

Zmienione w wersji 3.7: Порядок словника гарантовано буде порядком вставки.

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

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

Zmienione w wersji 3.8: Перегляди словника тепер оборотні.

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

Dodane w wersji 3.10.

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

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

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

Bağlam Yöneticisi Türleri¶

Оператор 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.

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

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

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

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

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

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

Genel Takma Ad Türü¶

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

Informacja

Як правило, індекс класу можливий, лише якщо клас реалізує спеціальний метод __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]

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

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

Спеціальні атрибути об’єктів `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,)

Informacja

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

genericalias.__unpacked__¶: Логическое значение, имеющее значение true, если псевдоним был распакован с помощью * оператор (см. TypeVarTuple ).

Dodane w wersji 3.11.

Zobacz także

PEP 484 - Type Hints: Представляємо структуру Python для анотацій типів.
PEP 585 - Type Hinting Generics In Standard Collections: Представляємо можливість нативної параметризації класів стандартної бібліотеки, якщо вони реалізують спеціальний метод класу __class_getitem__().
Generics, визначені користувачем узагальнення і typing.Generic: Documentation on how to implement generic classes that can be parameterized at runtime and understood by static type-checkers.

Dodane w wersji 3.9.

Тип союзу¶

A union object holds the value of the | (bitwise or) operation on multiple type objects. These types are intended primarily for type annotations. The union type expression enables cleaner type hinting syntax compared to 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

Informacja

The | операнд нельзя использовать во время выполнения для определения объединений, в которых один или несколько членов являются прямой ссылкой. Например, интервал | "Фу" , где "Фу" является ссылкой на еще не определенный класс, произойдет сбой во время выполнения. Для объединений, которые включают прямые ссылки, представьте все выражение в виде строки, например "int | Фу" .

union_object == other

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

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

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

Зайві типи видаляються:
```
int | str | int == int | str
```
Під час порівняння об’єднань порядок ігнорується:
```
int | str == str | int
```
It is compatible with 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

Однако :ref:`параметризованные дженерики ` в объектах объединения невозможно проверить:

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

The user-exposed type for the union object can be accessed from types.UnionType and used for isinstance() checks. An object cannot be instantiated from the type:

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

Informacja

The __or__() добавлен метод для объектов типа для поддержки синтаксиса `` Х | И `` . Если метакласс реализует __or__() , Союз может отменить это:

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

Zobacz także

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

Dodane w wersji 3.10.

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

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

Moduły¶

Єдиною спеціальною операцією над модулем є доступ до атрибутів: 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'>.

Sınıflar ve Sınıf Örnekleri¶

Перегляньте Objects, values and types і Class definitions для них.

Zadania¶

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

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

Перегляньте Function definitions для отримання додаткової інформації.

Methods¶

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.

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

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

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

Видеть методы экземпляра для получения дополнительной информации.

Code Objects¶

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

Доступ __code__ вызывает событие аудита ` ``object.__getattr__` с аргументами объект и "__code__" .

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

Перегляньте The standard type hierarchy для отримання додаткової інформації.

Type Objects¶

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

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

Boş Nesne¶

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

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

Об’єкт „Еліпсис”.¶

This object is commonly used used to indicate that something is omitted. It supports no special operations. There is exactly one ellipsis object, named Ellipsis (a built-in name). type(Ellipsis)() produces the Ellipsis singleton.

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

In typical use, ... as the Ellipsis object appears in a few different places, for instance:

In type annotations, such as callable arguments or tuple elements.
As the body of a function instead of a pass statement.
In third-party libraries, such as Numpy’s slicing and striding.

Python also uses three dots in ways that are not Ellipsis objects, for instance:

Doctest’s ELLIPSIS, as a pattern for missing content.
The default Python prompt of the interactive shell when partial input is incomplete.

Lastly, the Python documentation often uses three dots in conventional English usage to mean omitted content, even in code examples that also use them as the Ellipsis.

Об’єкт NotImplemented¶

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

Это написано как Нереализован .

Dahili Nesneler¶

Видеть типы для этой информации. Он описывает объекты фрейма стека. , :ref:`объекты трассировки и нарезать объекты.

Atribut Spesial¶

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

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

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

Dodane w wersji 3.3.

definition.__module__¶: Имя модуля, в котором был определен класс или функция.

definition.__doc__¶: Строка документации класса или функции или None, если она не определена.

definition.__type_params__¶: Параметры типа универсальных классов, функций и псевдонимов типов. Для классов и функций, которые не являются универсальными, это будет пустой кортеж.

Dodane w wersji 3.12.

Ограничение длины преобразования целочисленной строки¶

CPython имеет глобальное ограничение на преобразование между :класс:`int` и str для смягчения атак типа «отказ в обслуживании». Это ограничение только применяется к десятичным или другим системам счисления, отличным от степени двойки. Шестнадцатеричные, восьмеричные и двоичные преобразования не ограничены. Лимит можно настроить.

The :класс:`int` тип в CPython — это число произвольной длины, хранящееся в двоичной форме (широко известное как «bignum»). Не существует алгоритма, который мог бы преобразовать строку в двоичное целое число или двоичное целое число в строку за линейное время, если только основание не является степенью 2. Даже самые известные алгоритмы для основания 10 имеют субквадратическую сложность. Преобразование большого значения, например int('1' * 500_000) может занять больше секунды на быстром процессоре.

Ограничение размера конверсии предлагает практический способ избежать CVE 2020-10735 .

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

Если операция превысит лимит, ValueError поднят:

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

Ограничение по умолчанию составляет 4300 цифр, как указано в sys.int_info.default_max_str_digits. . Самый низкий предел, который можно настроить, составляет 640 цифр, как указано в sys.int_info.str_digits_check_threshold. .

Верификация:

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

Dodane w wersji 3.11.

Затронутые API¶

Ограничение применяется только к потенциально медленным преобразованиям между :класс:`int` и str или байты :

int(строка) с базой по умолчанию 10.
int(строка, база) для всех оснований, не являющихся степенью 2.
str(integer).
repr(integer).
любое другое преобразование строк в базу 10, например f"{integer}" , "{}".format(целое число) , или b"%d" % целое число .

Ограничения не распространяются на функции с линейным алгоритмом:

int(строка, база) с основанием 2, 4, 8, 16 или 32.
int.from_bytes() и int.to_bytes().
hex(), oct(), bin().
Format Specification Mini-Language для шестнадцатеричных, восьмеричных и двоичных чисел.
str на float.
str на decimal.Decimal.

Настройка лимита¶

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

PYTHONINTMAXSTRDIGITS , например PYTHONINTMAXSTRDIGITS=640 python3 чтобы установить ограничение на 640 или PYTHONINTMAXSTRDIGITS=0 python3 чтобы отключить ограничение.
-X int_max_str_digits `, например ``python3 -X int_max_str_digits=640`
sys.flags.int_max_str_digits содержит значение PYTHONINTMAXSTRDIGITS или -X int_max_str_digits `. Если и env var, и `-X`` опция установлена, -X вариант имеет приоритет. Значение -1 указывает, что оба были отключены, поэтому значение sys.int_info.default_max_str_digits использовался во время инициализации.

Из кода вы можете проверить текущий предел и установить новый, используя эти sys API:

sys.get_int_max_str_digits() и sys.set_int_max_str_digits() являются геттером и установщиком ограничения для всего интерпретатора. У субинтерпретаторов есть свой предел.

Информацию о значениях по умолчанию и минимуме можно найти в sys.int_info :

sys.int_info.default_max_str_digits — это скомпилированный предел по умолчанию.
sys.int_info.str_digits_check_threshold — наименьшее допустимое значение предела (кроме 0, которое отключает его).

Dodane w wersji 3.11.

Ostrzeżenie

Установка нижнего предела может привести к проблемам. Хотя и редко, но существует код, который содержит в исходном виде целочисленные константы в десятичном формате, превышающие минимальный порог. Последствием установки ограничения является то, что исходный код Python, содержащий десятичные целые литералы, длина которых превышает предел, столкнется с ошибкой во время анализа, обычно во время запуска или во время импорта или даже во время установки - в любое время и в обновленном виде. .pyc для кода еще не существует. Обходной путь для источника, содержащего такие большие константы, — преобразовать их в 0x шестнадцатеричной форме, поскольку она не имеет предела.

Тщательно протестируйте свое приложение, если вы используете нижний предел. Убедитесь, что ваши тесты выполняются с ограничением, установленным заранее через среду или флаг, чтобы оно применялось во время запуска и даже на любом этапе установки, который может вызвать Python для предварительной компиляции. .py источники для .pyc файлы.

Представництво	Opis
`\n`	Переведення рядка
`\r`	Повернення каретки
`\r\n`	Повернення каретки + Переведення рядка
`\v` or `\x0b`	Лінія табуляції
`\f` or `\x0c`	Подача форми
`\x1c`	Роздільник файлів
`\x1d`	Роздільник груп
`\x1e`	Розділювач записів
`\x85`	Наступний рядок (контрольний код C1)
`\u2028`	Розділювач рядків
`\u2029`	Роздільник абзаців

Wbudowane typy¶

Truth Value Testing¶

Boolean Operations — and, or, not¶

Comparisons¶

Numeric Types — int, float, complex¶

Bitwise Operations on Integer Types¶

Additional Methods on Integer Types¶

Additional Methods on Float¶

Hashing of numeric types¶

Boolean Type - bool¶

Iterator Types¶

Generator Types¶

Sequence Types — list, tuple, range¶

Common Sequence Operations¶

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

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

Listy¶

Tuples¶

діапазони¶

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

Metody ciągów¶

Strings literais formatadas (f-strings)¶

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

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

Bytes Objects¶

Bayt dizisi Nesneleri¶

Baytlar ve Bayt dizisi İşlemleri¶

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

Bellek Görünümleri¶

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

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

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

Bağlam Yöneticisi Türleri¶

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

Genel Takma Ad Türü¶

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

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

Тип союзу¶

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

Moduły¶

Sınıflar ve Sınıf Örnekleri¶

Zadania¶

Methods¶

Code Objects¶

Type Objects¶

Boş Nesne¶

Об’єкт „Еліпсис”.¶

Об’єкт NotImplemented¶

Dahili Nesneler¶

Atribut Spesial¶

Ограничение длины преобразования целочисленной строки¶

Затронутые API¶

Настройка лимита¶

Рекомендуемая конфигурация¶

Boolean Operations — `and`, `or`, `not`¶

Numeric Types — `int`, `float`, `complex`¶

Boolean Type - `bool`¶

Sequence Types — `list`, `tuple`, `range`¶

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

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

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

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

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

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

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

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