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 sys.hash_info.nan
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

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

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 Notes

x in s True if an item of s is equal to x, (1)
 Operation Result Notes
else False

False if an item of s is equal to x,

x not in s (1)
else True

s + t the concatenation of s and t (6)(7)

s * n or n * s equivalent to adding s to itself n times (2)(7)
s[i] ith 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

index of the first occurrence of x in s (at

s.index(x[, i[, j]]) (8)
or after index i and before index j)
s.count(x) total number of occurrences of x in s

Sequences of the same type 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:

1. While the in and not in operations are used only for simple containment

testing in the general case, some specialised sequences (such
as str, bytes and bytearray) also use them for subsequence testing:

>>>

>>> "gg" in "eggs"

True
2. Values of n less than 0 are treated as 0 (which yields an empty sequence of
the same type as s). Note that items in the sequence s are not copied; they
are referenced multiple times. This often haunts new Python programmers;
consider:

>>>

>>> lists = [[]] * 3

>>> lists
[[], [], []]
>>> lists[0].append(3)
>>> lists
[[3], [3], [3]]

What has happened is that [[]] is a one-element list containing an empty

list, so all three elements of [[]] * 3 are references 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:

>>>

>>> lists = [[] for i in range(3)]

>>> lists[0].append(3)
>>> lists[1].append(5)
>>> lists[2].append(7)
>>> lists
[[3], [5], [7]]

Further explanation is available in the FAQ entry How do I create a

multidimensional list?.
3. If i or j is negative, the index is relative to the end of
sequence s: len(s) + i or len(s) + j is substituted. But note that -
0 is still 0.
4. 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.
5. 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). When k is positive, i and j are
reduced to len(s) if they are greater. When k is negative, i and j are
reduced to len(s) - 1 if they are greater. 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.
6. Concatenating immutable sequences always results in a new object. This
means that building up a sequence by repeated concatenation will have a
quadratic runtime cost in the total sequence length. To get a linear runtime
cost, you must switch to one of the alternatives below:

o if concatenating str objects, you can build a list and

use str.join() at the end or else write to
an io.StringIO instance and retrieve its value when complete
o if concatenating bytes objects, you can similarly
use bytes.join() or io.BytesIO, or you can do in-place
concatenation with a bytearray object. bytearray objects are
mutable and have an efficient overallocation mechanism
o if concatenating tuple objects, extend a list instead
o for other types, investigate the relevant class documentation
7. Some sequence types (such as range) only support item sequences that
follow specific patterns, and hence don’t support sequence concatenation or
repetition.
8. index raises ValueError when x is not found in s. Not all
implementations support passing the additional arguments i and j. These
arguments allow efficient searching of subsections of the sequence. Passing
the extra arguments is roughly equivalent to using s[i:j].index(x),
only without copying any data and with the returned index being relative to
the start of the sequence rather than the start of the slice.
Immutable Sequence Types
The only operation that immutable sequence types generally implement that is not
also implemented by mutable sequence types is support for the hash() built-in.

This support allows immutable sequences, such as tuple instances, to be used

as dict keys and stored in set and frozenset instances.

Attempting to hash an immutable sequence that contains unhashable values will

result in TypeError.
Mutable Sequence Types
The operations in the following table are defined on mutable sequence types.
The collections.abc.MutableSequence ABC is provided to make it
easier to correctly implement these operations on custom sequence types.

In the table s is an instance of a mutable sequence type, t is any iterable object

and x is an arbitrary object that meets any type and value restrictions imposed
by s (for example, bytearray only accepts integers that meet the value
restriction 0 <= x <= 255).

Operation Result Notes

s[i] = x item i of s is replaced by x

slice of s from i to j is replaced by the

s[i:j] = t
contents of the iterable t
del s[i:j] same as s[i:j] = []

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

s[i:j:k] = t (1)
by those of t
removes the elements of s[i:j:k] from
del s[i:j:k]
the list

appends x to the end of the sequence

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

removes all items from s (same

s.clear() (5)
as del s[:])

creates a shallow copy of s (same

s.copy() (5)
as s[:])

extends s with the contents of t (for the

s.extend(t) or s += t most part the same
as s[len(s):len(s)] = t)

updates s with its contents

s *= n (6)
repeated n times

inserts x into s at the index given

s.insert(i, x)
by i (same as s[i:i] = [x])
 Operation Result Notes

retrieves the item at i and also removes it

s.pop([i]) (2)
from s

remove the first item

s.remove(x) (3)
from s where s[i] is equal to x

s.reverse() reverses the items of s in place (4)

Notes:

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

2. The optional argument i defaults to -1, so that by default the last item is
removed and returned.
3. remove() raises ValueError when x is not found in s.
4. The reverse() method modifies the sequence in place for economy of
space when reversing a large sequence. To remind users that it operates by
side effect, it does not return the reversed sequence.
5. clear() and copy() are included for consistency with the interfaces of
mutable containers that don’t support slicing operations (such
as dict and set). copy() is not part of
the collections.abc.MutableSequence ABC, but most concrete
mutable sequence classes provide it.

New in version 3.3:  clear() and copy() methods.

6. The value n is an integer, or an object implementing __index__(). Zero

and negative values of n clear the sequence. Items in the sequence are not
copied; they are referenced multiple times, as explained
for s * n under Common Sequence Operations.
Lists
Lists are mutable sequences, typically used to store collections of homogeneous
items (where the precise degree of similarity will vary by application).

class  list([iterable])
Lists may be constructed in several ways:

 Using a pair of square brackets to denote the empty list: []

  Using square brackets, separating items with commas: [a], [a, b, c]
 Using a list comprehension: [x for x in iterable]
 Using the type constructor: list() or list(iterable)

The constructor builds a list whose items are the same and in the same order as iterable’s
items. iterable may be either a sequence, a container that supports iteration, or an iterator
object. If iterable is already a list, a copy is made and returned, similar
to iterable[:]. For
example, list('abc') returns ['a', 'b', 'c'] and list( (1, 2, 3) ) retur
ns [1, 2, 3]. If no argument is given, the constructor creates a new empty list, [].

Many other operations also produce lists, including the sorted() built-in.

Lists implement all of the common and mutable sequence operations. Lists also provide

the following additional method:

sort(*, key=None, reverse=False)
This method sorts the list in place, using only < comparisons between items. Exceptions
are not suppressed - if any comparison operations fail, the entire sort operation will fail
(and the list will likely be left in a partially modified state).

sort() accepts two arguments that can only be passed by keyword (keyword-only

arguments):

key specifies a function of one argument that is used to extract a comparison key from
each list element (for example, key=str.lower). The key corresponding to each item
in the list is calculated once and then used for the entire sorting process. The default
value of None means that list items are sorted directly without calculating a separate key
value.

The functools.cmp_to_key() utility is available to convert a 2.x style cmp function

to a key function.

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

This method modifies the sequence in place for economy of space when sorting a large
sequence. To remind users that it operates by side effect, it does not return the sorted
sequence (use sorted() to explicitly request a new sorted list instance).
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).

For sorting examples and a brief sorting tutorial, see Sorting HOW TO.

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.
Tuples
Tuples are immutable sequences, typically used to store collections of
heterogeneous data (such as the 2-tuples produced by
the enumerate() built-in). Tuples are also used for cases where an
immutable sequence of homogeneous data is needed (such as allowing storage
in a set or dict instance).

class  tuple([iterable])
Tuples may be constructed in a number of ways:

 Using a pair of parentheses to denote the empty tuple: ()

 Using a trailing comma for a singleton tuple: a, or (a,)
 Separating items with commas: a, b, c or (a, b, c)
 Using the tuple() built-in: tuple() or tuple(iterable)

The constructor builds a tuple whose items are the same and in the same order
as iterable’s items. iterable may be either a sequence, a container that supports iteration,
or an iterator object. If iterable is already a tuple, it is returned unchanged. For
example, tuple('abc') returns ('a', 'b', 'c') and tuple( [1, 2, 3] ) r
eturns (1, 2, 3). If no argument is given, the constructor creates a new empty
tuple, ().

Note that it is actually the comma which makes a tuple, not the parentheses. The
parentheses are optional, except in the empty tuple case, or when they are needed to
avoid syntactic ambiguity. For example, f(a, b, c) is a function call with three
arguments, while f((a, b, c)) is a function call with a 3-tuple as the sole argument.

Tuples implement all of the common sequence operations.

For heterogeneous collections of data where access by name is clearer
than access by index, collections.namedtuple() may be a more
appropriate choice than a simple tuple object.