Python.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1- Tipos de datos\n",
    "# 2 - LISTAS: son listas mutables definidas entre corchetes\n",
    "# 3 - TUPLAS: listas NO mutables, definidas entre parentesis\n",
    "# 4 - DICCIONARIOS: definidos entre llaves {} separa elementos con :\n",
    "# 5 - STRINGS, CADENAS\n",
    "# 6 - TIPS Jupyter\n",
    "# 7 - OPERADORES LOGICOS\n",
    "# 8 - IF\n",
    "# 9 - TRY EXCEPT\n",
    "# 10 - ADVANCED LOGIC\n",
    "# 11 - INPUT\n",
    "# 12 - FOR LOOPS\n",
    "# 13 - WHILE LOOPS\n",
    "# 14 - CONTINUE, BREAK, PASS\n",
    "# 15 - PROBLEMA ROMBO\n",
    "# 16 - PROBLEMA ADIVINA EL NUMERO\n",
    "# 17 - FUNCIONES\n",
    "# 18 - *args y **kwargs\n",
    "# 19 - CLASES (objetos que almacenan funciones y atributos)\n",
    "# 20 - PROBLEMA trabajar con una cadena de texto\n",
    "# 21 - PROBLEMA procesar un .csv\n",
    "# 22 - PROBLEMA adivinar numero\n",
    "# 23 - instalar módulos\n",
    "# 24 - Cargar imagen\n",
    "# 25 - Manejo de ficheros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1- Tipos de datos\n",
    "anInteger = 3\n",
    "anInteger/3\n",
    "if type(anInteger) == \"int\":\n",
    "    print(\"OK!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aBoolean = True\n",
    "type(aBoolean)\n",
    "3 > 1 #True\n",
    "1 > 2 #False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[45, 4, 3]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 2 - LISTAS: son listas mutables definidas entre corchetes\n",
    "\n",
    "lista = []\n",
    "lista #devolvera []\n",
    "\n",
    "lista.append(23) #lo añaderá al final\n",
    "lista #devolvera [23]\n",
    "\n",
    "lista += [\"the\", 32]\n",
    "lista #devolvera [23, 'the', 32]\n",
    "\n",
    "len(lista) #devolvera 3\n",
    "\n",
    "lista = [3,-2,45,99,4]\n",
    "lista[0] #devolvera 3\n",
    "\n",
    "lista[:] #devolvera toda la lista: [3, -2, 45, 99, 4]\n",
    "\n",
    "lista[2:] #devolvera desde la posición 2: [45, 99, 4]\n",
    "\n",
    "lista[2:4] #devolvera desde la posición 2 a la 4: [45, 99]\n",
    "\n",
    "lista.index(-2) #busca la posición dentro de la lista: 1\n",
    "\n",
    "lista.remove(-2) #eliminar esa valor de la lista\n",
    "#otro metodo de eliminar\n",
    "eliminado = lista.pop(-2) #elimina el penultimo elemento\n",
    "eliminado #devolverá 99\n",
    "lista #devolverá [3, 45, 4]\n",
    "\n",
    "sorted (lista) #ordenará siempre y cuando sea todo int, o texto\n",
    "sorted (lista, reverse=True) #ordenar al revés"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 2, 'hola', ['Adios'], 'hola')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 3 - TUPLAS: listas NO mutables, definidas entre parentesis\n",
    "\n",
    "tupla =(3,2,\"hola\", [], \"hola\")\n",
    "tupla.count(\"hola\") #devolverá 2\n",
    "\n",
    "#tupla += 1 #devolverá error, no se puede modificar una tupla\n",
    "\n",
    "tupla[3].append(\"Adios\") #esto si es permitido porque el elemento de posicion 3 de la tupla es una lista\n",
    "tupla #devolverá (3, 2, 'hola', ['Adios'], 'hola')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'llave': '25'}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 4 - DICCIONARIOS: definidos entre llaves {} separa elementos con :\n",
    "\n",
    "dicc = {\"nombre\":\"Sergio\", \"llave\":\"25\"}\n",
    "dicc[\"llave\"] #devuelve 25\n",
    "\n",
    "#dicc[\"NOMBRE\"] #devuelve error, es casesensitive\n",
    "\n",
    "dicc.keys() #devuelve todas las llaves: dict_keys(['nombre', 'llave'])\n",
    "dicc.values() #devuelve todos los valores: dict_values(['Sergio', '25'])\n",
    "\n",
    "len(dicc) #devuelve 2\n",
    "\n",
    "del dicc[\"nombre\"]\n",
    "dicc #devuelve {'llave': '25'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 5 - STRINGS, CADENAS\n",
    "\n",
    "cadena = \"Test \\t \\n \\\" \"\n",
    "cadena #devuelve 'Test \\t \\n \" '\n",
    "#print(cadena) #devuelve Test tabula, salto de carro y \"\n",
    "\n",
    "cadena = \"mi variable string %s\" % (\"CADENA\")\n",
    "cadena #devuelve 'mi variable string CADENA'\n",
    "\n",
    "cadena = \"mi variable float %f\" % (3)\n",
    "cadena #devuelve 'mi variable float 3.000000'\n",
    "\n",
    "cadena = \"mi texto\"\n",
    "cadena[4] #'e'\n",
    "cadena[1:3] #'i '\n",
    "\n",
    "#cadena.capitalize() #'Mi texto'\n",
    "#cadena.upper() #'MI TEXTO'\n",
    "\n",
    "cadena.replace(\"texto\", \"XXX\") #buscara texto y lo remplazará por XXX\n",
    "cadena\n",
    "\n",
    "cadena.split(\" \") #transforma una cadena en lista con el patron usado de parametro en este caso un espacio\n",
    "cadena #devolvera [\"mi\", \"texto\"]\n",
    "\n",
    "cadena.index(\"texto\") #devuelve la posición dentro de la lista en este caso 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 6 - TIPS Jupyter\n",
    "\n",
    "# var = \"cadena\"\n",
    "# ?var.strip #devuelve la ayuda de esa funcion\n",
    "\n",
    "# Ctrl + Enter para ejecutar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 7 - OPERADORES LOGICOS\n",
    "\n",
    "x = 50\n",
    "x == 49 #False\n",
    "x !=49 #True\n",
    "\n",
    "x = \"22\"\n",
    "int(x) == 22 #Convertivo x a int y la comparacion es valida"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x es 6\n"
     ]
    }
   ],
   "source": [
    "# 8 - IF\n",
    "\n",
    "x=6\n",
    "if x > 20:\n",
    "    print(\"OK\")\n",
    "elif x / 3 == 2:\n",
    "    print(\"x es 6\")\n",
    "elif type(x) == str:\n",
    "    print(\"x es una cadena\")\n",
    "else:\n",
    "    print(\"NOT OK\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "excepcion: division by zero\n",
      "lo hizo\n",
      "termine\n"
     ]
    }
   ],
   "source": [
    "# 9 - TRY EXCEPT\n",
    "\n",
    "#ejemplo1\n",
    "try:\n",
    "    3/0\n",
    "    print(\"lo hizo\")\n",
    "except Exception as ex:\n",
    "    print(\"excepcion: %s\" % ex)\n",
    "    \n",
    "\n",
    "#ejemplo2\n",
    "lista = [1,2,3,4]\n",
    "a = \"XXX\"\n",
    "try:\n",
    "    if (5 not in lista) and (a ==\"XXX\"):\n",
    "        3*0\n",
    "        print(\"lo hizo\")\n",
    "except ZeroDivisionError as ex:\n",
    "    print(\"Error: %s\" % ex)\n",
    "except ArithmeticError as ex:\n",
    "    print(\"Error: %s\" % ex)\n",
    "finally:\n",
    "    print(\"termine\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cumple una condicion\n"
     ]
    }
   ],
   "source": [
    "# 10 - ADVANCED LOGIC\n",
    "\n",
    "x = [\"Casa\", 3, 22]\n",
    "y= 12\n",
    "z = \"Coche\"\n",
    "\n",
    "if (2 in x) or (y > x[1]):\n",
    "    print(\"cumple una condicion\")\n",
    "else:\n",
    "    print(\"NO las cumple\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dame un numero: 15\n",
      "es un numero impar y menor a 20\n"
     ]
    }
   ],
   "source": [
    "# 11 - INPUT\n",
    "\n",
    "x = input(\"dame un numero: \")\n",
    "\n",
    "try:\n",
    "    x = int(x) #le convertimos a entero\n",
    "\n",
    "    if x > 20:\n",
    "        print(\"es mayor de 20\")\n",
    "\n",
    "    elif x % 2 == 1:\n",
    "        print(\"es un numero impar y menor a 20\")\n",
    "\n",
    "    else:\n",
    "        print (\"Ni par ni mayor a 20, era: \" + x)\n",
    "    \n",
    "except:\n",
    "    print(\"no me diste un numero\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "13\n",
      "25\n",
      "41\n",
      "78\n",
      "h\n",
      "o\n",
      "l\n",
      "a\n",
      "78\n",
      "41\n",
      "25\n",
      "13\n",
      "4\n",
      "nombre Sergio <class 'str'>\n",
      "edad 41 <class 'int'>\n",
      "perfil {} <class 'dict'>\n",
      "2\n",
      "13\n",
      "19\n",
      "hora1 2\n",
      "hora2 13\n",
      "hora3 19\n"
     ]
    }
   ],
   "source": [
    "# 12 - FOR LOOPS\n",
    "\n",
    "#ejemplo1\n",
    "lista = [4,13,25,41,78]\n",
    "for i in lista:\n",
    "    print(i)\n",
    "    \n",
    "#ejemplo2\n",
    "cadena =\"hola\"\n",
    "for c in cadena:\n",
    "    print(c)\n",
    "\n",
    "#ejemplo3\n",
    "for orden_inv in sorted(lista, reverse=True): #ordenar una lista\n",
    "    print(orden_inv)\n",
    "\n",
    "#ejemplo4\n",
    "dicc = {\"nombre\":\"Sergio\", \"edad\":41, \"perfil\":{}}\n",
    "for a in dicc:\n",
    "    print(a, dicc[a], type(dicc[a]))\n",
    "\n",
    "#ejemplo5\n",
    "dicc2 = {\"hora1\": 2, \"hora2\": 13, \"hora3\": 19}\n",
    "for valor in dicc2.values():\n",
    "    print(valor) #devuelve 2 13 19\n",
    "\n",
    "#ejemplo6\n",
    "for clave, valor in dicc2.items():\n",
    "    print(clave, valor) #devuelve hora1 2 hora2 13 hora3 19"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "looping\n",
      "looping\n",
      "looping\n",
      "looping\n",
      "looping\n",
      "looping\n",
      "looping\n",
      "looping\n",
      "looping\n",
      "looping\n",
      "loop 1\n"
     ]
    }
   ],
   "source": [
    "# 13 - WHILE LOOPS\n",
    "\n",
    "#ejemplo1\n",
    "i = 0\n",
    "while i < 10:\n",
    "    print(\"looping\")\n",
    "    i += 1\n",
    "\n",
    "#ejemplo2\n",
    "i = 1\n",
    "while (i<10) and (i%2==1):\n",
    "    print(\"loop\",i)\n",
    "    i+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1\n",
      "1 3\n",
      "2 5\n",
      "3 7\n",
      "4 9\n",
      "5 12\n",
      "6 23\n",
      "1 9\n",
      "3 8\n",
      "5 7\n",
      "7 6\n",
      "1\n",
      "3\n",
      "Soy yo\n",
      "41\n"
     ]
    }
   ],
   "source": [
    "# 14 - CONTINUE, BREAK, PASS\n",
    "\n",
    "#ejemplo1\n",
    "lista1 = [1,3,5,7,9,12,23]\n",
    "for index, data in enumerate(lista1): #funcion enumerate\n",
    "    print(index, data)\n",
    "\n",
    "lista2 = [9,8,7,6]\n",
    "for d1, d2 in zip(lista1, lista2): #funcion zip\n",
    "    print(d1,d2)\n",
    "    \n",
    "\n",
    "for i in lista1[:2]: #imprime los dos primeros elementos de lista1\n",
    "    print(i)\n",
    "    \n",
    "\n",
    "#ejemplo2\n",
    "dicc ={\"nombre\":\"sergio\", \"edad\":\"41\"}\n",
    "for valor in dicc.values():\n",
    "    if valor == \"sergio\":\n",
    "        print(\"Soy yo\")\n",
    "        continue #probar con break y pass para ver que hace\n",
    "#         break\n",
    "#         pass\n",
    "    print(valor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "$\n",
      "$$\n",
      "$$$\n",
      "$$$$\n",
      "$$$$$\n",
      "$$$$\n",
      "$$$\n",
      "$$\n",
      "$\n"
     ]
    }
   ],
   "source": [
    "# 15 - PROBLEMA ROMBO\n",
    "\n",
    "ancho = 5\n",
    "for i in range(ancho):\n",
    "    #print(\"i=\",i)\n",
    "    print(''*(ancho-i-1)+'$'*(i+1))\n",
    "for j in range(ancho-1,0,-1):\n",
    "    #print(\"j=\",j)\n",
    "    print(''*(ancho-j)+'$'*(j))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dime un numero 4\n",
      "dime un numero 5\n",
      "dime un numero 6\n",
      "dime un numero 7\n",
      "dime un numero 8\n",
      "dime un numero 9\n",
      "dime un numero 1\n",
      "dime un numero 2\n",
      "dime un numero 3\n",
      "dime un numero 10\n",
      "Has encontrado el numero en el intento: 10\n"
     ]
    }
   ],
   "source": [
    "# 16 - PROBLEMA ADIVINA EL NUMERO\n",
    "\n",
    "import random\n",
    "numero = random.randint(1,10) #elegimos un aleatorio de 1 a 10\n",
    "respuesta = 0\n",
    "intento = 0\n",
    "while(respuesta != numero):\n",
    "        respuesta = int(input(\"dime un numero \"))\n",
    "        intento+=1\n",
    "        if (respuesta == numero):\n",
    "            print(\"Has encontrado el numero en el intento: %s\" % intento)\n",
    "            break\n",
    "        continue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "es entero o float\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 17 - FUNCIONES\n",
    "\n",
    "#ejemplo1\n",
    "def funcion1(param1):\n",
    "    if type(param1) in [int, float]:\n",
    "        print(\"es entero o float\")\n",
    "        \n",
    "x = funcion1(\"a\")\n",
    "y = funcion1(4.0)\n",
    "\n",
    "#ejemplo2 - funcion con dos parametros y con return\n",
    "def suma(x,y):\n",
    "    return x+y\n",
    "\n",
    "suma(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'str'>\n",
      "<class 'float'>\n",
      "<class 'float'>\n",
      "{'x': 1, 'y': 3, 'z': 7}\n",
      "{'x': 2, 'y': 3, 'z': 4}\n",
      "(2, 'coche', -4) {'x': 3, 'y': 4, 'z': 5}\n"
     ]
    }
   ],
   "source": [
    "# 18 - *args y **kwargs\n",
    "\n",
    "#ejemplo1 con *args, aceptará un numero indefinido de parametros y crea una lista con ellos\n",
    "def funcion1(*args):\n",
    "    for arg in args:\n",
    "        print(type(arg))\n",
    "\n",
    "funcion1(1,\"casa\",4.0)\n",
    "\n",
    "#ejemplo2 *args y un parametro de inicio\n",
    "def funcion2(param1, param2, *args): #que se salte los dos primeros parametros\n",
    "    for arg in args:\n",
    "        print(type(arg)) #devolverá <class 'float'>\n",
    "\n",
    "funcion2(1,\"casa\",4.0)\n",
    "\n",
    "#ejemplo3 con **kwargs, aceptará un numero indefinido de parametros y crea un diccionario con ellos\n",
    "def funcion3(**kwargs):\n",
    "    print(kwargs) #devuelve {'x': 1, 'y': 3, 'z': 7}\n",
    "\n",
    "funcion3(x=1, y=3, z=7)\n",
    "\n",
    "#ejemplo4 con **kwargs, que se salte los dos primeros parametros\n",
    "def funcion4(p1,p2,**kwargs):\n",
    "    print(kwargs) #devuelve {'x': 2, 'y': 3, 'z': 4}\n",
    "\n",
    "funcion4(1, \"casa\", x=2, y=3, z=4)\n",
    "\n",
    "#ejemplo5 *args y **kwargs juntos\n",
    "def funcion5(*args,**kwargs):\n",
    "    print(args,kwargs) #devuelve una lista y un diccionario (2, 'coche', -4) {'x': 3, 'y': 4, 'z': 5}\n",
    "\n",
    "funcion5(2, \"coche\", -4, x=3, y=4, z=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "es entero, le sumo 10\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "69"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 19 - CLASES (objetos que almacenan funciones y atributos)\n",
    "\n",
    "#ejemplo1\n",
    "class clase1():\n",
    "    test = 69\n",
    "    def add10(self, p1): #https://pythontips.com/2013/08/07/the-self-variable-in-python-explained/\n",
    "        #p1 será una variable local a la función\n",
    "        self.p1 = p1\n",
    "        if type(self.p1) != int:\n",
    "            print(\"no es entero\")\n",
    "        else:\n",
    "            print(\"es entero, le sumo 10\")\n",
    "            return p1 + 10\n",
    "\n",
    "a = clase1()\n",
    "a.add10(3) #devolvera 13\n",
    "#a.add10() #devolvera error porque falta el parametro\n",
    "a.test #devolvera 69\n",
    "\n",
    "#ejemplo2 cargar clases desde archivos\n",
    "# from nombre_fichero import clase2 #habra un fichero llamado nombre_fichero.py en el mismo directorio q este archivo de Jupyter\n",
    "# nombre_fichero.funcion()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['en', 'un', 'de', 'la', 'de', 'cuyo', 'nombre', 'no', 'quiero', 'acordarme']"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 20 - PROBLEMA trabajar con una cadena de texto\n",
    "\n",
    "texto = \"en un lugar de la mancha de cuyo nombre no quiero acordarme\"\n",
    "\n",
    "class parseador_lenguaje(object):\n",
    "    def contar_palabras(self, document, **kwargs):\n",
    "        self.document = document\n",
    "        listaPalabras = {}\n",
    "        if kwargs[\"raw\"] == True:\n",
    "            palabrasSplit = document.split(\" \") #lo separams en palabras\n",
    "        for palabra in palabrasSplit:\n",
    "            if palabra not in listaPalabras:\n",
    "                listaPalabras[palabra] = 0\n",
    "            listaPalabras[palabra] +=1\n",
    "            \n",
    "        return listaPalabras\n",
    "    \n",
    "    def contar_letras_diferentes(self, document, raw):\n",
    "        self.document = document\n",
    "        self.raw = raw\n",
    "        diccLetras = {}\n",
    "        if (type(self.raw) == bool) and (self.raw is not True):\n",
    "            self.document = \" \".join(self.document)\n",
    "        elif type(self.raw) != bool:\n",
    "            raise TypeError(\"Debe ser verdadero o falso\")\n",
    "        else:\n",
    "            pass\n",
    "        \n",
    "        document = document.replace(\" \",\"\").lower()\n",
    "        for caracter in document:\n",
    "            if caracter not in diccLetras:\n",
    "                diccLetras[caracter] = 0\n",
    "            diccLetras[caracter] +=1\n",
    "            \n",
    "        return diccLetras\n",
    "    \n",
    "    def eliminar_palabra(self, texto, *args):\n",
    "        stopWords = args\n",
    "        if type(texto) != list:\n",
    "            texto = texto.split(\" \")\n",
    "        removedWords = [word for word in texto if word.lower() not in stopWords]\n",
    "        \n",
    "        return removedWords\n",
    "\n",
    "a = parseador_lenguaje()\n",
    "\n",
    "#dejar descomentada una de estas 3 líneas para ejecutar una de las funciones\n",
    "#a.contar_palabras(texto, raw=True)\n",
    "#a.contar_letras_diferentes(texto, True)\n",
    "a.eliminar_palabra(texto, \"lugar\", \"mancha\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "He leido 15280 lineas.\n",
      "Lista de personajes vivos:  {'Peter Parker': ['Spider-Man'], 'Steven Rogers': ['Captain America'], 'Serval': ['Teddy']}\n",
      "\n",
      "\n",
      "Apariciones de cada personaje:  {'Peter Parker': 4043, 'Steven Rogers': 3360, 'Serval': 1}\n"
     ]
    }
   ],
   "source": [
    "# 21 - PROBLEMA procesar un .csv\n",
    "\n",
    "#columnas del archivo .csv\n",
    "# page_id\n",
    "# name\n",
    "# urlslug\n",
    "# ID\n",
    "# ALIGN\n",
    "# EYE\n",
    "# HAIR\n",
    "# SEX\n",
    "# GSM\n",
    "# ALIVE\n",
    "# APPEARANCES\n",
    "# FIRST APPEARANCE\n",
    "# Year\n",
    "\n",
    "import csv\n",
    "totalApariciones = {}\n",
    "vivosDict = {}\n",
    "\n",
    "with open('marvel-wikia-data.csv') as csv_file:\n",
    "    reader = csv.reader(csv_file, delimiter=',')\n",
    "    contador_lineas = 0\n",
    "    for row in reader: #recorremos las rows\n",
    "        nombre = row[1].split(\"(\")[0].rstrip() #los nombres son Spider-Man (Peter Parker), asi quitamos lo que haya tras encontrar un parentesis\n",
    "        vivoomuerto = row[9]\n",
    "        mundo = row[1][row[1].find(\"(\")+1:row[1].find(\")\")]\n",
    "        try:\n",
    "            aparecido = int(row[10])\n",
    "        except:\n",
    "            continue\n",
    "        if vivoomuerto == \"Living Characters\":\n",
    "            if mundo not in vivosDict:\n",
    "                vivosDict[mundo] = []\n",
    "            if mundo not in totalApariciones:\n",
    "                totalApariciones[mundo] = 0\n",
    "                \n",
    "            vivosDict[mundo].append(nombre)\n",
    "            totalApariciones[mundo] += int(aparecido) \n",
    "            \n",
    "        contador_lineas +=1\n",
    "        \n",
    "print(f'He leido {contador_lineas} lineas.')\n",
    "print(\"Lista de personajes vivos: \",vivosDict)\n",
    "print(\"\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\")\n",
    "print(\"Apariciones de cada personaje: \",totalApariciones)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cuantos juegos quieres 1\n",
      "Comineza el juego número 1\n",
      "dime un numero 1\n",
      "Has encontrado el numero en el intento: 1\n"
     ]
    }
   ],
   "source": [
    "# 22 - PROBLEMA adivinar numero\n",
    "\n",
    "import random\n",
    "\n",
    "cuantos_juegos = int(input(\"Cuantos juegos quieres \"))\n",
    "i=0\n",
    "\n",
    "for i in range(cuantos_juegos):\n",
    "    print(\"Comineza el juego número\",i+1)\n",
    "    numero = random.randint(1,5)\n",
    "    respuesta = 0\n",
    "    intento = 0\n",
    "    while(respuesta != numero):\n",
    "            respuesta = int(input(\"dime un numero \"))\n",
    "            intento+=1\n",
    "            if(respuesta > numero):\n",
    "                print(\"muy alto\")\n",
    "            elif(respuesta < numero):\n",
    "                print(\"muy bajo\")\n",
    "            elif (respuesta == numero):\n",
    "                print(\"Has encontrado el numero en el intento: %s\" % intento)\n",
    "            continue\n",
    "    i+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 23 - instalar módulos\n",
    "\n",
    "import sys\n",
    "!{sys.executable} -m pip install -U selenium"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 24 - Cargar imagen\n",
    "\n",
    "from IPython.display import Image\n",
    "Image(\"imagen.JPG\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 25 - Manejo de ficheros\n",
    "\n",
    "### Escribir en fichero\n",
    "archivo = open(\"archivo.txt\",\"w\") #w de modo escritura\n",
    "nombre = raw_input(\"Nombre: \")\n",
    "edad= raw_input(\"Edad: \")\n",
    "\n",
    "archivo.write(nombre)\n",
    "archivo.write(\"\\n\")\n",
    "archivo.write(edad)\n",
    "\n",
    "archivo.close()\n",
    "\n",
    "### Leer de fichero\n",
    "archivo = open(\"wordlist.lst\", \"r\") #r de lectura\n",
    "\n",
    "for linea in archivo.read().split('\\n'):\n",
    "    print (linea)\n",
    "\n",
    "lista = archivo.read().split('\\n')\n",
    "print(len(lista)) #número de líneas del archivo\n",
    "\n",
    "\n",
    "### Añadir datos a fichero"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}