<SYSTEM_TASK:>
Given the following text description, write Python code to implement the functionality described below step by step
<END_TASK>
<USER_TASK:>
Description:
 Object Oriented Programming
What is an Object?
First some semantics
Step1:  Note the reference to object, this means that our new class inherits from object. We won't be going into too much detail about inheritance, but for now you should always inherit from object when defining a class.
Once a class is defined you can create an instance of that class, which is an object. In Python we do this by calling the class name as if it were a function
Step2:  A class can store some data (after all, an empty class isn't very interesting!)
Step3:  We can access variables stored in a class by writing the name of the instance followed by a dot and then the name of the variable
Step4:  Classes can also contain functions. Functions attached to classes are called methods
Step5:  The first argument to every method automatically refers to the object we're calling the method on, by convention we call that argument self.
Step6:  Notice we don't have to pass the self argument, Python's object system does this for you.
Some methods are called special methods. Their names start and end with a double underscore. A particularly useful special method is __init__, which initializes an object.
Step7:  The __init__ method is called when we create an instance of a class. Now when we call the class name we can pass the arguments required by __init__
Step8:  Methods on an object have acces to the variables defined on the object
<ASSISTANT_TASK:>
Python Code:
class A(object):
    pass
Explanation: Object Oriented Programming
What is an Object?
First some semantics:
 - An object is essentially a container which holds some data, and crucially some associated methods for working with that data. 
 - We define objects, and their behaviours, using something called a class. 
 - We create objects by instantiating classes, so, objects are instances of classes.
Note, these are very similar to structures, with associated functions attached. 
Why do we need objects?
This is all very nice, but why bother with the overhead and confusion of objects and classes? People have been working with procedural programs for decades and they seem to work!
A few core ideas:
Modularity
Separation of concerns
Abstraction over complex mechanisms
We've used a lot of objects already!
Most of the code we've been using already has made heavy use of object-oriented programming:
NumPy arrays are objects (with attributes like shape and methods like mean())
Iris cubes are objects
CIS datasets are objects
Matplotlib axes/figures/lines etc. are all objects
Object-Oriented Programming in Python
Don't panic!
Objects can seem quite complex at first and it is possible to go into a lot of depth worring about things like inheritance and 'design'.
In many languages we're forced into using classes and objects for everything (e.g. Java and C#), but some languages don't support objects at all (e.g. R and Fortran 77). 
In python we have (in my opinion) a nice half-way house, we have a full OO implementation when we need it (including multiple inheritance, abstract classes etc), but we can use the procedural or functional styles when it's more desirable to do so.
Defining a class in Python is easy:
End of explanation
a_object = A()
print(type(a_object))
Explanation: Note the reference to object, this means that our new class inherits from object. We won't be going into too much detail about inheritance, but for now you should always inherit from object when defining a class.
Once a class is defined you can create an instance of that class, which is an object. In Python we do this by calling the class name as if it were a function:
End of explanation
class B(object):
    
    value = 1
Explanation: A class can store some data (after all, an empty class isn't very interesting!):
End of explanation
b_object = B()
print(b_object.value)
Explanation: We can access variables stored in a class by writing the name of the instance followed by a dot and then the name of the variable:
End of explanation
class B(object):
    
    value = 1
    
    def show_value(self, another_arg):
        print('self.value is {}'.format(self.value))
Explanation: Classes can also contain functions. Functions attached to classes are called methods:
End of explanation
b1 = B()
b1.show_value(12)
b1.value = 999
b1.show_value(132)
b2 = B()
Explanation: The first argument to every method automatically refers to the object we're calling the method on, by convention we call that argument self.
End of explanation
class C(object):
    
    def __init__(self, value):
        self.var = value
Explanation: Notice we don't have to pass the self argument, Python's object system does this for you.
Some methods are called special methods. Their names start and end with a double underscore. A particularly useful special method is __init__, which initializes an object.
End of explanation
c1 = C("Python!")
c2 = C("Hello")
print(c1.var)
print(c2.var) 
Explanation: The __init__ method is called when we create an instance of a class. Now when we call the class name we can pass the arguments required by __init__:
End of explanation
class Counter(object):
    
    def __init__(self, start=0):
        self.value = start
    def increment(self):
        self.value += 1 
counter1 = Counter()
print(counter1.value)
counter1.increment()
print(counter1.value) 
counter2 = Counter(start=10)
counter2.increment()
counter2.increment()
print(counter2.value) 
Explanation: Methods on an object have acces to the variables defined on the object:
End of explanation
<END_TASK>