practice

Following code is practiced form below url https://www.codementor.io/python/tutorial/essential-python-interview-questions

Author: anjali-92

Composition_Obj_Constrcution.py

@@ -0,0 +1,50 @@
+class Node(object):
+    def __init__(self,sName):
+        self._lChildren = []
+        self.sName = sName
+    def __repr__(self):
+        return "<Node '{}'>".format(self.sName)
+    def append(self,*args,**kwargs):
+        self._lChildren.append(*args,**kwargs)
+    def print_all_1(self):
+        print(self)
+        for oChild in self._lChildren:
+            oChild.print_all_1()
+    def print_all_2(self):
+        def gen(o):
+            lAll = [o,]
+            while lAll:
+                oNext = lAll.pop(0)
+                lAll.extend(oNext._lChildren)
+                print lAll
+                yield oNext
+        for oNode in gen(self):
+            print(oNode)
+
+oRoot = Node("root")
+oChild1 = Node("child1")
+oChild2 = Node("child2")
+oChild3 = Node("child3")
+oChild4 = Node("child4")
+oChild5 = Node("child5")
+oChild6 = Node("child6")
+oChild7 = Node("child7")
+oChild8 = Node("child8")
+oChild9 = Node("child9")
+oChild10 = Node("child10")
+
+oRoot.append(oChild1)
+oRoot.append(oChild2)
+oRoot.append(oChild3)
+oChild1.append(oChild4)
+oChild1.append(oChild5)
+oChild2.append(oChild6)
+oChild4.append(oChild7)
+oChild3.append(oChild8)
+oChild3.append(oChild9)
+oChild6.append(oChild10)
+
+# specify output from here onwards
+
+oRoot.print_all_1()
+oRoot.print_all_2()

Inheritence_Super.py

@@ -0,0 +1,58 @@
+class A(object):
+    def go(self):
+        print("go A go!")
+    def stop(self):
+        print("stop A stop!")
+    def pause(self):
+        raise Exception("Not Implemented")
+
+class B(A):
+    def go(self):
+        super(B, self).go()
+        print("go B go!")
+
+class C(A):
+    def go(self):
+        super(C, self).go()
+        print("go C go!")
+    def stop(self):
+        super(C, self).stop()
+        print("stop C stop!")
+
+class D(B,C):
+    def go(self):
+        super(D, self).go()
+        print("go D go!")
+    def stop(self):
+        super(D, self).stop()
+        print("stop D stop!")
+    def pause(self):
+        print("wait D wait!")
+
+class E(B,C): pass
+
+a = A()
+b = B()
+c = C()
+d = D()
+e = E()
+
+# specify output from here onwards
+
+a.go()	#A
+b.go()	#A B
+c.go()  #A C
+d.go()  #A C B D
+e.go()  #A C B
+
+a.stop()	#A
+b.stop()	#A
+c.stop()	#A C
+d.stop()	#A C D
+e.stop()	#A C
+
+a.pause()
+b.pause()
+c.pause()
+d.pause()
+e.pause()

ex2.py

@@ -0,0 +1,10 @@
+from collection import OrderedDict
+f = file('ex2.txt','r');
+dict1 = {}
+
+for line in f.readlines():
+	tokens = line.split(':',3)
+	dict1[tokens[0]] = int(tokens[2])
+	
+print OrderedDict(sorted(dict1.items(),key=lambda x: t[0]))
+

static_class_method.py

@@ -0,0 +1,97 @@
+class MyClass(object):
+    def __init__(self):
+        self._some_property = "properties are nice"
+        self._some_other_property = "VERY nice"
+    def normal_method(*args,**kwargs):
+        print("calling normal_method({0},{1})".format(args,kwargs))
+    @classmethod
+    def class_method(*args,**kwargs):
+        print("calling class_method({0},{1})".format(args,kwargs))
+    @staticmethod
+    def static_method(*args,**kwargs):
+        print("calling static_method({0},{1})".format(args,kwargs))
+    @property
+    def some_property(self,*args,**kwargs):
+        print("calling some_property getter({0},{1},{2})".format(self,args,kwargs))
+        return self._some_property
+    @some_property.setter
+    def some_property(self,*args,**kwargs):
+        print("calling some_property setter({0},{1},{2})".format(self,args,kwargs))
+        self._some_property = args[0]
+    @property
+    def some_other_property(self,*args,**kwargs):
+        print("calling some_other_property getter({0},{1},{2})".format(self,args,kwargs))
+        return self._some_other_property
+
+o = MyClass()
+# undecorated methods work like normal, they get the current instance (self) as the first argument
+
+o.normal_method 
+# <bound method MyClass.normal_method of <__main__.MyClass instance at 0x7fdd2537ea28>>
+
+o.normal_method() 
+# normal_method((<__main__.MyClass instance at 0x7fdd2537ea28>,),{})
+
+o.normal_method(1,2,x=3,y=4) 
+# normal_method((<__main__.MyClass instance at 0x7fdd2537ea28>, 1, 2),{'y': 4, 'x': 3})
+
+# class methods always get the class as the first argument
+
+o.class_method
+# <bound method classobj.class_method of <class __main__.MyClass at 0x7fdd2536a390>>
+
+o.class_method()
+# class_method((<class __main__.MyClass at 0x7fdd2536a390>,),{})
+
+o.class_method(1,2,x=3,y=4)
+# class_method((<class __main__.MyClass at 0x7fdd2536a390>, 1, 2),{'y': 4, 'x': 3})
+
+# static methods have no arguments except the ones you pass in when you call them
+
+o.static_method
+# <function static_method at 0x7fdd25375848>
+
+o.static_method()
+# static_method((),{})
+
+o.static_method(1,2,x=3,y=4)
+# static_method((1, 2),{'y': 4, 'x': 3})
+
+# properties are a way of implementing getters and setters. It's an error to explicitly call them
+# "read only" attributes can be specified by creating a getter without a setter (as in some_other_property)
+
+o.some_property
+# calling some_property getter(<__main__.MyClass instance at 0x7fb2b70877e8>,(),{})
+# 'properties are nice'
+
+o.some_property()
+# calling some_property getter(<__main__.MyClass instance at 0x7fb2b70877e8>,(),{})
+# Traceback (most recent call last):
+#   File "<stdin>", line 1, in <module>
+# TypeError: 'str' object is not callable
+
+o.some_other_property
+# calling some_other_property getter(<__main__.MyClass instance at 0x7fb2b70877e8>,(),{})
+# 'VERY nice'
+
+# o.some_other_property()
+# calling some_other_property getter(<__main__.MyClass instance at 0x7fb2b70877e8>,(),{})
+# Traceback (most recent call last):
+#   File "<stdin>", line 1, in <module>
+# TypeError: 'str' object is not callable
+
+o.some_property = "groovy"
+# calling some_property setter(<__main__.MyClass object at 0x7fb2b7077890>,('groovy',),{})
+
+o.some_property
+# calling some_property getter(<__main__.MyClass object at 0x7fb2b7077890>,(),{})
+# 'groovy'
+
+o.some_other_property = "very groovy"
+# Traceback (most recent call last):
+#   File "<stdin>", line 1, in <module>
+# AttributeError: can't set attribute
+
+o.some_other_property
+# calling some_other_property getter(<__main__.MyClass object at 0x7fb2b7077890>,(),{})
+# 'VERY nice'

variable_arguments.py

@@ -0,0 +1,32 @@
+def f(*args,**kwargs): print(args, kwargs)
+
+l = [1,2,3]
+t = (4,5,6)
+d = {'a':7,'b':8,'c':9}
+
+f()
+f(1,2,3)                    # (1, 2, 3) {}
+f(1,2,3,"groovy")           # (1, 2, 3, 'groovy') {}
+f(a=1,b=2,c=3)              # () {'a': 1, 'c': 3, 'b': 2}
+f(a=1,b=2,c=3,zzz="hi")     # () {'a': 1, 'c': 3, 'b': 2, 'zzz': 'hi'}
+f(1,2,3,a=1,b=2,c=3)        # (1, 2, 3) {'a': 1, 'c': 3, 'b': 2}
+
+f(*l,**d)                   # (1, 2, 3) {'a': 7, 'c': 9, 'b': 8}
+f(*t,**d)                   # (4, 5, 6) {'a': 7, 'c': 9, 'b': 8}
+f(1,2,*t)                   # (1, 2, 4, 5, 6) {}
+f(q="winning",**d)          # () {'a': 7, 'q': 'winning', 'c': 9, 'b': 8}
+f(1,2,*t,q="winning",**d)   # (1, 2, 4, 5, 6) {'a': 7, 'q': 'winning', 'c': 9, 'b': 8}
+
+def f2(arg1,arg2,*args,**kwargs): print(arg1,arg2, args, kwargs)
+
+f2(1,2,3)                       # 1 2 (3,) {}
+f2(1,2,3,"groovy")              # 1 2 (3, 'groovy') {}
+f2(arg1=1,arg2=2,c=3)           # 1 2 () {'c': 3}
+f2(arg1=1,arg2=2,c=3,zzz="hi")  # 1 2 () {'c': 3, 'zzz': 'hi'}
+f2(1,2,3,a=1,b=2,c=3)           # 1 2 (3,) {'a': 1, 'c': 3, 'b': 2}
+
+f2(*l,**d)                   # 1 2 (3,) {'a': 7, 'c': 9, 'b': 8}
+f2(*t,**d)                   # 4 5 (6,) {'a': 7, 'c': 9, 'b': 8}
+f2(1,2,*t)                   # 1 2 (4, 5, 6) {}
+f2(1,1,q="winning",**d)      # 1 1 () {'a': 7, 'q': 'winning', 'c': 9, 'b': 8}
+f2(1,2,*t,q="winning",**d)   # 1 2 (4, 5, 6) {'a': 7, 'q': 'winning', 'c': 9, 'b': 8}