{"id":11679,"date":"2016-03-28T16:15:10","date_gmt":"2016-03-28T13:15:10","guid":{"rendered":"http:\/\/www.webcodegeeks.com\/?p=11679"},"modified":"2018-01-09T09:42:31","modified_gmt":"2018-01-09T07:42:31","slug":"python-class-example","status":"publish","type":"post","link":"https:\/\/www.webcodegeeks.com\/python\/python-class-example\/","title":{"rendered":"Python Class Example"},"content":{"rendered":"

In this tutorial, we’ll talk about classes<\/em>. By using Python 3.4, we will talk about what classes are, how do we use them and what can we do with them.<\/p>\n

Python is an object-oriented programming language, and as such it has a class mechanism. Classes are extensible templates for creating objects, providing initial values for state (variables) and implementation of behavior (functions and methods).
\n 
\n 
\n 
\n 
\n[ulp id=’R7QVpFMZmjosABLC’]
\n 
\nCompared with other languages, Python’s class mechanism adds classes with a minimum of new syntax. See:<\/p>\n

\r\nclass ClassName:\r\n    body\r\n<\/pre>\n
The only new thing we need to learn to create a class as simple as this one is the keyword class<\/code>, pretty simple. To get an instance of this class, we don’t need to add a new keyword to our dictionary, we just do my_var = ClassName()<\/code>, and now my_var<\/code> is an instance of ClassName<\/code>. Still simple.<\/p>\n
Let’s talk about the body<\/em> of a class. When we define a class, its body is executed, in other words if we write a script that contains only the next piece of code:<\/p>\n
simple.py<\/em><\/span><\/p>\n
\r\nclass MyBodyWillBeExecuted:\r\n    print(\"MyBodyWillBeExecuted is being defined\")\r\n<\/pre>\n
By running it, like python3 simple.py<\/code>, the output will say:<\/p>\n
\r\n$ python3 simple.py\r\nMyBodyWillBeExecuted is being defined\r\n<\/pre>\n
And that is actually how class variables are defined, but before we see an example, let’s see a definition. Class variables are variables that are available at class level, all instances of a class will be able to access these variables. If you come from Java, you can think of them as static variables. Now, let’s see:<\/p>\n
simple.py<\/em><\/span><\/p>\n
\r\nclass MyBodyWillBeExecuted:\r\n    class_variable = \"a value\"\r\n<\/pre>\n
Now MyBodyWillBeExecuted<\/code> has a class variable, every instance of MyBodyWillBeExecuted<\/code> will be able to read class_variable<\/code>. Now, as in every other OOP language that I know of, classes in Python have constructors.<\/p>\n
A constructor in Python is a function that is executed when an instance of its class is created, and is always called __init__<\/code>, let’s see:<\/p>\n
simple.py<\/em><\/span><\/p>\n
\r\nclass MyBodyWillBeExecuted:\r\n    print(\"this print is executed when the class is defined\")\r\n    class_variable = \"a value\"\r\n\r\n    def __init__(self):\r\n        print(\"this print is executed when an instance of this class is created\")\r\n\r\na = MyBodyWillBeExecuted()\r\nb = MyBodyWillBeExecuted()\r\n<\/pre>\n
That __init__(self)<\/code> is the constructor of our class. This function receives a parameter, self<\/code>, we’ll talk about this later. Now, let’s see the output of this script:<\/p>\n
\r\n$ python3 simple.py\r\nthis print is executed when the class is defined\r\nthis print is executed when an instance of this class is created\r\nthis print is executed when an instance of this class is created\r\n<\/pre>\n
As you see, the “this print is executed when the class is defined”<\/em> message is printed once when we defined the class, and the “this print is executed when an instance of this class is created”<\/em> message is printed twice, once for every instance of MyBodyWillBeExecuted<\/code> we create.<\/p>\n
Let’s talk about that self<\/code> argument. In Python, there are no shorthands for referencing the object\u2019s members from its methods\/functions, the method\/function is defined with an explicit first argument representing the object, which is provided implicitly by the call. This is not specific to the __init__<\/code> method, but for all instance methods. This might seem a little weird, but you’ll get the hang of it by practice.<\/p>\n
Now that we’ve cleared out that self<\/code> argument, we can talk about instance variables. To create a variable in an instance of a class, you need to assign its value to a property of self<\/code>. Let’s see:<\/p>\n
simple.py<\/em><\/span><\/p>\n
\r\nclass MyBodyWillBeExecuted:\r\n    class_variable = \"a value\"\r\n\r\n    def __init__(self, n):\r\n        self.n = n\r\n\r\na = MyBodyWillBeExecuted(1)\r\nb = MyBodyWillBeExecuted(2)\r\n\r\nprint(a.n)\r\nprint(b.n)\r\n<\/pre>\n
The new script changed the constructor signature, as it now receives an argument n<\/code> and assigns it to self.n<\/code>. That self.n<\/code> will be available in every instance of that class, as we see in the print statements that are printing a.n<\/code> and b.n<\/code>. The output below.<\/p>\n
\r\n$ python3 simple.py\r\n1\r\n2\r\n<\/pre>\n
Now, let’s access that variable from another method, called add_one<\/code>:<\/p>\n
simple.py<\/em><\/span><\/p>\n
\r\nclass MyBodyWillBeExecuted:\r\n    class_variable = \"a value\"\r\n\r\n    def __init__(self, n):\r\n        self.n = n\r\n\r\n    def add_one(self):\r\n        self.n += 1\r\n        return self.n\r\n\r\na = MyBodyWillBeExecuted(1)\r\nb = MyBodyWillBeExecuted(2)\r\n\r\nwhile a.n < 10:\r\n    a.add_one()\r\n\r\nprint(a.n)\r\nprint(b.n)\r\n<\/pre>\n
From another function now, we are accessing the instance variable n<\/code>, by doing self.n<\/code>. Let’s see the output.<\/p>\n
\r\n$ python3 simple.py\r\n10\r\n2\r\n<\/pre>\n
One thing that’s worth noticing here, is that we have made all variables and functions public until now… well, that’s actually not optional, Python doesn’t provide a way of making things private. Instead, there is a convention, every name prefixed with an underscore should be treated as a non-public part of the class.<\/p>\n
Let’s see an example of this:<\/p>\n
simple.py<\/em><\/span><\/p>\n
\r\nclass MyBodyWillBeExecuted:\r\n    class_variable = \"a value\"\r\n\r\n    def __init__(self, n):\r\n        self.n = n\r\n\r\n    def _add(self, n):\r\n        self.n += n\r\n\r\n    def add_one(self):\r\n        self._add(1)\r\n        return self.n\r\n\r\na = MyBodyWillBeExecuted(1)\r\nb = MyBodyWillBeExecuted(2)\r\n\r\nwhile a.n < 10:\r\n    a.add_one()\r\n\r\nb._add(1)\r\n\r\nprint(a.n)\r\nprint(b.n)\r\n<\/pre>\n
We defined a new method called _add<\/code> that receives a number as argument and adds it to self.n<\/code>. This method will be available outside of the instance, as you can see when we do b._add(1)<\/code>, but you shouldn’t call this method from outside, it’s a convention that almost every Python programmer knows and follows.<\/p>\n
Also, Python provides a mechanism to hide things to prevent them from being accessed from outside a class, but let’s make it clear, it is not making anything private. If you name a member of a class with two underscores as prefix, Python will internally change its name to include the class name, this means that if you have an attribute called __private_member<\/code> in a class called AClass<\/code>, Python will internally rename this attribute _AClass__private_member<\/code> and refactor every internal calls, but not external ones. Of course, you can still access this member by doing instance._AClass__private_member<\/code>, so it is not actually private. I don’t really do this often, but maybe I should, I just really don’t see the point.<\/p>\n
Let’s do some recap. We’ve talked about classes syntax, constructors, class variables and instance variables and instance methods\/functions, let’s talk about destructors<\/em>.<\/p>\n
As you might know, Python deletes unreferenced objects automatically to free memory space (garbage collection). This process runs during program execution and it’s triggered when an object’s reference count reaches zero. An object’s reference count increases when it is assigned a new name or placed in a container (list, tuple, or dictionary). The object’s reference count decreases when it’s deleted with del, its reference is reassigned, or its reference goes out of scope. When an object’s reference count reaches zero, Python collects it automatically.<\/p>\n
In most cases (integers, strings, list, dictionaries, etc.), you won’t notice when an object is deleted, but a class can implement the __del__<\/code> method, which will be invoked right before the instance is destroyed. This method was meant to be used to release non memory resources an instance may use (files, sockets, etc.). Let’s see:<\/p>\n
simple.py<\/em><\/span><\/p>\n
\r\nclass MyBodyWillBeExecuted:\r\n    class_variable = \"a value\"\r\n\r\n    def __init__(self, n):\r\n        self.n = n\r\n\r\n    def _add(self, n):\r\n        self.n += n\r\n\r\n    def add_one(self):\r\n        self._add(1)\r\n        return self.n\r\n\r\n    def __del__(self):\r\n        print(\"I'm being destroyed... Goodbye world!\")\r\n\r\na = MyBodyWillBeExecuted(1)\r\nb = MyBodyWillBeExecuted(2)\r\n\r\nwhile a.n < 10:\r\n    a.add_one()\r\n\r\nb._add(1)\r\n\r\nprint(a.n)\r\n\r\na = None\r\n\r\nprint(b.n)\r\n<\/pre>\n
Every instance of this class will print “I’m being destroyed… Goodbye world!”<\/em> when Python is about to destroy it and reclaim the memory consumed by it. So, let’s predict what is going to happen:<\/p>\n