Chapter 11: Classes & Instances¶

Example: Vectors & Matrices¶

$\vec{x} = \begin{pmatrix} 1 \\ 2 \\ 3 \end{pmatrix}$

In [1]:

x = (1, 2, 3)

In [2]:

Out[2]:

(1, 2, 3)

$\bf{A} = \begin{bmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{bmatrix}$

In [3]:

A = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

In [4]:

Out[4]:

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

$\bf{A} * \vec{x} = \begin{bmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{bmatrix} * \begin{pmatrix} 1 \\ 2 \\ 3 \end{pmatrix} = \begin{pmatrix} 14 \\ 32 \\ 50 \end{pmatrix}$

In [5]:

A * x

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[5], line 1
----> 1 A * x

TypeError: can't multiply sequence by non-int of type 'tuple'

Class Definition¶

In [6]:

class Vector:
    """A one-dimensional vector from linear algebra."""

    dummy_variable = "I am a vector"

    def dummy_method(self):
        """A dummy method for illustration purposes."""
        return self.dummy_variable

In [8]:

type(Vector)

Out[8]:

type

In [9]:

Vector

Out[9]:

__main__.Vector

In [14]:

Vector.dummy_variable

Out[14]:

'I am a vector'

In [15]:

Vector.dummy_method

Out[15]:

<function __main__.Vector.dummy_method(self)>

In [16]:

Vector.dummy_method()

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[16], line 1
----> 1 Vector.dummy_method()

TypeError: Vector.dummy_method() missing 1 required positional argument: 'self'

In [17]:

class Vector:
    """A one-dimensional vector from linear algebra.

    All entries are converted to floats.
    """

    def __init__(self, data):
        """Create a new vector.

        Args:
            data (sequence): the vector's entries

        Raises:
            ValueError: if no entries are provided
        """
        self._entries = list(float(x) for x in data)
        if len(self._entries) == 0:
            raise ValueError("a vector must have at least one entry")

In [18]:

v = Vector([1, 2, 3])

In [20]:

type(v)

Out[20]:

__main__.Vector

In [21]:

Out[21]:

<__main__.Vector at 0x7f9b9416d760>

In [22]:

Vector()

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[22], line 1
----> 1 Vector()

TypeError: Vector.__init__() missing 1 required positional argument: 'data'

In [23]:

Vector(1, 2, 3)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[23], line 1
----> 1 Vector(1, 2, 3)

TypeError: Vector.__init__() takes 2 positional arguments but 4 were given

In [24]:

Vector([])

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[24], line 1
----> 1 Vector([])

Cell In[17], line 18, in Vector.__init__(self, data)
     16 self._entries = list(float(x) for x in data)
     17 if len(self._entries) == 0:
---> 18     raise ValueError("a vector must have at least one entry")

ValueError: a vector must have at least one entry

In [25]:

v._entries  # by convention not allowed

Out[25]:

[1.0, 2.0, 3.0]

Text Representations¶

In [26]:

x = 1, 2, 3

In [27]:

Out[27]:

(1, 2, 3)

In [28]:

(1, 2, 3)

Out[28]:

(1, 2, 3)

In [29]:

class Vector:

    def __init__(self, data):
        self._entries = list(float(x) for x in data)
        # ...

    def __repr__(self):
        args = ", ".join(repr(x) for x in self._entries)
        return f"Vector(({args}))"

    def __str__(self):
        first, last = self._entries[0], self._entries[-1]
        n_entries = len(self._entries)
        return f"Vector({first!r}, ..., {last!r})[{n_entries:d}]"

In [30]:

v = Vector([1, 2, 3])

In [31]:

Out[31]:

Vector((1.0, 2.0, 3.0))

In [33]:

repr(v)

Out[33]:

'Vector((1.0, 2.0, 3.0))'

In [34]:

str(v)

Out[34]:

'Vector(1.0, ..., 3.0)[3]'

In [35]:

print(v)

Vector(1.0, ..., 3.0)[3]

The `Matrix` Class¶

In [36]:

class Matrix:

    def __init__(self, data):
        self._entries = list(list(float(x) for x in r) for r in data)
        for row in self._entries[1:]:
            if len(row) != len(self._entries[0]):
                raise ValueError("rows must have the same number of entries")
        if len(self._entries) == 0:
            raise ValueError("a matrix must have at least one entry")

    def __repr__(self):
        args = ", ".join("(" + ", ".join(repr(c) for c in r) + ",)" for r in self._entries)
        return f"Matrix(({args}))"

    def __str__(self):
        first, last = self._entries[0][0], self._entries[-1][-1]
        m, n = len(self._entries), len(self._entries[0])
        return f"Matrix(({first!r}, ...), ..., (..., {last!r}))[{m:d}x{n:d}]"

In [40]:

m = Matrix([(1, 2, 3), (4, 5, 6), (7, 8, 9)])

In [42]:

type(m)

Out[42]:

__main__.Matrix

In [43]:

Out[43]:

Matrix(((1.0, 2.0, 3.0,), (4.0, 5.0, 6.0,), (7.0, 8.0, 9.0,)))

In [44]:

print(m)

Matrix((1.0, ...), ..., (..., 9.0))[3x3]

In [46]:

Matrix([(1, 2, 3), (4, 5)])

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[46], line 1
----> 1 Matrix([(1, 2, 3), (4, 5)])

Cell In[36], line 7, in Matrix.__init__(self, data)
      5 for row in self._entries[1:]:
      6     if len(row) != len(self._entries[0]):
----> 7         raise ValueError("rows must have the same number of entries")
      8 if len(self._entries) == 0:
      9     raise ValueError("a matrix must have at least one entry")

ValueError: rows must have the same number of entries

Instance Methods vs. Class Methods¶

In [47]:

class Matrix:

    def __init__(self, data):
        self._entries = list(list(float(x) for x in r) for r in data)
        # ...

    def __repr__(self):
        args = ", ".join("(" + ", ".join(repr(c) for c in r) + ",)" for r in self._entries)
        return f"Matrix(({args}))"

    def transpose(self):
        return Matrix(zip(*self._entries))

In [48]:

m = Matrix([(1, 2, 3), (4, 5, 6), (7, 8, 9)])

In [49]:

Out[49]:

Matrix(((1.0, 2.0, 3.0,), (4.0, 5.0, 6.0,), (7.0, 8.0, 9.0,)))

In [50]:

m.transpose()

Out[50]:

Matrix(((1.0, 4.0, 7.0,), (2.0, 5.0, 8.0,), (3.0, 6.0, 9.0,)))

In [51]:

n = m.transpose().transpose()

In [52]:

Out[52]:

Matrix(((1.0, 2.0, 3.0,), (4.0, 5.0, 6.0,), (7.0, 8.0, 9.0,)))

In [53]:

m is n

Out[53]:

False

In [54]:

m == n

Out[54]:

False

In [55]:

class Matrix:

    def __init__(self, data):
        self._entries = list(list(float(x) for x in r) for r in data)
        # ...

    def __repr__(self):
        args = ", ".join("(" + ", ".join(repr(c) for c in r) + ",)" for r in self._entries)
        return f"Matrix(({args}))"

    def transpose(self):
        return Matrix(zip(*self._entries))

    @classmethod
    def from_columns(cls, data):
        return cls(data).transpose()

In [56]:

m = Matrix.from_columns([(1, 4, 7), (2, 5, 8), (3, 6, 9)])

In [57]:

Out[57]:

Matrix(((1.0, 2.0, 3.0,), (4.0, 5.0, 6.0,), (7.0, 8.0, 9.0,)))

Computed Properties¶

In [58]:

class Matrix:

    def __init__(self, data):
        self._entries = list(list(float(x) for x in r) for r in data)
        for row in self._entries[1:]:
            if len(row) != self.n_cols:
                raise ValueError("rows must have the same number of entries")
        if self.n_rows == 0:
            raise ValueError("a matrix must have at least one entry")

    def __repr__(self):
        args = ", ".join("(" + ", ".join(repr(c) for c in r) + ",)" for r in self._entries)
        return f"Matrix(({args}))"

    @property
    def n_rows(self):
        return len(self._entries)

    @property
    def n_cols(self):
        return len(self._entries[0])

In [59]:

m = Matrix([(1, 2, 3), (4, 5, 6)])

In [60]:

m.n_rows, m.n_cols

Out[60]:

(2, 3)

In [61]:

m.n_rows = 3

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[61], line 1
----> 1 m.n_rows = 3

AttributeError: property 'n_rows' of 'Matrix' object has no setter