Python a través de ejemplos: Expresiones

Python te permite crear diferentes tipos de expresiones que podrás emplear para obtener valores requeridos en tu código. En este tutorial, aprenderás lo básico sobre cómo funcionan y cómo crear expresiones en Python.

Aritméticas

Las expresiones aritméticas son aquellas expresiones basadas en operadores aritméticos que relacionan valores numéricos y funciones que retornan números:

>>> 12 - 6
6
>>> 150 * 2
300
>>> 42 + pow(10, 2)
142
>>> abs(-15) / 3
5.0
>>> 8**2 + 200 / 2
164.0

En estos ejemplos, construyes expresiones usando operadores aritméticos para combinar valores numéricos y funciones que dan como resultado un número.

Las expresiones aritméticas también pueden emplear variables y constantes en lugar de literales numéricos:

>>> radius = 10
>>> PI = 3.142
>>> circle_area = PI * pow(radius, 2)
>>> circle_area
314.2

En este ejemplo, utilizamos una variable y una constante para crear una expresión que retorna el área de un círculo a partir del radio. Como las expresiones siempre retornan un valor, puedes emplear una variable para mantener una referencia al resultado.

Comparación

Por su parte, las expresiones de comparación son aquellas que nos permiten comparar objetos entre sí. Estas expresiones son útiles para decidir el flujo de ejecución de tus programas en función del cumplimiento de determinadas condiciones.

Por ejemplo, las expresiones siguientes comparan valores empleando operadores de comparación:

>>> a = 10
>>> b = 5

>>> a == b
False
>>> a != b
True
>>> a > b
True
>>> a < b
False
>>> a >= b
True
>>> a <= b
False

Todas las expresiones de comparación retornan un valor lógico, ya sea True o False.

Lógicas o booleanas

Se pueden formar expresiones lógicas o booleanas empleando los operadores lógicos and, or, y not:

>>> a = 10
>>> b = 5

>>> a > b and b > 0
True
>>> a > b or b > 0
True
>>> not a > b
False

En estos ejemplos las expresiones retornan valores booleanos. Es decir, True o False. Sin embargo, no todas las expresiones lógicas retornan valores booleanos.

Si los operandos involucrados son objetos o expresiones con un valor no booleano, entonces los operadores and y or retornan uno de los operandos dependiendo de sus valores de verdad:

>>> 5 and "Hola"
'Hola'
>>> 10 and 42
42
>>> 0 and 3.14
0

>>> 5 or "Hola"
5
>>> 10 or 42
10
>>> 0 or 3.14
3.14

La siguiente tabla resume el comportamiento de los operadores and y or con operandos cuyos valores no son booleanos:

Estos resultados se obtienen con una evaluación cortocircuitada (short-circuit evaluation). Por ejemplo, si x es falso entonces x and y retorna x, pero no evalúa a y.

Para poder funcionar de esta forma estos operadores siguen una serie de reglas que Python usa internamente para determinar el valor de verdad de cualquier objeto. Estas reglas son las siguientes:

Por defecto, un objeto se considera verdadero a menos que su clase defina un método .__bool__() que devuelva False o un método .__len__() que devuelva cero cuando se llama con el objeto. Aquí están los objetos integrados considerados falsos:

• Constantes definidas como falsas: None y False.
• Cero en cualquiera de los diferentes tipos numéricos: 0, 0.0, 0j, Decimal(0), Fraction(0, 1).
• Cualquier colección o secuencia vacía: '', (), [], {}, set(), range(0). (Fuente)

Concatenación y repetición

Las expresiones de concatenación se forman con el operador de adición (+). En este caso, los operandos deben ser cadenas de caracteres, listas, o tuplas:

>>> "Hola," + " Mundo" + "!"
'Hola, Mundo!'

>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]

>>> ("Juan", 25) + ("Programador", "España")
('Juan', 25, 'Programador', 'España')

En el primer ejemplo, concatenas varias cadenas para formar una cadena final. De modo similar, haces con listas y con tuplas. Sin embargo, debes notar que los operandos deben ser del mismo tipo de datos. Considera el ejemplo siguiente:

>>> ("Juan", 25) + ["Programador", "España"]
Traceback (most recent call last):
    ...
TypeError: can only concatenate tuple (not "list") to tuple

Si tratas de concatenar una tupla con una lista, entonces recibirás una excepción TypeError.

En lo que respecta a las expresiones de repetición, debes emplear el operador de repetición (*). Uno de los operandos será un número entero que representa el número de veces que deseas repetir el segundo operando. Este último puede ser una cadena, una lista, o una tupla:

>>> "Hola!" * 3
'Hola!Hola!Hola!'

>>> [1, 2, 3] * 2
[1, 2, 3, 1, 2, 3]

>>> 4 * ("uno", "dos")
('uno', 'dos', 'uno', 'dos', 'uno', 'dos', 'uno', 'dos')

El operador de repetición te permite repetir un objeto un determinado número de veces. Debes notar que el orden de los operandos no altera el resultado.

Precedencia de operadores

Cuando trabajas con expresiones que combinan diferentes tipos de operadores, debes considerar que los operadores tienen un orden de precedencia que define cuál operación se evalúa primero. A continuación un breve resumen de este orden.

Paréntesis (). Los paréntesis tienen la mayor precedencia y se evalúan primero:

>>> (2 + 3) * 4
20

En esta expresión, se evalúa (2 + 3) primero y se obtiene 5. Luego, se desarrolla la multiplicación y resulta en 20.

Exponenciación **. El operador de potencia tiene la segunda mayor precedencia:

>>> 2 * 3**2
18

Se evalúa primero la exponenciación (3**2) y se obtiene 9. Luego, se realiza la multiplicación y se obtiene 18.

Operadores unarios +x, -x, ~x. Los operadores unarios como el negativo - y el positivo + se aplican antes que la mayoría de los operadores. Sin embargo, su precedencia es menor que la del operador de exponenciación:

>>> -3**2
-9

>>> (-3)**2
9

La primera expresión se evalúa como -(3**2) = -9 en lugar de como (-3)**2 = 9 que sería lo esperado en matemáticas.

Multiplicación, División, Módulo y División entera *, /, %, //. Todos estos operadores tienen la misma precedencia y se evalúan de izquierda a derecha según aparecen en las expresiones:

>>> 10 + 5 * 2
20

Se evalúa primero la multiplicación y luego la suma 10 + (5 * 2).

Suma y Resta +, -. Tienen precedencia menor que la multiplicación y se evalúan después de ella:

>>> 10 - 2 + 3
11

Se evalúa de izquierda a derecha: primero 10 - 2 y luego 8 + 3.

Operadores de desplazamiento de bits <<, >>. Los operadores de desplazamiento tienen menor precedencia que los aritméticos:

>>> 1 + 2 << 2
12

Se evalúa como (1 + 2) << 2.

Operadores de comparación <, <=, >, >=. Los operadores de comparación se evalúan después de los aritméticos y de los de desplazamiento:

>>> 3 * 2 < 10
True

Se evalúa como (3 * 2) < 10.

Operadores de igualdad ==, !=. Tienen menor precedencia que los operadores de comparación:

>>> 3 + 2 == 5
True

Se evalúa primero 3 + 2 y luego 5 == 5.

Operadores de bits &, ^, |. Se evalúan en el siguiente orden: & (AND bit a bit), ^ (XOR bit a bit), | (OR bit a bit):

>>> 3 & 2 | 1
1

Se evalúa como (3 & 2) | 1.

Operadores lógicos not, and, or. El operador not tiene mayor precedencia que and, que a su vez tiene mayor precedencia que or:

>>> not True or False and True
False

Se evalúa como (not True) or (False and True).

Operadores de pertenencia e identidad in, not in, is, is not. Estos operadores tienen precedencia baja y se evalúan antes que los operadores lógicos:

>>> "m" in "mango" and None is not None
False

Se evalúa como ("m" in "mango") and (None is not None).

Operadores de asignación =, +=, -=, *=, /=, //=, **=, y %=. Los operadores de asignación tienen la menor precedencia, lo cual permite que los cálculos se realicen antes de asignar el valor final:

>>> x = 3 + 2 * 5
>>> x
13

Primero se evalúa 3 + (2 * 5) y luego se asigna el resultado a la variable x.

Conclusiones

Has aprendido sobre las expresiones en Python y cómo formarlas usando diferentes tipos de operadores, como los aritméticos, de comparación, lógicos, de concatenación y repetición. También has conocido la importancia de la precedencia de operadores en la evaluación de expresiones complejas.

Entender cómo formar expresiones en Python es fundamental, pues es la base de para una manipulación y transformación efectiva de datos.

Ahora que dominas estos conceptos, puedes continuar explorando el uso de expresiones y operadores para maximizar la eficiencia y legibilidad de tu código Python.