Methods

Author: Wisteli-ShikhaPandey

Diff for: Methods/.gitignore

@@ -0,0 +1,5 @@
+# ignore all logs
+*.log   
+# ignore cache
+__pycache__
+*.pyc

Diff for: Methods/methods.py

@@ -0,0 +1,63 @@
+class MyClass:
+    def method(self):
+        return 'instance method called', self
+
+    @classmethod
+    def classmethod(cls):
+        return 'class method called', cls
+
+    @staticmethod
+    def staticmethod():
+        return 'static method called'
+
+'''
+Instance Methods-
+The first method on MyClass, called method, is a regular instance method.
+the method takes one parameter, self, which points to an instance of MyClass when the method is called 
+(but of course instance methods can accept more than just one parameter).
+
+It can modify object's state and class state.
+Through the self parameter, instance methods can freely access attributes and other methods on the same object. 
+Not only can they modify object state, instance methods can also access the class itself through the self.__class__ attribute. This means instance methods can also modify class state.
+'''
+'''
+>>> obj = MyClass()
+>>> obj.method()
+('instance method called', <MyClass instance at 0x10205d190>)
+This confirmed that method (the instance method) has access to the object instance (printed as <MyClass instance>) via the self argument.
+
+When the method is called, Python replaces the self argument with the instance object, obj.
+
+we can also do like this 
+>>> MyClass.method(obj)
+('instance method called', <MyClass instance at 0x10205d190>)
+'''
+
+'''
+Class Methods-
+@classmethod decorator to flag it as a class method.
+
+Instead of accepting a self parameter, class methods take a cls parameter that points to the class—and not the object instance—when the method is called.
+Because the class method only has access to this cls argument, it can’t modify object instance state. 
+That would require access to self. 
+However, class methods can still modify class state that applies across all instances of the class.
+'''
+'''
+>>> obj.classmethod()
+('class method called', <class MyClass at 0x101a2f4c8>)
+Calling classmethod() showed us it doesn’t have access to the <MyClass instance> object, but only to the <class MyClass> object, representing the class itself (everything in Python is an object, even classes themselves).
+'''
+
+'''
+Static Methods-
+ @staticmethod decorator to flag it as a static method.
+
+This type of method takes neither a self nor a cls parameter (but of course it’s free to accept an arbitrary number of other parameters).
+
+Therefore a static method can neither modify object state nor class state.
+Static methods are restricted in what data they can access - and they’re primarily a way to namespace your methods.
+'''
+'''
+>>> obj.staticmethod()
+'static method called'
+'''

Diff for: README.md

@@ -2,9 +2,10 @@
 
 00. [OOPs](https://github.com/Shikha-code36/Object-Oriented-Programming-OOPs-Python#what-do-you-understand-by-oops)
 01. [Classes](https://github.com/Shikha-code36/Object-Oriented-Programming-OOPs-Python#01-classes)
-02. [Methods/Functions](https://github.com/Shikha-code36/Object-Oriented-Programming-OOPs-Python#02-methodsfunctions)
+02. [Methods-Functions](https://github.com/Shikha-code36/Object-Oriented-Programming-OOPs-Python#02-methodsfunctions)
 03. [Objects](https://github.com/Shikha-code36/Object-Oriented-Programming-OOPs-Python#03-objects)
 04. [Constructors](https://github.com/Shikha-code36/Object-Oriented-Programming-OOPs-Python#04-constructors)
+05. [Inheritance](https://github.com/Shikha-code36/Object-Oriented-Programming-OOPs-Python#04-constructors)
 
 ------------
 ## What do you understand by OOPs?
@@ -32,9 +33,11 @@ class myClass():
 ------------
 ------------
 
-#### 02. Methods/Functions
+#### 02. Methods-Functions
 
 - Inside classes, you can define functions or methods that are part of this class
+- Difference between functions and methods
+    * Functions can be called only by its name, as it is defined independently. But methods can't be called by its name only, we need to invoke the class by a reference of that class in which it is defined, i.e. method is defined within a class and hence they are dependent on that class.
 
 ```
 def method1 (self):
@@ -57,6 +60,11 @@ class myClass():
     - “self”
         - The self-argument refers to the object itself. Hence the use of the word self. So inside this method, self will refer to the specific instance of this object that’s being operated on.
         - Self is the name preferred by convention by Pythons to indicate the first parameter of instance methods in Python. It is part of the Python syntax to access members of objects
+
+- Types of methods- [Check code for reference](Methods/methods.py))
+    * Instance Method
+    * Class Method
+    * Static Method
 ------------
 ------------
 #### 03. Objects
@@ -107,4 +115,9 @@ The __init__ method lets the class initialize the object's attributes and serves
 def __init__(self):
     # body of the constructor
 ```
+------------
+------------
+#### 05. Inheritance
+
+
 ------------