Sage Days 20.5 Tutorial: Data Types

Lists

Creating Lists I: [Square brackets]

Example:

Exercise: Create the list [63, 12, -10, 'a', 12], assign it to the variable L, and print the list.

Exercise: Create the empty list. (You will often need to do this.)

Creating Lists II: range

The range function provides an easy way to construct a list of integers. Here is the documentation of the range function.

range([start,] stop[, step]) -> list of integers

Return a list containing an arithmetic progression of integers.
range(i, j) returns [i, i+1, i+2, ..., j-1]; start (!) defaults to 0.
When step is given, it specifies the increment (or decrement).
For example, range(4) returns [0, 1, 2, 3].  The end point is omitted!
These are exactly the valid indices for a list of 4 elements.

Exercise: Use range to construct the list $[1,2,\ldots,50]$.

Exercise: Use range to construct the list of even numbers between 1 and 100 (including 100).

Exercise: The step argument for the range command can be negative. Use range to construct the list $[10, 7, 4, 1, -2]$.

Creating Lists III: list comprehensions

List comprehensions provide a concise way to create lists from other lists (or other data types).

Example. We already know how to create the list $[1, 2, \ldots, 16]$:

range(1,17)

Using a list comprehension, we can now create the list $[1^2, 2^2, 3^2, ..., 16^2]$ as follows:

[i^2 for i in range(1,17)]

Project Euler Problem 6

The sum of the squares of the first ten natural numbers is,

1² + 2² + ... + 10² = 385

The square of the sum of the first ten natural numbers is,

(1 + 2 + ... + 10)² = 55² = 3025

Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 385 = 2640.

Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.

Exercise: Use a list comprehension to list all the natural numbers below 20 that are multiples of 3 or 5.

Hints:

1. To get the remainder of 7 divided by 3 use 7%3.
2. To test for equality use two equal signs (==); for example, 3 == 7.

Nested list comprehensions

List comprehensions can be nested!

Examples:

Exercise: 

A Pythagorean triple is a triple $(x,y,z)$ of positive integers satisfying $x^2+y^2=z^2$. 

The Pythagorean triples whose components are at most $10$ are :  $[(3, 4, 5), (4, 3, 5), (6, 8, 10), (8, 6, 10)]$.

Using a filtered list comprehension, construct the list of Pythagorean triples whose components are at most $50$.

Accessing individual elements of lists

To access an element of the list, use the syntax L[i], where i is the index of the item.

Exercise: 

1. Construct the list L = [1,2,3,4,3,5,6]. What is L[3]?
2. What is L[1]?
3. What is the index of the first element of L?
4. What is L[-1]? What is L[-2]?
5. What is L.index(2)? What is L.index(3)?

Modifying lists: changing an element in a list

To change the item in position i of a list L:

Modifying lists: append and extend

To append an object to a list:

To extend a list by another list:

Modifying lists: reverse, sort, ...

Concatenating Lists

To concatenate two lists, add them (+). This is not a commutative operation....

Slicing Lists

You can slice a list using the syntax L[start : stop : step]. This will return a sublist of L.

Exercise: Below are some examples of slicing lists. Try to guess what the output will be before evaluating the cell.

Exercise: The following function combines a loop with the some of the list operations above. What does the function do?

Tuples

A tuple is an immutable list. That is, it cannot be changed once it is created.

The syntax for creating a tuple is to the use parentheses. 

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

Tuples behave like lists in many respects:

Trying to modify a tuple will fail.

Generators

"Tuple-comprehension" does not exist.  The syntax produces something called a generator.  A generator allows you to process a sequence of items one at a time.  Each item is created when it is needed, and then forgotten.  This can be very efficient if we only need to use each item once.

g is now empty.

A nice 'pythonic' trick is to use generators as the argument to functions.  We do not need double parentheses for this.

Dictionaries

A dictionary is another built-in data type. Unlike lists, which are indexed by a range of numbers, dictionaries are "indexed" by keys, which can be any immutable object. 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.

Dictionaries behave as lists and tuples for several important operations.

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

Another way to add items to a dictionary is with the update() method:

We can iterate through the keys, or values, or both, of a dictionary.

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], ... }

Then try

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}$.

Modifying lists has consequences!

Try to predict the results of the following commands.

Now try these:

You can use the command deepcopy to avoid these issues.

The same issues occur with dictionaries.