pythonthings
diff --git a/‎context_managers.rst‎
Lines changed: 32 additions & 33 deletions b/‎context_managers.rst‎
Lines changed: 32 additions & 33 deletions
@@ -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,28 +52,28 @@ 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
 
     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 other 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
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -156,9 +156,9 @@ Let's see a basic, useless example:
         yield f
         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 +167,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 it's 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
@@ -180,5 +180,4 @@ Manager like this:
 .. code:: python
 
     with open_file('some_file') as f:
-        f.write('hola!')
-
+        f.write('hola!')