Tutorial: Programming in Python and Sage¶

Author: Florent Hivert <florent.hivert@univ-rouen.fr>, Franco Saliola <saliola@gmail.com>, et al.

This tutorial is an introduction to basic programming in Python and Sage, for readers with elementary notions of programming but not familiar with the Python language. It is far from exhaustive. For a more complete tutorial, have a look at the Python Tutorial. Also Python’s documentation and in particular the standard library can be useful.

A more advanced tutorial presents the notions of objects and classes in Python.

Here are further resources to learn Python:

Learn Python in 10 minutes ou en français Python en 10 minutes
Dive into Python is a Python book for experienced programmers. Also available in other languages.
Discover Python is a series of articles published in IBM’s developerWorks technical resource center.

Control structures¶

In Python, there is no keyword for the beginning and the end of an instructions block. Blocks are delimited solely by means of indentation. Most of the time a new block is introduced by :. Python has the following control structures:

Conditional instruction:

if <condition>:
    <instruction sequence>
[elif <condition>:
    <instruction sequence>]*
[else:
    <instruction sequence>]

Inside expression exclusively, one can write:
```
<value> if <condition> else <value>
```

Iterative instructions:

for <name> in <iterable>:
    <instruction sequence>
[else:
    <instruction sequence>]

while <condition>:
    <instruction sequence>
[else:
    <instruction sequence>]

The else block is executed at the end of the loop if the loop is ended normally, that is neither by a break nor an exception.

In a loop, continue jumps to the next iteration.
An iterable is an object which can be iterated through. Iterable types include lists, tuples, dictionaries, and strings.
An error (also called exception) is raised by:
```
raise <ErrorType>[("error message")]
```
Usual errors include ValueError and TypeError.

Functions¶

Note

Python functions vs. mathematical functions

In what follows, we deal with functions is the sense of programming languages. Mathematical functions, as manipulated in calculus, are handled by Sage in a different way. In particular it doesn’t make sense to do mathematical manipulation such as additions or derivations on Python functions.

One defines a function using the keyword def as:

def <name>(<argument list>):
     <instruction sequence>

The result of the function is given by the instruction return. Very short functions can be created anonymously using lambda (remark that there is no instruction return here):

lambda <arguments>: <expression>

Note

Functional programming

Functions are objects as any other objects. One can assign them to variables or return them. For details, see the tutorial on Functional Programming for Mathematicians.

Exercises¶

Tuples¶

A tuple is an immutable list. That is, it cannot be changed once it is created. This can be useful for code safety and foremost because it makes tuple hashable. To create a tuple, use parentheses instead of brackets:

Sage

sage: t = (3, 5, [3,1], (17,[2,3],17), 4)
sage: t
(3, 5, [3, 1], (17, [2, 3], 17), 4)

Python

>>> from sage.all import *
>>> t = (Integer(3), Integer(5), [Integer(3),Integer(1)], (Integer(17),[Integer(2),Integer(3)],Integer(17)), Integer(4))
>>> t
(3, 5, [3, 1], (17, [2, 3], 17), 4)

Sage Live

t = (3, 5, [3,1], (17,[2,3],17), 4)
t

To create a singleton tuple, a comma is required to resolve the ambiguity:

Sage

sage: (1)
1
sage: (1,)
(1,)

Python

>>> from sage.all import *
>>> (Integer(1))
1
>>> (Integer(1),)
(1,)

Sage Live

(1)
(1,)

We can create a tuple from a list, and vice-versa.

Sage

sage: tuple(range(5))
(0, 1, 2, 3, 4)

Python

>>> from sage.all import *
>>> tuple(range(Integer(5)))
(0, 1, 2, 3, 4)

Sage Live

tuple(range(5))

Sage

sage: list(t)
[3, 5, [3, 1], (17, [2, 3], 17), 4]

Python

>>> from sage.all import *
>>> list(t)
[3, 5, [3, 1], (17, [2, 3], 17), 4]

Sage Live

list(t)

Python

>>> from sage.all import *
>>> list(t)
[3, 5, [3, 1], (17, [2, 3], 17), 4]

Sage Live

list(t)

Tuples behave like lists in many respects:

Operation	Syntax for lists	Syntax for tuples
Accessing a letter	`list[3]`	`tuple[3]`
Concatenation	`list1 + list2`	`tuple1 + tuple2`
Slicing	`list[3:17:2]`	`tuple[3:17:2]`
A reversed copy	`list[::-1]`	`tuple[::-1]`
Length	`len(list)`	`len(tuple)`

Trying to modify a tuple will fail:

Sage

sage: t = (5, 'a', 6/5)
sage: t
(5, 'a', 6/5)

Python

>>> from sage.all import *
>>> t = (Integer(5), 'a', Integer(6)/Integer(5))
>>> t
(5, 'a', 6/5)

Sage Live

t = (5, 'a', 6/5)
t

Sage

sage: t[1] = 'b'
Traceback (most recent call last):
...
TypeError: 'tuple' object does not support item assignment

Python

>>> from sage.all import *
>>> t[Integer(1)] = 'b'
Traceback (most recent call last):
...
TypeError: 'tuple' object does not support item assignment

Sage Live

t[1] = 'b'

Python

>>> from sage.all import *
>>> t[Integer(1)] = 'b'
Traceback (most recent call last):
...
TypeError: 'tuple' object does not support item assignment

Sage Live

t[1] = 'b'

Dictionaries¶

A dictionary is another built-in data type. Unlike lists, which are indexed by a range of numbers starting at 0, dictionaries are indexed by keys, which can be any immutable objects. Strings and numbers can always be keys (because they are immutable). Dictionaries are sometimes called “associative arrays” in other programming languages.

There are several ways to define dictionaries. One method is to use braces, {}, with comma-separated entries given in the form key:value:

Sage

sage: d = {3:17, 0.5:[4,1,5,2,3], 0:"goo", 3/2 : 17}
sage: d
{0: 'goo', 0.500000000000000: [4, 1, 5, 2, 3], 3/2: 17, 3: 17}

Python

>>> from sage.all import *
>>> d = {Integer(3):Integer(17), RealNumber('0.5'):[Integer(4),Integer(1),Integer(5),Integer(2),Integer(3)], Integer(0):"goo", Integer(3)/Integer(2) : Integer(17)}
>>> d
{0: 'goo', 0.500000000000000: [4, 1, 5, 2, 3], 3/2: 17, 3: 17}

Sage Live

d = {3:17, 0.5:[4,1,5,2,3], 0:"goo", 3/2 : 17}
d

A second method is to use the constructor dict which admits a list (or actually any iterable) of 2-tuples (key, value):

Sage

sage: dd = dict((i,i^2) for i in range(10))
sage: dd
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

Python

>>> from sage.all import *
>>> dd = dict((i,i**Integer(2)) for i in range(Integer(10)))
>>> dd
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

Sage Live

dd = dict((i,i^2) for i in range(10))
dd

Dictionaries behave as lists and tuples for several important operations.

Operation	Syntax for lists	Syntax for dictionaries
Accessing elements	`list[3]`	`D["key"]`
Length	`len(list)`	`len(D)`
Modifying	`L[3] = 17`	`D["key"] = 17`
Deleting items	`del L[3]`	`del D["key"]`

Sage

sage: d[10]='a'
sage: d
{0: 'goo', 0.500000000000000: [4, 1, 5, 2, 3], 3/2: 17, 3: 17, 10: 'a'}

Python

>>> from sage.all import *
>>> d[Integer(10)]='a'
>>> d
{0: 'goo', 0.500000000000000: [4, 1, 5, 2, 3], 3/2: 17, 3: 17, 10: 'a'}

Sage Live

d[10]='a'
d

A dictionary can have the same value multiple times, but each key must only appear once and must be immutable:

Sage

sage: d = {3: 14, 4: 14}
sage: d
{3: 14, 4: 14}

Python

>>> from sage.all import *
>>> d = {Integer(3): Integer(14), Integer(4): Integer(14)}
>>> d
{3: 14, 4: 14}

Sage Live

d = {3: 14, 4: 14}
d

Sage

sage: d = {3: 13, 3: 14}
sage: d
{3: 14}

Python

>>> from sage.all import *
>>> d = {Integer(3): Integer(13), Integer(3): Integer(14)}
>>> d
{3: 14}

Sage Live

d = {3: 13, 3: 14}
d

Python

>>> from sage.all import *
>>> d = {Integer(3): Integer(13), Integer(3): Integer(14)}
>>> d
{3: 14}

Sage Live

d = {3: 13, 3: 14}
d

Sage

sage: d = {[1,2,3] : 12}
Traceback (most recent call last):
...
TypeError: unhashable type: 'list'

Python

>>> from sage.all import *
>>> d = {[Integer(1),Integer(2),Integer(3)] : Integer(12)}
Traceback (most recent call last):
...
TypeError: unhashable type: 'list'

Sage Live

d = {[1,2,3] : 12}

Python

>>> from sage.all import *
>>> d = {[Integer(1),Integer(2),Integer(3)] : Integer(12)}
Traceback (most recent call last):
...
TypeError: unhashable type: 'list'

Sage Live

d = {[1,2,3] : 12}

Another way to add items to a dictionary is with the update() method which updates the dictionary from another dictionary:

Sage

sage: d = {}
sage: d
{}

Python

>>> from sage.all import *
>>> d = {}
>>> d
{}

Sage Live

d = {}
d

Sage

sage: d.update({10 : 'newvalue', 20: 'newervalue', 3: 14, 0.5:[1,2,3]})
sage: d
{0.500000000000000: [1, 2, 3], 3: 14, 10: 'newvalue', 20: 'newervalue'}

Python

>>> from sage.all import *
>>> d.update({Integer(10) : 'newvalue', Integer(20): 'newervalue', Integer(3): Integer(14), RealNumber('0.5'):[Integer(1),Integer(2),Integer(3)]})
>>> d
{0.500000000000000: [1, 2, 3], 3: 14, 10: 'newvalue', 20: 'newervalue'}

Sage Live

d.update({10 : 'newvalue', 20: 'newervalue', 3: 14, 0.5:[1,2,3]})
d

Python

>>> from sage.all import *
>>> d.update({Integer(10) : 'newvalue', Integer(20): 'newervalue', Integer(3): Integer(14), RealNumber('0.5'):[Integer(1),Integer(2),Integer(3)]})
>>> d
{0.500000000000000: [1, 2, 3], 3: 14, 10: 'newvalue', 20: 'newervalue'}

Sage Live

d.update({10 : 'newvalue', 20: 'newervalue', 3: 14, 0.5:[1,2,3]})
d

We can iterate through the keys, or values, or both, of a dictionary. Note that, internally, there is no sorting of keys done. In general, the order of keys/values will depend on memory locations can and will differ between different computers and / or repeated runs on the same computer. However, Sage sort the dictionary entries by key when printing the dictionary specifically to make the docstrings more reproducible. However, the Python methods keys() and values() do not sort for you. If you want your output to be reproducible, then you have to sort it first just like in the examples below:

Sage

sage: d = {10 : 'newvalue', 20: 'newervalue', 3: 14, 0.5:(1,2,3)}

Python

>>> from sage.all import *
>>> d = {Integer(10) : 'newvalue', Integer(20): 'newervalue', Integer(3): Integer(14), RealNumber('0.5'):(Integer(1),Integer(2),Integer(3))}

Sage Live

d = {10 : 'newvalue', 20: 'newervalue', 3: 14, 0.5:(1,2,3)}

Sage

sage: sorted([key for key in d])
[0.500000000000000, 3, 10, 20]

Python

>>> from sage.all import *
>>> sorted([key for key in d])
[0.500000000000000, 3, 10, 20]

Sage Live

sorted([key for key in d])

Python

>>> from sage.all import *
>>> sorted([key for key in d])
[0.500000000000000, 3, 10, 20]

Sage Live

sorted([key for key in d])

Sage

sage: d.keys()   # random order
[0.500000000000000, 10, 3, 20]
sage: sorted(d.keys())
[0.500000000000000, 3, 10, 20]

Python

>>> from sage.all import *
>>> d.keys()   # random order
[0.500000000000000, 10, 3, 20]
>>> sorted(d.keys())
[0.500000000000000, 3, 10, 20]

Sage Live

d.keys()   # random order
sorted(d.keys())

Python

>>> from sage.all import *
>>> d.keys()   # random order
[0.500000000000000, 10, 3, 20]
>>> sorted(d.keys())
[0.500000000000000, 3, 10, 20]

Sage Live

d.keys()   # random order
sorted(d.keys())

Sage

sage: d.values()   # random order
[(1, 2, 3), 'newvalue', 14, 'newervalue']
sage: set(d.values()) == set([14, (1, 2, 3), 'newvalue', 'newervalue'])
True

Python

>>> from sage.all import *
>>> d.values()   # random order
[(1, 2, 3), 'newvalue', 14, 'newervalue']
>>> set(d.values()) == set([Integer(14), (Integer(1), Integer(2), Integer(3)), 'newvalue', 'newervalue'])
True

Sage Live

d.values()   # random order
set(d.values()) == set([14, (1, 2, 3), 'newvalue', 'newervalue'])

Python

>>> from sage.all import *
>>> d.values()   # random order
[(1, 2, 3), 'newvalue', 14, 'newervalue']
>>> set(d.values()) == set([Integer(14), (Integer(1), Integer(2), Integer(3)), 'newvalue', 'newervalue'])
True

Sage Live

d.values()   # random order
set(d.values()) == set([14, (1, 2, 3), 'newvalue', 'newervalue'])

Sage

sage: d.items()    # random order
[(0.500000000000000, (1, 2, 3)), (10, 'newvalue'), (3, 14), (20, 'newervalue')]
sage: sorted([(key, value) for key, value in d.items()])
[(0.500000000000000, (1, 2, 3)), (3, 14), (10, 'newvalue'), (20, 'newervalue')]

Python

>>> from sage.all import *
>>> d.items()    # random order
[(0.500000000000000, (1, 2, 3)), (10, 'newvalue'), (3, 14), (20, 'newervalue')]
>>> sorted([(key, value) for key, value in d.items()])
[(0.500000000000000, (1, 2, 3)), (3, 14), (10, 'newvalue'), (20, 'newervalue')]

Sage Live

d.items()    # random order
sorted([(key, value) for key, value in d.items()])

Python

>>> from sage.all import *
>>> d.items()    # random order
[(0.500000000000000, (1, 2, 3)), (10, 'newvalue'), (3, 14), (20, 'newervalue')]
>>> sorted([(key, value) for key, value in d.items()])
[(0.500000000000000, (1, 2, 3)), (3, 14), (10, 'newvalue'), (20, 'newervalue')]

Sage Live

d.items()    # random order
sorted([(key, value) for key, value in d.items()])

Exercise: Consider the following directed graph.

Create a dictionary whose keys are the vertices of the above directed graph, and whose values are the lists of the vertices that it points to. For instance, the vertex 1 points to the vertices 2 and 3, so the dictionary will look like:

d = { ..., 1:[2,3], ... }

Sage

sage: # edit here

Python

>>> from sage.all import *
>>> # edit here

Sage Live

# edit here

Then try:

Sage

sage: g = DiGraph(d)
sage: g.plot()

Python

>>> from sage.all import *
>>> g = DiGraph(d)
>>> g.plot()

Sage Live

g = DiGraph(d)
g.plot()

Using Sage types: The srange command¶

Example: Construct a \(3 \times 3\) matrix whose \((i,j)\) entry is the rational number \(\frac{i}{j}\). The integers generated by range() are Python int’s. As a consequence, dividing them does euclidean division (in Python2):

Sage

sage: matrix([[i/j for j in range(1,4)] for i in range(1,4)]) # not tested
[1 0 0]
[2 1 0]
[3 1 1]

Python

>>> from sage.all import *
>>> matrix([[i/j for j in range(Integer(1),Integer(4))] for i in range(Integer(1),Integer(4))]) # not tested
[1 0 0]
[2 1 0]
[3 1 1]

Sage Live

matrix([[i/j for j in range(1,4)] for i in range(1,4)]) # not tested

In Python3, the division of Python integers returns a float instead.

Whereas dividing a Sage Integer by a Sage Integer produces a rational number:

Sage

sage: matrix([[ i/j for j in srange(1,4)] for i in srange(1,4)])
[  1 1/2 1/3]
[  2   1 2/3]
[  3 3/2   1]

Python

>>> from sage.all import *
>>> matrix([[ i/j for j in srange(Integer(1),Integer(4))] for i in srange(Integer(1),Integer(4))])
[  1 1/2 1/3]
[  2   1 2/3]
[  3 3/2   1]

Sage Live

matrix([[ i/j for j in srange(1,4)] for i in srange(1,4)])

Tutorial: Programming in Python and Sage¶

Data structures¶

Control structures¶

Functions¶

Exercises¶

Lists¶

Creating Lists I: [Square brackets]¶

Creating Lists II: range¶

Creating Lists III: list comprehensions¶

Filtering lists with a list comprehension¶

Nested list comprehensions¶

Accessing individual elements of lists¶

Modifying lists: changing an element in a list¶

Modifying lists: append and extend¶

Modifying lists: reverse, sort, …¶

Concatenating Lists¶

Slicing Lists¶

Tuples¶

Generators¶

Dictionaries¶

Using Sage types: The srange command¶

Modifying lists has consequences!¶

Loops and Functions¶

While Loops¶

For Loops¶

Exercises¶

Functions¶

Exercises¶