A sequence is any object or data structure that stores and accesses elements in a fixed order. Built-in sequence types include
range. By contrast, sets and dictionaries, while they share some common features with sequences, are not themselves sequences. Sequences always support iteration (though not all iterable types are necessarily sequences) and a set of other basic operations.
A string (
str) is a sequence whose elements are characters (letters, symbols, or spaces). A string is surrounded by single quotes, double quotes, or a trio of double quotes:
str = 'test' str = "test" str = """test"""
tuple is a sequence that stores elements of any type. A tuple is created by enclosing comma-separated values in parentheses:
tup = (1, 2, 3)
tup = (1,) # (1) would be interpreted as an integer
Alternatively, a tuple can be constructed by calling
tuple(s) for some sequence
list also stores elements of any type. Lists behave much like tuples, except lists are mutable (see below). A list is created by enclosing comma-separated values in brackets:
lst = [1, 2, 3]
list(s)for some sequence
The number of elements in a sequence
s is given by
Indices and accessing
Elements in a sequence are organized by index, an integer denoting where that element is located in the ordering. The first element is at index 0, the second and index 1, and so on. This convention is called zero-based indexing. Note that Python also allows negative indices for convenience. The last element is at -1, the second to last at -2, and so on.
A particular element
x in a sequence
s can be retrieved with
i is the index of
x. Note that this returns, but does not remove, the element
x. Negative indices are permissible.
Indices are also used to return a slice of the sequence. For a sequence
s, create a slice with the format
s[start:end:step]. This will return a subsequence that begins with the element at index
start, ends with the element at index
end - 1, counting indices by
step. If not specified
start defaults to 0,
end defaults to
step defaults to 1. Negative indices and steps (indicating counting indices backwards) are permissible. For example,
>>> s = "abababab" >>> s[:-2:2] "aaa"
Two sequences of the same type can be concatenated together with the addition operator, which returns a new sequence containing all the elements in the first sequence followed by all the elements in the second. For example,
(1, 2) + (3, 4) returns
(1, 2, 3, 4).
x in s returns
x is an element of
x not in s returns the inverse: returns
x is not an element of
s. For example:
>>> 1 in [1, 2, 3] True >>> 1 not in [1, 2, 3] False
not in act like a substring test. For example:
>>> 'abc' in 'abcde' True
s and integer
s * n returns
n shallow copies of
s concatenated. For example:
>>> 'hi ' * 3 'hi hi hi '
The only built-in mutable sequence type in Python is the
list. In addition to the common sequence operations, lists support internal modification. For example,
>>> lst = [1, 2, 3] >>> lst = 5 >>> lst [5, 2, 3]
This piece of code creates
lst and replaces its first element. As opposed to concatenation and slicing, which leave the original unchanged and create new sequence objects with the specified modification, this changes the original list object itself.
Other operations which change the list object include
append, which takes in one argument and inserts that at the end of the list,
>>> lst.append(5) >>> lst [5, 2, 3, 5]
remove, which takes in one argument and removes the first instance of it from the list,
>>> lst.remove(5) >>> lst [2, 3, 5]
pop, which removes and returns the last element if it is not passed any additional arguments, or removes the element at index
i for integer
>>> lst.pop() 5 >>> lst [2, 3] >>> lst.pop(0) 2 >>> lst 
Other built-in methods that rely upon mutability include
sort which sorts the given list in-place (modifies the original object), and
reverse, which reverses a list in-place.