diff --git a/README.md b/README.md
index dd7e703..b4205fe 100644
--- a/README.md
+++ b/README.md
@@ -26,50 +26,38 @@ Moreover, if you want to add more content to this book then kindly submit a pull
 Table of Contents:
 ------------------
 1) Programmer tools
-
-- [Virtual Environment](virtual_environment.rst)
-- [Debugging](debugging.rst)
-- [Object introspection](object_introspection.rst)
-
+    - [Virtual Environment](virtual_environment.rst)
+    - [Debugging](debugging.rst)
+    - [Object introspection](object_introspection.rst)
 2) Syntax
-
-- [Exceptions](exceptions.rst)
-- [For - Else](for_-_else.rst)
-- [Ternary Operators](ternary_operators.rst)
-- [Global & Return](global_&_return.rst)
-- [Open function](open_function.rst)
-- [\*args and \*\*kwargs](args_and_kwargs.rst)
-- [Context managers](context_managers.rst)
-
+    - [Exceptions](exceptions.rst)
+    - [For - Else](for_-_else.rst)
+    - [Ternary Operators](ternary_operators.rst)
+    - [Global & Return](global_&_return.rst)
+    - [Open function](open_function.rst)
+    - [\*args and \*\*kwargs](args_and_kwargs.rst)
+    - [Context managers](context_managers.rst)
 3) Functional programming
-
-- [Enumerate](enumerate.rst)
-- [Lambdas](lambdas.rst)
-- [``set`` Data Structure](set_-_data_structure.rst)
-- [Map & Filter](map_filter.rst)
-- [Comprehensions](comprehensions.rst)
-
+    - [Enumerate](enumerate.rst)
+    - [Lambdas](lambdas.rst)
+    - [``set`` Data Structure](set_-_data_structure.rst)
+    - [Map & Filter](map_filter.rst)
+    - [Comprehensions](comprehensions.rst)
 4) Data structures
-
-- [Generators](generators.rst)
-- [Coroutines](coroutines.rst)
-
+    - [Generators](generators.rst)
+    - [Coroutines](coroutines.rst)
+    - [Classes](classes.rst)
 5) Data types
-
-- [Collections](collections.rst)
-- [Mutation](mutation.rst)
-- [\_\_slots\_\_ Magic](__slots__magic.rst)
-
+    - [Collections](collections.rst)
+    - [Mutation](mutation.rst)
+    - [\_\_slots\_\_ Magic](__slots__magic.rst)
 6) Decorators
-
-- [What is a decorator?](decorators.rst)
-- [Function caching](function_caching.rst)
-
+    - [What is a decorator?](decorators.rst)
+    - [Function caching](function_caching.rst)
 7) Extras
-
-- [One Liners](one_liners.rst)
-- [Targeting Python 2+3](targeting_python_2_3.rst)
-- [Python C extensions](python_c_extension.rst)
+    - [One Liners](one_liners.rst)
+    - [Targeting Python 2+3](targeting_python_2_3.rst)
+    - [Python C extensions](python_c_extension.rst)
 
 Author:
 ------
@@ -91,6 +79,7 @@ If you want to translate this book in any other language then kindly let [me kno
 - [Russian](https://github.com/lancelote/interpy-ru)
 - [Korean](https://github.com/DDanggle/interpy-kr)
 - [Portuguese](https://github.com/joanasouza/intermediatePython)
+- [Spanish](https://github.com/cursospython/LibroPython)
 
 License:
 -------
@@ -99,6 +88,4 @@ This book is released under the [following](http://creativecommons.org/licenses/
 
 If you end up using/recommending this book to someone then kindly [let me know](mailto:yasoob.khld@gmail.com). :smile:
 
-<a target='_blank' rel='nofollow' href='https://app.codesponsor.io/link/MonCGmEAFsJYSLQeuu5tieGc/yasoob/intermediatePython'>
-  <img alt='Sponsor' width='888' height='68' src='https://app.codesponsor.io/embed/MonCGmEAFsJYSLQeuu5tieGc/yasoob/intermediatePython.svg' />
-</a>
+
diff --git a/_templates/breadcrumbs.html b/_templates/breadcrumbs.html
index 502acda..f3f3b94 100644
--- a/_templates/breadcrumbs.html
+++ b/_templates/breadcrumbs.html
@@ -25,13 +25,14 @@
 {% endif %}
 
 <div role="navigation" aria-label="breadcrumbs navigation">
-
   <div class="admonition note">
-    <p class="first notice admonition-title" style="background: #e45959;">Note</p>
-    <p>Hi! I am currently looking for internships for Summer 2018. If you feel like your company might have some place for me, please reach out. You can check my resume <a href="https://goo.gl/vjg3GG">over here</a> and if you want to get to know about my journey, you can read this article: <a href="https://goo.gl/EMjuPP">How I got into programming</a></p>.
-
+    <p class="first notice admonition-title" style="background: #e45959;">New book released!</p>
+    <p>Hi! I just released the alpha version of my new book; Practical Python Projects. 
+      Learn more about it <a href="https://yasoob.me/posts/practical-python-projects-book-released/">
+      on my blog</a>. In 325+ pages, I will teach you how to implement 12 end-to-end projects. 
+      You can buy it from <a href="https://feld.to/ppp">Feldroy.com</a>.
+    </p>
   </div>
-
   <ul class="wy-breadcrumbs">
     {% block breadcrumbs %}
       <li><a href="{{ pathto(master_doc) }}">{{ _('Docs') }}</a> &raquo;</li>
diff --git a/args_and_kwargs.rst b/args_and_kwargs.rst
index 544742e..85ed174 100644
--- a/args_and_kwargs.rst
+++ b/args_and_kwargs.rst
@@ -3,21 +3,20 @@
 
 I have come to see that most new python programmers have a hard time
 figuring out the \*args and \*\*kwargs magic variables. So what are they
-? First of all let me tell you that it is not necessary to write \*args
+? First of all, let me tell you that it is not necessary to write \*args
 or \*\*kwargs. Only the ``*`` (asterisk) is necessary. You could have
 also written \*var and \*\*vars. Writing \*args and \*\*kwargs is just a
-convention. So now lets take a look at \*args first.
+convention. So now let's take a look at \*args first.
 
 Usage of \*args
 ^^^^^^^^^^^^^^^
 
 \*args and \*\*kwargs are mostly used in function definitions. \*args
-and \*\*kwargs allow you to pass a variable number of arguments to a
-function. What variable means here is that you do not know beforehand
-how many arguments can be passed to your function by the user
-so in this case you use these two keywords. \*args is used to send a
-**non-keyworded** variable length argument list to the function. Here's
-an example to help you get a clear idea:
+and \*\*kwargs allow you to pass an unspecified number of arguments to a
+function, so when writing the function definition, you do not need to
+know how many arguments will be passed to your function. \*args is used to
+send a **non-keyworded** variable length argument list to the function. 
+Here's an example to help you get a clear idea:
 
 .. code:: python
 
diff --git a/classes.rst b/classes.rst
index 3e09bb2..9485307 100644
--- a/classes.rst
+++ b/classes.rst
@@ -53,7 +53,7 @@ Let's take a look at an example:
     b.pi
     # Output: 50
 
-There are not many issues while using mutable class variables. This is
+There are not many issues while using immutable class variables. This is
 the major reason due to which beginners do not try to learn more about
 this subject because everything works! If you also believe that instance
 and class variables can not cause any problem if used incorrectly then
@@ -159,7 +159,7 @@ its ``__init__`` method is called. For example:
     # called
 
 You can see that ``__init__`` is called immediately after an instance is
-created. You can also pass arguments to the class during it's
+created. You can also pass arguments to the class during its
 initialization. Like this:
 
 .. code:: python
@@ -200,23 +200,24 @@ Implementing **getitem** in a class allows its instances to use the []
         def __getitem__(self,i):
             return self.info[i]
 
-    foo = OldClass()
-    foo['title']
+    foo = GetTest()
+
+    foo['name']
     # Output: 'Yasoob'
 
     foo['number']
-    # Output: 36845124
+    # Output: 12345812
 
 Without the ``__getitem__`` method we would have got this error:
 
 .. code:: python
 
-    >>> foo['title']
+    >>> foo['name']
 
     Traceback (most recent call last):
       File "<stdin>", line 1, in <module>
     TypeError: 'GetTest' object has no attribute '__getitem__'
 
-Static, Class & Abstract methods
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+.. Static, Class & Abstract methods
+.. ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/collections.rst b/collections.rst
index c09a3bf..f668ca6 100644
--- a/collections.rst
+++ b/collections.rst
@@ -9,7 +9,7 @@ The ones which we will talk about are:
 
 -  ``defaultdict``
 -  ``OrderedDict``
--  ``counter``
+-  ``Counter``
 -  ``deque``
 -  ``namedtuple``
 -  ``enum.Enum`` (outside of the module; Python 3.4+)
@@ -68,8 +68,8 @@ share a solution using ``defaultdict``.
 
 .. code:: python
 
-    import collections
-    tree = lambda: collections.defaultdict(tree)
+    from collections import defaultdict
+    tree = lambda: defaultdict(tree)
     some_dict = tree()
     some_dict['colours']['favourite'] = "yellow"
     # Works fine
@@ -119,7 +119,7 @@ the end of the dictionary.
     #   Blue 160
     # Insertion order is preserved
 
-``counter``
+``Counter``
 ^^^^^^^^^^^^^^^
 
 Counter allows us to count the occurrences of a particular item. For
@@ -216,9 +216,15 @@ example so here you go:
 
 .. code:: python
 
-    d = deque(maxlen=30)
+    d = deque([0, 1, 2, 3, 5], maxlen=5)
+    print(d)
+    # Output: deque([0, 1, 2, 3, 5], maxlen=5)
+    
+    d.extend([6])
+    print(d)
+    #Output: deque([1, 2, 3, 5, 6], maxlen=5)
 
-Now whenever you insert values after 30, the leftmost value will be
+Now whenever you insert values after 5, the leftmost value will be
 popped from the list. You can also expand the list in any direction with
 new values:
 
diff --git a/comprehensions.rst b/comprehensions.rst
index 43af9cd..1db2a61 100644
--- a/comprehensions.rst
+++ b/comprehensions.rst
@@ -3,12 +3,13 @@ Comprehensions
 
 Comprehensions are a feature of Python which I would really miss if I
 ever have to leave it. Comprehensions are constructs that allow
-sequences to be built from other sequences. Three types of
+sequences to be built from other sequences. Several types of
 comprehensions are supported in both Python 2 and Python 3:
 
 -  list comprehensions
 -  dictionary comprehensions
 -  set comprehensions
+-  generator comprehensions
 
 We will discuss them one by one. Once you get the hang of using ``list``
 comprehensions then you can use any of them easily.
@@ -91,3 +92,17 @@ that they use braces ``{}``. Here is an example:
     squared = {x**2 for x in [1, 1, 2]}
     print(squared)
     # Output: {1, 4}
+
+``generator`` comprehensions
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+They are also similar to list comprehensions. The only difference is that they don't allocate memory for the whole list but generate one item at a time, thus more memory efficient.
+
+.. code:: python
+
+    multiples_gen = (i for i in range(30) if i % 3 == 0)
+    print(multiples_gen)
+    # Output: <generator object <genexpr> at 0x7fdaa8e407d8>
+    for x in multiples_gen:
+      print(x)
+      # Outputs numbers
diff --git a/context_managers.rst b/context_managers.rst
index f3ff506..261ebd6 100644
--- a/context_managers.rst
+++ b/context_managers.rst
@@ -1,4 +1,4 @@
-Context managers
+Context Managers
 ----------------
 
 Context managers allow you to allocate and release resources precisely
@@ -30,16 +30,16 @@ advantage of using a ``with`` statement is that it makes sure our file
 is closed without paying attention to how the nested block exits.
 
 A common use case of context managers is locking and unlocking resources
-and closing opened files (as I have already showed you).
+and closing opened files (as I have already shown you).
 
-Let's see how we can implement our own Context Manager. This would allow
+Let's see how we can implement our own Context Manager. This should allow
 us to understand exactly what's going on behind the scenes.
 
-Implementing Context Manager as a Class:
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Implementing a Context Manager as a Class:
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 At the very least a context manager has an ``__enter__`` and
-``__exit__`` methods defined. Let's make our own file opening Context
+``__exit__`` method defined. Let's make our own file-opening Context
 Manager and learn the basics.
 
 .. code:: python
@@ -52,7 +52,7 @@ Manager and learn the basics.
         def __exit__(self, type, value, traceback):
             self.file_obj.close()
 
-Just by defining ``__enter__`` and ``__exit__`` methods we can use it in
+Just by defining ``__enter__`` and ``__exit__`` methods we can use our new class in
 a ``with`` statement. Let's try:
 
 .. code:: python
@@ -60,20 +60,20 @@ a ``with`` statement. Let's try:
     with File('demo.txt', 'w') as opened_file:
         opened_file.write('Hola!')
 
-Our ``__exit__`` function accepts three arguments. They are required by
+Our ``__exit__`` method accepts three arguments. They are required by
 every ``__exit__`` method which is a part of a Context Manager class.
 Let's talk about what happens under-the-hood.
 
-1. The ``with`` statement stores the ``__exit__`` method of ``File``
+1. The ``with`` statement stores the ``__exit__`` method of the ``File``
    class.
-2. It calls the ``__enter__`` method of ``File`` class.
-3. ``__enter__`` method opens the file and returns it.
-4. the opened file handle is passed to ``opened_file``.
-5. we write to the file using ``.write()``
-6. ``with`` statement calls the stored ``__exit__`` method.
-7. the ``__exit__`` method closes the file.
-
-Handling exceptions
+2. It calls the ``__enter__`` method of the ``File`` class.
+3. The ``__enter__`` method opens the file and returns it.
+4. The opened file handle is passed to ``opened_file``.
+5. We write to the file using ``.write()``.
+6. The ``with`` statement calls the stored ``__exit__`` method.
+7. The ``__exit__`` method closes the file.
+
+Handling Exceptions
 ^^^^^^^^^^^^^^^^^^^
 
 We did not talk about the ``type``, ``value`` and ``traceback``
@@ -92,20 +92,20 @@ instance:
     with File('demo.txt', 'w') as opened_file:
         opened_file.undefined_function('Hola!')
 
-Let's list down the steps which are taken by the ``with`` statement when
-an error is encountered.
+Let's list the steps which are taken by the ``with`` statement when
+an error is encountered:
 
 1. It passes the type, value and traceback of the error to the
    ``__exit__`` method.
 2. It allows the ``__exit__`` method to handle the exception.
-3. If ``__exit__`` returns True then the exception was gracefully
+3. If ``__exit__`` returns ``True`` then the exception was gracefully
    handled.
-4. If anything else than True is returned by the ``__exit__`` method then
-   an exception is raised by the ``with`` statement.
+4. If anything other than ``True`` is returned by the ``__exit__`` method then
+   the exception is raised by the ``with`` statement.
 
 In our case the ``__exit__`` method returns ``None`` (when no return
-statement is encountered then the method returns ``None``). Therefore, the
-``with`` statement raises the exception.
+statement is encountered then the method returns ``None``). Therefore,
+the ``with`` statement raises the exception:
 
 .. code:: python
 
@@ -132,11 +132,11 @@ Let's try handling the exception in the ``__exit__`` method:
 
     # Output: Exception has been handled
 
-Our ``__exit__`` method returned True, therefore no exception was raised
+Our ``__exit__`` method returned ``True``, therefore no exception was raised
 by the ``with`` statement.
 
-This is not the only way to implement context managers. There is another
-way and we will be looking at it in this next section.
+This is not the only way to implement Context Managers. There is another
+way and we will be looking at it in the next section.
 
 Implementing a Context Manager as a Generator
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -153,12 +153,14 @@ Let's see a basic, useless example:
     @contextmanager
     def open_file(name):
         f = open(name, 'w')
-        yield f
-        f.close()
+        try:
+            yield f
+        finally:
+            f.close()
 
-Okay! This way of implementing Context Managers appears to be more
+Okay! This way of implementing Context Managers appear to be more
 intuitive and easy. However, this method requires some knowledge about
-generators, yield, and decorators. In this example we have not caught any
+generators, yield and decorators. In this example we have not caught any
 exceptions which might occur. It works in mostly the same way as the
 previous method.
 
@@ -167,11 +169,11 @@ Let's dissect this method a little.
 1. Python encounters the ``yield`` keyword. Due to this it creates a
    generator instead of a normal function.
 2. Due to the decoration, contextmanager is called with the function
-   name (open\_file) as it's argument.
-3. The ``contextmanager`` function returns the generator wrapped by the
+   name (``open_file``) as its argument.
+3. The ``contextmanager`` decorator returns the generator wrapped by the
    ``GeneratorContextManager`` object.
 4. The ``GeneratorContextManager`` is assigned to the ``open_file``
-   function. Therefore, when we later call ``open_file`` function, we
+   function. Therefore, when we later call the ``open_file`` function, we
    are actually calling the ``GeneratorContextManager`` object.
 
 So now that we know all this, we can use the newly generated Context
@@ -181,4 +183,3 @@ Manager like this:
 
     with open_file('some_file') as f:
         f.write('hola!')
-
diff --git a/debugging.rst b/debugging.rst
index 58af25a..5e591f8 100644
--- a/debugging.rst
+++ b/debugging.rst
@@ -2,14 +2,14 @@ Debugging
 ---------
 
 Debugging is also something which once mastered can greatly enhance your
-bug hunting skills. Most of the newcomers neglect the importance of the
+bug hunting skills. Most newcomers neglect the importance of the
 Python debugger (``pdb``). In this section I am going to tell you only a
 few important commands. You can learn more about it from the official
 documentation.
 
-**Running from commandline**
+**Running from the command line**
 
-You can run a script from the commandline using the Python debugger.
+You can run a script from the command line using the Python debugger.
 Here is an example:
 
 .. code:: python
@@ -58,3 +58,7 @@ function.
 These are just a few commands. ``pdb`` also supports post mortem. It is
 also a really handy function. I would highly suggest you to look at the
 official documentation and learn more about it.
+
+**Note:**
+
+It might seem unintuitive to use `pdb.set_trace()` if you are new to this. Fortunately, if you are using Python 3.7+ then you can simply use the `breakpoint()` [built-in function](https://docs.python.org/3/library/functions.html#breakpoint). It automatically imports `pdb` and calls `pdb.set_trace()`.
diff --git a/decorators.rst b/decorators.rst
index 7bf2609..30509fe 100644
--- a/decorators.rst
+++ b/decorators.rst
@@ -2,8 +2,8 @@ Decorators
 ----------
 
 Decorators are a significant part of Python. In simple words: they are
-functions which modify the functionality of another function. They help
-to make our code shorter and more Pythonic. Most of the beginners do not
+functions which modify the functionality of other functions. They help
+to make our code shorter and more Pythonic. Most beginners do not
 know where to use them so I am going to share some areas where
 decorators can make your code more concise.
 
@@ -176,8 +176,8 @@ previous decorator and make a little bit more usable program:
 
 Did you get it? We just applied the previously learned principles. This
 is exactly what the decorators do in Python! They wrap a function and
-modify its behaviour in one way or the another. Now you might be
-wondering that we did not use the @ anywhere in our code? That is just a
+modify its behaviour in one way or another. Now you might be
+wondering why we did not use the @ anywhere in our code? That is just a
 short way of making up a decorated function. Here is how we could have
 run the previous code sample using @.
 
@@ -206,9 +206,9 @@ Python. Now there is one problem with our code. If we run:
     # Output: wrapTheFunction
 
 That's not what we expected! Its name is
-"a\_function\_requiring\_decoration". Well our function was replaced by
+"a\_function\_requiring\_decoration". Well, our function was replaced by
 wrapTheFunction. It overrode the name and docstring of our function.
-Luckily Python provides us a simple function to solve this problem and
+Luckily, Python provides us a simple function to solve this problem and
 that is ``functools.wraps``. Let's modify our previous example to use
 ``functools.wraps``:
 
@@ -263,7 +263,7 @@ decorators.
 
 Note: ``@wraps`` takes a function to be decorated and adds the
 functionality of copying over the function name, docstring, arguments
-list, etc. This allows to access the pre-decorated function's properties
+list, etc. This allows us to access the pre-decorated function's properties
 in the decorator.
 
 Use-cases:
@@ -273,7 +273,7 @@ Now let's take a look at the areas where decorators really shine and
 their usage makes something really easy to manage.
 
 Authorization
-~~~~~~~~~~~~
+~~~~~~~~~~~~~
 
 Decorators can help to check whether someone is authorized to use an
 endpoint in a web application. They are extensively used in Flask web
@@ -296,7 +296,7 @@ authentication:
         return decorated
 
 Logging
-~~~~~~~~~~~~
+~~~~~~~
 
 Logging is another area where the decorators shine. Here is an example:
 
@@ -329,7 +329,7 @@ Come to think of it, isn't ``@wraps`` also a decorator?  But, it takes an
 argument like any normal function can do.  So, why can't we do that too?
 
 This is because when you use the ``@my_decorator`` syntax, you are
-applying a wrapper function with a single function as a parameter
+applying a wrapper function with a single function as a parameter.
 Remember, everything in Python is an object, and this includes
 functions!  With that in mind, we can write a function that returns
 a wrapper function.
@@ -354,6 +354,7 @@ us specify a logfile to output to.
                 with open(logfile, 'a') as opened_file:
                     # Now we log to the specified logfile
                     opened_file.write(log_string + '\n')
+                return func(*args, **kwargs)
             return wrapped_function
         return logging_decorator
 
@@ -390,18 +391,26 @@ rebuild logit as a class instead of a function.
 .. code:: python
 
     class logit(object):
-        def __init__(self, logfile='out.log'):
-            self.logfile = logfile
+    
+        _logfile = 'out.log'
+    
+        def __init__(self, func):
+            self.func = func
         
-        def __call__(self, func):
-            log_string = func.__name__ + " was called"
+        def __call__(self, *args):
+            log_string = self.func.__name__ + " was called"
             print(log_string)
             # Open the logfile and append
-            with open(self.logfile, 'a') as opened_file:
+            with open(self._logfile, 'a') as opened_file:
                 # Now we log to the specified logfile
                 opened_file.write(log_string + '\n')
             # Now, send a notification
             self.notify()
+            
+            # return base func
+            return self.func(*args)
+            
+            
         
         def notify(self):
             # logit only logs, no more
@@ -412,10 +421,14 @@ the nested function approach, and wrapping a function still will use
 the same syntax as before:
 
 .. code:: python
-
-    @logit()
-    def myfunc1():
+    
+    logit._logfile = 'out2.log' # if change log file
+    @logit
+    def myfunc1():
         pass
+    
+    myfunc1()
+    # Output: myfunc1 was called
 
 Now, let's subclass logit to add email functionality (though this topic
 will not be covered here).
diff --git a/enumerate.rst b/enumerate.rst
index 06719f0..3bcd2f6 100644
--- a/enumerate.rst
+++ b/enumerate.rst
@@ -1,18 +1,25 @@
 Enumerate
 ---------
 
-Enumerate is a built-in function of Python. It's usefulness can not be
+Enumerate is a built-in function of Python. Its usefulness can not be
 summarized in a single line. Yet most of the newcomers and even some
 advanced programmers are unaware of it. It allows us to loop over
 something and have an automatic counter. Here is an example:
 
 .. code:: python
+    
+    my_list = ['apple', 'banana', 'grapes', 'pear']
+    for counter, value in enumerate(my_list):
+        print counter, value
 
-    for counter, value in enumerate(some_list):
-        print(counter, value)
+    # Output:
+    # 0 apple
+    # 1 banana
+    # 2 grapes
+    # 3 pear
 
-And there is more! ``enumerate`` also accepts an optional argument which
-makes it even more useful.
+And there is more! ``enumerate`` also accepts an optional argument that
+allows us to specify the starting index of the counter.
 
 .. code:: python
 
@@ -26,9 +33,9 @@ makes it even more useful.
     # 3 grapes
     # 4 pear
 
-The optional argument allows us to tell ``enumerate`` from where to
-start the index. You can also create tuples containing the index and
-list item using a list. Here is an example:
+An example of where the optional argument of ``enumerate`` comes in handy
+is creating tuples containing the index and list item using a list. Here 
+is an example:
 
 .. code:: python
 
diff --git a/exceptions.rst b/exceptions.rst
index cbe752e..ebeb0d5 100644
--- a/exceptions.rst
+++ b/exceptions.rst
@@ -5,9 +5,11 @@ Exception handling is an art which once you master grants you immense
 powers. I am going to show you some of the ways in which we can handle
 exceptions.
 
-In basic terminology we are aware of ``try/except`` clause. The code
-which can cause an exception to occur is put in the ``try`` block and
+In basic terminology we are aware of the ``try/except`` structure. The code
+that can cause an exception to occur is put in the ``try`` block and
 the handling of the exception is implemented in the ``except`` block.
+The code in the ``except`` block will only execute if the ``try`` block
+runs into an exception.
 Here is a simple example:
 
 .. code:: python
@@ -56,12 +58,20 @@ trapping ALL exceptions:
 
     try:
         file = open('test.txt', 'rb')
-    except Exception:
+    except Exception as e:
         # Some logging if you want
-        raise
+        raise e
+
+This can be helpful when you have no idea about the exceptions that may
+be thrown by your program. If you are just looking to catch all execptions, 
+but don't actually care about what they are, you can even exclude the 
+``Exception as e`` part. 
 
-This can be helpful when you have no idea about the exceptions which may
-be thrown by your program.
+Note:: catching all exceptions may have unintended consequences because catching 
+all exceptions may also catch the ones you want to occur; for example, in 
+many command-line based programs, pressing control+c will terminate the program, 
+but if you catch all excepts, the ``KeyboardInterrupt`` will be caught as an 
+exception, so pressing control+c will NOT terminate the program.
 
 ``finally`` clause
 ~~~~~~~~~~~~~~~~~~
@@ -111,7 +121,7 @@ example:
         print('This would be printed in every case.')
 
     # Output: I am sure no exception is going to occur!
-    # This would only run if no exception occurs.
+    # This would only run if no exception occurs. And an error here would NOT be caught
     # This would be printed in every case.
 
 The ``else`` clause would only run if no exception occurs and it would run
diff --git a/for_-_else.rst b/for_-_else.rst
index 364abf5..f7fbe82 100644
--- a/for_-_else.rst
+++ b/for_-_else.rst
@@ -1,12 +1,11 @@
-For - Else
-----------
+``for/else``
+------------
 
 Loops are an integral part of any language. Likewise ``for`` loops are
 an important part of Python. However there are a few things which most
-beginners do not know about them. We will discuss a few of them one by
-one.
+beginners do not know about them. We will discuss a few of them one-by-one.
 
-Let's first start of by what we know. We know that we can use for loops
+Let's first start off with what we know. We know that we can use ``for`` loops
 like this:
 
 .. code:: python
@@ -19,24 +18,24 @@ like this:
     #         Banana
     #         Mango
 
-That is the very basic structure of a for loop. Now let's move on to
+That is the very basic structure of a ``for`` loop. Now let's move on to
 some of the lesser known features of ``for`` loops in Python.
 
-``else`` clause:
-^^^^^^^^^^^^^^^^^^^^
+``else`` Clause
+^^^^^^^^^^^^^^^
 
-For loops also have an ``else`` clause which most of us are unfamiliar
-with. The ``else`` clause executes when the loop completes normally.
-This means that the loop did not encounter any ``break``. They are
-really useful once you understand where to use them. I myself came to
+``for`` loops also have an ``else`` clause which most of us are unfamiliar
+with. The ``else`` clause executes after the loop completes normally.
+This means that the loop did not encounter a ``break`` statement. They are
+really useful once you understand where to use them. I, myself, came to
 know about them a lot later.
 
 The common construct is to run a loop and search for an item. If the
-item is found, we break the loop using ``break``. There are two
+item is found, we break out of the loop using the ``break`` statement. There are two
 scenarios in which the loop may end. The first one is when the item is
 found and ``break`` is encountered. The second scenario is that the loop
-ends. Now we may want to know which one of these is the reason for a
-loops completion. One method is to set a flag and then check it once the
+ends without encountering a ``break`` statement. Now we may want to know which one of these is the reason for a
+loop's completion. One method is to set a flag and then check it once the
 loop ends. Another is to use the ``else`` clause.
 
 This is the basic structure of a ``for/else`` loop:
@@ -64,8 +63,7 @@ documentation:
                 break
 
 It finds factors for numbers between 2 to 10. Now for the fun part. We
-can add an additional ``else`` block which catches the numbers which are
-prime and tells us so:
+can add an additional ``else`` block which catches the numbers which have no factors and are therefore prime numbers:
 
 .. code:: python
 
diff --git a/function_caching.rst b/function_caching.rst
index 865a866..7100aad 100644
--- a/function_caching.rst
+++ b/function_caching.rst
@@ -52,9 +52,9 @@ is a generic cache:
         memo = {}
         @wraps(function)
         def wrapper(*args):
-            if args in memo:
+            try:
                 return memo[args]
-            else:
+            except KeyError:
                 rv = function(*args)
                 memo[args] = rv
                 return rv
@@ -67,6 +67,8 @@ is a generic cache:
 
     fibonacci(25)
 
+**Note:** memoize won't cache unhashable types (dict, lists, etc...) but only the immutable types. Keep that in mind when using it.
+
 `Here <https://www.caktusgroup.com/blog/2015/06/08/testing-client-side-applications-django-post-mortem/>`__
 is a fine article by Caktus Group in which they caught a bug in Django
 which occurred due to ``lru_cache``. It's an interesting read. Do check it out.
diff --git a/generators.rst b/generators.rst
index f65afae..23cd1b0 100644
--- a/generators.rst
+++ b/generators.rst
@@ -20,8 +20,8 @@ Iterable
 
 An ``iterable`` is any object in Python which has an ``__iter__`` or a
 ``__getitem__`` method defined which returns an **iterator** or can take
-indexes (Both of these dunder methods are fully explained in a previous
-chapter). In short an ``iterable`` is any object which can provide us
+indexes (You can read more about them `here <https://stackoverflow.com/a/20551346>`_). 
+In short an ``iterable`` is any object which can provide us
 with an **iterator**. So what is an **iterator**?
 
 Iterator
@@ -134,10 +134,10 @@ element of a sequence. So let's test out our understanding:
 
 As we can see that after yielding all the values ``next()`` caused a
 ``StopIteration`` error. Basically this error informs us that all the
-values have been yielded. You might be wondering that why don't we get
-this error while using a ``for`` loop? Well the answer is simple. The
+values have been yielded. You might be wondering why we don't get
+this error when using a ``for`` loop? Well the answer is simple. The
 ``for`` loop automatically catches this error and stops calling
-``next``. Do you know that a few built-in data types in Python also
+``next``. Did you know that a few built-in data types in Python also
 support iteration? Let's check it out:
 
 .. code:: python
diff --git a/global_&_return.rst b/global_&_return.rst
index 2718ed5..0661752 100644
--- a/global_&_return.rst
+++ b/global_&_return.rst
@@ -1,9 +1,9 @@
-Global & Return
+Global and Return
 ---------------
 
-You might have encountered some functions written in python which have a
+You might have encountered some functions written in Python which have a
 ``return`` keyword in the end of the function. Do you know what it does? It
-is similar to return in other languages. Lets examine this little
+is similar to return in other languages. Let's examine this little
 function:
 
 .. code:: python
@@ -15,7 +15,7 @@ function:
     print(result)
     # Output: 8
 
-The function above takes two values as input and then output their
+The function above takes two values as input and then outputs their
 addition. We could have also done:
 
 .. code:: python
@@ -28,11 +28,11 @@ addition. We could have also done:
     print(result)
     # Output: 8
 
-So first lets talk about the first bit of code which involves the
+So first let's talk about the first bit of code which involves the
 ``return`` keyword. What that function is doing is that it is assigning
 the value to the variable which is calling that function which in our
-case is ``result``. In most cases and you won't need to use the
-``global`` keyword. However lets examine the other bit of code as well
+case is ``result``. In most cases you won't need to use the
+``global`` keyword. However, let's examine the other bit of code as well
 which includes the ``global`` keyword. So what that function is doing is
 that it is making a global variable ``result``. What does global mean
 here? Global variable means that we can access that variable outside the
@@ -125,4 +125,36 @@ Or by more common convention:
     print(profile_age)
     # Output: 30
 
-This is a better way to do it along with returning ``lists`` and ``dicts``. Don't use ``global`` keyword unless you know what you are doing. ``global`` might be a better option in a few cases but is not in most of them.
+Keep in mind that even in the above example we are returning a tuple (despite the lack of parenthesis) and not separate multiple values. If you want to take it one step further, you can also make use of `namedtuple <https://docs.python.org/3/library/collections.html#collections.namedtuple>`_. Here is an example:
+
+.. code:: python
+
+    from collections import namedtuple
+    def profile():
+        Person = namedtuple('Person', 'name age')
+        return Person(name="Danny", age=31)
+
+    # Use as namedtuple
+    p = profile()
+    print(p, type(p))
+    # Person(name='Danny', age=31) <class '__main__.Person'>
+    print(p.name)
+    # Danny
+    print(p.age)
+    #31
+
+    # Use as plain tuple
+    p = profile()
+    print(p[0])
+    # Danny
+    print(p[1])
+    #31
+
+    # Unpack it immediatly
+    name, age = profile()
+    print(name)
+    # Danny
+    print(age)
+    #31
+
+This is a better way to do it, along with returning ``list`` and ``dict``. Don't use ``global`` keyword unless you know what you are doing. ``global`` might be a better option in a few cases but is not in most of them.
diff --git a/index.rst b/index.rst
index 9895a2d..b45de64 100644
--- a/index.rst
+++ b/index.rst
@@ -2,9 +2,7 @@
 
 .. note::
 
-   You can donate me for my hardwork if you want to by buying the donation version of Intermediate Python from `Gumroad <https://gumroad.com/l/intermediate_python>`__. Your help would be greatly appreciated!
-
-   You can also sign up to my `mailing list <http://eepurl.com/bwjcej>`__ so that you remain in sync with any major updates to this book or my future projects!
+   You can sign up to my `mailing list <http://eepurl.com/bwjcej>`__ so that you remain in sync with any major updates to this book or my future projects!
 
 Intermediate Python
 ===================
@@ -52,9 +50,11 @@ Table of Contents
    virtual_environment
    collections
    enumerate
+   zip
    object_introspection
    comprehensions
    exceptions
+   classes
    lambdas
    one_liners
    for_-_else
diff --git a/lambdas.rst b/lambdas.rst
index 1223dca..756e260 100644
--- a/lambdas.rst
+++ b/lambdas.rst
@@ -21,7 +21,7 @@ normal functions and even behave like them.
     print(add(3, 5))
     # Output: 8
 
-Here are a few useful use cases for lambdas and just a few way in which
+Here are a few useful use cases for lambdas and just a few ways in which
 they are used in the wild:
 
 **List sorting**
@@ -39,5 +39,5 @@ they are used in the wild:
 .. code:: python
 
     data = zip(list1, list2)
-    data.sort()
+    data = sorted(data)
     list1, list2 = map(lambda t: list(t), zip(*data))
diff --git a/mutation.rst b/mutation.rst
index 440222a..493579c 100644
--- a/mutation.rst
+++ b/mutation.rst
@@ -30,7 +30,8 @@ something like this:
     bar += ['bye']
 
     print(foo)
-    # Output: ['hi']
+    # Expected Output: ['hi']
+    # Output: ['hi', 'bye']
 
     print(bar)
     # Output: ['hi', 'bye']
diff --git a/one_liners.rst b/one_liners.rst
index 1914ea6..17dc776 100644
--- a/one_liners.rst
+++ b/one_liners.rst
@@ -29,9 +29,59 @@ repl. Here is the relevant code:
     from pprint import pprint
 
     my_dict = {'name': 'Yasoob', 'age': 'undefined', 'personality': 'awesome'}
-    pprint(my_dict)
-
-This is more effective on ``dict`` s. Moreover, if you want to pretty print
+    print(dir(my_dict))
+    # ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
+    
+    pprint(dir(my_dict))
+    # ['__add__',
+    #  '__class__',
+    #  '__contains__',
+    #  '__delattr__',
+    #  '__delitem__',
+    #  '__dir__',
+    #  '__doc__',
+    #  '__eq__',
+    #  '__format__',
+    #  '__ge__',
+    #  '__getattribute__',
+    #  '__getitem__',
+    #  '__gt__',
+    #  '__hash__',
+    #  '__iadd__',
+    #  '__imul__',
+    #  '__init__',
+    #  '__init_subclass__',
+    #  '__iter__',
+    #  '__le__',
+    #  '__len__',
+    #  '__lt__',
+    #  '__mul__',
+    #  '__ne__',
+    #  '__new__',
+    #  '__reduce__',
+    #  '__reduce_ex__',
+    #  '__repr__',
+    #  '__reversed__',
+    #  '__rmul__',
+    #  '__setattr__',
+    #  '__setitem__',
+    #  '__sizeof__',
+    #  '__str__',
+    #  '__subclasshook__',
+    #  'append',
+    #  'clear',
+    #  'copy',
+    #  'count',
+    #  'extend',
+    #  'index',
+    #  'insert',
+    #  'pop',
+    #  'remove',
+    #  'reverse',
+    #  'sort']
+
+
+This is more effective on nested ``dict`` s. Moreover, if you want to pretty print
 json quickly from a file then you can simply do:
 
 .. code:: python
diff --git a/open_function.rst b/open_function.rst
index 8281b2f..3683bb3 100644
--- a/open_function.rst
+++ b/open_function.rst
@@ -69,8 +69,8 @@ and does the right thing. You can pass in the encoding with the
 Python -- specific default will be picked. You may be tempted to rely on
 these defaults, but the defaults are often wrong, or the default
 encoding cannot actually express all characters in the file (this will happen often on
-Python 2.x and/or Windows). So go ahead and pick an encoding. ``utf-8``
-is a terrific one. When you write a file, you can just pick the encoding
+Python 2.x and/or Windows). So go ahead and pick an encoding. Encoding is the way to instruct computers about how the numbers should be stored as bytes in memory. ``utf-8``
+is a terrific one and is supported by major browsers and programming languages. When you write a file, you can just pick the encoding
 to your liking (or the liking of the program that will eventually read
 your file).
 
diff --git a/python_c_extension.rst b/python_c_extension.rst
index 5cea2e2..f4cf5d4 100644
--- a/python_c_extension.rst
+++ b/python_c_extension.rst
@@ -6,7 +6,7 @@ implementation is the ease of interfacing C code to Python.
 
 There are three key methods developers use to call C functions from
 their python code - ``ctypes``, ``SWIG`` and ``Python/C API``. Each
-method comes with it's own merits and demerits.
+method comes with its own merits and demerits.
 
 Firstly, why would you want to interface C with Python?
 
@@ -36,8 +36,6 @@ Simple C code to add two numbers, save it as ``add.c``
 
     //sample C file to add 2 numbers - int and floats
 
-    #include <stdio.h>
-
     int add_int(int, int);
     float add_float(float, float);
 
@@ -194,7 +192,7 @@ Python/C API
 ---------------
 
 The `C/Python API <https://docs.python.org/2/c-api/>`__ is probably the
-most widely used method - not for it's simplicity but for the fact that
+most widely used method - not for its simplicity but for the fact that
 you can manipulate python objects in your C code.
 
 This method requires your C code to be specifically written for
@@ -229,7 +227,7 @@ the addList module is not written in Python at all, but rather in C.
 Next we'll have a look at the C code that get's built into the
 ``addList`` Python module. This may seem a bit daunting at first, but
 once you understand the various components that go into writing the C
-file, it's pretty straight forward.
+file, it's pretty straightforward.
 
 *adder.c*
 
@@ -252,7 +250,7 @@ file, it's pretty straight forward.
       long length = PyList_Size(listObj);
 
       //iterate over all the elements
-      int i, sum =0;
+      long i, sum =0;
       for(i = 0; i < length; i++){
         //get an element out of the list - the element is also a python objects
         PyObject* temp = PyList_GetItem(listObj, i);
@@ -316,7 +314,7 @@ and a python list in that order, the function signature would be
     int n;
     char *s;
     PyObject* list;
-    PyArg_ParseTuple(args, "siO", &n, &s, &list);
+    PyArg_ParseTuple(args, "siO", &s, &n, &list);
 
 In this case we only have to extract a list object, and store it in the
 variable ``listObj``. We then use the ``PyList_Size()`` function on our
diff --git a/targeting_python_2_3.rst b/targeting_python_2_3.rst
index 00e08ff..caa0c1e 100644
--- a/targeting_python_2_3.rst
+++ b/targeting_python_2_3.rst
@@ -5,7 +5,7 @@ In a lot of cases you might want to develop programs which can be run in
 both Python 2+ and 3+.
 
 Just imagine that you have a very popular Python module which is used by
-hundreds of people but not all of them have Python 2 or 3. In that case
+hundreds of people but not all of them have the same version of Python (2 or 3). In that case
 you have two choices. The first one is to distribute 2 modules, one for
 Python 2 and the other for Python 3. The other choice is to modify your
 current code and make it compatible with both Python 2 and 3.
diff --git a/ternary_operators.rst b/ternary_operators.rst
index d4a4e00..6f9cbbc 100644
--- a/ternary_operators.rst
+++ b/ternary_operators.rst
@@ -12,14 +12,14 @@ expressions.
 
 .. code:: python
 
-    condition_is_true if condition else condition_is_false
+    value_if_true if condition else value_if_false
 
 **Example:**
 
 .. code:: python
 
-    is_fat = True
-    state = "fat" if is_fat else "not fat"
+    is_nice = True
+    state = "nice" if is_nice else "not nice"
 
 It allows to quickly test a condition instead of a multiline if
 statement. Often times it can be immensely helpful and can make your
@@ -38,10 +38,10 @@ is some sample code:
 
 .. code:: python
 
-    fat = True
-    fitness = ("skinny", "fat")[fat]
-    print("Ali is ", fitness)
-    # Output: Ali is fat
+    nice = True
+    personality = ("mean", "nice")[nice]
+    print("The cat is ", personality)
+    # Output: The cat is nice
 
 This works simply because True == 1 and False == 0, and so can be done
 with lists in addition to tuples.
@@ -70,3 +70,44 @@ first built, then an index is found.  For the if-else ternary operator,
 it follows the normal if-else logic tree.  Thus, if one case could
 raise an exception based on the condition, or if either case is a
 computation-heavy method, using tuples is best avoided.
+
+
+**ShortHand Ternary**
+
+In python there is also the shorthand ternary tag which is a shorter version of the 
+normal ternary operator you have seen above. 
+
+Syntax was introduced in Python 2.5 and can be used in python 2.5 or greater.
+
+**Example**
+
+.. code:: python
+
+    >>> True or "Some"
+    True
+    >>>
+    >>> False or "Some"
+    'Some'
+
+The first statement (`True or "Some"`) will return `True` and the second statement (`False or "Some"`) will return `Some`. 
+
+This is helpful in case where you quickly want to check for the output of a function and give a useful message if the output is empty:
+
+.. code:: python
+
+    >>> output = None
+    >>> msg = output or "No data returned"
+    >>> print(msg)
+    No data returned
+
+Or as a simple way to define function parameters with dynamic default values:
+
+.. code:: python
+
+    >>> def my_function(real_name, optional_display_name=None):
+    >>>     optional_display_name = optional_display_name or real_name
+    >>>     print(optional_display_name)
+    >>> my_function("John")
+    John
+    >>> my_function("Mike", "anonymous123")
+    anonymous123
diff --git a/virtual_environment.rst b/virtual_environment.rst
index 58746ce..28b119f 100644
--- a/virtual_environment.rst
+++ b/virtual_environment.rst
@@ -32,7 +32,7 @@ To install it, just type this command in the shell:
 The most important commands are:
 
 -  ``$ virtualenv myproject``
--  ``$ source bin/activate``
+-  ``$ source myproject/bin/activate``
 
 This first one makes an isolated virtualenv environment in the
 ``myproject`` folder and the second command activates that isolated
diff --git a/zip.rst b/zip.rst
new file mode 100644
index 0000000..947fe2a
--- /dev/null
+++ b/zip.rst
@@ -0,0 +1,71 @@
+Zip and unzip
+-------------
+
+**Zip**
+
+Zip is a useful function that allows you to combine two lists easily. 
+
+After calling zip, an iterator is returned. In order to see the content wrapped inside, we need to first convert it to a list.
+
+Example:
+
+.. code:: python
+    
+    first_name = ['Joe','Earnst','Thomas','Martin','Charles']
+
+    last_name = ['Schmoe','Ehlmann','Fischer','Walter','Rogan','Green']
+
+    age = [23, 65, 11, 36, 83]
+
+    print(list(zip(first_name,last_name, age)))
+
+    # Output
+    #
+    # [('Joe', 'Schmoe', 23), ('Earnst', 'Ehlmann', 65), ('Thomas', 'Fischer', 11), ('Martin', 'Walter', 36), ('Charles', 'Rogan', 83)]
+
+One advantage of zip is that it improves readability of for loops.
+
+For example, instead of needing multiple inputs, you only need one zipped list for the following for loop:
+
+.. code:: python
+
+    first_name = ['Joe','Earnst','Thomas','Martin','Charles']
+    last_name = ['Schmoe','Ehlmann','Fischer','Walter','Rogan','Green']
+    age = [23, 65, 11, 36, 83]
+
+    for first_name, last_name, age in zip(first_name, last_name, age):
+        print(f"{first_name} {last_name} is {age} years old")
+
+    # Output
+    #
+    # Joe Schmoe is 23 years old                                                                                                                    
+    # Earnst Ehlmann is 65 years old                                                                                                                
+    # Thomas Fischer is 11 years old                                                                                                                
+    # Martin Walter is 36 years old                                                                                                                 
+    # Charles Rogan is 83 years old
+    
+**Unzip**
+
+We can use the `zip` function to unzip a list as well. This time, we need an input of a list with an asterisk before it.
+
+The outputs are the separated lists. 
+
+Example:
+
+.. code:: python
+
+    full_name_list = [('Joe', 'Schmoe', 23), 
+                      ('Earnst', 'Ehlmann', 65), 
+                      ('Thomas', 'Fischer', 11), 
+                      ('Martin', 'Walter', 36), 
+                      ('Charles', 'Rogan', 83)]
+                      
+    first_name, last_name, age = list(zip(*full_name_list))
+    print(f"first name: {first_name}\nlast name: {last_name} \nage: {age}")
+
+    # Output
+
+    # first name: ('Joe', 'Earnst', 'Thomas', 'Martin', 'Charles')
+    # last name: ('Schmoe', 'Ehlmann', 'Fischer', 'Walter', 'Rogan')
+    # age: (23, 65, 11, 36, 83)
+