##
2.2.6 Sequence Types

There are six sequence types: strings, Unicode strings, lists, tuples, buffers, and xrange objects.

Strings literals are written in single or double quotes: `'xyzzy'`, `"frobozz"`. See chapter 2 of the Python Reference Manual for more about string literals. Unicode strings are much like strings, but are specified in the syntax using a preceeding "`u`" character: `u'abc'`, `u"def"`. 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, e.g., `a, b, c` or `()`. A single item tuple must have a trailing comma, e.g., `(d,)`.

Buffer objects are not directly supported by Python syntax, but can be created by calling the builtin function `buffer()`. They support concatenation and repetition, but the result is a new string object rather than a new buffer object.

Xrange objects are similar to buffers in that there is no specific syntax to create them, but they are created using the `xrange()` function. They don't support slicing or concatenation, but do support repetition, and using `in`, `not in`, `min()` or `max()` on them is inefficient.

Most sequence types support the following operations. The "`in`" and "`not in`" operations have the same priorities as the comparison operations. The "`+`" and "`*`" operations have the same priority as the corresponding numeric operations.2.7

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
--- | --- | ---
`x in s` | `1` if an item of s is equal to x, else `0` |
`x not in s` | `0` if an item of s is equal to x, else `1` |
`s + t` | the concatenation of s and t |
`s * n , n * s` | n shallow copies of s concatenated | (1)
`s[i]` | i'th item of s, origin 0 | (2)
`s[i:j]` | slice of s from i to j | (2), (3)
`len(s)` | length of s |
`min(s)` | smallest item of s |
`max(s)` | largest item of s |

Notes:

(1)
  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:

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

  What has happened is that `lists` is a list containing three copies of the list `[[]]` (a one-element list containing an empty list), but the contained list is shared by each copy. 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]]

(2)
  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`.

(3)
  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, use `0`. If j is omitted, use `len(s)`. If i is greater than or equal to j, the slice is empty.

#### Footnotes

... operations.2.7
  They must have since the parser can't tell the type of the operands.

Subsections

- 2.2.6.1 String Methods
- 2.2.6.2 String Formatting Operations
- 2.2.6.3 XRange Type
- 2.2.6.4 Mutable Sequence Types