CLASS

Author: Shikha-code36

Class-Attributes/class-attributes-1.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python2.7
+
+# class-attributes-1.py
+
+# Here we define an attribute under the class `YourClass`
+# as well as an attribute within the function.
+
+# The attribute defined in the class is called `class attributes`
+# and the attribute defined in the function is called `instance attributes`.
+
+
+class YourClass(object):
+    classy = 10
+
+    def set_val(self):
+        self.insty = 100
+
+
+dd = YourClass()
+dd.classy  # This will fetch the class attribute 10.
+dd.set_val()
+dd.insty  # This will fetch the instance attribute 100.
+
+# Once `dd` is instantiated, we can access both the class and instance
+# attributes, ie.. dd.classy and dd.insty.

Class-Attributes/class-attributes-2.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python
+
+# class-attributes-2.py
+
+# The code below shows two important points:
+
+# a) A class attribute can be overridden in an instance, even
+# though it is bad due to breaking Encapsulation.
+
+# b) There is a lookup path for attributes in Python. The first being
+# the method defined within the class, and then the class above it.
+
+# We are overriding the 'classy' class attribute in the instance 'dd'.
+# When it's overridden, the python interpreter reads the overridden value.
+# But once the new value is deleted with 'del', the overridden value is no longer
+# present in the instance, and hence the lookup goes a level above and gets it from
+# the class.
+
+
+class YourClass(object):
+    classy = "class value"
+
+
+dd = YourClass()
+print(dd.classy)  # < This should return the string "class value"
+
+dd.classy = "Instance value"
+print(dd.classy)  # This should return the string "Instance value"
+
+# This will delete the value set for 'dd.classy' in the instance.
+del dd.classy
+# Since the overriding attribute was deleted, this will print 'class value'.
+print(dd.classy)

Class-Attributes/class-instance-attributes-1.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+
+# class-instance-attributes-1.py
+
+# This code shows that an Instance can access it's own
+# attributes as well as Class attributes.
+
+# We have a class attribute named 'count', and we add 1 to
+# it each time we create an instance. This can help count the
+# number of instances at the time of instantiation.
+
+
+class InstanceCounter(object):
+    count = 0
+
+    def __init__(self, val):
+        self.val = val
+        InstanceCounter.count += 1
+
+    def set_val(self, newval):
+        self.val = newval
+
+    def get_val(self):
+        print(self.val)
+
+    def get_count(self):
+        print(InstanceCounter.count)
+
+
+a = InstanceCounter(5)
+b = InstanceCounter(10)
+c = InstanceCounter(15)
+
+for obj in (a, b, c):
+    print("value of obj: %s" % obj.get_val())
+    print("Count : %s" % obj.get_count())

README.md

@@ -30,6 +30,7 @@ In Python, classes are defined by the “Class” keyword
 ```
 class myClass():
 ```
+[Class Attributes]()
 ------------
 ------------