Python/clases/1_introduccion/1_informacion_general.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Notas para contenedor de docker:**\n",
    "\n",
    "Comando de docker para ejecución de la nota de forma local:\n",
    "\n",
    "nota: cambiar `dir_montar` por la ruta de directorio que se desea mapear a `/datos` dentro del contenedor de docker.\n",
    "\n",
    "```\n",
    "dir_montar=<ruta completa de mi máquina a mi directorio>#aquí colocar la ruta al directorio a montar, por ejemplo: \n",
    "#dir_montar=/Users/erick/midirectorio.\n",
    "```\n",
    "\n",
    "Ejecutar:\n",
    "\n",
    "```\n",
    "VERSION=<versión imagen de docker>\n",
    "docker run --rm -v $dir_montar:/datos --name jupyterlab_prope_r_kernel_tidyverse -p 8888:8888 -d palmoreck/jupyterlab_prope_r_kernel_tidyverse:$VERSION\n",
    "\n",
    "```\n",
    "\n",
    "Ir a `localhost:8888` y escribir el password para jupyterlab: `qwerty`\n",
    "\n",
    "\n",
    "Detener el contenedor de docker:\n",
    "\n",
    "```\n",
    "docker stop jupyterlab_prope_r_kernel_tidyverse\n",
    "```\n",
    "\n",
    "Documentación de la imagen de docker `palmoreck/jupyterlab_prope_r_kernel_tidyverse:<versión imagen de docker>` en [liga](https://github.com/palmoreck/dockerfiles/tree/master/jupyterlab/prope_r_kernel_tidyverse)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ejecución de la nota usar:\n",
    "\n",
    "[docker](https://www.docker.com/) (instalación de forma **local** con [Get docker](https://docs.docker.com/install/)) y ejecutar comandos que están al inicio de la nota de forma **local**. \n",
    "\n",
    "O bien dar click en alguno de los botones siguientes:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/palmoreck/dockerfiles-for-binder/jupyterlab_prope_r_kernel_tidyverse?urlpath=lab/tree/Propedeutico/Python/clases/1_introduccion/1_informacion_general.ipynb) esta opción crea una máquina individual en un servidor de Google, clona el repositorio y permite la ejecución de los notebooks de jupyter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Run on Repl.it](https://repl.it/badge/github/palmoreck/dummy)](https://repl.it/languages/python3) esta opción no clona el repositorio, no ejecuta los notebooks de jupyter pero permite ejecución de instrucciones de *Python* de forma colaborativa con [repl.it](https://repl.it/). Al dar click se crearán nuevos ***repl*** debajo de sus users de ***repl.it***.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Información general"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *Statements*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Computación un *statement* es una sección de código que representa una instrucción, comando o una acción. Como ejemplos en Computación están el *assignment* y *print statements* o los que se obtienen con el uso de operadores."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Valores, tipos y operadores aritméticos en los lenguajes de programación"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los valores son unidades básicas de información. Pertenecen a diferentes tipos como un número, una cadena de caracteres, *aka string*, que un programa manipula.\n",
    "\n",
    "Un tipo es una categoría de valores. Pueden ser por ejemplo: *integers*, *float* o *str* para números enteros, números con punto flotante o cadenas de caracteres respectivamente.\n",
    "\n",
    "Los operadores son símbolos especiales que representan cómputos. Ejemplos están: suma, multiplicación, asignación."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejemplos de valores y tipos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 #es un número entero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.0 #es un número en punto flotante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(3.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hola mundo!'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Hola mundo!\" #es una cadena de caracteres o string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(\"Hola mundo!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"2\" #es un string, en Python3 no hacemos distinción con '2'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'2'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(\"2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type('2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejemplos de operadores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-4 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5*3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "8/4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lenguajes formales y naturales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los **lenguajes naturales** son los que hablamos las personas como el Español, Inglés, Francés, evolucionaron naturalmente y las personas les hemos dado orden para comunicarnos entre nosotros.\n",
    "\n",
    "Los **lenguajes formales** son lenguajes diseñados por las personas para aplicaciones específicas. Por ejemplo la notación que es utilizada en Matemáticas es un lenguaje formal para denotar relaciones entre números y símbolos. Los **lenguajes de programación** son lenguajes formales que han sido diseñados para expresar cómputos.\n",
    "\n",
    "Los lenguajes naturales y formales comparten características y difieren en otras. Ambos utilizan reglas de sintaxis que hacen referencia a unidades básicas (palabras y números, por ejemplo, nombradas ***tokens***) y a una estructura (forma de combinar las *tokens*). Los lenguajes formales, sin embargo, tienen la característica de tener reglas estrictas de sintaxis para escribir ***statements*** de forma correcta y estructurada. En los lenguajes naturales es más flexible esto último.\n",
    "\n",
    "En Matemáticas encontramos *statements* al escribir 3 + 3 = 6. Un *statement* con una sintaxis incorrecta en Mate es 3 + = 3 o 3 ? 3 = 1 o bien en Español \"casa está lloviendo en mi\" o \"cas- está lloviendo en m\" (aunque tales *statements* utilicen *tokens* o símbolos correctos). **En Computación un *statement* es una sección de código que representa un comando o una acción**. Como ejemplos en Computación están el ***assignment*** y ***print statements***. \n",
    "\n",
    "También los lenguajes naturales están llenos de ambiguedad y las personas usamos el contexto y otra información para entender los *statements*. Los lenguajes formales están diseñados para no tener ambiguedad.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ¿Qué es un programa?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una secuencia de instrucciones que especifican cómo realizar un cómputo. Podemos distinguir **instrucciones básicas** en todos los lenguajes de programación:\n",
    "\n",
    "* *input:* datos de entrada (p.ej. obtenidos del teclado, un archivo, internet u otro dispositivo).\n",
    "\n",
    "* *output:* datos de salida (p.ej. mostrar información en la pantalla, o guardarla en un archivo o enviarla por internet)\n",
    "\n",
    "* *math:* operaciones matemáticas (p.ej. suma, multiplicación).\n",
    "\n",
    "* *conditional execution:* revisión de condiciones y ejecución del código.\n",
    "\n",
    "* *repetition*: realización de una acción repetidamente.\n",
    "\n",
    "Un programa está construído por instrucciones que son similares a las anteriores (no importa lo complejo de este programa). \n",
    "\n",
    "**Programación:** piensen a la programación como el proceso de dividir una tarea grande o compleja en tareas más pequeñas hasta tener tareas lo suficientemente sencillas para realizarlas con alguna(s) de éstas instrucciones.\n",
    "\n",
    "Como ejemplo de las instrucciones básicas en los lenguajes de programación que revisaremos, Python y R, permiten el uso de operadores siendo los más simples los operadores aritméticos (*math*). También ambos lenguajes permiten imprimir en pantalla con funciones como `print` (*output*).\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejemplo de programa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calcular el punto medio de dos valores proporcionados con valores de entrada en una celda de *jupyterlab*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.05"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#valores: <- utilizamos el símbolo de hashtag para escribir una línea de comentario\n",
    "\n",
    "7\n",
    "\n",
    "3.1\n",
    "\n",
    "#punto medio:\n",
    "\n",
    "(7 + 3.1)/2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables, expresiones, *assignment statement*, *print statement*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En un lenguaje de programación manejamos variables. Una variable es un nombre que hace referencia a un valor.\n",
    "\n",
    "Un *assignment statement* crea una nueva variable y le da un valor. Un *print statement* imprime en pantalla.\n",
    "\n",
    "Una expresión es una combinación de valores, variables y operadores. Un valor y una variable son por sí mismas consideradas expresiones.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Los lenguajes de programación se apoyan de funciones u operadores para crear *statements*.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En *Python* utilizamos la función `print` y el operador de asignación `=` para *print statement* y *assignment statement* respectivamente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python3 y R podemos empezar a usarlos dando click en el botón siguiente\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al dar click en el siguiente botón se crea un ambiente para escribir códigos con sintaxis de Python3 o R. El ambiente es de *jupyterlab* el cual corre un programa que nombramos **intérprete**. En programación escribimos en lenguajes que podemos leer y escribir y este intérprete realiza la traducción de tal escritura a lenguaje de máquina y también del lenguaje de máquina hacia lenguaje que podemos leer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/palmoreck/dockerfiles-for-binder/jupyterlab_prope_r_kernel_tidyerse?urlpath=lab/tree/Propedeutico/Python/clases/1_introduccion/2_core_python.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejemplo: *print statement*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola mundo!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hola mundo!\") #imprime en pantalla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n"
     ]
    }
   ],
   "source": [
    "print(4.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   2\n"
     ]
    }
   ],
   "source": [
    "print(\"{:4d}\".format(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.1415e+00\n"
     ]
    }
   ],
   "source": [
    "print(\"{:0.4e}\".format(2.141519182))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.9\n"
     ]
    }
   ],
   "source": [
    "print(\"{:.1f}\".format(1.87919))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En *jupyterlab* al sólo colocar en una nueva celda una sintaxis correcta del lenguaje el *default* es imprimir en pantalla:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hola mundo!'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Hola mundo!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejemplo: *assignment statement*\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creamos una variable y le damos un valor:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = \"Este mensaje es un string que almacenamos en la variable m, tal variable hace referencia a un valor de tipo string\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Este mensaje es un string que almacenamos en la variable m, tal variable hace referencia a un valor de tipo string\n"
     ]
    }
   ],
   "source": [
    "print(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 17 #variable que hace referencia a un valor tipo integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## *Python*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Python* es un lenguaje [orientado a objetos](https://en.wikipedia.org/wiki/Object-oriented_programming) desarrollado a finales de los 80's como un *scripting language* y actualmente es utilizado en las ciencias de datos y millones de proyectos afines."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los programas de *Python* no se compilan en lenguaje de máquina y más bien son interpretados. Los lenguajes intérpretes (como *MATLAB* o *R*) tienen la ventaja que pueden ser probados y *debuggeados* rápidamente. Por esto, el desarrollo de software en *Python* resulta ser más rápido que sus equivalentes en *Fortran* o en *C*. Sin embargo, una desventaja de los lenguajes intérpretes es que no producen aplicaciones *stand alone* por lo que los programas hechos en *Python* sólo pueden ejecutarse en computadoras que tengan el intérprete de *Python* instalado. Otra desventaja es que la velocidad de los programas en *Python* es menor que los programas compilados, por ejemplo los compilados en *C*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algunas ventajas que tiene *Python* sobre los lenguajes *mainstream* son las siguientes:\n",
    "* Es open source o de código abierto.\n",
    "* Disponible para la mayoría de sistemas operativos (GNU/Linux, Unix, Windows, Mac OS) y en varios de éstos se encuentra de inicio instalado.\n",
    "* Sencillo de instalar sus extensiones (paqueterías y librerías). El *core language* de *Python* es pequeño para mantener su simplicidad y se utilizan extensiones como paquetes y librerías para hacerlo más poderoso."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hay una notable influencia de *java* y *C++* y similitud con *MATLAB*. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un ejemplo para ver la similitud entre *MATLAB* y *Python* es el siguiente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "%Función en MATLAB\n",
    "function result = myfunc(a,b)\n",
    "    n = length(a);\n",
    "    resultado = zeros(n,1);\n",
    "    for i = 1:n\n",
    "            result(i) = a(i) + b(i);\n",
    "    end\n",
    "end\n",
    "\n",
    "%Llamada a función myfunc:\n",
    "a=[1 2 3]\n",
    "b=[4 5 6]\n",
    "myfunc(a,b)\n",
    "ans =\n",
    "\n",
    "   5\n",
    "   7\n",
    "   9\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Comentario**\n",
    "\n",
    "La documentación de *MATLAB* es mejor que la de *Python* principalmente pues este último es *open source* y la documentación depende de la comunidad de *developers* y *users* por lo que puede estar dispersa en distintos sitios. \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Python* implementa los conceptos de lenguajes orientados a objetos como clases, herencia, métodos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clases, objetos, atributos e instancias."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En los lenguajes de programación orientada a objetos como *Python* se hace uso de nombres como clases, objetos y atributos. Con los objetos y clases modelamos entidades de nuestro mundo. Por ejemplo el plano de una casa y una casa se pueden modelar con una clase y un objeto respectivamente. La clase para una casa contiene los detalles respecto a las ventanas, pisos y puertas. El objeto de la clase anterior es la casa misma ya construída.\n",
    "\n",
    "El nombre de atributo hace referencia a valores (referidos por variables) y métodos de un objeto. En el ejemplo de la casa del párrafo anterior, los atributos serían las ventanas, pisos y puertas del objeto casa.\n",
    "\n",
    "El nombre de instancia se utiliza para nombrar a los objetos creados a partir de una clase. Normalmente se le asigna una instancia a una variable vía un *assignment statement*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejemplo de función para el programa anterior"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podríamos crear una función con el *statement* `def` que reciba dos valores y devuelva el punto medio."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La estructura general de una función en *Python* es:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "def func(param1, param2): #puede haber más parámetros\n",
    "    #statements\n",
    "    return #return_values\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un parámetro puede ser cualquier objeto de *Python* incluyendo una función."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Observación**\n",
    "\n",
    "Es común utilizar el nombre de párametros y argumentos como sinónimos, sin embargo sí existe diferencia: el nombre parámetros se utiliza dentro de funciones y el nombre argumentos se utiliza en llamadas a funciones, esto es, los valores que se le pasan a la función.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para el cálculo del punto medio:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def middle_point(p1, p2): #parámetros p1, p2\n",
    "    return (p1+p2)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.05"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1 = 7 \n",
    "p2 = 3.1\n",
    "\n",
    "middle_point(p1, p2) #argumentos p1, p2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Paquetes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**El *core language* de Python es pequeño para mantener su simplicidad y se utilizan extensiones como paquetes y librerías para hacerlo más poderoso.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "#importamos el paquete de NumPy:\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Función en Python:\n",
    "def myfunc(a,b):\n",
    "    \"\"\"\n",
    "    Sum pointwise of two 1d numpy arrays.\n",
    "    Args:\n",
    "        a (array): 1d numpy array\n",
    "        b (array): 1d numpy array\n",
    "    Returns:\n",
    "        result (array): 1d numpy array with sum pointwise a, b\n",
    "    \"\"\"\n",
    "    n, = a.shape\n",
    "    result = np.zeros(n)\n",
    "    for i in range(0,n):\n",
    "        result[i] = a[i] + b[i]\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5. 7. 9.]\n"
     ]
    }
   ],
   "source": [
    "#Llamada a función myfunc:\n",
    "a = np.array([1,2,3])\n",
    "b = np.array([4,5,6])\n",
    "result = myfunc(a,b)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el ejemplo anterior se importó `numpy`. [NumPy](https://www.numpy.org/) es un paquete para cómputo científico con Python. Entre lo que contiene se encuentra:\n",
    "\n",
    "* Objetos array n-dimensionales.\n",
    "* Funciones para cálculos típicos en el Álgebra lineal, Cálculo, Probabilidad y Estadística. \n",
    "* Integración de código de *C/C++* y *Fortran* a través de herramientas.\n",
    "\n",
    "Además, *NumPy* procesa de forma multi-dimensional arrays que pueden contener no sólo números sino otro tipo de datos por ejemplo `strings`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Observación** \n",
    "\n",
    "\n",
    "Si el *array* contiene números entonces deben ser del mismo tipo de valor para formar al *NumPy array*.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*NumPy* puede instalarse como parte del *stack* del paquete [SciPy](https://www.scipy.org/) el cual es \"*... a Python-based ecosystem of open-source software for mathematics, science, and engineering. In particular, these are some of the core packages: NumPy, Scipy library, Matplotlib, IPython, Sympy, Pandas...*\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algunas observaciones del código de *Python* anterior:\n",
    "\n",
    "* No se tienen que definir o declararse variables para empezar a usarlas (a diferencia de *java* o *C*)\n",
    "* La línea `import numpy` indica al intérprete que se importe el paquete *NumPy* y por convención se importa como `np` (ver por ejemplo [liga](https://medium.com/google-cloud/naming-conventions-in-python-import-statements-a-bigquery-adventure-using-the-github-db-dump-d900159ab680)).\n",
    "* La función `range` crea la secuencia: [0,1,...,n-1]. También podemos usar [arange](https://numpy.org/doc/stable/reference/generated/numpy.arange.html) de *NumPy*.\n",
    "* El primer elemento del *array* tiene índice 0 a diferencia de *MATLAB* o *R*.\n",
    "* En *Python* no se tienen `end` *statements* para indicar que un loop o función termina pues se utiliza `indentation` para definirse el cuerpo.\n",
    "* *Python* es case-sensitive (como *R* y *MATLAB*)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Versión"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Python 3* es la versión que se utilizará en el curso."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Referencias para saber más sobre *Python*\n",
    "\n",
    "* [NumPy User Guide](https://docs.scipy.org/doc/numpy/user/)\n",
    "* [SciPy Tutorial](https://docs.scipy.org/doc/scipy/reference/tutorial/index.html). En esta referencia (sección Introduction) se hace mención sobre la convención en la comunidad para realizar imports:\n",
    "\n",
    "```\n",
    "import numpy as np\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "```\n",
    "\n",
    "...\"These are the import conventions that our community has adopted after discussion on public mailing lists. You will see these conventions used throughout NumPy and SciPy source code and documentation. While we obviously don’t require you to follow these conventions in your own code, it is highly recommended...\"\n",
    "\n",
    "* Una diferencia entre *SciPy* y *NumPy* pueden encontrarla en la liga [Linear Algebra (scipy.linalg)](https://docs.scipy.org/doc/scipy/reference/tutorial/linalg.html) en donde se hace mención lo siguiente: \"*...`scipy.linalg` contains all the functions in `numpy.linalg` plus some other more advanced ones not contained in `numpy.linalg`*.\n",
    "\n",
    "*Another advantage of using `scipy.linalg` over `numpy.linalg` is that it is always compiled with `BLAS/LAPACK` support, while for numpy this is optional. Therefore, the scipy version might be faster depending on how numpy was installed.*\n",
    "\n",
    "*Therefore, unless you don’t want to add SciPy as a dependency to your NumPy program, use `scipy.linag` instead of `numpy.linalg`...\"*\n",
    "\n",
    "* [PEP 8 -- Style Guide for Python Code](https://www.python.org/dev/peps/pep-0008/) en la que encontramos convención para los *import*'s: [PEP 8 -- Style Guide for Python Code:imports](https://www.python.org/dev/peps/pep-0008/#imports)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Referencias"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* [Think Python 2nd Edition by Allen B. Downey, O'Reilly](https://greenteapress.com/wp/think-python-2e/)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}