Add a couple of exercises

SSIA :)

Author: abregman

README.md

@@ -27,6 +27,8 @@
 |Name|Objective & Instructions|Solution|Comments|
 |--------|--------|------|----|
 | Valid Names | [Exercise](exercises/variables/valid_names.md) | [Solution](solutions/variables/valid_names.md) | |
+| Locations or Names | [Exercise](exercises/variables/locations_or_names.md) | [Solution](solutions/variables/locations_or_names.md) | |
+| Types | [Exercise](exercises/variables/types.md) | [Solution](solutions/variables/types.md) | |
 
 ## Booleans
 
@@ -76,6 +78,18 @@
 | My First Function | [Exercise](exercises/functions/my_first_function.md) | [Solution](solutions/functions/my_first_function.md) | |
 | Calculator | [Exercise](exercises/functions/calculator.md) | [Solution](solutions/functions/calculator.md) | |
 | First Class Objects | [Exercise](exercises/functions/first_class_objects.md) | [Solution](solutions/functions/first_class_objects.md) | |
+
+## OOP
+
+|Name|Objective & Instructions|Solution|Comments|
+|--------|--------|------|----|
+| Inheritance | [Exercise](exercises/oop/inheritance.md) | [Solution](solutions/oop/inheritance.md) | |
+
+## Classes
+
+|Name|Objective & Instructions|Solution|Comments|
+|--------|--------|------|----|
+| Attributes | [Exercise](exercises/classes/attributes.md) | [Solution](solutions/classes/attributes.md) | |
 
 ## Magic Methods
 

exercises/oop/inheritance.md

@@ -0,0 +1,66 @@
+## Inheritance
+
+Explain what is inheritance and how does it work in Python
+
+### Solution
+
+By definition inheritance is the mechanism where an object acts as a base of another object, retaining all its
+properties.
+
+So if Class B inherits from Class A, every characteristics from class A will be also available in class B.
+Class A would be the 'Base class' and B class would be the 'derived class'.
+
+This comes handy when you have several classes that share the same functionalities.
+
+The basic syntax is:
+
+class Base: pass
+
+class Derived(Base): pass
+
+A more forged example:
+
+class Animal:
+    def __init__(self):
+        print("and I'm alive!")
+
+    def eat(self, food):
+        print("ñom ñom ñom", food)
+
+class Human(Animal):
+    def __init__(self, name):
+        print('My name is ', name)
+        super().__init__()
+
+    def write_poem(self):
+        print('Foo bar bar foo foo bar!')
+
+class Dog(Animal):
+    def __init__(self, name):
+        print('My name is', name)
+        super().__init__()
+
+    def bark(self):
+        print('woof woof')
+
+
+michael = Human('Michael')
+michael.eat('Spam')
+michael.write_poem()
+
+bruno = Dog('Bruno')
+bruno.eat('bone')
+bruno.bark()
+
+>>> My name is  Michael
+>>> and I'm alive!
+>>> ñom ñom ñom Spam
+>>> Foo bar bar foo foo bar!
+>>> My name is Bruno
+>>> and I'm alive!
+>>> ñom ñom ñom bone
+>>> woof woof
+
+Calling super() calls the Base method, thus, calling super().__init__() we called the Animal __init__.
+
+There is a more advanced python feature called MetaClasses that aid the programmer to directly control class creation.

exercises/variables/locations_or_names.md

@@ -0,0 +1,5 @@
+## Locations or Names
+
+What do you think about the following statement:
+
+In Python, variables are locations, not just names. Each

solutions/classes/attributes.md

@@ -0,0 +1,15 @@
+## Attributes
+
+Explain class attributes vs. instance attributes
+
+### Solution
+
+In the following block of code `x` is a class attribute while `self.y` is a instance attribute
+
+```
+class MyClass(object):
+    x = 1
+
+    def __init__(self, y):
+        self.y = y
+```

solutions/oop/inheritance.md

@@ -0,0 +1,66 @@
+## Inheritance
+
+Explain what is inheritance and how does it work in Python
+
+### Solution
+
+By definition inheritance is the mechanism where an object acts as a base of another object, retaining all its
+properties.
+
+So if Class B inherits from Class A, every characteristics from class A will be also available in class B.
+Class A would be the 'Base class' and B class would be the 'derived class'.
+
+This comes handy when you have several classes that share the same functionalities.
+
+The basic syntax is:
+
+class Base: pass
+
+class Derived(Base): pass
+
+A more forged example:
+
+class Animal:
+    def __init__(self):
+        print("and I'm alive!")
+
+    def eat(self, food):
+        print("ñom ñom ñom", food)
+
+class Human(Animal):
+    def __init__(self, name):
+        print('My name is ', name)
+        super().__init__()
+
+    def write_poem(self):
+        print('Foo bar bar foo foo bar!')
+
+class Dog(Animal):
+    def __init__(self, name):
+        print('My name is', name)
+        super().__init__()
+
+    def bark(self):
+        print('woof woof')
+
+
+michael = Human('Michael')
+michael.eat('Spam')
+michael.write_poem()
+
+bruno = Dog('Bruno')
+bruno.eat('bone')
+bruno.bark()
+
+>>> My name is  Michael
+>>> and I'm alive!
+>>> ñom ñom ñom Spam
+>>> Foo bar bar foo foo bar!
+>>> My name is Bruno
+>>> and I'm alive!
+>>> ñom ñom ñom bone
+>>> woof woof
+
+Calling super() calls the Base method, thus, calling super().__init__() we called the Animal __init__.
+
+There is a more advanced python feature called MetaClasses that aid the programmer to directly control class creation.

solutions/variables/locations_or_names.md

@@ -0,0 +1,12 @@
+## Locations or Names
+
+### Objective
+
+What do you think about the following statement:
+
+In Python, variables are locations, not just names. Each
+
+### Solution
+
+The statement above is wrong. In Python a variable is merely a name, a reference to the object, not the actual object.
+So when for example you perform an assignment, you don't copy the value into the variable, but you assign the object with a name.

solutions/variables/types.md

@@ -0,0 +1,11 @@
+## Types
+
+1. How to check the type of a variable in Python?
+2. How to check if a variable points to an object of an integer type?
+3. How to check type of a literal?
+
+### Solution
+
+1. `type(some_var)`
+2. `isinstance(some_var, int)`
+3. Same way: `type(2017)` and `isinstance(2022, int)`