- \n
- \n
- \n
- superclasses are always presented above<\/b> their subclasses;<\/li>\n
- relations between classes are shown as arrows directed from the subclass toward its superclass<\/b>.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
![\"\"](\"http:\/\/miro.borodziuk.eu\/wp-content\/uploads\/OOP.jpg\")
<\/p>\n<\/p>\n
3. Objects are equipped with:<\/p>\n
- \n
- \n
- \n
- a name<\/b> which identifies them and allows us to distinguish between them;<\/li>\n
- a set of properties<\/b> (the set can be empty)<\/li>\n
- a set of methods<\/b> (can be empty, too)<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
<\/p>\n
4. To define a Python class, you need to use the
class<\/code> keyword. For example:<\/p>\nclass This_Is_A_Class:\r\n pass\r\n<\/pre>\n
<\/p>\n
5. To create an object of the previously defined class, you need to use the class as if it were a function. For example:<\/p>\n
this_is_an_object = This_Is_A_Class()<\/pre>\n
<\/p>\n
6. A stack<\/b> is an object designed to store data using the LIFO<\/b> model. It’s an abbreviation for a very clear description of the stack’s behavior: Last In – First Out<\/strong>. The coin that came last onto the stack will leave first. The stack usually performs at least two operations, named<\/p>\n
- \n
- \n
- \n
push <\/strong><\/code>(when a new element is put on the top)<\/li>\npop <\/code><\/strong>(when an existing element is taken away from the top).<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n![\"\"](\"http:\/\/miro.borodziuk.eu\/wp-content\/uploads\/Stack.jpg\")
<\/p>\nThe stack – the procedural approach<\/p>\n
stack = []\r\n\r\ndef push(val):\r\n stack.append(val)\r\n\r\ndef pop():\r\n val = stack[-1]\r\n del stack[-1]\r\n return val\r\n\r\npush(3)\r\npush(2)\r\npush(1)\r\n\r\nprint(pop())\r\nprint(pop())\r\nprint(pop())<\/pre>\n
1<\/code><\/p>\n2<\/code><\/p>\n3<\/code><\/p>\n<\/p>\n
7. Implementing the stack in a procedural model raises several problems which can be solved by the techniques offered by OOP<\/b> (O<\/b>bject O<\/b>riented P<\/b>rogramming):<\/p>\n
<\/p>\n
8. The part of the Python class responsible for creating new objects is called the constructor.<\/b><\/p>\n
- \n
- \n
- \n
- the constructor’s name is always
__init__<\/code><\/strong>;<\/li>\n- it has to have at least one parameter<\/strong>; the parameter is used to represent the newly created object – you can use the parameter to manipulate the object, and to enrich it with the needed properties; you’ll make use of this soon;<\/li>\n
- the obligatory parameter is usually named
self<\/code> <\/strong>– it’s only a convention, but you should follow it – it simplifies the process of reading and understanding your code.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\nclass Stack: # Defining the Stack class.\r\n def __init__(self): # Defining the constructor function.\r\n print(\"Hi!\")\r\n\r\n\r\nstack_object = Stack() # Instantiating the object.<\/pre>\n
<\/p>\n
9. To create a property<\/strong> inside a class it is used a dot notation<\/strong>, just like when invoking methods; this is the general convention for accessing an object’s properties \u000f you need to name the object, put a dot (.) after it, and specify the desired property’s name;<\/p>\n
class Stack:\r\n def __init__(self):\r\n self.stack_list = []\r\n\r\nstack_object = Stack()\r\nprint(len(stack_object.stack_list))\r\n<\/pre>\n
<\/p>\n
10. If we want to hide any of a class’s components from the outside world, we should start its name with
__<\/strong><\/code>. Such components are called private<\/b>.<\/p>\nThe ability to hide (protect) selected values against unauthorized access is called encapsulation<\/strong>; the encapsulated values can be neither accessed nor modified if you want to use them exclusively;<\/p>\n
class Stack:\r\n def __init__(self):\r\n self.__stack_list = []\r\n\r\nstack_object = Stack()\r\nprint(len(stack_object.__stack_list))<\/pre>\n
Traceback (most recent call last):<\/code><\/p>\nFile \"main.py\", line 7, in <module><\/code><\/p>\nprint(len(stack_object.__stack_list))<\/code><\/p>\nAttributeError: 'Stack' object has no attribute '__stack_list'<\/code><\/p>\n<\/p>\n
11. A class method<\/b> is actually a function declared inside the class and able to access all the class’s components. Each class method declaration must contain at least one parameter (always the first one) usually referred to as
self<\/code><\/strong>, and is used by the objects to identify themselves.<\/p>\nclass Stack:\r\n def __init__(self):\r\n self.__stack_list = []\r\n\r\n def push(self, val):\r\n self.__stack_list.append(val)\r\n\r\n def pop(self):\r\n val = self.__stack_list[-1]\r\n del self.__stack_list[-1]\r\n return val\r\n\r\nstack_object = Stack()\r\n\r\nstack_object.push(3)\r\nstack_object.push(2)\r\nstack_object.push(1)\r\n\r\nprint(stack_object.pop())\r\nprint(stack_object.pop())\r\nprint(stack_object.pop())\r\n<\/pre>\n
<\/p>\n
<\/p>\n
12. An instance variable<\/strong> is a property whose existence depends on the creation of an object. Every object can have a different set of instance variables.<\/p>\n
Moreover, they can be freely added to and removed from objects during their lifetime. All object instance variables are stored inside a dedicated dictionary named
__dict__<\/strong><\/code>, contained in every object separately.<\/p>\nclass ExampleClass:\r\n def __init__(self, val = 1):\r\n self.first = val\r\n\r\n def set_second(self, val):\r\n self.second = val\r\n\r\n\r\nexample_object_1 = ExampleClass()\r\nexample_object_2 = ExampleClass(2)\r\n\r\nexample_object_2.set_second(3)\r\n\r\nexample_object_3 = ExampleClass(4)\r\nexample_object_3.third = 5\r\n\r\nprint(example_object_1.__dict__)\r\nprint(example_object_2.__dict__)\r\nprint(example_object_3.__dict__)<\/pre>\n
- \n
- \n
- \n
- the class named
ExampleClass<\/code> has a constructor, which unconditionally creates an instance variable namedfirst<\/code>, and sets it with the value passed through the first argument (from the class user’s perspective) or the second argument (from the constructor’s perspective); note the default value of the parameter – any trick you can do with a regular function parameter can be applied to methods, too;<\/li>\n- the class also has a method which creates another instance variable, named
second<\/code>;<\/li>\n- we’ve created three objects of the class ExampleClass, but all these instances differ:<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
example_object_1<\/code> only has the property named first;<\/p>\nexample_object_2<\/code> has two properties: first and second;<\/p>\nexample_object_3<\/code> has been enriched with a property named third just on the fly, outside the class’s code – this is possible and fully permissible.<\/p>\nThe program’s output clearly shows that our assumptions are correct – here it is:
\n{'first': 1}<\/code>
\n{'second': 3, 'first': 2}<\/code>
\n{'third': 5, 'first': 4}<\/code><\/p>\nThere is one additional conclusion that should be stated here: modifying an instance variable of any object has no impact on all the remaining objects. Instance variables are perfectly isolated from each other.<\/p>\n
<\/p>\n
13. An instance variable<\/strong> can be private when its name starts with
__<\/code><\/strong>, but don’t forget that such a property is still accessible from outside the class using a mangled name constructed as_ClassName__PrivatePropertyName<\/code><\/strong>.<\/p>\nclass ExampleClass:\r\n def __init__(self, val = 1):\r\n self.__first = val\r\n\r\n def set_second(self, val = 2):\r\n self.__second = val\r\n\r\nexample_object_1 = ExampleClass()\r\nexample_object_2 = ExampleClass(2)\r\nexample_object_2.set_second(3)\r\n\r\nexample_object_3 = ExampleClass(4)\r\nexample_object_3.__third = 5\r\n\r\nprint(example_object_1.__dict__)\r\nprint(example_object_2.__dict__)\r\nprint(example_object_3.__dict__)<\/pre>\n
It’s nearly the same as the previous one. The only difference is in the property names. We’ve added two underscores (__) in front of them.<\/p>\n
Output:<\/p>\n
{'_ExampleClass__first': 1}<\/code><\/p>\n{'_ExampleClass__first': 2, '_ExampleClass__second': 3}<\/code><\/p>\n{'_ExampleClass__first': 4, '__third': 5}<\/code><\/p>\nThe name is now fully accessible from outside the class. You can run a code like this:<\/p>\n
print(example_object_1._ExampleClass__first)<\/pre>\n
<\/p>\n
14. A class variable<\/strong> is a property which exists in exactly one copy, and doesn’t need any created object to be accessible. Such variables are not shown as
__dict__<\/code> content.<\/p>\nAll a class’s class variables are stored inside a dedicated dictionary named
__dict__<\/code>, contained in every class separately.<\/p>\nclass ExampleClass:\r\n counter = 0\r\n def __init__(self, val = 1):\r\n self.__first = val\r\n ExampleClass.counter += 1\r\n\r\n\r\nexample_object_1 = ExampleClass()\r\nexample_object_2 = ExampleClass(2)\r\nexample_object_3 = ExampleClass(4)\r\n\r\nprint(example_object_1.__dict__, example_object_1.counter)\r\nprint(example_object_2.__dict__, example_object_2.counter)\r\nprint(example_object_3.__dict__, example_object_3.counter)\r\n\r\n<\/pre>\n
Running the code will cause the following output:
\n{'_ExampleClass__first': 1} 3<\/code>
\n{'_ExampleClass__first': 2} 3<\/code>
\n{'_ExampleClass__first': 4} 3<\/code><\/p>\n- \n
- \n
- \n
- class variables aren’t shown in an object’s
__dict__<\/code> (this is natural as class variables aren’t parts of an object) but you can always try to look into the variable of the same name, but at the class level<\/li>\n- a class variable always presents the same value in all class instances (objects)<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
class ExampleClass:\r\n __counter = 0\r\n def __init__(self, val = 1):\r\n self.__first = val\r\n ExampleClass.__counter += 1\r\n\r\nexample_object_1 = ExampleClass()\r\nexample_object_2 = ExampleClass(2)\r\nexample_object_3 = ExampleClass(4)\r\n\r\nprint(example_object_1.__dict__, example_object_1._ExampleClass__counter)\r\nprint(example_object_2.__dict__, example_object_2._ExampleClass__counter)\r\nprint(example_object_3.__dict__, example_object_3._ExampleClass__counter)<\/pre>\n
{'_ExampleClass__first': 1} 3<\/code><\/p>\n{'_ExampleClass__first': 2} 3<\/code><\/p>\n{'_ExampleClass__first': 4} 3<\/code><\/p>\n<\/p>\n
15. A function named
hasattr(<\/code>) can be used to determine if any object\/class contains a specified property.<\/p>\nclass ExampleClass:\r\n def __init__(self, val):\r\n if val % 2 != 0:\r\n self.a = 1\r\n else:\r\n self.b = 1\r\n\r\n\r\nexample_object = ExampleClass(1)\r\n\r\nprint(example_object.a)\r\nprint(example_object.b)<\/pre>\n
As you can see, accessing a non-existing object (class) attribute causes an
AttributeError<\/code> exception.<\/p>\n1<\/code>
\nTraceback (most recent call last):<\/code>
\nFile \".main.py\", line 11, in <\/code>
\nprint(example_object.b)<\/code>
\nAttributeError: 'ExampleClass' object has no attribute 'b'<\/code><\/p>\nThe
try-except<\/code> instruction gives you the chance to avoid issues with non-existent properties.<\/p>\nclass ExampleClass:\r\n def __init__(self, val):\r\n if val % 2 != 0:\r\n self.a = 1\r\n else:\r\n self.b = 1\r\n\r\nexample_object = ExampleClass(1)\r\nprint(example_object.a)\r\n\r\ntry:\r\n print(example_object.b)\r\nexcept AttributeError:\r\n pass\r\n<\/pre>\n
or utlize the
hasattr()<\/code>:<\/p>\nclass ExampleClass:\r\n def __init__(self, val):\r\n if val % 2 != 0:\r\n self.a = 1\r\n else:\r\n self.b = 1\r\n\r\nexample_object = ExampleClass(1)\r\nprint(example_object.a)\r\n\r\nif hasattr(example_object, 'b'):\r\n print(example_object.b)<\/pre>\n
<\/p>\n
Example:<\/em><\/p>\n
class Sample:\r\n gamma = 0 # Class variable.\r\n def __init__(self):\r\n self.alpha = 1 # Instance variable.\r\n self.__delta = 3 # Private instance variable.\r\n\r\n\r\nobj = Sample()\r\nobj.beta = 2 # Another instance variable (existing only inside the \"obj\" instance.)\r\nprint(obj.__dict__)<\/pre>\n
The code outputs:
\n{'alpha': 1, '_Sample__delta': 3, 'beta': 2}<\/code><\/p>\n<\/p>\n
Example<\/em><\/p>\n
class A: \r\n def __init__(self, v): \r\n pass \r\n\r\na = A(1) \r\nprint(hasattr(a, 'A')) \r\n<\/pre>\n
False<\/code><\/p>\nclass A: \r\n A=1\r\n def __init__(self): \r\n self.a = 0 \r\n\r\n \r\nprint(hasattr(A, 'a')) \r\n<\/pre>\n
False<\/code><\/p>\nclass A: \r\n A=1\r\n def __init__(self): \r\n self.a = 0 \r\n\r\nb=A()\r\nprint(hasattr(A, 'a')) \r\n<\/pre>\n
False<\/code><\/p>\nclass A: \r\n A=1\r\n def __init__(self): \r\n self.a = 0 \r\n\r\nb=A() \r\nprint(hasattr(b, 'A')) \r\n<\/pre>\n
True<\/code><\/p>\nclass A: \r\n A=1\r\n def __init__(self): \r\n self.a = 0 \r\n\r\nb=A() \r\nprint(hasattr(b, 'a')) \r\n<\/pre>\n
True<\/code><\/p>\n<\/p>\n
16. A method<\/strong> is a function embedded inside a class. The first (or only) parameter of each method is usually named
self<\/code>, which is designed to identify the object for which the method is invoked in order to access the object’s properties or invoke its methods. There is one fundamental requirement – a method is obliged to have at least one parameter<\/strong> (there are no such thing as parameterless methods – a method may be invoked without an argument, but not declared without parameters).<\/p>\nIf you want the method to accept parameters other than
self<\/code>, you should: place them afterself<\/code> in the method’s definition; deliver them during invocation without specifying self (as previously) Just like here:<\/p>\nclass Classy:\r\n def method(self, par):\r\n print(\"method:\", par)\r\n\r\nobj = Classy()\r\nobj.method(1)\r\nobj.method(2)\r\nobj.method(3)<\/pre>\n
The code outputs:
\nmethod: 1<\/code>
\nmethod: 2<\/code>
\nmethod: 3<\/code><\/p>\nThe
self<\/code> parameter is used to obtain access to the object’s instance and class variables<\/strong>.<\/p>\nclass Classy:\r\n varia = 2\r\n def method(self):\r\n print(self.varia, self.var)\r\n\r\n\r\nobj = Classy()\r\nobj.var = 3\r\nobj.method()<\/pre>\n
The code outputs:
\n2 3<\/code><\/p>\nThe
self<\/code> parameter is also used to invoke other object\/class methods from inside the class<\/strong>.<\/p>\nclass Classy:\r\n def other(self):\r\n print(\"other\")\r\n\r\n def method(self):\r\n print(\"method\")\r\n self.other()\r\n\r\nobj = Classy()\r\nobj.method()\r\n<\/pre>\n
The code outputs:
\nmethod<\/code>
\nother<\/code><\/p>\n<\/p>\n
17. If a class contains a constructor (a method named
__init__<\/code>) it cannot return any value and cannot be invoked directly.<\/p>\nEverything we’ve said about property name mangling applies to method names, too – a method whose name starts with
__<\/code> is (partially) hidden. The example shows this effect:<\/p>\nclass Classy:\r\n def visible(self):\r\n print(\"visible\")\r\n \r\n def __hidden(self):\r\n print(\"hidden\")\r\n\r\nobj = Classy()\r\nobj.visible()\r\n\r\ntry:\r\n obj.__hidden()\r\nexcept:\r\n print(\"failed\")\r\n\r\nobj._Classy__hidden()<\/pre>\n
visible<\/code>
\nfailed<\/code>
\nhidden<\/code><\/p>\n<\/p>\n
18.\u00a0Each Python class and each Python object is pre-equipped with a set of useful attributes which can be used to examine its capabilities.<\/p>\n
- \n
- One of these – it’s the
__dict__<\/code> <\/strong>property.<\/li>\n<\/ul>\nclass Classy:\r\n varia = 1\r\n def __init__(self):\r\n self.var = 2\r\n\r\n def method(self):\r\n pass\r\n\r\n def __hidden(self):\r\n pass\r\n\r\nobj = Classy()\r\n\r\nprint(obj.__dict__)\r\nprint(Classy.__dict__)\r\n<\/pre>\n
Output:<\/p>\n
{'var': 2}\r\n\r\n{'__module__': '__main__', 'varia': 1, '__init__': <function Classy.__init__ at 0x7fb94adea320>, 'method': <function Classy.method at 0x7fb94adeaef0>, '_Classy__hidden': <function Classy.__hidden at 0x7fb94adeaf80>, '__dict__': <attribute '__dict__' of 'Classy' objects>, '__weakref__': <attribute '__weakref__' of 'Classy' objects>, '__doc__': None}<\/pre>\n<\/p>\n
- \n
- Another built-in property worth mentioning is
__name__<\/code><\/strong>, which is a string. The property contains the name of the class. \u00a0The__name__<\/code> <\/strong>attribute is absent from the object – it exists only inside classes<\/strong>.<\/li>\n<\/ul>\nIf you want to find the class of a particular object, you can use a function named
type()<\/code>, which is able (among other things) to find a class which has been used to instantiate any object.<\/p>\nclass Classy:\r\n pass\r\n\r\nprint(Classy.__name__)\r\nobj = Classy()\r\nprint(type(obj).__name__)\r\n<\/pre>\n
The code outputs:
\nClassy<\/code>
\nClassy<\/code><\/p>\nNote that a statement like this one:<\/p>\n
print(obj.__name__)<\/pre>\n
will cause an error.<\/p>\n
Example:<\/p>\n
class Sample:\r\n def __init__(self):\r\n self.name = Sample.__name__\r\n def myself(self):\r\n print(\"My name is \" + self.name + \" living in a \" + Sample.__module__)\r\n\r\n\r\nobj = Sample()\r\nobj.myself()\r\n<\/pre>\n
The code outputs:<\/p>\n
My name is Sample living in a __main__<\/code><\/p>\n<\/p>\n
- \n
- Additionally, a property named
__module__<\/code> <\/strong>stores the name of the module in which the class has been declared,<\/li>\n<\/ul>\nclass Classy:\r\n pass\r\n\r\nprint(Classy.__module__)\r\nobj = Classy()\r\nprint(obj.__module__)<\/pre>\n
The code outputs:
\n__main__<\/code>
\n__main__<\/code><\/p>\nAny module named
__main__<\/code> is actually not a module, but the file currently being run.<\/p>\n<\/p>\n
- \n
- the property named
__bases__<\/code> <\/strong>is a tuple containing a class’s superclasses.<\/li>\n<\/ul>\nNote: only classes have this attribute – objects don’t.<\/p>\n
class SuperOne:\r\n pass\r\n\r\nclass SuperTwo:\r\n pass\r\n\r\nclass Sub(SuperOne, SuperTwo):\r\n pass\r\n\r\ndef printBases(cls):\r\n print('( ', end='')\r\n\r\n for x in cls.__bases__:\r\n print(x.__name__, end=' ')\r\n print(')')\r\n\r\nprintBases(SuperOne)\r\nprintBases(SuperTwo)\r\nprintBases(Sub)\r\n<\/pre>\nIt will output:
\n( object )<\/code>
\n( object )<\/code>
\n( SuperOne SuperTwo )<\/code><\/p>\n
- the property named
- Additionally, a property named
- Another built-in property worth mentioning is
- a class variable always presents the same value in all class instances (objects)<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
- class variables aren’t shown in an object’s
- the class also has a method which creates another instance variable, named
- the class named
- it has to have at least one parameter<\/strong>; the parameter is used to represent the newly created object – you can use the parameter to manipulate the object, and to enrich it with the needed properties; you’ll make use of this soon;<\/li>\n
- the constructor’s name is always
- a set of properties<\/b> (the set can be empty)<\/li>\n
- a name<\/b> which identifies them and allows us to distinguish between them;<\/li>\n
- relations between classes are shown as arrows directed from the subclass toward its superclass<\/b>.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
- superclasses are always presented above<\/b> their subclasses;<\/li>\n