Added new python releated conceptual example and oops example

Author: soham-aubergine

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,24 @@
+# coding=utf-8
+class Cup:
+    def __init__(self, color):
+        self._color = color    # protected variable
+        self.__content = None  # private variable
+
+    def fill(self, beverage):
+        self.__content = beverage
+
+    def empty(self):
+        self.__content = None
+
+    def get_content(self):
+        return self.__content
+
+# By declaring your data member private you mean,
+# that nobody should be able to access it from outside the class,
+# i.e. strong you can’t touch this policy. Python supports a technique
+#  called name mangling. This feature turns every member name prefixed
+# with at least two underscores and suffixed with at most one underscore into _<className><memberName> .
+
+redCup = Cup("red")
+redCup._Cup__content = "tea"
+print redCup.get_content()

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,32 @@
+# coding=utf-8
+class cup:
+    def __init__(self):
+        self.color = None
+        self._content = None  # protected variable
+
+    def fill(self, beverage):
+        self._content = beverage
+
+    def empty(self):
+        self._content = None
+
+    def get_color(self):
+        return self.color
+
+    def get_content(self):
+        return self._content
+
+# Protected member is accessible only from within the class and it’s subclasses.
+
+
+class second_cup():
+    def content(self, content):
+        cup()._content = content
+        print cup().get_content()
+
+cup = cup()
+cup._content = "tea"
+# print cup.get_content()
+print second_cup().content("yes")
+
+

.idea/workspace.xml

@@ -0,0 +1,27 @@
+import json
+from collections import namedtuple
+
+data = '{"name": "John Smith", "hometown": {"name": "New York", "id": 123}, "address": {"city": "Ahmedabad",' \
+       '"pincode": 382345, "country": "india", "state": "gujrat"}, "stock": ["abc", "pqr", "def", "lml"]}'
+
+# list_data = '["abc", "pqr", "def", "lml"]'
+
+# Parse JSON into an object with attributes corresponding to dict keys.
+x = json.loads(data, object_hook=lambda d: namedtuple('X', d.keys())(*d.values()))
+
+# print x.name, x.hometown.name, x.hometown.id, x.address.city
+for single_stock_list in x.stock:
+    pass
+    # print single_stock_list
+
+
+# to reuse it # while developing application | webservice
+def _json_object_hook(d):
+    return namedtuple('X', d.keys())(*d.values())
+
+
+def json2obj(data):
+    return json.loads(data, object_hook=_json_object_hook)
+
+real_object = json2obj(data)
+print real_object.name

accessspecifier/private_example.py

@@ -0,0 +1,107 @@
+# ---------- WARRIORS BATTLE ----------
+# We will create a game with this sample output
+'''
+Sam attacks Paul and deals 9 damage
+Paul is down to 10 health
+Paul attacks Sam and deals 7 damage
+Sam is down to 7 health
+Sam attacks Paul and deals 19 damage
+Paul is down to -9 health
+Paul has Died and Sam is Victorious
+Game Over
+'''
+
+# We will create a Warrior & Battle class
+
+import random
+import math
+
+# Warriors will have names, health, and attack and block maximums
+# They will have the capabilities to attack and block random amounts
+
+
+class Warrior:
+    def __init__(self, name="warrior", health=0, attkMax=0, blockMax=0):
+        self.name = name
+        self.health = health
+        self.attkMax = attkMax
+        self.blockMax = blockMax
+
+    def attack(self):
+        # Randomly calculate the attack amount
+        # random() returns a value from 0.0 to 1.0
+        attkAmt = self.attkMax * (random.random() + .5)
+
+        return attkAmt
+
+    def block(self):
+
+        # Randomly calculate how much of the attack was blocked
+        blockAmt = self.blockMax * (random.random() + .5)
+
+        return blockAmt
+
+# The Battle class will have the capability to loop until 1 Warrior dies
+# The Warriors will each get a turn to attack each turn
+
+
+class Battle:
+
+    def startFight(self, warrior1, warrior2):
+
+        # Continue looping until a Warrior dies switching back and
+        # forth as the Warriors attack each other
+        while True:
+            if self.getAttackResult(warrior1, warrior2) == "Game Over":
+                print("Game Over")
+                break
+
+            if self.getAttackResult(warrior2, warrior1) == "Game Over":
+                print("Game Over")
+                break
+
+    # A function will receive each Warrior that will attack the other
+    # Have the attack and block amounts be integers to make the results clean
+    # Output the results of the fight as it goes
+    # If a Warrior dies return that result to end the looping in the
+    # above function
+
+    # Make this method static because we don't need to use self
+    @staticmethod
+    def getAttackResult(warriorA, warriorB):
+        warriorAAttkAmt = warriorA.attack()
+
+        warriorBBlockAmt = warriorB.block()
+
+        damage2WarriorB = math.ceil(warriorAAttkAmt - warriorBBlockAmt)
+
+        warriorB.health = warriorB.health - damage2WarriorB
+
+        print("{} attacks {} and deals {} damage".format(warriorA.name,
+                                                         warriorB.name, damage2WarriorB))
+
+        print("{} is down to {} health".format(warriorB.name,
+                                               warriorB.health))
+
+        if warriorB.health <= 0:
+            print("{} has Died and {} is Victorious".format(warriorB.name,
+                                                            warriorA.name))
+
+            return "Game Over"
+        else:
+            return "Fight Again"
+
+
+def main():
+
+    # Create 2 Warriors
+    paul = Warrior("Paul", 50, 20, 10)
+    sam = Warrior("Sam", 50, 20, 10)
+
+    # Create Battle object
+    battle = Battle()
+
+    # Initiate Battle
+    battle.startFight(paul, sam)
+
+main()

accessspecifier/protected_example.py

@@ -0,0 +1,24 @@
+# ---------- CUSTOM EXCEPTIONS ----------
+
+# Lets trigger an exception if the user enters a
+# name that contains a number
+
+# Although you won't commonly create your own exceptions
+# this is how you do it
+
+# Create a class that inherits from Exception
+class DogNameError(Exception):
+    def __init__(self, *args, **kwargs):
+        Exception.__init__(self, *args, **kwargs)
+
+
+try:
+    dogName = input("What is your dogs name : ")
+
+    if any(char.isdigit() for char in dogName):
+        # Raise your own exception
+        # You can raise the built in exceptions as well
+        raise DogNameError
+
+except DogNameError:
+    print("Your dogs name can't contain a number")