module_1/1_03.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  1.3. Strings\n",
    "\n",
    "## La función print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Como ya hemps visto,  **print()** imprime todos los argumentos por pantalla separados por espacios.\n",
    "    - print(\"Hello World\")\n",
    "    - print(\"Hello\",'World')\n",
    "    - print(\"Hello\", <Variable Containing the String>)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello\", \"World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Este comportamiento se puede cambiar, usando  `sep`  para el separador (por defecto el espacio) y `end` (por defecto salto de línea \\n)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello...World!!"
     ]
    }
   ],
   "source": [
    "print(\"Hello\", \"World\", sep='...', end='!!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Hello "
     ]
    }
   ],
   "source": [
    "print(\"Hello\", end=' ')\n",
    "print(\"Hello\", end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "- Se pueden definir con \" o con ' indistintamente.\n",
    "- Con \"\"\" podemos definir string de varias lineas\n",
    "- Si dentro queremos poner \" usar ' y viceversa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hola\n",
      "hola\n",
      "hola 'u'\n",
      "hola \"u\"\n"
     ]
    }
   ],
   "source": [
    "print('hola')\n",
    "print(\"hola\")\n",
    "print(\"hola 'u'\")\n",
    "print('hola \"u\"')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "This is a longer string that\n",
      "spans multiple lines\n",
      "\n"
     ]
    }
   ],
   "source": [
    "c = \"\"\"\n",
    "This is a longer string that\n",
    "spans multiple lines\n",
    "\"\"\"\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Formating\n",
    "- Exiten muchos métodos para formatear y manipular strings.\n",
    "- El mejor y más moderno es utilizar los llamados f strings.\n",
    "- Para concatenar se puede usar '+'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello World'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Hello' + ' ' + 'World'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'World!'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string_1 = 'World'\n",
    "string_2 = '!'\n",
    "string_1 + string_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hola a es: 1!'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Hola a es: ' + str(a) + '!' # Para que esto funcione tenemos que convertir a primero a string para poder concatenar con +"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Para introducir el valor de las variables dentro de un string, sin necesidad de convertirlas a string, lo más fácil es utilizar format strings.\n",
    "```python\n",
    "<str> = f'{<elemento_1>}, {<elemento_2>}'\n",
    "```\n",
    "- Se añade una f antes de las comillas. Dentro del string, entre llaves, la varaible a incluir.\n",
    "- De esta manera, podemos realizar operaciones dentro del string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a es: 1 b es: hola a mas 1 es: 2\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "b = 'hola'\n",
    "print(f'a es: {a} b es: {b} a mas 1 es: {a+1}') # EL código que está dentro de las llaves se ejecuta. Se puede incluso llamar a una función."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Se puede formatear el string especificando el formato entre las llaves. ej: {variable:formato}\n",
    "- Ejemplos de formatos:\n",
    "\n",
    "|Number|Format|Output|Description|\n",
    "|----|---|---|---|\n",
    "|8|{:o}|10|Octal equivalent of the number|\n",
    "|255|{:x}| ff |Hexadecimal equivalent of the number |\n",
    "|100|{:e}| '1.000000e+02' |Exponential equivalent of the number |\n",
    "|100|{:.2e}| '1.00e+02' |Exponential equivalent of the number with 2 decimal places|\n",
    "|3|{:f}| '3.000000'|float equivalent of the number |\n",
    "|3.1415926|{:.2f}|3.14|2 decimal places|\n",
    "|3.1415926|{:+.2f}|+3.14|2 decimal places with sign|\n",
    "|2.71828|{:.0f}|3|No decimal places|\n",
    "|5|{:0>2d}|05|Pad number with zeros (left padding, width 2)|\n",
    "|5|{:x<4d}|5xxx|Pad number with x’s (right padding, width 4)|\n",
    "|10|{:x<4d}|10xx|Pad number with x’s (right padding, width 4)|\n",
    "|1000000|{:,}|1,000,000|Number format with comma separator|\n",
    "|0.25|{:.2%}|25.00%|Format percentage|\n",
    "|1000000000|{:.2e}|1.00e+09|Exponent notation|\n",
    "|13|{:10d}|13|Right aligned (default, width 10)|\n",
    "|13|{:<10d}|13|Left aligned (width 10)|\n",
    "|13|{:^10d}|13|Center aligned (width 10)|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "pi = 3.1416"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Con 2 decimales: 3.14'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f'Con 2 decimales: {pi:.2f}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Con 2 decimales y signo: +3.14'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f'Con 2 decimales y signo: {pi:+.2f}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'En notacion cientifica: 3.141600e+00'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f'En notacion cientifica: {pi:e}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'En notacion cientifica con 2 decimales: 3.14e+00'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f'En notacion cientifica con 2 decimales: {pi:.2e}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'con diez espacios         10'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aux = 10\n",
    "f'con diez espacios {aux:10d}'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Los Strings se pueden transformar de muchas maneras:\n",
    "\n",
    "\n",
    "\n",
    "|Médodos|Descripción|\n",
    "|----|---|\n",
    "``` <str>  = <str>.strip() ``` |  Strips all whitespace characters from both ends.\n",
    "```  <str>  = <str>.strip('<chars>') ```             | Strips specific characters from both ends.\n",
    "``` <list> = <str>.split()  ```                     | Splits on any whitespace character.\n",
    "``` <list> = <str>.split(sep=None) ``` | Splits on 'sep' str.\n",
    "``` <str>  = <str>.join(<collection>)  ```          | Joins elements using string as separator.\n",
    "``` <str>  = <str>.replace(old, new [, count]) ```  | Replaces 'old' with 'new' at most 'count' times.\n",
    "``` <bool> = <str>.startswith(<sub_str>)  ```       | True if strings start with an expression.\n",
    "``` <bool> = <str>.endswith(<sub_str>)```           | True if strings end with an expression.\n",
    "``` <int>  = <str>.index(<sub_str>) ```             | Returns start index of first match.\n",
    "``` <bool> = <str>.isnumeric()   ```                | True if str contains only numeric characters.\n",
    "``` <list> = textwrap.wrap(<str>, width) ```        | Nicely breaks string into lines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "s=\"hello wOrld\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello world'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.capitalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Porqué hay veces que llamamos a una función metiendo la variable dentro: print(s) o type(s), y otras veces llamamos a la función con un punto detrás de la variable s.upper()?\n",
    "\n",
    "Las funciones que son propias del objeto se llaman con un punto: s.upper() Estás invocando un método del objeto\n",
    "\n",
    "Print(), type(), len()... son funciones genéricas del lenguaje. No pertenecen a un objeto en concreto y por eso las llamamos metiendo la variable dentro. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HELLO WORLD'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello world'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'         Hello World          '"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Centramos en 30 caracteres\n",
    "\"Hello World\".center(30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'lots of space'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Elimina los espacios en blanco iniciales y finales\n",
    "\"     lots of space             \".strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello Class'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Hello World\".replace(\"World\", \"Class\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello wOrldhello wOrldhello wOrldhello wOrldhello wOrld'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s*5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"La longitud de 'hello wOrld' es 11\""
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"La longitud de '{s}' es {len(s)}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.startswith(\"hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.endswith(\"World\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hay 3 l pero solo 0 World en hello wOrld'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"Hay {s.count('l')} l pero solo {s.count('World')} World en {s}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"'el' está en la posición 1 en hello wOrld\""
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f\"'el' está en la posición {s.find('el')} en {s}\" # El índice empieza por 0. OJo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparación de Strings\n",
    "- Strings se comparan por orden alfabético.\n",
    "- El operador `in`  permite buscar substrings (retorna un booleano)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' > 'b'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'z' > 'b'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'abc' < 'bbc' <= 'bbc'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"ABC\" in \"This is the ABC of Python\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Los strings se pueden indexar usando corchetes. \n",
    "- Los índices empiezan por cero en Python.\n",
    "- **len()** nos da la longitud."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = '123456789'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Primer carácter\n",
    "s[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "string index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-30-f2636e106e89>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ms\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ms\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;31m# Da error si intento recuperar así el último elemento\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "s[len(s)] # Da error si intento recuperar así el último elemento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'9'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[len(s)-1] # Para obtener el último elemento hay que restarle 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Se pueden usar índices negativos se pueden usar para empezar por atrás"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'123456789'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'9'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[-len(s)] # Al hacerlo desde atrás, no es necesario restar 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Podemos especificar substring usando $a:b$\n",
    "- El último no está incluido:\n",
    "\n",
    "<center>\n",
    "<img src=\"imgs/string_slide.png\"  alt=\"drawing\" width=\"600\"/>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'123'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Primeros tres caracteres\n",
    "s[0:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'456'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Siguientes tres caracteres. Recuerda que el último no había sido incluído en la selección anterior!\n",
    "s[3:6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Puedes especificar rangos \"desde el inicio\" o \"hasta el final\", indicándolo con los dos puntos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'123'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Primeros tres caracteres\n",
    "s[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'789'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Últimos tres caracteres\n",
    "s[-3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'123456789'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Todos los caracteres\n",
    "s[:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Podemos pasar un tercer elmento para ir extrayendo los elementos especificando el paso.\n",
    "- **string[start:end:step]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'357'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[2:-1:2] # Del tercer elemento, hasta el último (no incluído), de dos en dos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'13579'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[::2] # Todos los elementos, de dos en dos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'987654321'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[::-1] # Todos los elementos, invirtiendo el órden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Los Strings son inmutables\n",
    "\n",
    "- Los strings son inmutables, no se pueden modificar una vez creados.\n",
    "- La única manera de modificarlo es crear un nuevo string y asignarlo a esa variable (destruyendo el contenido anterior)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Creando un nuevo string 01X345 OK\n",
      "01X345 sigue OK\n"
     ]
    }
   ],
   "source": [
    "s = '012345'\n",
    "s_new = s[:2] + 'X' + s[3:] # Creamos un nuevo string donde hemos reemplazado el 2 con una X\n",
    "print(\"Creando un nuevo string\", s_new, \"OK\")\n",
    "\n",
    "s_new = s.replace('2', 'X') # Hago lo mismo. No lo modifico, creo un nuevo string\n",
    "print(s_new, \"sigue OK\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'012345'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "01X345\n"
     ]
    }
   ],
   "source": [
    "s = s.replace('2', 'X')\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ejercicios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. \\\n",
    "Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. \\\n",
    "Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1.3.1.** Guarda, en una nueva variable, la frase en mayúsculas, y cuenta el número de caracteres que tiene."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1.3.2.** Separa la frase por palabras."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1.3.3.** Localiza la posición en la que se encuentra la subcadena \"irure\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1.3.4.** Introduce la variable string_to_test = ’Python is an interesting and useful language for numerical computing!’. Usando slicing, extrae:  \n",
    "- Python\n",
    "- !\n",
    "- computing\n",
    "- in\n",
    "- !gnitupmoc laciremun rof egaugnal lufesu dna gnitseretni na si nohtyP - inverso\n",
    "- nohtyP\n",
    "- Pto sa neetn n sfllnug o ueia optn!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1.3.5.** Crea un string y cuenta el número de caracteres y las veces que aparece la letra a."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1.3.6.** Escribe un programa que “codifique” una frase modificando todas las vocales según el siguiente código: a por 4, e por 3, i por 1, o por 0 y u por el símbolo #. Por ejemplo, la frase: “Un perro del hortelano”, deberá devolverse: “#n p3rr0 d3l h0rt3l4n0”."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}