Comprender los Operadores en Python

Introducción

En este laboratorio, obtendrá una comprensión exhaustiva de varios operadores en Python, un concepto fundamental para escribir código efectivo. Exploraremos y practicaremos el uso de operadores aritméticos, de comparación, de asignación, lógicos, a nivel de bits (bitwise), de pertenencia (membership) e de identidad (identity).

A través de ejercicios prácticos utilizando el editor integrado de VS Code y la terminal, aprenderá a realizar cálculos, hacer comparaciones, asignar valores, combinar condiciones, manipular bits, verificar la pertenencia y comparar identidades de objetos. Al finalizar este laboratorio, dominará el uso de estos operadores para construir programas en Python más complejos y funcionales.

Explorar Operadores Aritméticos y de Comparación

En este paso, exploraremos los operadores aritméticos y de comparación fundamentales en Python. Estos operadores son esenciales para realizar cálculos y tomar decisiones en sus programas. El entorno de laboratorio ya ha creado un archivo llamado operators.py para usted en el directorio ~/project.

Primero, localice el archivo operators.py en el explorador de archivos del lado izquierdo del editor de VS Code y ábralo. Escribiremos todo nuestro código en este único archivo.

Comencemos con los operadores aritméticos. Agregue el siguiente código Python al archivo operators.py:

## Arithmetic Operators
a = 21
b = 5
print(f'{a} + {b} = {a + b}')
print(f'{a} - {b} = {a - b}')
print(f'{a} * {b} = {a * b}')
print(f'{a} / {b} = {a / b}') ## Standard division
print(f'{a} // {b} = {a // b}')  ## Floor division, rounds down to the nearest whole number
print(f'{a} % {b} = {a % b}')  ## Modulo, returns the remainder
print(f'{a} ** {b} = {a ** b}')  ## Exponentiation, a to the power of b

Después de agregar el código, guarde el archivo presionando Ctrl + S.

Para ejecutar el script, abra la terminal integrada en VS Code seleccionando Terminal > New Terminal (Terminal > Nueva Terminal) en el menú superior. Luego, ejecute el siguiente comando:

python ~/project/operators.py

Debería ver la siguiente salida en la terminal:

21 + 5 = 26
21 - 5 = 16
21 * 5 = 105
21 / 5 = 4.2
21 // 5 = 4
21 % 5 = 1
21 ** 5 = 4084101

A continuación, exploraremos los operadores de comparación. Estos operadores comparan dos valores y devuelven un valor booleano (True o False).

Agregue el siguiente código al final de su archivo operators.py:

## Comparison Operators
print("\n--- Comparison Operators ---")
a = 6
b = 5
print(f'{a} == {b} is {a == b}')  ## Equal to
print(f'{a} != {b} is {a != b}')  ## Not equal to
print(f'{a} > {b} is {a > b}')    ## Greater than
print(f'{a} < {b} is {a < b}')    ## Less than
print(f'{a} >= {b} is {a >= b}')  ## Greater than or equal to
print(f'{a} <= {b} is {a <= b}')  ## Less than or equal to

Guarde el archivo nuevamente y ejecútelo desde la terminal:

python ~/project/operators.py

La salida ahora incluirá los resultados de las operaciones de comparación:

21 + 5 = 26
21 - 5 = 16
21 * 5 = 105
21 / 5 = 4.2
21 // 5 = 4
21 % 5 = 1
21 ** 5 = 4084101

--- Comparison Operators ---
6 == 5 is False
6 != 5 is True
6 > 5 is True
6 < 5 is False
6 >= 5 is True
6 <= 5 is False

Ahora ha utilizado con éxito los operadores aritméticos y de comparación en un script de Python.

Practicar Operadores de Asignación y Lógicos

En este paso, practicaremos el uso de operadores de asignación y operadores lógicos. Los operadores de asignación se utilizan para asignar o actualizar el valor de una variable, mientras que los operadores lógicos se utilizan para combinar sentencias condicionales.

Continúe trabajando con el archivo operators.py en el editor de VS Code.

Primero, agreguemos ejemplos de operadores de asignación. Estos proporcionan una forma abreviada de realizar una operación y asignar el resultado de nuevo a la misma variable.

Agregue el siguiente código al final de su archivo operators.py:

## Assignment Operators
print("\n--- Assignment Operators ---")
a = 10
b = 3
print(f'Initial a: {a}')

c = a
c += b  ## Equivalent to c = c + b
print(f'a += b: {c}')

c = a
c -= b  ## Equivalent to c = c - b
print(f'a -= b: {c}')

c = a
c *= b  ## Equivalent to c = c * b
print(f'a *= b: {c}')

c = a
c /= b  ## Equivalent to c = c / b
print(f'a /= b: {c}')

## Walrus operator (Python 3.8+)
## It assigns a value to a variable as part of a larger expression.
print("\n--- Walrus Operator ---")
text = 'hello python'
if (n := len(text)) > 10:
    print(f'The string is long enough ({n} characters)')

Guarde el archivo y ejecútelo desde la terminal:

python ~/project/operators.py

Debería ver la salida de los operadores de asignación:

... (output from previous step) ...

--- Assignment Operators ---
Initial a: 10
a += b: 13
a -= b: 7
a *= b: 30
a /= b: 3.3333333333333335

--- Walrus Operator ---
The string is long enough (12 characters)

Ahora, agreguemos ejemplos de operadores lógicos (and, or, not). Estos operadores funcionan con valores booleanos, pero también pueden funcionar con otros tipos. En Python, valores como 0, None y colecciones vacías ('', [], {}) se consideran False. Todos los demás valores se consideran True.

Agregue el siguiente código al final de su archivo operators.py:

## Logical Operators
print("\n--- Logical Operators ---")
x = True
y = False

print(f'{x} and {y} is {x and y}')
print(f'{x} or {y} is {x or y}')
print(f'not {x} is {not x}')

## Evaluation with non-boolean values
a = 10  ## True
b = 0   ## False
print(f'{a} and {b} returns {a and b}') ## Returns the first Falsey value or the last Truthy value
print(f'{a} or {b} returns {a or b}')   ## Returns the first Truthy value or the last Falsey value

Guarde el archivo y ejecútelo de nuevo:

python ~/project/operators.py

La salida ahora incluirá los resultados de las operaciones lógicas:

... (output from previous examples) ...

--- Logical Operators ---
True and False is False
True or False is True
not True is False
10 and 0 returns 0
10 or 0 returns 10

Ahora ha practicado el uso de operadores de asignación y lógicos en Python.

Aprender Operadores a Nivel de Bits (Bitwise)

En este paso, aprenderemos sobre los operadores a nivel de bits (bitwise operators). Estos operadores realizan operaciones directamente sobre la representación binaria (base 2) de los enteros. Esto es útil para la manipulación de datos de bajo nivel.

Continúe editando el archivo operators.py.

Primero, veamos la representación binaria de algunos números usando la función bin(). El prefijo 0b indica que los dígitos siguientes son binarios.

Agregue este código al final de operators.py:

## Bitwise Operators
print("\n--- Bitwise Operators ---")
a = 5  ## Binary: 0b101
b = 9  ## Binary: 0b1001
print(f'Binary of {a} is {bin(a)}')
print(f'Binary of {b} is {bin(b)}')

## For clarity, let's align them with 4 bits:
## a = 0101
## b = 1001

## Bitwise AND (&): Sets each bit to 1 if both bits are 1.
## 0101 & 1001 = 0001 (Decimal 1)
print(f'{a} & {b} = {a & b}')

## Bitwise OR (|): Sets each bit to 1 if one of the two bits is 1.
## 0101 | 1001 = 1101 (Decimal 13)
print(f'{a} | {b} = {a | b}')

## Bitwise XOR (^): Sets each bit to 1 if only one of the two bits is 1.
## 0101 ^ 1001 = 1100 (Decimal 12)
print(f'{a} ^ {b} = {a ^ b}')

## Bitwise NOT (~): Inverts all the bits.
## ~a is equivalent to -(a+1)
print(f'~{a} = {~a}')

## Left Shift (<<): Shifts bits to the left, filling with zeros.
## Equivalent to multiplying by 2**n.
## 5 << 2 means 0101 becomes 10100 (Decimal 20)
print(f'{a} << 2 = {a << 2}')

## Right Shift (>>): Shifts bits to the right, discarding bits from the right.
## Equivalent to floor division by 2**n.
## 9 >> 2 means 1001 becomes 10 (Decimal 2)
print(f'{b} >> 2 = {b >> 2}')

Guarde el archivo y ejecute el script desde la terminal:

python ~/project/operators.py

Verá la salida que demuestra cada operación a nivel de bits:

... (output from previous steps) ...

--- Bitwise Operators ---
Binary of 5 is 0b101
Binary of 9 is 0b1001
5 & 9 = 1
5 | 9 = 13
5 ^ 9 = 12
~5 = -6
5 << 2 = 20
9 >> 2 = 2

Ahora ha aprendido a usar operadores a nivel de bits para manipular enteros a nivel de bits.

Usar Operadores de Pertenencia e Identidad

En este paso final, cubriremos los operadores de pertenencia (in, not in) y los operadores de identidad (is, is not). Los operadores de pertenencia comprueban si un valor está presente en una secuencia, mientras que los operadores de identidad comprueban si dos variables hacen referencia exactamente al mismo objeto en memoria.

Continúe trabajando con el archivo operators.py.

Primero, agreguemos ejemplos de operadores de pertenencia. Se utilizan comúnmente con secuencias como listas, tuplas y cadenas (strings).

Agregue el siguiente código al final de su archivo operators.py:

## Membership Operators
print("\n--- Membership Operators ---")
my_list = [1, 3, 5, 7]
print(f'3 in {my_list} is {3 in my_list}')
print(f'4 not in {my_list} is {4 not in my_list}')

greeting = "hello world"
print(f'"world" in "{greeting}" is {"world" in greeting}')

Guarde el archivo y ejecútelo:

python ~/project/operators.py

La salida para los operadores de pertenencia será:

... (output from previous steps) ...

--- Membership Operators ---
3 in [1, 3, 5, 7] is True
4 not in [1, 3, 5, 7] is True
"world" in "hello world" is True

Ahora, exploremos los operadores de identidad. Es importante entender la diferencia entre is (identidad) y == (igualdad). == comprueba si los valores de dos objetos son iguales, mientras que is comprueba si son el mismo objeto (es decir, tienen la misma dirección de memoria).

Agregue el siguiente código a su archivo operators.py:

## Identity Operators
print("\n--- Identity Operators ---")

## For small integers, Python often reuses the same object.
x = 256
y = 256
print(f'x is y (for 256): {x is y}') ## This is often True

## For larger integers, Python may create separate objects.
a = 257
b = 257
print(f'a is b (for 257): {a is b}') ## This is often False

## For mutable objects like lists, they are different objects even if their content is the same.
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(f'list1 == list2: {list1 == list2}') ## Checks for equal content (True)
print(f'list1 is list2: {list1 is list2}') ## Checks for same object (False)
print(f'list1 is not list2: {list1 is not list2}') ## Checks for different objects (True)

Guarde el archivo y ejecútelo por última vez:

python ~/project/operators.py

La salida demuestra la diferencia entre igualdad e identidad:

... (output from previous examples) ...

--- Identity Operators ---
x is y (for 256): True
a is b (for 257): True
list1 == list2: True
list1 is list2: False
list1 is not list2: True

Ha utilizado con éxito los operadores de pertenencia e identidad, completando su exploración de los principales tipos de operadores de Python.

Resumen

En este laboratorio, ha adquirido experiencia práctica con los diversos tipos de operadores en Python. Comenzó explorando los operadores aritméticos y de comparación fundamentales para realizar cálculos y evaluar condiciones. Luego practicó el uso de operadores de asignación para actualizaciones eficientes de variables y operadores lógicos para combinar la lógica condicional.

Además, profundizó en los operadores a nivel de bits (bitwise operators) para comprender la manipulación de datos de bajo nivel y concluyó con los operadores de pertenencia (membership) e identidad (identity) para verificar la presencia de elementos y la identidad del objeto. Al escribir y ejecutar código para cada tipo de operador en el editor de VS Code, ha construido una base sólida para utilizar estas herramientas esenciales en su futura programación en Python.