Creating classes is the bread and butter of object oriented programming. Before diving stright into the good stuff lets review and cover some more conceptual ideas before going into programming. The Python syntax for creating classes is pretty stright forward. Specially since creating a class in python has very little syntax then some of the other programming languages.
We have seen different types so far in Python such as Strings/Integers/Floats. However what if you wanted to make a type? Thats what classes are actually. In a way they are user defined types.
Scoping and Namespaces. Scoping is the idea that certain variables are defined in certain contexts. In python objects have attributes that are specific to that object. Instances which is what is created from a class share class variable shared between all instances of a particular class.
class Person:
population = 0
def __init__(self, name, money):
self.name = name
self.money = money
def main():
a = Person("Batman", 999999999)
print(a.name)
print(a.money)
print(a.population)
main()
Batman
999999999
0
class Person:
population = 0
def __init__(self, name, money):
self.name = name
self.money = money
_init_ is special that it is called whenever a class instance is created using a constructor. Here you are telling python that the constructor function must take 2 arguments. But wait what is this self argument that the constructor is taking? __init__ always takes self as the first argument and the rest of the arguments can be applied as attributes like we are doing here. Attributes are called using the . syntax on the variable that is holding the instance. a = Person("Batman", 999999999)
init. The constructor will take two arguments a name and the money that the person has. Note that you don't pass three arguments but only two this is because self is a special argument that gets passed onto itself already that you don't have to worry about hence self.print(a.name)
print(a.money)
print(a.population)
k = Person("Superman", 100000)
print(k.name)
print(k.money)
print(k.population)
a.population = 3
print(a.population)
print(k.population)
So your main function should look like this now.
def main():
a = Person("Batman", 999999999)
print(a.name)
print(a.money)
print(a.population)
k = Person("Superman", 100000)
print(k.name)
print(k.money)
print(k.population)
a.population = 3
print(a.population)
print(k.population)
This is the result:
Batman
999999999
1
Superman
100000
1
3
1
Now running this will result seeing that the a.population results in 3 while the k.population is still 1. So you can change an attribute using the dot syntax and the attribute name of the instance followed by the assignment operator to set the attribute for that specific instance to a different value just like you do for other variables expect it will be specific for that instance alone.
Lets look at another feature of classes. So lets change our entire python file to this.
class Person:
population = 0
def __init__(self, name, money):
self.name = name
self.money = money
def getname(self):
print(self.name)
def getmoney(self):
print(self.money)
def getpopulation(self):
print(self.population)
def main():
a = Person("Batman", 999999999)
k = Person("Superman", 100000)
print("Batman info:")
a.getname()
a.getmoney()
a.getpopulation()
print("Superman info:")
k.getname()
k.getmoney()
k.getpopulation()
main()
Batman info:
Batman
999999999
0
Superman info:
Superman
100000
0
print("Batman info:")
a.getname()
a.getmoney()
a.getpopulation()
print("Superman info:")
k.getname()
k.getmoney()
k.getpopulation()
Lets review because there is quite a bit that was talked about here but maybe not fully discussed about. First we have the whole concept of classes. For now classes can be thought of has a seperate namespace that you have with variables in that namespace.
Attributes are very much like variables that are specific to the instance. Instances being what is created when using a constructor which is how we created the Batman and Superman instances from the class Person. The constructor looks for a template on how to make the instance and then creates it using the "init" function that is called when an instance is made. The init function should not be treated like a normal function within the class. It is ONLY called when you create an instance such as when batman and superman was first created by calling the constructor. The constructor calls init if there is one and that is the only way that function gets called. Until you make another instance that is then it is called again for that instance.
I threw around a lot of words and it may still not click much for you what exactly instances, classes, constructors are exactly. However it just takes time to get used to seeing them and practice making your own classes and playing around with them to figure what what they can be or can't be.
I didnt go over too well what exactly the a and k are doing but they are essentially objects holding the instance. You can check this using type on both a and k by adding the following lines at the end of the main function.
print(type(a))
print(type(k))
You'll see from the result that both a and k are of class Person.
Now that you have created classes you can greatly abstract your programs with all kinds of self created classes. However be weary that not all cases call for classes. You can sometimes just write a function instead of actually make an entire class for it. Knowing the difference between when to create a function or a class can sometimes be tricky but generally you should try to create functions. The only time you need to create a class if you need to create objects that require specific individual attributes and need to be manipulated in a special way that a function would constrict you from doing.