The module below uses an ``if`` statement to check if a file exists before attempting to use the file. This is not the preferred coding style in the Python community. The community prefers to assume that a file exists and you have access to it, and catch any problems as exceptions.

The code below refactors the comparison to ``None`` to use the PEP 8 preferred pattern of ``if cond is None``.

- `PEP 8 Style Guide - Progrmaming Recommendations <http://legacy.python.org/dev/peps/pep-0008/#programming-recommendations>`_

The code below refactors the comparison to ``True`` to use the PEP 8 preferred pattern of ``if cond is True:``.

The code below refactors the comparison to ``True`` to use the PEP 8 preferred pattern of ``if cond:``. This only works if the object, variable, or expression evaluates to a Boolean value of ``True`` or ``False``.

- `PEP 8 Style Guide - Progrmaming Recommendations <http://legacy.python.org/dev/peps/pep-0008/#programming-recommendations>`_

Note that the following situation will not raise the error.

Docstrings help you remember the intention of a module, function, class, or method. This is especially important as your codebase grows and it becomes harder to remember the implemenation details of each object.

The function below contains no docstring describing its purpose. If you had access to the implementation of the function, then you could tell that it is a function for computing the area of a rectangle. However, if you did not have access to the function implemenation and only had access to the function signature (``def area(width, height):``), you wouldn't be able to tell whether this function computes the area of a triangle or a rectangle. Without a docstring, it is more difficult to understand what this function is used for.

The function named ``Hello`` below does not follow the standard naming convention for functions. As indicated in the table above in the "Description" section of this article, functions are supposed to begin with a lower case letter. The problem with ``Hello`` is that it begins with an upper case letter. The program executes, but other programmers may find the code hard to read, because classes are usually the only objects that begin with upper case letters.

The body of a lambda expression is just a function call on the same argument list as the lambda itself. The lambda is probably unnecessary. Improve code readability by removing the lambda and calling the function directly on the argument list.

Lambda expressions enable you to create inline, anonymous functions. A lambda serves no purpose when it is just a call to a named function. It only makes the code harder to read.

For Python versions 2.6 and below, a common way to initialize a dict was to pass an iterable of key-value pairs in the dict's constructor (e.g. ``d = dict((key, value) for (key, value) in iterable)``). However, in Python 2.7 and beyond, a new syntax called dict comprehension (e.g. ``d = {key: value for (key, value) in iterable}``) was introduced which is generally more readable and is now the preferred style. Use the new syntax whenever possible.

You may encounter the old style of initializing a dict by passing an iterable of key-value pairs in older Python code that was written before version 2.7. The new dict comprehension style is functionally equivalent and is much more readable. Consider refactoring the code to use the new style, assuming that you are now using Python 2.7 or higher.

The module below demonstrates the old syntax of initializing a dict via an iterable of key-value pairs. Although there is nothing wrong with this code, it is somewhat hard to read.

``items()`` is the preferred way to iterate through the key-value pairs of a dictionary. Although there are other valid ways to iterate through a dictionary, this is the most concise way, and you can improve code readability by using the method which is most familiar to the most Python programmers.

The module below defines a for loop that iterates over a dictionary named ``d``. For each loop iteration Python automatically assigns the value of ``k`` to the name of the next key in the dictionary. Inside of the ``for`` loop the module uses ``k`` to access the value of each key of the dictionary. This is a common way for iterating over a dictionary, but it is not the preferred way in Python.

Use named tuples when returning more than one value from a function. This makes code easier to read and makes the data easier to access, as each value can be accessed via a name in addition to an index.

Named tuples can be used anywhere where normal tuples are acceptable, but their values can be accessed through their name in addition to their index, which makes code more verbose and easier to read.