Clase 1 - Introducción.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Unidad V: Lenguaje de programación Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En esta unidad aprenderemos ideas básicas sobre programación utilizando el leguaje python. \n",
    "\n",
    "Durante toda esta parte, utilizaremos como guía: \n",
    "\n",
    "* El libro **Python para todos**, de _Raúl González Duque_, el cual se encuentra online siguiendo [este link]\n",
    "* Los apuntes de la cátedra, disponibles en  [github]\n",
    "* El tutorial de python en español, disponble en el sitio web de la [Comunidad de Python Argentina]\n",
    "* La [documentación oficial de python](https://docs.python.org/3/), en inglés \n",
    "\n",
    "Todos estos materiales pueden ser accedidos durante el parcial.\n",
    "\n",
    "Además son muy interesantes para aprender:\n",
    "\n",
    "* El curso interactivo de python en [codecademy]\n",
    "* El curso de [python ya]\n",
    "* Curso de código facilito en [youtube]\n",
    "\n",
    "<!-- Links -->\n",
    "[este link]: http://mundogeek.net/tutorial-python/\n",
    "[github]: https://github.com/py-crash/fundamentos-de-informatica\n",
    "[Comunidad de Python Argentina]: http://docs.python.org.ar/tutorial/3/index.html \n",
    "[documentación oficial de python]: https://docs.python.org/3/\n",
    "[codecademy]: https://www.codecademy.com/learn/learn-python\n",
    "[python ya]: http://www.tutorialesprogramacionya.com/pythonya/\n",
    "[youtube]: https://www.youtube.com/watch?v=mGH1uooFhGs&list=PLpOqH6AE0tNiK7QN6AJo_3nVGQPc8nLdM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "64de540e-1794-422c-a05c-76114b0a38dc"
    }
   },
   "source": [
    "## ¿Qué es python?\n",
    "\n",
    "Un **lenguaje de programación**. Fue creado por un holadés llamado Guido Van Rossum en el año 1989.\n",
    "\n",
    "Tiene como características:\n",
    "* Es un lenguaje de _alto nivel_\n",
    "* Ser fácil de aprender, de programar y de leer\n",
    "* Interpretado\n",
    "* Multiparadigma\n",
    "* Fuertemente tipado, aunque presenta tipado dinámico\n",
    "* Gratuito"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algo genial para recordar antes de adentrarnos en el maravilloso mundo de la programación son las palabras escritas en el libro _\"Estructura e Interpretacion de programas computacionales\"_:\n",
    "\n",
    "> Los lenguajes de programacion no son solo una forma de lograr que una computadora\n",
    "> realice una tarea, sino que es en realidad una novedosa forma de expresar ideas sobre una\n",
    "> metodología. Por tanto, los programas deben ser escritos para ser leidos por personas,\n",
    "> e incidentalmente para ser ejecutadas por máquinas. \n",
    "\n",
    "Es por ello que es realmente importante que nuestro código sea legible, de modo tal de que cualquier persona con la que trabajemos, y nosotros mismos después de un tiempo, pueda entender nuestro código.\n",
    "\n",
    "## Las herramientas del curso\n",
    "\n",
    "Actualmente coexisten las versiones de python 2 y python 3. Sin embargo, python 2 solo va a ser soportado hasta el 2020, es por ello que en este curso se utiliza **python 3**. Algunos de los materiales nombrados arriba son para python 2, sin embargo las diferencias en esta instancia son pequeñas, por lo que no debería presentar problemas\n",
    "\n",
    "La herramienta utilizada es el Notebok de jupyter. Tiene la ventaja de ser muy interactivo, permitiendonos crear celdas de código que después ejecutamos. Además podemos agregar distintas celdas de texto.\n",
    "\n",
    "Los notebooks de jupyter se guardan en un archivo \\*.ipynb. Y pueden exportarse a pdf, html o como archivos de código python (\\*.py). Esto nos permite compartir fácilmente con otras personas lo que trabajamos. Es por ello que Paul Romer, ganador del premio nobel de economía 2018, lo eligió como la herramienta para [realizar su investigación]. Es por ello que los apuntes de la cátedra están hechos utilizando los notebooks de jupyter.\n",
    "\n",
    "### Instalación\n",
    "Para instalar Jupyter Notebook podemos:\n",
    "* Si estamos en _Windows_ utilizar una distribución de python como [Anaconda] o [Canopy]\n",
    "* Los usuarios de _Linux_ pueden utilizar las distribuciones arriba mencionadas, o simplemente utilizar los paquetes de su distribución.\n",
    "\n",
    "<!-- Links -->\n",
    "[realizar su investigación]: https://qz.com/1417145/economics-nobel-laureate-paul-romer-is-a-python-programming-convert\n",
    "[Anaconda]: https://www.enthought.com/product/canopy/\n",
    "[Canopy]: https://www.anaconda.com/download/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "e004aba3-5e3a-4a38-814b-0f734ab00d22"
    }
   },
   "source": [
    "## Temas de esta clase\n",
    "\n",
    "Los temas que aprenderémos en la primer clase son:\n",
    "\n",
    "1. El uso de la función `print`\n",
    "1. Nombres válidos de variables en python\n",
    "1. Los distintos tipos de datos\n",
    "1. Las distintas operaciones con números\n",
    "1. Uso de funciones\n",
    "\n",
    "Para repasar estos temas recomiendo ir al libro [**\"Python para todos\"**](http://mundogeek.net/tutorial-python/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio 1:\n",
    "Crear un programa que salude a toda la clase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "nbpresent": {
     "id": "e6d83493-83c8-4835-89dc-06ee482d95c1"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola clase\n"
     ]
    }
   ],
   "source": [
    "print(\"Hola clase\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "f734ec47-8a43-4199-aa2c-380216ff3cc5"
    }
   },
   "source": [
    "### Ejercicio 2:\n",
    "Crear una variable de cada tipo que hayamos aprendido"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true,
    "nbpresent": {
     "id": "f5ead9af-673a-449b-a5c6-a454e3a22e2f"
    }
   },
   "outputs": [],
   "source": [
    "real = 1.5\n",
    "entero = 2\n",
    "cadena = \"Agustin\"\n",
    "# Y cual falta?\n",
    "boleanos = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio 3:\n",
    "Crear un programa que pida al usuario dos números e imprima:\n",
    "* La suma de ambos\n",
    "* La diferencia del primero respecto segundo\n",
    "* Su producto\n",
    "* La división del primero por el segundo\n",
    "* La potencia del primero elevado al sugundo\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "nbpresent": {
     "id": "00977e02-9c9d-4573-b48a-6493a6e686bb"
    }
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "ingrese un Número 10\n",
      "ingrese otro Número 2\n"
     ]
    }
   ],
   "source": [
    "numero_1 = input(\"ingrese un Número\")\n",
    "numero_2 = input(\"ingrese otro Número\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Convertimos los números a enteros\n",
    "numero_1 = int(numero_1)\n",
    "numero_2 = int(numero_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "suma = numero_1 + numero_2\n",
    "resta = numero_1 - numero_2\n",
    "multiplicacion = numero_1 * numero_2\n",
    "division = numero_1 / numero_2\n",
    "potencia = numero_1 ** numero_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La suma es 12\n",
      "La resta es 8\n",
      "La multiplicación es 20\n",
      "La division es 5.0\n",
      "La potencia es 100\n"
     ]
    }
   ],
   "source": [
    "print(\"La suma es\", suma)\n",
    "print(\"La resta es\", resta)\n",
    "print(\"La multiplicación es\", multiplicacion)\n",
    "print(\"La division es\", division)\n",
    "print(\"La potencia es\", potencia)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio 4:\n",
    "Realice en una celda un programa que convierta un número ingresado de metros a centímetros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Ingrese una distancia en metros:  4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La distancia en cm es 400.0\n"
     ]
    }
   ],
   "source": [
    "numero_en_metros = input(\"Ingrese una distancia en metros: \")\n",
    "numero_en_metros = float(numero_en_metros)\n",
    "numero_en_cm = numero_en_metros*100\n",
    "print(\"La distancia en cm es\", numero_en_cm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones\n",
    "\n",
    "Para evitar repetir una y otra vez un fragmento de código, podemos crear funciones. Las funciones son justamente fragmentos de código con un nombre asociado, las cuales nos devuelven un valor. Las funciones nos ayudan a dividir  nuestro código en partes, es decir más modular, lo cual nos permite expandirlo más fácilmente, así como también hace más fácil corregir los errores que se presenten.\n",
    "\n",
    "Veamos un ejemplo con el ejercicio anterior:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def mts2cm(dist_mts):\n",
    "    \"\"\"Convierte una distancia ingresada en metros a su correspondiente \n",
    "    valor en cm \n",
    "    \"\"\"\n",
    "    dist_mts = float(dist_mts)\n",
    "    dist_cm = dist_mts * 100\n",
    "    return dist_cm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Así vemos que una función se define comenzando con la palabra `def`, seguida por el nombre de la función (en este caso `mts2cm`, y entre parentesis las entradas separadas por comas (en este caso una sola llamada `dist_mts`). La linea finaliza con `:`\n",
    "\n",
    "Todo lo que esté adentro de la función deberá estar correctamente indendado a 4 espacios. \n",
    "\n",
    "Al final de la función vemos la palabra `return` y al lado el valor que nos devolverá la función (en este caso nos va a devolver el valor que se encuentre dentro de la variable `dist_cm`)\n",
    "\n",
    "Para usar entonces la función debemos llamarla por su nombre:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Escriba una distacia en mts:  10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La distancia en cm es 1000.0\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Escriba una distacia en mts:  4\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La distancia en cm es 400.0\n"
     ]
    }
   ],
   "source": [
    "metros_1 = input(\"Escriba una distacia en mts: \")\n",
    "print(\"La distancia en cm es\",mts2cm(metros_1))\n",
    "\n",
    "metros_2 = input(\"Escriba una distacia en mts: \")\n",
    "print(\"La distancia en cm es\",mts2cm(metros_2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las funciones en pueden tener 0 o más entradas, y siempre devuelven un valor. Es así que que cuando una función no tenga ningún `return` nos devolverá el valor `None` (_Nada_)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las funciones nos pueden ahorrar mucho código ya que podemos usar una función una y otra vez, así como también usarlas dentro de otras funciones. Veamos el siguiente ejemplo en los ejercicios 5 y 6:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio 5: \n",
    "Crear una función que convierta una temperatura dada en grados celcius la convierta a grados Farenheit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def celcius_a_farenheit(temp_C):\n",
    "    temp_F = temp_C*9/5 + 32\n",
    "    return temp_F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "212.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "celcius_a_farenheit(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio 6:\n",
    "Crear una función que convierta una temperatura dada en grados Kelvin la convierta a grados Farenheit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def kelvin_a_farenheit(temp_k):\n",
    "    temp_celcius = temp_k - 273.15\n",
    "    temp_f = celcius_a_farenheit(temp_celcius)\n",
    "    return temp_f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32.0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kelvin_a_farenheit(273.15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Justamente, la función `kelvin_a_farenheit` hace uso de la función ya creada `celcius_a_farenheit` para facilitar su construcción."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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"
  },
  "nbpresent": {
   "slides": {
    "418c99dd-bd85-42fb-a3e6-fb7aee67c4cf": {
     "id": "418c99dd-bd85-42fb-a3e6-fb7aee67c4cf",
     "prev": "b28ff143-a5e7-4198-839c-30e918b77794",
     "regions": {
      "3385f71e-0400-4942-b1a0-646f79fe940b": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "f5ead9af-673a-449b-a5c6-a454e3a22e2f",
        "part": "whole"
       },
       "id": "3385f71e-0400-4942-b1a0-646f79fe940b"
      }
     }
    },
    "45312cfc-698b-4a53-9dd3-39ad15724452": {
     "id": "45312cfc-698b-4a53-9dd3-39ad15724452",
     "prev": null,
     "regions": {
      "cf5d3a54-f6e0-4c80-9e6f-aa346dd5df73": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "64de540e-1794-422c-a05c-76114b0a38dc",
        "part": "whole"
       },
       "id": "cf5d3a54-f6e0-4c80-9e6f-aa346dd5df73"
      }
     }
    },
    "b07357c3-666d-45be-881a-44d8871901f3": {
     "id": "b07357c3-666d-45be-881a-44d8871901f3",
     "prev": "d5021d66-6055-4481-aef0-a12fb939f657",
     "regions": {
      "66355481-6e00-4d18-bbdf-8edc1d7bbc8d": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "8d675fe8-bb1e-4d12-8214-faaf20751f71",
        "part": "whole"
       },
       "id": "66355481-6e00-4d18-bbdf-8edc1d7bbc8d"
      }
     }
    },
    "b28ff143-a5e7-4198-839c-30e918b77794": {
     "id": "b28ff143-a5e7-4198-839c-30e918b77794",
     "prev": "c4252237-61ce-4c6b-aa02-74774f652b4e",
     "regions": {
      "4586d165-386e-4767-9218-1645dd50a6d4": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "f734ec47-8a43-4199-aa2c-380216ff3cc5",
        "part": "whole"
       },
       "id": "4586d165-386e-4767-9218-1645dd50a6d4"
      }
     }
    },
    "c4252237-61ce-4c6b-aa02-74774f652b4e": {
     "id": "c4252237-61ce-4c6b-aa02-74774f652b4e",
     "prev": "feb43cba-077f-4e4a-b8e2-3abf313747a6",
     "regions": {
      "f93356fc-c4f1-4213-b8c0-259efaa17ec9": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "e6d83493-83c8-4835-89dc-06ee482d95c1",
        "part": "whole"
       },
       "id": "f93356fc-c4f1-4213-b8c0-259efaa17ec9"
      }
     }
    },
    "d5021d66-6055-4481-aef0-a12fb939f657": {
     "id": "d5021d66-6055-4481-aef0-a12fb939f657",
     "prev": "418c99dd-bd85-42fb-a3e6-fb7aee67c4cf",
     "regions": {
      "d03ba02e-ca9e-4358-ace4-a2a2f3a3898a": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "00977e02-9c9d-4573-b48a-6493a6e686bb",
        "part": "whole"
       },
       "id": "d03ba02e-ca9e-4358-ace4-a2a2f3a3898a"
      }
     }
    },
    "feb43cba-077f-4e4a-b8e2-3abf313747a6": {
     "id": "feb43cba-077f-4e4a-b8e2-3abf313747a6",
     "prev": "45312cfc-698b-4a53-9dd3-39ad15724452",
     "regions": {
      "eb4be71a-ebde-4595-9625-e141475eede1": {
       "attrs": {
        "height": 0.8,
        "width": 0.8,
        "x": 0.1,
        "y": 0.1
       },
       "content": {
        "cell": "e004aba3-5e3a-4a38-814b-0f734ab00d22",
        "part": "whole"
       },
       "id": "eb4be71a-ebde-4595-9625-e141475eede1"
      }
     }
    }
   },
   "themes": {}
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}