2.1. Introducción y objetivos

En este tema, exploraremos los fundamentos de los tipos de datos, las variables y los operadores en Python. Comprender estos conceptos es esencial para escribir código, ya que son la base para la manipulación y almacenamiento de información en cualquier programa.

Los tipos de datos determinan cómo se interpretan y manejan los valores en Python. Aprenderemos sobre los tipos primitivos como números enteros y cadenas de texto, y también sobre las colecciones de datos básicas que permiten agrupar múltiples elementos.

Las variables son identificadores que nos permiten almacenar y acceder a datos en la memoria. Entenderemos cómo declarar variables, las convenciones de nomenclatura y las mejores prácticas para su uso en Python.

Los operadores son símbolos que nos permiten realizar operaciones sobre uno o más operandos, como sumas, restas o comparaciones lógicas. Veremos cómo utilizar operadores aritméticos, lógicos y de asignación para construir expresiones que controlen el flujo y la lógica de nuestros programas.

Al finalizar este tema, seremos capaces de:

• Identificar y utilizar correctamente los tipos de datos primitivos y las estructuras de datos disponibles en Python.
• Declarar y manipular variables para almacenar y procesar información.
• Realizar conversión de tipos cuando sea necesario para garantizar la compatibilidad entre distintos datos.
• Aplicar operadores en la construcción de expresiones y en la evaluación de condiciones para controlar el flujo del programa.

Este conocimiento nos proporcionará una base sólida para poder resolver problemas más complejos en el futuro.

2.2. Introducción al tipado de datos en Python

Python es un lenguaje de programación de tipado dinámico y tipado fuerte, lo que influye directamente en cómo se manejan y manipulan los datos en los programas. Hay que comprender el sistema de tipos en Python para evitar errores en tiempo de ejecución.

En un lenguaje de tipado dinámico, las variables no tienen un tipo fijo asignado. Esto significa que una misma variable puede referenciar objetos de diferentes tipos durante la ejecución del programa. Por ejemplo:

dato = 10        # 'dato' es un entero
dato = "Diez"    # ahora 'dato' es una cadena de texto

En este ejemplo, la variable dato cambia de referenciar un entero a una cadena sin necesidad de declarar explícitamente el tipo. Esta flexibilidad facilita la escritura de código, pero exige atención para mantener la coherencia de tipos.

A pesar de esta flexibilidad, Python es de tipado fuerte, lo que implica que no permite operaciones entre tipos incompatibles sin una conversión explícita. Intentar sumar un entero y una cadena generará un error:

resultado = 5 + "5"  # Provoca TypeError

Para realizar la operación correctamente, es necesario convertir la cadena a entero o el entero a cadena:

resultado = 5 + int("5")      # resultado es 10
# o
resultado = str(5) + "5"      # resultado es "55"

Todas las entidades en Python son objetos, incluidos los tipos primitivos como enteros y cadenas. Cada objeto tiene asociado un tipo que determina qué operaciones se pueden realizar sobre él. Podemos verificar el tipo de un objeto utilizando la función type():

valor = 3.14
print(type(valor))  # Muestra: <class 'float'>

La mutabilidad es otro concepto clave en el tipado de Python. Los objetos mutables pueden cambiar su estado o contenido después de ser creados, mientras que los inmutables no pueden. Tipos como listas y diccionarios son mutables, mientras que las tuplas y las cadenas de texto son inmutables. Por ejemplo:

lista = [1, 2, 3]
lista.append(4)        # 'lista' ahora es [1, 2, 3, 4]

texto = "Hola"
texto += " Mundo"      # Se crea un nuevo objeto; 'texto' es "Hola Mundo"

Es importante comprender la mutabilidad para evitar efectos secundarios no deseados, sobre todo al trabajar con funciones y estructuras de datos complejas.

Python permite el uso de anotaciones de tipo mediante type hints, introducidas en la versión 3.5. Aunque no son obligatorias ni afectan la ejecución del código, mejoran la legibilidad y facilitan el trabajo con herramientas de análisis estático. Por ejemplo:

def sumar(a: int, b: int) -> int:
    return a + b

En este caso, se indica que la función sumar espera dos argumentos de tipo entero y devuelve un entero. Esto ayuda a otros desarrolladores a entender el propósito de la función y a prevenir errores relacionados con tipos.

Es importante destacar que, aunque Python es dinámicamente tipado, el uso correcto de los tipos de datos es crucial para la escritura de programas. La gestión adecuada de los tipos mejora la legibilidad del código y reduce la probabilidad de errores durante la ejecución.

Los tipos de datos primitivos son los bloques básicos y fundamentales que constituyen la base de cualquier programa en Python. Estos tipos permiten representar información básica como números, texto y valores lógicos, y son necesarios para la manipulación y almacenamiento de datos.

1. Números enteros

El tipo int se utiliza para representar números enteros de cualquier tamaño. En Python, los enteros no tienen un límite máximo predefinido, ya que pueden crecer en tamaño hasta donde la memoria del sistema lo permita. Por ejemplo:

numero_entero = 42

Es posible realizar operaciones aritméticas con enteros, como suma, resta, multiplicación y división. Los enteros también soportan operaciones de módulo y exponenciación:

resultado = 7 ** 3   # Exponenciación: Resultado es 343
modulo = 10 % 3      # Módulo: Resultado es 1

2. Números de punto flotante

El tipo float representa números de punto flotante, es decir, números reales con partes decimales. Son útiles para cálculos que requieren precisión decimal:

temperatura = 36.6

Es importante tener en cuenta que los cálculos con flotantes pueden sufrir errores de representación debido a la forma en que se almacenan internamente:

suma = 0.1 + 0.2     # Resultado es 0.30000000000000004

Esto se debe a la representación binaria de los números decimales en el hardware.

3. Números complejos

Python también soporta números complejos mediante el tipo complex, que representan números con una parte real y una imaginaria. Se definen utilizando la letra j para indicar la parte imaginaria:

numero_complejo = 2 + 3j

Los números complejos permiten realizar operaciones matemáticas avanzadas:

c1 = 1 + 2j
c2 = 3 + 4j
suma = c1 + c2        # Resultado: (4+6j)
producto = c1 * c2    # Resultado: (-5+10j)

4. Booleanos

El tipo bool representa los valores lógicos True y False. Es una subclase de int, donde True es equivalente a 1 y False equivale a 0. Los valores booleanos se utilizan en evaluaciones y operaciones lógicas:

es_mayor = 5 > 3      # Resultado: True

5. Cadenas de caracteres

Las cadenas de caracteres, representadas por el tipo str, permiten almacenar y manipular texto. Las cadenas en Python son inmutables, lo que significa que no pueden modificarse una vez creadas:

saludo = "Hola, mundo"

Es posible concatenar cadenas utilizando el operador + y repetirlas con *:

frase = saludo + "!"
eco = "echo" * 3      # Resultado: "echoechoecho"

Para acceder a caracteres individuales dentro de una cadena, se utilizan índices, comenzando desde cero:

primera_letra = saludo[0]   # Resultado: 'H'

6. Ausencia de valor

El valor especial None se utiliza para representar la ausencia de valor o un valor nulo. Es de tipo NoneType y es útil para inicializar variables que aún no tienen un valor asignado:

resultado = None

7. Literales numéricos

En Python, también existen literales numéricos en diferentes bases numéricas. Se pueden representar números en binario, octal y hexadecimal utilizando prefijos específicos:

• Binario: prefijo 0b o 0B
• Octal: prefijo 0o o 0O
• Hexadecimal: prefijo 0x o 0X

Ejemplos de números en distintas bases:

binario = 0b1010     # Equivalente decimal: 10
octal = 0o12         # Equivalente decimal: 10
hexadecimal = 0xA    # Equivalente decimal: 10

Con un manejo adecuado de los tipos de datos primitivos, es posible realizar operaciones básicas y manipular información de manera eficiente en Python. Estos tipos son la base sobre la cual se construyen estructuras de datos más complejas y se desarrollan programas robustos.

2.4. Colecciones de datos básicas

Las colecciones de datos en Python permiten almacenar y manipular agrupaciones de elementos, ofreciendo estructuras flexibles para manejar conjuntos de información. Las colecciones básicas incluyen listas, tuplas, conjuntos y diccionarios, cada una con características y usos específicos.

1. Listas

Las listas son colecciones ordenadas y mutables que permiten almacenar elementos de diferentes tipos. Se definen utilizando corchetes [] y los elementos se separan por comas:

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

Es posible acceder a los elementos de una lista mediante índices, empezando desde cero, y modificar sus valores:

print(numeros[0])  # Salida: 1
numeros[0] = 10
print(numeros)     # Salida: [10, 2, 3, 4, 5]

Las listas admiten diversas operaciones como añadir, eliminar o reordenar elementos, lo que las hace muy versátiles para colecciones que cambian con frecuencia.

2. Tuplas

Las tuplas son colecciones ordenadas pero inmutables, lo que significa que una vez creadas, no es posible modificar sus elementos. Se definen utilizando paréntesis () o simplemente separando los elementos por comas:

coordenadas = (10.0, 20.0)
# o
coordenadas = 10.0, 20.0

Aunque no se pueden alterar, las tuplas permiten acceder a sus elementos mediante índices:

print(coordenadas[1])  # Salida: 20.0

Las tuplas son útiles para representar datos que no deben cambiar, proporcionando integridad y seguridad en la manipulación de la información.

3. Conjuntos

Los conjuntos son colecciones desordenadas de elementos únicos y mutables. Se definen utilizando llaves {} o la función set():

letras = {'a', 'b', 'c'}
# o
letras = set(['a', 'b', 'c'])

Los conjuntos son ideales para operaciones de pertenencia, eliminación de duplicados y operaciones matemáticas como unión, intersección y diferencia:

letras.add('d')
print(letras)  # Salida: {'a', 'b', 'c', 'd'}

Al ser desordenados, no es posible acceder a los elementos por índice, pero permiten comprobar rápidamente si un elemento pertenece al conjunto:

print('a' in letras)  # Salida: True

4. Diccionarios

Los diccionarios son colecciones desordenadas que almacenan pares clave-valor, permitiendo asociar un valor a una clave única. Se definen utilizando llaves {} y dos puntos : para separar las claves de los valores:

persona = {'nombre': 'Carlos', 'edad': 30}

Se accede a los valores mediante sus claves correspondientes:

print(persona['nombre'])  # Salida: Carlos

Los diccionarios son mutables, permitiendo agregar, modificar o eliminar pares clave-valor:

persona['edad'] = 31
persona['profesión'] = 'Ingeniero'
print(persona)  # Salida: {'nombre': 'Carlos', 'edad': 31, 'profesión': 'Ingeniero'}

Las claves deben ser de un tipo inmutable y único, como cadenas, números o tuplas, asegurando la integridad de las asociaciones.

Estas colecciones de datos básicas son necesarias en Python para organizar y manipular información. Elegir la estructura adecuada según las necesidades del programa mejora la legibilidad y optimiza el rendimiento del código. Más adelante, se profundizará en las operaciones y métodos específicos que ofrecen estas colecciones para potenciar su utilidad en diversas aplicaciones.

2.5. Declaración y uso de variables

En Python, una variable es un identificador que hace referencia a un objeto almacenado en memoria. Las variables permiten almacenar datos y manipularlos a lo largo de la ejecución del programa. A diferencia de otros lenguajes, en Python no es necesario declarar el tipo de una variable previamente; basta con asignarle un valor para crearla.

La asignación de una variable se realiza utilizando el operador = (signo igual), donde el nombre de la variable se coloca a la izquierda y el valor que se quiere asignar a la derecha:

edad = 25
nombre = "María"
pi = 3.1416

En este ejemplo, hemos creado tres variables: edad que referencia al número entero 25, nombre que hace referencia a la cadena de texto "María", y pi que apunta al número de punto flotante 3.1416.

Los nombres de variables deben seguir ciertas reglas y convenciones:

• Los nombres pueden contener letras (mayúsculas y minúsculas), dígitos y el carácter guion bajo (_).
• No pueden comenzar con un dígito.
• Son sensibles a mayúsculas y minúsculas (case-sensitive), por lo que variable, Variable y VARIABLE son nombres distintos.
• No pueden coincidir con las palabras reservadas del lenguaje, como if, for, while, def, etc.

Es recomendable seguir las convenciones de estilo establecidas en la guía PEP 8 para mejorar la legibilidad del código:

• Utilizar nombres en minúsculas, separando palabras con guiones bajos:

contador_total = 100
nombre_usuario = "Ana"

• Emplear nombres descriptivos que reflejen el propósito de la variable.

Para obtener la lista de palabras reservadas, se puede utilizar el módulo keyword:

import keyword
print(keyword.kwlist)

Python permite asignar valores a múltiples variables en una sola línea:

a, b, c = 1, 2, 3

En este caso, a toma el valor 1, b el valor 2 y c el valor 3. Esto es muy útil para inicializar varias variables de manera rápida.

También es posible asignar el mismo valor a varias variables simultáneamente:

x = y = z = 0

Aquí, x, y y z se inicializan con el valor 0.

Una característica interesante de Python es la capacidad de intercambiar los valores de dos variables sin necesidad de una variable auxiliar:

x, y = y, x

Este código intercambia los valores de x y y de forma rápida.

Como Python es un lenguaje de tipado dinámico, una variable puede referenciar objetos de diferentes tipos a lo largo de su vida. Simplemente asignando un nuevo valor, la variable apunta al nuevo objeto:

dato = 10
print(type(dato))  # Salida: <class 'int'>
dato = "Diez"
print(type(dato))  # Salida: <class 'str'>

En este ejemplo, dato primero es una referencia a un entero y luego a una cadena de texto.

Es importante entender que las variables en Python son referencias a objetos en memoria. Si dos variables apuntan al mismo objeto mutable, los cambios realizados a través de una variable se reflejarán en la otra:

lista_a = [1, 2, 3]
lista_b = lista_a
lista_b.append(4)
print(lista_a)  # Salida: [1, 2, 3, 4]

Ambas variables lista_a y lista_b apuntan al mismo objeto mutable. Para crear una copia independiente, se debe usar un método de copia:

lista_c = lista_a.copy()
lista_c.append(5)
print(lista_a)  # Salida: [1, 2, 3, 4]
print(lista_c)  # Salida: [1, 2, 3, 4, 5]

Ahora, lista_c es una copia y las modificaciones en ella no afectan a lista_a.

Python soporta operadores que combinan la asignación con una operación aritmética o lógica. Estos operadores de asignación compuesta facilitan las actualizaciones de variables:

n = 10
n += 5  # Equivale a n = n + 5
n -= 2  # Equivale a n = n - 2
n *= 3  # Equivale a n = n * 3
n /= 4  # Equivale a n = n / 4

Estos operadores funcionan con diferentes tipos de datos, siempre que las operaciones sean compatibles.

En los programas Python, existen variables especiales que comienzan y terminan con doble guion bajo (__). Una de ellas es __name__, que indica el contexto de ejecución del módulo:

if __name__ == "__main__":
    # El código dentro de este bloque solo se ejecuta si el módulo
    # es ejecutado como programa principal y no cuando es importado
    print("El módulo se está ejecutando directamente")

Estas variables son útiles para controlar el comportamiento del código según cómo se ejecute.

Por último, es recomendable seguir buenas prácticas en el uso de variables:

• Inicializar siempre las variables antes de usarlas para evitar excepciones.
• Utilizar nombres significativos que reflejen el propósito de la variable.
• Mantener la consistencia en el estilo de nombrado a lo largo del código.
• Evitar el uso de variables globales en módulos, a menos que sea necesario.

2.6. Conversión y tipos de datos (casting)

En Python, la conversión de tipos o casting es el proceso de cambiar explícitamente el tipo de un objeto a otro tipo compatible. Dado que Python es un lenguaje de tipado dinámico pero fuertemente tipado, es común que durante la programación sea necesario transformar datos a diferentes tipos para realizar ciertas operaciones.

Python proporciona una serie de funciones incorporadas que permiten convertir valores entre distintos tipos de datos básicos. Estas conversiones son útiles sobre todo cuando se trabaja con entrada de datos, operaciones aritméticas y manipulación de cadenas.

Para convertir un valor a entero, se utiliza la función int(). Esta función puede recibir un número de punto flotante o una cadena que represente un entero:

numero_entero = int(3.7)         # Resultado: 3
cadena_a_entero = int("42")      # Resultado: 42

Es importante destacar que al convertir un float a int, la función int() trunca la parte decimal sin redondear.

Para convertir a float, se emplea la función float():

numero_float = float(10)          # Resultado: 10.0
cadena_a_float = float("3.1416")  # Resultado: 3.1416

Si intentamos convertir una cadena que no representa un número válido, se producirá un ValueError:

valor = int("texto")  # Provoca ValueError

La conversión a cadena de texto se realiza con la función str(), que convierte cualquier objeto a su representación en forma de cadena:

numero = 100
cadena_numero = str(numero)       # Resultado: "100"

Esto es útil para concatenar números y cadenas:

nombre = "Alice"
edad = 30
mensaje = nombre + " tiene " + str(edad) + " años"
# Resultado: "Alice tiene 30 años"

Para convertir valores a booleanos, se utiliza la función bool(). En Python, los valores 0, 0.0, False, None y cadenas vacías "" se consideran False, mientras que cualquier otro valor es True:

bool(0)          # Resultado: False
bool(15)         # Resultado: True
bool("")         # Resultado: False
bool("Python")   # Resultado: True

La conversión entre colecciones de datos también es posible. Para convertir una colección a lista, se usa list():

tupla = (1, 2, 3)
lista = list(tupla)          # Resultado: [1, 2, 3]

De forma similar, para convertir a tupla se utiliza tuple():

lista = [4, 5, 6]
tupla = tuple(lista)         # Resultado: (4, 5, 6)

La función set() permite convertir una colección a conjunto, eliminando elementos duplicados:

lista = [1, 2, 2, 3, 3, 3]
conjunto = set(lista)        # Resultado: {1, 2, 3}

Es posible convertir una lista de pares clave-valor en un diccionario utilizando la función dict():

pares = [("uno", 1), ("dos", 2)]
diccionario = dict(pares)    # Resultado: {"uno": 1, "dos": 2}

La conversión explícita es necesaria cuando Python no realiza una conversión implícita. Por ejemplo, al intentar sumar un número y una cadena, se producirá un error a menos que se convierta uno de los operandos:

resultado = 10 + "20"        # Provoca TypeError

Para solucionar esto, podemos convertir la cadena a entero:

resultado = 10 + int("20")   # Resultado: 30

O convertir el número a cadena:

resultado = str(10) + "20"   # Resultado: "1020"

La función eval() permite evaluar una cadena como una expresión de Python, convirtiéndola al tipo correspondiente:

expresion = "1 + 2 * 3"
resultado = eval(expresion)  # Resultado: 7

Sin embargo, se debe tener cuidado al usar eval() ya que puede haber posibles riesgos de seguridad si se evalúan entradas no controladas.

En algunas situaciones, es útil convertir tipos complejos a simples. Por ejemplo, convertir un número complejo a su parte real o imaginaria:

complejo = 3 + 4j
real = complejo.real         # Resultado: 3.0
imaginaria = complejo.imag   # Resultado: 4.0

Además, para convertir un entero a su representación en carácter Unicode, se utilizan las funciones chr() y ord():

letra = chr(65)              # Resultado: 'A'
codigo = ord('A')            # Resultado: 65

Se necesita la conversión de tipos para asegurarse de que las operaciones y funciones reciban los datos en el formato correcto. Realizar casting ayuda a prevenir errores y escribir código más seguro y legible.

Es importante manejar adecuadamente las excepciones que puedan surgir durante el casting. Utilizar estructuras de control como try-except permite gestionar los posibles errores de conversión:

entrada = "abc"
try:
    numero = int(entrada)
except ValueError:
    print("Error: la entrada no es un número válido")

El casting no cambia el tipo del objeto original, sino que crea un nuevo objeto del tipo deseado. Por tanto, es fundamental asignar el resultado de la conversión a una variable o utilizarlo directamente en la operación:

numero = 5.7
print(int(numero))           # Muestra: 5
print(numero)                # Muestra: 5.7

En este ejemplo, numero sigue siendo un float, ya que la conversión con int() no modifica el objeto original.

Por último, es posible definir funciones de conversión personalizadas para manejar casos específicos. Esto es útil cuando se requiere una lógica adicional durante la conversión:

def a_float_seguro(valor):
    try:
        return float(valor)
    except ValueError:
        return 0.0

resultado = a_float_seguro("3.14")   # Resultado: 3.14
resultado = a_float_seguro("abc")    # Resultado: 0.0

Hay que hacer un uso adecuado de la conversión de tipos para asegurar que los datos se manipulan correctamente y que las operaciones se realizan sin inconvenientes. Mediante el casting, se logra mayor control sobre los tipos de datos en la programación.

2.7. Operadores

Los operadores en Python son símbolos especiales que permiten realizar operaciones sobre uno o más operandos. Estos operadores se utilizan para manipular datos y variables, y son fundamentales en la construcción de expresiones y en la ejecución de instrucciones lógicas y aritméticas dentro de los programas.

Los operadores en Python se clasifican en diferentes categorías según su funcionalidad:

1. Operadores aritméticos

Los operadores aritméticos realizan operaciones matemáticas básicas entre valores numéricos:

• + Suma: Añade dos valores.

resultado = 10 + 5   # resultado es 15

• - Resta: Resta el segundo operando del primero.

resta = 10 - 5   # resta es 5

• * Multiplicación: Multiplica dos valores.

producto = 4 * 3   # producto es 12

• / División: Divide el primer operando entre el segundo y devuelve un float.

division = 10 / 3   # division es 3.3333333333333335

• // División entera: Divide y devuelve la parte entera del cociente.

division_entera = 10 // 3   # division_entera es 3

• % Módulo: Devuelve el resto de la división entre dos operandos.

modulo = 10 % 3   # modulo es 1

• ** Exponenciación: Eleva el primer operando a la potencia del segundo.

potencia = 2 ** 3   # potencia es 8

2. Operadores de asignación

Los operadores de asignación se utilizan para asignar valores a las variables:

• = Asignación simple: Asigna el valor del operando derecho a la variable del lado izquierdo.

x = 5

• Operadores de asignación compuesta: Combinan una operación y una asignación en una sola expresión.

  • += Suma y asigna:

x += 3   # Equivale a x = x + 3

• -= Resta y asigna:

x -= 2   # Equivale a x = x - 2

• *= Multiplica y asigna:

x *= 4   # Equivale a x = x * 4

• /= Divide y asigna:

x /= 2   # Equivale a x = x / 2

• //= División entera y asigna:

x //= 3   # Equivale a x = x // 3

• %= Módulo y asigna:

x %= 5   # Equivale a x = x % 5

• **= Exponenciación y asigna:

x **= 2   # Equivale a x = x ** 2

3. Operadores de comparación

Los operadores de comparación se utilizan para comparar dos valores y devuelven un resultado booleano (True o False):

• == Igual a: Devuelve True si ambos operandos son iguales.

es_igual = (x == y)

• != Diferente de: Devuelve True si los operandos no son iguales.

es_diferente = (x != y)

• > Mayor que: Devuelve True si el operando izquierdo es mayor que el derecho.

mayor_que = (x > y)

• < Menor que: Devuelve True si el operando izquierdo es menor que el derecho.

menor_que = (x < y)

• >= Mayor o igual que: Devuelve True si el operando izquierdo es mayor o igual al derecho.

mayor_igual = (x >= y)

• <= Menor o igual que: Devuelve True si el operando izquierdo es menor o igual al derecho.

menor_igual = (x <= y)

Estos operadores son muy importantes para las estructuras de control y la toma de decisiones en los programas.

4. Operadores lógicos

Los operadores lógicos permiten combinar expresiones booleanas:

• and Conjunción lógica: Devuelve True si ambas expresiones son verdaderas.

resultado = (x > 0) and (x < 10)

• or Disyunción lógica: Devuelve True si al menos una de las expresiones es verdadera.

resultado = (x < 0) or (x > 10)

• not Negación lógica: Invierte el valor de verdad de la expresión.

resultado = not (x == y)

Los operadores lógicos son fundamentales para construir condiciones complejas en las estructuras de control.

5. Operadores de identidad

Los operadores de identidad se utilizan para determinar si dos variables referencian el mismo objeto en memoria:

• is Es: Devuelve True si ambos operandos son el mismo objeto.

a = [1, 2, 3]
b = a
es_mismo_objeto = (a is b)   # es_mismo_objeto es True

• is not No es: Devuelve True si los operandos no son el mismo objeto.

c = [1, 2, 3]
es_distinto_objeto = (a is not c)   # es_distinto_objeto es True

Aunque dos variables puedan ser iguales en contenido (a == c podría ser True), los operadores de identidad verifican si son el mismo objeto.

6. Operadores de pertenencia

Los operadores de pertenencia se emplean para comprobar si un elemento está presente en una secuencia o colección:

• in En: Devuelve True si el elemento se encuentra en la secuencia.

lista = [1, 2, 3]
esta_presente = 2 in lista   # esta_presente es True

• not in No en: Devuelve True si el elemento no está en la secuencia.

no_esta_presente = 4 not in lista   # no_esta_presente es True

Estos operadores son muy útiles para operaciones de búsqueda y validación en estructuras de datos.

7. Operadores a nivel de bits

Los operadores a nivel de bits realizan operaciones sobre los bits individuales de los números enteros:

• & AND bit a bit: Realiza una conjunción lógica entre los bits de dos números.

resultado = 5 & 3   # 0101 & 0011 = 0001 (resultado es 1)

• | OR bit a bit: Realiza una disyunción lógica entre los bits de dos números.

resultado = 5 | 3   # 0101 | 0011 = 0111 (resultado es 7)

• ^ XOR bit a bit: Realiza una disyunción exclusiva entre los bits.

resultado = 5 ^ 3   # 0101 ^ 0011 = 0110 (resultado es 6)

• ~ NOT bit a bit: Invierte los bits de un número.

resultado = ~5   # Siendo 5 en binario 0101, ~5 es -6 (complemento a dos)

• << Desplazamiento a la izquierda: Desplaza los bits hacia la izquierda.

resultado = 5 << 1   # 0101 << 1 = 1010 (resultado es 10)

• >> Desplazamiento a la derecha: Desplaza los bits hacia la derecha.

resultado = 5 >> 1   # 0101 >> 1 = 0010 (resultado es 2)

Los operadores a nivel de bits son utilizados en programación de bajo nivel y en operaciones de optimización.

8. Operadores ternarios

Python permite la utilización de una forma abreviada para las expresiones condicionales, conocido como operador ternario:

mensaje = "Mayor de edad" if edad >= 18 else "Menor de edad"

En este caso, mensaje tomará el valor según la condición evaluada, lo que permite simplificar las asignaciones condicionales.

9. Precedencia y asociatividad de operadores

La precedencia de operadores determina el orden en que las operaciones son evaluadas en una expresión. Por ejemplo, en la expresión x = 5 + 3 * 2, primero se evalúa la multiplicación y luego la suma, resultando en x = 11.

El orden de precedencia de mayor a menor es:

1. ** (Exponenciación)
2. ~, +, - (Complemento, positivo y negativo unario)
3. *, /, //, % (Multiplicación, división, división entera, módulo)
4. +, - (Suma y resta binaria)
5. >>, << (Desplazamientos)
6. & (AND bit a bit)
7. ^ (XOR bit a bit)
8. | (OR bit a bit)
9. in, not in, is, is not, ==, !=, >, <, >=, <= (Comparaciones)
10. not (Negación lógica)
11. and (Conjunción lógica)
12. or (Disyunción lógica)

La asociatividad determina cómo se agrupan los operadores de la misma precedencia. La mayoría de los operadores en Python son asociativos por la izquierda, excepto la exponenciación **, que es asociativa por la derecha.

Para controlar el orden de evaluación, se pueden utilizar paréntesis:

resultado = (5 + 3) * 2   # resultado es 16

En este caso, la suma se evalúa antes que la multiplicación gracias a los paréntesis.

10. Operadores especiales

• := Operador de asignación en expresión (también conocido como "operador walrus"): Permite asignar y retornar un valor en una sola expresión.

if (n := len(lista)) > 5:
    print(f"La lista tiene {n} elementos")

Este operador es muy útil para mejorar la eficiencia del código al evitar llamadas redundantes.

Buenas prácticas en el uso de operadores

• Utilizar paréntesis para mejorar la legibilidad y asegurarse del orden de evaluación deseado.
• Evitar operaciones innecesarias o redundantes que puedan afectar el rendimiento.
• Ser consciente de la diferencia entre comparación (==) e identidad (is), especialmente al comparar cadenas y tipos inmutables.
• Asegurarse de que los tipos de datos de los operandos sean compatibles para evitar excepciones.

Manejar correctamente los operadores y comprender cómo y cuándo utilizar cada operador permite escribir código más claro y eficiente, facilitando el mantenimiento en proyectos grandes.

2.8. Introducción a expresiones y evaluación de condiciones

En Python, una expresión es una combinación de valores, variables y operadores que Python evalúa y resuelve para producir un resultado. Las expresiones son fundamentales en la programación, ya que permiten realizar cálculos, asignar valores y controlar el flujo de ejecución del programa mediante la evaluación de condiciones.

Las condiciones son expresiones que se evalúan en un contexto booleano, es decir, su resultado es interpretado como verdadero o falso. Estas condiciones son esenciales para tomar decisiones en el código, permitiendo que el programa ejecute ciertas acciones solo cuando se cumplen determinados criterios.

Por ejemplo, una expresión aritmética como 3 + 4 * 2 es evaluada por Python utilizando las reglas de precedencia de operadores, resultando en el valor 11. Sin embargo, una expresión condicional como x > 10 se evalúa como True si el valor de x es mayor que 10, o False en caso contrario.

En Python, cualquier objeto puede ser evaluado en un contexto booleano. Los valores que se consideran falsos (también denominados falsy) incluyen:

• None
• False
• Cero numérico de cualquier tipo: 0, 0.0, 0j
• Secuencias o colecciones vacías: '', (), [], {}, set(), frozenset()
• Objetos que implementan el método especial __bool__() o __len__() y devuelven False o 0 respectivamente

Todos los demás valores se consideran verdaderos (o truthy). Esto permite utilizar expresiones como condiciones de manera intuitiva:

if lista:  # Verifica si 'lista' no está vacía
    print("La lista tiene elementos")

En este ejemplo, si lista contiene elementos, la condición se evalúa como True, y se ejecuta el bloque de código correspondiente.

La evaluación de condiciones es clave para controlar el flujo del programa. Python utiliza un proceso llamado evaluación de cortocircuito en expresiones lógicas con los operadores and y or. En una expresión con and, Python evalúa los operandos de izquierda a derecha y detiene la evaluación en cuanto encuentra un valor que se evalúa como False, ya que el resultado total será False. De manera similar, con or, la evaluación se detiene al encontrar un valor que se evalúa como True.

Por ejemplo:

a = 0
b = 5
if a != 0 and b / a > 2:
    print("La condición es verdadera")

En este caso, la expresión a != 0 se evalúa como False (porque a es 0), por lo que Python no evalúa b / a > 2, evitando un ZeroDivisionError. Esta característica es útil para escribir condiciones seguras y eficientes.

Las expresiones pueden combinarse utilizando operadores lógicos y de comparación para formar condiciones más complejas:

edad = 20
ingresos = 30000
if edad >= 18 and ingresos >= 25000:
    print("Es apto para el crédito")

Aquí, tanto edad >= 18 como ingresos >= 25000 deben ser True para que la condición total sea True.

Es importante comprender que las asignaciones con el operador = no son expresiones en Python y, por lo tanto, no pueden utilizarse dentro de condiciones directamente. Sin embargo, a partir de Python 3.8, se introdujo el operador de asignación en expresión :=, conocido como el operador walrus, que permite asignar y evaluar una expresión en una sola línea:

if (n := len(lista)) > 5:
    print(f"La lista tiene más de cinco elementos: {n}")

En este ejemplo, se asigna el valor de len(lista) a n y se utiliza en la condición y posteriormente en el bloque de código.

Las expresiones condicionales o operadores ternarios permiten asignar un valor basado en una condición de manera concisa:

estado = "Mayor de edad" if edad >= 18 else "Menor de edad"

Este código asigna "Mayor de edad" a estado si edad >= 18 es True, o "Menor de edad" en caso contrario.

Al utilizar expresiones y condiciones, es fundamental seguir buenas prácticas para mejorar la legibilidad y mantenibilidad del código:

• Paréntesis: Aunque Python respeta la precedencia de operadores, usar paréntesis puede aclarar expresiones complejas.

resultado = (a + b) * (c - d)

• Variables intermedias: Descomponer expresiones complejas en variables intermedias con nombres descriptivos facilita la comprensión.

es_adulto = edad >= 18
tiene_ingresos = ingresos >= 25000
if es_adulto and tiene_ingresos:
    print("Es apto para el crédito")

• Comentarios: Añadir comentarios cuando las expresiones no sean obvias.

Las expresiones lambda permiten definir funciones anónimas en una sola línea, que pueden utilizarse como expresiones:

cuadrado = lambda x: x ** 2
print(cuadrado(5))  # Muestra: 25

Aunque las expresiones lambda se usan principalmente en contextos funcionales, entender que son expresiones que pueden evaluarse y utilizarse como condiciones amplía las posibilidades en Python.

2.9. Referencias bibliográficas

Para profundizar en los tipos de datos, variables y operadores en Python, se recomiendan las siguientes fuentes:

• Python Software Foundation. (2024). Documentación oficial de Python 3.13. Recuperado de https://docs.python.org/3.13/

• Van Rossum, G., & Drake Jr, F. L. (2024). Tutorial de Python, versión 3.13. Python Software Foundation.

• Lutz, M. (2025). Aprende Python (6ª ed.). O'Reilly Media.

• Ramalho, L. (2025). Python fluido (3ª ed.). O'Reilly Media.

• McKinney, W. (2025). Python para análisis de datos (3ª ed.). O'Reilly Media.

• Python Software Foundation. (2024). PEP 8 – Guía de estilo para el código Python. Recuperado de https://www.python.org/dev/peps/pep-0008/

• Beazley, D. M. (2025). Referencia esencial de Python (5ª ed.). Addison-Wesley Professional.