1-introduccion-python-texto.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "source": [
    "\n",
    "# Lectura distante y minería de corpus textuales con Python\n",
    "\n",
    "## Introducción a Python, Jupyter Notebooks y al trabajo con textos\n",
    "\n",
    "---\n",
    "---\n",
    "Romina De León\n",
    "\n",
    "CONICET\n",
    "\n",
    "[rdeleon@conicet.gov.ar](rdeleon@conicet.gov.ar)\n",
    "\n",
    "---\n",
    "---\n",
    "\n",
    "### ¿Qué es Pyhton?\n",
    "<div style=\"text-align: center;\">\n",
    "    <img src=\"https://www.python.org/static/img/python-logo.png\" alt=\"Logo de Python\" title=\"Logo de Python\" style=\"width: 300px; height: auto;\">\n",
    "</div>\n",
    "\n",
    "Python es un **lenguaje de programación potente y fácil de aprender**, tiene estructuras de datos de alto nivel, eficientes y un simple, pero efectivo sistema de programación orientado a objetos. \n",
    "\n",
    "Posee una elegante sintaxis, tipado dinámico, que junto a su naturaleza interpretada lo convierten en un lenguaje ideal para scripting y desarrollo de aplicaciones en diversas áreas, para la mayoría de plataformas.\n",
    "\n",
    "La extensión de archivos para correr un programa escrito en Python es `.py`. Asimismo en lugar de este tipo de archivos utilizaremos cuadernos (**notebooks**) que permiten las combinación textos y códigos, que se organizan en *celdas*, facilitando pruebas y documentación del código. Para ello utilizaremos **Jupyter Notebooks**. \n",
    "\n",
    "---\n",
    "\n",
    "Más información sobre Python se encuentra en el siguiente [tutorial](https://python-docs-es.readthedocs.io/es/3.12/tutorial/index.html) \n",
    "\n",
    "---\n",
    "---\n",
    "\n",
    "### ¿Qué es Jupyter Notebooks?\n",
    "<div style=\"text-align: center;\">\n",
    "    <img src=\"https://jupyter.org/assets/homepage/main-logo.svg\" alt=\"Logo de Jupyter Notebooks\" title=\"Logo de Jupyter Notebooks\" style=\"width: 150px; height: auto;\">\n",
    "</div>\n",
    "\n",
    "Es una de las aplicaciones para programar en Python, facilita la creación de documentos que permiten combinar código con otros elementos tales como texto enriquecido, imágenes, enlaces, etc. Estas características lo han covertido en uno de los formatos más elegidos por la comunidad de Data Science. Además permite trabajar en las Notebooks localmente en navegadores de internet aún sin conexión.\n",
    "\n",
    "Estos ficheros (notebooks) poseen extensión `.ipynb`, y pueden abrirse desde la misma aplicación [Jupyter Notebook](https://jupyter-notebook.readthedocs.io/en/stable/), así como desde [Visual Studio Code](https://code.visualstudio.com/docs/datascience/jupyter-notebooks).\n",
    "\n",
    "Jupyter Notebook consta de dos componentes:\n",
    "\n",
    "- Kernel, encargado de ejecutar el código que contiene la notebook. El kernel por defecto ejecuta código Python, aunque se pueden instalar otros kernels para distintos lenguajes.\n",
    "- Dashboard, nos muestra las notebooks de nuestra computadora, y se usa también para gestionar los kernels.\n",
    "\n",
    "\n",
    "---\n",
    "\n",
    "Tutoriales recomendados sobre para iniciar el trabajo con Jupyter Notebooks:\n",
    "- [Tutorial para principiantes con Jupyter Notebook](https://jupyter-notebook.readthedocs.io/en/stable/notebook.html)\n",
    "- [Otro tutorial para principiantes](https://www.dataquest.io/blog/jupyter-notebook-tutorial/)\n",
    "- [Tutorial en español interactivo](https://interactivechaos.com/es/manual/tutorial-de-python/jupyter)\n",
    "\n",
    "---\n",
    "---\n",
    "<div style=\"text-align: center;\">\n",
    "    <img src=\"https://camo.githubusercontent.com/210aaa21e63d8094b8b31c5cef8783803fc6612dada5d92cc114319f233d9135/68747470733a2f2f696d67732e786b63642e636f6d2f636f6d6963732f707974686f6e2e706e67\" alt=\"Python\" title=\"Python\" style=\"width: 300px; height: auto;\">\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introducción a Jupyter notebook\n",
    "\n",
    "#### Celdas de textos\n",
    "\n",
    "Las *celdas* son donde se escribe el texto, las *celdas de texto* utilizan 'Markdown', un lenguaje de marcado sencillo. Aquí hay una guía rápida de [Markdown](https://www.markdownguide.org/cheat-sheet/). Es decir, se puede editar y luego ejecutar las celdas para producir un resultado (`CTRL o COMANDO + Enter` o haciendo `click` en la barra de herramientas), y se reproducirá texto con formato. Algunos [atajos de teclado](https://www.notion.so/es-la/help/keyboard-shortcuts) para Markdown.\n",
    "\n",
    "---\n",
    "\n",
    "> Ejercicio de ejemplo: Al hacer doble-click sobre esta celda, se podrá editar la misma.\n",
    "\n",
    "<div style=\"text-align: center;\">\n",
    "    <img src=\"img/ejecutar-notebook.png\" alt=\"Click en el botón de Run para correr la celda\" title=\"Click en el botón de Run para correr la celda\" style=\"width: 450px; height: auto;\">\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "#### Celdas de código\n",
    "\n",
    "En ellas se puede escribir código y ejecutar órdenes de la misma manera que la de textos. Se ejecuta el código en la celda (**`In [1]:`**) el resultado se revela en (**`Out [1]:`**). Dentro de dichas celdas, se pueden añadir comentarios con el siguiente formato: `# Este es un comentario en una celda de código. Al ejecutar la celda, este será ignorada y no hará nada.`\n",
    "\n",
    "<div style=\"text-align: center;\">\n",
    "    <video width=\"600\" controls>\n",
    "    <source src=\"/img/ejecutar-celda.mp4\" type=\"video/mp4\">\n",
    "    </video>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "> Ejercicio: Ejecutar la celda de código a continuación para evaluar el código Python. Probar con otros valores para obtener un resultado diferente.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "23 + 8 #este será un comentario para presentar como realizar una simple suma en Python, al ejecutar la celda realizará el cálculo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **ATENCIÓN**\n",
    "\n",
    "Al ejecutar celdas de código se debe hacer en orden, de arriba hacia abajo de la *notebook*, debido a que cada celda toma el resultado de las anteriores. Si no están estos resultados, devolverá **error**.\n",
    "\n",
    "Si se quiere correr todas las celdas y en orden, se deberá hacer desde **RUN** en la barra de herramientas, y seleccionar **Run all cells**. Para borrar los resultados (*outputs*) de todas las celdas, en la barra de herramientas en **Edit** seleccione **Clear Outputs of All Cells** o sino en una celda hacer click con el botón derecho y seleccionar lo mismo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "---\n",
    "## Conocimientos para principiantes en Python\n",
    "\n",
    "Este lenguaje cuenta con funciones básicas incorporadas. En las próximas activiades utilizaremos algunas de ellas, como ser `print()`, `range()`, `len()`. Les comparto la [biblioteca](https://docs.python.org/es/3/library/functions.html) de Python, dónde pueden encontrar más información sobre las mismas. \n",
    "\n",
    "Al momento de la instalación de Python, se suman paquetes, módulos y librerías estándar. Asimismo, dependiendo de las actividades a realizar en ciertas ocasiones, las que se encuentran por default son versiones obsoletas o no se encuentran disponibles, y se requiere su instalación o importación.\n",
    "\n",
    "### Manejo de paquetes con pip\n",
    "\n",
    "El programa [`pip`](https://packaging.python.org/en/latest/key_projects/#pip), permite la instalación, actualización y eliminación de paquetes, los subcomandos: `install`, `uninstall`, `freeze`. (Pueden consultar la guía [Instalando módulos de Python](https://docs.python.org/es/3/installing/index.html#installing-index) para obtener la documentación completa de `pip`).\n",
    "\n",
    "Un ejemplo de como instalar la última versión de un paquete, es especificando el nombre del paquete:\n",
    "\n",
    "> `pip install novas` #para líneas de comandos\n",
    "> \n",
    "> `!pip install novas` #para las Jupyter Notebooks\n",
    "\n",
    "`!` se utiliza para ejecutar comandos de shell (es decir, como comandos de terminal) desde una celda de código de Python. Es una opción muy útil al trabajar desde notebooks, para no tener que salir de la misma cuando se requiere instalar un paquete o librería. Una cuestión a tener en cuenta, es que en ciertas ocasiones luego de instalar un paquete con `!pip`, se necesite reiniciar el kernel de la notebook para que Python lo detecte correctamente.\n",
    "\n",
    "### Funciones\n",
    "\n",
    "Una función se define como un bloque de código reutilizable que realiza una tarea específica. Las funciones permiten agrupar un conjunto de instrucciones bajo su nombre, facilitando su invocación en cualquier parte del programa sin la necesidad de tener que volver a escribir el mismo código. Pueden recibir parámetros (entradas) y devolver un resultado (salida) utilizando la palabra clave `return`. Esto facilita el código de un programa en partes más pequeñas y manejables.\n",
    "Un ejemplo básico de una función:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def resta(a, b):\n",
    "    \"Esta función resta dos números y devuelve el resultado.\"\n",
    "    resultado = a - b\n",
    "    return resultado"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Explicación del código:\n",
    "\n",
    "    * `def` palabra que se utiliza en Python para definir una función.\n",
    "    * `resta` nombre dado a la función.\n",
    "    * ``a`` y ``b`` parámetros de entrada.\n",
    "    * ``resultado`` variable local dentro de la función.\n",
    "    * ``return`` devuelve el valor de la resta de a y b."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-7\n"
     ]
    }
   ],
   "source": [
    "#Para utilizar la función se la llama por su nombre y se ingresan los valores para los parámetros\n",
    "\n",
    "resultado_final = resta(8, 15)\n",
    "print(resultado_final)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    ** Las funciones pueden ser simples o complejas según las necesidades, pueden aceptar cualquier número de parámetros, incluido listas, diccionarios, así como otros objetos.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Manipulación de textos en Python\n",
    "\n",
    "Los datos textuales se representan en Python, y en la mayoría de los lenguajes de programación, con objetos de tipo **string** o **str** (cadena).\n",
    "\n",
    "Un *string* es una *secuencia de caracteres* simple: `ruido` se representa con la siguiente secuencia de caracteres individuales `r` `u` `i` `d` `o`.\n",
    "\n",
    "***\n",
    "***\n",
    "#### Conocimientos básicos para crear y manipular cadenas en Python. \n",
    "\n",
    "Esto será a modo introductorio para la minería de texto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creación y almacenamiento de Strings con nombres\n",
    "\n",
    "La creación de cadenas es sencillo, solo se debe escribir caracteres intre comillas (simples `'` o dobles `\"`).\n",
    "\n",
    "Se puede probar con la siguiente celda:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'La discoteca clausurada.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Está lloviendo en Mar del Plata.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para poder almacenar y luego reutilizar una cadena, o imprimirla, se debe utilizar el *operador de asignación* `=` (signo de igual). Lo que figure a la derecha del `=` se almacena en _nombre_ a la izquierda. Es decir, que al _nombre_ se le asigna el valor, como una etiqueta que se adhiere, y se puede utilizar luego. En otros lenguajes de programación se denomina *variable*.\n",
    "\n",
    "El código es:\n",
    "\n",
    "`nombre = valor`\n",
    "\n",
    "Corre la celda que sigue:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_sentence = 'La discoteca clausurada'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se observa que no imprime nada como *output*. Esto es porque se almacenó la cadena y no la imprimió. Para poder ver `my_sentence`, solo se debe escribir `my_sentence` en una celda de código, ejecutarlo y se imprimirá. Prueba ejecutar la siguiente celda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_sentence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "> Ejercicio: Trata de crear tu propia cada en la celda que sigue con el nombre `my_string`. Luego añadir, otra línea de código para imprimirla. Es decir, deberá haber dos líneas de código debajo.\n",
    "\n",
    "---\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Escribe aquí el código"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Concatenación de cadenas\n",
    "\n",
    "Si se suman dos (o más) cadenas con el signo (`+`), se encontrarán concatenadas, es decir, las secuencias de caracteres se unen.\n",
    "Por ejemplo, correr la siguiente celda:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sentence2 = my_sentence + ' estaba llena de gente.' #dejar espacio antes del primer carácter para que no quede pegada a my_sentence\n",
    "sentence2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Escribe aquí una concatenación de tres cadenas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Manipulación de cadenas completas\n",
    "\n",
    "Python posee varios métodos que permiten manipular cadenas en su totalidad. Estos se aplican utilizando la notación de punto. Es decir, primero se escribre el nombre de la cadena, seguido de un punto `.`, y luego el nombre del método, terminando con un par de paréntesis `()`, que indican a Python que deberá ejecutar esa orden.\n",
    "\n",
    "Ejemplo de ello sería:\n",
    "\n",
    "`my_string.method_name()`\n",
    "\n",
    "Se podría realizar operaciones como cambiar mayúsculas y/o minúsculas. \n",
    "\n",
    "---\n",
    "**Es importante** destacar que estos métodos no modifican la cadena original, sino que devuelven una nueva cadena con las modificaciones solicitadas. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_sentence.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_sentence.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ¿Cómo podrías guardar algunas de esas dos nuevas cadenas?>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#escribe aquí tu solución"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Realizar algunos test con cadenas\n",
    "\n",
    "Es posible realizar diversas pruebas en una cadena para comprobar si cumple con ciertas condiciones. Por ejemplo, se puede verificar si la cadena contiene únicamente caracteres alfabéticos.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_sentence.isalpha()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "---\n",
    "Existen diferentes métodos disponibles para manipular cadenas. A continuación, se ofrece una guía con detalles técnicos en la [Documentación de Pyhton](https://docs.python.org/es/3/library/stdtypes.html#string-methods) sobre los métodos de cadenas y otros módulos útiles para trabajar con textos. También se puede acceder a [Servicios de procesamiento de texto](https://docs.python.org/es/3/library/text.html#textservices), que incluyen expresiones regulares del módulo [re](https://docs.python.org/es/3/library/re.html#module-re). Estas son patrones que se utilizan para hacer coincidir combinaciones de caracteres en cadenas. \n",
    "\n",
    "---\n",
    "---\n",
    "> Ejercicio: Probar al menos tres métodos de cadena que recuperen de la documentación mencionada.\n",
    "---\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Escribe aquí tu código"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Acceder a caracteres individuales con un índice\n",
    "\n",
    "Una cadena es una secuencia de caracteres, similar a una lista, lo que permite acceder a un carácter individual especificando su posición en la cadena. Para ello, se utiliza un *índice* numérico entre corchetes (`[]`). Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_sentence[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el ejemplo, utilizamos el *index* `1`, por ello se podría esperar que devuelva el primer carácter de la cadena, ¿no? Sin embargo, hubo algo inesperado, nos devuelve `a` en lugar de `L`.\n",
    "\n",
    "Esto ocurre porque, en muchos lenguajes de programación, incluida Pyhton, la numeración de índices comienza desde 0, lo que se denomina *numeración basada en cero*. Por lo tanto, cuando usamos el índice `1`, accedemos al *segundo* carácter de la cadena.\n",
    "\n",
    "Para obtener el primer carácter, se debe especificar el índice `0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write code here to get the first character in the string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Rango de caracteres\n",
    "\n",
    "Los objetos de tipo **range** o *rango* representan una secuencia inmutable de números. De manera similar, se puede seleccionar un rango de caracteres dentro de una cadena informando un índice para el inicio y otro para el final, separados por dos puntos `:`. Esta técnica se denomina *notación de segmento* o **slicing**.\n",
    "\n",
    "Por ejemplo, si seleccionamos el rango desde el índice `0` (inicio  o *start*) hasta el índice `20` (fin o *stop*), obtendremos todos los caracteres desde el primero hasta el carácter en el índice `19`, pues el índice de finalización `20` no se incluye en el segmento.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_sentence[0:20]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Escribir el código para acceder solo a los caracteres \"La discoteca\" de la cadena"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También es posible realizar saltos dentro de una cadena al seleccionar un rango de caracteres. Para hacerlo, se debe especificar un valor adicional llamado *step* o *pasos*. \n",
    "\n",
    "La sintaxis:\n",
    "    \n",
    "`my_sentence[start:stop:step]`\n",
    "\n",
    "Para realizar saltos de 3 en 3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_sentence[0:20:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Listas de *strings*\n",
    "\n",
    "Otra utilidad importante de las cadenas es la posibilidad de almacenarlas en una *lista*. Por ejemplo, se puede almacenar diferentes oraciones como elementos individuales dentro de una lista.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = ['La discoteca clausurada',\n",
    "          'Hace unos años se cerró',\n",
    "          'La música se apagó definitivamente']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Escribe el código para imprimir la lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "**NOTA:** Los corchetes (`[]`) que se utilizan para crear listas son distintos de los que se emplean para indexar caracteres individuales.\n",
    "***\n",
    "\n",
    "Al igual que con los caracteres individuales en una cadena, se puede acceder a las string almacenadas en una lista mediante un índice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Rango de elementos en las cadenas en una lista \n",
    "\n",
    "De manera similar, se puede acceder a un rango de elementos dentro de una lista usando la notación de segmentos o slicing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Igual que con las cadenas se pueden realizar rangos con `steps`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Escribir el código para cortar `my_list`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se puede acceder a la lista entera sin añadir índices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**También se podría recorrer la lista *hacia atrás* de la siguiente manera:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Avanzado: Creación de listas de cadenas con Comprensión de listas\n",
    "\n",
    "La comprensión de listas en Python es una poderosa herramienta que permite la creación de nuevas listas de forma concisa, a partir de iteraciones sobre secuencias existentes. Esta técnica combina lo aprendido sobre listas y manipulación de cadenas, y nos permite transformar y filtrar elementos de manera eficiente.\n",
    "\n",
    "Por ejemplo, desde nuestra lista original `my_list` crearemos una nueva lista `new_list` recorriendo cada cadena de la lista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Crear una nueva lista con todas las cadenas en mayúsculas\n",
    "new_list = [sentence.upper() + '.' if not sentence.endswith('.') else sentence.upper() for sentence in my_list]\n",
    "\n",
    "print(new_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "---\n",
    "\n",
    "### Resumen\n",
    "\n",
    "* Python es un lenguaje de programación de propósito general que es bueno para principiantes.\n",
    "* Las Jupyter Notebooks tienen dos tipos de **celda** principales: **código** y **texto** (Markdown).\n",
    "* Creación y almacenación de **cadenas** con **nombre** (también conocidas como variables).\n",
    "* Manipulación de strings mediante:\n",
    "    * **Concatenación** de dos o más cadenas;\n",
    "    * Acceso a un carácter individual con un **índice**;\n",
    "    * Acceso a un rango de caracteres con **segmentos** o **slicing**;\n",
    "    * Reemplazo de cadenas completas o evaluación de características de la cadena.\n",
    "* Creación y almacenamiento de **listas** de cadenas.\n",
    "* Acceso a cadenas en una lista mediante índice y slicing.\n",
    "* Comprensión de listas"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}