There are six sequence types: strings, Unicode strings, lists, tuples, buffers, and xrange objects.
String literals are written in single or double quotes:
"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"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
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
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:
||the concatenation of s and t||(6)|
||n shallow copies of s concatenated||(2)|
||i'th item of s, origin 0||(3)|
||slice of s from i to j||(3), (4)|
||slice of s from i to j with step k||(3), (5)|
||length of s|
||smallest item of s|
||largest item of s|
not inoperations 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.
0are 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.append(3) >>> lists [, , ]
What has happened is that
[] is a one-element list containing
an empty list, so all three elements of
[] * 3 are (pointers to)
this single empty list. Modifying any of the elements of
modifies this single list. You can create a list of different lists this
>>> lists = [ for i in range(3)] >>> lists.append(3) >>> lists.append(5) >>> lists.append(7) >>> lists [, , ]
len(s) + ior
len(s) + jis substituted. But note that
i <= k < j. If i or j is greater than
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.
x = i + n*ksuch that . In other words, the indices are
i+3*kand so on, stopping when j is reached (but never including j). If i or j is greater than
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.
s+=t. When applicable, this optimization makes quadratic run-time much less likely. This optimization is both version and implementation dependent. For performance sensitive code, it is preferrable to use the str.join() method which assures consistent linear concatenation performance across versions and implementations. Changed in version 2.4: Formerly, string concatenation never occurred in-place.