The Python Book

linalg
20150206

# Linear Algebra MOOC

### Odds of letters in scrable:

``````{'A':9/98, 'B':2/98, 'C':2/98, 'D':4/98, 'E':12/98, 'F':2/98,
'G':3/98, 'H':2/98, 'I':9/98, 'J':1/98, 'K':1/98, 'L':1/98,
'M':2/98, 'N':6/98, 'O':8/98, 'P':2/98, 'Q':1/98, 'R':6/98,
'S':4/98, 'T':6/98, 'U':4/98, 'V':2/98, 'W':2/98, 'X':1/98,
'Y':2/98, 'Z':1/98}``````

### Use // to find the remainder

Remainder using modulo: `2304811 % 47 -> 25`

Remainder using // : `2304811 - 47 * (2304811 // 47) -> 25`

### Infinity

Infinity: float('infinity') : `1/float('infinity') -> 0.0`

## Set

Test membership with 'in' and 'not in'.

Note the difference between set (curly braces!) and tuple:

``````sum( {1,2,3,2} )
6

sum( (1,2,3,2) )
8``````

Union of sets: use the bar operator `{ 1,2,4 } | { 1,3,5 } -> {1, 2, 3, 4, 5}`

Intersection of sets: use the ampersand operator `{ 1,2,4 } & { 1,3,5 } -> {1}`

Empty set: is not `{ }` but `set()`! While for a list, the empty list is `[]`.

``````s = { 1,2,4 }
s.update( { 1,3,5 } )
s
{1, 2, 3, 4, 5}``````

Intersect with another set:

``````s.intersection_update( { 4,5,6,7 } )
s
{4, 5}``````

Bind another variable to the same set: (any changes to s or t are visible to the other)

``t=s``

Make a complete copy:

``u=s.copy()``

Set comprehension:

``{2*x for x in {1,2,3} }``

.. union of 2 sets combined with if (the if clause can be considered a filter) ..

``````s = { 1, 2,4 }

{ x for x in s|{5,6} if x>=2 }
{2, 4, 5, 6}``````

Double comprehension : iterate over the Cartesian product of two sets:

``````{x*y for x in {1,2,3} for y in {2,3,4}}
{2, 3, 4, 6, 8, 9, 12}``````

Compare to a list, which will return 2 more elements ( the 4 and the 6) :

``````[x*y for x in {1,2,3} for y in {2,3,4}]
[2, 3, 4, 4, 6, 8, 6, 9, 12]``````

Or producing tuples:

``````{ (x,y) for x in {1,2,3} for y in {2,3,4}}
{(1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 2), (3, 3), (3, 4)}``````

The factors of n:

``````n=64
{ (x,y) for x in range(1,1+int(math.sqrt(n))) for y in range(1,1+n) if (x*y)==n }
{(1, 64), (2, 32), (4, 16), (8, 8)}``````

Or use it in a loop:

`````` for n in range(40,100):
print (n ,
{ (x,y) for x in range(1,1+int(math.sqrt(n))) for y in range(1,1+n) if (x*y)==n })
40 {(4, 10), (1, 40), (2, 20), (5, 8)}
41 {(1, 41)}
42 {(1, 42), (2, 21), (6, 7), (3, 14)}
43 {(1, 43)}
44 {(2, 22), (1, 44), (4, 11)}
45 {(1, 45), (3, 15), (5, 9)}
46 {(2, 23), (1, 46)}
47 {(1, 47)}
48 {(3, 16), (2, 24), (1, 48), (4, 12), (6, 8)}
.. ``````

## Lists

• a list can contain other sets and lists, but a set cannot contain a list (since lists are mutable).
• order: respected for lists, but not for sets
• concatenate lists using the '+' operator

• provide second argument `[]` to sum to make this work: `sum([ [1,2,3], [4,5,6], [7,8,9] ], [])` -> `[1, 2, 3, 4, 5, 6, 7, 8, 9]`

Skip elements in a slice: use the colon separate triple a:b:c notation

``````L = [0,10,20,30,40,50,60,70,80,90]

L[::3]
[0, 30, 60, 90]``````

List of lists and comprehension:

``````listoflists = [[1,1],[2,4],[3, 9]]

[y for [x,y] in listoflists]
[1, 4, 9]``````

## Tuples

• difference with lists: a tuple is immutable. So sets may contain tuples.

Unpacking in a comprehension:

`````` [y for (x,y) in [(1,'A'),(2,'B'),(3,'C')] ]
['A', 'B', 'C']

[x for x in [(1,'A'),(2,'B'),(3,'C')] ]
['A', 'B', 'C']``````

## Converting list/set/tuple

Use constructors: `set()`, `list()` or `tuple()`.

Note about range: a range represents a sequence, but it is not a list. Either iterate through the range or use set() or list() to turn it into a set or list.

Note about zip: it does not return a list, an 'iterator of tuples'.

## Dictionary comprehensions

``{ k:v for (k,v) in [(1,2),(3,4),(5,6)] }``

Iterate over the k,v pairs with items(), producing tuples:

``````[ item for item in {'a':1, 'b':2, 'c':3}.items()  ]
[('a', 1), ('c', 3), ('b', 2)]``````

# Modules

• create your own module: name it properly, eg "spacerocket.py"
• import it in another script

``````list(enumerate(['A','B','C']))