C01.2 Fundamentos de Python (Estructuras de datos básicos).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"logo.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Estructuras de datos\n",
    "\n",
    "Las estructuras de datos son aquellos objetos que se usan para almacenar información. En esta sección veremos los tipos básicos de Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listas\n",
    "\n",
    "Las listas son conjuntos ordenados e indexados de elementos.\n",
    "\n",
    "``nombre_lista = [elemento_1, elemento_2,...,elemento_n]``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carreras = [\"matemáticas\",\"física\",\"actuaría\",\"computación\"]\n",
    "carreras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Lista con varios tipos de elementos\n",
    "lista1 = [\"Hola\",1+2,1<0]\n",
    "lista1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexado de listas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para retornar el elemento de una lista, utilizamos ``nombre_lista[índice]`` donde *índice* es el número de elemento que queremos. Es importante notar que los índices en Python comienzan en 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carreras[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos retornar un rango de elementos de las listas con la sintaxis ``nombre_lista[inicio:final:orden]`` **pero Python siempre resta un 1 a *final*** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(carreras[0:2])\n",
    "print(carreras[:2])\n",
    "print(carreras[1:2])\n",
    "print(carreras[2:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos también retornar los elementos de atrás hacia adelante utilizando índices negativos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carreras[-2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El *orden* nos dice que podemos saltar elementos. Es decir, `nombre_lista[inicio:final:n]` nos devuelve desde inicio hasta final brincando de *n* en *n*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carreras[::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si *orden* es negativo, nos devuelve brincando de *n* en *n* la lista pero en sentido contrario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carreras[::-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En particular para invertir el orden de la lista usamos `nombre_lista[::-1]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carreras[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tarea**\n",
    "\n",
    "Investigar cómo extraer solo ciertos elementos de una lista de Python. \n",
    "\n",
    "Por ejemplo, de la lista ``L=[0,1,2,3,4,5,6,7]`` extraer la sublista ``[2,4,5]``."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operaciones internas de listas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para conocer la cantidad de elementos de una lista usamos ``len``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(carreras)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las listas son objetos *mutables* en Python. Esto significa, en particular, que podemos añadirles elementos. Lo anterior lo hacemos con el ** muy útil** método `append`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carreras.append(\"matemáticas aplicadas\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carreras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos crear una nueva lista a partir de una existente *concatenando* esta última consigo misma tantas veces como queramos mediante multiplicaciones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carreras_doble = 2 * carreras\n",
    "carreras_doble"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E incluso, concatenar listas diferentes en una sola usando el operador `+`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carreras + carreras[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por otra parte, mediante la indexación podemos también cambiar los elementos de una lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carreras[4] = \"matemáticas industriales\"\n",
    "carreras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aprovechand la mutabilidad, podemos cambiar un rango de elementos de la lista e incluso añanadir mas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carreras[2:] = [\"Actuaría\",\"Computación\", \"Matemáticas industriales\", \"Matemáticas Aplicadas\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carreras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ver si algo pertenece a una lista "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"¿La carrera de biología pertence a la lista de carreras?\\n\",\"biología\" in carreras)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"¿La carrera de física pertence a la lista de carreras?\\n\",\"Física\" in carreras)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"¿La carrera de física pertence a la lista de carreras?\\n\",\"física\" in carreras)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Además, para encontrar el lugar donde un elemento se encuentra en una lista usamos el método `index`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carreras.index(\"física\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Observación.** Es importante notar que el método *index* devuelve el índice en que el elemento aparece por primera vez."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [\"a\",\"b\",\"c\",\"b\",\"a\"]\n",
    "lista.index(\"b\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para eliminar elementos de una lista lo podemos hacer de dos maneras: dando el índice o el nombre del elemento usando el método *pop*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carreras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carreras.pop(4)\n",
    "carreras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carreras.pop(carreras.index(\"física\"))\n",
    "carreras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos ordenar los elementos de una lista con el método `sort`, pero aquí es **muy importante saber qué este método modifica al objeto**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carreras.sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "carreras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una función útil para generar listas secuenciales es la función `range(n)`. Por ejemplo `list(range(15))` crea una lista cuyos elementos van de 0 a 14:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista2 = list(range(15))\n",
    "lista2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otras funciones que se pueden aplicar a las listas son `min(nombre_lista)` y `max(nombre_lista)`. Mas adelante veremos otras."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuplas\n",
    "\n",
    "Las tuplas son versiones de listas que son inmutables. Para accesar a sus elementos usamos `()` en lugar de `[]`. Ver [nuestra documentación de Py_Jr](https://github.com/scidatmath2020/Py_Jr/blob/master/C15_tipos_list_y_tuple.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Diccionarios\n",
    "\n",
    "Los diccionarios, junto con las listas, son las estructuras básicas de datos más usadas en Python.\n",
    "\n",
    "Son conjuntos de claves asociadas a valores. Sabiendo una clave podemos encontrar el valor de esa clave. Ver [nuestra documentación de Py_Jr](https://github.com/scidatmath2020/Py_Jr/blob/master/C17_tipo_dict.ipynb)"
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}