4. Manejo de Cadenas en Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Manejando textos en python\n",
    "\n",
    "Los textos representan una secuencia de cero o más caracteres. Un string es una estructura de datos inmutable. Esto significa que no puede ser cambiada.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ejemplo de cadena\n"
     ]
    }
   ],
   "source": [
    "str1 = 'ejemplo de cadena'\n",
    "print(str1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```id(str_var)``` obtiene el identificador único (la posición en memoria) de la variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1786354876256"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(str1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1786354986288"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = 'otra cosa'\n",
    "id(str1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para obtener la longitud de una cadena se puede utilizar la función len  ```len(str)```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "26"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 'May the Force be with you.'\n",
    "len(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = ''\n",
    "len(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## El operador subscript[]\n",
    "\n",
    "Accede los elementos de un string, lista, tupla y demás estructuras de datos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M\n",
      "Y\n"
     ]
    }
   ],
   "source": [
    "name = \"Minch Yoda\"\n",
    "print(name[0])\n",
    "print(name[6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "print(len(name))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "#name[10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'M'"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name[-10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dividiendo cadenas (slices)\n",
    "\n",
    "En muchos casos es necesario obtener porciones de una cadena. Se maneja la notación ```[start:end:step]```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Minch'"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name[0:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Minch'"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Yoda'"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name[6:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'adoY hcniM'"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Métodos interesantes con Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para contar los caracteres en una cadena dada se puede utilizar ```count(substr), count(substr, start, end)```:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = 'The avengers'\n",
    "str1.count('e')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible contar las ocurrencias de los elementos en una porción de la cadena:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1.count('e',0,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1.count('e',4,12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cad = 'abcabcabcabcabc'\n",
    "cad.count('abc')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En algunos casos se requiere encontrar primer el índice de una subcadena en la cadena dada. Para esto se puede usar el método ```find()```. La sintaxis de ```find``` es la siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = 'All we have to decide is what to do with the time that is given us.'\n",
    "str1.find('we', 0, len(str1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para encontrar el último indice ```rfind``` de una cadena se puede usar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first: 10\n",
      "last:  23\n"
     ]
    }
   ],
   "source": [
    "str2 = 'It is not despair, for despair is only for those who see the end beyond all doubt. We do not.'\n",
    "print('first:', str2.find('despair'))\n",
    "print('last: ', str2.rfind('despair'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Métodos basados en el case de una cadena "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arles\n",
      "arles\n"
     ]
    }
   ],
   "source": [
    "s = input() #lee una cadena\n",
    "print(s.lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lalala\n",
      "LALALA\n"
     ]
    }
   ],
   "source": [
    "s = input() #lee una cadena\n",
    "print(s.upper()) #muestra la cadena en mayúsculas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para poner en mayúsculas la primera letra de una cadena ```capitalize()```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Arles\n"
     ]
    }
   ],
   "source": [
    "name = 'arles'\n",
    "print(name.capitalize())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para convertir el primer caracter de cada palabra en la cadena se puede usar ```title()```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cien Años De Soledad\n",
      "cien años de soledad\n"
     ]
    }
   ],
   "source": [
    "str1 = 'cien años de soledad'\n",
    "title = str1.title() \n",
    "print(title)\n",
    "print(str1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para intercambiar mayúsculas por minúsculas en una cadena se puede usar ```swapcase()```:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cIEN aÑOS dE sOLEDAD'"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "title.swapcase()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## strip \n",
    "\n",
    "Cuando se está procesando un texto, a veces se encuentran caracteres al principio o al finalizar una cadena. Por ejemplo ```\" ciudad de Bogotá \"``` y ```\" ICPC competition col\"``` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ciudad de Bogotá'"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = \" ciudad de Bogotá \"\n",
    "str1.strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' ciudad de Bogotá'"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = \" ciudad de Bogotá \"\n",
    "str1.rstrip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' ICPC competition '"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = \" ICPC competition col\"\n",
    "str1.rstrip(\"col\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String split methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A veces se tienen strings definidas por partes como \"05-06-2020\" y \"Arles Rodríguez\" y se desea procesar u obtener una de las partes de la cadena. ```str1.split(\"delimiter\", num)```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "año: 2020\n"
     ]
    }
   ],
   "source": [
    "sdate = \"05-06-2020\"\n",
    "sp = sdate.split(\"-\")\n",
    "print('año: ' + sp[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['05', '06-2020']"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sdate = \"05-06-2020\"\n",
    "sdate.split(\"-\", 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 233\n",
      "num 1:3\n",
      "num 2:233\n",
      "3233\n"
     ]
    }
   ],
   "source": [
    "### Split\n",
    "\n",
    "cad = str(input())\n",
    "num1, num2 = cad.split(' ')\n",
    "print('num 1:' + num1)\n",
    "print('num 2:' + num2)\n",
    "print(num1 + num2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#en este código se pueden digitar dos números separados por &. Ejemplo 434354&23782375\n",
    "s = input()\n",
    "a,b = (int(x) for x in s.split(\"&\"))\n",
    "print(\"a=\" + str(a))\n",
    "print(\"b=\" + str(b))\n",
    "print(\"a+b=\" + str(a+b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para empezar de derecha a izquierda:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['05-06', '2020']"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sdate = \"05-06-2020\"\n",
    "sdate.rsplit(\"-\", 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Justificación de cadenas\n",
    "\n",
    "Existen cuatro métodos para justificar cadenas:\n",
    "\n",
    "- ```ljust()``` justificar una cadena a la izquierda\n",
    "- ```rjust()``` justificar una cadena a la derecha\n",
    "- ```center()``` centrar una cadena\n",
    "- ```zfill()``` llenar una cadena con ceros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bogotá#########'"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = 'Bogotá'\n",
    "str1.ljust(15, \"#\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'#########Bogotá'"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = 'Bogotá'\n",
    "str1.rjust(15, \"#\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'#####Bogotá####'"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = 'Bogotá'\n",
    "str1.center(15, \"#\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'000000123456789'"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "account = '123456789'\n",
    "account.zfill(15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0000000010101010'"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binary_num = '10101010'\n",
    "binary_num.zfill(16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reemplazar una palabra de una cadena por otra: ```replace(old_str, new_str)```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cien años de soledad\n",
      "70 años de soledad\n",
      "70 días de soledad\n",
      "70 días de clases sincrónicas!\n"
     ]
    }
   ],
   "source": [
    "str1 = 'cien años de soledad'\n",
    "print(str1)\n",
    "rep = str1.replace('cien','70')\n",
    "print(rep)\n",
    "rep = rep.replace('años','días')\n",
    "print(rep)\n",
    "rep = rep.replace('soledad','clases sincrónicas!')\n",
    "print(rep)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Crear una lista a partir de una palabra:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cien años de soledad'"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = ['cien', 'años', 'de', 'soledad']\n",
    "\" \".join(lista) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cienañosdesoledad'"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\".join(lista) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cien-años-de-soledad'"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"-\".join(lista) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Métodos booleanos sobre cadenas\n",
    "\n",
    "Utilizados para validar si una cadena dada cumple o no con una propiedad.\n",
    "\n",
    "- ```endswith```: saber si una cadena termina con\n",
    "- ```startswith```: saber si una cadena empieza con\n",
    "- ```isalpha```: saber si una cadena contiene letras únicamente\n",
    "- ```isalnum```: saber si una cadena contiene números y letras únicamente (alfanumérico)\n",
    "- ```isdigit```: saber si una cadena contiene sólo dígitos.\n",
    "- ```isspace```: saber si una cadena contiene sólo espacios.\n",
    "- ```istitle```: saber si una cadena es un título\n",
    "- ```islower```: saber si una cadena contiene todos sus caracteres en minúsculas\n",
    "- ```isupper```: saber si una cadena contiene todos sus caracteres en mayúsculas\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "text = \"Cien años de soledad.\"\n",
    "result = text.endswith('soledad.')\n",
    "# returns False\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "text = \"Cien años de soledad.\"\n",
    "result = text.startswith('años',5,len(text))\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = 'lasquinceletras'\n",
    "str1.isalpha()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str2 = 'las quince letras'\n",
    "str2.isalpha()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str3 = 'edad:15'\n",
    "str3.isalpha()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str4 = 'edad15'\n",
    "str4.isalnum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str5 = 'edad15#'\n",
    "str5.isalnum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str_num = '123456789'\n",
    "str_num.isdigit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "strs = \" \"\n",
    "strs.isspace()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "strs = 'Cien Años De Soledad'\n",
    "strs.istitle()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = 'pepe'\n",
    "str1.islower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = 'pepe#235252'\n",
    "str1.islower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str1 = 'PEPE MUNCK'\n",
    "str1.isupper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mínima ó máxima letra alfanumérica ```min```, ```max```:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min('abcdario')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'r'"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max('abcdario')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yes\n"
     ]
    }
   ],
   "source": [
    "## Saber si una palabra o letra está en una cadena\n",
    "\n",
    "text = 'cien años de soledad'\n",
    "\n",
    "if 'años' in text:\n",
    "    print('yes')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible iterar cada letra de la cadena"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h,o,l,a, ,a,m,i,g,o,s, ,q,u,e,r,i,d,o,s,"
     ]
    }
   ],
   "source": [
    "s = \"hola amigos queridos\"\n",
    "\n",
    "for c in s:  #se puede iterar cada letra de la cadena\n",
    "  print(c + \",\", end='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio 1: Extraer nombres de universidades Colombianas\n",
    "\n",
    "Dada una lista de Universidades Colombianas, obtener el nombre de sitios web. Se asume que un nombre de universidad está entre los caracteres www.  y edu.co. Por ejemplo de www.konradlorenz.edu.co se obtiene konradlorenz.\n",
    "\n",
    "*Entrada:*\n",
    "Un numero n indicando la cantidad de nombres de sitios web a procesar\n",
    "\n",
    "*Salida:*\n",
    "Listado de posibles nombres de universidades.\n",
    "\n",
    "*Ejemplo:*\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <td>\n",
    "        Input\n",
    "        </td>\n",
    "        <td>\n",
    "        Output\n",
    "        </td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>\n",
    "        3<br>\n",
    "        www.konradlorenz.edu.co<br>\n",
    "        www.unal.edu.co<br>\n",
    "        www.udistrital.edu.co\n",
    "        </td>\n",
    "        <td>\n",
    "        konradlorenz<br>\n",
    "        unal<br>\n",
    "        udistrital<br>\n",
    "        </td>\n",
    "    </tr>   \n",
    "</table>\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio 2: Validador\n",
    "\n",
    "Al pequeño Sam le gusta escribir al reves. Sin embargo ha escrito unas cadenas muy largas y se tiene la traducción. Sam necesita su ayuda para saber si lo que ha escrito al revés es lo mismo que piensa.\n",
    "Entrada:\n",
    "Dos Strings uno con la cadena al derecho y otro con la posible cadena invertida.\n",
    "Salida:\n",
    "La palabra SI si la palabra corresponde a su versión invertida.  La palabra NO en caso contrario.\n",
    "Ejemplo:\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <td>Input</td><td>Output</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>\n",
    "No tengo ningún consejo para darle a aquel que desespera.<br>\n",
    ".arepsesed euq leuqa a elrad arap ojesnoc núgnin ognet oN\n",
    "        </td><td>SI</td>\n",
    "    </tr>\n",
    " <table>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicio 3: mAYUSCULAS PEGADAS\n",
    "A veces al escribir cosas de afán suele pasar que se queda el teclado con la tecla de caps lock pegada. Su misión detectar si esto sucedió y escribir la cadena correctamente.\n",
    "\n",
    "Entrada: Una cadena de texto\n",
    "Salida: La cadena escrita correctamente\n",
    "\n",
    "Ejemplo 1:\n",
    "\n",
    "<table>\n",
    "    <tr><td>Input</td><td>Output</td>\n",
    "    <tr>\n",
    "        <td>No tengo ningún consejo para darle a aquel que desespera.</td>\n",
    "        <td>No tengo ningún consejo para darle a aquel que desespera.</td>\n",
    "     </tr>\n",
    "<table>\n",
    "    \n",
    "Ejemplo 2:\n",
    "\n",
    "<table>\n",
    "    <tr><td>Input</td><td>Output</td>\n",
    "    <tr>\n",
    "        <td>cAPS LOCK</td>\n",
    "        <td>Caps LOCK</td>\n",
    "     </tr>\n",
    "<table>\n",
    "\n",
    "\t\n",
    "Ejemplo 3:\n",
    "\n",
    "<table>\n",
    "    <tr><td>Input</td><td>Output</td>\n",
    "    <tr>\n",
    "        <td>cien años de soledad</td>\n",
    "        <td>cien años de soledad</td>\n",
    "     </tr>\n",
    "<table>\n",
    "\n",
    "Ejemplo 3:\n",
    "<table>\n",
    "    <tr><td>Input</td><td>Output</td>\n",
    "    <tr>\n",
    "        <td>Cien años de sOLEDAD</td>\n",
    "        <td>Cien años de Soledad</td>\n",
    "     </tr>\n",
    "<table>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Referencias\n",
    "\n",
    "Das, B. N. (2017). Learn Python in 7 Days. Packt Publishing Ltd."
   ]
  }
 ],
 "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
}