Some operations are supported by several object types; in particular,
practically all objects can be compared, 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.

Any object can be tested for truth value, for use in an if or
while condition or as operand of the Boolean operations below. The
following values are considered false:

None

False

zero of any numeric type, for example, 0, 0.0, 0j.

any empty sequence, for example, '', (), [].

any empty mapping, for example, {}.

instances of user-defined classes, if the class defines a __bool__() or
__len__() method, when that method returns the integer zero or
bool value False. [1]

All other values are considered true — so objects of many types are always
true.

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

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

Meaning

<

strictly less than

<=

less than or equal

>

strictly greater than

>=

greater than or equal

==

equal

!=

not equal

is

object identity

isnot

negated object identity

Objects of different types, except different numeric types, never compare equal.
Furthermore, some types (for example, function objects) support only a degenerate
notion of comparison where any two objects of that type are unequal. The <,
<=, > and >= operators will raise a TypeError exception when
any operand is a complex number, the objects are of different types that cannot
be compared, or other cases where there is no defined ordering.

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 isnot 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 notin, are
supported only by sequence types (below).

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 additional numeric types, fractions that hold
rationals, and decimal that hold 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. Comparisons between numbers of mixed type use
the same rule. [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, sorted by
ascending priority (operations in the same box have the same priority; all
numeric operations have a higher priority than comparison operations):

Also referred to as integer division. The resultant value 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 floating point to integer may round or truncate
as in C; see functions floor() and ceil() in the math module
for well-defined 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).

Integers support additional operations that make sense only for bit-strings.
Negative numbers are treated as their 2’s complement value (this assumes a
sufficiently large number of bits that no overflow occurs during the operation).

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 bit-string operations sorted in ascending priority
(operations in the same box have the same priority):

Operation

Result

Notes

x|y

bitwise or of x and
y

x^y

bitwise exclusive or of
x and y

x&y

bitwise and of x and
y

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

Notes:

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)
without overflow check.

A right shift by n bits is equivalent to division by pow(2,n) without
overflow check.

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.

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.

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:

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 iteration
support:

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:

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.

Return the next item from the container. 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.

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.

There are six sequence types: strings, byte sequences (bytes objects),
byte arrays (bytearray objects), lists, tuples, and range objects. For
other containers see the built in dict and set classes, and
the collections module.

Strings contain Unicode characters. Their literals are written in single or
double quotes: 'xyzzy', "frobozz". See String and Bytes literals for more about
string literals. In addition to the functionality described here, there are
also string-specific methods described in the String Methods section.

Bytes and bytearray objects contain single bytes – the former is immutable
while the latter is a mutable sequence. Bytes objects can be constructed the
constructor, bytes(), and from literals; use a b prefix with normal
string syntax: b'xyzzy'. To construct byte arrays, use the
bytearray() function.

Warning

While string objects are sequences of characters (represented by strings of
length 1), bytes and bytearray objects are sequences of integers (between 0
and 255), representing the ASCII value of single bytes. That means that for
a bytes or bytearray object b, b[0] will be an integer, while
b[0:1] will be a bytes or bytearray object of length 1. The
representation of bytes objects uses the literal format (b'...') since it
is generally more useful than e.g. bytes([50,19,100]). You can always
convert a bytes object into a list of integers using list(b).

Also, while in previous Python versions, byte strings and Unicode strings
could be exchanged for each other rather freely (barring encoding issues),
strings and bytes are now completely separate concepts. There’s no implicit
en-/decoding if you pass an object of the wrong type. A string always
compares unequal to a bytes or bytearray object.

Lists are constructed with square brackets, separating items with commas: [a,b,c]. Tuples are constructed by the comma operator (not within square
brackets), with or without enclosing parentheses, but an empty tuple must have
the enclosing parentheses, such as a,b,c or (). A single item tuple
must have a trailing comma, such as (d,).

Objects of type range are created using the range() function. They don’t
support slicing, concatenation or repetition, and using in, notin,
min() or max() on them is inefficient.

Most sequence types support the following operations. The in and notin
operations have the same priorities as the comparison operations. The + and
* operations have the same priority as the corresponding numeric operations.
[3] Additional methods are provided for Mutable Sequence Types.

This table lists the sequence operations sorted in ascending priority
(operations in the same box have the same priority). In the table, s and t
are sequences of the same type; n, i and j are integers:

Operation

Result

Notes

xins

True if an item of s is
equal to x, else False

(1)

xnotins

False if an item of s is
equal to x, else True

(1)

s+t

the concatenation of s and
t

(6)

s*n,n*s

n shallow copies of s
concatenated

(2)

s[i]

i‘th item of s, origin 0

(3)

s[i:j]

slice of s from i to j

(3)(4)

s[i:j:k]

slice of s from i to j
with step k

(3)(5)

len(s)

length of s

min(s)

smallest item of s

max(s)

largest item of s

s.index(i)

index of the first occurence
of i in s

s.count(i)

total number of occurences of
i in s

Sequence types also support comparisons. In particular, tuples and lists are
compared lexicographically by comparing corresponding elements. This means that
to compare equal, every element must compare equal and the two sequences must be
of the same type and have the same length. (For full details see
Comparisons in the language reference.)

Notes:

When s is a string object, the in and notin operations act like a
substring test.

Values of n less than 0 are treated as 0 (which yields an empty
sequence of the same type as s). Note also that the copies are shallow;
nested structures are not copied. This often haunts new Python programmers;
consider:

What has happened is that [[]] is a one-element list containing an empty
list, so all three elements of [[]]*3 are (pointers to) this single empty
list. Modifying any of the elements of lists modifies this single list.
You can create a list of different lists this way:

If i or j is negative, the index is relative to the end of the string:
len(s)+i or len(s)+j is substituted. But note that -0 is
still 0.

The slice of s from i to j is defined as the sequence of items with index
k such that i<=k<j. If i or j is greater than len(s), use
len(s). If i is omitted or None, use 0. If j is omitted or
None, use len(s). If i is greater than or equal to j, the slice is
empty.

The slice of s from i to j with step k is defined as the sequence of
items with index x=i+n*k such that 0<=n<(j-i)/k. In other words,
the indices are i, i+k, i+2*k, i+3*k and so on, stopping when
j is reached (but never including j). If i or j is greater than
len(s), use len(s). If i or j are omitted or None, they become
“end” values (which end depends on the sign of k). Note, k cannot be zero.
If k is None, it is treated like 1.

CPython implementation detail: If s and t are both strings, some Python implementations such as
CPython can usually perform an in-place optimization for assignments of
the form s=s+t or s+=t. When applicable, this optimization
makes quadratic run-time much less likely. This optimization is both
version and implementation dependent. For performance sensitive code, it
is preferable to use the str.join() method which assures consistent
linear concatenation performance across versions and implementations.

Return an encoded version of the string as a bytes object. Default encoding
is the current default string encoding. errors may be given to set a
different error handling scheme. The default for errors is 'strict',
meaning that encoding errors raise a UnicodeError. Other possible
values are 'ignore', 'replace', 'xmlcharrefreplace',
'backslashreplace' and any other name registered via
codecs.register_error(), see section Codec Base Classes. For a
list of possible encodings, see section Standard Encodings.

Return True if the string ends with the specified suffix, otherwise return
False. suffix can also be a tuple of suffixes to look for. With optional
start, test beginning at that position. With optional end, stop comparing
at that position.

Return a copy of the string where all tab characters are replaced by one or
more spaces, depending on the current column and the given tab size. The
column number is reset to zero after each newline occurring in the string.
If tabsize is not given, a tab size of 8 characters is assumed. This
doesn’t understand other non-printing characters or escape sequences.

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

Note

The find() method should be used only if you need to know the
position of sub. To check if sub is a substring or not, use the
in operator:

Perform a string formatting operation. The format_string argument can
contain literal text or replacement fields delimited by braces {}. Each
replacement field contains either the numeric index of a positional argument,
or the name of a keyword argument. Returns a copy of format_string where
each replacement field is replaced with the string value of the corresponding
argument.

>>> "The sum of 1 + 2 is {0}".format(1+2)'The sum of 1 + 2 is 3'

See Format String Syntax for a description of the various formatting options
that can be specified in format strings.

Return true if all characters in the string are alphanumeric and there is at
least one character, false otherwise. A character c is alphanumeric if one
of the following returns True: c.isalpha(), c.isdecimal(),
c.isdigit(), or c.isnumeric().

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

Return true if all characters in the string are decimal
characters and there is at least one character, false
otherwise. Decimal characters are those from general category “Nd”. This category
includes digit characters, and all characters
that that can be used to form decimal-radix numbers, e.g. U+0660,
ARABIC-INDIC DIGIT ZERO.

Return true if all characters in the string are digits and there is at least one
character, false otherwise. Digits include decimal characters and digits that need
special handling, such as the compatibility superscript digits. Formally, a digit
is a character that has the property value Numeric_Type=Digit or Numeric_Type=Decimal.

Return true if all cased characters in the string are lowercase and there is at
least one cased character, false otherwise. Cased characters are those with
general category property being one of “Lu”, “Ll”, or “Lt” and lowercase characters
are those with general category property “Ll”.

Return true if all characters in the string are numeric
characters, and there is at least one character, false
otherwise. Numeric characters include digit characters, and all characters
that have the Unicode numeric value property, e.g. U+2155,
VULGAR FRACTION ONE FIFTH. Formally, numeric characters are those with the property
value Numeric_Type=Digit, Numeric_Type=Decimal or Numeric_Type=Numeric.

Return true if all characters in the string are printable or the string is
empty, false otherwise. Nonprintable characters are those characters defined
in the Unicode character database as “Other” or “Separator”, excepting the
ASCII space (0x20) which is considered printable. (Note that printable
characters in this context are those which should not be escaped when
repr() is invoked on a string. It has no bearing on the handling of
strings written to sys.stdout or sys.stderr.)

Return true if there are only whitespace characters in the string and there is
at least one character, false otherwise. Whitespace characters are those
characters defined in the Unicode character database as “Other” or “Separator”
and those with bidirectional property being one of “WS”, “B”, or “S”.

Return true if the string is a titlecased string and there is at least one
character, for example uppercase characters may only follow uncased characters
and lowercase characters only cased ones. Return false otherwise.

Return true if all cased characters in the string are uppercase and there is at
least one cased character, false otherwise. Cased characters are those with
general category property being one of “Lu”, “Ll”, or “Lt” and uppercase characters
are those with general category property “Lu”.

Return a string which is the concatenation of the strings in the
iterableiterable. A TypeError will be raised if there are
any non-string values in seq, including bytes objects. The
separator between elements is the string providing this method.

Return a copy of the string with leading characters removed. The chars
argument is a string specifying the set of characters to be removed. If omitted
or None, the chars argument defaults to removing whitespace. The chars
argument is not a prefix; rather, all combinations of its values are stripped:

If there is only one argument, it must be a dictionary mapping Unicode
ordinals (integers) or characters (strings of length 1) to Unicode ordinals,
strings (of arbitrary lengths) or None. Character keys will then be
converted to ordinals.

If there are two arguments, they must be strings of equal length, and in the
resulting dictionary, each character in x will be mapped to the character at
the same position in y. If there is a third argument, it must be a string,
whose characters will be mapped to None in the result.

Split the string at the first occurrence of sep, and return a 3-tuple
containing the part before the separator, the separator itself, and the part
after the separator. If the separator is not found, return a 3-tuple containing
the string itself, followed by two empty strings.

Return the highest index in the string where substring sub is found, such
that sub is contained within s[start:end]. Optional arguments start
and end are interpreted as in slice notation. Return -1 on failure.

Split the string at the last occurrence of sep, and return a 3-tuple
containing the part before the separator, the separator itself, and the part
after the separator. If the separator is not found, return a 3-tuple containing
two empty strings, followed by the string itself.

Return a list of the words in the string, using sep as the delimiter string.
If maxsplit is given, at most maxsplit splits are done, the rightmost
ones. If sep is not specified or None, any whitespace string is a
separator. Except for splitting from the right, rsplit() behaves like
split() which is described in detail below.

Return a copy of the string with trailing characters removed. The chars
argument is a string specifying the set of characters to be removed. If omitted
or None, the chars argument defaults to removing whitespace. The chars
argument is not a suffix; rather, all combinations of its values are stripped:

Return a list of the words in the string, using sep as the delimiter
string. If maxsplit is given, at most maxsplit splits are done (thus,
the list will have at most maxsplit+1 elements). If maxsplit is not
specified, then there is no limit on the number of splits (all possible
splits are made).

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

If sep is not specified or is None, a different splitting algorithm is
applied: runs of consecutive whitespace are regarded as a single separator,
and the result will contain no empty strings at the start or end if the
string has leading or trailing whitespace. Consequently, splitting an empty
string or a string consisting of just whitespace with a None separator
returns [].

Return True if string starts with the prefix, otherwise return False.
prefix can also be a tuple of prefixes to look for. With optional start,
test string beginning at that position. With optional end, stop comparing
string at that position.

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

Return a titlecased version of the string where words start with an uppercase
character and the remaining characters are lowercase.

The algorithm uses a simple language-independent definition of a word as
groups of consecutive letters. The definition works in many contexts but
it means that apostrophes in contractions and possessives form word
boundaries, which may not be the desired result:

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

A workaround for apostrophes can be constructed using regular expressions:

Return a copy of the s where all characters have been mapped through the
map which must be a dictionary of Unicode ordinals (integers) to Unicode
ordinals, strings or None. Unmapped characters are left untouched.
Characters mapped to None are deleted.

You can use str.maketrans() to create a translation map from
character-to-character mappings in different formats.

Note

An even more flexible approach is to create a custom character mapping
codec using the codecs module (see encodings.cp1251 for an
example).

The formatting operations described here are obsolete and may go away in future
versions of Python. Use the new String Formatting in new code.

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

If format requires a single argument, values may be a single non-tuple
object. [4] Otherwise, values must be a tuple with exactly the number of
items specified by the format string, or a single mapping object (for example, a
dictionary).

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

Conversion flags (optional), which affect the result of some conversion
types.

Minimum field width (optional). If specified as an '*' (asterisk), the
actual width is read from the next element of the tuple in values, and the
object to convert comes after the minimum field width and optional precision.

Precision (optional), given as a '.' (dot) followed by the precision. If
specified as '*' (an asterisk), the actual width is read from the next
element of the tuple in values, and the value to convert comes after the
precision.

Length modifier (optional).

Conversion type.

When the right argument is a dictionary (or other mapping type), then the
formats in the string must include a parenthesised mapping key into that
dictionary inserted immediately after the '%' character. The mapping key
selects the value to be formatted from the mapping. For example:

The alternate form causes a leading zero ('0') to be inserted between
left-hand padding and the formatting of the number if the leading character
of the result is not already a zero.

The alternate form causes a leading '0x' or '0X' (depending on whether
the 'x' or 'X' format was used) to be inserted between left-hand padding
and the formatting of the number if the leading character of the result is not
already a zero.

The alternate form causes the result to always contain a decimal point, even if
no digits follow it.

The precision determines the number of digits after the decimal point and
defaults to 6.

The alternate form causes the result to always contain a decimal point, and
trailing zeroes are not removed as they would otherwise be.

The precision determines the number of significant digits before and after the
decimal point and defaults to 6.

The range type is an immutable sequence which is commonly used for
looping. The advantage of the range type is that an range
object will always take the same amount of memory, no matter the size of the
range it represents. There are no consistent performance advantages.

Range objects have very little behavior: they only support indexing, iteration,
and the len() function.

List and bytearray objects support additional operations that allow in-place
modification of the object. Other mutable sequence types (when added to the
language) should also support these operations. Strings and tuples are
immutable sequence types: such objects cannot be modified once created. The
following operations are defined on mutable sequence types (where x is an
arbitrary object).

Note that while lists allow their items to be of any type, bytearray object
“items” are all integers in the range 0 <= x < 256.

Operation

Result

Notes

s[i]=x

item i of s is replaced by
x

s[i:j]=t

slice of s from i to j
is replaced by the contents of
the iterable t

dels[i:j]

same as s[i:j]=[]

s[i:j:k]=t

the elements of s[i:j:k]
are replaced by those of t

(1)

dels[i:j:k]

removes the elements of
s[i:j:k] from the list

s.append(x)

same as s[len(s):len(s)]=[x]

s.extend(x)

same as s[len(s):len(s)]=x

(2)

s.count(x)

return number of i‘s for
which s[i]==x

s.index(x[,i[,j]])

return smallest k such that
s[k]==x and i<=k<j

(3)

s.insert(i,x)

same as s[i:i]=[x]

(4)

s.pop([i])

same as x=s[i];dels[i];returnx

(5)

s.remove(x)

same as dels[s.index(x)]

(3)

s.reverse()

reverses the items of s in
place

(6)

s.sort([key[,reverse]])

sort the items of s in place

(6), (7), (8)

Notes:

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

x can be any iterable object.

Raises ValueError when x is not found in s. When a negative index is
passed as the second or third parameter to the index() method, the sequence
length is added, as for slice indices. If it is still negative, it is truncated
to zero, as for slice indices.

When a negative index is passed as the first parameter to the insert()
method, the sequence length is added, as for slice indices. If it is still
negative, it is truncated to zero, as for slice indices.

The optional argument i defaults to -1, so that by default the last
item is removed and returned.

The sort() and reverse() methods modify the sequence in place for
economy of space when sorting or reversing a large sequence. To remind you
that they operate by side effect, they don’t return the sorted or reversed
sequence.

The sort() method takes optional arguments for controlling the
comparisons. Each must be specified as a keyword argument.

key specifies a function of one argument that is used to extract a comparison
key from each list element: key=str.lower. The default value is None.

reverse is a boolean value. If set to True, then the list elements are
sorted as if each comparison were reversed.

The sort() method is guaranteed to be stable. A
sort is stable if it guarantees not to change the relative order of elements
that compare equal — this is helpful for sorting in multiple passes (for
example, sort by department, then by salary grade).

CPython implementation detail: While a list is being sorted, the effect of attempting to mutate, or even
inspect, the list is undefined. The C implementation of Python makes the
list appear empty for the duration, and raises ValueError if it can
detect that the list has been mutated during a sort.

Bytes and bytearray objects, being “strings of bytes”, have all methods found on
strings, with the exception of encode(), format() and
isidentifier(), which do not make sense with these types. For converting
the objects to strings, they have a decode() method.

Wherever one of these methods needs to interpret the bytes as characters
(e.g. the is...() methods), the ASCII character set is assumed.

Note

The methods on bytes and bytearray objects don’t accept strings as their
arguments, just as the methods on strings don’t accept bytes as their
arguments. For example, you have to write

Return a string decoded from the given bytes. Default encoding is the
current default string encoding. errors may be given to set a different
error handling scheme. The default for errors is 'strict', meaning
that encoding errors raise a UnicodeError. Other possible values are
'ignore', 'replace' and any other name registered via
codecs.register_error(), see section Codec Base Classes. For a
list of possible encodings, see section Standard Encodings.

Return a copy of the bytes or bytearray object where all bytes occurring in
the optional argument delete are removed, and the remaining bytes have been
mapped through the given translation table, which must be a bytes object of
length 256.

This static method returns a translation table usable for
bytes.translate() that will map each character in from into the
character at the same position in to; from and to must be bytes objects
and have the same length.

A set object is an unordered collection of distinct hashable objects.
Common uses include membership testing, removing duplicates from a sequence, and
computing mathematical operations such as intersection, union, difference, and
symmetric difference.
(For other containers see the built in dict, list,
and tuple classes, and the collections module.)

Like other collections, sets support xinset, len(set), and forxinset. Being an unordered collection, sets do not record element position or
order of insertion. Accordingly, sets do not support indexing, slicing, or
other sequence-like behavior.

There are currently two built-in set types, set and frozenset.
The set type is mutable — the contents can be changed using methods
like add() and remove(). Since it is mutable, it has no hash value
and cannot be used as either a dictionary key or as an element of another set.
The frozenset type is immutable and hashable — its contents cannot be
altered after it is created; it can therefore be used as a dictionary key or as
an element of another set.

Non-empty sets (not frozensets) can be created by placing a comma-separated list
of elements within braces, for example: {'jack','sjoerd'}, in addition to the
set constructor.

Return a new set or frozenset object whose elements are taken from
iterable. The elements of a set must be hashable. To represent sets of
sets, the inner sets must be frozenset objects. If iterable is
not specified, a new empty set is returned.

Note, the non-operator versions of union(), intersection(),
difference(), and symmetric_difference(), issubset(), and
issuperset() methods will accept any iterable as an argument. In
contrast, their operator based counterparts require their arguments to be
sets. This precludes error-prone constructions like set('abc')&'cbs'
in favor of the more readable set('abc').intersection('cbs').

Both set and frozenset support set to set comparisons. Two
sets are equal if and only if every element of each set is contained in the
other (each is a subset of the other). A set is less than another set if and
only if the first set is a proper subset of the second set (is a subset, but
is not equal). A set is greater than another set if and only if the first set
is a proper superset of the second set (is a superset, but is not equal).

Instances of set are compared to instances of frozenset
based on their members. For example, set('abc')==frozenset('abc')
returns True and so does set('abc')inset([frozenset('abc')]).

The subset and equality comparisons do not generalize to a complete ordering
function. For example, any two disjoint sets are not equal and are not
subsets of each other, so all of the following return False: a<b,
a==b, or a>b.

Since sets only define partial ordering (subset relationships), the output of
the list.sort() method is undefined for lists of sets.

Note, the elem argument to the __contains__(), remove(), and
discard() methods may be a set. To support searching for an equivalent
frozenset, the elem set is temporarily mutated during the search and then
restored. During the search, the elem set should not be read or mutated
since it does not have a meaningful value.

A mapping object maps hashable values to arbitrary objects.
Mappings are mutable objects. There is currently only one standard mapping
type, the dictionary. (For other containers see the built in
list, set, and tuple classes, and the
collections module.)

A dictionary’s keys are almost arbitrary values. Values that are not
hashable, that is, values containing lists, dictionaries or other
mutable types (that are compared by value rather than by object identity) may
not be used as keys. Numeric types used for keys obey the normal rules for
numeric comparison: if two numbers compare equal (such as 1 and 1.0)
then they can be used interchangeably to index the same dictionary entry. (Note
however, that since computers store floating-point numbers as approximations it
is usually unwise to use them as dictionary keys.)

Dictionaries can be created by placing a comma-separated list of key:value
pairs within braces, for example: {'jack':4098,'sjoerd':4127} or {4098:'jack',4127:'sjoerd'}, or by the dict constructor.

Return a new dictionary initialized from an optional positional argument or
from a set of keyword arguments. If no arguments are given, return a new
empty dictionary. If the positional argument arg is a mapping object,
return a dictionary mapping the same keys to the same values as does the
mapping object. Otherwise the positional argument must be a sequence, a
container that supports iteration, or an iterator object. The elements of
the argument must each also be of one of those kinds, and each must in turn
contain exactly two objects. The first is used as a key in the new
dictionary, and the second as the key’s value. If a given key is seen more
than once, the last value associated with it is retained in the new
dictionary.

If keyword arguments are given, the keywords themselves with their associated
values are added as items to the dictionary. If a key is specified both in
the positional argument and as a keyword argument, the value associated with
the keyword is retained in the dictionary. For example, these all return a
dictionary equal to {"one":1,"two":2}:

dict(one=1,two=2)

dict({'one':1,'two':2})

dict(zip(('one','two'),(1,2)))

dict([['two',2],['one',1]])

The first example only works for keys that are valid Python identifiers; the
others work with any valid keys.

These are the operations that dictionaries support (and therefore, custom
mapping types should support too):

len(d)

Return the number of items in the dictionary d.

d[key]

Return the item of d with key key. Raises a KeyError if key is
not in the map.

If a subclass of dict defines a method __missing__(), if the key key
is not present, the d[key] operation calls that method with the key key
as argument. The d[key] operation then returns or raises whatever is
returned or raised by the __missing__(key) call if the key is not
present. No other operations or methods invoke __missing__(). If
__missing__() is not defined, KeyError is raised.
__missing__() must be a method; it cannot be an instance variable. For
an example, see collections.defaultdict.

update() accepts either another dictionary object or an iterable of
key/value pairs (as tuples or other iterables of length two). If keyword
arguments are specified, the dictionary is then updated with those
key/value pairs: d.update(red=1,blue=2).

The objects returned by dict.keys(), dict.values() and
dict.items() are view objects. They provide a dynamic view on the
dictionary’s entries, which means that when the dictionary changes, the view
reflects these changes.

Dictionary views can be iterated over to yield their respective data, and
support membership tests:

len(dictview)

Return the number of entries in the dictionary.

iter(dictview)

Return an iterator over the keys, values or items (represented as tuples of
(key,value)) in the dictionary.

Keys and values are iterated over in an arbitrary order which is non-random,
varies across Python implementations, and depends on the dictionary’s history
of insertions and deletions. If keys, values and items views are iterated
over with no intervening modifications to the dictionary, the order of items
will directly correspond. This allows the creation of (value,key) pairs
using zip(): pairs=zip(d.values(),d.keys()). Another way to
create the same list is pairs=[(v,k)for(k,v)ind.items()].

Iterating views while adding or deleting entries in the dictionary may raise
a RuntimeError or fail to iterate over all entries.

x in dictview

Return True if x is in the underlying dictionary’s keys, values or
items (in the latter case, x should be a (key,value) tuple).

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

Create a memoryview that references obj. obj must support the
buffer protocol. Built-in objects that support the buffer protocol include
bytes and bytearray.

A memoryview has the notion of an element, which is the
atomic memory unit handled by the originating object obj. For many
simple types such as bytes and bytearray, an element
is a single byte, but other types such as array.array may have
bigger elements.

len(view) returns the total number of elements in the memoryview,
view. The itemsize attribute will give you the
number of bytes in a single element.

A memoryview supports slicing to expose its data. Taking a single
index will return a single element as a bytes object. Full
slicing will result in a subview:

Python’s with statement supports the concept of a runtime context
defined by a context manager. This is implemented using a pair of methods
that allow user-defined classes to define a runtime context that is entered
before the statement body is executed and exited when the statement ends:

Enter the runtime context and return either this object or another object
related to the runtime context. The value returned by this method is bound to
the identifier in the as clause of with statements using
this context manager.

An example of a context manager that returns itself is a file object.
File objects return themselves from __enter__() to allow open() to be
used as the context expression in a with statement.

An example of a context manager that returns a related object is the one
returned by decimal.localcontext(). These managers set the active
decimal context to a copy of the original decimal context and then return the
copy. This allows changes to be made to the current decimal context in the body
of the with statement without affecting code outside the
with statement.

Exit the runtime context and return a Boolean flag indicating if any exception
that occurred should be suppressed. If an exception occurred while executing the
body of the with statement, the arguments contain the exception type,
value and traceback information. Otherwise, all three arguments are None.

Returning a true value from this method will cause the with statement
to suppress the exception and continue execution with the statement immediately
following the with statement. Otherwise the exception continues
propagating after this method has finished executing. Exceptions that occur
during execution of this method will replace any exception that occurred in the
body of the with statement.

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

Python defines several context managers to support easy thread synchronisation,
prompt closure of files or other objects, and simpler manipulation of the active
decimal arithmetic context. The specific types are not treated specially beyond
their implementation of the context management protocol. See the
contextlib module for some examples.

Note that there is no specific slot for any of these methods in the type
structure for Python objects in the Python/C API. Extension types wanting to
define these methods must provide them as a normal Python accessible method.
Compared to the overhead of setting up the runtime context, the overhead of a
single class dictionary lookup is negligible.

The only special operation on a module is attribute access: m.name, where
m is a module and name accesses a name defined in m‘s symbol table.
Module attributes can be assigned to. (Note that the import
statement is not, strictly speaking, an operation on a module object; importfoo does not require a module object named foo to exist, rather it requires
an (external) definition for a module named foo somewhere.)

A special member of every module is __dict__. This is the dictionary
containing the module’s symbol table. Modifying this dictionary will actually
change the module’s symbol table, but direct assignment to the __dict__
attribute is not possible (you can write m.__dict__['a']=1, which defines
m.a to be 1, but you can’t write m.__dict__={}). Modifying
__dict__ directly is not recommended.

Modules built into the interpreter are written like this: <module'sys'(built-in)>. If loaded from a file, they are written as <module'os'from'/usr/local/lib/pythonX.Y/os.pyc'>.

Function objects are created by function definitions. The only operation on a
function object is to call it: func(argument-list).

There are really two flavors of function objects: built-in functions and
user-defined functions. Both support the same operation (to call the function),
but the implementation is different, hence the different object types.

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 methods. Built-in methods are described with the types that support
them.

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

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

classC:defmethod(self):passc=C()c.method.__func__.whoami='my name is c'

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

A code object can be executed or evaluated by passing it (instead of a source
string) to the exec() or eval() built-in functions.

Type objects represent the various object types. An object’s type is accessed
by the built-in function type(). There are no special operations on
types. The standard module types defines names for all standard built-in
types.

Boolean values are the two constant objects False and True. They are
used to represent truth values (although other values can also be considered
false or true). In numeric contexts (for example when used as the argument to
an arithmetic operator), they behave like the integers 0 and 1, respectively.
The built-in function bool() can be used to cast any value to a Boolean,
if the value can be interpreted as a truth value (see section Truth Value
Testing above).