2.3.6 Sequence Types
There are six sequence types: strings, Unicode strings, lists, tuples, buffers, and
xrange objects.
String 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, such as a,
b, c or (). A single item tuple must have a trailing comma, such as (d,).
Buffer objects are not directly supported by Python syntax, but can be created by
calling the builtin function buffer().
They don't support concatenation or repetition.
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, concatenation or 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:
x in s |
1 if an item of s is equal to x,
else 0 |
(1) |
x not in s |
0 if an item of s is equal to x,
else 1 |
(1) |
s + t |
the concatenation of s and t |
|
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 |
|
Notes:
- (1)
- When s is a string or Unicode string object the
in and not
in operations act like a substring test. In Python versions before 2.3, x
had to be a string of length 1. In Python 2.3 and beyond, x may be a string
of any length.
- (2)
- 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]]
- (3)
- 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.
- (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, use 0. If
j is omitted, 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 < abs(i-j).
If i or j is greater than len(s), use len(s).
If i or j are omitted then they become ``end'' values (which end
depends on the sign of k). Note, k cannot be zero.
Footnotes
- ... operations.2.7
- They must have since the parser can't tell the type of the operands.
|
