![\"Licencia](\"https://i.creativecommons.org/l/by-sa/4.0/88x31.png\")
Esta obra está bajo una licencia de Creative Commons Reconocimiento-CompartirIgual 4.0 Internacional
Autor: Pablo Cerrillo Ruiz.
Última modificación: 26 de junio de 2019.
Jupyter Notebook es un entorno de trabajo interactivo que permite desarrollar código de manera dinámica. Ahora mismo nos encontramos en el cuaderno UD Estructuras de datos, cuya finalidad es enseñar al alumno las diferentes estructuras de datos en Python y la utilidad que éstas tienen en el mundo de la programación.
" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/menu_superior_jupyter_notebook.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Recuerde que para ejecutar el contenido de una celda basta con pulsar el botón Run del panel de control. También puede pulsar al mismo tiempo las teclas Mayúsculas+Enter
" }, { "metadata": {}, "cell_type": "markdown", "source": "\nUna vez vistos los tipos de datos básicos del lenguaje de programación en Python (int, float, bool, complex, str ), puede ser que necesitemos realizar algún tipo de agrupación de éstos debido a lo que puedan representar en conjunto. Por ejemplo, imagine que tenemos que almacenar la temperatura de los últimos 5 días, una solución podría ser la siguiente:\n" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Definiendo la temperatura de los últimos 5 días con distintas varibles'''\n\ntemperatura_dia_1 = 22.3\ntemperatura_dia_2 = 25.2\ntemperatura_dia_3 = 23.8\ntemperatura_dia_4 = 27.9\ntemperatura_dia_5 = 30.0\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "
Como vemos, hemos creado 5 variables, una por cada día, para almacenar la temperatura. Esto supone un problema debido a que si quiesieráramos almacenar la temperatura de más días, tendríamos que modificar el código y añadir más variables. Para solucionar este problema, podemos usar las estructuras de datos de Python. Las 4 estructuras de datos más utilizadas en Python son:
\nLas listas son secuencias ordenadas de cero o más elementos. Los listas son un tipo de dato mutable, es decir, podemos modificiar, añadir o borrar elementos de la lista.
\n" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/ud_estructuras_datos/lista.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Podemos crear una lista de dos formas diferentes: mediante la función list() o mediante el uso de [ ] en la asignación a una variable. Veamos un ejemplo:
" }, { "metadata": {}, "cell_type": "markdown", "source": "Ejemplo: Creación de listas en Python.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Creación de listas de Python '''\n\n# Creación de una lista vacía mediante la función list()\nlista_uno = list()\n\n# Creación de una lista vacía mediante el operador [ ]\nlista_dos = [ ]\n\n# Creación de una lista con elementos de un mismo tipo de dato mediante el operador [ ]\nlista_tres = [2, 4, 7, 1, 2, 9]\n\n# Creación de una lista \nlista_cuatro = ['Hola', 2, 5.3, True, 'Mundo']\n\n# Podemos imprimir el contenido entero de una lista mediante la función print\nprint(lista_uno)\nprint(lista_dos)\nprint(lista_tres)\nprint(lista_cuatro)\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Como hemos podido ver, las listas admiten elementos de diferentes tipos de datos.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Crear dos listas, una lista vacía y otra lista con el nombre de 5 asignaturas que conozcas. Imprime el contenido de las listas utilizando la función print.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Crear dos listas en imprimir el contenido de dichas listas. '''\n\n# Crear aquí una lista vacía\nlista_vacia = \n\n# Crear una lista que contenga el nombre de 5 asignaturas\nlista_asignaturas = \n\n# Imprimir aquí el contenido de las dos listas\nprint()\nprint()\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "\nAnteriormente hemos visto que podemos imprimir el contenido de toda la lista mediante la función print pero ¿Y si necesitamos obtener un elemento en concreto de la lista?. Python proporciona la posibilidad de acceder a ellos mediante el operador [ ]. A continuación, vamos a crear una lista:
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "# Creación de una lista \nlista_ejemplo = ['Hola', 2, 5.3, True, 'Mundo']\n\n# Podemos imprimir el contenido entero de una lista mediante la función print\nprint(lista_ejemplo)", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "En la siguiente imagen podemos ver una representación gráfica de la lista, donde se especifican los índices para acceder a los elementos de la lista creda anteriormente:
" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/ud_estructuras_datos/ejemplo_lista.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Como podemos observar, tenemos dos formas de acceder a un elemento, mediante su índice o su índice inverso. Vamos a acceder al segundo elemento de la lista creada anteriormente de las dos formas:
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Acceso al segundo elemento de la lista \"lista_ejemplo\" ''' \n\n# Creación de una lista \nlista_ejemplo = ['Hola', 2, 5.3, True, 'Mundo']\n\nprint(lista_ejemplo[1]) # accedemos al segundo elemento de la lista con su índice\nprint(lista_ejemplo[-4]) # accedemos al segundo elemento de la lista con su índice inverso", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Podemos consultar el número de elementos de una lista mediante la función len de Python. Dicha función se puede utilizar con cualquier elemento iterable como listas, tuplas, conjuntos o cadenas de texto.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "len(lista_ejemplo)", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Un operador fundamental en el uso de estructuras de datos es el operador in. El operador in nos indica si un elemento se encuentra o no la estructura de datos que especifiquemos.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Acceso al segundo elemento de la lista \"lista_ejemplo\" ''' \n\n# Creación de una lista \nlista_ejemplo = ['Hola', 2, 5.3, True, 'Mundo']\n\nprint('Hola' in lista_ejemplo) # comprobamos si 'Hola' se encuentra en la lista\nprint( 5 in lista_ejemplo) # comprobamos si 5 se encuentra en la lista", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "En el siguiente ejercicio vamos a crear una lista con el nombre de 5 asignaturas diferentes. Después imprimiremos aquellas que se encuentran en posición impar mediante su indice normal y las que se encuentran en una posición par con su índice inverso.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Crea una lista que contenga los nombres de 5 comidas diferentes '''\n\ncomidas = []\n\n# Vamos a imprimir cada uno de los elementos\nprint( ) # el primer elemento mediante su índice normal\nprint( ) # el segundo elemento mediante su índice inverso\nprint( ) # el tercer elemento mediante su índice normal\nprint( ) # el cuarto elemento mediante su índice inverso\nprint( ) # el quinto elemento mediante su índice normal\n\n# Imprime el número de elementos que contiene la lista\n\n# Comprueba si 'pizza' se encuentra en la lista comidas\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "\nEs posible que tengamos la necesidad de obtener más de un elemento de una lista, es decir, una sublista. Una sublista es un conjunto de elementos más pequeño de la lista original.
" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/ud_estructuras_datos/ejemplo_sublista.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Para ello, Python permite indicar dentro del operador [ ] rangos de índices. A continuación, se muestra una imagen para describir las posibles características que se ofrecen:
" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/ud_estructuras_datos/slicing_dos_parametros.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Donde:
\nVeamos un ejemplo:
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Obteniendo diferentes sublistas a partir de una lista '''\n\ndeportes = [\"Fútbol\", \"Baloncesto\", \"Tenis\", \"Bádminton\", \"Balonmano\", \"Padel\", \"Rugby\"] # lista original\n\n# imprimimos la lista original\nprint(\"\\n Lista original \", deportes)\n\n# imprimimos los tres primeros deportes\nprint(\"\\n Los tres primeros deportes de la lista son \", deportes[0:3])\nprint(\" Los tres primeros deportes de la lista son \", deportes[-7:-4]) # En este caso, utilizamos los índices inversos\n\n# imprimimos los tres últimos deportes\nprint(\"\\n Los tres últimos deportes de la lista son \", deportes[4:7])\n\n# obtenemos la lista vacía si especificamos rangos cuyo valor final sea menor o igual que el inicial\nprint(\"\\n Obtenemos la lista vacía \", deportes[7:-4])\nprint(\" Obtenemos la lista vacía \", deportes[1:1])", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "¡CUIDADO! ya que si se nos olvida especificar el índice de inicio, Python da por sentado que estamos especificando el primer índice (0). Lo mismo ocurre con el índice final, si no se especifica, Python lo establece como el índice final de la lista.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Obteniendo diferentes sublistas a partir de una lista '''\n\ndeportes = [\"Fútbol\", \"Baloncesto\", \"Tenis\", \"Bádminton\", \"Balonmano\", \"Padel\", \"Rugby\"] # lista original\n\n# imprimimos la lista original\nprint(\"\\n Lista original \", deportes)\n\n# imprimimos los tres primeros deportes\nprint(\"\\n Los tres primeros deportes de la lista son \", deportes[:3])\n\n# imprimimos los tres últimos deportes\nprint(\"\\n Los tres últimos deportes de la lista son \", deportes[4:])\n\n# Si no especificamos nada, nos devolverá la lista original\nprint(\"\\n Obtenemos la lista original \", deportes[:])", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Como podemos observar, una vez especificados el índice inicial y el final, vamos incrementado el valor inicial hasta quedarnos en el índice fin - 1, pero ¿Y si queremos recorrer la lista al revés o hacer que el índice incremente de otra forma?. Entonces deberíamos indicar el incremento en la notación slice de la siguiente forma:
" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/ud_estructuras_datos/slicing_tres_parametros.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Donde:
\nEjemplo: Obtención de sublistas mediante la notación slice.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Obteniendo diferentes sublistas a partir de una lista '''\n\nasignaturas = [\"Historia\", \"Matemáticas\", \"Lengua\", \"Inglés\", \"Francés\", \"Informática\"] # lista original\n\n# imprimimos los deportes en una posición de índice impar\nprint(\"\\n Las asignaturas de la lista en una posición con índice impar son \", asignaturas[1::2])\n\n# imprimimos los deportes en una posicion de índice par\nprint(\"\\n Las asignaturas de la lista en una posición con índice par son\", asignaturas[::2])\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "De esta forma, tenemos una mayor flexibilidad para obtener sublistas, ya que nos permite incluso obtener una lista de forma inversa, realizando decrementos:
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Obteniendo diferentes sublistas a partir de una lista '''\n\nasignaturas = [\"Historia\", \"Matemáticas\", \"Lengua\", \"Inglés\", \"Francés\", \"Informática\"] # lista original\n\n# En esta ocasión realizaremos un decremento\nprint(\"\\n Las asignaturas en una posición impar de la lista son \", asignaturas[-2:-5:-1])", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "En este ejercicio vamos a trabajar con sublistas. Para ello, se proporciona una lista, sobre la cuál se deberán obtener las sublistas que se especifican.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Obtener las sublistas especificadas '''\n\n# Lista original\nvideojuegos = ['Batman: Arkham City', 'Pokémon', 'Phoenix Wright', 'Mario Kart', 'FIFA 19', 'Metal Gear V', 'Brain Training']\n\n# Nº1 Sublista que contenga los videojuegos en un índice de posición par\nprint(\"\\n La sublista nº1 es: \", )\n\n# Nº2 Sublista que contenga los videojuegos en un índice de posición par\nprint(\"\\n La sublista nº2 es: \", )\n\n# Nº3 Sublista que contenga los videojuegos en un índice de posición par\nprint(\"\\n La sublista nº3 es: \", )\n\n# Nº4 Sublista que los dos primeros elementos y los dos últimos\nprint(\"\\n La sublista nº4 es: \", )\n\n# Nº5 Sublista que contenga los videojuegos en un índice de posición impar\nprint(\"\\n La sublista nº5 es: \", )\n\n# Nº6 lista inversa a la original\nprint(\"\\n La lista inversa nº6 es: \", )\n\n# Nº7 Sublista que contenga los videojuegos con un índice impar negativo.\nprint(\"\\n La sublista nº7 es: \", )\n\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "\nLlegados a este punto, ya sabemos crear listas y obtener elementos de un lista. Además de eso, Python permite modificar elementos de una lista, añadiendo nuevos elementos a la lista o eliminar elementos de la misma.
" }, { "metadata": {}, "cell_type": "markdown", "source": "\nPara modificar un elemento de una lista, lo único que debemos hacer es asignar un valor a una posición indicada de la lista.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Modificando un elemento de una lista '''\n\n# Definimos una lista\nasignaturas = [\"Historia\", \"Matemáticas\", \"Lengua\", \"Inglés\", \"Francés\", \"Informática\"]\n\nprint(\"\\n\",asignaturas)\n\n# modificamos el primer elemento de la lista\nasignaturas[0] = \"Filosofía\"\n\nprint(\"\\n\",asignaturas)", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "En este ejercicio vamos a cambiar un elemento de nuestra lista de la compra.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Modificando elementos a una lista de la compra '''\n\n# lista de la compra para realizar una tortilla de patatas\nlista_compra = ['patatas', 'huevos', 'aceite de girasol', 'cebolla']\n\n'''\n Vamos a sustituir el aceite de girasol por el aceite de oliva, \n para ello, modificar el valor de la posición 2 de la lista\n'''\n\n\nprint() # imprimimos la lista de la compra ", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "\nPython proporciona los siguientes métodos para insertar elementos en una lista:
" }, { "metadata": {}, "cell_type": "markdown", "source": "| Método | \nDescripción | \n
|---|---|
| append(X) | \nAñade el elemento X al final de la lista. | \n
| insert(i,X) | \nAñade el elemento X en la posición i de la lista. | \n
Ejemplo: Añadir elementos a una lista creada.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Añadiendo elementos a una lista '''\n\n# Creamos una lista\nobjetos_mochila = ['portátil','cargador','libreta']\n\n# añadimos mediante el método append al final de la lista el elemento 'bolígrafo'\nobjetos_mochila.append('bolígrafo')\n\n# añadimos en la posición 0, es decir al principio, elemento 'libro'\nobjetos_mochila.insert(0,'libro')\n\nprint(objetos_mochila) # imprimimos la lista para ver el resultado final", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "En este ejercicio vamos a utilizar las funciones para insertar elementos en una lista, para ello, se deberán añadir los elementos que se especifican a la lista que se proporciona e imprimir una vez hayamos realizado dichas inserciones.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Añadiendo elementos a una lista de la compra '''\n\n# lista de la compra para realizar una tortilla de patatas\nlista_compra = ['patatas','huevos']\n\n# Se me olvidó apuntar el aceite de oliva, añadirlo mediante el uso de la función append\n\n# Un poco de cebolla no vendría mal, añade cebolla en una posición intermedia para que no se nos olvide\n\n\nprint() # imprimir la lista de la compra ", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "\nPython proporciona los siguientes métodos para insertar eliminar en una lista:
" }, { "metadata": {}, "cell_type": "markdown", "source": "| Método | \nDescripción | \n
|---|---|
| pop() | \nDevuelve y elimina el último elemento de la lista. | \n
| pop(i) | \nDevuelve el elemento en la posición i-ésima, es decir lista[i], y lo elimina de la lista. | \n
| clear() | \nElimina todos los elementos de la lista. | \n
Ejemplo: Eliminar elementos de una lista creada.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Eliminar elementos de una lista '''\n\n# Creamos una lista\nobjetos_mochila = ['portátil','cargador','libreta','bolígrafo','libro']\n\n\nobjetos_mochila.pop() # Eliminamos el último elemento de la lista\nobjetos_mochila.pop(1) # Eliminamos el elemento en la posición 1\n\nprint(\"\\n\",objetos_mochila) # imprimimos la lista para ver el resultado final\n\nobjetos_mochila.clear() # Eliminamos todos los elementos de la lista\n\nprint(\"\\n\",objetos_mochila) # imprimimos la lista para ver el resultado final\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "¡Vaya! Alguien ha modificado nuestra lista de la compra y ha añadido productos que no son necesarios para nuestra tortilla de patatas. Vamos a utilizar las funciones para eliminar elementos en una lista, para ello, se deberán añadir los elementos que se especifican a la lista que se proporciona e imprimir una vez hayamos realizado dichas inserciones.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Eliminando elementos a una lista de la compra '''\n\n# lista de la compra para realizar una tortilla de patatas\nlista_compra = ['macarrones', 'patatas', 'huevos', 'aceite de oliva', 'oreo', 'cebolla', ' ketchup']\n\n# Vamos a eliminar el último elemento de la lista, para ello, utilizaremos el metodo pop()\n\n# Ahora utilizaremos la variante pop(i) para eliminar los elementos en la posición 1 y 4\n\nprint() # imprimimos la lista de la compra \n\n# Acabamos de terminar de realizar la compra, borra todos los elementos de la lista", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "\nLas tuplas son secuencias ordenadas de cero o más elementos. La única diferencia respecto a las lista es que una tupla es inmutable. Esto implica que una vez creada la tupla, no podemos modificar su contenido.
\n" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/ud_estructuras_datos/tupla.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Existen diferentes formas para crear tuplas. Las más usuales son utilizando la función tuple,mediante un conjunto de elementos separados por comas dentro de paréntesis ( ) o un conjunto de elementos separados por comas.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Ejemplo: Creación de tuplas en Python.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Creación de tuplas de Python '''\n\n# Creación de una tupla vacía mediante la función tuple()\ntupla_uno = tuple()\n\n# Creación de una tupla vacía mediante el operador [ ]\ntupla_dos = ()\n\n# Creación de una tupla con elementos de un mismo tipo de dato mediante el operador ()\ntupla_tres = (2, 4, 7, 1, 2, 9)\n\n# Creación de una tupla \ntupla_cuatro = ('Hola', 2, 5.3, True, 'Mundo')\n\n# creación de una tupla \ntupla_cinco = 'Hola',3,2,5,1,'Mundo'\n\n# Podemos imprimir el contenido entero de una lista mediante la función print\nprint(tupla_uno)\nprint(tupla_dos)\nprint(tupla_tres)\nprint(tupla_cuatro)\nprint(tupla_cinco)", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "¡Cuidado! si queremos crear una tupla utilizando paréntesis con un solo elemento, debemos añadir una coma.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Creación de tuplas de Python '''\n\n# Creación de una tupla vacía mediante la función list()\ntupla_uno = (5,)\n\n# Creación de una tupla vacía mediante el operador [ ]\ntupla_dos = (8)\n\n# Podemos imprimir el contenido entero de una lista mediante la función print\nprint(tupla_uno, \"es de tipo \", type(tupla_uno))\nprint(tupla_dos, \"es de tipo \", type(tupla_dos))\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Como podemos observar, si no añadimos una coma dentro del paréntesís, al crear una tupla de un elemento, Python interpreta que se trata solamente de un número entero. He ahí la importancia de la coma.
" }, { "metadata": {}, "cell_type": "markdown", "source": "En este ejercicio vamos a crear varias tuplas. Para ello completar el código que se propone a continuación:
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Completar el código para crear las tuplas que se proponen '''\n\n# Crear una tupla vacía\ntupla_vacia = \n\n# Crear una tupla con un elemento que contenga el nombre de tu comida favorita\ncomida_favorita =\n\n# Crear una tupla que contenga los ingredientes que más te gustan en una pizza\ningredientes_favoritos =\n\n# Imprimir las tuplas\nprint()\nprint()\nprint() ", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "\nAl igual que ocurre con las listas, Python proporciona la posibilidad de acceder a ellos mediante el operador []. A continuación, vamos a crear una lista:
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "mi_tupla = ('Hola', 'Mundo', 2.3, 7.3, 'Mundo')\n\nprint(mi_tupla)", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "En la siguiente imagen podemos ver una representación gráfica de la tupla, donde se especifican los índices para acceder a los elementos de la lista creda anteriormente:
" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/ud_estructuras_datos/recorrer_tupla.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Como podemos observar, tenemos dos formas de acceder a un elemento, mediante su índice o su índice inverso. Vamos a acceder al segundo elemento de la lista creada anteriormente de las dos formas:
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Acceso al segundo elemento de la lista \"lista_ejemplo\" ''' \n\nmi_tupla = ('Hola', 'Mundo', 2.3, 7.3, 'Mundo')\n\nprint(mi_tupla[1]) # accedemos al segundo elemento de la lista con su índice\nprint(mi_tupla[-4]) # accedemos al segundo elemento de la lista con su índice inverso", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Podemos consultar el número de elementos de una tupla mediante la función len() de Python. Dicha función se puede utilizar con cualquier elemento iterable como listas, tuplas, conjuntos o cadenas de texto.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "mi_tupla = ('Hola', 'Mundo', 2.3, 7.3, 'Mundo')\n\nlen(mi_tupla) # devuelve el número de elementos de la tupla", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Un operador fundamental en el uso de estructuras de datos es el operador in. El operador in nos indica si un elemento se encuentra o no la estructura de datos que especifiquemos.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "mi_tupla = ('Hola', 'Mundo', 2.3, 7.3, 'Mundo')\n\nesta = 5 in mi_tupla\n\nprint(esta)", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Al igual que pasaba con las listas, es posible que tengamos la necesidad de obtener más de un elemento de una tupla, es decir, una subtupla. Una subtupla es un conjunto de elementos más pequeño de la tupla original. Para ello, utilizaremos la notación slice con las tuplas de la misma forma que con las listas.
" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/ud_estructuras_datos/slice_tupla.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Donde:
\nEjemplo: Obtener subtuplas a partir de una tupla.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Obteniendo diferentes subtuplas a partir de una tupla '''\n\nasignaturas = (\"Historia\", \"Matemáticas\", \"Lengua\", \"Inglés\", \"Francés\", \"Informática\") # Tupla original\n\n# imprimir las asignaturas Matemáticas, Lengua e Inglés\nprint(\"\\n Imprimir las asignaturas Matemáticas, Lengua e Inglés: \", asignaturas[1:4])\n\n# imprimimos los deportes en una posición de índice impar\nprint(\"\\n Las asignaturas de la tupla en una posición con índice impar son: \", asignaturas[1::2])\n\n# imprimimos los deportes en una posicion de índice par\nprint(\"\\n Las asignaturas de la tupla en una posición con índice par son: \", asignaturas[::2])\n\n# imprimimos tupla al revés\nprint(\"\\n La tupla al revés: \", asignaturas[::-1])", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "En este ejercicio vamos a utilizar la funcionalidad vista anteriormente acerca del acceso a elementos de una tupla. Para ello, completa el código siguiendo las instrucciones.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Tuplas y notación slice '''\n\n# tupla_original\nnumeros = (1,2,3,4,5,6,7,8,9,10)\n\n# Imprimir los elementos que se encuentra en la posición 4 y -4\nprint( )\nprint( )\n\n# Asignarle a pares los elementos pares de tupla original utilizando la notación slice\npares = \n\n# Asignarles a impares los elementos impares de la tupla original en orden descendente utilizando la notacion slice\nimpares =\n\n# Comprueba si 5 se encuentra contenido en pares\nencontrado = \nprint(encontrado)\n\n# Imprime el número de elementos que contiene pares e impares\nprint()\nprint()\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "\nLos conjuntos son colecciones desordenadas de cero o más elementos. Al igual que las listas, son un tipo de dato mutable. Esto implica que una vez creado el conjunto podemos modificar, añadir y eliminar elementos de nuestro conjunto. Cabe destacar que los conjuntos no admiten repeticiones.
\n" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/ud_estructuras_datos/ejemplo_conjunto.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Podemos crear un conjunto vacío con la función set o crear un conjunto que contenga elementos mediante una sucesión de elementos separados por comas dentro de los operadores { }.
\n" }, { "metadata": {}, "cell_type": "markdown", "source": "Ejemplo: Creación de conjuntos en Python
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Creación de conjuntos en Python '''\n\na = set() # Con set() podemos crear un conjunto vacío\n\nb = {1,2,3,4,5,6,7,8,9,10} # conjunto que contiene los números del 1 al 10\n\nc = {\"hola\", 2, 3.4, True} # conjunto con diferentes tipos de datos\n\nd = {1,7,1,7,5,2,2,6,3,3} # conjunto con repeticiones, las cuales serán eliminadas\n\n# imprimimos los diferentes conjuntos\nprint(a)\nprint(b)\nprint(c)\nprint(d)\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "En este caso, no podemos crear un conjunto vacío mediante el uso de llaves { }, ya que Python lo interpreta como la creación de un diccionario.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Creación de conjuntos en Python '''\n\na = set() # Con set() podemos crear un conjunto vacío\n\nb = {} # diccionario vacío\n\n# imprimimos el tipo de dato de cada variable\nprint(\"a es del tipo \", type(a))\nprint(\"b es del tipo \", type(b))\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Al igual que con las listas y las tuplas, utilizamos el método len( ) para comprobar el número de elementos que componen el conjunto y el operador in para comprobar si un elemento pertenece al conjunto.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Elementos de un conjunto '''\n\nc = {\"hola\", 2, 3.4, True} # conjunto con diferentes tipos de datos\nd = {1,7,1,7,5,2,2,6,3,3} # conjunto con repeticiones, las cuales serán eliminadas\n\nesta = True in c # comprobamos si el elemento True se encuentra en el conjunto\nesta_dos = 8 in d # comprobamos si el elemento 8 se encuentra en el conjunto\n\n# imprimimos los conjuntos y el número de elementos de cada uno\nprint(c)\nprint(d)\nprint(\"El número de elementos del conjunto c es: \", len(c))\nprint(\"El número de elementos del conjunto d es: \", len(d))\nprint(esta)\nprint(esta_dos)\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "En este ejercicio vamos a utilizar las funcionalidades vistas anteriormente. Para ello, completa el código siguiendo las instrucciones.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Creación de conjuntos '''\n\n# Crear dos conjuntos, uno vacío y otro con 6 nombre de personas\n\nconjunto_vacio = {}\npersonas = {'pepe','maría'}\n\n# Imprimir los conjuntos creados anteriormente\nprint(conjunto_vacio)\nprint(personas)\n# Imprimir el número de elementos de cada uno de los conjuntos\n\n# Comprobar si el nombre 'Pablo' se encuentra en el conjunto personas\n\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "\nPython proporciona los siguientes métodos para insertar y eliminar elementos en un conjunto:
" }, { "metadata": {}, "cell_type": "markdown", "source": "| Método | \nDescripción | \n
|---|---|
| add(x) | \nAñade el elemento x al conjunto si no se encuentra. | \n
| discard(x) | \nElimina el elemento x del conjunto. | \n
| clear() | \nElimina todos los elementos del conjunto. | \n
Ejemplo: Añadiendo y elemento elementos del conjunto
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Añadiendo y eliminando elementos del conjunto '''\n\nconjunto_asignaturas = {'Matemáticas', 'Lengua', 'Inglés'}\n\nprint(\"\\n\",conjunto_asignaturas)\n\n# Añadimos un nuevo elemento 'Francés' 'Informática' y 'Matemáticas'\nconjunto_asignaturas.add('Francés')\nconjunto_asignaturas.add('Informática')\nconjunto_asignaturas.add('Matemáticas')\n\nprint(\"\\n\",conjunto_asignaturas)\n\n# Eliminamos las asignaturas 'Lengua', 'Inglés' e 'Historia'\nconjunto_asignaturas.discard('Lengua')\nconjunto_asignaturas.discard('Inglés')\nconjunto_asignaturas.discard('Historia')\n\nprint(\"\\n\",conjunto_asignaturas)\n\n# Eliminamos todos los elementos del conjunto\nconjunto_asignaturas.clear()\nprint(\"\\n\",conjunto_asignaturas)\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "En este ejercicio vamos a poner en prueba los métodos para añadir y eliminar elementos de un conjunto. Para ello, completa el código del siguiente ejercicio.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Añadiendo y eliminado elementos del conjunto '''\n\na = {2,4,6,7,8,10}\n\n# Añadir al conjunto a los elementos 1,5,11\n\n# Imprimir el conjunto\n\n# Eliminar del conjunto los elementos 2,6,10\n\n# Imprimir el conjunto\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "\nPython proporciona métodos y operadores para realizar operaciones con conjuntos. En este apartado veremos las tres operaciones más usadas con conjuntos: unión, intersección y diferencia.
\n" }, { "metadata": {}, "cell_type": "markdown", "source": "\nSean A y B dos conjuntos, se define el conjunto A unión B como un nuevo conjunto donde tenemos todos los elementos del conjunto A junto con los elementos del conjunto B que no se encuentran en A.
" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/ud_estructuras_datos/union_conjuntos.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "En Python, utilizamos el operador | para realizar la unión de conjuntos.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Ejemplo: Unión de dos conjuntos.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Unión de conjuntos '''\n\n# Definimos los conjuntos\nA = {'a','b','c','d','e'}\nB = {'a','e','i','o','u'}\n\nC = A | B # calculamos la unión de los dos conjuntos\n\nprint(C) # Imprimimos el conjunto C", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "\nSean A y B dos conjuntos, se define el conjunto A intersección B como un nuevo conjunto donde tenemos todos los elementos del conjunto A que aparecen también en el conjunto B.
" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/ud_estructuras_datos/interseccion_conjuntos.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "En Python, utilizamos el operador & para realizar la intersección de conjuntos.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Ejemplo: Intersección de dos conjuntos.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Intersección de conjuntos '''\n\n# Definimos los conjuntos\nA = {'a','b','c','d','e'}\nB = {'a','e','i','o','u'}\n\nC = A & B # calculamos la intersección de los dos conjuntos\n\nprint(C) # Imprimimos el conjunto C", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "\nSean A y B dos conjuntos, se define el conjunto A diferencia B como un nuevo conjunto donde tenemos todos los elementos del conjunto A que no aparecen en el conjunto B. Cuidado con esta operación, ya que A diferencia B es distinto a B diferencia A.
" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/ud_estructuras_datos/diferencia_conjuntos.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "En Python, utilizamos el operador - para realizar la diferencia de conjuntos.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Ejemplo: Diferencia de dos conjuntos.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Diferencia de conjuntos '''\n\n# Definimos los conjuntos\nA = {'a','b','c','d','e'}\nB = {'a','e','i','o','u'}\n\nC = A - B # calculamos la diferencia de los dos conjuntos\nD = B - A # calculamos la diferencia de los dos conjuntos\n\nprint(C) # Imprimimos el conjunto C\nprint(D) # Imprimimos el conjunto D", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "En este ejercicio vamos a probar las operaciones de unión, intersección y diferencia de conjuntos. Para ello, se proponen dos conjuntos de números, los cuales deberá rellenar y realizar las operaciones que se indican.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Completa el código del ejercicio '''\n\n# Crear un conjunto que contenga los múltiplos de 2 del 0 al 10\nA = {}\n\n# Crear un conjunto que contenga los múltiplos de 3 del 0 al 10\nB = {}\n\n# Completa la sentencia para imprimir el conjunto A union B\nprint(\"\\n La unión de los conjunto A y B es: \", )\n\n# Completa la sentencia para imprimir el conjunto A union B\nprint(\"\\n La intersección de los conjunto A y B es: \", )\n\n# Completa la sentencia para imprimir el conjunto A union B\nprint(\"\\n La diferencia del conjunto A respecto B es: \", )\n\n# Completa la sentencia para imprimir el conjunto B diferencia A\nprint(\"\\n La diferencia del conjunto B respecto A es: \", )", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "\nEn Python, un diccionario es un conjunto de claves que tienen asociados diversos valores al igual que un diccionario convencional. Cada clave tendrá asociado un valor o conjunto de valores, que no tiene por que ser del mismo tipo de dato que los otros valores asociados a las claves. Cabe destacar que los diccionarios no tienen un orden establecido, ya que sus valores los obtenemos mediante la clave y no mediante la posición que ocupan.
" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/ud_estructuras_datos/ejemplo_diccionario.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "En Python, para definir un diccionario, utilizamos llaves { } y dentro, pares de claves y valores que contendrá el diccionario. También podemos crear un diccionario mediante la función dict(). Veamos un ejemplo de uso.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Ejemplo: Creación de diccionarios.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Definimos un diccionario donde cada clave es el año de estreno y el valor la película '''\n\ndiccionario_vacio = dict() # Creación de un diccionario vacío\n\ndiccionario_vacio_2 = {} # Creación de un diccionario vacío\n\npeliculas = {'2013': 'Iron man 3',\n '2011': 'Thor', \n '2016': 'Dr. Strange', \n '2019': 'Capitana Marvel' \n }\n\nprint(diccionario_vacio)\nprint(diccionario_vacio_2)\nprint(peliculas)", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "En este ejercicio vamos a poner en práctica las diferentes maneras de crear un diccionario. Para ello, completa el código del siguiente ejercicio.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Creación de diccionarios '''\n\n# Crear un diccionario vacío \n\ndiccionario_vacio =\n\n\n''' Crear un diccionario que contenga las claves y valores \n 'C1' tendrá asociado el valor 5\n 'C2' tendrá asociado la cadena 'Hola'\n 'C3' tendrá asociado la cadena 'Mundo'\n 'C4' tendrá asociado la lista [1,2,3,4,5,6,7,8,9,10] \n'''\n\ndiccionario = {\n\n}\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Python proporciona métodos para gestionar de forma sencilla nuestros diccionarios. A continuación se muestran los métodos más utilizados para la gestión de diccionarios:
" }, { "metadata": {}, "cell_type": "markdown", "source": "| Método | \nDescripción | \n
|---|---|
| get('clave') | \nDevuelve el valor asociado a la clave introducida. | \n
| pop('clave') | \nDevuelve el valor asociado a la clave introducida y elimina la entrada en el diccionario. | \n
| update({'clave': 'valor'}) | \nSi la clave ya existe en el diccionario, actualiza su valor asociado. En otro caso, crea una nueva entrada | \n
Podemos obtener el valor asociado a una clave mediante el uso del método get o llamando al diccionario con el operador [ ] y la clave dentro.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Obteniendo valores del diccionario '''\n\npeliculas = {'2011': 'Thor', \n '2013': 'Iron man 3', \n '2016': 'Dr. Strange', \n '2019': 'Capitana Marvel' \n }\n\n# Vamos a obtener valores del diccionario\n\nprint( peliculas.get('2011') ) # Muestra como salida la cadena Thor\n\nprint( peliculas['2016'] ) # Muestra como salida Dr. Strange", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "La diferencia entre ambas formas radica en que pop borra la entrada que ha devuelto, mientras que get no la borra. Si la clave proporcionada no existiese en el diccionario mientras que el método get devolvería el valor None, el método pop devolvería un KeyError.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "print( peliculas.get('2011') ) # Muestra como salida la cadena Thor", "execution_count": null, "outputs": [] }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "print( peliculas['2016'] ) # Muestra como salida Dr. Strange", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Podemos añadir o actualizar el contenido de nuestro diccionario utilizando el método update o asignandole a una clave directamente y un valor.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Ejemplo: Añadiendo y actualizando elementos de un diccionario
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Añadiendo y actualizando elementos de un diccionario '''\n\npeliculas = {'2011': 'Thor', \n '2013': 'Iron man 3', \n '2016': 'Dr. Strange', \n '2019': 'Capitana Marvel' \n }\n\nprint(\"\\n\",peliculas) # imprimimos el contenido del diccionario\n\n# Vamos a obtener valores del diccionario\n\npeliculas.update({'2008':'Iron Man'}) # Insertamos un nuevo valor y clave\npeliculas['2014'] = 'Guardianes de la Galaxia' # Insertamos un nuevo valor y clave\n\nprint(\"\\n\",peliculas) # imprimimos el contenido del diccionario\n\npeliculas.update({'2008':'El increible Hulk'}) # Actualizamos la clave 2008 con el valor nuevo\npeliculas['2019'] = 'Avengers 4: Endgame' # Actualizamos la clave 2019 con el valor nuevo\n\nprint(\"\\n\",peliculas) # imprimimos el contenido del diccionario", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Podemos añadir o actualizar el contenido de nuestro diccionario utilizando el método pop.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Ejemplo: Eliminando elementos de un diccionario
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Eliminando elementos de un diccionario '''\n\npeliculas = {\n '2011': 'Thor', \n '2013': 'Iron man 3', \n '2016': 'Dr. Strange', \n '2019': 'Avengers 4: Endgame', \n '2008': 'El increible Hulk', \n '2014': 'Guardianes de la Galaxia'}\n\nprint(\"\\n\",peliculas) # imprimimos el contenido del diccionario\n\n# Eliminamos la clave 2008 y 2014\npeliculas.pop('2014')\npeliculas.pop('2008')\n\nprint(\"\\n\",peliculas) # imprimimos el contenido del diccionario\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "En este ejercicio vamos a poner en práctica los diferentes métodos que permiten gestionar un diccionario en Python. Para ello, completa el código del siguiente ejercicio.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "''' Trabajando con diccionarios '''\n\npremios_BAFTA = {\n '2003-2004' = 'Half-life 2',\n '2007-2008' = 'Super Mario Galaxy',\n '2009' = 'Batman Arkham Asylum',\n '2013' = 'The Last of Us',\n '2016' = 'Uncharted 4'\n}\n\n\n## Añadir a nuestro diccionario la clave '2018' con el valor asociado 'God of War'\n\n\n## Consultar mediante el método get el valor de la clave 2007-2008\n\n\n## Eliminar aquellos elementos del diccionario cuya clave sea menor al 2005\n\n\n## Modificar el contenido de la clave 2016 para que sea igual a Uncharted 4: A Thief`s End\n\n\n## Imprimir el diccionario\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "\n![](\"./images/resumen.jpg\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Una vez terminado el cuaderno, vamos a realizar un pequeño resumen acerca de lo visto hasta ahora:
\n![](\"./images/ejercicios.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "EJERCICIO 1: ¿Sabrías decir cuál es la salida del siguiente código sin ejecutarlo?.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "## Elimina las comillas para ejercutar el código y comprobar el resultado de salida.\n'''\n\nmi_lista = list()\nmi_tupla = tuple()\nmi_conjunto = set()\nmi_diccionario = dict()\n\nprint(mi_lista)\nprint(mi_tupla)\nprint(mi_conjunto)\nprint(mi_diccionario)\n\n'''", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "EJERCICIO 2: ¿Sabrías decir cuál es la salida del siguiente código sin ejecutarlo?.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "## Elimina las comillas para ejercutar el código y comprobar el resultado de salida.\n'''\n\nestructura = {}\n\nprint(estructura)\nprint(\"\\n\",type(estructura))\n\n'''", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "EJERCICIO 3: ¿Sabrías decir cuál es la salida del siguiente código sin ejecutarlo?.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "## Elimina las comillas para ejercutar el código y comprobar el resultado de salida.\n'''\n\nmi_lista = [1,2,3,4,5,6,7,8,9,10]\nmi_tupla = ('a','c','u','r','r','u','c','a')\n\nprint(mi_lista[::2])\nprint(mi_lista[2::3])\n\nprint(mi_tupla[::])\nprint(mi_tupla[-1:-9:-1])\n\n'''", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "EJERCICIO 4: ¿Sabrías decir cuál es la salida del siguiente código sin ejecutarlo?.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "## Elimina las comillas para ejercutar el código y comprobar el resultado de salida.\n'''\n\nprimos = {1, 2, 3, 5, 7, 11, 13, 17}\n\nprimos.add(19)\nprimos.add(23)\nprimos.discard(2)\nprimos.discard(1)\n\nprint(\"\\n\",primos)\nprint(\"\\n\",type(primos))\n\n'''", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "EJERCICIO 5: Realiza cambios en el la notación slice para imprimir los múltiplos de 3 mayores que o iguales que 10 y menores que 22.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "## La salida debería ser [12,15,18,21]\n\nmultiplos_3 = (0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30)\n\nprint(multiplos_3[::])\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "EJERCICIO 6: Realiza cambios en el la notación slice para imprimir la lista de elementos en orden decreciente situados en índice impar" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "## La salida debería ser [23,17,11,5,2]\nprimos = (1, 2, 3, 5, 7, 11, 13, 17, 19, 23)\n\nprint(primos[::2])", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "
EJERCICIO 7: Crear un diccionario donde la clave será el nombre del país y el valor asociado una lista con las 3 comidas típicas del país. Busca información acerca de la comida de los siguientes países y añadelos en el diccionario: España, Portugal, Francia e Italia.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "", "execution_count": null, "outputs": [] } ], "metadata": { "kernelspec": { "name": "python3", "display_name": "Python 3", "language": "python" }, "language_info": { "mimetype": "text/x-python", "nbconvert_exporter": "python", "name": "python", "pygments_lexer": "ipython3", "version": "3.5.4", "file_extension": ".py", "codemirror_mode": { "version": 3, "name": "ipython" } } }, "nbformat": 4, "nbformat_minor": 2 }