<jupyter_start><jupyter_text>Classes and Object Oriented Programming We have looked at functions which take input and return output (or do things to the input). However, sometimes it is useful to think about *objects* first rather than the actions applied to them. Think about a polynomial, such as the cubic$$  p(x) = 12 - 14 x + 2 x^3. $$This is one of the standard forms that we would expect to see for a polynomial. We could imagine representing this in Python using a container containing the coefficients, such as:<jupyter_code>p_normal = (12, -14, 0, 2)<jupyter_output><empty_output><jupyter_text>The order of the polynomial is given by the number of coefficients (minus one), which is given by `len(p_normal)-1`. However, there are many other ways it could be written, which are useful in different contexts. For example, we are often interested in the roots of the polynomial, so would want to express it in the form$$  p(x) = 2 (x - 1)(x - 2)(x + 3). $$This allows us to read off the roots directly. We could imagine representing this in Python using a container containing the roots, such as:<jupyter_code>p_roots = (1, 2, -3)<jupyter_output><empty_output><jupyter_text>combined with a single variable containing the leading term,<jupyter_code>p_leading_term = 2<jupyter_output><empty_output><jupyter_text>We see that the order of the polynomial is given by the number of roots (and hence by `len(p_roots)`). This form represents the same polynomial but requires two pieces of information (the roots and the leading coefficient). The different forms are useful for different things. For example, if we want to add two polynomials the standard form makes it straightforward, but the factored form does not. Conversely, multiplying polynomials in the factored form is easy, whilst in the standard form it is not. But the key point is that the object - the polynomial - is the same: the representation may appear different, but it's the object itself that we really care about. So we want to represent the object in code, and work with that object.  Classes Python, and other languages that include *object oriented* concepts (which is most modern languages) allow you to define and manipulate your own objects. Here we will define a *polynomial* object step by step.<jupyter_code>class Polynomial(object):
    explanation = "I am a polynomial"
    
    def explain(self):
        print(self.explanation)<jupyter_output><empty_output><jupyter_text>We have defined a *class*, which is a single object that will represent a polynomial. We use the keyword `class` in the same way that we use the keyword `def` when defining a function. The definition line ends with a colon, and all the code defining the object is indented by four spaces.The name of the object - the general class, or type, of the thing that we're defining - is `Polynomial`. The convention is that class names start with capital letters, but this convention is frequently ignored.The type of object that we are building on appears in brackets after the name of the object. The most basic thing, which is used most often, is the `object` type as here. Class variables are defined in the usual way, but are only visible inside the class. Variables that are set outside of functions, such as `explanation` above, will be common to all class variables.Functions are defined inside classes in the usual way (using the `def` keyword, indented by four additional spaces). They work in a special way: they are not called directly, but only when you have a member of the class. This is what the `self` keyword does: it takes the specific *instance* of the class and uses its data. Class functions are often called *methods*.Let's see how this works on a specific example:<jupyter_code>p = Polynomial()
print(p.explanation)
p.explain()
p.explanation = "I change the string"
p.explain()<jupyter_output>I am a polynomial
I am a polynomial
I change the string<jupyter_text>The first line, `p = Polynomial()`, creates an *instance* of the class. That is, it creates a specific `Polynomial`. It is assigned to the variable named `p`. We can access class variables using the "dot" notation, so the string can be printed via `p.explanation`. The method that prints the class variable also uses the "dot" notation, hence `p.explain()`. The `self` variable in the definition of the function is the instance itself, `p`. This is passed through automatically thanks to the dot notation.Note that we can change class variables in specific instances in the usual way (`p.explanation = ...` above). This only changes the variable for that instance. To check that, let us define two polynomials:<jupyter_code>p = Polynomial()
p.explanation = "Changed the string again"
q = Polynomial()
p.explanation = "Changed the string a third time"
p.explain()
q.explain()<jupyter_output>Changed the string a third time
I am a polynomial<jupyter_text>We can of course make the methods take additional variables. We modify the class (note that we have to completely re-define it each time):<jupyter_code>class Polynomial(object):
    explanation = "I am a polynomial"
    
    def explain_to(self, caller):
        print("Hello, {}. {}.".format(caller,self.explanation))<jupyter_output><empty_output><jupyter_text>We then use this, remembering that the `self` variable is passed through automatically:<jupyter_code>r = Polynomial()
r.explain_to("Alice")<jupyter_output>Hello, Alice. I am a polynomial.<jupyter_text>At the moment the class is not doing anything interesting. To do something interesting we need to store (and manipulate) relevant variables. The first thing to do is to add those variables when the instance is actually created. We do this by adding a special function (method) which changes how the variables of type `Polynomial` are created:<jupyter_code>class Polynomial(object):
    """Representing a polynomial."""
    explanation = "I am a polynomial"
    
    def __init__(self, roots, leading_term):
        self.roots = roots
        self.leading_term = leading_term
        self.order = len(roots)
    
    def explain_to(self, caller):
        print("Hello, {}. {}.".format(caller,self.explanation))
        print("My roots are {}.".format(self.roots))<jupyter_output><empty_output><jupyter_text>This `__init__` function is called when a variable is created. There are a number of special class functions, each of which has two underscores before and after the name. This is another Python *convention* that is effectively a rule: functions surrounded by two underscores have special effects, and will be called by other Python functions internally. So now we can create a variable that represents a specific polynomial by storing its roots and the leading term:<jupyter_code>p = Polynomial(p_roots, p_leading_term)
p.explain_to("Alice")
q = Polynomial((1,1,0,-2), -1)
q.explain_to("Bob")<jupyter_output>Hello, Alice. I am a polynomial.
My roots are (1, 2, -3).
Hello, Bob. I am a polynomial.
My roots are (1, 1, 0, -2).<jupyter_text>It is always useful to have a function that shows what the class represents, and in particular what this particular instance looks like. We can define another method that explicitly `display`s the `Polynomial`:<jupyter_code>class Polynomial(object):
    """Representing a polynomial."""
    explanation = "I am a polynomial"
    
    def __init__(self, roots, leading_term):
        self.roots = roots
        self.leading_term = leading_term
        self.order = len(roots)
        
    def display(self):
        string = str(self.leading_term)
        for root in self.roots:
            if root == 0:
                string = string + "x"
            elif root > 0:
                string = string + "(x - {})".format(root)
            else:
                string = string + "(x + {})".format(-root)
        return string
    
    def explain_to(self, caller):
        print("Hello, {}. {}.".format(caller,self.explanation))
        print("My roots are {}.".format(self.roots))
p = Polynomial(p_roots, p_leading_term)
print(p.display())
q = Polynomial((1,1,0,-2), -1)
print(q.display())<jupyter_output>2(x - 1)(x - 2)(x + 3)
-1(x - 1)(x - 1)x(x + 2)<jupyter_text>Where classes really come into their own is when we manipulate them as objects in their own right. For example, we can multiply together two polynomials to get another polynomial. We can create a method to do that:<jupyter_code>class Polynomial(object):
    """Representing a polynomial."""
    explanation = "I am a polynomial"
    
    def __init__(self, roots, leading_term):
        self.roots = roots
        self.leading_term = leading_term
        self.order = len(roots)
        
    def display(self):
        string = str(self.leading_term)
        for root in self.roots:
            if root == 0:
                string = string + "x"
            elif root > 0:
                string = string + "(x - {})".format(root)
            else:
                string = string + "(x + {})".format(-root)
        return string
    
    def multiply(self, other):
        roots = self.roots + other.roots
        leading_term = self.leading_term * other.leading_term
        return Polynomial(roots, leading_term)
    
    def explain_to(self, caller):
        print("Hello, {}. {}.".format(caller,self.explanation))
        print("My roots are {}.".format(self.roots))
p = Polynomial(p_roots, p_leading_term)
q = Polynomial((1,1,0,-2), -1)
r = p.multiply(q)
print(r.display())<jupyter_output>-2(x - 1)(x - 2)(x + 3)(x - 1)(x - 1)x(x + 2)
{'fraction_non_alphanumeric': 0.08723560980742923, 'fraction_numerical': 0.006524255498263706, 'mean_word_length': 3.8440366972477062, 'pattern_counts': {'":': 0, '<': 43, '<?xml version=': 0, '>': 45, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '12', 'dir': 'jupyter-structured-clean-dedup', 'id': '123975', 'license': 'MIT', 'n_tokens_mistral': 2701, 'n_tokens_neox': 2600, 'n_words': 1196, 'path': 'content/notebooks/05-classes-oop.ipynb', 'repo_name': 'IanHawke/maths-with-python-book', 'size': '9503'}