Notebooks/draft/Aula_17_Otimizando_Codigo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "FGV - EMAp - Escola de Matemática Aplicada\n",
    "==\n",
    "Introdução à Programação com a Linguagem Python\n",
    "--"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Otimização de Código em Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Referências:  \n",
    "http://cython.readthedocs.io/en/latest/src/tutorial/cython_tutorial.html  \n",
    "https://numba.pydata.org/  \n",
    "https://www.ibm.com/developerworks/community/blogs/jfp/entry/Python_Meets_Julia_Micro_Performance?lang=en  \n",
    "https://gist.github.com/jfpuget/b53f1e15a37aba5944ad  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import time\n",
    "import glob\n",
    "import os\n",
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Criando uma função Fibonacci Recursiva:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fib(n):\n",
    "    if n<2:\n",
    "        return n\n",
    "    return fib(n-1)+fib(n-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.64 ms ± 340 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n",
      "714 ms ± 114 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
      "2.42 s ± 251 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%timeit fib(20)\n",
    "%timeit fib(30)\n",
    "%timeit fib(33)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Compilando a função com o compilador Cython:  \n",
    "(pip3 install Cython)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext Cython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%cython\n",
    "\n",
    "def fib_cython(n):\n",
    "    if n<2:\n",
    "        return n\n",
    "    return fib_cython(n-1)+fib_cython(n-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.77 ms ± 296 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "217 ms ± 18.9 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
      "925 ms ± 110 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%timeit fib_cython(20)\n",
    "%timeit fib_cython(30)\n",
    "%timeit fib_cython(33)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos melhorar ainda mais compilando as variáveis estaticamente.  \n",
    "A função deve ser declarada com \"cpdef\" ao invés de def\". Dessa forma, podemos usar os tipos do C como parâmetros da função:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%cython\n",
    "\n",
    "cpdef long fib_cython_type(long n):\n",
    "    if n<2:\n",
    "        return n\n",
    "    return fib_cython_type(n-1)+fib_cython_type(n-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "61.3 µs ± 14.4 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n",
      "6.74 ms ± 703 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n",
      "27 ms ± 2.04 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit fib_cython_type(20)\n",
    "%timeit fib_cython_type(30)\n",
    "%timeit fib_cython_type(33)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma outra abordagem é permitindo que os resultados sejam guardados em _cache_:  \n",
    "Dessa forma podemos manter a precisão arbitrária das variáveis do Python, sem recorrer aos [tipos estáticos do C](https://notes-on-cython.readthedocs.io/en/latest/function_declarations.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import lru_cache as cache #Python3\n",
    "\n",
    "@cache(maxsize=None)\n",
    "def fib_cache(n):\n",
    "    if n<2:\n",
    "        return n\n",
    "    return fib_cache(n-1)+fib_cache(n-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "201 ns ± 40.8 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n",
      "278 ns ± 2.92 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n",
      "200 ns ± 51.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit fib_cache(20)\n",
    "%timeit fib_cache(30)\n",
    "%timeit fib_cache(33)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma outra maneira de emular o cache seria realizando uma modificação no algoritmo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fib_seq(n):\n",
    "    if n < 2:\n",
    "        return n\n",
    "    a,b = 1,0\n",
    "    for i in range(n-1):\n",
    "        a,b = a+b,a\n",
    "    return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.32 µs ± 568 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n",
      "2.39 µs ± 17.9 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n",
      "2.6 µs ± 37.6 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit fib_seq(20)\n",
    "%timeit fib_seq(30)\n",
    "%timeit fib_seq(33)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos compilar esta nova função com e sem a utilização de tipagem estática: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%cython\n",
    "\n",
    "def fib_seq_cython(n):\n",
    "    if n < 2:\n",
    "        return n\n",
    "    a,b = 1,0\n",
    "    for i in range(n-1):\n",
    "        a,b = a+b,a\n",
    "    return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "870 ns ± 30.3 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n",
      "1.36 µs ± 52 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n",
      "1.41 µs ± 191 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit fib_seq_cython(20)\n",
    "%timeit fib_seq_cython(30)\n",
    "%timeit fib_seq_cython(33)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%cython\n",
    "\n",
    "cpdef long fib_seq_cython_type(long n):\n",
    "    if n < 2:\n",
    "        return n\n",
    "    cdef long a,b\n",
    "    a,b = 1,0\n",
    "    for i in range(n-1):\n",
    "        a,b = a+b,a\n",
    "    return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "126 ns ± 30 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n",
      "122 ns ± 18 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n",
      "124 ns ± 15.2 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit fib_seq_cython_type(20)\n",
    "%timeit fib_seq_cython_type(30)\n",
    "%timeit fib_seq_cython_type(33)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos usar uma ferramenta chamada Numba, que é um just-in-time (jit) compiler:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numba import jit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "@jit\n",
    "def fib_seq_numba(n):\n",
    "    if n < 2:\n",
    "        return n\n",
    "    a,b = 1,0\n",
    "    for i in range(n-1):\n",
    "        a,b = a+b,a\n",
    "    return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "328 ns ± 10.8 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n",
      "330 ns ± 9.27 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n",
      "456 ns ± 50.9 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit fib_seq_numba(20)\n",
    "%timeit fib_seq_numba(30)\n",
    "%timeit fib_seq_numba(33)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Segundo exemplo:  \n",
    "Algoritmo de ordenação Quick Sort  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def qsort_kernel(a, lo, hi):\n",
    "    i = lo\n",
    "    j = hi\n",
    "    while i < hi:\n",
    "        pivot = a[(lo+hi) // 2]\n",
    "        while i <= j:\n",
    "            while a[i] < pivot:\n",
    "                i += 1\n",
    "            while a[j] > pivot:\n",
    "                j -= 1\n",
    "            if i <= j:\n",
    "                a[i], a[j] = a[j], a[i]\n",
    "                i += 1\n",
    "                j -= 1\n",
    "        if lo < j:\n",
    "            qsort_kernel(a, lo, j)\n",
    "        lo = i\n",
    "        j = hi\n",
    "    return a\n",
    "\n",
    "def benchmark_qsort():\n",
    "    lst = [random.random() for i in range(1,5000)]\n",
    "    qsort_kernel(lst, 0, len(lst)-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usando Numba:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "@jit\n",
    "def qsort_kernel_numba(a, lo, hi):\n",
    "    i = lo\n",
    "    j = hi\n",
    "    while i < hi:\n",
    "        pivot = a[(lo+hi) // 2]\n",
    "        while i <= j:\n",
    "            while a[i] < pivot:\n",
    "                i += 1\n",
    "            while a[j] > pivot:\n",
    "                j -= 1\n",
    "            if i <= j:\n",
    "                a[i], a[j] = a[j], a[i]\n",
    "                i += 1\n",
    "                j -= 1\n",
    "        if lo < j:\n",
    "            qsort_kernel_numba(a, lo, j)\n",
    "        lo = i\n",
    "        j = hi\n",
    "    return a\n",
    "\n",
    "def benchmark_qsort_numba():\n",
    "        lst = [random.random() for i in range(1,5000)]\n",
    "        qsort_kernel_numba(lst, 0, len(lst)-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numba e Numpy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "@jit\n",
    "def qsort_kernel_numba_numpy(a, lo, hi):\n",
    "    i = lo\n",
    "    j = hi\n",
    "    while i < hi:\n",
    "        pivot = a[(lo+hi) // 2]\n",
    "        while i <= j:\n",
    "            while a[i] < pivot:\n",
    "                i += 1\n",
    "            while a[j] > pivot:\n",
    "                j -= 1\n",
    "            if i <= j:\n",
    "                a[i], a[j] = a[j], a[i]\n",
    "                i += 1\n",
    "                j -= 1\n",
    "        if lo < j:\n",
    "            qsort_kernel_numba_numpy(a, lo, j)\n",
    "        lo = i\n",
    "        j = hi\n",
    "    return a\n",
    "\n",
    "def benchmark_qsort_numba_numpy():\n",
    "        lst = np.random.rand(5000)\n",
    "        qsort_kernel_numba(lst, 0, len(lst)-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usando Numpy e Cython:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%cython\n",
    "import numpy as np\n",
    "import cython\n",
    "\n",
    "@cython.boundscheck(False)\n",
    "@cython.wraparound(False)\n",
    "cdef double[:] \\\n",
    "qsort_kernel_cython_numpy_type(double[:] a, \\\n",
    "                               long lo, \\\n",
    "                               long hi):\n",
    "    cdef: \n",
    "        long i, j\n",
    "        double pivot\n",
    "    i = lo\n",
    "    j = hi\n",
    "    while i < hi:\n",
    "        pivot = a[(lo+hi) // 2]\n",
    "        while i <= j:\n",
    "            while a[i] < pivot:\n",
    "                i += 1\n",
    "            while a[j] > pivot:\n",
    "                j -= 1\n",
    "            if i <= j:\n",
    "                a[i], a[j] = a[j], a[i]\n",
    "                i += 1\n",
    "                j -= 1\n",
    "        if lo < j:\n",
    "            qsort_kernel_cython_numpy_type(a, lo, j)\n",
    "        lo = i\n",
    "        j = hi\n",
    "    return a\n",
    "\n",
    "def benchmark_qsort_numpy_cython():\n",
    "    lst = np.random.rand(5000)\n",
    "    qsort_kernel_cython_numpy_type(lst, 0, len(lst)-1)\n",
    "\n",
    "def benchmark_sort_numpy():\n",
    "    lst = np.random.rand(5000)\n",
    "    np.sort(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20.8 ms ± 3.01 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
      "1.67 ms ± 212 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
      "614 µs ± 664 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "820 µs ± 110 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n",
      "536 µs ± 62.6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit benchmark_qsort()\n",
    "%timeit benchmark_qsort_numba()\n",
    "%timeit benchmark_qsort_numba_numpy()\n",
    "%timeit benchmark_qsort_numpy_cython()\n",
    "%timeit benchmark_sort_numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multithreading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Módulo [Threading](https://www.tutorialspoint.com/python3/python_multithreading.htm)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import threading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "exitFlag = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class myThread(threading.Thread):\n",
    "    def __init__(self, threadID, name, counter, delay):\n",
    "        threading.Thread.__init__(self)\n",
    "        self.threadID = threadID\n",
    "        self.name = name\n",
    "        self.counter = counter\n",
    "        self.delay = delay\n",
    "        \n",
    "    def run(self):\n",
    "        print (\"Starting {}...\\n \".format(self.name))\n",
    "        print_time(self.name, self.counter, self.delay)\n",
    "        print (\"Exiting {}... \\n \".format(self.name))\n",
    "\n",
    "def print_time(threadName, counter, delay):\n",
    "    while counter:\n",
    "        if exitFlag:\n",
    "            threadName.exit()\n",
    "        time.sleep(delay)\n",
    "        print (\"{}: {}\\n\".format(threadName, time.ctime(time.time())))\n",
    "        counter -= 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create new threads\n",
    "thread1 = myThread(1, \"Thread-1\", 5, 1)\n",
    "thread2 = myThread(2, \"Thread-2\", 5, 2)\n",
    "thread3 = myThread(3, \"Thread-3\", 5, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting Thread-1...\n",
      " \n",
      "Starting Thread-2...\n",
      " \n",
      "Starting Thread-3...\n",
      " \n",
      "Thread-1: Mon Oct 22 15:49:06 2018\n",
      "\n",
      "Thread-1: Mon Oct 22 15:49:07 2018\n",
      "Thread-2: Mon Oct 22 15:49:07 2018\n",
      "\n",
      "\n",
      "Thread-3: Mon Oct 22 15:49:07 2018\n",
      "\n",
      "Thread-1: Mon Oct 22 15:49:08 2018\n",
      "\n",
      "Thread-3: Mon Oct 22 15:49:09 2018\n",
      "\n",
      "Thread-2: Mon Oct 22 15:49:09 2018\n",
      "Thread-1: Mon Oct 22 15:49:09 2018\n",
      "\n",
      "\n",
      "Thread-1: Mon Oct 22 15:49:10 2018\n",
      "\n",
      "Exiting Thread-1... \n",
      " \n",
      "Thread-3: Mon Oct 22 15:49:11 2018\n",
      "\n",
      "Thread-2: Mon Oct 22 15:49:11 2018\n",
      "\n",
      "Thread-3: Mon Oct 22 15:49:13 2018\n",
      "\n",
      "Thread-2: Mon Oct 22 15:49:13 2018\n",
      "\n",
      "Thread-3: Mon Oct 22 15:49:15 2018\n",
      "\n",
      "Exiting Thread-3... \n",
      " \n",
      "Thread-2: Mon Oct 22 15:49:15 2018\n",
      "\n",
      "Exiting Thread-2... \n",
      " \n",
      "Exiting Main Thread\n"
     ]
    }
   ],
   "source": [
    "# Start new Threads\n",
    "thread1.start() #chama o método run\n",
    "thread2.start()\n",
    "thread3.start()\n",
    "thread1.join() #aguarda que o thread termine\n",
    "thread2.join()\n",
    "thread3.join()\n",
    "print (\"Exiting Main Thread\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Módulo [Multiprocessing](https://docs.python.org/3/library/multiprocessing.html#module-multiprocessing)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "main line\n",
      "module name: __main__\n",
      "parent process: 56048\n",
      "process id: 57151\n",
      "function f\n",
      "module name: __main__\n",
      "parent process: 57151\n",
      "process id: 76230\n",
      "hello bob\n"
     ]
    }
   ],
   "source": [
    "from multiprocessing import Process\n",
    "import os\n",
    "\n",
    "def info(title):\n",
    "    print(title)\n",
    "    print('module name:', __name__)\n",
    "    print('parent process:', os.getppid())\n",
    "    print('process id:', os.getpid())\n",
    "\n",
    "def f(name):\n",
    "    info('function f')\n",
    "    print('hello', name)\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    info('main line')\n",
    "    p = Process(target=f, args=('bob',))\n",
    "    p.start()\n",
    "    p.join()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Módulo [Concurrent futures](https://docs.python.org/3/library/concurrent.futures.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import concurrent.futures\n",
    "import urllib.request"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "112272535095293 is prime: True\n",
      "112582705942171 is prime: True\n",
      "112272535095293 is prime: True\n",
      "115280095190773 is prime: True\n",
      "115797848077099 is prime: True\n",
      "1099726899285419 is prime: False\n"
     ]
    }
   ],
   "source": [
    "PRIMES = [\n",
    "    112272535095293,\n",
    "    112582705942171,\n",
    "    112272535095293,\n",
    "    115280095190773,\n",
    "    115797848077099,\n",
    "    1099726899285419]\n",
    "\n",
    "def is_prime(n):\n",
    "    if n % 2 == 0:\n",
    "        return False\n",
    "    sqrt_n = int(math.floor(math.sqrt(n)))\n",
    "    for i in range(3, sqrt_n + 1, 2):\n",
    "        if n % i == 0:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "def main():\n",
    "    with concurrent.futures.ProcessPoolExecutor() as executor:\n",
    "        for number, prime in zip(PRIMES, executor.map(is_prime, PRIMES)):\n",
    "            print('%d is prime: %s' % (number, prime))\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'http://www.oglobo.com/' page is 134590 bytes\n",
      "'http://europe.wsj.com/' page is 994081 bytes\n",
      "'http://www.cnn.com/' page is 1723318 bytes\n",
      "'http://www.foxnews.com/' page is 230195 bytes\n",
      "'http://www.bbc.co.uk/' page is 305605 bytes\n"
     ]
    }
   ],
   "source": [
    "URLS = ['http://www.foxnews.com/',\n",
    "        'http://www.cnn.com/',\n",
    "        'http://europe.wsj.com/',\n",
    "        'http://www.bbc.co.uk/',\n",
    "        'http://www.oglobo.com/']\n",
    "\n",
    "# Retrieve a single page and report the URL and contents\n",
    "def load_url(url, timeout):\n",
    "    with urllib.request.urlopen(url, timeout=timeout) as conn:\n",
    "        return conn.read()\n",
    "\n",
    "# We can use a with statement to ensure threads are cleaned up promptly\n",
    "with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:\n",
    "    # Start the load operations and mark each future with its URL\n",
    "    future_to_url = {executor.submit(load_url, url, 60): url for url in URLS}\n",
    "    for future in concurrent.futures.as_completed(future_to_url):\n",
    "        url = future_to_url[future]\n",
    "        try:\n",
    "            data = future.result()\n",
    "        except Exception as exc:\n",
    "            print('%r generated an exception: %s' % (url, exc))\n",
    "        else:\n",
    "            print('%r page is %d bytes' % (url, len(data)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}