Recitation 7a (Dec 12, 2011)

Code examples

Example 1: matrix class

» show Python code »

import random
 
class Matrix:
    """
    Represents a rectangular matrix with n rows and m columns.
    """
 
    def __init__(self, n, m):
        assert m > 0 and n > 0
        self.rows = [ [0]*m for i in range(n)]
##        self.rows = [ [0]*m ]*n
 
##    def get(self, i,j):
##        return self.rows[i][j]
    def __getitem__(self, ij):
        i,j = ij
        if isinstance(i,int) and isinstance(j,int):
            return self.rows[i][j]
            #return self.rows[ij[0]][ij[1]]
        elif isinstance(i, slice) and isinstance(j,slice):
            M = Matrix(1,1) # to be overwritten
            M.rows = [row[j] for row in self.rows[i]]
            return M
        else:
            return NotImplemented
 
##    def set(self, i,j, val):
##        self.rows[i][j] = val
    def __setitem__(self, ij, val):
        i,j = ij
        if isinstance(i,int) and isinstance(j,int):
            assert isinstance(val, (int, float, complex))
            self.rows[i][j] = val
        elif isinstance(i, slice) and isinstance(j,slice):
            assert isinstance(val, Matrix)
            n,m = val.dim()
            s_rows = self.rows[i]
            assert n == len(s_rows) and m == len(s_rows[0][j])
            for s_row, v_row in zip(s_rows, val.rows):
                s_row[j] = v_row
        else:
            return NotImplemented
 
    def __repr__(self):
        return "<Matrix {}>".format(self.rows)
 
    def dim(self):
        return len(self.rows),len(self.rows[0])
 
    def __add__(self, other):
        n,m = self.dim()
        assert (n,m) == other.dim()
        M = Matrix(n,m)
        for i in range(n):
            for j in range(m):
                M[i,j] = self[i,j] + other[i,j]
        return M
 
    def __sub__(self, other):
        n,m = self.dim()
        assert (n,m) == other.dim()
        M = Matrix(n,m)
        for i in range(n):
            for j in range(m):
                M[i,j] = self[i,j] - other[i,j]
        return M
 
    def __neg__(self):
        n,m = self.dim()
        return Matrix(n,m)-self
 
    def __mul__(self, other):
        if isinstance(other, Matrix):
            return self.multiply_by_matrix(other)
        else:
            return self.multiply_by_scalar(other)
 
    def naive_multiply_by_matrix(self, other):
        assert isinstance(other, Matrix)
        n,m = self.dim()
        n2,m2 = other.dim()
        assert m == n2
        M = Matrix(n, m2)
        for i in range(n):
            for j in range(m2):
                M[i,j] = sum(self[i,k] * other[k,j] for k in range(m))
        return M
 
    multiply_by_matrix = naive_multiply_by_matrix
 
    def multiply_by_scalar(self, other):
        assert isinstance(other, (int, float, complex))
        n,m = self.dim()
        M = Matrix(n,m)
        for i in range(n):
            for j in range(m):
                M[i,j] = self[i,j] * other
        return M
 
##    def __rmul__(self, other):
##        return self * other
    __rmul__ = __mul__
 
    def __eq__(self, other):
        return isinstance(other, Matrix) and self.rows == other.rows
 
def random_matrix(n,m):
    M = Matrix(n,m)
    for i in range(n):
        for j in range(m):
            M[i,j] = random.randint(-10,10)
    return M

Download (right click -> save link as "ex1.py")

Documentation highlights

• List of special method names.
• Especially relevant are the section on numeric types and also parts of the section on container types.

Interpreter session log

» show Python code »

Python 3.2 (r32:88445, Feb 20 2011, 21:29:02) [MSC v.1500 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>> [1]*4
[1, 1, 1, 1]
>>> [[]]*4
[[], [], [], []]
>>> ================================ RESTART ================================
>>> 
>>> m = Matrix(3,3)
>>> m
<Matrix [[0, 0, 0], [0, 0, 0], [0, 0, 0]]>
>>> m.set(1,2, 100)
>>> m
<Matrix [[0, 0, 100], [0, 0, 100], [0, 0, 100]]>
>>> ================================ RESTART ================================
>>> 
>>> m = Matrix(3,3)
>>> m.set(1,2, 100)
>>> m
<Matrix [[0, 0, 0], [0, 0, 100], [0, 0, 0]]>
>>> [id(row) for row in m.rows]
[21798704, 14773944, 14772384]
>>> m[1,2] = 100
Traceback (most recent call last):
  File "<pyshell#11>", line 1, in <module>
    m[1,2] = 100
TypeError: 'Matrix' object does not support item assignment
>>> m[1,2]
Traceback (most recent call last):
  File "<pyshell#12>", line 1, in <module>
    m[1,2]
TypeError: 'Matrix' object is not subscriptable
>>> ================================ RESTART ================================
>>> 
>>> m = Matrix(3,3)
>>> m[2,2]=5
>>> m
<Matrix [[0, 0, 0], [0, 0, 0], [0, 0, 5]]>
>>> m[1,2]
0
>>> m[(1,2)]
0
>>> m[5]
Traceback (most recent call last):
  File "<pyshell#18>", line 1, in <module>
    m[5]
  File "C:/Documents and Settings/ranihod/Desktop/r7-ex1.py", line 14, in __getitem__
    i,j = ij
TypeError: 'int' object is not iterable
>>> m[111]
Traceback (most recent call last):
  File "<pyshell#19>", line 1, in <module>
    m[111]
  File "C:/Documents and Settings/ranihod/Desktop/r7-ex1.py", line 14, in __getitem__
    i,j = ij
TypeError: 'int' object is not iterable
>>> m[1,2,3]
Traceback (most recent call last):
  File "<pyshell#20>", line 1, in <module>
    m[1,2,3]
  File "C:/Documents and Settings/ranihod/Desktop/r7-ex1.py", line 14, in __getitem__
    i,j = ij
ValueError: too many values to unpack (expected 2)
>>> a,b,c=(4,5,6)
>>> a
4
>>> b
5
>>> a,b=b,a
>>> a
5
>>> b
4
>>> ================================ RESTART ================================
>>> 
>>> random_matrix(2,5)
<Matrix [[-9, -8, 1, 7, 6], [-1, 8, -5, -2, 4]]>
>>> ================================ RESTART ================================
>>> 
>>> random_matrix(3,4) + Matrix(6,6)
7
>>> ================================ RESTART ================================
>>> 
>>> m=random_matrix(3,4)
>>> m
<Matrix [[-1, -10, 7, -2], [-9, -10, 5, 6], [7, -4, 9, 9]]>
>>> m+m
<Matrix [[-2, -20, 14, -4], [-18, -20, 10, 12], [14, -8, 18, 18]]>
>>> m+6
Traceback (most recent call last):
  File "<pyshell#32>", line 1, in <module>
    m+6
  File "C:/Documents and Settings/ranihod/Desktop/r7-ex1.py", line 38, in __add__
    M[i,j] = self[i,j] + other[i,j]
TypeError: 'int' object is not subscriptable
>>> ================================ RESTART ================================
>>> 
>>> m=random_matrix(3,4)
>>> m+6
Traceback (most recent call last):
  File "<pyshell#34>", line 1, in <module>
    m+6
  File "C:/Documents and Settings/ranihod/Desktop/r7-ex1.py", line 34, in __add__
    assert (n,m) == other.dim()
AttributeError: 'int' object has no attribute 'dim'
>>> assert 1,0
>>> assert 1,1/0
>>> assert False, "terrible!"
Traceback (most recent call last):
  File "<pyshell#37>", line 1, in <module>
    assert False, "terrible!"
AssertionError: terrible!
>>> m+6
Traceback (most recent call last):
  File "<pyshell#38>", line 1, in <module>
    m+6
  File "C:/Documents and Settings/ranihod/Desktop/r7-ex1.py", line 34, in __add__
    assert (n,m) == other.dim()
AttributeError: 'int' object has no attribute 'dim'
>>> ================================ RESTART ================================
>>> 
>>> m=random_matrix(3,4)
>>> m
<Matrix [[8, -9, 0, 2], [0, -3, 8, -9], [2, -10, -9, 8]]>
>>> m * 5
<Matrix [[40, -45, 0, 10], [0, -15, 40, -45], [10, -50, -45, 40]]>
>>> m *= 5
>>> m
<Matrix [[40, -45, 0, 10], [0, -15, 40, -45], [10, -50, -45, 40]]>
>>> m*5
<Matrix [[200, -225, 0, 50], [0, -75, 200, -225], [50, -250, -225, 200]]>
>>> m
<Matrix [[40, -45, 0, 10], [0, -15, 40, -45], [10, -50, -45, 40]]>
>>> 5*m
Traceback (most recent call last):
  File "<pyshell#46>", line 1, in <module>
    5*m
TypeError: unsupported operand type(s) for *: 'int' and 'Matrix'
>>> ================================ RESTART ================================
>>> 
>>> 5*m
Traceback (most recent call last):
  File "<pyshell#47>", line 1, in <module>
    5*m
NameError: name 'm' is not defined
>>> m=random_matrix(3,4)
>>> 5*m
self= <Matrix [[4, -10, -8, -9], [6, 9, 5, -8], [3, -9, -8, 3]]> ; other= 5
<Matrix [[20, -50, -40, -45], [30, 45, 25, -40], [15, -45, -40, 15]]>
>>> m*"dghgdh"
Traceback (most recent call last):
  File "<pyshell#50>", line 1, in <module>
    m*"dghgdh"
  File "C:/Documents and Settings/ranihod/Desktop/r7-ex1.py", line 51, in __mul__
    assert isinstance(other, (int, float, complex))
AssertionError
>>> A * B # A.__mul__(B)   ->    B.__rmul__(A)
Traceback (most recent call last):
  File "<pyshell#51>", line 1, in <module>
    A * B # A.__mul__(B)   ->    B.__rmul__(A)
NameError: name 'A' is not defined
>>> return NotImplemented
SyntaxError: 'return' outside function
>>> ================================ RESTART ================================
>>> 
>>> m=random_matrix(3,4)
>>> 5*m
<Matrix [[35, -35, -25, 30], [-50, 15, -10, -15], [5, 0, -30, 30]]>
>>> m
<Matrix [[7, -7, -5, 6], [-10, 3, -2, -3], [1, 0, -6, 6]]>
>>> m.__rmul__(5)
<Matrix [[35, -35, -25, 30], [-50, 15, -10, -15], [5, 0, -30, 30]]>
>>> class A:
    def __mul__(self, other):
        print("A.__mul__", self, other)

>>> class B:
    def __mul__(self, other):
        print("B.__mul__", self, other)
    def __rmul__(self, other):
        print("B.__rmul__", self, other)

>>> a = A()
>>> b = B()
>>> a*5
A.__mul__ <__main__.A object at 0x014E7DB0> 5
>>> a*a
A.__mul__ <__main__.A object at 0x014E7DB0> <__main__.A object at 0x014E7DB0>
>>> a*b
A.__mul__ <__main__.A object at 0x014E7DB0> <__main__.B object at 0x014E76D0>
>>> 5*a
Traceback (most recent call last):
  File "<pyshell#69>", line 1, in <module>
    5*a
TypeError: unsupported operand type(s) for *: 'int' and 'A'
>>> b*5
B.__mul__ <__main__.B object at 0x014E76D0> 5
>>> b*b
B.__mul__ <__main__.B object at 0x014E76D0> <__main__.B object at 0x014E76D0>
>>> b*a
B.__mul__ <__main__.B object at 0x014E76D0> <__main__.A object at 0x014E7DB0>
>>> 5*b
B.__rmul__ <__main__.B object at 0x014E76D0> 5
>>> m*m
Traceback (most recent call last):
  File "<pyshell#74>", line 1, in <module>
    m*m
  File "C:/Documents and Settings/ranihod/Desktop/r7-ex1.py", line 51, in __mul__
    assert isinstance(other, (int, float, complex))
AssertionError
>>> ================================ RESTART ================================
>>> 
>>> M1 = random_matrix(3,4)
>>> M2 = random_matrix(4,2)
>>> M1
<Matrix [[-7, 10, 1, 2], [3, -2, 1, -9], [-3, 5, 6, 8]]>
>>> M2
<Matrix [[10, 9], [0, 3], [8, -7], [1, -9]]>
>>> M1*M2
<Matrix [[-60, -58], [29, 95], [26, -126]]>
>>> -7*10 + 10*0 + 1*8 + 2*1
-60
>>> M*M*M
Traceback (most recent call last):
  File "<pyshell#81>", line 1, in <module>
    M*M*M
NameError: name 'M' is not defined
>>> M = random_matrix(3,3)
>>> M*M*M*M
<Matrix [[2076, -1360, 1395], [-1580, 7576, -10975], [1220, -8920, 16541]]>
>>> M**4
Traceback (most recent call last):
  File "<pyshell#84>", line 1, in <module>
    M**4
TypeError: unsupported operand type(s) for ** or pow(): 'Matrix' and 'int'
>>> M2*M1
Traceback (most recent call last):
  File "<pyshell#85>", line 1, in <module>
    M2*M1
  File "C:/Documents and Settings/ranihod/Desktop/r7-ex1.py", line 52, in __mul__
    return self.multiply_by_matrix(other)
  File "C:/Documents and Settings/ranihod/Desktop/r7-ex1.py", line 60, in naive_multiply_by_matrix
    assert m == n2
AssertionError
>>> M
<Matrix [[-4, 3, 4], [4, 6, -5], [4, -4, 9]]>
>>> -M
Traceback (most recent call last):
  File "<pyshell#87>", line 1, in <module>
    -M
TypeError: bad operand type for unary -: 'Matrix'
>>> Matrix(3,3)-M
<Matrix [[4, -3, -4], [-4, -6, 5], [-4, 4, -9]]>
>>> ================================ RESTART ================================
>>> 
>>> M = random_matrix(3,3)
>>> -M
<Matrix [[0, -2, -1], [3, -5, 10], [-8, -3, 8]]>
>>> --M
<Matrix [[0, 2, 1], [-3, 5, -10], [8, 3, -8]]>
>>> ----------M
<Matrix [[0, 2, 1], [-3, 5, -10], [8, 3, -8]]>
>>> return a + -b
SyntaxError: 'return' outside function
>>> --M == M
False
>>> ================================ RESTART ================================
>>> 
>>> M = random_matrix(3,3)
>>> --M == M
True
>>> M = random_matrix(10,10)
>>> M[3:6,7:8]
[]
>>> M.rows[3:6][7:8]
[]
>>> M.rows[3:6]
[[-8, -7, 6, -7, 0, 4, 2, -8, -6, -1], [-7, 9, 10, 1, 5, 10, 0, 4, 1, 6], [-2, 7, -6, 4, 4, 0, 7, -1, 1, 4]]
>>> M[3:6,:2]
[[-8, -7, 6, -7, 0, 4, 2, -8, -6, -1], [-7, 9, 10, 1, 5, 10, 0, 4, 1, 6]]
>>> type(_)
<class 'list'>
>>> M[5,5:6]
[0]
>>> 5:^
SyntaxError: invalid syntax
>>> 56
56
>>> 5:7
SyntaxError: invalid syntax
>>> slice(5,7)
slice(5, 7, None)
>>> ================================ RESTART ================================
>>> 
>>> M = random_matrix(10,10)
>>> M[5,6]
8
>>> M
<Matrix [[8, 4, -10, 1, 6, -1, 7, -8, 0, 7], [-2, -2, -4, 5, -6, -2, 7, 9, 10, -3], [-7, 2, -8, -8, -5, -3, 1, 4, 4, 10], [-5, -6, -7, 5, -3, -6, 3, -6, 1, 0], [-5, 9, 10, -1, -9, -7, -9, 5, -7, -10], [-7, -8, -9, -1, 0, 2, 8, -6, -5, -4], [-1, 7, -7, -8, -5, -7, 10, -8, 2, -8], [-6, -2, -1, 0, 2, -6, 5, 5, -2, -4], [4, 5, -3, -1, -6, 4, 4, -9, -8, -8], [5, -3, 7, -10, -5, -8, 1, -1, 9, -5]]>
>>> M[:2, 4:8]
<Matrix [[6, -1, 7, -8], [-6, -2, 7, 9]]>
>>> M[:5, :5]
<Matrix [[8, 4, -10, 1, 6], [-2, -2, -4, 5, -6], [-7, 2, -8, -8, -5], [-5, -6, -7, 5, -3], [-5, 9, 10, -1, -9]]>
>>> M[:5, 5:]
<Matrix [[-1, 7, -8, 0, 7], [-2, 7, 9, 10, -3], [-3, 1, 4, 4, 10], [-6, 3, -6, 1, 0], [-7, -9, 5, -7, -10]]>
>>> M[:5,:]
<Matrix [[8, 4, -10, 1, 6, -1, 7, -8, 0, 7], [-2, -2, -4, 5, -6, -2, 7, 9, 10, -3], [-7, 2, -8, -8, -5, -3, 1, 4, 4, 10], [-5, -6, -7, 5, -3, -6, 3, -6, 1, 0], [-5, 9, 10, -1, -9, -7, -9, 5, -7, -10]]>
>>> M[:5]
Traceback (most recent call last):
  File "<pyshell#115>", line 1, in <module>
    M[:5]
  File "C:/Documents and Settings/ranihod/Desktop/r7-ex1.py", line 16, in __getitem__
    i,j = ij
TypeError: 'slice' object is not iterable
>>> M[:5,]
Traceback (most recent call last):
  File "<pyshell#116>", line 1, in <module>
    M[:5,]
  File "C:/Documents and Settings/ranihod/Desktop/r7-ex1.py", line 16, in __getitem__
    i,j = ij
ValueError: need more than 1 value to unpack
>>> M[:5,]
Traceback (most recent call last):
  File "<pyshell#117>", line 1, in <module>
    M[:5,]
  File "C:/Documents and Settings/ranihod/Desktop/r7-ex1.py", line 16, in __getitem__
    i,j = ij
ValueError: need more than 1 value to unpack
>>> 5,
(5,)
>>> type(_)
<class 'tuple'>
>>> (5)
5
>>> M["bla",7]
NotImplemented
>>> M[:200,1:2]
<Matrix [[4], [-2], [2], [-6], [9], [-8], [7], [-2], [5], [-3]]>
>>> list(zip([1,2,3], [7,8,9]))
[(1, 7), (2, 8), (3, 9)]
>>> ================================ RESTART ================================
>>> 
>>> M = random_matrix(10,10)
>>> M
<Matrix [[2, -9, 9, 7, -4, 1, 7, -7, 1, 9], [1, 5, 0, 3, -2, -2, 3, 2, 3, 10], [3, 9, -3, 5, -3, -1, 4, 0, 5, 6], [1, -3, 4, -2, -3, -9, -9, 9, -3, -7], [4, -9, -3, -1, -7, -2, -5, 8, 9, 5], [-3, 5, 3, 6, -10, 10, 0, 1, 6, -1], [-4, -3, 7, 4, 2, -2, -4, -10, 6, -6], [-6, -2, -1, -5, 10, 10, -6, 0, -6, -10], [-8, 0, 2, -6, -10, 1, -10, 6, 5, 1], [9, 8, 9, 4, 6, -3, -3, 7, -5, -8]]>
>>> M[2:7, 4:6] = Matrix(5,2)
>>> M
<Matrix [[2, -9, 9, 7, -4, 1, 7, -7, 1, 9], [1, 5, 0, 3, -2, -2, 3, 2, 3, 10], [3, 9, -3, 5, 0, 0, 4, 0, 5, 6], [1, -3, 4, -2, 0, 0, -9, 9, -3, -7], [4, -9, -3, -1, 0, 0, -5, 8, 9, 5], [-3, 5, 3, 6, 0, 0, 0, 1, 6, -1], [-4, -3, 7, 4, 0, 0, -4, -10, 6, -6], [-6, -2, -1, -5, 10, 10, -6, 0, -6, -10], [-8, 0, 2, -6, -10, 1, -10, 6, 5, 1], [9, 8, 9, 4, 6, -3, -3, 7, -5, -8]]>
>>>