nb00-python-basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python - Conceptos basicos  \n",
    "### Obteniendo ayuda en el interprete de python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module string:\n",
      "\n",
      "NAME\n",
      "    string - A collection of string constants.\n",
      "\n",
      "MODULE REFERENCE\n",
      "    https://docs.python.org/3.5/library/string.html\n",
      "    \n",
      "    The following documentation is automatically generated from the Python\n",
      "    source files.  It may be incomplete, incorrect or include features that\n",
      "    are considered implementation detail and may vary between Python\n",
      "    implementations.  When in doubt, consult the module reference at the\n",
      "    location listed above.\n",
      "\n",
      "DESCRIPTION\n",
      "    Public module variables:\n",
      "    \n",
      "    whitespace -- a string containing all ASCII whitespace\n",
      "    ascii_lowercase -- a string containing all ASCII lowercase letters\n",
      "    ascii_uppercase -- a string containing all ASCII uppercase letters\n",
      "    ascii_letters -- a string containing all ASCII letters\n",
      "    digits -- a string containing all ASCII decimal digits\n",
      "    hexdigits -- a string containing all ASCII hexadecimal digits\n",
      "    octdigits -- a string containing all ASCII octal digits\n",
      "    punctuation -- a string containing all ASCII punctuation characters\n",
      "    printable -- a string containing all ASCII characters considered printable\n",
      "\n",
      "CLASSES\n",
      "    builtins.object\n",
      "        Formatter\n",
      "        Template\n",
      "    \n",
      "    class Formatter(builtins.object)\n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  check_unused_args(self, used_args, args, kwargs)\n",
      "     |  \n",
      "     |  convert_field(self, value, conversion)\n",
      "     |  \n",
      "     |  format(*args, **kwargs)\n",
      "     |  \n",
      "     |  format_field(self, value, format_spec)\n",
      "     |  \n",
      "     |  get_field(self, field_name, args, kwargs)\n",
      "     |      # given a field_name, find the object it references.\n",
      "     |      #  field_name:   the field being looked up, e.g. \"0.name\"\n",
      "     |      #                 or \"lookup[3]\"\n",
      "     |      #  used_args:    a set of which args have been used\n",
      "     |      #  args, kwargs: as passed in to vformat\n",
      "     |  \n",
      "     |  get_value(self, key, args, kwargs)\n",
      "     |  \n",
      "     |  parse(self, format_string)\n",
      "     |      # returns an iterable that contains tuples of the form:\n",
      "     |      # (literal_text, field_name, format_spec, conversion)\n",
      "     |      # literal_text can be zero length\n",
      "     |      # field_name can be None, in which case there's no\n",
      "     |      #  object to format and output\n",
      "     |      # if field_name is not None, it is looked up, formatted\n",
      "     |      #  with format_spec and conversion and then used\n",
      "     |  \n",
      "     |  vformat(self, format_string, args, kwargs)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |      dictionary for instance variables (if defined)\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "    \n",
      "    class Template(builtins.object)\n",
      "     |  A string class for supporting $-substitutions.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __init__(self, template)\n",
      "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
      "     |  \n",
      "     |  safe_substitute(*args, **kws)\n",
      "     |  \n",
      "     |  substitute(*args, **kws)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |      dictionary for instance variables (if defined)\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  delimiter = '$'\n",
      "     |  \n",
      "     |  flags = 2\n",
      "     |  \n",
      "     |  idpattern = '[_a-z][_a-z0-9]*'\n",
      "     |  \n",
      "     |  pattern = re.compile('\\n    \\\\$(?:\\n      (?P<escaped>\\\\$)..._a-z][_a-...\n",
      "\n",
      "FUNCTIONS\n",
      "    capwords(s, sep=None)\n",
      "        capwords(s [,sep]) -> string\n",
      "        \n",
      "        Split the argument into words using split, capitalize each\n",
      "        word using capitalize, and join the capitalized words using\n",
      "        join.  If the optional second argument sep is absent or None,\n",
      "        runs of whitespace characters are replaced by a single space\n",
      "        and leading and trailing whitespace are removed, otherwise\n",
      "        sep is used to split and join the words.\n",
      "\n",
      "DATA\n",
      "    __all__ = ['ascii_letters', 'ascii_lowercase', 'ascii_uppercase', 'cap...\n",
      "    ascii_letters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'\n",
      "    ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'\n",
      "    ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'\n",
      "    digits = '0123456789'\n",
      "    hexdigits = '0123456789abcdefABCDEF'\n",
      "    octdigits = '01234567'\n",
      "    printable = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTU...\n",
      "    punctuation = '!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~'\n",
      "    whitespace = ' \\t\\n\\r\\x0b\\x0c'\n",
      "\n",
      "FILE\n",
      "    /home/hmedrano/anaconda3/lib/python3.5/string.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Comando help, muestra la documentacion de algun objeto.\n",
    "help(\"string\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__abs__',\n",
       " '__add__',\n",
       " '__and__',\n",
       " '__bool__',\n",
       " '__ceil__',\n",
       " '__class__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__divmod__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__float__',\n",
       " '__floor__',\n",
       " '__floordiv__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getnewargs__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__index__',\n",
       " '__init__',\n",
       " '__int__',\n",
       " '__invert__',\n",
       " '__le__',\n",
       " '__lshift__',\n",
       " '__lt__',\n",
       " '__mod__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__neg__',\n",
       " '__new__',\n",
       " '__or__',\n",
       " '__pos__',\n",
       " '__pow__',\n",
       " '__radd__',\n",
       " '__rand__',\n",
       " '__rdivmod__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rfloordiv__',\n",
       " '__rlshift__',\n",
       " '__rmod__',\n",
       " '__rmul__',\n",
       " '__ror__',\n",
       " '__round__',\n",
       " '__rpow__',\n",
       " '__rrshift__',\n",
       " '__rshift__',\n",
       " '__rsub__',\n",
       " '__rtruediv__',\n",
       " '__rxor__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__sub__',\n",
       " '__subclasshook__',\n",
       " '__truediv__',\n",
       " '__trunc__',\n",
       " '__xor__',\n",
       " 'bit_length',\n",
       " 'conjugate',\n",
       " 'denominator',\n",
       " 'from_bytes',\n",
       " 'imag',\n",
       " 'numerator',\n",
       " 'real',\n",
       " 'to_bytes']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Comando dir, muestra los atributos y metodos de un objeto.\n",
    "dir(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-8-f15e38c5ce05>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-8-f15e38c5ce05>\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    print len(__doc__)\u001b[0m\n\u001b[1;37m            ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sintaxis\n",
    "Python no cuenta con un caracter de terminacion de comando, caracteres y bloques son especificados por **\"identacion\"**.\n",
    "Idente para empezar un bloque y descienda para terminarlo. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mivar = 3 \n",
    "mivar += 2\n",
    "mivar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mivar -= 1\n",
    "mivar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola Mundo\n"
     ]
    }
   ],
   "source": [
    "micadena = \"Hola\"\n",
    "micadena += \" Mundo\"\n",
    "print (micadena)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hola mundo'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "micadena.capitalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 Hola Mundo\n"
     ]
    }
   ],
   "source": [
    "# Intercambia contenido de variables en una linea\n",
    "mivar, micadena = micadena, mivar\n",
    "print (mivar, micadena)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tipos de datos\n",
    "Las estruturas de datos disponibles en python son listas, tuples y diccionarios.\n",
    "\n",
    "**Las listas** es algo como arreglos unidimensionales (Aunque es posible tener listas de listas). <br>\n",
    "**Los diccionarios** son arreglos asociados (tambien llamados tablas hash).<br>\n",
    "**Los tuples** son arreglos unidimensionales inmutables (una vez que se definen no cambian sus valores)<br>\n",
    "\n",
    "Las listas de python pueden ser de cualquier tipo, se puede combinar enteros, cadenas, listas/tuples/diccionarios.\n",
    "El primer indice de un arreglo en python es 0, numeros negativos cuentan del final de la lista al inicio."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "listaejemplo = [1, [ \"otra\" ,  \"lista\"], (\"a\", \"tuple\")]\n",
    "milista = [\"elemento lista 1\", 2, 3.14]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'elemento lista 1'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "milista[0]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "listaejemplo = [1, [ \"otra\" ,  \"lista\"], (\"a\", \"tuple\")]\n",
    "milista = [\"elemento lista 1\", 2, 3.14]\n",
    "\n",
    "milista[0] = \"elemento lista 1 de nuevo\" # Modificamos el contenido del elemento 0\n",
    "milista[-1] = 3.21 # Aqui, nos referimos al ultimo elemento de la lista\n",
    "\n",
    "midict = { \"vector 1\" : \"Valor 1\", 2: 3, \"pi\": 3.1416 }\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys([2, 'pi', 'vector 1'])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__delitem__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__iadd__',\n",
       " '__imul__',\n",
       " '__init__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__reversed__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__setitem__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'append',\n",
       " 'clear',\n",
       " 'copy',\n",
       " 'count',\n",
       " 'extend',\n",
       " 'index',\n",
       " 'insert',\n",
       " 'pop',\n",
       " 'remove',\n",
       " 'reverse',\n",
       " 'sort']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Metodos en listas, permiten trabajar con ella como pila o cola de datos.\n",
    "dir(milista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rangos\n",
    "Como seleccionar secciones de una lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['elemento lista 1 de nuevo', 2, 3.21]\n"
     ]
    }
   ],
   "source": [
    "print ( milista[:] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['elemento lista 1 de nuevo', 2]\n"
     ]
    }
   ],
   "source": [
    "print ( milista[0:2] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['elemento lista 1 de nuevo', 3.21]\n"
     ]
    }
   ],
   "source": [
    "print ( milista[0:4:2] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cadenas\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saluda con formato: numero 2.91\n",
      "Esto sirve como prueba\n"
     ]
    }
   ],
   "source": [
    "micadena = \"Hola mundo\"\n",
    "\n",
    "micadena = \"\"\" Esta es una \n",
    "cadena con\n",
    "multiples lineas \"\"\" \n",
    "\n",
    "# Salidas formateadas\n",
    "\n",
    "print (\"Saluda con formato: %s %0.2f\" % (\"numero\",2.90773) )\n",
    "\n",
    "print (\"Esto %(verbo)s como %(sust)s\" % {\"sust\" : \"prueba\" , \"verbo\" : \"sirve\"}  )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sentencias de control de flujos\n",
    "Las sentencias para controlar flujos son: **`if`**, **`for`** y **`while`**, no existe el **`select case`**, en su lugar use **`if`**'s anidados.<br>\n",
    "Use **`for`** para recorrer los elementos de una lista. <br>\n",
    "Para obtener una lista de numeros, use **`range(<numero>)`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(1, 11)\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "listarangos = range(1,11)\n",
    "\n",
    "\n",
    "\n",
    "print ( listarangos )\n",
    "print ( len(listarangos) )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "par :  2\n",
      "divisible entre 3 :  3\n",
      "par :  4\n",
      "par :  6\n",
      "par :  8\n",
      "divisible entre 3 :  9\n",
      "par :  10\n",
      "terminanos\n"
     ]
    }
   ],
   "source": [
    "for numero in listarangos: \n",
    "     # Verificar si el numero impar\n",
    "     if (numero % 2 == 0): \n",
    "         print (\"par : \", numero)\n",
    "     elif (numero % 3 == 0):\n",
    "         print (\"divisible entre 3 : \" , numero)        \n",
    "     else:\n",
    "         pass\n",
    "\n",
    "print (\"terminanos\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ----\n",
    " *Python no cuenta con una funcion SELECT CASE, en su lugar se usan bloques que comienzan con `if` y siguen con sentencias `elif` para los otros casos*\n",
    " \n",
    " ---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#0: gato\n",
      "#1: perro\n",
      "#2: mono\n"
     ]
    }
   ],
   "source": [
    "animales = ['gato','perro','mono']\n",
    "\n",
    "#for idx,a in enumerate(animales):\n",
    "#   print (idx, a)     \n",
    "\n",
    "# Acceder al numero de indice dentro del cuerpo del ciclo, con la sentencia enumerate\n",
    "for idx,animal in enumerate(animales):\n",
    "    print (\"#%d: %s\" % (idx,animal))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "nums = [1,2,3,4,5,6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 4, 16]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cuadrado = []\n",
    "for x in nums:\n",
    "    if x % 2 == 0 :\n",
    "        cuadrado.append(x**2)\n",
    "cuadrado    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ciclos Inline , o \"list comprehensions\" \n",
    "cuadrado = [ x**2 for x in nums ]\n",
    "cuadrado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2d = [[1,2,3],[4,5,6]]\n",
    "arr2d.append([7,8,9])\n",
    "arr2d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 4, 9], [16, 25, 36], [49, 64, 81]]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c2 = [ [ x**2 for x in l ] for l in arr2d ]\n",
    "c2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 4, 16]\n"
     ]
    }
   ],
   "source": [
    "# ciclos inline con condicion , agregar a la lista solo los numeros pares\n",
    "nums = [0, 1, 2, 3, 4]\n",
    "\n",
    "cuadrados = [x ** 2 for x in nums if x % 2==0]\n",
    "\n",
    "\n",
    "print (cuadrados)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuenta  0\n",
      "cuenta  1\n",
      "cuenta  2\n",
      "cuenta  3\n",
      "cuenta  4\n",
      "cuenta  5\n",
      "cuenta  6\n",
      "cuenta  7\n",
      "cuenta  8\n"
     ]
    }
   ],
   "source": [
    "# Ciclos while\n",
    "cuenta = 0\n",
    "while (cuenta < 9):\n",
    "    print (\"cuenta \" , cuenta)\n",
    "    cuenta += 1 \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "Las sentencias **break y continue** pueden ser usados dentro de estos bloques.<br>\n",
    "`break` termina la ejecucion del ciclo.<br>\n",
    "`continue`, vuelve al inicio del ciclo para la siguiente iteracion.<br>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones\n",
    "Las funciones son declarados con la palabra clave **`def`** . Los argumentos opcionales pueden ser definidos, despues de los argumentos obligatorios.<br>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def funcs(x):\n",
    "    return x +1 \n",
    " \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "# Igual a: \n",
    "funcsimple = lambda x: x + 1 \n",
    "print (funcsimple(4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "([1, 2, 3, 'nuevo elemento'], 4, 'default string')\n",
      "[1, 2, 3, 'nuevo elemento']\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# un argumento entero y una cadena son opcionales, tienen valores default\n",
    "# en esta funcion.\n",
    "# Los argumentos se pasan por REFERENCIA, pero tipos de datos \n",
    "# inmutables no son modificados (tuples,ints,cadenas,etc)\n",
    "def argumentos_ej(a_list, an_int=2, a_string=\"default string\"):\n",
    "    a_list.append(\"nuevo elemento\")\n",
    "    an_int = 4\n",
    "    return a_list, an_int, a_string\n",
    "\n",
    "milista = [1,2,3]\n",
    "miint = 10\n",
    "print (argumentos_ej(milista,miint))\n",
    "\n",
    "# La lista es modificada por la funcion argumentos_ej\n",
    "print (milista)\n",
    "# Tipo de dato inmutable no es modificado por la funcion\n",
    "print (miint)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Excepciones\n",
    "Bloques que se encargan de capturar el flujo del programa cuando se encuentre un error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error capturado\n",
      "division by zero\n",
      "Terminamos con esto\n"
     ]
    }
   ],
   "source": [
    "def mifuncion():\n",
    "    try:\n",
    "        # La division entre cero causa un error\n",
    "        10 / 0\n",
    "    except Exception as e:        \n",
    "        print ('Error capturado')\n",
    "        print (e)\n",
    "    else:\n",
    "        # Aqui no sucedio ningun error, continuamos el flujo\n",
    "        print ('Sin error')\n",
    "        pass\n",
    "    finally:\n",
    "        # Estos se ejecuta despues del bloque try y despues que las\n",
    "        # excepciones se hayan manejado\n",
    "        print ('Terminamos con esto')\n",
    "\n",
    "mifuncion()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importando librerias\n",
    "Las librerias externas se cargan al entorno usando `import [nombrelibreria]`<br>\n",
    "Tambien se puede utilizar la notacion: `from [nombrelibreria] import [nombrefuncion(es)]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9142330493441689\n",
      "1.081118\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo\n",
    "import random\n",
    "from time import clock\n",
    "\n",
    "print (random.random())\n",
    "print (clock())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Salvando y leyendo archivos\n",
    "Para esto python cuenta con varias librerias ya incluidas. En el ejemplo siguiente salvamos estructuras de datos complejas de python en un archivo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Salvando en un archivo de texto\n",
    "miarchivo = open('texto.txt','w')\n",
    "\n",
    "lineas = []\n",
    "for linea in range(0,10):\n",
    "    lineas.append('Linea de texto numero ' + str(linea) + '\\n')\n",
    "    \n",
    "    \n",
    "    \n",
    "miarchivo.writelines(lineas)\n",
    "miarchivo.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linea de texto numero 0\r\n",
      "Linea de texto numero 1\r\n",
      "Linea de texto numero 2\r\n",
      "Linea de texto numero 3\r\n",
      "Linea de texto numero 4\r\n",
      "Linea de texto numero 5\r\n",
      "Linea de texto numero 6\r\n",
      "Linea de texto numero 7\r\n",
      "Linea de texto numero 8\r\n",
      "Linea de texto numero 9\r\n"
     ]
    }
   ],
   "source": [
    "%cat texto.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Linea de texto numero 0\\n',\n",
       " 'Linea de texto numero 1\\n',\n",
       " 'Linea de texto numero 2\\n',\n",
       " 'Linea de texto numero 3\\n',\n",
       " 'Linea de texto numero 4\\n',\n",
       " 'Linea de texto numero 5\\n',\n",
       " 'Linea de texto numero 6\\n',\n",
       " 'Linea de texto numero 7\\n',\n",
       " 'Linea de texto numero 8\\n',\n",
       " 'Linea de texto numero 9\\n']"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Recuperando el contenido del archivo de texto\n",
    "miarchivo = open('texto.txt','r')\n",
    "contenido = miarchivo.readlines()\n",
    "miarchivo.close()\n",
    "contenido"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Lista': [1, 2, 3, 4, 5], 'Nombre': 'Favio Medrano', 'tuple': (4, 5, 6)}"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Libreria pickle se encarga de serializar la estructura de datos\n",
    "import pickle\n",
    "\n",
    "midic = {'Lista' : [1,2,3,4,5] , 'Nombre' : 'Favio Medrano' , 'tuple' : (4,5,6)}\n",
    "midic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Salvamos la estructura en el archivo binario.dat\n",
    "miarchivo = open('binario.dat','wb')\n",
    "pickle.dump(midic, miarchivo)\n",
    "miarchivo.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "�\u0003}q\u0000(X\u0005\u0000\u0000\u0000Listaq\u0001]q\u0002(K\u0001K\u0002K\u0003K\u0004K\u0005eX\u0005\u0000\u0000\u0000tupleq\u0003K\u0004K\u0005K\u0006�q\u0004X\u0006\u0000\u0000\u0000Nombreq\u0005X\r",
      "\u0000\u0000\u0000Favio Medranoq\u0006u."
     ]
    }
   ],
   "source": [
    "%cat binario.dat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Lista': [1, 2, 3, 4, 5], 'Nombre': 'Favio Medrano', 'tuple': (4, 5, 6)}"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Recuperando la informacion\n",
    "miarchivo = open('binario.dat','rb')\n",
    "datos = pickle.load(miarchivo)\n",
    "miarchivo.close()\n",
    "\n",
    "datos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "**hmedrano@cicese.mx**"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [Root]",
   "language": "python",
   "name": "Python [Root]"
  },
  "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}