Alfonso de la Guarda Reyes avatar Alfonso de la Guarda Reyes committed e01e901

Correcciones en Cap. 3

Comments (0)

Files changed (1)

 Colecciones
 -----------
 
-En el capítulo anterior vimos algunos tipos básicos, como los 
-números, las cadenas de texto y los booleanos. En esta lección 
-veremos algunos tipos de colecciones de datos: listas, tuplas y 
-diccionarios.
+
+Consideraciones
+~~~~~~~~~~~~~~~
+
+Los conjuntos de datos o *colecciones*, como se denomina este 
+capítulo, son posiciones de memoria que a través de 
+*identificadores* permiten almacenar múltiples valores.  Esto nos 
+permite organizar datos a partir de un único conjunto, por ejemplo: 
+cómo haríamos para crear un conjunto de números pares? Bueno! 
+Simplemente empleamos un *identificador* y dentro de este ponemos 
+los números con estas características.
+
+Ahora, cada lenguaje tiene particularidades en este punto y la 
+manera de crear estos conjuntos cambia según sus especificaciones, 
+sin embargo, siempre tendremos un resultado: un grupo de valores.
+
+Python, al ser multi-paradigma, hace mucho uso de las *colecciones* 
+y sin lughar a dudas, no existe programa *pythonico* que no haga uso 
+extensivo de este recurso.  Lo cierto es que su enfoque *funcional* 
+prácticamente nos obliga a aprovecharnos de estas (*colecciones*).
 
 
 Listas
-La lista es un tipo de colección ordenada. Sería equivalente a lo 
-que en otros lenguajes se conoce por arrays, o vectores.  Las listas 
-pueden contener cualquier tipo de dato: números, cadenas, booleanos, 
-… y también listas.  Crear una lista es tan sencillo como indicar 
-entre corchetes, y separa- dos por comas, los valores que queremos 
-incluir en la lista:
+~~~~~~
 
-l = [22, True, “una lista”, [1, 2]]
+La **lista** es un tipo de colección ordenada. Sería equivalente a 
+lo que en otros lenguajes se conoce por *arrays* o vectores.  Las 
+listas pueden contener cualquier tipo de dato: números, cadenas, 
+booleanos, *listas* y en general: cualquier *objeto_*.  Crear una 
+lista es tan sencillo como indicar entre corchetes y separados por 
+comas, los valores que queremos incluir en la *lista*::
 
+    >>> l = [22, True, "una lista", [1, 2]]
 
 Podemos acceder a cada uno de los elementos de la lista escribiendo 
-el nombre de la lista e indicando el índice del elemento entre 
-corchetes. Ten en cuenta sin embargo que el índice del primer 
-elemento de la lista es 0, y no 1:
+el nombre e indicando el índice (posición) del elemento entre 
+corchetes.  Debes considerar que los índices se computan desde la 
+posición **0**, de esta manera::
 
-l = [11, False]
-mi_var = l[0] # mi_var vale 11
+    >>> mi_var = l[0] # mi_var contiene 22
+    >>> ot_var = l[2] # ot_var contiene "una lista"
 
+Imprime los nuevos conjuntos *mi_var* y *ot_var*, nota que poniendo 
+el *0* extrajimos el primer (1) valor de **l** y que poniendo *2* 
+extrajimos el tercer (3) valor.  Con esto debemos tener bien en 
+claro el tema de las posiciones o *índices*, verdad?
 
+Ahora, si queremos acceder a un elemento de una lista incluida 
+dentro de otra lista tendremos que utilizar dos veces el operador 
+**[]**, primero para indicar a que posición de la lista exterior 
+queremos acceder y el segundo para seleccionar el elemento de la 
+lista interior::
 
-Si queremos acceder a un elemento de una lista incluida dentro de 
-otra lista tendremos que utilizar dos veces este operador, primero 
-para in- dicar a qué posición de la lista exterior queremos acceder, 
-y el segundo para seleccionar el elemento de la lista interior:
+    >>> ma_var = l[3][0] # ma_var vale 1
 
-l = [“una lista”, [1, 2]]
-mi_var = l[1][0] # mi_var vale 1
+Las listas son *mutables*, es decir: pueden cambiar sus valores, 
+recibir nuevos, eliminar otros, etc.  Dicho esto, podemos emplear el 
+recurso de acceso por índices para modificar el valor de un elemento 
+de la lista::
 
-
-También podemos utilizar este operador para modificar un elemento de 
-la lista si lo colocamos en la parte izquierda de una asignación:
-
-l = [22, True]
-l[0] = 99 # Con esto l valdrá [99, True]
-
+    >>> l[0] = 99 # Con esto la posición *0* de **l** será ahora *99*
 
 El uso de los corchetes para acceder y modificar los elementos de 
 una lista es común en muchos lenguajes, pero Python nos depara 
 varias sorpresas muy agradables.
 
-Una curiosidad sobre el operador [] de Python es que podemos 
-utilizar también números negativos. Si se utiliza un número negativo 
-como índice, esto se traduce en que el índice empieza a contar desde 
-el final, hacia la izquierda; es decir, con [-1] accederíamos al 
-último elemento de la lista, con [-2] al penúltimo, con [-3], al 
-antepenúltimo, y así sucesivamente.
+Lo interesante del operador **[]** de Python es que podemos utilizar 
+también números negativos.  Si se utiliza un número negativo como 
+índice, esto se traduce en que el índice empieza a contar desde el 
+final, hacia la izquierda; es decir, con [-1] accederíamos al último 
+elemento de la lista, con [-2] al penúltimo, con [-3] al 
+antepenúltimo y así sucesivamente.
 
-Otra cosa inusual es lo que en Python se conoce como slicing o parti-
-cionado, y que consiste en ampliar este mecanismo para permitir selec-
-cionar porciones de la lista. Si en lugar de un número escribimos dos
-números inicio y fin separados por dos puntos (inicio:fin) Python
-interpretará que queremos una lista que vaya desde la posición inicio
-a la posición fin, sin incluir este último. Si escribimos tres números
-(inicio:fin:salto) en lugar de dos, el tercero se utiliza para determi-
-nar cada cuantas posiciones añadir un elemento a la lista.
+Otra cosa particular en Python es lo que se le conoce como *slicing* 
+o *particionado* y que consiste en ampliar este mecanismo para 
+permitir seleccionar porciones de la lista.  Si en lugar de un 
+número escribimos dos números inicio y fin separados por dos puntos 
+**(inicio:fin)** Python interpretará que queremos una lista que vaya 
+desde la posición inicio a la posición fin, sin incluir este último. 
+Si escribimos tres números **(inicio:fin:salto)** en lugar de dos, 
+el tercero se utiliza para determinar cada cuantas posiciones añadir 
+un elemento a la lista::
 
-l = [99, True, “una lista”, [1, 2]]
-mi_var = l[0:2]   # mi_var vale [99, True]
-mi_var = l[0:4:2] # mi_var vale [99, “una lista”]
+    >>> l = [99, True, "una lista", [1, 2]]
+    >>> mi_var = l[0:2]   # mi_var vale [99, True]
+    >>> mi_var = l[0:4:2] # mi_var vale [99, "una lista"]
 
+Los números negativos también se pueden utilizar en un slicing, con 
+el mismo comportamiento que se comentó anteriormente.  Hay que 
+mencionar así mismo que no es necesario indicar el principio y el 
+final del slicing, sino que, si estos se omiten, se usarán por 
+defecto las posiciones de inicio y fin de la lista, 
+respectivamente::
 
-Los números negativos también se pueden utilizar en un slicing, con el
-mismo comportamiento que se comentó anteriormente.
+    >>> mi_var = l[1:] # mi_var vale [True, "una lista", [1, 2]]
+    >>> mi_var = l[:2] # mi_var vale [99, True]
+    >>> mi_var = l[:]   # mi_var vale [99, True, "una lista", [1, 2]]
+    >>> mi_var = l[::2] # mi_var vale [99, "una lista"]
 
-Hay que mencionar así mismo que no es necesario indicar el principio
-y el final del slicing, sino que, si estos se omiten, se usarán por defecto
-las posiciones de inicio y fin de la lista, respectivamente:
+También podemos utilizar este mecanismo para modificar la lista::
 
-l = [99, True, “una lista”]
-mi_var = l[1:] # mi_var vale [True, “una lista”]
-mi_var = l[:2] # mi_var vale [99, True]
-mi_var = l[:]   # mi_var vale [99, True, “una lista”]
-mi_var = l[::2] # mi_var vale [99, “una lista”]
+    >>> l = [99, True, "una lista", [1, 2]]
+    >>> l[0:2] = [0, 1] # l vale [0, 1, "una lista", [1, 2]]
 
+Pudiendo incluso modificar el tamaño de la lista si la lista de la 
+parte derecha de la asignación tiene un tamaño menor o mayor que el 
+de la selección de la parte izquierda de la asignación:
 
-También podemos utilizar este mecanismo para modificar la lista:
+    >>> l[0:2] = [False] # l vale [False, "una lista", [1, 2]]
 
-l = [99, True, “una lista”, [1, 2]]
-l[0:2] = [0, 1] # l vale [0, 1, “una lista”, [1, 2]]
-
-
-pudiendo incluso modificar el tamaño de la lista si la lista de la parte
-derecha de la asignación tiene un tamaño menor o mayor que el de la
-selección de la parte izquierda de la asignación:
-
-l[0:2] = [False] # l vale [False, “una lista”, [1, 2]]
-
-
-En todo caso las listas ofrecen mecanismos más cómodos para ser mo-
-dificadas a través de las funciones de la clase correspondiente, aunque
-no veremos estos mecanismos hasta más adelante, después de explicar
-lo que son las clases, los objetos y las funciones.
+En todo caso las listas ofrecen mecanismos más cómodos para ser 
+modificadas a través de las funciones de la clase correspondiente, 
+aunque no veremos estos mecanismos hasta más adelante, después de 
+explicar lo que son las clases, los objetos y las funciones.
 
 
 Tuplas
-Todo lo que hemos explicado sobre las listas se aplica también a las
-tuplas, a excepción de la forma de definirla, para lo que se utilizan
-paréntesis en lugar de corchetes.
+~~~~~~
 
-t = (1, 2, True, “python”)
+Todo lo que hemos explicado sobre las listas se aplica también a las 
+tuplas, a excepción de la forma de definirla, para lo que se 
+utilizan paréntesis en lugar de corchetes::
 
+    >>> t = (1, 2, True, “python”)
 
-En realidad el constructor de la tupla es la coma, no el paréntesis, pero
-el intérprete muestra los paréntesis, y nosotros deberíamos utilizarlos,
-por claridad.
+En realidad el constructor de la tupla es la coma, no el paréntesis, 
+pero el intérprete muestra los paréntesis, y nosotros deberíamos 
+utilizarlos, por claridad::
 
->>> t = 1, 2, 3
->>> type(t)
-type “tuple”
+    >>> t = 1, 2, 3
+    >>> type(t)
+    type “tuple”
 
+Además hay que tener en cuenta que es necesario añadir una coma para 
+tuplas de un solo elemento, para diferenciarlo de un elemento entre 
+paréntesis::
 
-Además hay que tener en cuenta que es necesario añadir una coma
-para tuplas de un solo elemento, para diferenciarlo de un elemento
-entre paréntesis.
-
->>> t = (1)
->>> type(t)
-type “int”
->>> t = (1,)
->>> type(t)
-type “tuple”
-
+    >>> t = (1)
+    >>> type(t)
+    type “int”
+    >>> t = (1,)
+    >>> type(t)
+    type “tuple”
 
 Para referirnos a elementos de una tupla, como en una lista, se usa el
-operador []:
+operador **[]**::
 
-mi_var = t[0] # mi_var es 1
-mi_var = t[0:2] # mi_var es (1, 2)
+    >>> mi_var = t[0] # mi_var es 1
+    >>> mi_var = t[0:2] # mi_var es (1, 2)
 
+Podemos utilizar el operador **[]** debido a que las *tuplas*, al igual que
+las *listas*, forman parte de un tipo de objetos llamados secuencias.
+Es preciso aclarar que las cadenas de texto también son secuencias, 
+por lo que no les debe extraña que podamos hacer cosas como estas::
 
-Podemos utilizar el operador [] debido a que las tuplas, al igual que
-las listas, forman parte de un tipo de objetos llamados secuencias.
-Permitirme un pequeño inciso para indicaros que las cadenas de texto
-también son secuencias, por lo que no os extrañará que podamos hacer
-cosas como estas:
+    >>> c = “hola mundo”
+    >>> c[0]   # h
+    >>> c[5:] # mundo
+    >>> c[::3] # hauo
 
-c = “hola mundo”
-c[0]   # h
-c[5:] # mundo
-c[::3] # hauo
+Muy bien, hasta ahora lo mismo que hemos visto en las **listas** se 
+aplica a las **tuplas**, entonces: cuál es la diferencia entre 
+ambas? Bueno, vamos a colocar las más importantes:
 
+    **Inmutables**
+        No pueden modificarse una vez creadas.
+    **Consumo de memoria**
+        Las tuplas consumen menos memoria que las listas.
 
-Volviendo al tema de las tuplas, su diferencia con las listas estriba en
-que las tuplas no poseen estos mecanismos de modificación a través
-de funciones tan útiles de los que hablábamos al final de la anterior
-sección.
-
-Además son inmutables, es decir, sus valores no se pueden modificar
-una vez creada; y tienen un tamaño fijo.
-
-A cambio de estas limitaciones las tuplas son más “ligeras” que las
-listas, por lo que si el uso que le vamos a dar a una colección es muy
-básico, puedes utilizar tuplas en lugar de listas y ahorrar memoria.
+Adicionalmente las tuplas no poseen mecanismos de modificación a 
+través de funciones tan útiles como las que poseen las listas.
 
 
 Diccionarios
+~~~~~~~~~~~~
+
 Los diccionarios, también llamados matrices asociativas, deben su
 nombre a que son colecciones que relacionan una clave y un valor. Por
 ejemplo, veamos un diccionario de películas y directores:
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.