To create objects we instantiate the class by calling the class name and assigning it to the variable. 
```python
obj = ClassName()
```
To access the object attributes and methods we can use the dot operator.
```python
print( obj.items )
print( obj.findMaximum() )
```

Creating Objects in Python

In Python, classes may be defined using the following syntax:
```python
class ClassName:

    def __init__(self, dataList, dataString):
        self.items = dataList
        self.descriptor = dataString

    def findMaximum(self):
        return max(self.items)

    def __str__(self):
        return self.descriptor
```

University of Michigan - Ann Arbor

A Class allows us to group together data and functions. It provides a template which can be instantiated to create objects. Classes and Objects help improve readability and allow code reuse. 

Classes are most often used in Object Oriented Programming, as they allow programmers to bundle sets of functions and data together. 

Python Classes and Objects

Python Documentation

Defining Classes in Python

Class variables are attributes that are common for all its instances and declared in the class definition. But Instance variables are unique to a particular instance and are declared inside the ```___init___()``` method. 
For example, if we have a Class called Employee, each employee (an instance) will have unique employee_id, but might have the same manager_id. So in this case, manager_id should be declared as class variable and employee_id should be instance variable. 

Class Variable vs Instance Variable

•Class inheritance is the process by which a derived class is written based on a base class. Derived classes have the same functionality as the base class, unless otherwise changed. In the example below, Class B would inherit Class A’s methods and properties and a programmer can specify additional characteristics of the derived class.

Class Inheritance 

When creating objects, instance is passed as the first argument by default. ```Self``` represents that instance of the class. We access all the variables of a class by using  ```self```.

"Self" Keyword in Python Class

The __init__() method acts as a constructor that is used to initialize the variables in the class. This method is called during the creation of the object. 

__init__() method in Python

A method is a function that is explicitly tied to a class. Unlike regular functions, methods require an object instance of the class it is tied to in order to be called.

```python
class MyClass:
    def __init__(self, n, a):
        selt.name = n
        self.age = a

    def myName(self):
        print(self.name)

myName()  # This method cannot be called on its own
Jim = MyClass("Jim", 25)
Jim.myName()  # This call works
```

Methods vs. Functions

Encapsulation is an important concept of OOP. It is used to make data in a class private so that the data can not be accessed outside of the class. We create a getter method, for the object to safely access the data without directly interacting with the data itself. We make a variable private by prefixing the variable name by double underscores, e.g. ```__password = 123```

Encapsulation in Python


Where inheritance represents an "Is-A" relationship, composition represents a "Has-A" relationship. For example, a Car is a type of Vehicle. To represent these as classes, Car would be a child class of Vehicle, inheriting some of its members (four tires, a steering wheel, etc.) and some of its methods (such as a method for Move() or Stop()). 
However, this isn't the only way to structure a relationship. You could represent a Car as a class that Has instances of other classes which provide it the functionality a Car would need. You could have two classes, called Move and Stop, which Car has an instance of in its constructor. Typically the class that Has the other classes is referred to as the Composite class, because it is composed of other classes (the Car is composed of Move and Stop). The classes that the Composite class contains are referred to as Components (the Move and Stop class are Components which make up the Car class).

Class Composition

https://www.geeksforgeeks.org/constants-of-maths-in-python/

Math Constants

- math.pi
- math.e
- math.inf
- math.tau 
- math.nan

Useful Math Constants in Python

In interactive environments like Jupyter notebooks, class definitions can become lengthy blocks of code, which conflicts with the need to intersperse short code fragments with text explanations. To resolve this, the add_to_class utility function can be used to register functions as methods in a class after the class has already been created. By applying this function as a decorator to a method defined outside the class scope, the method can still access the class's member variables as if it were defined internally. This allows developers to split the implementation of a complex class across multiple, readable code blocks.

The add_to_class Utility Function

When implementing machine learning models, extending constructor call signatures often requires repetitive code to save arguments as class attributes. The HyperParameters utility serves as a base class to streamline this process. By inheriting from HyperParameters and calling the self.save_hyperparameters() method within the __init__ constructor, a class can implicitly save all provided arguments as class attributes without requiring additional, explicit assignment statements for each variable.

The HyperParameters Utility Class

To monitor the training process of a model, the ProgressBoard utility class allows for plotting experiment progress interactively while it is ongoing. Serving as a lightweight alternative to more complex tools like TensorBoard, it uses a draw method to plot $$(x, y)$$ data points dynamically. It also includes an option to smooth the plotted lines by displaying only $$1/n$$ points, where the values are averaged from the $$n$$ neighbor points in the original data. This enables clear, animated visualizations of metrics such as loss and accuracy directly within a notebook.

The ProgressBoard Utility Class

In deep learning implementations, models are structured using a base `Module` class. This class typically inherits from the underlying deep learning framework's standard neural network base class—such as `nn.Module` in PyTorch, `nn.Block` in MXNet, `linen.Module` in Flax, or `tf.keras.Model` in TensorFlow. By doing so, it provides a consistent interface and leverages built-in functionalities for constructing and managing neural networks.

Learn Before

Related

Learn After