The problem:

We want to create a function that is able to determine whether a string is a palindrome.

A palindrome is a word that is read the same from front-to-back and from back-to-front.

For instance, the words "noon" and "racecar" are both palindromes.

Algorithm:

Reverse the string.

Compare the reversed string to the original string.

Recipe for designing functions:

0. Give the function a name
1. Examples
2. Type Contract
3. Header
4. Description
5. Body
6. Test

First, we will see the python module doctest which is good for having an up to date documentation.

But using doctest is not recommended for testing a whole program. This is why we will see the python module unittest which is more relevant.

For more about the cons of using doctest: Narrative tests are lousy tests and Tests are code and doctests are not.

Create the file palindrome.py:

#! /usr/bin/python2.7

def is_palindrome(s):
    """(str) -> bool

    Return True if and only if s is a palindrome.

    >>> is_palindrome('noon')
    True
    >>> is_palindrome('racecar')
    True
    >>> is_palindrome('dented')
    False
    """
    return reverse(s) == s

def reverse(s):
    """(str) -> str

    Return the reversed string.

    >>> reverse('hello')
    'olleh'
    >>> reverse('a')
    'a'
    """
    rev = ''
    # for each character in s, add the character at the beginning of rev.
    for char in s:
        rev = char + rev
    return rev

import doctest
doctest.testmod()

We want to separate the tests from the main program and use the python unittest module.

Create the file test_palindromes.py

#! /usr/bin/python2.7

import unittest
import palindromes


class TestPalindrome(unittest.TestCase):

    def test_is_palindrome_true(self):
        value = palindromes.is_palindrome('racecar')
        self.assertEquals(value, True)

    def test_is_palindrome_false(self):
        value = palindromes.is_palindrome('dedent')
        self.assertEquals(value, False)

    def test_reverse_normal(self):
        value = palindromes.reverse('hello')
        self.assertEquals(value, 'olleh')

    def test_reverse_error(self):
        list_of_bad_value = [
        123,
        None,
        ]
        for bad_value in list_of_bad_value:
            self.assertRaises(
                TypeError,
                palindromes.reverse,
                bad_value
            )

if __name__ == '__main__':
    unittest.main()

Choosing test cases to test

• Size: For collections, test with an empty collection, a collection with 1 item, the smallest interesting case, and a collection with several items
• Dichotomies: Vowels/Non Vowels, even/odd, positive/negative, empty/full, and so on.
• Boundaries: If the function behaves differently for values near a particular threshold, test at that threshold.
• Order: If the function behaves differently when the values are in different orders, identify and test each of those orders.

Source: https://class.coursera.org/programming2-001

The keyword with

The context manager is going to be used with the keyword with such as:

with MyContextManager as context_var:
    # here the statement is going to evaluate the methods
    # __enter__ and __exit__ of the class MyContextManager.
    # The value returned by __enter__ is going to be assigned
    # to the variable "context_var".

The context manager can be defined as a class

Two essential methods are required for making the class a context manager:

• __enter__(self)

  Defines what the context manager should do at the beginning of the block created by the with statement. Note that the return value of __enter__ is bound to the target of the with statement, or the name after the as.

• __exit__(self, exception_type, exception_value, traceback)

  Defines what the context manager should do after its block has been executed (or terminates). It can be used to handle exceptions, perform cleanup, or do something always done immediately after the action in the block. If the block executes successfully, exception_type, exception_value, and traceback will be None. Otherwise, you can choose to handle the exception or let the user handle it; if you want to handle it, make sure __exit__ returns True after all is said and done. If you don't want the exception to be handled by the context manager, just let it happen.

Example

class MyContextManager(object):
    def __enter__(self):
        print '__enter__()'
        return self
    def __exit__(self, exception_type, exception_value, traceback):
        print '__exit__()'

with MyContextManager() as context_var:
    print 'Doing work in the context'

Where the output is:

__enter__()
Doing work in the context
__exit__()

The Context Manager can also be defined as a Generator

Here, we use the contextlib library and the module contextmanager.

The equivalent of the example above would be:

import contextlib

@contextlib.contextmanager
def mycontextmanager():
    print "__enter__"
    try:
        yield
    finally:
        print "__exit__"

with mycontextmanager() as context_var:
    print 'Doing work in the context'

First we use the decorator @contextmanager to indicate to Python that the function will be a context manager.

Then, we do a try/finally (it is not automatic like with __enter__ and __exit__).

The word yield split the code in two parts:

• everything that is before yield is similar to what we had above in __enter__
• everything that is after is similar to __exit__

The content (the returned value) of yield is taken in the variable 'context_var' here defined with the key word as.