Tutorial de Python para Machine Learning II - Secuencias, Sets y Diccionarios

Publicado por @SpainML el Nov. 25, 2019, 11:20 p.m.
Esta es la segunda entrega de la serie de tutoriales sobre Python. Puedes encontrar la primera entrega en la que hablamos de tipos simples [aquí][1]. Una vez conocemos los booleanos, los números y las strings, es hora de pasar a las secuencias (aunque ya las conocemos en parte realmente del apartado anterior por medio de las strings :D ). Una vez conozcamos las secuencias, pasaremos a los sets y por último a los diccionarios. Si necesitas ayuda o tienes cualquier sugerencia, escríbenos por [Slack][2] o en el apartado de [contacto][3]. ## Secuencias Dentro de las secuencias, nos podemos encontrar con lists, tuples y ranges. En esta subsección vamos a ver cómo funcionan y cómo operar con ellas. ### Lists Las listas son secuencias de valores ordenadas y mutables, es decir, importa la posición de cada elemento de la secuencia y son modificables (se pueden insertar, actualizar, o eliminar valores). Podemos definirlas utilizando los corchetes []. ```python In[1] [1,2,3,4] ``` *`Out[1] [1, 2, 3, 4]`* Pueden contener elementos de distintos tipos como en el siguiente ejemplo. ```python In[2] [1,"a","b",2] ``` *`Out[2] [1, 'a', 'b', 2]`* E incluso, se pueden crear listas dentro de otras listas. ```python In[3] [[1,2],[3,4]] ``` *`Out[3] [[1, 2], [3, 4]]`* ```python In[4] type([1,"a","b",2]) ``` *`Out[4] list`* ```python In[5] type([1,"a","b",2]) ``` *`Out[5] list`* ```python In[6] type([[1,2],[3,4]]) ``` *`Out[6] list`* Uno de los métodos más útiles es len, que devuelve la longitud de la lista. ```python In[7] len([1,"a","b",2]) ``` *`Out[7] 4`* #### Operaciones Vamos a ver una serie de operaciones que seleccionan, modifican u ordenan las listas. ```python In[8] example_list = [1,2,3,4,5,6] ``` El siguiente operador sirve para seleccionar los elementos que empiezan en el primer índice de dentro de los corchetes, y acaban en el último índice de dentro de los corchetes sin incluir, es decir, en este caso nos quedamos con las posiciones 0, 1 y 2. Sí, los índices empiezan con el 0. ```python In[9] example_list[0:3] ``` *`Out[9] [1, 2, 3]`* En este otro ejemplo nos quedamos con las posiciones 3, 4 y 5. Como hemos dicho antes la primera posición está en el índice 0, por lo tanto en esta lista teníamos las posiciones 0,1,2,3,4,5 asociadas a los enteros 1,2,3,4,5,6. ```python In[10] example_list[3:6] ``` *`Out[10] [4, 5, 6]`* La concatenación de listas se puede realizar fácilmente con el operador +. ```python In[11] example_list + [4,5,6] ``` *`Out[11] [1, 2, 3, 4, 5, 6, 4, 5, 6]`* Otra forma de definir listas es con el método list(). Para introducir elementos utilizamos el método append(), que va añadiendo los elementos al final de la lista. ```python In[12] empty_list = list() empty_list.append(1) print(empty_list) ``` *`Out[12] [4]`* Partiendo del ejemplo de más arriba, vemos cómo con append el 7 se va al final de la lista. ```python In[13] example_list.append(7) print(example_list) ``` *`Out[13] [1, 2, 3, 4, 5, 6, 7]`* También podemos eliminar el último elemento con el método pop(). ```python In[14] example_list.pop() print(example_list) ``` *`Out[14] [1, 2, 3, 4, 5, 6]`* También nos habría valido utilizar remove() si hubiésemos querido quitar el elemento con valor 7. ```python In[15] example_list = [1,2,3,4,5,6,7] example_list.remove(7) print(example_list) ``` *`Out[15] [1, 2, 3, 4, 5, 6]`* Otra opción hubiese sido usar del. Aquí hemos utilizado la indexación con número negativo, siendo el -1 el último valor de la lista. ```python In[16] example_list = [1,2,3,4,5,6,7] del example_list[-1] print(example_list) ``` *`Out[16] [1, 2, 3, 4, 5, 6]`* Si quisiésemos insertar el 7 en la posición 1, utilizaríamos insert(). ```python In[17] example_list.insert(1,7) print(example_list) ``` *`Out[17] [1, 7, 2, 3, 4, 5, 6]`* En cuanto a las funciones de ordenado, podemos voltear la lista con reverse(). ```python In[18] example_list.reverse() print(example_list) ``` *`Out[18] [6, 5, 4, 3, 2, 7, 1]`* O también podemos ordenarlas con sort(). ```python In[19] example_list.sort() print(example_list) ``` *`Out[19] [1, 2, 3, 4, 5, 6, 7]`* Si queremos hacer un update de algún valor en concreto, lo hacemos con la notación con corchetes y asignando el valor deseado. ```python In[20] example_list[0] = 7 print(example_list) ``` *`Out[20] [7, 2, 3, 4, 5, 6, 7]`* En caso de querer comprobar que la lista contiene un valor, utilizamos in. ```python In[21] 2 in example_list ``` *`Out[21] True`* Por último, para obtener el valor de la lista en un índice concreto, usarmos index(). ```python In[22] example_list.index(2) ``` *`Out[22] 1`* ### Tuples Las tuplas son secuencias inmutables, por lo que no se pueden actualizar con los métodos insert(), pop(), remove() ó append(), pero se pueden convertir en listas con el método list() (y las listas en tuplas con tuple()). Su ventaja sobre las listas es la rapidez. Se definen entre paréntesis () y tienen un uso muy similar a las listas: ```python In[23] (1,2) ``` *`Out[23] (1, 2)`* ```python In[24] type((1,2)) ``` *`Out[24] tuple`* ```python In[25] type(("a",1)) ``` *`Out[25] tuple`* ```python In[26] ex_tuple = (1,2,3) ``` ```python In[27] ex_tuple[0] ``` *`Out[27] 1`* ### Range Los rangos son secuencias inmutables de números. Se construyen de dos formas: o bien indicando el punto de inicio, el punto de parada (sin incluir) y el paso, o bien indicando únicamente el punto de parada. Cuando no se especifica el punto de inicio, se asume que es 0. En el caso de no especificarse el paso, se asume que es 1 por defecto. Esta es la forma más simplificada de construir usar range(). ```python In[28] range(5) ``` *`Out[28] range(0, 5)`* Si lo transformamos a lista, vemos que empieza en 0, tiene un salto de 1 y acaba en 4 (el entero anterior a 5). ```python In[29] list(range(5)) ``` *`Out[29] [0, 1, 2, 3, 4]`* ```python In[30] type(range(5)) ``` *`Out[30] range`* En este caso vamos del 1 al 7 (sin incluir) con un salto de 2. ```python In[31] range(1,7,2) ``` *`Out[31] range(1, 7, 2)`* Efectivamente, eso resulta en los números 1, 3 y 5. ```python In[32] list(range(1,7,2)) ``` *`Out[32] [1, 3, 5]`* Este ejemplo es el mismo que el que vimos al principio del todo con range(5). ```python In[33] list(range(0,5,1)) ``` *`Out[33] [0, 1, 2, 3, 4]`* Y acabamos con otro caso más, por si no estaba claro del todo. ```python In[34] list(range(2,10,3)) ``` *`Out[34] [2, 5, 8]`* ## Sets Los sets son colecciones de objetos sin ordenar. Pueden ser mutables o inmutables (set vs frozenset). Podemos crear uno vacío de la siguiente forma. ```python In[35] empty_set = set() print(empty_set) ``` *`Out[35] set()`* Para añadir un elemento, usamos la función add. ```python In[36] empty_set.add(0) print(empty_set) ``` *`Out[36] {0}`* ```python In[37] empty_set.add(1) print(empty_set) ``` *`Out[37] {0, 1}`* Si ahora volvemos a añadir el 0, no ocurre nada ya que el 0 ya se encontraba en el set. Esta es una de las grandes diferencias con respecto a las secuencias. ```python In[38] empty_set.add(0) print(empty_set) ``` *`Out[38] {0, 1}`* Si creamos un set a partir de una lista con elementos repetidos, aparecerán en el set los mismos elementos pero una única vez. ```python In[39] aux_list = [1,1,2,2,3,4] set(aux_list) ``` *`Out[39] {1, 2, 3, 4}`* ## Dictionaries Los diccionarios son colecciones sin ordenar, mutables e indexadas. Se definen con pares clave-valor como vemos en este ejemplo, utilizando los corchetes {}. ```python In[40] example_dict = {"a":1,"b":2,"c":3} type(example_dict) ``` *`Out[40] dict`* Podemos obtener el valor de cualquier clave contenida en el diccionario accediendo con []. ```python In[41] example_dict["a"] ``` *`Out[41] 1`* Para actualizar el valor asociado a una clave, procedemos como en el siguiente ejemplo. ```python In[42] example_dict["a"] = 2 print(example_dict) ``` *`Out[42] {'a': 2, 'b': 2, 'c': 3}`* Además de strings, enteros o booleanos, podemos crear diccionarios anidados. ```python In[43] example_dict["b"] = {"d":4} print(example_dict) ``` *`Out[43] {'a': 2, 'b': {'d': 4}, 'c': 3}`* Otra forma de definirlos es crearlos vacíos, y posteriormente ir rellenándolos. ```python In[44] new_dict = {} ``` ```python In[45] new_dict[1] = "a" new_dict[2] = "b" new_dict["c"] = 3 print(new_dict) ``` *`Out[45] {1: 'a', 2: 'b', 'c': 3}`* Si queremos acceder a todas las claves del diccionario utilizamos keys(). ```python In[46] new_dict.keys() ``` *`Out[46] dict_keys([1, 2, 'c'])`* Por último, para sacar todos los valores, utilizamos values(). ```python In[47] new_dict.values() ``` *`Out[47] dict_values(['a', 'b', 3])`* [1]: https://spainml.com/blog/tutorial-de-python-para-machine-learning-i-tipos-simples/ [2]: http://bit.ly/JoinSpainML [3]: https://spainml.com/contacto [4]: https://spainml.com/contacto