In [1]:

    

# code for loading the format for the notebook
import os

# path : store the current path to convert back to it later
path = os.getcwd()
os.chdir(os.path.join('..', 'notebook_format'))

from formats import load_style
load_style(plot_style=False)


    

    
Out[1]:

In [2]:

    

os.chdir(path)

# 1. magic to print version
# 2. magic so that the notebook will reload external python modules
%load_ext watermark
%load_ext autoreload
%autoreload 2

%watermark -a 'Ethen' -d -t -v


    

    




Ethen 2020-02-24 14:21:58 

CPython 3.6.4
IPython 7.9.0

In [3]:

    

import logging
from imp import reload

# jupyter notebook already uses logging, thus we reload the module to make it work in notebooks
# http://stackoverflow.com/questions/18786912/get-output-from-the-logging-module-in-ipython-notebook
reload(logging)

# In the following not only did we change the logging level, but
# also specify a logging file to write the log to, and the format.
# the format we specified here is simply the time, the level name
# and the message that we'll later specify, for more information
# about what format we can specify, refer to the following webpage
# https://docs.python.org/3/library/logging.html#logrecord-attributes
logging.basicConfig(filename='test.log', level=logging.DEBUG,
                    format='%(asctime)s:%(levelname)s:%(message)s')

def add(x, y):
    """Add Function"""
    return x + y


def subtract(x, y):
    """Subtract Function"""
    return x - y


def multiply(x, y):
    """Multiply Function"""
    return x * y


def divide(x, y):
    """Divide Function"""
    return x / y


    

In [4]:

    

num1 = 20
num2 = 10

# add logging debugrmation instead of print statement 
# to record what was going on, note that if we were to
# run it for multiple 
add_result = add(num1, num2)
logging.debug('Add: {} + {} = {}'.format(num1, num2, add_result))

sub_result = subtract(num1, num2)
logging.debug('Sub: {} - {} = {}'.format(num1, num2, sub_result))

mul_result = multiply(num1, num2)
logging.debug('Mul: {} * {} = {}'.format(num1, num2, mul_result))

div_result = divide(num1, num2)
logging.debug('Div: {} / {} = {}'.format(num1, num2, div_result))


    

In [5]:

    

import logging

# then specify the module's logger, the logger's level
# and add the handler to the logger
logger = logging.getLogger(__name__)
logger.setLevel(logging.ERROR)

# boiler plate, set the format using Formatter,
# and set the file to log to with FileHandler
formatter = logging.Formatter('%(asctime)s:%(levelname)s:%(message)s')
file_handler = logging.FileHandler('math.log')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)

# note that we do not need to reload the logging 
# module this time, as it will not have conflict 
# with jupyter notebook's logging behavior

def add(x, y):
    """Add Function"""
    return x + y


def subtract(x, y):
    """Subtract Function"""
    return x - y


def multiply(x, y):
    """Multiply Function"""
    return x * y


def divide(x, y):
    """Divide Function"""
    try:
        result = x / y
    except ZeroDivisionError:
        # by calling .exception it will produce the traceback,
        # which is helpful for knowing where the bug occurred
        logger.exception('Tried to divide by 0')
    else:
        return result


    

In [6]:

    

num1 = 20
num2 = 0

# note that we'll use the logger we explicitly created 
# to log to message as oppose to logging in the last example
add_result = add(num1, num2)
logger.info('Add: {} + {} = {}'.format(num1, num2, add_result))

sub_result = subtract(num1, num2)
logger.info('Sub: {} - {} = {}'.format(num1, num2, sub_result))

mul_result = multiply(num1, num2)
logger.info('Mul: {} * {} = {}'.format(num1, num2, mul_result))

div_result = divide(num1, num2)
logger.info('Div: {} / {} = {}'.format(num1, num2, div_result))


    

In [7]:

    

num1 = 20
num2 = 0

result = None
try:
    result = num1 / num2
except: # or except Exception:
    pass

result


    

In [8]:

    

def divide(x, y):
    """Divide Function"""
    try:
        result = x / y
    except ZeroDivisionError:
        # by calling .exception it will produce the traceback,
        # which is helpful for knowing where the bug occurred
        logger.exception('Tried to divide by 0')
    else:
        return result


    

In [9]:

    

import traceback

def divide(x, y):
    """Divide Function"""
    try:
        result = x / y
        output = {'result': result}
    except ZeroDivisionError as ex:
        error_message = log_traceback(ex)
        output = {'result': None, 'error': error_message}

    return output


def log_traceback(ex):
    """Format full stack trace into a single string."""
    traceback_lines = traceback.format_exception(ex.__class__, ex, ex.__traceback__)
    traceback_text = ''.join(traceback_lines)
    return traceback_text


    

In [10]:

    

output = divide(20, 0)
output


    

    
Out[10]:





{'result': None,
 'error': 'Traceback (most recent call last):\n  File "<ipython-input-9-b27e677bf7be>", line 6, in divide\n    result = x / y\nZeroDivisionError: division by zero\n'}