# Sequence

A **sequence** is any object or data structure that stores and accesses elements in a *fixed order*. Built-in sequence types include `list`

, `tuple`

, `str`

, and `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.

## Contents

## Types

### String

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

A `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 `s`

.

### List

A `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 `s`

.
## Operations

### Length

The number of elements in a sequence `s`

is given by `len(s)`

.

### 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 `s[i]`

, where `i`

is the index of `x`

. Note that this returns, but does not remove, the element `x`

. Negative indices are permissible.

### Slicing

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 `len(s)`

, and `step`

defaults to 1. Negative indices and steps (indicating counting indices backwards) are permissible. For example,

>>> s = "abababab" >>> s[:-2:2] "aaa"

### Concatenation

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

.

### Membership test

For sequence `s`

, `x in s`

returns `True`

if `x`

is an element of `s`

. `x not in s`

returns the inverse: returns `True`

if `x`

is not an element of `s`

. For example:

>>> 1 in [1, 2, 3] True >>> 1 not in [1, 2, 3] False

For strings, `in`

and `not in`

act like a substring test. For example:

>>> 'abc' in 'abcde' True

### Shallow copy

For sequence `s`

and integer `n`

, `s * n`

returns `n`

shallow copies of `s`

concatenated. For example:

>>> 'hi ' * 3 'hi hi hi '

## Mutable sequences

The only built-in mutable sequence type in Python is the `list`

. In addition to the common sequence operations, lists support internal modification.

### Element assignment

An element at index `i`

of list `lst`

can be reassigned to `c`

by `lst[i] = c`

. Example:

>>> lst = [1, 2, 3] >>> lst[0] = 5 # replaces first element of lst >>> lst [5, 2, 3]

### Slice assignment

A slice of list `s`

can be reassigned to other values. Examples:

>>> lst = [1, 2, 3] >>> lst[0:2] = 5, 6 >>> lst [5, 6, 3] >>> lst[0:0] = 1, 2 >>> lst [1, 2, 5, 6, 3]

`append`

`append`

takes in one argument and inserts it at the end of the list. Example:

>>> lst.append(5) >>> lst [5, 2, 3, 5]

`remove`

and `pop`

`remove`

takes in one argument and removes the first instance of it from the list. Example:

>>> lst.remove(5) >>> lst [2, 3, 5]

`pop`

removes and returns the last element if it is not passed any additional arguments, or removes the element at index `i`

for integer `i`

. Example:

>>> lst.pop() 5 >>> lst [2, 3] >>> lst.pop(0) 2 >>> lst [3]

`sort`

and `reverse`

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.