Encuentro Asíncrono 8

Haciendo uso de las listas

El bucle for tiene una variante muy especial que puede procesar las listas de manera
muy efectiva. Echemos un vistazo a eso.

Supongamos que desea calcular la suma de todos los valores almacenados en la lista
miLista.

Necesitas una variable cuya suma se almacenará y se le asignará inicialmente un valor

de 0 - su nombre es suma. Luego agrega todos los elementos de la lista usando el
bucle for. Echa un vistazo al fragmento ...

Comentemos este ejemplo:

A la lista se le asigna una secuencia de cinco valores enteros.

La variable i toma los valores 0, 1,2,3, y 4, y luego indexa la lista, seleccionando los
elementos siguientes: el primero, segundo, tercero, cuarto y quinto.

Cada uno de estos elementos se agrega junto con el operador += a la variable suma,
dando el resultado final al final del bucle.

Observa la forma en que se ha empleado la función len(), hace que el código sea
independiente de cualquier posible cambio en el contenido de la lista.

La segunda cara del ciclo for

Pero el bucle for puede hacer mucho más. Puede ocultar todas las acciones conectadas
a la indexación de la lista y entregar todos los elementos de la lista de manera práctica.

Este fragmento modificado muestra cómo funciona:

pág. 1
¿Qué sucede aquí?

• La instrucción for especifica la variable utilizada para navegar por la lista (i)
seguida de la palabra clave in y el nombre de la lista siendo procesado
(miLista).
• A la variable i se le asignan los valores de todos los elementos de la lista
subsiguiente, y el proceso ocurre tantas veces como hay elementos en la lista.
• Esto significa que usa la variable i como una copia de los valores de los
elementos, y no necesita emplear índices.
• La función len() tampoco es necesaria aquí.

Las listas en acción

Dejemos de lado las listas por un breve momento y veamos un tema intrigante.

Imagina que necesitas reorganizar los elementos de una lista, es decir, revertir el orden
de los elementos: el primero y el quinto, así como el segundo y cuarto elementos serán
intercambiados. El tercero permanecerá intacto.

Pregunta: ¿Cómo se pueden intercambiar los valores de dos variables?

Echa un vistazo al fragmento:

variable1 = 1
variable2 = 2
variable2 = variable1
variable1 = variable2

Si haces algo como esto, perderás el valor previamente almacenado en variable2.

Cambiar el orden de las tareas no ayudará. Necesitas una tercera variable que sirva
como almacenamiento auxiliar.

Así es como puedes hacerlo:

pág. 2
variable1 = 1
variable2 = 2
auxiliar = variable1
variable1 = variable2
variable2 = auxiliar

Python ofrece una forma más conveniente de hacer el intercambio, echa un vistazo:

variable1 = 1
variable2 = 2
variable1, variable2 = variable2, variable1

Ahora puedes intercambiar fácilmente los elementos de la lista para revertir su orden:

Ejecuta el fragmento. Su salida debería verse así:

[5, 3, 8, 1, 10]
Se ve bien con cinco elementos.

¿Seguirá siendo aceptable con una lista que contenga 100 elementos? No, no lo hará.

¿Puedes usar el bucle for para hacer lo mismo automáticamente, independientemente

de la longitud de la lista? Si, si puedes.

Así es como lo hemos hecho:

• Hemos asignado la variable longitud a la longitud de la lista actual (esto hace

que nuestro código sea un poco más claro y más corto).
• Hemos lanzado el ciclo for para que se ejecute a través de su cuerpo longitud //
2 veces (esto funciona bien para listas con longitudes pares e impares, porque
cuando la lista contiene un número impar de elementos, el del medio
permanece intacto).

pág. 3
 • Hemos intercambiado el elemento i (desde el principio de la lista) por el que
tiene un índice igual a (longitud-i-1) (desde el final de la lista); en nuestro
ejemplo, for i igual a 0 la (longitud-i-1) da 4; for i igual a 3, da 3: esto es
exactamente lo que necesitábamos.
• Las listas son extremadamente útiles y las encontrarás muy a menudo.

Resumen

1. La lista es un tipo de dato en Python que se utiliza para almacenar múltiples objetos.
Es una colección ordenada y mutable de elementos separados por comas entre
corchetes, por ejemplo:

miLista = [1, None, True, "Soy una cadena", 256, 0]

2. Las listas se pueden indexar y actualizar , por ejemplo:

miLista = [1, 1, None, True, 'Soy una cadena', 256, 0]

print(miLista [3]) # salida: soy una cadena
print(miLista [-1]) # salida: 0

miLista [1] = '?'

print (miLista) # salida: [1, '?', True, 'Soy una cadena', 256, 0]

miLista.insert (0, "first")

miLista.append ("last")
print (miLista ) # salida: ['first', 1, '?', True, 'Soy una cadena', 256, 0, 'last']

3. Las listas pueden estar anidadas, por ejemplo:

miLista = [1, 'a', ["lista", 64, [0, 1], False]]

4. Los elementos de la lista y las listas se pueden eliminar, por ejemplo:

miLista = [1, 2, 3, 4]
del miLista[2]
print(miLista) # salida: [1, 2, 4]
del miLista # borra toda la lista

5.Las listas pueden ser iteradas mediante el uso del bucle for, por ejemplo:

miLista = ["blanco", "purpura", "azul", "amarillo", "verde"]

for color in miLista :
print(color)

pág. 4
6. La función len() se puede usar para verificar la longitud de la lista, por ejemplo:

miLista = ["blanco", "purpura", "azul", "amarillo", "verde"]

print(len(miLista)) # la salidas es 5

del miLista[2]
print (len(miLista)) # la salidas es 4

7. Una invocación típica de función tiene el siguiente aspecto:

resultado = funcion(argumento),

mientras que una invocación típica de un método se ve así:

resultado = data.method(arg).

Ordenamiento Burbuja
Ahora que puedes hacer malabarismos con los elementos de las listas, es hora de
aprender como ordenarlos. Se han inventado muchos algoritmos de clasificación, que
difieren mucho en velocidad, así como en complejidad. Vamos a mostrar un algoritmo
muy simple, fácil de entender, pero desafortunadamente, tampoco es muy eficiente. Se
usa muy raramente, y ciertamente no para listas extensas.

Digamos que una lista se puede ordenar de dos maneras:

Ascendente (o más precisamente, no descendente): si en cada par de elementos

adyacentes, el primer elemento no es mayor que el segundo.

Descendente (o más precisamente, no ascendente): si en cada par de elementos

adyacentes, el primer elemento no es menor que el segundo.

En las siguientes secciones, ordenaremos la lista en orden ascendente, de modo que los
números se ordenen de menor a mayor.

Aquí está la lista:

Intentaremos utilizar el siguiente enfoque: tomaremos el primer y el segundo elemento

y los compararemos; si determinamos que están en el orden incorrecto (es decir, el
primero es mayor que el segundo), los intercambiaremos; Si su orden es válido, no
haremos nada. Un vistazo a nuestra lista confirma lo último: los elementos 01 y 02
están en el orden correcto, así como 8<10.

pág. 5
Ahora observa el segundo y el tercer elemento. Están en las posiciones equivocadas.
Tenemos que intercambiarlos:

Vamos más allá y observemos los elementos tercero y cuarto. Una vez más, esto no es
lo que se supone que es. Tenemos que intercambiarlos:

Ahora comprobemos los elementos cuarto y quinto. Si, ellos también están en las
posiciones equivocadas. Ocurre otro intercambio:

El primer paso a través de la lista ya está terminado. Todavía estamos lejos de terminar
nuestro trabajo, pero algo curioso ha sucedido mientras tanto. El elemento más grande,
10, ya ha llegado al final de la lista. Ten en cuenta que este es el lugar deseado para el.
Todos los elementos restantes forman un lío pintoresco, pero este ya está en su lugar.

Ahora, por un momento, intenta imaginar la lista de una manera ligeramente diferente,
es decir, de esta manera:

Observa - El 10 está en la parte superior. Podríamos decir que flotó desde el fondo
hasta la superficie, al igual que las burbujas en una copa de champán. El método de
clasificación deriva su nombre de la misma observación: se denomina ordenamiento de
burbuja.

pág. 6
Ahora comenzamos con el segundo paso a través de la lista. Miramos el primer y el
segundo elemento, es necesario un intercambio:

Tiempo para el segundo y tercer elemento: también tenemos que intercambiarlos:

Ahora el tercer y cuarto elementos, y la segunda pasada, se completa, ya que 8 ya está

en su lugar:

Comenzamos el siguiente pase inmediatamente. Observe atentamente el primer y el

segundo elemento: se necesita otro cambio:

Ahora 6 necesita ir a su lugar. Cambiamos el segundo y el tercer elemento:

La lista ya está ordenada. No tenemos nada más que hacer. Esto es exactamente lo que
queremos.

Como puedes ver, la esencia de este algoritmo es simple: comparamos los elementos
adyacentes y, al intercambiar algunos de ellos, logramos nuestro objetivo.

Codifiquemos en Python todas las acciones realizadas durante un solo paso a través de
la lista, y luego consideraremos cuántos pases necesitamos para realizarlo. No hemos
explicado esto hasta ahora, pero lo haremos pronto.

pág. 7
Ordenando una lista
¿Cuántos pases necesitamos para ordenar la lista completa?

Resolvamos este problema de la siguiente manera: introducimos otra variable, su

tarea es observar si se ha realizado algún intercambio durante el pase o no. Si no hay
intercambio, entonces la lista ya está ordenada, y no hay que hacer nada más.
Creamos una variable llamada swapped , y le asignamos un valor de False para
indicar que no hay intercambios. De lo contrario, se le asignará True .

Deberías poder leer y comprender este programa sin ningún problema:

Ejecuta el programa y pruébalo.

El ordenamiento burbuja- versión interactiva

Debajo de este párrafo, puedes ver un programa completo, enriquecido por una
conversación con el usuario, y que permite ingresar e imprimir elementos de la lista: El
ordenamiento burbuja: versión interactiva final.

pág. 8
Python, sin embargo, tiene sus propios mecanismos de clasificación. Nadie necesita
escribir sus propias clases, ya que hay un número suficiente de herramientas listas para
usar.

Te explicamos este sistema de clasificación porque es importante aprender como

procesar los contenidos de una lista y mostrarte como puede funcionar la clasificación
real.

Si quieres que Python ordene tu lista, puedes hacerlo de la siguiente manera:

Es tan simple como eso.

La salida del fragmento es la siguiente:

[2, 4, 6, 8, 10]

Como puedes ver, todas las listas tienen un método denominado sort(), que las ordena
lo más rápido posible. Ya has aprendido acerca de algunos de los métodos de lista
anteriormente, y pronto aprenderás más sobre otros.

1. Puedes usar el método sort() para ordenar los elementos de una lista, por ejemplo:

lst = [5, 3, 1, 2, 4]
print(lst)

lst.sort ()
print(lst) # salida: [1, 2, 3, 4, 5]

pág. 9
2. También hay un método de lista llamado reverse(), que puedes usar para invertir la
lista, por ejemplo:

lst = [5, 3, 1, 2, 4]
print(lst)

lst.reverse()
print (lst) # salida: [4, 2, 1, 3, 5]

La vida al interior de las listas

Ahora quiero mostrarte una característica importante y muy sorprendente de las listas,
que las distingue de las variables ordinarias.

Queremos que lo memorices, ya que puede afectar tus programas futuros y causar
graves problemas si se olvida o se pasa por alto.

Echa un vistazo al fragmento.

El programa:

Crea una lista de un elemento llamada lista1.

La asigna a una nueva lista llamada lista2.

Cambia el único elemento de lista1.

Imprime la lista2.

La parte sorprendente es el hecho de que el programa mostrará como resultado:

[2], no [1], que parece ser la solución obvia.

Las listas (y muchas otras entidades complejas de Python) se almacenan de

diferentes maneras que las variables ordinarias (escalares).

Se podría decir que:

El nombre de una variable ordinaria es el nombre de su contenido.

El nombre de una lista es el nombre de una ubicación de memoria donde se almacena

la lista.

pág. 10
La asignación: lista2 = lista1copia el nombre de la matriz, no su contenido. En efecto,
los dos nombres (lista1 y lista2) identifican la misma ubicación en la memoria de la
computadora. Modificar uno de ellos afecta al otro, y viceversa.

Rodajas Poderosas
Afortunadamente, la solución está al alcance de su mano: su nombre es rodaja.

Una rodaja es un elemento de la sintaxis de Python que permite hacer una copia nueva
de una lista, o partes de una lista.

En realidad, copia el contenido de la lista, no el nombre de la lista.

Esto es exactamente lo que necesitas. Echa un vistazo al fragmento de código a

continuación:

Su salida es [1].

Esta parte no visible del código descrito como [:] puede producir una lista
completamente nueva.

Una de las formas más generales de la rodaja es la siguiente:

miLista[inicio:fin]

Como puedes ver, se asemeja a la indexación, pero los dos puntos en el interior hacen
una gran diferencia.

Una rodaja de este tipo crea una nueva lista (de destino), tomando elementos de la lista
de origen: los elementos de los índices desde el principio hasta el fin-1.

Nota: no hasta el fin, sino hasta fin-1. Un elemento con un índice igual a fin es el primer
elemento el cual no participa en la segmentación.

Es posible utilizar valores negativos tanto para el inicio como para el fin(al igual que en
la indexación).

Echa un vistazo al fragmento:

miLista = [10, 8, 6, 4, 2]
nuevaLista = miLista [1:3]
print(nuevaLista)

pág. 11
La lista nuevaLista contendrá inicio-fin (3-1=2) elementos, los que tienen índices
iguales a 1 y 2 (pero no 3)

La salida del fragmento es: [8, 6]

Rodajas- índices negativos

Observa el fragmento de código a continuación:

miLista[inicio:fin]

Para repetir:

inicio es el índice del primer elemento incluido en la rodaja.

fin es el índice del primer elemento no incluido en la rodaja.

Así es como los índices negativos funcionan con la rodaja:

miLista = [10, 8, 6, 4, 2]
nuevaLista = miLista [1:-1]
print(nuevaLista)

El resultado del fragmento es: [8, 6, 4].

Si el inicio especifica un elemento que se encuentra más allá del descrito por fin (desde
el punto de vista inicial de la lista), la rodaja estará vacía:

miLista = [10, 8, 6, 4, 2]
nuevaLista = miLista [-1:1]
print(nuevaLista)

La salida del fragmento es: [].

pág. 12
Si omites inicio en tu rodaja, se supone que deseas obtener un segmento que
comienza en el elemento con índice 0.

En otras palabras, la rodaja sería de esta forma:

miLista[:fin]

Es un equivalente más compacto:

miLista[0:fin]

Observa el fragmento de código a continuación:

miLista = [10, 8, 6, 4, 2]
nuevaLista = miLista [:3]
print(nuevaLista)

Es por esto que su salida es: [10, 8, 6].

Del mismo modo, si omites el fin en tu rodaja, se supone que deseas que el segmento
termine en el elemento con el índice len(miLista).

En otras palabras, la rodaja sería de esta forma:

miLista[inicio:]

Es un equivalente más compacto:

miLista[inicio:len(miLista)]

Observa el siguiente fragmento de código:

miLista = [10, 8, 6, 4, 2]
nuevaLista = miLista[3:]
print(nuevaLista)

Por lo tanto, la salida es: [4, 2].

Rodajas: continuación
Como hemos dicho antes, el omitir inicio y fin hace una copia de toda la lista:

miLista = [10, 8, 6, 4, 2]
nuevLista = miLista [:]
print(nuevLista)

pág. 13
El resultado del fragmento es: [10, 8, 6, 4, 2].

La instrucción del descrita anteriormente puede eliminar más de un elemento de la lista

a la vez, también puede eliminar rodajas:

miLista = [10, 8, 6, 4, 2]
del miLista[1:3]
print(miLista)

Nota: En este caso, la rodaja ¡no produce ninguna lista nueva!

La salida del fragmento es:[10, 4, 2].

También es posible eliminar todos los elementos a la vez:

miLista = [10, 8, 6, 4, 2]
del miLista[:]
print(miLista)

La lista se queda vacía y la salida es: [].

Al eliminar la rodaja del código, su significado cambia dramáticamente.

Echa un vistazo:

miLista = [10, 8, 6, 4, 2]
del miLista
print(miLista)

La instrucción del eliminará la lista, no su contenido.

La función print() de la última línea del código provocará un error de ejecución.

Los operadores in y not

Python ofrece dos operadores muy poderosos, capaces de revisar la lista para verificar
si un valor específico está almacenado dentro de la lista o no.

Estos operadores son:

elem in miLista
elem not in miLista

El primero de ellos (in) verifica si un elemento dado(su argumento izquierdo) está

actualmente almacenado en algún lugar dentro de la lista(el argumento derecho) - el
operador devuelve True en este caso.

pág. 14
El segundo (not in) comprueba si un elemento dado (su argumento izquierdo) está
ausente en una lista - el operador devuelve True en este caso.

Observa el siguiente código. El fragmento muestra ambos operadores en acción.

¿Puedes adivinar su salida? Ejecuta el programa para comprobar si tenías razón.

Listas- algunos programas simples

Ahora queremos mostrarte algunos programas simples que utilizan listas.

El primero de ellos intenta encontrar el mayor valor en la lista. Mira el siguiente código.

El concepto es bastante simple: asumimos temporalmente que el primer elemento es el

más grande y comparamos la hipótesis con todos los elementos restantes de la lista.

El código da como resultado el 17 (como se espera).

El código puede ser reescrito para hacer uso de la forma recién introducida del ciclo
for:

miLista = [17, 3, 11, 5, 1, 9, 7, 15, 13]

mayor = miLista [0]

for i in miLista:
if i > mayor:
mayor = i

print(mayor)

pág. 15
El programa anterior realiza una comparación innecesaria, cuando el primer elemento
se compara consigo mismo, pero esto no es un problema en absoluto.

El código da como resultado el 17 también (nada inusual).

Si necesitas ahorrar energía de la computadora, puedes usar una rodaja:

miLista = [17, 3, 11, 5, 1, 9, 7, 15, 13]

mayor = miLista [0]

for i in miLista [1:]:

if i > mayor:
mayor = i

print(mayor)

La pregunta es: ¿Cuál de estas dos acciones consume más recursos informáticos: solo
una comparación o partir casi todos los elementos de una lista?

Listas- algunos programas simples

Ahora encontremos la ubicación de un elemento dado dentro de una lista:

miLista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Encontrar = 5
Encontrado = False

for i in range(len(miLista)):
Encontrado = miLista[i] == Encontrar
if Encontrado:
break

if Encontrado:
print("Elemento encontrado en el índice", i)
else:
print("ausente")

Nota:

El valor buscado se almacena en la variable Encontrar.

El estado actual de la búsqueda se almacena en la variable Encontrado (True/False).

Cuando Encontrado se convierte en True, se sale del bucle for.

Supongamos que has elegido los siguientes números en la lotería: 3, 7, 11, 42, 34, 49.

pág. 16
Los números que han salido sorteados son: 5, 11, 9, 42, 3, 49.

La pregunta es: ¿A cuántos números le has atinado?

El programa te dará la respuesta:

sorteados = [5, 11, 9, 42, 3, 49]

seleccionados = [3, 7, 11, 42, 34, 49]
aciertos = 0

for numeros in seleccionados:

if numeros in sorteados:
aciertos += 1

print(aciertos)

Nota:

La lista sorteados almacena todos los números ganadores.

La lista de seleccionados almacena con números con que se juega.

La variable aciertos cuenta tus aciertos.

La salida del programa es: 4.

1) Si tienes una lista l1, la siguiente asignación: l2 = l1 no hace una copia de la

lista l1, pero hace que las variables l1 y l2 apunten a la misma lista en la
memoria . Por ejemplo:

vehiculosUno = ['carro', 'bicicleta', 'moto']

print(vehiculosUno) # salida: ['carro', 'bicicleta', 'moto']

vehiculosDos = vehiculosUno
del vehiculosUno[0] # borra 'carro'
print(vehiculosDos) # salida: ['bicicleta', 'moto']

2) Si deseas copiar una lista o parte de la lista, puede hacerlo haciendo uso de
rodajas(slicing):

colores = ['rojo', 'verde', 'naranja']

copiaTodosColores = colores[:] # copia la lista completa

copiaParteColores = colores[0:2] # copia parte de la lista

pág. 17
 3) También puede utilizar índices negativos para hacer uso de rodajas. Por
ejemplo:

listaMuestra = ["A", "B", "C", "D", "E"]

nuevaLista = listaMuestra[2:-1]
print(nuevaLista) # salida: ['C', 'D']

4) Los parámetros inicio y fin son opcionales al partir en rodajas una lista:
lista[inicio:fin], por ejemplo:

miLista = [1, 2, 3, 4, 5]
rodajaUno = miLista [2:]
rodajaDos = miLista [:2]
rodajaTres = miLista [-2:]

print(rodajaUno) # salidas: [3, 4, 5]

print(rodajaDos) # salidas: [1, 2]
print(rodajaTres) # salidas: [4, 5]

5) Puedes eliminar rodajas utilizando la instrucción del:

miLista = [1, 2, 3, 4, 5]
del miLista [0:2]
print(miLista) # salida: [3, 4, 5]

del miLista[:]
print(miLista) # elimina el contenido de la lista, genera: []

6) Puedes probar si algunos elementos existen en una lista o no utilizando las

palabras clave in y not in, por ejemplo:

miLista = ["A", "B", 1, 2]

print("A" in miLista) # salida: True

print("C" not in miLista) # salida: False
print(2 not in miLista) # salidas: False

pág. 18