3.

3 Sección 3 – Operaciones lógicas y de bits en

Python

3.3.1 Lógica de computadoras

Si tenemos tiempo libre, y el clima es bueno, saldremos a caminar.

Hemos utilizado la conjunción and (y), lo que significa que salir a caminar depende
del cumplimiento simultáneo de estas dos condiciones. En el lenguaje de la lógica,
tal conexión de condiciones se denomina conjunción. Y ahora otro ejemplo:

Si tu estás en el centro comercial o yo estoy en el centro comercial, uno de

nosotros le comprará un regalo a mamá.

La aparición de la palabra or (o) significa que la compra depende de al menos una

de estas condiciones. En lógica, este compuesto se llama una disyunción.

Está claro que Python debe tener operadores para construir conjunciones y disyunciones.
Sin ellos, el poder expresivo del lenguaje se debilitaría sustancialmente. Se
llaman operadores lógicos.

El operador and
Un operador de conjunción lógica en Python es la palabra and. Es un operador
binario con una prioridad inferior a la expresada por los operadores de
comparación. Nos permite codificar condiciones complejas sin el uso de
paréntesis como este:

counter > 0 and value == 100

Si consideramos la conjunción de A and B, el conjunto de valores posibles de argumentos

y los valores correspondientes de conjunción se ve de la siguiente manera:

Argumento A Argumento B A and B

False False False

 False True False

True False False

True True True

El operador or
Un operador de disyunción es la palabra or. Es un operador binario con una
prioridad más baja que and (al igual que + en comparación con *). Su tabla de
verdad es la siguiente:

Argumento A Argumento B A or B

False False False

False True True

True False True

True True True

El operador not
Además, hay otro operador que se puede aplicar para condiciones de
construcción. Es un operador unario que realiza una negación lógica. Su
funcionamiento es simple: convierte la verdad en falso y lo falso en verdad.

Este operador se escribe como la palabra not, y su prioridad es muy alta: igual

que el unario + y -. Su tabla de verdad es simple:

Argumento not Argumento

False True
 True False

3.3.2 Expresiones lógicas

Creemos una variable llamada var y asignémosle 1. Las siguientes condiciones

son equivalentes a pares:

# Ejemplo 1:
print(var > 0)
print(not (var <= 0))
 
 
# Ejemplo 2:
print(var != 0)
print(not (var == 0))

Puedes estar familiarizado con las leyes de De Morgan. Dicen que:

La negación de una conjunción es la separación de las negaciones.

La negación de una disyunción es la conjunción de las negaciones.

Escribamos lo mismo usando Python:

not (p and q) == (not p) or (not q)

not (p or q) == (not p) and (not q)
 

Observa como se han utilizado los paréntesis para codificar las expresiones - las
colocamos allí para mejorar la legibilidad.

Deberíamos agregar que ninguno de estos operadores de dos argumentos se

puede usar en la forma abreviada conocida como op=. Vale la pena recordar esta
excepción.
3.3.3 Valores lógicos vs bits individuales

Los operadores lógicos toman sus argumentos como un todo, independientemente

de cuantos bits contengan. Los operadores solo conocen el valor: cero (cuando
todos los bits se restablecen) significa False; no cero (cuando se establece al
menos un bit) significa True.

El resultado de sus operaciones es uno de estos valores: False o True. Esto

significa que este fragmento de código asignará el valor True a la variable j si i no
es cero; de lo contrario, será False.

3.3.4 Operadores bit a bit

Sin embargo, hay cuatro operadores que le permiten manipular bits de datos

individuales. Se denominan operadores bit a bit.

Cubren todas las operaciones que mencionamos anteriormente en el contexto

lógico, y un operador adicional. Este es el operador xor (significa o exclusivo ), y
se denota como ^ (signo de intercalación).

Aquí están todos ellos:

 & (ampersand) ‒ conjunción a nivel de bits;

 | (barra vertical) - disyunción a nivel de bits;
 ~ (tilde) - negación a nivel de bits;
 ^ (signo de intercalación) - o exclusivo a nivel de bits (xor).

Operaciones bit a bit (&, |, y ^)

Argumento A Argumento B A&B A|B A^B

0 0 0 0 0

0 1 0 1 1
 1 0 0 1 1

1 1 1 1 0

Operaciones bit a bit (~)

Argument
~ Argumento
o

0 1

1 0

Hagámoslo más fácil:

 & requieres exactamente dos 1 s para proporcionar 1 como resultado;

 | requiere al menos un 1 para proporcionar 1 como resultado;
 ^ requiere exactamente un 1 para proporcionar 1 como resultado.

Agreguemos un comentario importante: los argumentos de estos

operadores deben ser enteros; no debemos usar flotantes aquí.

La diferencia en el funcionamiento de los operadores lógicos y de bits es

importante: los operadores lógicos no penetran en el nivel de bits de su
argumento. Solo les interesa el valor entero final.

Los operadores bit a bit son más estrictos: tratan con cada bit por separado. Si
asumimos que la variable entera ocupa 64 bits (lo que es común en los sistemas
informáticos modernos), puede imaginar la operación a nivel de bits como una
evaluación de 64 veces del operador lógico para cada par de bits de los
argumentos. Su analogía es obviamente imperfecta, ya que en el mundo real
todas estas 64 operaciones se realizan al mismo tiempo (simultáneamente).

Operaciones lógicas vs operaciones

de bit
Ahora te mostraremos un ejemplo de la diferencia en la operación entre las
operaciones lógicas y de bit. Supongamos que se han realizado las siguientes
tareas:

1
2
3
i = 15
j = 22
 

Si asumimos que los enteros se almacenan con 32 bits, la imagen a nivel de bits
de las dos variables será la siguiente:

i: 00000000000000000000000000001111
j: 00000000000000000000000000010110

Se ejecuta la asignación:

1
2
log = i and j
 

Estamos tratando con una conjunción lógica aquí. Vamos a trazar el curso de los
cálculos. Ambas variables i y j no son ceros, por lo que se considerará que
representan a True. Al consultar la tabla de verdad para el operador and, podemos
ver que el resultado será True. No se realizan otras operaciones.

log: True

Ahora la operación a nivel de bits - aquí está:

1
2
bit = i & j
 

El operador & operará con cada par de bits correspondientes por separado,

produciendo los valores de los bits relevantes del resultado. Por lo tanto, el
resultado será el siguiente:

i 00000000000000000000000000001111

j 00000000000000000000000000010110

bit = i & j 00000000000000000000000000000110

Estos bits corresponden al valor entero de seis.

Veamos ahora los operadores de negación. Primero el lógico:

 1
2
logneg = not i
 

La variable logneg se establecerá en False - no es necesario hacer nada más.

La negación a nivel de bits es así:

1
2
bitneg = ~i
 

Puede ser un poco sorprendente: el valor de la variable bitneg es -16. Esto puede

parecer extraño, pero no lo es en absoluto. Si deseas obtener más información,
debes consultar el sistema de números binarios y las reglas que rigen los números
de complemento de dos.

i 00000000000000000000000000001111

bitneg = ~i 11111111111111111111111111110000

Cada uno de estos operadores de dos argumentos se puede utilizar en forma

abreviada. Estos son los ejemplos de sus notaciones equivalentes:

x=x&y x &= y

x=x|y x |= y

x=x^y x ^= y
Incompleto 3.3.5 ¿Cómo tratar con bits individuales?

3.3.5 ¿Cómo tratar con bits individuales?

Ahora te mostraremos para que puedes usar los operadores de bit a bit. Imagina
que eres un desarrollador obligado a escribir una pieza importante de un sistema
operativo. Se te ha dicho que puedes usar una variable asignada de la siguiente
forma:

flag_register = 0x1234
La variable almacena la información sobre varios aspectos de la operación del
sistema. Cada bit de la variable almacena un valor de si/no. También se te ha
dicho que solo uno de estos bits es tuyo - el tercero (recuerda que los bits se
numeran desde cero y el número de bits cero es el más bajo, mientras que el más
alto es el número 31). Los bits restantes no pueden cambiar, porque están
destinados a almacenar otros datos. Aquí está tu bit marcado con la letra x:

flag_register = 0000000000000000000000000000x000
 

Es posible que tengas que hacer frente a las siguientes tareas:

1. Comprobar el estado de tu bit - deseas averiguar el valor de su bit; comparar

la variable completa con cero no hará nada, porque los bits restantes pueden tener
valores completamente impredecibles, pero puedes usar la siguiente propiedad de
conjunción:

1
2
3
x & 1 = x
x & 0 = 0

La variable almacena la información sobre varios aspectos de la operación del

sistema. Cada bit de la variable almacena un valor de si/no. También se te ha
dicho que solo uno de estos bits es tuyo - el tercero (recuerda que los bits se
numeran desde cero y el número de bits cero es el más bajo, mientras que el más
alto es el número 31). Los bits restantes no pueden cambiar, porque están
destinados a almacenar otros datos. Aquí está tu bit marcado con la letra x:

flag_register = 0000000000000000000000000000x000
 

Es posible que tengas que hacer frente a las siguientes tareas:

1. Comprobar el estado de tu bit - deseas averiguar el valor de su bit; comparar

la variable completa con cero no hará nada, porque los bits restantes pueden tener
valores completamente impredecibles, pero puedes usar la siguiente propiedad de
conjunción:
 1
2
3
x & 1 = x
x & 0 = 0
 

Si aplicas la operación & a la variable flag_register junto con la siguiente imagen

de bits:

00000000000000000000000000001000

(observa el 1 en la posición de tu bit) como resultado, obtendrás una de las

siguientes cadenas de bits:

 00000000000000000000000000001000 si tu bit se estableció en 1

 00000000000000000000000000000000 si tu bit se reseteo a 0

Dicha secuencia de ceros y unos, cuya tarea es tomar el valor o cambiar los bits
seleccionados, se denomina máscara de bits.

Construyamos una máscara de bits para detectar el estado de tus bits. Debería
apuntar a el tercer bit. Ese bit tiene el peso de 2 =8. Se podría crear una máscara
3

adecuada mediante la siguiente sentencia:

1
2
the_mask = 8
 

También puedes hacer una secuencia de instrucciones dependiendo del estado de

tu bit, aquí está:

1
2
3
4
5
if flag_register & the_mask:
    # Mi bit se estableció en 1.
else:
    # Mi bit se restableció a 0.
 

2. Reinicia tu bit - asigna un cero al bit, mientras que todos los otros bits deben
permanecer sin cambios; usemos la misma propiedad de la conjunción que antes,
pero usemos una máscara ligeramente diferente - exactamente como se muestra
a continuación:

11111111111111111111111111110111
 

Toma en cuenta que la máscara se creó como resultado de la negación de todos

los bits de la variable the_mask. Restablecer el bit es simple, y se ve así (elige el
que más te guste):

1
2
3
flag_register = flag_register & ~the_mask
flag_register &= ~the_mask
 

3. Establece tu bit - asigna un 1 a tu bit, mientras que todos los bits restantes
deben permanecer sin cambios; usa la siguiente propiedad de disyunción:

1
2
3
x | 1 = 1
x | 0 = x
 

Ya estás listo para configurar su bit con una de las siguientes instrucciones:

1
2
3
flag_register = flag_register | the_mask
flag_register |= the_mask
 

4. Niega tu bit - reemplaza un 1 con un 0 y un 0 con un 1. Puedes utilizar una
propiedad interesante del operador ~x:

1
2
3
x ^ 1 = ~x
x ^ 0 = x
 
Niega tu bit con las siguientes instrucciones:

1
2
3
flag_register = flag_register ^ the_mask
flag_register ^= the_mask
 

3.3.6 Desplazamiento binario a la izquierda y

desplazamiento binario a la derecha

Python ofrece otra operación relacionada con los bits individuales: shifting. Esto
se aplica solo a los valores de número entero, y no debe usar flotantes como
argumentos para ello.

Ya aplicas esta operación muy a menudo y muy inconscientemente. ¿Cómo

multiplicas cualquier número por diez? Echa un vistazo:

12345 × 10 = 123450

Como puede ver, multiplicar por diez es de hecho un desplazamiento de todos

los dígitos a la izquierda y llenar el vacío resultante con cero.

¿División entre diez? Echa un vistazo:

12340 ÷ 10 = 1234

Dividir entre diez no es más que desplazar los dígitos a la derecha.

La computadora realiza el mismo tipo de operación, pero con una diferencia: como
dos es la base para los números binarios (no 10), desplazar un valor un bit a la
izquierda corresponde a multiplicarlo por dos; respectivamente, desplazar un
bit a la derecha es como dividir entre dos (observa que se pierde el bit más a la
derecha).

Los operadores de cambio en Python son un par de dígrafos: < < y > >,

sugiriendo claramente en qué dirección actuará el cambio.

valor << bits

valor >> bits
 
El argumento izquierdo de estos operadores es un valor entero cuyos bits se
desplazan. El argumento correcto determina el tamaño del desplazamiento.

Esto demuestra que esta operación ciertamente no es conmutativa

La prioridad de estos operadores es muy alta. Los verás en la tabla de prioridades

actualizada, que te mostraremos al final de esta sección.

Echa un vistazo a los turnos en la ventana del editor.

var = 17

var_right = var >> 1

var_left = var << 2

print(var, var_left, var_right)

Nota:

 17 >> 1 → 17 // 2 (17 dividido entre 2 a la potencia de 1) → 8 (desplazarse

hacia la derecha en un bit equivale a la división entera entre dos)
 17 << 2 → 17 * 4 (17 multiplicado por 2 a la potencia de 2)
→ 68 (desplazarse hacia la izquierda dos bits es lo mismo que multiplicar
números enteros por cuatro)

Y aquí está la tabla de prioridades actualizada , que contiene todos los

operadores presentados hasta ahora:

Priorida
Operador
d

1 ~, +, - unario

2 **

3 *, /, //, %

4 +, - binari
o

5 <<, >>

6 <, <=, >, >=
 7 ==, !=

8 &

9 |

10 =, +=, -=, *=, /=, %=, &=, ^=, |=, >
>=, <<=

3.3.7 RESUMEN DE SECCIÓN

1. Python es compatible con los siguientes operadores lógicos:

 and → si ambos operandos son verdaderos, la condición es verdadera, por

ejemplo, (True and True) es True.
 or → si alguno de los operandos es verdadero, la condición es verdadera,
por ejemplo, (True or False) es True.
 not → devuelve False si el resultado es verdadero y devuelve True si es
falso, por ejemplo, not True es False.

2. Puedes utilizar operadores bit a bit para manipular bits de datos individuales.
Los siguientes datos de muestra:

 x = 15, el cual es 0000 1111 en binario,

 y = 16, el cual es 0001 0000 en binario.

Se utilizarán para ilustrar el significado de operadores bit a bit en Python. Analiza

los ejemplos a continuación:

 & hace un bit a bit and (y), por ejemplo, x & y = 0, el cual es 0000 0000 en
binario,
 | hace un bit a bit or (o), por ejemplo, x | y = 31, el cual es 0001 1111 en
binario,
 ˜ hace un bit a bit not (no), por ejemplo, ˜ x = 240*, el cual es 1111 0000 en
binario,
 ^ hace un bit a bit xor, por ejemplo, x ^ y = 31, el cual es 0001 1111 en
binario,
 >> hace un desplazamiento bit a bit a la derecha, por ejemplo, y >> 1 = 8, el
cual es 0000 1000 en binario,
 << hace un desplazamiento bit a bit a la izquierda, por ejemplo, y << 3 = , el
cual es 1000 0000 en binario.
* -16 (decimal del complemento a 2 con signo) -- lee más acerca de la
operación Complemento a dos.

3.4 Sección 4 – Listas

3.4.1 ¿Por qué necesitamos listas?

Puede suceder que tengas que leer, almacenar, procesar y, finalmente, imprimir
docenas, quizás cientos, tal vez incluso miles de números. ¿Entonces qué?
¿Necesitas crear una variable separada para cada valor? ¿Tendrás que pasar
largas horas escribiendo sentencias como la que se muestra a continuación?

Si no crees que esta sea una tarea complicada, toma un papel y escribe un
programa que:

 lea cinco números.

 los imprima en orden desde el más pequeño hasta el más grande (Este tipo
de procesamiento se denomina ordenamiento).

Debes percatarte que ni siquiera tienes suficiente papel para completar la tarea.

Hasta ahora, has aprendido como declarar variables que pueden almacenar
exactamente un valor dado a la vez. Tales variables a veces se
denominan escalares por analogía con las matemáticas. Todas las variables que
has usado hasta ahora son realmente escalares.

Piensa en lo conveniente que sería declarar una variable que podría almacenar

más de un valor. Por ejemplo, cien, o mil o incluso diez mil. Todavía sería una y
la misma variable, pero muy amplia y espaciosa. ¿Suena atractivo? Quizás, pero
¿cómo manejarías un contenedor así lleno de valores diferentes? ¿Cómo elegirías
solo el que necesitas?

¿Y si solo pudieras numerarlos? Y luego di: dame el valor número 2; asigna el

valor número 15; aumenta el número del valor 10000.

Te mostraremos como declarar tales variables de múltiples valores. Haremos

esto con el ejemplo que acabamos de sugerir. Escribiremos un programa que
ordene una secuencia de números. No seremos particularmente ambiciosos -
asumiremos que hay exactamente cinco números.

Vamos a crear una variable llamada numbers; se le asigna no solo un número,

sino que se llena con una lista que consta de cinco valores (nota: la
lista comienza con un corchete abierto y termina con un corchete cerrado; el
espacio entre los corchetes es llenado con cinco números separados por comas).

numbers = [10, 5, 7, 2, 1]
 

Digamos lo mismo utilizando una terminología adecuada: numbers es una lista

que consta de cinco valores, todos ellos números. También podemos decir
que esta sentencia crea una lista de longitud igual a cinco (ya que contiene cinco
elementos).

Los elementos dentro de una lista pueden tener diferentes tipos. Algunos de

ellos pueden ser enteros, otros son flotantes y otros pueden ser listas.

Python ha adoptado una convención que indica que los elementos de una lista
están siempre numerados desde cero. Esto significa que el elemento
almacenado al principio de la lista tendrá el número cero. Como hay cinco
elementos en nuestra lista, al último de ellos se le asigna el número cuatro. No
olvides esto.

Pronto te acostumbrarás, y se convertirá en algo natural.

Antes de continuar con nuestra discusión, debemos indicar lo siguiente: nuestra

lista es una colección de elementos, pero cada elemento es un escalar.

3.4.2 Indexación de listas

¿Cómo cambias el valor de un elemento elegido en la lista?

Vamos a asignar un nuevo valor de 111 al primer elemento en la lista. Lo

hacemos de esta manera:

numbers = [10, 5, 7, 2, 1]

print("Contenido de la lista:", numbers) # Imprimiendo contenido de la lista original.

numbers[0] = 111

print("Nuevo contenido de la lista: ", numbers) # Contenido actual de la lista.

Y ahora queremos copiar el valor del quinto elemento al segundo elemento -

¿puedes adivinar cómo hacerlo?

1
2
 3
4
5
6
7
8
9
numbers = [10, 5, 7, 2, 1]
print("Contenido de la lista original:", numbers)  # Imprimiendo
contenido de la lista original.
 
numbers[0] = 111
print("\nPrevio contenido de la lista:", numbers)  # Imprimiendo
contenido de la lista anterior.
 
numbers[1] = numbers[4]  # Copiando el valor del quinto elemento
al segundo elemento.
print("Nuevo contenido de la lista:", numbers)  # Imprimiendo el
contenido de la lista actual.
 

El valor dentro de los corchetes que selecciona un elemento de la lista se llama

un índice, mientras que la operación de seleccionar un elemento de la lista se
conoce como indexación.

Vamos a utilizar la función print() para imprimir el contenido de la lista cada vez

que realicemos los cambios. Esto nos ayudará a seguir cada paso con más
cuidado y ver que sucede después de una modificación de la lista en particular.

Nota: todos los índices utilizados hasta ahora son literales. Sus valores se fijan en
el tiempo de ejecución, pero cualquier expresión también puede ser un índice.
Esto abre muchas posibilidades.
Completo 3.4.3 Acceso al contenido de las listas

3.4.3 Acceso al contenido de las listas

Se puede acceder a cada uno de los elementos de la lista por separado. Por
ejemplo, se puede imprimir:

1
2
print(numbers[0]) # Accediendo al primer elemento de la lista.
 

Suponiendo que todas las operaciones anteriores se hayan completado con éxito,
el fragmento enviará 111 a la consola.
numbers = [10, 5, 7, 2, 1]

print("Contenido de la lista original:", numbers) # Imprimiendo el contenido de la lista original.

numbers[0] = 111

print("\nContenido de la lista con cambio:", numbers) # Imprimiendo contenido de la lista con

111.

numbers[1] = numbers[4] # Copiando el valor del quinto elemento al segundo elemento.

print("Contenido de la lista con intercambio:", numbers) # Imprimiendo contenido de la lista con

intercambio.

print("\nLongitud de la lista:", len(numbers)) # Imprimiendo la longitud de la lista.

sole 
Contenido de la lista original: [10, 5, 7, 2, 1]

Contenido de la lista con cambio: [111, 5, 7, 2, 1]

Contenido de la lista con intercambio: [111, 1, 7, 2, 1]

Como puedes ver en el editor, la lista también puede imprimirse como un todo -
como aquí:

1
2
print(numbers) # Imprimiendo la lista completa.
 

Como probablemente hayas notado antes, Python decora la output de una manera
que sugiere que todos los valores presentados forman una lista. La output del
fragmento de ejemplo anterior se ve así:

[111, 1, 7, 2, 1]
Output

La función len()
La longitud de una lista puede variar durante la ejecución. Se pueden agregar
nuevos elementos a la lista, mientras que otros pueden eliminarse de ella. Esto
significa que la lista es una entidad muy dinámica.

Si deseas verificar la longitud actual de la lista, puedes usar una función

llamada len() (su nombre proviene de length - longitud).

La función toma el nombre de la lista como un argumento y devuelve el

número de elementos almacenados actualmente dentro de la lista (en otras
palabras - la longitud de la lista).

Observa la última línea de código en el editor, ejecuta el programa y verifica que

valor imprimirá en la consola. ¿Puedes adivinar?

3.4.4 Eliminando elementos de una

lista
Cualquier elemento de la lista puede ser eliminado en cualquier momento - esto
se hace con una instrucción llamada del (eliminar). Nota: es una instrucción, no
una función.

Tienes que apuntar al elemento que quieres eliminar - desaparecerá de la lista y la

longitud de la lista se reducirá en uno.

Mira el fragmento de abajo. ¿Puedes adivinar qué output producirá? Ejecuta el

programa en el editor y comprueba.

1
2
3
4
del numbers[1]
print(len(numbers))
print(numbers)

No puedes acceder a un elemento que no existe - no puedes obtener su valor

ni asignarle un valor. Ambas instrucciones causarán ahora errores de tiempo de
ejecución:

1
2
 3
print(numbers[4])
numbers[4] = 1

Agrega el fragmento de código anterior después de la última línea de código en el editor,

ejecuta el programa y verifica que sucede.

numbers = [10, 5, 7, 2, 1]

print("Contenido de la lista original:", numbers) # Imprimiendo el contenido de la lista original.

numbers[0] = 111

print("\nContenido de la lista con cambio:", numbers) # Imprimiendo contenido de la lista con

111.

numbers[1] = numbers[4] # Copiando el valor del quinto elemento al segundo elemento.

print("Contenido de la lista con intercambio:", numbers) # Imprimiendo contenido de la lista con

intercambio.

print("\nLongitud de la lista:", len(numbers)) # Imprimiendo la longitud de la lista.

###

del numbers[1] # Eliminando el segundo elemento de la lista.

print("Longitud de la nueva lista:", len(numbers)) # Imprimiendo nueva longitud de la lista.

print("\nNuevo contenido de la lista:", numbers) # Imprimiendo el contenido de la lista actual.

3.4.5 Los índices negativos son

legales
Puede parecer extraño, pero los índices negativos son válidos, y pueden ser muy útiles.
Un elemento con un índice igual a -1 es el último en la lista.

El código del ejemplo mostrará 1. Ejecuta el programa y comprueba.

Del mismo modo, el elemento con un índice igual a -2 es el anterior al último en
la lista.

3.4.6   LAB   Los fundamentos de las

listas

Escenario

Había una vez un sombrero. El sombrero no contenía conejo, sino una lista de
cinco números: 1, 2, 3, 4, y 5.

Tu tarea es:

 escribir una línea de código que solicite al usuario que reemplace el número
central en la lista con un número entero ingresado por el usuario (Paso 1)
 escribir una línea de código que elimine el último elemento de la lista (Paso 2)
 escribir una línea de código que imprima la longitud de la lista existente (Paso 3).

¿Listo para este desafío?

hat_list = [1, 2, 3, 4, 5] # Esta es una lista existente de números ocultos en el sombrero.

Digita un numero para remplazar

# Paso 1: escribe una línea de código que solicite al usuario

# reemplazar el número de en medio con un número entero ingresado por el usuario.

# Paso 2: escribe aquí una línea de código que elimine el último elemento de la lista.

# Paso 3: escribe aquí una línea de código que imprima la longitud de la lista existente.
print(hat_list)

lista = [1,2,3,4,5]

aux = input("Ingrese el numero entero ")

lista[2] = int(aux)

print(lista)

print("eliminación del último elemento de la lista")

lista.pop()

print(lista)

print("La longitud de la lista existente es: ", len(lista))

3.4.7 Funciones vs métodos

Un método es un tipo específico de función - se comporta como una función y
se parece a una función, pero difiere en la forma en que actúa y en su estilo de
invocación.

Una función no pertenece a ningún dato - obtiene datos, puede crear nuevos
datos y (generalmente) produce un resultado.

Un método hace todas estas cosas, pero también puede cambiar el estado de

una entidad seleccionada.

Un método es propiedad de los datos para los que trabaja, mientras que una
función es propiedad de todo el código.

Esto también significa que invocar un método requiere alguna especificación de

los datos a partir de los cuales se invoca el método.

Puede parecer desconcertante aquí, pero lo trataremos en profundidad cuando

profundicemos en la programación orientada a objetos.

En general, una invocación de función típica puede tener este aspecto:

result = function(arg)
 
La función toma un argumento, hace algo, y devuelve un resultado.

Una invocación de un método típico usualmente se ve así:

result = data.method(arg)
 

Nota: el nombre del método está precedido por el nombre de los datos que posee
el método. A continuación, se agrega un punto, seguido del nombre del
método y un par de paréntesis que encierran los argumentos.

El método se comportará como una función, pero puede hacer algo más -
puede cambiar el estado interno de los datos a partir de los cuales se ha
invocado.

Puedes preguntar: ¿por qué estamos hablando de métodos, y no de listas?

Este es un tema esencial en este momento, ya que le mostraremos como agregar

nuevos elementos a una lista existente. Esto se puede hacer con métodos propios
de las listas, no por funciones.

3.4.8 Agregando elementos a una

lista: append() y insert()
Un nuevo elemento puede ser añadido al final de la lista existente:

list.append(value)
 

Dicha operación se realiza mediante un método llamado append(). Toma el valor de su

argumento y lo coloca al final de la lista que posee el método.

La longitud de la lista aumenta en uno.

El método insert() es un poco más inteligente - puede agregar un nuevo elemento en

cualquier lugar de la lista, no solo al final.

list.insert(location, value)
 

Toma dos argumentos:

 el primero muestra la ubicación requerida del elemento a insertar; nota: todos los
elementos existentes que ocupan ubicaciones a la derecha del nuevo elemento
 (incluido el que está en la posición indicada) se desplazan a la derecha, para hacer
espacio para el nuevo elemento;
 el segundo es el elemento a insertar.

Observa el código en el editor. Ve como usamos los métodos append() e insert(). Presta

atención a lo que sucede después de usar insert(): el primer elemento anterior ahora es el
segundo, el segundo el tercero, y así sucesivamente.

numbers = [111, 7, 2, 1]

print(len(numbers))

print(numbers)

###

numbers.append(4)

print(len(numbers))

print(numbers)

###

numbers.insert(0, 222)

print(len(numbers))

print(numbers)

numbers.insert(1, 333)

Puedes iniciar la vida de una lista creándola vacía (esto se hace con un par de

corchetes vacíos) y luego agregar nuevos elementos según sea necesario.
Echa un vistazo al fragmento en el editor. Intenta adivinar su output después de la
ejecución del bucle for. Ejecuta el programa para comprobar si tenías razón.

my_list = [] # Creando una lista vacía.

for i in range(5):

my_list.append(i + 1)

print(my_list)

my_list = []  # Creando una lista vacía.

 
for i in range(5):
    my_list.insert(0, i + 1)
 
print(my_list)

3.4.9 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.

my_list = [10, 1, 8, 3, 5]

total = 0

for i in range(len(my_list)):

total += my_list[i]

print(total)
Supongamos que deseas calcular la suma de todos los valores almacenados
en la lista my_list.

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

valor de 0 - su nombre será total. (Nota: no la vamos a nombrar sum ya que
Python utiliza el mismo nombre para una de sus funciones
integradas: sum(). Utilizar ese nombre sería considerado una mala práctica.)
Luego agrega todos los elementos de la lista usando el bucle for. Echa un vistazo
al fragmento en el editor.

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.

El segundo aspecto del bucle 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 como funciona:

1
2
3
4
5
6
7
8
my_list = [10, 1, 8, 3, 5]
total = 0
 
for i in my_list:
    total += i
 
print(total)
 
¿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 (my_list).
 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í.

3.4.10 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:
 1
 2
 3
 4
 5
 6
 variable_1 = 1
 variable_2 = 2
  
 variable_2 = variable_1
 variable_1 = variable_2
  
 Si haces algo como esto, perderás el valor previamente almacenado en
variable_2. Cambiar el orden de las tareas no ayudará. Necesitas una
tercera variable que sirva como almacenamiento auxiliar.
 Así es como puedes hacerlo:
 1
 2
 3
 4
 5
 6
 7
 variable_1 = 1
 variable_2 = 2
  
 auxiliary = variable_1
 variable_1 = variable_2
  variable_2 = auxiliary
  
 Python ofrece una forma más conveniente de hacer el intercambio - echa
un vistazo:
 1
 2
 3
 4
 5
 variable_1 = 1
 variable_2 = 2
  
 variable_1, variable_2 = variable_2, variable_1
  
 Claro, efectivo y elegante - ¿no?
 Ahora puedes intercambiar fácilmente los elementos de la lista
para revertir su orden:
 1
 2
 3
 4
 5
 6
 7
 my_list = [10, 1, 8, 3, 5]
  
 my_list[0], my_list[4] = my_list[4], my_list[0]
 my_list[1], my_list[3] = my_list[3], my_list[1]
  
 print(my_list)
  
 Ejecuta el fragmento. Su output debería verse así:
 [5, 3, 8, 1, 10]

for i in range(length // 2):
    my_list[i], my_list[length - i - 1] = my_list[length - i - 1],
my_list[i]
 
print(my_list)

Nota:
  hemos asignado la variable length a la longitud de la lista actual (esto hace
que nuestro código sea un poco más claro y más corto)
 hemos preparado el bucle for para que se ejecute su cuerpo length //
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)
 hemos intercambiado el elemento i (desde el principio de la lista) por el que
tiene un índice igual a (length - i - 1) (desde el final de la lista); en nuestro
ejemplo, for i igual a 0 a la (length - 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.

lista = [1,2,3,4,5]
aux = input("Ingrese el numero
entero ")
lista[2] = int(aux)
print(lista)
print("eliminación del último
elemento de la lista")
lista.pop()
print(lista)
print("La longitud de la lista
existente es: ", len(lista))
3.4.11   LAB   Los fundamentos de
las listas: los Beatles

Escenario

Los Beatles fueron uno de los grupos de música más populares de la década de
1960 y la banda más vendida en la historia. Algunas personas los consideran el
acto más influyente de la era del rock. De hecho, se incluyeron en la compilación
de la revista Time de las 100 personas más influyentes del siglo XX.

La banda sufrió muchos cambios de formación, que culminaron en 1962 con la

formación de John Lennon, Paul McCartney, George Harrison y Richard Starkey
(mejor conocido como Ringo Starr).

Escribe un programa que refleje estos cambios y le permita practicar con el

concepto de listas. Tu tarea es:

 paso 1: crea una lista vacía llamada beatles;

 paso 2: emplea el método append() para agregar los siguientes miembros de la
banda a la lista: John Lennon, Paul McCartney y George Harrison;
 paso 3: emplea el buclefor y el append() para pedirle al usuario que agregue los
siguientes miembros de la banda a la lista: Stu Sutcliffe, y Pete Best;
 paso 4: usa la instrucción del para eliminar a Stu Sutcliffe y Pete Best de la lista;
 paso 5: usa el método insert() para agregar a Ringo Starr al principio de la lista.

Por cierto, ¿eres fan de los Beatles? (Los Beatles son una de las bandas favoritas
de Greg. Pero espera...¿Quién es Greg?)

# paso 1

beatles=[]

print("Paso 1:", beatles)

# paso 2

beatles.append("John Lennon")
beatles.append("Paul McCartney")

beatles.append("George Harrison")

print("Paso 2:", beatles)

# paso 3

n1 = input("Ingrese miembro Stu de la banda:")

n2 = input("Ingrese miembro Pete de la banda:")

beatles.append(n1)

beatles.append(n2)

print("Paso 3:", beatles)

# paso 4

beatles.pop()

beatles.pop()

print("Paso 4:", beatles)

# paso 5

beatles.insert(0, "Ringo Starr")

print("Paso 5:", beatles)

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:
3.5 Sección 5 – Ordenando
listas simples: el
ordenamiento de burbuja
3.5.1 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:

8 10 6 2 4

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.

Ahora observa el segundo y el tercer elemento. Están en las posiciones

equivocadas. Tenemos que intercambiarlos:

8 6 10 2 4

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:
 8 6 2 10 4

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

8 6 2 4 10

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:

10

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 burbuja.

Ahora comenzamos con el segundo paso a través de la lista. Miramos el primer y

el segundo elemento - es necesario un intercambio:

6 8 2 4 10

Es hora del segundo y tercer elemento: también tenemos que intercambiarlos:

6 2 8 4 10

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

está en su lugar:
 6 2 4 8 10

Comenzamos el siguiente pase inmediatamente. Observa atentamente el primer y

el segundo elemento - se necesita otro cambio:

2 6 4 8 10

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

2 4 6 8 10

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.
Incompleto 3.5.2 Ordenando una lista

3.5.2 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.

my_list = [8, 10, 6, 2, 4]  # lista a ordenar

 
for i in range(len(my_list) - 1):  # necesitamos (5 - 1)
comparaciones
    if my_list[i] > my_list[i + 1]:  # compara elementos
adyacentes
        my_list[i], my_list[i + 1] = my_list[i + 1], my_list[i]  #
Si terminamos aquí, tenemos que intercambiar elementos.
 
my_list = [8, 10, 6, 2, 4]  # lista a ordenar
swapped = True  # Lo necesitamos verdadero (True) para ingresar al
bucle while.
 
while swapped:
    swapped = False  # no hay intercambios hasta ahora
    for i in range(len(my_list) - 1):
        if my_list[i] > my_list[i + 1]:
            swapped = True  # ¡ocurrió el intercambio!
            my_list[i], my_list[i + 1] = my_list[i + 1],
my_list[i]
 
print(my_list)

3.5.3 El ordenamiento burbuja –

versión interactiva

En el editor, 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 final interactiva.

my_list = []

swapped = True

num = int(input("¿Cuántos elementos deseas ordenar?: "))

for i in range(num):

val = float(input("Ingresa un elemento de la lista: "))

 my_list.append(val)

while swapped:

swapped = False

for i in range(len(my_list) - 1):

if my_list[i] > my_list[i + 1]:

swapped = True

my_list[i], my_list[i + 1] = my_list[i + 1], my_list[i]

print("\nOrdenada:")

print(my_list)

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:

my_list = [8, 10, 6, 2, 4]

my_list.sort()
print(my_list)

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.
 3.5.4 RESUMEN DE SECCIÓN
1. Puedes usar el método sort() para ordenar los elementos de una lista, por
ejemplo:

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

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

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

3.6 Sección 6 – Operaciones

con listas
3.6.1 La vida al interior de las listas
Ahora queremos 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 en el editor.

list_1 = [1]

list_2 = list_1

list_1[0] = 2

print(list_2)

El programa:

 crea una lista de un elemento llamada list_1;

 la asigna a una nueva lista llamada list_2;
 cambia el único elemento de list_1;
 imprime la list_2;

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.

Lee estas dos líneas una vez más - la diferencia es esencial para comprender de que vamos
a hablar a continuación.

La asignación: list_2 = list_1 copia el nombre del arreglo no su contenido. En efecto, los

dos nombres (list_1 y list_2) identifican la misma ubicación en la memoria de la
computadora. Modificar uno de ellos afecta al otro, y viceversa.
¿Cómo te las arreglas con eso?
Completo 3.6.2 Rebanadas poderosas

3.6.2 Rebanadas poderosas

Afortunadamente, la solución está al alcance de tu mano - su nombre es rebanada.

Una rebanada 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:

1
2
3
4
5
list_1 = [1]
list_2 = list_1[:]
list_1[0] = 2
print(list_2)
 

Su output 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 rebanada es la siguiente:

my_list[inicio:fin]

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

Una rebanada de este tipo crea una nueva lista (de destino), tomando elementos de la
lista de origen - los elementos de los índices desde el start hasta el fin 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:

1
2
3
4
my_list = [10, 8, 6, 4, 2]
new_list = my_list[1:3]
print(new_list)
 

La lista new_list contendrá fin - inicio (3 - 1 = 2) elementos ‒ los que tienen índices iguales

a 1 y 2 (pero no 3).

La output del fragmento es: [8, 6]

Ejecuta el código en el editor para ver cómo Python copia la lista completa y un fragmento
de la lista. ¡Siéntete libre de experimentar!

# Copiando la lista completa.

list_1 = [1]

list_2 = list_1[:]

list_1[0] = 2

print(list_2)

# Copiando parte de la lista.

my_list = [10, 8, 6, 4, 2]

new_list = my_list[1:3]

print(new_list)
3.6.3 Rebanadas – índices negativos
Observa el fragmento de código a continuación:

my_list[start:end]
 

Para confirmar:

 start es el índice del primer elemento incluido en la rebanada.

 end es el índice del primer elemento no incluido en la rebanada.

Así es como los índices negativos funcionan en las rebanadas:

1
2
3
4
my_list = [10, 8, 6, 4, 2]
new_list = my_list[1:-1]
print(new_list)
 

El resultado del fragmento es:

[8, 6, 4]
Output

Si start especifica un elemento que se encuentra más allá del descrito

por end (desde el punto de vista inicial de la lista), la rebanada estará vacía:

my_list = [10, 8, 6, 4, 2]
new_list = my_list[-1:1]
print(new_list)
 

La output del fragmento es:

[]
Output

Si omites el start en tu rebanada, se supone que deseas obtener un segmento que

comienza en el elemento con índice 0.
En otras palabras, la rebanada sería de esta forma:

my_list[:end]
 

es un equivalente más compacto de:

my_list[0:end]
 

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

1
2
3
4
my_list = [10, 8, 6, 4, 2]
new_list = my_list[:3]
print(new_list)
 

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

Del mismo modo, si omites el end en tu rebanada, se supone que deseas que el
segmento termine en el elemento con el índice len(my_list).

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

my_list[start:]
 

es un equivalente más compacto de:

my_list[start:len(my_list)]
 

Observa el siguiente fragmento de código:

1
2
3
4
my_list = [10, 8, 6, 4, 2]
new_list = my_list[3:]
print(new_list)
 
Por lo tanto, la output es: [4, 2].

Como hemos dicho anteriormente, el omitir el inicio y fin crea una copia de toda la

lista:

1
2
3
4
my_list = [10, 8, 6, 4, 2]
new_list = my_list[:]
print(new_list)
 

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

Más sobre la instrucción del

La instrucción del descrita anteriormente puede eliminar más de un elemento de
la lista a la vez - también puede eliminar rebanadas:

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

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

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

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

1
2
3
4
my_list = [10, 8, 6, 4, 2]
del my_list[:]
print(my_list)
 
La lista se queda vacía y la output es: [].

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

Echa un vistazo:

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

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.

3.6.4 Los operadores in y not in

Completo 3.6.4 Los operadores in y not in

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:

1
2
3
elem in my_list
elem not in my_list
 

El primero de ellos (in) verifica si un elemento dado (el argumento izquierdo) está
actualmente almacenado en algún lugar dentro de la lista (el argumento derecho) -
el operador devuelve True en este caso.

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

Observa el código en el editor. El fragmento muestra ambos operadores en

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

my_list = [0, 3, 12, 8, 2]

print(5 in my_list)

print(5 not in my_list)

print(12 in my_list)

El primero de ellos (in) verifica si un elemento dado (el argumento izquierdo) está
actualmente almacenado en algún lugar dentro de la lista (el argumento derecho) - el
operador devuelve True en este caso.

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

Observa el código en el editor. El fragmento muestra ambos operadores en acción. ¿Puedes

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

my_list = [0, 3, 12, 8, 2]

print(5 in my_list)

print(5 not in my_list)

print(12 in my_list)

3.6.5 Listas - algunos programas simples

Ahora queremos mostrarte algunos programas simples que utilizan listas.

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

editor

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

largest = my_list[0]
for i in range(1, len(my_list)):

if my_list[i] > largest:

largest = my_list[i]

print(largest)

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
bucle for:

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

largest = my_list[0]
 
for i in my_list:
    if i > largest:
        largest = i
 
print(largest)

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 rebanada:

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

largest = my_list[0]
 
for i in my_list[1:]:
    if i > largest:
        largest = i
 
print(largest)

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

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

to_find = 5
found = False
 
for i in range(len(my_list)):
    found = my_list[i] == to_find
    if found:
        break
 
if found:
    print("Elemento encontrado en el índice", i)
else:
    print("ausente")

Nota:

 el valor buscado se almacena en la variable to_find;

 el estado actual de la búsqueda se almacena en la
variable found (True/False).
 cuando found 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.

Los números que han salido sorteados son: 5, 11, 9, 42, 3, y 49.

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

Este programa te dará la respuesta:

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

bets = [3, 7, 11, 42, 34, 49]
hits = 0
 
for number in bets:
    if number in drawn:
        hits += 1
 
print(hits)

Nota:

 la lista drawn almacena todos los números sorteados;

 La lista bets almacena los números con que se juega;
 la variable hits cuenta tus aciertos.

la output del programa es: 4.

3.6.6   LAB   Operaciones con listas:

conceptos básicos
Escenario

Imagina una lista - no muy larga ni muy complicada, solo una lista simple que
contiene algunos números enteros. Algunos de estos números pueden estar
repetidos, y esta es la clave. No queremos ninguna repetición. Queremos que
sean eliminados.

Tu tarea es escribir un programa que elimine todas las repeticiones de números de

la lista. El objetivo es tener una lista en la que todos los números aparezcan no
más de una vez.

Nota: Asume que la lista original está ya dentro del código - no tienes que
ingresarla desde el teclado. Por supuesto, puedes mejorar el código y agregar una
parte que pueda llevar a cabo una conversación con el usuario y obtener todos los
datos.

Sugerencia: Te recomendamos que crees una nueva lista como área de trabajo
temporal - no necesitas actualizar la lista actual.

No hemos proporcionado datos de prueba, ya que sería demasiado fácil. Puedes

usar nuestro esqueleto en su lugar.

lista = [1, 2, 3, 4, 5, 2, 4, 6, 8, 5]
lista_sin_repetidos = list(set(lista))

print(lista_sin_repetidos)
3.6.7 RESUMEN DE SECCIÓN

1. Si tienes una lista list_1, y la siguiente asignación: list_2 = list_1 esto no hace

una copia de la lista list_1, pero hace que las variables list_1 y list_2 apunten a la
misma lista en la memoria. Por ejemplo:

1
2
3
4
5
6
7
vehicles_one = ['coche', 'bicicleta', 'motor']
print(vehicles_one) # output: ['coche', 'bicicleta', 'motor']
 
vehicles_two = vehicles_one
del vehicles_one[0] # elimina 'coche'
print(vehicles_two) # output: ['bicicleta', 'motor']
 

2. Si deseas copiar una lista o parte de la lista, puedes hacerlo haciendo uso
de rebanadas:

1
2
3
4
5
colors = ['rojo', 'verde', 'naranja']
 
copy_whole_colors = colors[:]  # copia la lista entera
copy_part_colors = colors[0:2]  # copia parte de la lista
 

3. También puede utilizar índices negativos para hacer uso de rebanadas. Por

ejemplo:

1
2
3
4
sample_list = ["A", "B", "C", "D", "E"]
new_list = sample_list[2:-1]
print(new_list)  # output: ['C', 'D']
 

4. Los parámetros start y end son opcionales al partir en rebanadas una

lista: list[start:end], por ejemplo:

1
2
3
4
5
6
7
8
9
my_list = [1, 2, 3, 4, 5]
slice_one = my_list[2: ]
slice_two = my_list[ :2]
slice_three = my_list[-2: ]
 
print(slice_one)  # output: [3, 4, 5]
print(slice_two)  # output: [1, 2]
print(slice_three)  # output: [4, 5]
 

5. Puedes eliminar rebanadas utilizando la instrucción del:

1
2
3
4
5
6
7
my_list = [1, 2, 3, 4, 5]
del my_list[0:2]
print(my_list)  # output: [3, 4, 5]
 
del my_list[:]
print(my_list)  # 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:
 1
2
3
4
5
6
my_list = ["A", "B", 1, 2]
 
print("A" in my_list)  # output: True
print("C" not in my_list)  # output: True
print(2 not in my_list)  # output: False
 

3.7 Sección 7 – Listas en

aplicaciones avanzadas
3.7.1 Listas dentro de listas
Las listas pueden constar de escalares (es decir, números) y elementos de una
estructura mucho más compleja (ya has visto ejemplos como cadenas, booleanos
o incluso otras listas en las lecciones del Resumen de la Sección anterior).
Veamos más de cerca el caso en el que los elementos de una lista son listas.

A menudo encontramos estos arreglos en nuestras vidas. Probablemente el mejor

ejemplo de esto sea un tablero de ajedrez.

Un tablero de ajedrez está compuesto de filas y columnas. Hay ocho filas y ocho
columnas. Cada columna está marcada con las letras de la A a la H. Cada línea
está marcada con un número del uno al ocho.

La ubicación de cada campo se identifica por pares de letras y dígitos. Por lo

tanto, sabemos que la esquina inferior derecha del tablero (la que tiene la torre
blanca) es A1, mientras que la esquina opuesta es H8.

Supongamos que podemos usar los números seleccionados para representar

cualquier pieza de ajedrez. También podemos asumir que cada fila en el tablero
de ajedrez es una lista.

Observa el siguiente código:

1
2
3
 4
5
row = []
 
for i in range(8):
    row.append(WHITE_PAWN)
 

Crea una lista que contiene ocho elementos que representan la segunda fila del
tablero de ajedrez: la que está llena de peones (supon que WHITE_PAWN es
un símbolo predefinido que representa un peón blanco).

Comprensión de lista
El mismo efecto se puede lograr mediante una comprensión de lista, la sintaxis
especial utilizada por Python para completar o llenar listas masivas.

Una comprensión de lista es en realidad una lista, pero se creó sobre la marcha
durante la ejecución del programa, y no se describe de forma estática.

Echa un vistazo al fragmento:

1
2
row = [WHITE_PAWN for i in range(8)]
 

La parte del código colocada dentro de los paréntesis especifica:

 los datos que se utilizarán para completar la lista (WHITE_PAWN)

 la cláusula que especifica cuántas veces se producen los datos dentro de la
lista (for i in range(8))

Permítenos mostrarte otros ejemplos de comprensión de lista:

Ejemplo #1:

1
2
squares = [x ** 2 for x in range(10)]
 

El fragmento de código genera una lista de diez elementos y la rellena con

cuadrados de diez números enteros que comienzan desde cero (0, 1, 4, 9, 16, 25,
36, 49, 64, 81)
Ejemplo #2:

1
2
twos = [2 ** i for i in range(8)]
 

El fragmento crea un arreglo de ocho elementos que contiene las primeras ocho
potencias del numero dos (1, 2, 4, 8, 16, 32, 64, 128)

Ejemplo #3:

1
2
odds = [x for x in squares if x % 2 != 0 ]
 

El fragmento crea una lista con solo los elementos impares de la lista squares.

3.7.2 Arreglos de dos dimensiones

Supongamos también que un símbolo predefinido denominado EMPTY designa
un campo vacío en el tablero de ajedrez.

Entonces, si queremos crear una lista de listas que representan todo el tablero de
ajedrez, se puede hacer de la siguiente manera:

1
2
3
4
5
6
board = []
 
for i in range(8):
    row = [EMPTY for i in range(8)]
    board.append(row)
 

Nota:
  la parte interior del bucle crea una fila que consta de ocho elementos (cada
uno de ellos es igual a EMPTY) y lo agrega a la lista del board;
 la parte exterior se repite ocho veces;
 en total, la lista board consta de 64 elementos (todos iguales a EMPTY).

Este modelo imita perfectamente el tablero de ajedrez real, que en realidad es una
lista de elementos de ocho elementos, todos ellos en filas individuales.
Resumamos nuestras observaciones:

 los elementos de las filas son campos, ocho de ellos por fila;
 los elementos del tablero de ajedrez son filas, ocho de ellos por tablero de
ajedrez.

La variable board ahora es un arreglo bidimensional. También se le llama, por

analogía a los términos algebraicos, una matriz.

Como las listas de comprensión puede ser anidadas, podemos acortar la creación

del tablero de la siguiente manera:

board = [[EMPTY for i in range(8)] for j in range(8)]
 

La parte interna crea una fila, y la parte externa crea una lista de filas.

El acceso al campo seleccionado del tablero requiere dos índices - el primero

selecciona la fila; el segundo - el número del campo dentro de la fila, el cual es un
número de columna.

Echa un vistazo al tablero de ajedrez. Cada campo contiene un par de índices que
se deben dar para acceder al contenido del campo:

3.7.3 Naturaleza multidimensional de

las listas: aplicaciones avanzadas

Profundicemos en la naturaleza multidimensional de las listas. Para encontrar

cualquier elemento de una lista bidimensional, debes usar dos coordenadas:

 Una vertical (número de fila).

 Una horizontal (número de columna).
Imagina que desarrollas una pieza de software para una estación meteorológica
automática. El dispositivo registra la temperatura del aire cada hora y lo hace
durante todo el mes. Esto te da un total de 24 × 31 = 744 valores. Intentemos
diseñar una lista capaz de almacenar todos estos resultados.

Primero, debes decidir qué tipo de datos sería adecuado para esta aplicación. En
este caso, sería mejor un float, ya que este termómetro puede medir la
temperatura con una precisión de 0.1 ℃.

Luego tomarás la decisión arbitraria de que las filas registrarán las lecturas cada
hora exactamente (por lo que la fila tendrá 24 elementos) y cada una de las filas
se asignará a un día del mes (supongamos que cada mes tiene 31 días, por lo que
necesita 31 filas). Aquí está el par apropiado de comprensiones (h es para las
horas, d para el día):

temps = [[0.0 for h in range(24)] for d in range(31)] 

Toda la matriz está llena de ceros ahora. Puede suponer que se actualiza
automáticamente utilizando agentes de hardware especiales. Lo que tienes que
hacer es esperar a que la matriz se llene con las mediciones.

Ahora es el momento de determinar la temperatura promedio mensual del

mediodía. Suma las 31 lecturas registradas al mediodía y divida la suma por 31.
Puedes suponer que la temperatura de medianoche se almacena primero. Aquí
está el código:

temps = [[0.0 for h in range(24)] for d in range(31)]
#
# La matriz se actualiza aquí.
#
 
total = 0.0
 
for day in temps:
    total += day[11]
 
average = total / 31
 
print("Temperatura promedio al mediodía:", average)
 

Nota: La variable day utilizada por el bucle for no es un escalar - cada paso a

través de la matriz temps lo asigna a la siguiente fila de la matriz; Por lo tanto, es
una lista. Se debe indexar con 11 para acceder al valor de temperatura medida al
mediodía.

Ahora encuentra la temperatura más alta durante todo el mes - analiza el código:

temps = [[0.0 for h in range(24)] for d in range(31)]
#
# La matriz se actualiza aquí.
#
 
highest = -100.0
 
for day in temps:
    for temp in day:
        if temp > highest:
            highest = temp
 
print("La temperatura más alta fue:", highest)

Note:

 la variable day itera en todas las filas de la matriz temps;

 la variable temp itera a través de todas las mediciones tomadas en un día.

Ahora cuenta los días en que la temperatura al mediodía fue de al menos 20 ℃:

temps = [[0.0 for h in range(24)] for d in range(31)]
#
# La matriz se actualiza aquí.
#
 
hot_days = 0
 
for day in temps:
    if day[11] > 20.0:
        hot_days += 1
 
print(hot_days, "fueron los días calurosos.")
 

Python no limita la profundidad de la inclusión lista en lista. Aquí puedes ver un

ejemplo de un arreglo tridimensional:

rooms =
[[[False for r in range(20)] for f in range(15)] for t in range(3)
]

Imagina un hotel. Es un hotel enorme que consta de tres edificios, de 15 pisos

cada uno. Hay 20 habitaciones en cada piso. Para esto, necesitas un arreglo que
pueda recopilar y procesar información sobre las habitaciones ocupadas/libres.

Primer paso - El tipo de elementos del arreglo. En este caso, sería un valor
Booleano (True/False).

Paso dos - análisis de la situación. Resume la información disponible: tres

edificios, 15 pisos, 20 habitaciones.

Ahora puedes crear el arreglo:

rooms =
[[[False for r in range(20)] for f in range(15)] for t in range(3)
]

El primer índice (0 a 2) selecciona uno de los edificios; el segundo (0 a 14)

selecciona el piso, el tercero (0 a 19) selecciona el número de habitación. Todas
las habitaciones están inicialmente desocupadas.

Ahora ya puedes reservar una habitación para dos recién casados: en el segundo
edificio, en el décimo piso, habitación 14

rooms[1][9][13] = True

y desocupar el segundo cuarto en el quinto piso ubicado en el primer edificio:

rooms[0][4][1] = False

Verifica si hay disponibilidad en el piso 15 del tercer edificio:

vacancy = 0
 
for room_number in range(20):
    if not rooms[2][14][room_number]:
        vacancy += 1

La variable vacancy contiene 0 si todas las habitaciones están ocupadas, o en

dado caso el número de habitaciones disponibles.

¡Felicitaciones! Has llegado al final del módulo. ¡Sigue con el buen trabajo!

3.7.4 RESUMEN DE SECCIÓN

1. La comprensión de listas te permite crear nuevas listas a partir de las
existentes de una manera concisa y elegante. La sintaxis de una comprensión de
lista es la siguiente:

[expresión para el elemento en la lista si es condicional]

 

El cual es un equivalente del siguiente código:

for element in list:

    if conditional:
        expression
 

Este es un ejemplo de una comprensión de lista - el código siguiente crea una lista
de cinco elementos con los primeros cinco números naturales elevados a la
potencia de 3:

cubed = [num ** 3 for num in range(5)]

print(cubed) # output: [0, 1, 8, 27, 64]

2. Puedes usar listas anidadas en Python para crear matrices (es

decir, listas bidimensionales). Por ejemplo:
 # Una tabla de cuatro columnas y cuatro filas: un arreglo
bidimensional (4x4)
  
 table = [[":(", ":)", ":(", ":)"],
           [":)", ":(", ":)", ":)"],
          [":(", ":)", ":)", ":("],
          [":)", ":)", ":)", ":("]]
  
 print(table)
 print(table[0][0])  # output: ':('
 print(table[0][3])  # output: ':)'

3. Puedes anidar tantas listas en las listas como desee y, por lo tanto, crear listas
n-dimensionales, por ejemplo, arreglos de tres, cuatro o incluso sesenta y cuatro
dimensiones. Por ejemplo:

# Cubo - un arreglo tridimensional (3x3x3)

 
cube = [[[':(', 'x', 'x'],
         [':)', 'x', 'x'],
         [':(', 'x', 'x']],
 
        [[':)', 'x', 'x'],
         [':(', 'x', 'x'],
         [':)', 'x', 'x']],
 
        [[':(', 'x', 'x'],
         [':)', 'x', 'x'],
         [':)', 'x', 'x']]]
 
print(cube)
print(cube[0][0][0])  # output: ':('
print(cube[2][2][0])  # output: ':)'

3.8 Módulo 3 Finalización -

Prueba del Módulo
¡Bien hecho! Has llegado al final del Módulo 3 y has completado una meta
importante en tu educación de programación en Python. He aquí un breve
resumen de los objetivos que has cubierto y con lo que te has familiarizado en el
Módulo 3:
  Valores booleanos para comparar diferentes valores y controlar las rutas de
ejecución usando las instrucciones if e if-else;
 la utilización de bucles (while and for) y cómo controlar su comportamiento
utilizando las instrucciones break y continue;
 la diferencia entre operaciones lógicas y bit a bit;
 el concepto de listas y procesamiento de listas, incluyendo la iteración
proporcionada por el bucle for loop, y las rebanadas;
 la idea de los arreglos multidimensionales.

Ahora estás listo para tomar la Prueba del Módulo, que te ayudará a evaluar lo
que has aprendido hasta ahora.

La siguiente prueba se basa en lo que acabas de aprender. Hay veinte preguntas

en total y debes obtener al menos un 70% para aprobar.

¡Buena suerte!