pythonthings
diff --git a/‎classes.rst‎
Lines changed: 7 additions & 6 deletions b/‎classes.rst‎
Lines changed: 7 additions & 6 deletions
diff --git a/‎collections.rst‎
Lines changed: 5 additions & 5 deletions b/‎collections.rst‎
Lines changed: 5 additions & 5 deletions
diff --git a/‎context_managers.rst‎
Lines changed: 9 additions & 9 deletions b/‎context_managers.rst‎
Lines changed: 9 additions & 9 deletions
diff --git a/‎decorators.rst‎
Lines changed: 11 additions & 11 deletions b/‎decorators.rst‎
Lines changed: 11 additions & 11 deletions
diff --git a/‎for_-_else.rst‎
Lines changed: 2 additions & 2 deletions b/‎for_-_else.rst‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎function_caching.rst‎
Lines changed: 1 addition & 2 deletions b/‎function_caching.rst‎
Lines changed: 1 addition & 2 deletions
diff --git a/‎global_&_return.rst‎
Lines changed: 1 addition & 1 deletion b/‎global_&_return.rst‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎lambdas.rst‎
Lines changed: 1 addition & 3 deletions b/‎lambdas.rst‎
Lines changed: 1 addition & 3 deletions
diff --git a/‎targeting_python_2_3.rst‎
Lines changed: 20 additions & 21 deletions b/‎targeting_python_2_3.rst‎
Lines changed: 20 additions & 21 deletions
@@ -9,7 +9,7 @@ going!
 1. Instance & Class variables
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Most beginners and even some advance Python programmers do not
+Most beginners and even some advanced Python programmers do not
 understand the distinction between instance and class variables. Their
 lack of understanding forces them to use these different types of
 variables incorrectly. Let's understand them.
@@ -53,7 +53,7 @@ Let's take a look at an example:
     b.pi
     # Output: 50
 
-There are not much issues while using mutable class variables. This is
+There are not many issues while using mutable 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
@@ -90,7 +90,7 @@ make your code safe against this kind of surprise attacks then make sure
 that you do not use mutable class variables. You may use them only if
 you know what you are doing.
 
-2.New style classes:
+2. New style classes
 ^^^^^^^^^^^^^^^^^^^^
 
 New style classes were introduced in Python 2.1 but a lot of people do
@@ -130,16 +130,17 @@ classes.
 whether you subclass from ``object`` or not. However it is recommended
 that you still subclass from ``object``.
 
-3.Magic Methods:
+3. Magic Methods
 ^^^^^^^^^^^^^^^^
 
 Python's classes are famous for their magic methods, commonly called
-**dunder** methods. I am going to discuss a few of them.
+**dunder** (double underscore) methods. I am going to discuss a few of
+them.
 
 -  ``__init__``
 
 It is a class initializer. Whenever an instance of a class is created
-it's ``__init__`` method. For instance:
+its ``__init__`` method is called. For example:
 
 .. code:: python
 
 
@@ -205,7 +205,7 @@ major one is that unlike lists, **you can not change a value in a
 tuple**. In order to access the value in a tuple you use integer indexes
 like:
 
-::
+.. code:: python
 
     man = ('Ali', 30)
     print(man[0])
@@ -217,7 +217,7 @@ integer indexes for accessing members of a tuple. You can think of
 namedtuples like dictionaries but unlike dictionaries they are
 immutable.
 
-::
+.. code:: python
 
     from collections import namedtuple
 
@@ -244,7 +244,7 @@ memory than regular tuples. This makes them faster than dictionaries.
 However, do remember that as with tuples, **attributes in namedtuples
 are immutable**. It means that this would not work:
 
-::
+.. code:: python
 
     from collections import namedtuple
 
@@ -260,7 +260,7 @@ You should use named tuples to make your code self-documenting. **They
 are backwards compatible with normal tuples**. It means that you can use
 integer indexes with namedtuples as well:
 
-::
+.. code:: python
 
     from collections import namedtuple
 
@@ -272,7 +272,7 @@ integer indexes with namedtuples as well:
 Last but not the least, you can convert a namedtuple to a dictionary.
 Like this:
 
-::
+.. code:: python
 
     from collections import namedtuple
 
 
@@ -7,7 +7,7 @@ the ``with`` statement. Suppose you have two related operations which
 you’d like to execute as a pair, with a block of code in between.
 Context managers allow you to do specifically that. For example:
 
-::
+.. code:: python
 
     with open('some_file', 'w') as opened_file:
         opened_file.write('Hola!')
@@ -16,7 +16,7 @@ The above code opens the file, writes some data to it and then closes
 it. If an error occurs while writing the data to the file, it tries to
 close it. The above code is equivalent to:
 
-::
+.. code:: python
 
     file = open('some_file', 'w')
     try:
@@ -42,7 +42,7 @@ At the very least a context manager has an ``__enter__`` and
 ``__exit__`` methods defined. Let's make our own file opening Context
 Manager and learn the basics.
 
-::
+.. code:: python
 
     class File(object):
         def __init__(self, file_name, method):
@@ -55,7 +55,7 @@ Manager and learn the basics.
 Just by defining ``__enter__`` and ``__exit__`` methods we can use it in
 a ``with`` statement. Let's try:
 
-::
+.. code:: python
 
     with File('demo.txt', 'w') as opened_file:
         opened_file.write('Hola!')
@@ -87,7 +87,7 @@ What if our file object raises an exception? We might be trying to
 access a method on the file object which it does not supports. For
 instance:
 
-::
+.. code:: python
 
     with File('demo.txt', 'w') as opened_file:
         opened_file.undefined_function('Hola!')
@@ -107,15 +107,15 @@ In our case the ``__exit__`` method returns ``None`` (when no return
 statement is encountered then the method returns ``None``). Therefore,
 ``with`` statement raises the exception.
 
-::
+.. code:: python
 
     Traceback (most recent call last):
       File "<stdin>", line 2, in <module>
     AttributeError: 'file' object has no attribute 'undefined_function'
 
 Let's try handling the exception in the ``__exit__`` method:
 
-::
+.. code:: python
 
     class File(object):
         def __init__(self, file_name, method):
@@ -146,7 +146,7 @@ Python has a contextlib module for this very purpose. Instead of a
 class, we can implement a Context Manager using a generator function.
 Let's see a basic, useless example:
 
-::
+.. code:: python
 
     from contextlib import contextmanager
 
@@ -177,7 +177,7 @@ Let's dissect this method a little.
 So now that we know all this, we can use the newly generated Context
 Manager like this:
 
-::
+.. code:: python
 
     with open_file('some_file') as f:
         f.write('hola!')
 
@@ -9,15 +9,15 @@ decorators can make your code concise.
 
 Firstly let's discuss how to write your own decorator.
 
-It is perhaps one of the most difficult concept to grasp. We will take
+It is perhaps one of the most difficult concepts to grasp. We will take
 it one step at a time so that you can fully understand it.
 
 Everything in python is an object:
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 First of all let's understand functions in python:
 
-::
+.. code:: python
 
     def hi(name="yasoob"):
         return "hi " + name
@@ -48,7 +48,7 @@ So those are the basics when it comes to functions. Lets take your
 knowledge one step further. In Python we can define functions inside
 other functions:
 
-::
+.. code:: python
 
     def hi(name="yasoob"):
         print "now you are inside the hi() function"
@@ -86,7 +86,7 @@ Returning functions from within functions:
 It is not necessary to execute a function within another function, we
 can return it as an output as well:
 
-::
+.. code:: python
 
     def hi(name="yasoob"):
         def greet():
@@ -125,7 +125,7 @@ function will be returned. We can also do print ``hi()()`` which outputs
 Giving a function as an argument to another function:
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-::
+.. code:: python
 
     def hi():
         return "hi yasoob!"
@@ -147,7 +147,7 @@ Writing your first decorator:
 In the last example we actually made a decorator! Lets modify the
 previous decorator and make a little bit more usable program:
 
-::
+.. code:: python
 
     def a_new_decorator(a_func):
 
@@ -181,7 +181,7 @@ wondering that 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 @.
 
-::
+.. code:: python
 
     @a_new_decorator
     def a_function_requiring_decoration():
@@ -200,19 +200,19 @@ run the previous code sample using @.
 I hope you now have a basic understanding of how decorators work in
 Python. Now there is one problem with our code. If we run:
 
-::
+.. code:: python
 
     print(a_function_requiring_decoration.__name__)
     # Output: wrapTheFunction
 
-That's not what we expected! It's name is
+That's not what we expected! Its name is
 "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
 that is ``functools.wraps``. Let's modify our previous example to use
 ``functools.wraps``:
 
-::
+.. code:: python
 
     from functools import wraps
 
@@ -291,7 +291,7 @@ authentication:
         def decorated(*args, **kwargs):
             auth = request.authorization
             if not auth or not check_auth(auth.username, auth.password):
-                return authenticate()
+                authenticate()
             return f(*args, **kwargs)
         return decorated
 
 
@@ -9,7 +9,7 @@ one.
 Let's first start of by what we know. We know that we can use for loops
 like this:
 
-::
+.. code:: python
 
     fruits = ['apple', 'banana', 'mango']
     for fruit in fruits:
@@ -67,7 +67,7 @@ It outputs the prime numbers between 2 to 10. Now for the fun part. We
 can add an additional ``else`` block which catches the numbers which are
 not prime and tells us so:
 
-::
+.. code:: python
 
     for n in range(2, 10):
         for x in range(2, n):
 
@@ -69,5 +69,4 @@ is a generic cache:
 
 `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.
+which occurred due to ``lru_cache``. It's an interesting read. Do check it out.
@@ -2,7 +2,7 @@ Global & Return
 ---------------
 
 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
+``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
 function:
 
 
@@ -32,7 +32,7 @@ they are used in the wild:
     a.sort(key=lambda x: x[1])
 
     print(a)
-    # Output: [(13, -3), (4, 1), (1, 2), (9, 10)] 
+    # Output: [(13, -3), (4, 1), (1, 2), (9, 10)]
 
 **Parallel sorting of lists**
 
@@ -41,5 +41,3 @@ they are used in the wild:
     data = zip(list1, list2)
     data.sort()
     list1, list2 = map(lambda t: list(t), zip(*data))
-
-Note: We will learn about map in a later chapter so don't worry!
@@ -2,13 +2,13 @@ Targeting Python 2+3
 --------------------
 
 In a lot of cases you might want to develop programs which can be run in
-both, Python 2+ and 3+.
+both Python 2+ and 3+.
 
-Just imagine that you have a very popular python module which is use by
-hundreds of people but not all of them have python 2 or 3. In that case
+Just imagine that you have a very popular Python module which is use by
+hundreds of people but not all of them have 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 is compatible with both python 2 and 3.
+Python 2 and the other for Python 3. The other choice is to modify your
+current code and make is compatible with both Python 2 and 3.
 
 In this section I am going to highlight some of the tricks which you can
 employ to make a script compatible with both of them.
@@ -19,7 +19,7 @@ The first and most important method is to use ``__future__`` imports. It
 allows you to import Python 3 functionality in Python 2. Here is an
 example:
 
--  Context manager were new in Python 3. For using them in Python 2.5+
+-  Context managers were new in Python 2.6+. For using them in Python 2.5
    you can use:
 
 .. code:: python
@@ -57,28 +57,28 @@ Do you know that you can do something like this as well?
 
     import foo as foo
 
-I know it’s function is the same as above listed code but it is vital
-for making your script compatible with python 2 and 3. Now examine the
+I know its function is the same as the above listed code but it is vital
+for making your script compatible with Python 2 and 3. Now examine the
 code below :
 
 .. code:: python
 
     try:
-        import urllib.request as urllib_request  # for python 3
+        import urllib.request as urllib_request  # for Python 3
     except ImportError:
-        import urllib2 as urllib_request  # for python 2
+        import urllib2 as urllib_request  # for Python 2
 
 So let me explain the above code a little. We are wrapping our importing
-code in a try except clause. We are doing it because in python2 there is
-no urllib.request module and will result in an ImportError. The
-functionality of urllib.request is provided by urllib2 module in
-python2. So now when in Python2 we try to import ``urllib.request`` and
-get an ``ImportError`` we tell Python to import urllib2 instead.
+code in a try except clause. We are doing it because in Python 2 there is
+no ``urllib.request`` module and will result in an ImportError. The
+functionality of ``urllib.request`` is provided by ``urllib2`` module in
+Python 2. So now when in Python 2 we try to import ``urllib.request`` and
+get an ``ImportError`` we tell Python to import ``urllib2`` instead.
 
 The final thing you need to know about is the ``as`` keyword. It is
 mapping the imported module to ``urllib_request``. So that now all of
-the Classes and methods of urllib2 are available to us by
-urllib\_request.
+the Classes and methods of ``urllib2`` are available to us by
+``urllib_request``.
 
 **Obsolete Python 2 builtins**
 
@@ -111,7 +111,6 @@ functionality in Python 2. For instance we have:
 -  singledispatch ``pip install singledispatch``
 -  pathlib ``pip install pathlib``
 
-
-I am sure there are a lot of other methods and tricks which can be used
-to make you code compatible with both of these Python series. This was
-just to give you some ideas.
+For further reading, the Python documentation has a `comprehensive guide
+<https://docs.python.org/3/howto/pyporting.html>`_ of steps you need to
+take to make your code compatible with both Python 2 and 3.