1-sintaxis-python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sintáxis de Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algunos tips para usar este Jupyter notebook:\n",
    "\n",
    "+ Click en una celda para entrar en **modo edición** (color verde), donde podés editar su contenido.\n",
    "+ `Esc` en una celda para salir del **modo edición** y pasar al **modo navegación**, donde podés copiar, pegar y mover una celda completa.\n",
    "+ `shift + enter` para ejecutar el contenido de una celda y moverte a la siguiente.\n",
    "+ `alt + enter` para ejecutar el contenido de una celda y crear una nueva inmediatamente después."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables, tipos básicos y operaciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podés sumar, restar, multiplicar y dividir como si usaras la calculadora de tu computadora."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T01:33:55.901301Z",
     "start_time": "2019-03-15T01:33:55.888605Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T01:34:33.793155Z",
     "start_time": "2019-03-15T01:34:33.789068Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T01:34:07.828841Z",
     "start_time": "2019-03-15T01:34:07.824223Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T01:35:13.653191Z",
     "start_time": "2019-03-15T01:35:13.649004Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python detecta automáticamente cuando un valor es un número entero o decimal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T01:36:41.612035Z",
     "start_time": "2019-03-15T01:36:41.607961Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(1 + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T01:36:49.988088Z",
     "start_time": "2019-03-15T01:36:49.983910Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T01:36:59.592629Z",
     "start_time": "2019-03-15T01:36:59.588374Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(3 / 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T01:37:03.900476Z",
     "start_time": "2019-03-15T01:37:03.896265Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(1.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algunas de estas operaciones también se pueden hacer con texto! El texto siempre va entre comillas dobles \"\" o simples ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T01:39:00.651819Z",
     "start_time": "2019-03-15T01:39:00.647583Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Mi balcón tiene un ficus'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Mi balcón tiene \" + \"un ficus\" # se pueden sumar textos!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T01:39:01.634186Z",
     "start_time": "2019-03-15T01:39:01.625602Z"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for -: 'str' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-28-34b27a9ada1b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m\"Mi balcón tiene \"\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;34m\"un ficus\"\u001b[0m \u001b[0;31m# no se pueden restar textos!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for -: 'str' and 'str'"
     ]
    }
   ],
   "source": [
    "\"Mi balcón tiene \" - \"un ficus\" # no se pueden restar textos!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio:** intenta multiplicar un texto por el número 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio:** intenta dividir un texto por el número 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los valores se pueden guardar en variables con el nombre que quieras para usarlos luego en operaciones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T01:51:17.024127Z",
     "start_time": "2019-03-15T01:51:17.020038Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45\n",
      "Mi balcón tiene un ficus\n"
     ]
    }
   ],
   "source": [
    "personas_cantidad = 15\n",
    "empanadas_por_persona = 3\n",
    "empanadas_a_pedir = personas_cantidad * empanadas_por_persona\n",
    "print(empanadas_a_pedir)\n",
    "\n",
    "balcon_contenido = \"un ficus\"\n",
    "balcon_frase = \"Mi balcón tiene \" + balcon_contenido\n",
    "print(balcon_frase)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio**: formar la frase \"Mi balcón tiene un ficus\" creando y sumando variables que contengan texto pero que no contengan *ningún espacio en su interior* (Hint: podés sumar espacios *sin que estén dentro de variables*)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Templates de texto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin embargo, si querés generar textos más complejos puede ser poco práctico crear una infinidad de variables y sumarlas. Sería mejor escribir primero todo el texto que vas a querar y dejar el espacio para las cosas que pueden variar, no? Python tiene una forma muy práctica de hacer esto **generando templates de texto**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T01:57:31.556553Z",
     "start_time": "2019-03-15T01:57:31.552652Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'En el día de hoy va a hacer {} grados de temperatura, con vientos {} y va a llover {} milímetros'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tiempo_hoy = \"En el día de hoy va a hacer {} grados de temperatura, con vientos {} y va a llover {} milímetros\"\n",
    "tiempo_hoy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T01:57:58.363694Z",
     "start_time": "2019-03-15T01:57:58.359604Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'En el día de hoy va a hacer 25 grados de temperatura, con vientos fuertes y va a llover 200 milímetros'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tiempo_hoy.format(25, \"fuertes\", 200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si tu texto va a tener varias líneas, también podés escribir párrafos de cualquier longitud, usando **triples comillas dobles o simples**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T02:01:12.720106Z",
     "start_time": "2019-03-15T02:01:12.711627Z"
    }
   },
   "outputs": [],
   "source": [
    "tiempo_semana = \"\"\"\n",
    "Lunes    : temperatura ({}) / vientos  ({}) / precipitaciones ({})\n",
    "Martes   : temperatura ({}) / vientos  ({}) / precipitaciones ({})\n",
    "Miércoles: temperatura ({}) / vientos  ({}) / precipitaciones ({})\n",
    "Jueves   : temperatura ({}) / vientos  ({}) / precipitaciones ({})\n",
    "Viernes  : temperatura ({}) / vientos  ({}) / precipitaciones ({})\n",
    "\"\"\"\n",
    "\n",
    "reporte_tiempo_semana = tiempo_semana.format(\n",
    "    25, \"fuertes\", 220,\n",
    "    23, \"fuertes\", 180,\n",
    "    22, \"moderados\", 215,\n",
    "    26, \"leves\", 154,\n",
    "    28, \"leves\", 167\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Lunes    : temperatura (25) / vientos  (fuertes) / precipitaciones (220)\n",
      "Martes   : temperatura (23) / vientos  (fuertes) / precipitaciones (180)\n",
      "Miércoles: temperatura (22) / vientos  (moderados) / precipitaciones (215)\n",
      "Jueves   : temperatura (26) / vientos  (leves) / precipitaciones (154)\n",
      "Viernes  : temperatura (28) / vientos  (leves) / precipitaciones (167)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(reporte_tiempo_semana)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin embargo, podés ver que esto no es muy práctico si tu texto va a ser muy largo y va a contener muchas variables. Es muy fácil cometer un error con la posición de alguna variable y terminar poniéndola donde no iba. Para solucionar esto, se pueden asignar **nombres** a las variables dentro de un template de texto. Ahora el orden ya no es relvante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "tiempo_semana = \"\"\"\n",
    "Lunes    : temperatura ({lun_temp}) / vientos  ({lun_temp}) / precipitaciones ({lun_temp})\n",
    "Martes   : temperatura ({mar_temp}) / vientos  ({mar_temp}) / precipitaciones ({mar_temp})\n",
    "Miércoles: temperatura ({mie_temp}) / vientos  ({mie_temp}) / precipitaciones ({mie_temp})\n",
    "Jueves   : temperatura ({jue_temp}) / vientos  ({jue_temp}) / precipitaciones ({jue_temp})\n",
    "Viernes  : temperatura ({vie_temp}) / vientos  ({vie_temp}) / precipitaciones ({vie_temp})\n",
    "\"\"\"\n",
    "\n",
    "reporte_tiempo_semana = tiempo_semana.format(\n",
    "    lun_temp = 25,\n",
    "    mar_temp = 23,\n",
    "    mie_temp = 22,\n",
    "    jue_temp = 26,\n",
    "    vie_temp = 28,\n",
    "    lun_viento = \"fuertes\",\n",
    "    mar_viento = \"fuertes\",\n",
    "    mie_viento = \"moderados\",\n",
    "    jue_viento = \"leves\",\n",
    "    vie_viento = \"leves\",\n",
    "    lun_precip = 220,\n",
    "    mar_precip = 180,\n",
    "    mie_precip = 215,\n",
    "    jue_precip = 154,\n",
    "    vie_precip = 167\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Lunes    : temperatura (25) / vientos  (25) / precipitaciones (25)\n",
      "Martes   : temperatura (23) / vientos  (23) / precipitaciones (23)\n",
      "Miércoles: temperatura (22) / vientos  (22) / precipitaciones (22)\n",
      "Jueves   : temperatura (26) / vientos  (26) / precipitaciones (26)\n",
      "Viernes  : temperatura (28) / vientos  (28) / precipitaciones (28)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(reporte_tiempo_semana)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las listas permiten guardar cualquier tipo de valor u objeto dentro de ellas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T10:26:10.972608Z",
     "start_time": "2019-03-15T10:26:10.967491Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['lunes', 'martes', 'miercoles', 'jueves', 'viernes']"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "semana_dias_habiles = [\"lunes\", \"martes\", \"miercoles\", \"jueves\", \"viernes\"]\n",
    "semana_dias_habiles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se puede acceder a uno o varios elementos contenidos utilizando sus índices, donde la primer posición es \"0\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T10:27:20.528149Z",
     "start_time": "2019-03-15T10:27:20.524254Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'lunes'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "semana_dias_habiles[0] # primera posición"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T10:27:28.967624Z",
     "start_time": "2019-03-15T10:27:28.963458Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'jueves'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "semana_dias_habiles[3] # cuarta posición"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando seleccionás un rango, no se incluye la posición final."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T10:29:10.039964Z",
     "start_time": "2019-03-15T10:29:10.035562Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['martes', 'miercoles']"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "semana_dias_habiles[1:3] # segunda a tercera posición"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También se puede hacer desde \"atrás para adelante\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T10:29:10.039964Z",
     "start_time": "2019-03-15T10:29:10.035562Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'viernes'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "semana_dias_habiles[-1] # última posición"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las listas pueden mezclar valores de distintos tipos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T10:30:08.686366Z",
     "start_time": "2019-03-15T10:30:08.681683Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['lunes', 'martes', 3, 4.0, ['otra', 'lista']]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[\"lunes\", \"martes\", 3, 4.0, [\"otra\", \"lista\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y se puede asignar valores a listas ya creadas, reemplazando su contenido."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T10:38:38.487698Z",
     "start_time": "2019-03-15T10:38:38.483101Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'dos', 3]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numeros = [1, 2, 3]\n",
    "numeros[1] = \"dos\"\n",
    "numeros"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio:** crear una lista con los nombres de los meses del año y acceder a los valores de los meses de invierno."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Diccionarios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un diccionario es parecido a una lista, pero en lugar de tener **elementos ordenados** tiene **elementos con nombre o etiqueta**. Ya no habrá índices numéricos para acceder a los valores, sino un nombre puesto por vos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T10:37:35.848565Z",
     "start_time": "2019-03-15T10:37:35.843360Z"
    }
   },
   "outputs": [],
   "source": [
    "meses_numeros = {\n",
    "    \"enero\": 1,\n",
    "    \"febrero\": 2,\n",
    "    \"marzo\": 3,\n",
    "    \"abril\": 4,\n",
    "    \"mayo\": 5,\n",
    "    \"junio\": 6,\n",
    "    \"julio\": 7,\n",
    "    \"agosto\": 8,\n",
    "    \"septiembre\": 9,\n",
    "    \"octubre\": 10,\n",
    "    \"noviembre\": 11,\n",
    "    \"diciembre\": 12\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T10:37:50.888097Z",
     "start_time": "2019-03-15T10:37:50.883499Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "meses_numeros[\"agosto\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También se puede asignar valores usando la misma sintaxis que en el caso de las listas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-03-15T10:39:33.535058Z",
     "start_time": "2019-03-15T10:39:33.530246Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'abril': 4,\n",
       " 'agosto': 'ocho',\n",
       " 'diciembre': 12,\n",
       " 'enero': 1,\n",
       " 'febrero': 2,\n",
       " 'julio': 7,\n",
       " 'junio': 6,\n",
       " 'marzo': 3,\n",
       " 'mayo': 5,\n",
       " 'noviembre': 11,\n",
       " 'octubre': 10,\n",
       " 'septiembre': 9}"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "meses_numeros[\"agosto\"] = \"ocho\"\n",
    "meses_numeros"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Recordatorio:** recordá siempre que los diccionarios _no tienen orden en sus elementos_!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Condicionales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podés ejecutar distintas instrucciones, dependiendo de que alguna condición se cumpla o no."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 no es igual a 2\n"
     ]
    }
   ],
   "source": [
    "if 1 == 2:\n",
    "    print(\"1 es igual a 2\")\n",
    "else:\n",
    "    print(\"1 no es igual a 2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se puede encadenar toda una serie de condiciones, que se chequean si la anterior falla."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El numero es igual a 1\n"
     ]
    }
   ],
   "source": [
    "numero = 1\n",
    "\n",
    "if numero == 2:\n",
    "    print(\"El numero es igual a 2\")\n",
    "elif numero == 3:\n",
    "    print(\"El numero es igual a 3\")\n",
    "elif numero == 1:\n",
    "    print(\"El numero es igual a 1\")\n",
    "else:\n",
    "    print(\"No sabemos qué es 1!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podés volver las condiciones a chequear más complejas usando `and` y `or`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El numero es igual a 2 o a 1\n"
     ]
    }
   ],
   "source": [
    "if numero == 2 or numero == 1:\n",
    "    print(\"El numero es igual a 2 o a 1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El numero es igual a 1 y la palabra arbol contiene una letra 'a'.\n"
     ]
    }
   ],
   "source": [
    "if numero == 1 and \"a\" in \"arbol\":\n",
    "    print(\"El numero es igual a 1 y la palabra arbol contiene una letra 'a'.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio:** escribí un bloque de código que lea la variable \"mes\" (que debe contener el nombre de un mes) e indique si este pertenece al primer, segundo, tercer o cuarto trimestre del año (Hint: podés volver a usar la variable `meses_numeros`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existen dos estructuras para iterar instrucciones en python: `for ... in ... :` y `while ... :`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# itera elementos de una lista, generador, diccionario o cualquier elemento iterable\n",
    "for number in [1, 2, 3]:\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# ejecuta un bloque de código mientras una condición se mantenga verdadera\n",
    "i = 1\n",
    "while i < 4:\n",
    "    print(i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio:** imprimir uno a uno todos los meses del año (usar `meses_numeros`), con su nombre y su número, usando un `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hasta acá revisaste los tipos de datos básicos en python, algunas operaciones y las estructuras de control (`while`, `for`, `if ... else`) más importantes. Pero cualquier proyecto chico o mediano se vuelve de una complejidad difícil de manejar, mantener y modificar sin usar funciones.\n",
    "\n",
    "Las funciones permiten encapsular operaciones complejas que hayamos construido, permitiendo manejar el crecimiento de la complejidad de un proyecto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sumar(numero_a, numero_b):\n",
    "    return numero_a + numero_b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sumar(1, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La definición de una función puede contener argumentos obligatorios (van primero) y argumentos opcionales (van al final y tienen un valor default)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sumar(numero_a, numero_b, numero_c=0):\n",
    "    return numero_a + numero_b + numero_c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "print(sumar(1, 1))\n",
    "print(sumar(1, 1, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio:** construí una función que reciba el nombre de un mes y devuelva el número del trimestre al que pertenece."
   ]
  },
  {
   "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.5.5"
  },
  "toc": {
   "base_numbering": 1,
   "colors": {
    "hover_highlight": "#DAA520",
    "running_highlight": "#FF0000",
    "selected_highlight": "#FFD700"
   },
   "moveMenuLeft": true,
   "nav_menu": {},
   "navigate_menu": true,
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "threshold": 4,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}