Álvaro López - Ejercicios Bloque 1 - Tipos de datos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Tipos de datos **\n",
    "\n",
    "Definir una función que devuelva los números pares de una lista que se pasa\n",
    "como parámetro. Implementar dos versiones, una que utilice list\n",
    "comprehensions y otra no."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8]\n",
      "[2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "def pares_lc( lista ):\n",
    "    return [x for x in lista if x % 2 == 0]\n",
    "\n",
    "def pares_normal( listaIn ):\n",
    "    listaOut = []\n",
    "    for x in listaIn:\n",
    "        if x % 2 == 0:\n",
    "            listaOut.append(x)\n",
    "    return listaOut\n",
    "\n",
    "L = [1,2,3,4,5,6,7,8]\n",
    "print(pares_lc(L))\n",
    "print(pares_normal(L))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definir una función que nos indique si dos números reales son\n",
    "aproximadamente iguales, con un parámetro opcional que indica la precisión\n",
    "que queremos en la comparación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def aproximados (n1, n2, pr):\n",
    "    return abs(n1-n2) <= pr\n",
    "\n",
    "print(aproximados(1, 1.1, 0.05))\n",
    "print(aproximados(1, 1.02, 0.03))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Utilizando reduce, definir una función que calcule el máximo elemento de\n",
    "una lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Para disponer del reduce\n",
    "from functools import reduce\n",
    "\n",
    "maxnum = lambda x,y: x if (x > y) else y\n",
    "L2 = [3,5,7,1,22,5,9,0,4,10]\n",
    "reduce(maxnum, L2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Investigar la función decode y definir una función que dada una cadena\n",
    "sustituya con el carácter “#” las ocurrencias de caracteres que no son ASCII."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'En el r#o Mi#o ha ca#do un cami#n.'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "#Trata cadenas codificadas en UTF-8 por defecto\n",
    "def replaceNoAscii(cadena, encoding = 'utf-8'):\n",
    "    for i in range(0, len(cadena)):\n",
    "            try:\n",
    "                bi = cadena[i].encode(encoding)\n",
    "                bi.decode('ascii')\n",
    "            except:\n",
    "                  #El carácter no es ASCII. Hacer el reemplazo trabajando como una lista.\n",
    "                s = list(cadena)\n",
    "                s[i] = '#'\n",
    "                cadena = \"\".join(s)\n",
    "    return cadena\n",
    "\n",
    "#http://pythoncentral.io/encoding-and-decoding-strings-in-python-3-x/\n",
    "#all strings in Python 3.x are automatically Unicode.\n",
    "replaceNoAscii(\"En el río Miño ha caído un camión.\")\n",
    "\n",
    "#Referencias:\n",
    "#http://stackoverflow.com/questions/20078816/replace-non-ascii-characters-with-a-single-space\n",
    "#https://www.tutorialspoint.com/python/string_decode.htm\n",
    "#http://stackoverflow.com/questions/1228299/change-one-character-in-a-string-in-python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Utilizando **map y reduce** hacer un programa que tome una lista y le aplique\n",
    "de manera aleatoria una de entre varias funciones a cada uno de sus\n",
    "elementos, y que después aleatoriamente obtenga bien la media o la mediana\n",
    "de los elementos de la lista. Utilizad el módulo **statistics**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mapRnd 6 reduceRnd 9\n",
      "Map cuadrado\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n",
      "statistics.median: 30.5\n",
      "mapRnd 1 reduceRnd 9\n",
      "Map duplica\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]\n",
      "statistics.median: 11.0\n",
      "mapRnd 3 reduceRnd 0\n",
      "Map cuadrado\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n",
      "reduce mean: 38.5 vs. statistics.mean: 38.5\n",
      "mapRnd 3 reduceRnd 3\n",
      "Map cuadrado\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n",
      "reduce mean: 38.5 vs. statistics.mean: 38.5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "38.5"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Obtener números aleatorios\n",
    "from random import randrange\n",
    "from math import sqrt\n",
    "from functools import reduce\n",
    "from statistics import mean, median\n",
    "\n",
    "duplica = lambda x: x * 2\n",
    "cuadrado = lambda x: x ** 2\n",
    "\n",
    "def funcAleatoria(lista):\n",
    "    mapRnd = randrange(0, 10)\n",
    "    reduceRnd = randrange(0, 10)\n",
    "    \n",
    "    print(\"mapRnd \" + str(mapRnd) + \" reduceRnd \" + str(reduceRnd))\n",
    "    maplist = []\n",
    "    if mapRnd < 3:\n",
    "        print(\"Map duplica\")\n",
    "        maplist = list(map(duplica, lista))\n",
    "    elif mapRnd < 7:\n",
    "        print(\"Map cuadrado\")\n",
    "        maplist = list(map(cuadrado, lista))\n",
    "    else:\n",
    "        print(\"Map sqrt\")\n",
    "        maplist = list(map(sqrt, lista))\n",
    "    \n",
    "    print(lista)\n",
    "    print(maplist)\n",
    "    \n",
    "    reducelist = []\n",
    "    if reduceRnd < 5:\n",
    "        r = reduce(lambda x, y: x + y, maplist) / len(maplist)\n",
    "        reducelist = mean(maplist)\n",
    "        \n",
    "        print(\"reduce mean: \" + str(reducelist) + \" vs. statistics.mean: \" + str(r))\n",
    "    else:\n",
    "        reducelist = median(maplist)\n",
    "        print(\"statistics.median: \" + str(reducelist))\n",
    "    return reducelist\n",
    "\n",
    "l = [1,2,3,4,5,6,7,8,9,10]\n",
    "funcAleatoria(l)\n",
    "funcAleatoria(l)\n",
    "funcAleatoria(l)\n",
    "funcAleatoria(l)\n",
    "\n",
    "#Referencias:\n",
    "#http://stackoverflow.com/questions/3996904/generate-random-integers-between-0-and-9\n",
    "#http://stackoverflow.com/questions/1303347/getting-a-map-to-return-a-list-in-python-3-x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definir y probar una **expresión regular** para detectar algunos emoticonos en\n",
    "una cadena de caracteres."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Emojis\n",
      "Encontrado emoji: 😀\n",
      "Encontrado emoji: 😺\n",
      "Emoticonos v1\n",
      "Encontrado emoticono: :-/\n",
      "Encontrado emoticono: 8^P\n",
      "Encontrado emoticono: =-D\n",
      "Encontrado emoticono: :)\n",
      "Emoticonos v2\n",
      "Encontrado emoticono: =-D\n",
      "Encontrado emoticono: :)\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "#(1) Emojis\n",
    "emoji_regexp = u'[\\U00002600-\\U000026FF]|[\\U00002700-\\U000027BF]|[\\U0001f300-\\U0001f5fF]|[\\U0001f600-\\U0001f64F]|' \\\n",
    "               u'[\\U0001f680-\\U0001f6FF]'\n",
    "\n",
    "#(2) Emoticonos Alternativa 1: patrón de \"generic smiley\"\n",
    "eyes, noses, mouths = r\":;8BX=\", r\"-~'^\", r\")(/\\|DP\"\n",
    "pattern1 = \"[%s][%s]?[%s]\" % tuple(map(re.escape, [eyes, noses, mouths]))\n",
    "\n",
    "# Emoticonos Alternativa 2: disjunction of a list of smileys\n",
    "smileys = \"\"\":-) :) :o) :] :3 :c) :> =] 8) =) :} :^) \n",
    "             :D 8-D 8D x-D xD X-D XD =-D =D =-3 =3 B^D\"\"\".split()\n",
    "pattern2 = \"|\".join(map(re.escape, smileys))\n",
    "\n",
    "def detectaEmojis(cadena):\n",
    "    emojis = re.findall(emoji_regexp, cadena, re.UNICODE)\n",
    "    if len(emojis) > 0:\n",
    "        #Se podria incluso mostrar el nombre del emoji\n",
    "        for emoji in emojis: print(\"Encontrado emoji: \" + emoji)\n",
    "    else:\n",
    "        print(\"Cadena sin emojis\")\n",
    "\n",
    "def detectaEmoticonos(cadena, patron = pattern1):\n",
    "    emoticonos = re.findall(patron, cadena)\n",
    "    if len(emoticonos) > 0:\n",
    "        for emoticono in emoticonos: print(\"Encontrado emoticono: \" + emoticono)\n",
    "    else:\n",
    "        print(\"Cadena sin emoticonos\")       \n",
    "\n",
    "print(\"Emojis\")\n",
    "detectaEmojis(u\"Smiley emoticon rocks!\\U0001f600 I like you.\\U0001f63a\")\n",
    "print(\"Emoticonos v1\")\n",
    "detectaEmoticonos(\"bla bla bla :-/ more text 8^P and another smiley =-D even more text. Wow :) !!!\")\n",
    "print(\"Emoticonos v2\")\n",
    "detectaEmoticonos(\"bla bla bla :-/ more text 8^P and another smiley =-D even more text. Wow :) !!!\", pattern2)\n",
    "\n",
    "#Referencias:\n",
    "#Lista de emojis: http://www.unicode.org/emoji/charts-beta/full-emoji-list.html#1f912\n",
    "#http://stackoverflow.com/questions/19149186/how-to-find-and-count-emoticons-in-a-string-using-python\n",
    "#http://stackoverflow.com/questions/28290240/python-2-7-detect-emoji-from-text\n",
    "#http://stackoverflow.com/questions/33404752/removing-emojis-from-a-string-in-python\n",
    "#http://stackoverflow.com/questions/14571103/capturing-emoticons-using-regular-expression-in-python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "(**) Crear y probar una expresión regular que reconozca en una cadena de\n",
    "nucleótidos del conjunto {A, C, G, T} la repetición de tres nucleótidos seguidos.\n",
    "NOTA: Se debería comprobar que la cadena sigue la notación IUPAC:\n",
    "https://en.wikipedia.org/wiki/Nucleic_acid_notation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Detectada repetición triple de los nucleótidos\n",
      "['AAA', 'TTT', 'CCC']\n",
      "True\n",
      "Cadena de nucleótidos no válida!\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "def detectaRepeticionNucleotidos(cadena):\n",
    "    #Comprobar que la cadena sigue la notación (solamente hay esos caracteres)\n",
    "    reNucleotidos = re.compile('^[ACGT]+$')\n",
    "    if not reNucleotidos.match(cadena):\n",
    "        print('Cadena de nucleótidos no válida!')\n",
    "        return False\n",
    "    \n",
    "    #Una vez filtradas las cadenas invalidas, detectar si existe la triple repeticion de los nucleótidos\n",
    "    matcher = re.compile(r\"(\\w)\\1\\1\")\n",
    "    groups = [match.group() for match in matcher.finditer(cadena)]\n",
    "    \n",
    "    if len(groups) > 0:\n",
    "        print(\"Detectada repetición triple de los nucleótidos\")\n",
    "        print(groups)\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "\n",
    "print(detectaRepeticionNucleotidos(\"AATATAAAGTACTAGTTTACGTACCCGGTACGTACT\"))\n",
    "print(detectaRepeticionNucleotidos(\"TGASDasdadsdaEEHJ\"))\n",
    "\n",
    "#Referencias\n",
    "#http://stackoverflow.com/questions/1323364/in-python-how-to-check-if-a-string-only-contains-certain-characters\n",
    "#http://stackoverflow.com/questions/1023902/it-is-possible-to-match-a-character-repetition-with-regex-how\n",
    "#http://stackoverflow.com/questions/6306098/regexp-match-repeated-characters\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "(**) Modelar con listas y diccionarios Python la información que aparece en\n",
    "una línea de tweets.\n",
    "Si consideramos dos usuarios de Twitter que se re-tuitean\n",
    "o responden, ¿cómo podrían modelarse esas referencias cruzadas?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Modelado de un tweet (ej: tweepy)\n",
    "The key attributes are the following:\n",
    "\n",
    "- text: the text of the tweet itself\n",
    "- created_at: the date of creation\n",
    "- favorite_count, retweet_count: the number of favourites and retweets\n",
    "- favorited, retweeted: boolean stating whether the authenticated user (you) have favourited or retweeted this tweet\n",
    "- lang: acronym for the language (e.g. “en” for english)\n",
    "- id: the tweet identifier\n",
    "- place, coordinates, geo: geo-location information if available\n",
    "- user: the author’s full profile\n",
    "- entities: list of entities like URLs, @-mentions, hashtags and symbols\n",
    "- in_reply_to_user_id: user identifier if the tweet is a reply to a specific user\n",
    "- in_reply_to_status_id: status identifier id the tweet is a reply to a specific status\n",
    "\n",
    "La estructura disponible de un tweet dependerá de la librería utilizada, aunque debería concidir en su mayoría.\n",
    "Para modelar referencias cruzadas se podría hacer uso de un dict intermedio donde se almacenaran los retweets siguiendo\n",
    "el modelo (id -> in_reply_to_user_id)  o el ID del tweet original si estuviera disponible.\n",
    "\n",
    "Referencias:\n",
    "- https://dev.twitter.com/resources/twitter-libraries#python\n",
    "- https://marcobonzanini.com/2015/03/02/mining-twitter-data-with-python-part-1/\n",
    "- https://marcobonzanini.com/2015/03/09/mining-twitter-data-with-python-part-2/\n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda root]",
   "language": "python",
   "name": "conda-root-py"
  },
  "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": 1
}