02-Clases-y-modulos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Clases y Objetos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Las clases son una característica clave de la programación orientada al objeto. Una clase es **una estructura para representar un objeto**. Se puede considerar como un mapa (blueprint) del objecto a definir, una vez\n",
    "que se crea un objeto se le asigna un valor real. \n",
    "\n",
    "En Python una clase (y por ende un objeto) puede contener **atributos (variables)** y **métodos (funciones)**. Los atributos se asocian al estado de un objecto y los métodos al comportamiento del objeto. \n",
    "\n",
    "En Python una clase es definida en forma similar a una función, pero usando el comando `class`, y la definición de la clase usualmente contiene algunas definiciones de métodos (una función en una clase).\n",
    "\n",
    "Cada método de una clase debería tener un argumento `self` como su primer argumento. Este objeto es una autoreferencia.\n",
    "\n",
    "Algunos nombres de métodos de clases tienen un significado especial, por ejemplo:\n",
    "\n",
    "`__init__:` El nombre del método que es invocado cuando el objeto es creado por primera vez.\n",
    "Existen muchos otros métodos especiales, ver http://docs.python.org/2/reference/datamodel.html#special-method-names\n",
    "\n",
    "Ahora intentemos construir nuestra propia clase:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Perro:\n",
    "    pass\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Por Convención las **clases se definien con una letra mayuscula**. Esta clase como está ahora no tiene ningun atributo o método. Está vacía. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Como ya se mencionó, todas las clases contienen instruciones para crear\n",
    "objetos, y todos los objetos contienen ciertas características. Para entregar \n",
    "el estado inicial del objecto se utiliza el método especial `__init__`. Este método se llama de forma automática al crear un obejto (instancia) de un perro y no es necesario llamarlo de forma explícita. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Perro:\n",
    "    \n",
    "    # Inicializador/ Atributos iniciales\n",
    "    def __init__(self, edad, nombre):\n",
    "        self.edad = edad\n",
    "        self.nombre = nombre"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "Ahora podemos agregar algun atributo a nuestra clase Perro. Por ejemplo,\n",
    "aunque los perros pueden tener nombres distintos, todo perro es mamifero:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Perro:\n",
    "    \n",
    "    # Inicializador/ Atributos iniciales\n",
    "    def __init__(self, edad, nombre):\n",
    "        self.edad = edad\n",
    "        self.nombre = nombre\n",
    "        \n",
    "    especie = 'Mamifero'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Listo, nuestra clase Perro caracteriza de manera suficiente a una perro.\n",
    "Intentemos generar un objecto (instancia) de perro. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'Perro' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-5cdf828acb9e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mperro1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mPerro\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\"Snoo\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mperro2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mPerro\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\"Py\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'Perro' is not defined"
     ]
    }
   ],
   "source": [
    "perro1 = Perro(5,\"Snoo\")\n",
    "perro2 = Perro(6,\"Py\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Una vez creado los objetos puedo **acceder a los atributos** de nuestro \n",
    "objetos. En Python esto se hace con la siguiente síntaxis. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El nombre del gato 1 es Schro\n"
     ]
    }
   ],
   "source": [
    "print(\"El nombre del perro 1 es {}\".format(gato1.nombre))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La edad del gato 2 es 6\n"
     ]
    }
   ],
   "source": [
    "print(\"La edad del perro 2 es {}\".format(gato2.edad))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Métodos\n",
    "\n",
    "Además de tener atributos, un objeto puede tener métodos que \n",
    "se definen a través de una clase. Ya vimos un ejemplo de método\n",
    "que es el método `__init__` que define la clase. Siempre el primer\n",
    "argumento de cada método es el mismo objeto en forma de `self`. \n",
    "Entonces agregemos algunos métodos a nuestra clase Perro. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Perro:\n",
    "    \n",
    "    # Inicializador/ Atributos iniciales\n",
    "    def __init__(self, edad, nombre):\n",
    "        self.edad = edad\n",
    "        self.nombre = nombre\n",
    "        \n",
    "    especie = 'Mamifero'\n",
    "    \n",
    "    def descripcion(self):\n",
    "        return \"Mi perro tiene {} años y se llama {}\".format(self.edad,self.nombre)\n",
    "    \n",
    "    def habla(self, ideoma):\n",
    "        if ideoma == \"aleman\":\n",
    "            return(\"Wuff Wuff\")\n",
    "        elif ideoma == \"ingles\":\n",
    "            return(\"Woof Woof\")\n",
    "        elif ideoma == \"espanol\":\n",
    "            return(\"Wuau Wuau\")\n",
    "        else:\n",
    "            return(\"No se hablar \"+ideoma+\" =(\")\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Ahora vamos a definir un nuevo objeto con esta nueva clase y llamar los distintos métodos. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "miPerro = Perro(9, \"Albert\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Mi perro tiene 9 años y se llama Albert'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miPerro.descripcion()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Woof Woof'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "miPerro.habla(\"ingles\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Programación orientada en objetos y ciencia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este curso tiene un **enfoque cientifico** por lo tanto corresponde\n",
    "entregar ejemplos más acorde al enfoque del curso. **Programación \n",
    "orientada al objeto** tiene un rol muy importante por la siemple razón\n",
    "que cada disciplina científica tiene ciertos **objectos de estudio** cuya representación natural puede ser una clase. \n",
    "\n",
    "Por ejemplo pueden haber  **clases que permiten crear objectos de moleculas, estrellas, proteinas, capas tectónicas, mapas de radiación solar, etc..**\n",
    "\n",
    "Es por eso que es muy imporatante tener esta estrucutra de datos en mente cuando se pretende diseñar un codigo reutilizable. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Por ejemplo una clase de molecula se puede pensar de la siguiente manera:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Modulos "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "La mayoría de la funcionalidad en Python es provista por *módulos*. La [*Librería Estándar*](https://docs.python.org/2/library/) de Python es una gran colección de  módulos que proveen implementaciones *multiplataforma* de recursos tales como el acceso al sistema operativo, entrada/salido de archivos (file I/O), manejo de cadenas, comunicación en redes, y mucho más.\n",
    "\n",
    "Además es posible escribir un código de Python en forma de un módulo,\n",
    "lo que perimte organización lógica del código y una mayor capacidad \n",
    "de reutilización. Utilizando la Jerga de programación, un *modulo* es\n",
    "un objeto python con atributos que pueden ser referenciados y ligados a otros módulos. \n",
    "\n",
    "Para usar un módulo en un programa Python éste debe primero ser **importado**, para lo cual se usa el comando `import`. Por ejemplo, para importar el módulo `math`, que contiene muchas funciones matemáticas estándar, podemos usar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Esto importa el módulo completo y lo deja disponible para su uso en el programa. Por ejemplo, podemos escribir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "x = math.cos(2*math.pi)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Alternativamente, podemos elegir importar todos los símbolos (funciones y variables) en un módulo al espacio de nombres (namespace) actual (de modo que no necesitemos usar el prefijo \"`math.`\" cada vez que usemos algo del módulo `math`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "from math import *\n",
    "\n",
    "x = cos(2*pi)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Esta forma de proceder puede ser muy conveniente, pero en programas largos que incluyen muchos módulos es a menudo una buena idea mantener los símbolos de cada módulo en sus propios espacios de nombres, usando `import math`. Esto elimina potenciales confusiones con eventuales colisiones de nombres, ya que no es poco común encontrar funciones o variables definidas con el mismo nombre en módulos distintos.\n",
    "\n",
    "Como alternativa intermedia, podemos importar un módulo con un *alias* o nombre abreviado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "import math as m\n",
    "\n",
    "x = m.cos(2*m.pi)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Finalmente, podemos importar sólo algunos símbolos seleccionados desde un módulo listándolos explícitamente, en lugar de usar el carácter comodín `*`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "from math import cos, pi\n",
    "\n",
    "x = cos(2*pi)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "###  Mirando qué contiene un módulo, y su documentación\n",
    "\n",
    "Luego que se ha cargado un módulo, podemos listar los símbolos que éste provee usando la función `dir`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " 'acos',\n",
       " 'acosh',\n",
       " 'asin',\n",
       " 'asinh',\n",
       " 'atan',\n",
       " 'atan2',\n",
       " 'atanh',\n",
       " 'ceil',\n",
       " 'copysign',\n",
       " 'cos',\n",
       " 'cosh',\n",
       " 'degrees',\n",
       " 'e',\n",
       " 'erf',\n",
       " 'erfc',\n",
       " 'exp',\n",
       " 'expm1',\n",
       " 'fabs',\n",
       " 'factorial',\n",
       " 'floor',\n",
       " 'fmod',\n",
       " 'frexp',\n",
       " 'fsum',\n",
       " 'gamma',\n",
       " 'gcd',\n",
       " 'hypot',\n",
       " 'inf',\n",
       " 'isclose',\n",
       " 'isfinite',\n",
       " 'isinf',\n",
       " 'isnan',\n",
       " 'ldexp',\n",
       " 'lgamma',\n",
       " 'log',\n",
       " 'log10',\n",
       " 'log1p',\n",
       " 'log2',\n",
       " 'modf',\n",
       " 'nan',\n",
       " 'pi',\n",
       " 'pow',\n",
       " 'radians',\n",
       " 'remainder',\n",
       " 'sin',\n",
       " 'sinh',\n",
       " 'sqrt',\n",
       " 'tan',\n",
       " 'tanh',\n",
       " 'tau',\n",
       " 'trunc']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "dir(math)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Usando la función `help` podemos obtener una descripción de cada función (casi... no todas las funciones tienen *docstrings*, como se les llama técnicamente. Sin embargo, la mayoría de las funciones están documentadas de esta forma). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function log in module math:\n",
      "\n",
      "log(...)\n",
      "    log(x, [base=math.e])\n",
      "    Return the logarithm of x to the given base.\n",
      "    \n",
      "    If the base not specified, returns the natural logarithm (base e) of x.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(math.log)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.302585092994046"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log(10) # calcula el logaritmo de 10 en base e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.3219280948873626"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log(10, 2) # calcula el logaritmo de 10 en base 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "También podemos usar la función `help` directamente sobre los módulos: \n",
    "\n",
    "    help(math) \n",
    "\n",
    "Algunos módulos muy útiles de la librería estándar de Python son `os` (interfaz con el sistema operativo), `sys` (Parámetros y funciones específicas del sistema), `math` (funciones matemáticas), `shutil` (operaciones con archivos), `subprocess`, `multiprocessing`, `threading`. \n",
    "\n",
    "Una lista completa de los módulos estándar para Python 2 y Python 3 está disponible (en inglés) en [http://docs.python.org/2/library/](http://docs.python.org/2/library/) y [http://docs.python.org/3/library/](http://docs.python.org/3/library/), respectivamente. Una versión en español está disponible en [http://pyspanishdoc.sourceforge.net/lib/lib.html](http://pyspanishdoc.sourceforge.net/lib/lib.html).\n",
    "\n",
    "Existen muchos otros módulos (paquetes) desarrollados para Python que implementan distintas funcionalidades, herramientas y algoritmos. Muchos de ellos son constantemente desarrollados en forma abierta por comunidades de usuari@s interesad@s.\n",
    "\n",
    " Aquí listamos algunos módulos generales útiles en el ámbito de las ciencias (Físicas):\n",
    " \n",
    " * [Numpy](http://www.numpy.org/): Implementa el uso eficiente de arreglos numéricos multidimensionales (vectores, matrices, etc.).\n",
    " * [Scipy](http://www.scipy.org/): Implementa múltiples funciones especiales, algoritmos de integración numérica, optimización, interpolación, transformada de Fourier, procesamiento de señales, álgebra lineal, estadística, procesamiento de imágenes, entre otras. Este módulo hace uso de Numpy.\n",
    " * [Matplotlib](http://matplotlib.org/): Suministra herramientas para crear gráficos bidimensionales en diversos formatos, y en una calidad adecuada para incluirlos en publicaciones científicas.\n",
    " * [Sympy](http://sympy.org/): Paquete que implementa algoritmos de matemática simbólica.\n",
    " \n",
    " Además de estos paquetes principales (más usados) cabe la pena mencionar a:\n",
    "  \n",
    "* [Sunpy](http://sunpy.org/): Módulo para el análisis de datos relacionados con la física solar.\n",
    "* [EMpy](http://sunpy.org/): Suministra algoritmos numéricos usados en electromagnetismo.\n",
    "* [Mpmath](http://mpmath.org/): Módulo con herramientas para cálculos con valores reales y complejos con precisión arbitraria.\n",
    "* [Poliastro](http://poliastro.readthedocs.io/en/latest/):  Conjunto de rutinas Python útiles en astrodinámica y mecánica orbital.\n",
    "* [Fatiando a Terra](http://fatiando.org/): Conjunto de herramientas para la modelación de fenómenos geofísicos.\n",
    "* [ArcPy](http://pro.arcgis.com/en/pro-app/arcpy/get-started/what-is-arcpy-.htm). Módulo que provee heramientas para análisis, conversión y manejo de datos geográficos, y de automatización de mapas.\n",
    "* [Qutip2](http://qutip.org/):  Paquete de herramientas para simular la dinámica de sistemas cuánticos abiertos.\n",
    "* [Yt](http://yt-project.org/): Paquete para el análisis y visualización de datos volumétricos.\n",
    "* [Fipy](http://www.ctcms.nist.gov/fipy/): Implementa algoritmos para resolver ecuaciones diferenciales parciales (EDP) por medio de métodos de volúmenes finitos.\n",
    "* [Holopy](http://manoharan.seas.harvard.edu/holopy/): Herramientas para el trabajo con hologramas digitales y scattering de luz.\n",
    "* [Astropy](http://www.astropy.org/): Módulo que implementa herramientas de uso común en Astronomía.\n",
    "* [Galpy](http://galpy.readthedocs.io/en/latest/): Módulo para Dinámica Galáctica.\n",
    "* [AstroML](http://www.astroml.org/) Módulo con herramientas de \"machine learning\" y \"data mining\" de datos astronómicos, basado en Numpy, Scipy, Scikit-Learn, Matplotlib y Astropy.\n",
    "* [Librosa](http://librosa.github.io/librosa/): Módulo para análisis de audio y música.\n",
    "* [Scikit-learn](http://scikit-learn.org/): Implementa funciones de \"Machine Learning\" (Clasificación, Regresión, Clustering, reducción dimensional, Selección de Modelos, etc.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "help(math)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Creación de Módulos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Uno de los conceptos más importantes en programación es el de reusar código para evitar repeticiones.\n",
    "\n",
    "La idea es escribir funciones y clases con un propósito y extensión bien definidos, y reusarlas en lugar de repetir código similar en diferentes partes del programa (programación modular). Usualmente el resultado es que se mejora ostensiblemente la facilidad de lectura y de mantención de un programa. En la práctica, esto significa que nuestro programa tendrá menos errores, y serán más fáciles de extender y corregir. \n",
    "\n",
    "Python permite programación modular en diferentes niveles. Las funciones y las clases son ejemplos de herramientas para programación modular de bajo nivel. Los módulos Python son construcciones de programación modular de más alto nivel, donde podemos colectar variables relacionadas, funciones y clases. Un módulo Python es definido en un archivo Python (con extensión `.py`), y puede ser accequible a otros módulos Python y a programas usando el comendo `import`. \n",
    "\n",
    "Considere el siguiente ejemplo: el archivo `curosPYC.py` contiene una implementación simple de una variable, una función y una clase:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import cursoPYC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "perro3 = cursoPYC.Perro(7, \"Jack\")"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}