python-intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python\n",
    "\n",
    "## Instalación\n",
    "\n",
    "El lenguaje de programación del que harás uso es Python 2.7 (no se cubrirá el uso de Python 3.x), que puedes bajar de la siguiente dirección\n",
    "http://www.python.org/getit/windows/\n",
    "\n",
    "<img src='fig1pagpython.png'>\n",
    "\n",
    "En este sitio puedes ver las opciones para bajar Python en distintas distribuciones. Si sigues la primer liga (http://www.python.org/download/releases/), entrarás a la siguiente página\n",
    "\n",
    "<img src='fig2pagdescarga.png'>\n",
    "\n",
    "Pero si lo deseas, y de hecho, como recomendación, puedes usar la versión de Enthought Python Distribution (http://www.enthought.com/products/epd.php), la cual tiene una distribución gratuita (https://www.enthought.com/products/epd/free/) y que resultará particularmente útil, ya que tiene integradas bibliotecas como Numpy o Matplotlib. \n",
    "\n",
    "<img src='fig3pagcanopy.png'\n",
    "\n",
    "Una vez instalado, podrás ver las siguientes opciones en el menú de inicio:\n",
    "\n",
    "<img src='fig4menuinicio.png'>\n",
    "\n",
    "Para los usuarios de Windows 8 y 10, la ejecución e instalación es esencialmente la misma.\n",
    "\n",
    "Si eres usuario de Linux es muy probable que ya lo tengas instalado, y si no, es muy sencillo instalarlo; depende de tu distribución para lograr esto.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Uso básico\n",
    "\n",
    "Python es un lenguaje de programación interactivo, orientado a objetos, y de tipado dinámico, así como con algunas características de un lenguaje funcional. Su principal motivación es la de crear código entendible y restringir más el laconismo que caracteriza a C o Java. Para hacer esto, en Python la identificación de los programas no es despreciable; esto significa que el margen izquierdo que caracteriza en el editor de scripts tiene un significado: el alcance de las variables definidas en ese nivel, o bien, la definición de un ámbito concreto. Esto significa que todas las variables que defina en cierto nivel pueden ser leídas en ese nivel o en aquellos donde la identación es mayor. Identar un texto se refiere a alinearlo con un margen izquierdo mayor que el nivel anterior. El nivel de identación original es el margen 0. Si identaras el texto un nivel, por ejemplo, al margen izquierdo 4, entonces todo el texto que estuviera alineado al margen 4 estaría a un nivel de identación. En el caso concreto de Python, los distintos niveles de identación determinan el estilo de codificación que seguirás, ya que es la manera en que este lenguaje decide qué líneas pertenecen o no a un mismo bloque de código.\n",
    "\n",
    "A continuación puedes ver un par de ejemplos, uno de ellos correcto y el otro incorrecto.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 0\n",
      "4 1\n",
      "4 2\n",
      "4 3\n",
      "4 4\n"
     ]
    }
   ],
   "source": [
    "i = 4\n",
    "for j in range(5):\n",
    "    print i,j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block (<ipython-input-3-20b939772371>, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-3-20b939772371>\"\u001b[1;36m, line \u001b[1;32m3\u001b[0m\n\u001b[1;33m    print i,j\u001b[0m\n\u001b[1;37m        ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m expected an indented block\n"
     ]
    }
   ],
   "source": [
    "i = 4\n",
    "for j in range(5):\n",
    "print i,j"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La razón por la que el primer ejemplo funciona y el segundo no, a pesar de que ambos se ven idénticos, es porqué el segundo no tiene un tabulador que le indica al lenguaje que esas líneas pertenecen al bloque del for, cuando esta instrucción debe tener al menos una línea. Otro requerimiento de la sintaxis de python es el uso de los dos punto (:). Puedes ver que después de\n",
    "\n",
    "$$\\mathtt{range(5)}$$\n",
    "\n",
    "Está escrito un símbolo de $\\mathtt{:}$. Estos también son necesarios, por lo que la instrucción queda.\n",
    "\n",
    "$$\\mathtt{range(5)}:$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como todo lenguaje de programación, Python tiene definido una sintaxis de operación básica en la que está definido cómo hacer la asignación de variables, cómo usar los operadores aritméticos básicos, las operaciones lógicas básicas, la ejecución de ciclos, la definición de clases, etcétera. En esta sección repasarás algunos de estos puntos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Asignación y cadenas\n",
    "\n",
    "Python es un lenguaje de tipado dinámico, lo que quiere decir que no tiene palabras reservadas para determinar si algún número es entero, flotante, o cualquier variante de ésas que son ampliamente usadas en otros lenguajes fuertemente tipados como Java. Los detalles sobre cómo Python puede identificar la precisión del número con el que estás trabajando son ajenos a este curso; sin embargo, de aquí en adelante usarás la siguiente regla de asignación de variables sin mayor diferencia:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45\n",
      "nombre\n",
      "0.445\n"
     ]
    }
   ],
   "source": [
    "var = 45\n",
    "print var\n",
    "var = \"nombre\"\n",
    "print var\n",
    "var = 0.445\n",
    "print var"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como puedes ver, sin mayor problema asignas no sólo un valor, sino un tipo completamente diferente de datos a la misma variable, y así es como funciona la asignación de variables en Python. \n",
    "También puedes observar que el uso de cadenas se hace a través de envolver las mismas con un par de comillas (“cadena\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cadena 1\n"
     ]
    }
   ],
   "source": [
    "var = \"cadena 1\"\n",
    "print var\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un conjunto de funciones existentes en Python que vale la pena recordar son: $\\mathtt{len, str, print, input}$. A continuación puedes ver un ejemplo de cada una aplicada a la variable var del ejemplo anterior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(var)  #logitud de var"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'12'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(12)   #convierte a cadena el argumento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dame tu nombre: \"Sergio \"\n",
      "Sergio \n"
     ]
    }
   ],
   "source": [
    "var=input(\"Dame tu nombre: \" ) #Encierra entre comillas el nuevo valor\n",
    "print var"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "En los ejemplos anteriores es importante notar que $\\mathtt{len}$ calcula la longitud del argumento que hayas pasado, $\\mathtt{str}$ convierte a cadena el argumento; es por esto que aparece envuelto en comillas simples, y $\\mathtt{var}$ recibe una cadena, ya que de otra forma fallaría."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listas\n",
    "\n",
    "Otra característica en la operación de Python es su orientación al manejo de listas, las cuales se conforman de la siguiente manera. \n",
    "Si deseas hacer una lista vacía, debes hacer lo siguiente:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = []\n",
    "M = list()\n",
    "type(L)\n",
    "type(M)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si deseas hacer una lista con una cantidad ya conocida de elementos, lo que tienes que hacer es lo siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fruta   huevos   frijoles   tocino   cafe  \n"
     ]
    }
   ],
   "source": [
    "L = [1,2,3,6,8,\"a\",\"algo\",8, 3.2]\n",
    "Desayuno = [\"fruta\", \"huevos\", \"frijoles\", \"tocino\", \"cafe\"]\n",
    "for alimento in Desayuno:    #examinando la lista Desayuno\n",
    "    print alimento, \" \","
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para que puedas obtener (indexar) algún elemento de una lista previamente hecha, lo que tienes que hacer es usar los paréntesis cuadrados y el índice del elemento requerido:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'fruta'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Desayuno[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observa que, al igual que en muchos lenguajes de programación, el indexado de elementos empieza en 0 y no en 1 como usualmente se hace en matemáticas (o incluso en Matlab u Octave).\n",
    "\n",
    "Pero con Python se han esforzado mucho en hacer un uso eficiente y cómodo de las listas y otro tipo de secuencias, por lo que la siguiente notación, aunque no es estándar, te ayudará mucho a poder manipularlas con comodidad. \n",
    "\n",
    "Si deseas obtener todos los elementos de una lista cuyos índices sean, por ejemplo, el 3, 4 y 5, lo que tienes que hacer es pasar entre corchetes los índices 3 y 6, separados por dos puntos de la siguiente forma:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 8, 'a']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[3:6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es decir, entre corchetes pasas el índice donde quieras empezar a tomar la subsecuencia (<i>slice</i>) y el índice siguiente de donde quieras que termine; o sea, si tu subsecuencia va del índice i al índice j, entonces, entre corchetes, pasas desde i hasta j+1.\n",
    "Si quieres todos los elementos de una lista a partir del elemento 2 (o bien, lo puedes generalizar del n-ésimo elemento en adelante), lo que tienes que haces es:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['frijoles', 'tocino', 'cafe']"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Desayuno[2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puedes pasar índices negativos. Por ejemplo, si pasas Desayuno[-1], lo que obtienes es:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cafe'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Desayuno[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O bien, puedes pedir toda la subsecuencia de los últimos dos elementos de la lista Desayuno de la siguiente manera:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['tocino', 'cafe']"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Desayuno[-2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta instrucción puede ser interpretada en lenguaje natural como: dame los elementos de la lista $\\mathtt{Desayuno}$, empezando dos antes de terminar. Perosi quieres los elementos de la lista Desayuno, dejando fuera los últimos dos elementos, entonces  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['fruta', 'huevos', 'frijoles']"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Desayuno[:-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si lo que quieres es obtener una copia de los valores de una lista, lo que tienes que hacer es ocupar el operador dos puntos (:) dentro de los corchetes sin acompañarlo de ningún número, o sea:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 6, 8, 'a', 'algo', 8, 3.2]\n",
      "[1, 2, 3, 6, 8, 'a', 'algo', 8, 3.2]\n",
      "[1, 2, 3, 6, 100, 'a', 'algo', 8, 3.2]\n",
      "[1, 2, 3, 6, 8, 'a', 'algo', 8, 3.2]\n"
     ]
    }
   ],
   "source": [
    "P = L[:]\n",
    "print P\n",
    "print L\n",
    "P[4]=100\n",
    "print P\n",
    "print L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es muy importante que recuerdes que así se copian los valores de una lista, ya que al hacer una simple asignación, como $\\mathtt{Q=L}$, lo que estarías haciendo sería referenciar la lista $\\mathtt{L}$ con el nombre $\\mathtt{Q}$. Lo que significa que si haces un cambio en la lista Q, se verá reflejado también en L sin que sea necesariamente lo que necesitas, y esto puede inducir a errores, ya que Python no lanza una excepción en este caso, pues así está diseñado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 6, 'cambio', 'a', 'algo', 8, 3.2]\n",
      "[1, 2, 3, 6, 'cambio', 'a', 'algo', 8, 3.2]\n",
      "[1, 2, 3, 6, 'cambio', 'a', 'algo', 8, 3.2]\n"
     ]
    }
   ],
   "source": [
    "Q=L\n",
    "print Q\n",
    "Q[4]\n",
    "Q[4]='cambio'\n",
    "print Q\n",
    "print L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si lo que quieres es unir dos listas, puedes usar el operador +"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "L = [1, 2, 3]\n",
    "M = [4, 5, 6]\n",
    "N = L+M            #Union de las dos listas anteriores\n",
    "print N"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O bien, puedes concatenar varias veces el valor de alguna lista, por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "O = L*4\n",
    "print O"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python las cadenas de caracteres también son consideradas como listas, lo que significa que el primer carácter de alguna cadena lleva el índice 0, 1 el segundo, y así hasta el último carácter, el cual se puede saber haciendo uso de la función $\\mathtt{len}$, que dirá la longitud total de la cadena y, por lo tanto, el último carácter tiene como índice un número menor que lo que indique esta función. Al ser tratadas como listas, podrás indexarlas de la misma manera que estas últimas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = \"Hola Mundo\"\n",
    "len(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "la \n"
     ]
    }
   ],
   "source": [
    "print  c[0]\n",
    "print  c[2:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existen otras estructuras extremadamente útiles que se mencionarán en su momento en caso de que las ocupes, pero sería bueno que investigaras su función y las conocieras; se trata de las tuplas y los diccionarios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "D = dict()   #D es ahora un diccionario y puede guardar valores con llaves\n",
    "t = (4,5)    #t es una tupla que es muy parecido a una lista con más restricciones\n",
    "D['nombre'] = 'Alumno'\n",
    "D['edad'] = 20\n",
    "D['altura'] = 1.80\n",
    "print D['edad']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operadores Aritméticos\n",
    "\n",
    "Los operadores matemáticos son un tema que prácticamente ya conoces porque son muy similares al de otros lenguajes, excepto por algunas particularidades referentes a la conversión de tipos en los números.\n",
    "\n",
    "Los operadores de suma, multiplicación, división, potenciación, negación, etcétera, los puedes encontrar en la siguiente tabla:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "5\n",
      "50\n",
      "2\n",
      "100000\n",
      "5\n",
      "-10\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "a=10\n",
    "b=5\n",
    "print a+b    #suma\n",
    "print a-b    #resta\n",
    "print a*b    #multiplicacion\n",
    "print a/b    #división\n",
    "print a**b   #potenciación\n",
    "print b%a    #modulo\n",
    "print -a     #negación\n",
    "print abs(a) #valor absoluto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una observación importante es que si divides un entero entre otro entero, el resultado por default es entero. Pero si lo que quieres es la expansión decimal, entonces tienes que hacer un truco como se muestra a continuación:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1.25\n",
      "1.25\n"
     ]
    }
   ],
   "source": [
    "a = 5/4\n",
    "print a\n",
    "a = float(5)/4\n",
    "print a\n",
    "a = 5.0/4\n",
    "print a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observa el uso de la función float. Lo que hace está función es convertir en flotante el argumento que le pases. \n",
    "\n",
    "La jerarquía para aplicar estos operadores está determinada por la siguiente tabla. Primero se ejecuta lo que haya entre paréntesis, luego se evalúan los exponentes, luego la multiplicación y división, y hasta el final, la suma y la resta.\n",
    "\n",
    "1. Paréntesis\n",
    "0. Exponentes\n",
    "0. Multiplicación y División\n",
    "0. Suma y Resta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operadores lógicos\n",
    "\n",
    "Los valores lógicos en Python son el $\\mathtt{True}$ y el $\\mathtt{False}$. Los operadores lógicos son el and, or y not. La forma de checar la igualdad entre dos valores es igual que en muchos lenguajes, con el doble igual ($\\mathtt{==}$)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a,b,c = 1,2,1\n",
    "a==b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a==c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = 0\n",
    "not d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para comprobar la relación entre dos valores puedes usar los siguientes operadores, $\\mathtt{==}$ (igualdad), > (mayor que), < (menor que), $\\mathtt{>=}$ (mayor o igual), $\\mathtt{<=}$ (menor o igual), y que funcionan como en otros lenguajes que ya conoces"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ciclos\n",
    "\n",
    "Una de las partes más importantes de un lenguaje de programación es su control de flujo, aspecto que se controla a través de las instrucciones para establecer ciclos; en Python éstas son el $\\mathtt{for}$ y el $\\mathtt{while}$. \n",
    "\n",
    "La sintaxis del $\\mathtt{for}$ es como sigue:\n",
    "\n",
    "for variable in lista_de_valores:\\\\\n",
    "\\rightarrow Cuerpo del for\n",
    "\n",
    "Esta forma del for indica que todas las líneas especificadas en el cuerpo se ejecutan tantas veces como valores tome variable en la lista_de_valores. Presta particular atención en los dos puntos al final de la línea que contiene al for, y en el tabulador que debe aplicarse a Todas las líneas dentro del cuerpo del for; estos no son Opcionales.\n",
    "\n",
    "A continuación puedes ver un par de ejemplos de cómo invocar el for:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linea  1\n",
      "Linea  2\n",
      "Linea  3\n"
     ]
    }
   ],
   "source": [
    "for i in [1, 2, 3]:\n",
    "    print \"Linea \", i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aquí puedes ver cómo el cuerpo del for que consta de una sola línea se ejecuta tantas veces como valores toma la variable i dentro de la lista especificada. El siguiente ejemplo es un poco más complicado, no sólo porque el for usa dos líneas, sino porque también se introducen dos funciones nuevas que son str y range, así como la concatenación de cadenas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Esta es la linea  0\n",
      "0El doble de 0 es: 0\n",
      "Esta es la linea  1\n",
      "1El doble de 1 es: 2\n",
      "Esta es la linea  2\n",
      "2El doble de 2 es: 4\n",
      "Esta es la linea  3\n",
      "3El doble de 3 es: 6\n",
      "Esta es la linea  4\n",
      "4El doble de 4 es: 8\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print \"Esta es la linea \", i \n",
    "    print str(i) +  \"El doble de \" + str(i) + \" es: \" + str(i*2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función range entrega una lista que va desde el valor inicial indicado en el parámetro hasta el final, también indicado en el parámetro; cuando sólo se indica un número, toma por defecto que la lista comienza en 0 y acaba en ese número. Opcionalmente, también puedes indicarle cuántos pasos debe dejar intermedios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(2,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(2,5,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función range entrega una lista que va desde el valor inicial indicado en el parámetro hasta el final, también indicado en el parámetro; cuando sólo se indica un número, toma por defecto que la lista comienza en 0 y acaba en ese número. Opcionalmente, también puedes indicarle cuántos pasos debe dejar intermedios.\n",
    "\n",
    "Observa cómo en este último ejemplo ambas líneas tenían la misma indentación y fueron éstas las que se ejecutaron mientras la variable i tomaba los valores especificados con range, a saber 0, 1, 2, 3 y 4.\n",
    "\n",
    "La función while es muy similar, y la diferencia radica en que el cuerpo del while se ejecuta mientras la condición lógica especificada se siga cumpliendo. La sintaxis es como sigue:\n",
    "\n",
    "while condicion:\n",
    "     cuerpo del while"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = 5\n",
    "while x < 5:\n",
    "    print str(x) + \" es menor \" + str(valor)\n",
    "    x += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observa cómo se ejecutaron las dos líneas en el cuerpo del while hasta que la condición dejó de cumplirse. En la segunda línea del cuerpo puedes notar que hay una instrucción atípica que es \n",
    "\n",
    "$$x += 1 $$\n",
    "\n",
    "Lo que en Python significa que la variable x va a aumentar en 1 su valor. Esta instrucción tiene la misma función que en Java o en C tiene la instrucción $\\mathcal{x++}$ con la diferencia de que en Python, en vez de poner 1, puedes poner el valor que desees.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imports\n",
    "\n",
    "En Python, como en cualquier otro lenguaje, existen funciones preprogramadas o módulos que se qiueran incorporar al código, lo cual se logra con la palabra reservada import. Por ejemplo\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import math "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "incorpora todo un conjunto de funciones que puede intuirse que son de naturaleza matemática, y a las cuales vas a acceder a través del operador “.” (punto), por ejemplo, la función $\\mathtt{sqrt}$, que calcula la raíz cuadrada, pertenece a este módulo; entonces, para invocar a la raíz cuadrada, lo que tienes que hacer es lo siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sqrt(25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otras formas equivalentes de importar las funciones de un módulo son:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math as m\n",
    "m.sqrt(25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo que hace que tengas un alias para el módulo math llamado m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.2246467991473532e-16"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import sin\n",
    "sin(m.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo que hace que importes la pura función sin, que dependa del módulo math. Aunque esta particular forma de importar funciones no es la mejor práctica de programación, ya que puede suceder que tengas redundancia de funciones en el mismo ámbito de programación.\n",
    "Con esto tienes una introducción muy básica pero bastante robusta para entender cualquier programa en Python. \n",
    "\n",
    "## Para saber más\n",
    "\n",
    "- http://en.wikibooks.org/wiki/Python_Programming/Sequences \n",
    "- http://docs.python.org/2/tutorial/datastructures.html\n",
    "- http://docs.python.org/2/library/stdtypes.html\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}