The list data type stores elements of arbitrary type. Like in C, C++, etc. (but unlike most standard computer algebra systems), the elements of the list are indexed starting from 0 :
sage: v = [2, 3, 5, 'x', SymmetricGroup(3)]; v [2, 3, 5, 'x', Symmetric group of order 3! as a permutation group] sage: type(v) <type 'list'> sage: v[0] 2 sage: v[2] 5
Note:
When indexing into a list, it is OK if the index is
not a Python int! A
Sage Integer (or Rational, or anything with an __index__
method)
will work just fine.
sage: v = [1,2,3] sage: v[2] 3 sage: n = 2 # SAGE Integer sage: v[n] # Perfectly OK! 3 sage: v[int(n)] # Also OK. 3
The range
function creates a list of Python int's (not Sage Integers):
sage: range(1, 15) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
sage: L = [factor(n) for n in range(1, 15)] sage: print L [1, 2, 3, 2^2, 5, 2 * 3, 7, 2^3, 3^2, 2 * 5, 11, 2^2 * 3, 13, 2 * 7] sage: L[12] 13 sage: type(L[12]) <class 'sage.structure.factorization.Factorization'> sage: [factor(n) for n in range(1, 15) if is_odd(n)] [1, 3, 5, 7, 3^2, 11, 13]
List slicing is a wonderful feature. If L
is a list,
then L[m:n]
returns the sublist of L
obtained
by starting at the
th element and stopping at the
st element,
as illustrated below.
sage: L = [factor(n) for n in range(1, 20)] sage: L[4:9] [5, 2 * 3, 7, 2^3, 3^2] sage: print L[:4] [1, 2, 3, 2^2] sage: L[14:4] [] sage: L[14:] [3 * 5, 2^4, 17, 2 * 3^2, 19]
Tuples are similar to lists, except they are immutable, meaning once they are created they can't be changed.
sage: v = (1,2,3,4); v (1, 2, 3, 4) sage: type(v) <type 'tuple'> sage: v[1] = 5 Traceback (most recent call last): ... TypeError: 'tuple' object does not support item assignment
Sequences are a third list-oriented Sage type. Unlike lists and tuples,
Sequence is not a built-in Python type. By default, a sequence is
mutable, but using the Sequence
class method
set_immutable
, it can be set to be immutable, as the following
example illustrates. All elements of a sequence have a common parent,
called the sequences universe.
sage: v = Sequence([1,2,3,4/5]) sage: v [1, 2, 3, 4/5] sage: type(v) <class 'sage.structure.sequence.Sequence'> sage: type(v[1]) <type 'sage.rings.rational.Rational'> sage: v.universe() Rational Field sage: v.is_immutable() False sage: v.set_immutable() sage: v[0] = 3 Traceback (most recent call last): ... ValueError: object is immutable; please change a copy instead.
sage: v = Sequence([1,2,3,4/5]) sage: isinstance(v, list) True sage: list(v) [1, 2, 3, 4/5] sage: type(list(v)) <type 'list'>
As another example, basis for vector spaces are immutable sequences, since it's important that you don't change them.
sage: V = QQ^3; B = V.basis(); B [ (1, 0, 0), (0, 1, 0), (0, 0, 1) ] sage: type(B) <class 'sage.structure.sequence.Sequence'> sage: B[0] = B[1] Traceback (most recent call last): ... ValueError: object is immutable; please change a copy instead. sage: B.universe() Vector space of dimension 3 over Rational Field
See About this document... for information on suggesting changes.