Write Efficient Python Code [Defining and Measuring Code Efficiency].ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Write Efficient Python Code: Defining & Measuring Code Efficiency"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a data scientist, you should spend most of your time working on gaining insights from data not waiting for your code to finish running. Writing efficient Python code can help reduce runtime and save computational resources, ultimately freeing you up to do the things that have more impact."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Table of Content: \n",
    "1. Define Efficiency\n",
    "   \n",
    "   1.1. What is meant by efficient code?\n",
    "   \n",
    "   1.2. Python Standard Libraries\n",
    "   \n",
    "\n",
    "2. Python Code Timing and Profiling\n",
    "   \n",
    "   2.1. Python Runtime Investigation\n",
    "   \n",
    "   2.2. Code profiling for runtime\n",
    "   \n",
    "   2.3. Code profiling for memory use"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Define Efficiency "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1. What is meant by efficient code?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Efficient refers to code that satisfies two key concepts. First, efficient code is fast and has a small latency between execution and returning a result. Second, efficient code allocates resources skillfully and isn't subjected to unnecessary overhead. Although in general your definition of fast runtime and small memory usage may differ depending on the task at hand, the goal of writing efficient code is still to reduce both latency and overhead."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is a language that prides itself on code readability, and thus, it comes with its own set of idioms and best practices. Writing Python code the way it was intended is often referred to as Pythonic code. This means the code that you write follows the best practices and guiding principles of Python. Pythonic code tends to be less verbose and easier to interpret. Although Python supports code that doesn't follow its guiding principles, this type of code tends to run slower."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As an example, look at the non-Pythonic below. Not only is this code more verbose than the Pythonic version, but it also takes longer to run. We'll take a closer look at why this is the case later on in the course, but for now, the main takeaway here is that Pythonic code is efficient code!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1,2,3,4,5]\n",
    "\n",
    "# Non-Pythonic \n",
    "doubled_numbers = []\n",
    "\n",
    "for i in range(len(numbers)):\n",
    "    doubled_numbers.append(numbers[i]*2)\n",
    "    \n",
    "# pythonic \n",
    "\n",
    "double_numbers = [x*2 for x in numbers ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2. Python Standard Libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python Standard Libraries are the Built-in components and libraries of python. These libraries come with every Python installation and are commonly cited as one of Python's greatest strengths. Python has a number of built-in types."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start exploring some of the mentioned functions:\n",
    "* range(): This is a handy tool whenever we want to create a sequence of numbers. Suppose we wanted to create a list of integers from zero to ten. We could explicitly type out each integer, but that is not very efficient. Instead, we can use range to accomplish this task. We can provide a range with a start and stop value to create this sequence. Or, we can provide just a stop value assuming that we want our sequence to start at zero. Notice that the stop value is exclusive, or up to but not including this value. Also note the range function returns a range object, which we can convert into a list and print. The range function can also accept a start, stop, and step value (in that order)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "# range(start,stop)\n",
    "nums = range(0,11)\n",
    "nums_list = list(nums)\n",
    "print(nums_list)\n",
    "\n",
    "# range(stop)\n",
    "nums = range(11)\n",
    "nums_list = list(nums)\n",
    "print(nums_list)\n",
    "\n",
    "# Using range() with a step value\n",
    "\n",
    "even_nums = range(2, 11, 2)\n",
    "even_nums_list = list(even_nums)\n",
    "print(even_nums_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**enumerate():** Another useful built-in function is enumerate. enumerate creates an index item pair for each item in the object provided. For example, calling enumerate on the list letters produces a sequence of indexed values. Similar to the range function, enumerate returns an enumerate object, which can also be converted into a list and printed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]\n"
     ]
    }
   ],
   "source": [
    "# Creates an indexed list of objects using enumerate\n",
    "letters = ['a', 'b', 'c', 'd' ]\n",
    "indexed_letters = enumerate(letters)\n",
    "indexed_letters_list = list(indexed_letters)\n",
    "# print(indexed_letters_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also specify the starting index of enumerate with the keyword argument start. Here, we tell enumerate to start the index at five by passing start equals five into the function call."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(5, 'a'), (6, 'b'), (7, 'c'), (8, 'd')]\n"
     ]
    }
   ],
   "source": [
    "#specify a start value\n",
    "letters = ['a', 'b', 'c', 'd' ]\n",
    "indexed_letters2 = enumerate(letters, start=5)\n",
    "indexed_letters2_list = list(indexed_letters2)\n",
    "print(indexed_letters2_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**map():** The last notable built-in function we'll cover is the map() function. map applies a function to each element in an object. Notice that the map function takes two arguments; first, the function you'd like to apply, and second, the object you'd like to apply that function on. Here, we use a map to apply the built-in function round to each element of the nums list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 2, 3, 5, 5]\n"
     ]
    }
   ],
   "source": [
    "nums = [1.5, 2.3, 3.4, 4.6, 5.0]\n",
    "rnd_nums = map(round, nums)\n",
    "print(list(rnd_nums))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The map function can also be used with a lambda, or, an anonymous function. Notice here, that we can use the map function and a lambda expression to apply a function, which we've defined on the fly, to our original list nums. The map function provides a quick and clean way to apply a function to an object iteratively without writing a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "# map() with lambda \n",
    "nums = [1, 2, 3, 4, 5]\n",
    "sqrd_nums = map(lambda x: x ** 2, nums)\n",
    "print(list(sqrd_nums))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy, or Numerical Python, is an invaluable Python package for Data Scientists. It is the fundamental package for scientific computing in Python and provides a number of benefits for writing efficient code.\n",
    "\n",
    "**NumPy arrays** provide a fast and memory-efficient alternative to Python lists. Typically, we import NumPy as np and use np dot array to create a NumPy array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n",
      "[0 1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "# python list \n",
    "nums_list = list(range(5))\n",
    "print(nums_list)\n",
    "\n",
    "# using numpyu alternative to python lists\n",
    "import numpy as np\n",
    "nums_np = np.array(range(5))\n",
    "print(nums_np)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy arrays are homogeneous, which means that they must contain elements of the same type. We can see the type of each element using the .dtype method. Suppose we created an array using a mixture of types. Here, we create the array nums_np_floats using the integers [1,3] and a float [2.5]. Can you spot the difference in the output? The integers now have a proceeding dot in the array. That's because NumPy converted the integers to floats to retain that array's homogeneous nature. Using .dtype, we can verify that the elements in this array are floats."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "integer numpy array [1 2 3]\n",
      "int32\n",
      "float numpy array [1.  2.5 3. ]\n",
      "float64\n"
     ]
    }
   ],
   "source": [
    "# NumPy array homogeneity\n",
    "nums_np_ints = np.array([1, 2, 3]) \n",
    "print('integer numpy array',nums_np_ints)\n",
    "print(nums_np_ints.dtype)\n",
    "\n",
    "nums_np_floats = np.array([1, 2.5, 3])\n",
    "print('float numpy array',nums_np_floats)\n",
    "print(nums_np_floats.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When analyzing data, you'll often want to perform operations over entire collections of values quickly. Say, for example, you'd like to square each number within a list of numbers. It'd be nice if we could simply square the list, and get a list of squared values returned. Unfortunately, Python lists don't support these types of calculations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for ** or pow(): 'list' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-10-14d223ec0fdb>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Python lists don't support broadcasting\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mnums\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mnums\u001b[0m \u001b[1;33m**\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for ** or pow(): 'list' and 'int'"
     ]
    }
   ],
   "source": [
    "# Python lists don't support broadcasting\n",
    "nums = [-2, -1, 0, 1, 2]\n",
    "nums ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could square the values using a list by writing a for loop or using a list comprehension as shown in the code below. But neither of these approaches is the most efficient way of doing this. Here lies the second advantage of NumPy arrays - their broadcasting functionality. NumPy arrays vectorize operations, so they are performed on all elements of an object at once. This allows us to efficiently perform calculations over entire arrays. Let's compare the computational time using these three approaches in the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Execution time using for loops over list: 0.0020008087158203125 seconds\n",
      "Execution time using list comprehension: 0.0020008087158203125 seconds\n",
      "Execution time using numpy array broadcasting: 0.0010006427764892578 seconds\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "# define numerical list \n",
    "nums = range(0,1000)\n",
    "nums = list(nums)\n",
    "\n",
    "# For loop (inefficient option)\n",
    "# get the start time\n",
    "st = time.time()\n",
    "\n",
    "sqrd_nums = []\n",
    "for num in nums:\n",
    "    sqrd_nums.append(num ** 2)\n",
    "#print(sqrd_nums)\n",
    "\n",
    "# get the end time\n",
    "et = time.time()\n",
    "\n",
    "# get the execution time\n",
    "elapsed_time = et - st\n",
    "print('Execution time using for loops over list:', elapsed_time, 'seconds')\n",
    "\n",
    "\n",
    "# List comprehension (better option but not best)\n",
    "# get the start time\n",
    "st = time.time()\n",
    "\n",
    "sqrd_nums = [num ** 2 for num in nums]\n",
    "#print(sqrd_nums)\n",
    "\n",
    "# get the end time\n",
    "et = time.time()\n",
    "print('Execution time using list comprehension:', elapsed_time, 'seconds')\n",
    "\n",
    "\n",
    "# using numpy array broadcasting\n",
    "\n",
    "# define the numpy array \n",
    "nums_np = np.arange(0,1000)\n",
    "# get the start time\n",
    "st = time.time()\n",
    "\n",
    "nums_np ** 2\n",
    "\n",
    "# get the end time\n",
    "et = time.time()\n",
    "\n",
    "# get the execution time\n",
    "elapsed_time = et - st\n",
    "print('Execution time using numpy array broadcasting:', elapsed_time, 'seconds')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the first two approaches have the same time complexity while using NumPy in the third approach has decreased the computational time to half."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another advantage of NumPy arrays is their indexing capabilities. When comparing basic indexing between a one-dimensional array and a list, the capabilities are identical. When using two-dimensional arrays and lists, the advantages of arrays are clear. To return the second item of the first row in our two-dimensional object, the array syntax is [0,1]. The analogous list syntax is a bit more verbose as you have to surround both the zero and one with square brackets [0][1]. To return the first column values in the 2-d object, the array syntax is [:,0]. Lists don't support this type of syntax, so we must use a list comprehension to return columns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2\n",
      "[1, 4]\n",
      "[1 4]\n"
     ]
    }
   ],
   "source": [
    "#2-D list\n",
    "nums2 = [ [1, 2, 3],\n",
    "        [4, 5, 6] ]\n",
    "\n",
    "\n",
    "# 2-D array\n",
    "nums2_np = np.array(nums2)\n",
    "\n",
    "# printing the second item of the first row \n",
    "print(nums2[0][1])\n",
    "print(nums2_np[0,1])\n",
    "\n",
    "# printing the first row values \n",
    "\n",
    "print([row[0] for row in nums2])\n",
    "print(nums2_np[:,0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy arrays also have a special technique called boolean indexing. Suppose we wanted to gather only positive numbers from the sequence listed here. With an array, we can create a boolean mask using a simple inequality. Indexing the array is as simple as enclosing this inequality in square brackets. However, to do this using a list, we need to write a for loop to filter the list or use a list comprehension. In either case, using a NumPy array to the index is less verbose and has a faster runtime."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2]\n",
      "[1, 2]\n",
      "[1, 2]\n"
     ]
    }
   ],
   "source": [
    "nums = [-2, -1, 0, 1, 2]\n",
    "nums_np = np.array(nums)\n",
    "\n",
    "# Boolean indexing\n",
    "print(nums_np[nums_np > 0])\n",
    "\n",
    "# No boolean indexing for lists\n",
    "# For loop (inefficient option)\n",
    "\n",
    "\n",
    "pos = []\n",
    "for num in nums:\n",
    "    if num > 0:\n",
    "        pos.append(num)\n",
    "print(pos)\n",
    "\n",
    "\n",
    "# List comprehension (better option but not best)\n",
    "pos = [num for num in nums if num > 0]\n",
    "print(pos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.Python Code Timing and Profiling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the second section of the article, you will learn how to gather and compare runtimes between different coding approaches. You'll practice using the line_profiler and memory_profiler packages to profile your code base and spot bottlenecks. Then, you'll put your learnings to practice by replacing these bottlenecks with efficient Python code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1. Python Runtime Investigation "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As mentioned in the previous chapter code efficiency code means fast code. To be able to measure how fast our code is we need to be able to measure the code runtime. Comparing runtimes between two code bases, that effectively do the same thing, allows us to pick the code with the optimal performance. By gathering and analyzing runtimes, we can be sure to implement the code that is fastest and thus more efficient.\n",
    "\n",
    "To compare runtimes, we need to be able to compute the runtime for a line or multiple lines of code. IPython comes with some handy built-in magic commands we can use to time our code. Magic commands are enhancements that have been added on top of the normal Python syntax. These commands are prefixed with the percentage sign. If you aren't familiar with magic commands take a moment to review the documentation. \n",
    "\n",
    "\n",
    "Let's start with this example: we want to inspect the runtime for selecting 1,000 random numbers between zero and one using NumPy's **random.rand()** function. Using %timeit just requires adding the magic command before the line of code we want to analyze. That's it! One simple command to gather runtimes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "26.6 µs ± 4.32 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit rand_nums = np.random.rand(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see %timeit provides an average of timing statistics. This is one of the advantages of using %timeit. We also see that multiple runs and loops were generated. %timeit runs through the provided code multiple times to estimate the code's average execution time. This provides a more accurate representation of the actual runtime rather than relying on just one iteration to calculate the runtime. The mean and standard deviation displayed in the output is a summary of the runtime considering each of the multiple runs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Specifying number of runs/loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The number of runs represents how many iterations you'd like to use to estimate the runtime. The number of loops represents how many times you'd like the code to be executed per run. We can specify the number of runs, using the -r flag, and the number of loops, using the -n flag. Here, we use -r2, to set the number of runs to two and -n10, to set the number of loops to ten. In this example, %timeit would execute our random number selection 20 times in order to estimate runtime (2 runs each with 10 executions)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "90 µs ± 2.64 µs per loop (mean ± std. dev. of 2 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "# Set number of runs to 2 (-r2)\n",
    "# Set number of loops to 10 (-n10)\n",
    "%timeit -r2 -n10 rand_nums = np.random.rand(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another cool feature of %timeit is its ability to run on single or multiple lines of code. When using %timeit in line magic mode, or with a single line of code, one percentage sign is used and we can run %timeit in cell magic mode (or provide multiple lines of code) by using two percentage signs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.77 µs ± 62.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "# Single line of code\n",
    "%timeit nums = [x for x in range(10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.32 µs ± 101 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "# Multiple lines of code\n",
    "nums = []\n",
    "for x in range(10):\n",
    "    nums.append(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also save the output of %timeit into a variable using the -o flag. This allows us to dig deeper into the output and see things like the time for each run, the best time for all runs, and the worst time for all runs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21.6 µs ± 991 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "The timings for all the 7 runs [1.9878090000020164e-05, 2.1997419999934208e-05, 2.3160939999979746e-05, 2.157510999995793e-05, 2.0585660000051577e-05, 2.2036539999953675e-05, 2.1905299999980344e-05]\n",
      "The best timing is 1.9878090000020164e-05\n",
      "The worst timeing is 2.3160939999979746e-05\n"
     ]
    }
   ],
   "source": [
    "# Saving the output to a variable and exploring them\n",
    "\n",
    "times = %timeit -o rand_nums = np.random.rand(1000)\n",
    "print('The timings for all the 7 runs',times.timings)\n",
    "print('The best timing is',times.best)\n",
    "print('The worst timeing is',times.worst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2. Code profiling for runtime"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've covered how to time the  code using the magic command %timeit, which works well with bite-sized code. But, what if we wanted to time a large code base or see the line-by-line runtimes within a function? In this section, we'll cover a concept called code profiling that allows us to analyze code more efficiently.\n",
    "\n",
    "Code profiling is a technique used to describe how long, and how often, various parts of a program are executed. The beauty of a code profiler is its ability to gather summary statistics on individual pieces of our code without using magic commands like %timeit. We'll focus on the line_profiler package to profile a function's runtime line-by-line. \n",
    "\n",
    "Since this package isn't a part of Python's Standard Library, we need to install it separately. This can easily be done with a pip install command as shown in the code below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting line_profiler\n",
      "  Downloading line_profiler-3.5.1-cp37-cp37m-win_amd64.whl (52 kB)\n",
      "Installing collected packages: line-profiler\n",
      "Successfully installed line-profiler-3.5.1\n"
     ]
    }
   ],
   "source": [
    "!pip install line_profiler"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's explore using line_profiler with an example. Suppose we have a list of names along with each someones height (in centimeters) and weight (in kilograms) loaded as NumPy arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = ['Ahmed', 'Mohammed', 'Youssef']\n",
    "hts = np.array([188.0, 191.0, 185.0])\n",
    "wts = np.array([ 95.0, 100.0, 75.0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will then develop a function called convert_units that converts each person's height from centimeters to inches and weight from kilograms to pounds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Ahmed': (74.01559999999999, 209.4389),\n",
       " 'Mohammed': (75.19669999999999, 220.462),\n",
       " 'Youssef': (72.8345, 165.3465)}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def convert_units(names, heights, weights):\n",
    "    new_hts = [ht * 0.39370 for ht in heights]\n",
    "    new_wts = [wt * 2.20462 for wt in weights]\n",
    "    data = {}\n",
    "    for i,name in enumerate(names):\n",
    "        data[name] = (new_hts[i], new_wts[i])\n",
    "    return data\n",
    "convert_units(names, hts, wts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we wanted to get an estimated runtime of this function, we could use %timeit. But, this will only give us the total execution time. What if we wanted to see how long each line within the function took to run? One solution is to use %timeit on each individual line of our convert_units function. But, that's a lot of manual work and not very efficient."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13.1 µs ± 787 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit convert_units(names, hts, wts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead, we can profile our function with the line_profiler package. To use this package, we first need to load it into our session. We can do this using the command %load_ext followed by line_profiler."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we can use the magic command %lprun, from line_profiler, to gather runtimes for individual lines of code within the convert_units function. %lprun uses a special syntax. First, we use the -f flag to indicate we'd like to profile a function. Then, we specify the name of the function we'd like to profile. Note, the name of the function is passed without any parentheses. Finally, we provide the exact function call we'd like to profile by including any arguments that are needed. This is shown in the code below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The line_profiler extension is already loaded. To reload it, use:\n",
      "  %reload_ext line_profiler\n"
     ]
    }
   ],
   "source": [
    "%load_ext line_profiler\n",
    "%lprun -f convert_units convert_units(names, hts, wts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3. Code profiling for memory use"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've defined efficient code as code that has a minimal runtime and a small memory footprint. So far, we've only covered how to inspect the runtime of our code. In this section, we'll cover a few techniques on how to evaluate our code's memory usage."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One basic approach for inspecting memory consumption is using Python's built-in module sys. This module contains system-specific functions and contains one nice method .getsizeof which returns the size of an object in bytes. sys.getsizeof() is a quick way to see the size of an object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9112"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "nums_list = [*range(1000)]\n",
    "sys.getsizeof(nums_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4096"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nums_np = np.array(range(1000))\n",
    "sys.getsizeof(nums_np)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the memory allocation of a list is almost double that of a NumPy array. However, this method only gives us the size of an individual object. However, if we wanted to inspect the line-by-line memory size of our code. As the runtime profile, we could use a code profiler. Just like we've used code profiling to gather detailed stats on runtimes, we can also use code profiling to analyze the memory allocation for each line of code in our code base. We'll use the memory_profiler package which is very similar to the line_profiler package. It can be downloaded via pip and comes with a handy magic command (%mprun) that uses the same syntax as %lprun."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "first lets download the meomery profiler package"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting memory_profiler\n",
      "  Downloading memory_profiler-0.60.0.tar.gz (38 kB)\n",
      "Requirement already satisfied: psutil in c:\\users\\youss\\anaconda3\\envs\\new_enviroment\\lib\\site-packages (from memory_profiler) (5.7.2)\n",
      "Building wheels for collected packages: memory-profiler\n",
      "  Building wheel for memory-profiler (setup.py): started\n",
      "  Building wheel for memory-profiler (setup.py): finished with status 'done'\n",
      "  Created wheel for memory-profiler: filename=memory_profiler-0.60.0-py3-none-any.whl size=31279 sha256=288154cda37cbe0ab88effb1aaa56beba4a185ce47eb84b745a1603b06b8294b\n",
      "  Stored in directory: c:\\users\\youss\\appdata\\local\\pip\\cache\\wheels\\67\\2b\\fb\\326e30d638c538e69a5eb0aa47f4223d979f502bbdb403950f\n",
      "Successfully built memory-profiler\n",
      "Installing collected packages: memory-profiler\n",
      "Successfully installed memory-profiler-0.60.0\n"
     ]
    }
   ],
   "source": [
    "!pip install memory_profiler"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To be able to apply %mprun to a function and calculate the meomery allocation, this function should be loaded from a separate physical file and not in the IPython console so first we will create a utils_funcs.py file and define the convert_units function in it, and then we will load this function from the file and apply %mprun to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The memory_profiler extension is already loaded. To reload it, use:\n",
      "  %reload_ext memory_profiler\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from utils_funcs import convert_units\n",
    "\n",
    "%load_ext memory_profiler\n",
    "%mprun -f convert_units convert_units(names, hts, wts)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}